लक्ष्य:

स्ट्रिंग की एक सरणी को देखते हुए, प्रत्येक स्ट्रिंग के संक्षिप्त संस्करण बनाएं।

विशिष्टता:

इस चुनौती के लिए, एक संक्षिप्त नाम स्ट्रिंग का पहला एन अक्षर है। स्ट्रिंग के लिए abc: a, ab, और abcसभी वैध संक्षिप्त रूपों हैं, जबकि bc, और acनहीं कर रहे हैं।

तार की एक सरणी को देखते हुए, हम संक्षिप्त रूप का सबसे छोटा सेट ढूंढना चाहते हैं, जैसे कि इनपुट और कोई संक्षिप्त नाम, आप यह निर्धारित कर सकते हैं कि इनपुट का कौन सा आइटम जिसका संक्षिप्त नाम था।

उदाहरण:

इनपुट: ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]

हम पहले वाले से शुरू होने वाले तारों के माध्यम से अपना काम करते हैं।

सोमवार केवल ए के साथ आइटम स्ट्रिंग है M, इसलिए सबसे कम संभव संक्षिप्त नाम है M।
मंगलवार से शुरू होता है T, लेकिन गुरुवार होता है। इसका मतलब है कि हम स्ट्रिंग की कोशिश करते हैं TU। चूंकि कोई अन्य तार उस से शुरू नहीं होता है, हम उपयोग करते हैं TU।
बुधवार है W, गुरुवार है Th, और शुक्रवार है F।

और ज्यादा उदाहरण:

Input: "one,two,three,four,five,six,seven"
Output: "o,tw,th,fo,fi,si,se"

Input: "red,orange,yellow,green,blue,purple"
Output: "r,o,y,g,b,p"

Input: "a,ab,abc"
Output: Not valid! No abbreviation for `a` that doesn't apply to the other items.

आप किसी भी उचित तरीके से इनपुट और आउटपुट बनाते हैं।
आप मान सकते हैं कि इनपुट हमेशा स्ट्रिंग का एक मान्य सरणी होगा।
आप मान सकते हैं कि अंतिम परीक्षण मामले के विपरीत, हमेशा एक समाधान होगा।
स्ट्रिंग्स में केवल मुद्रण योग्य ASCII (या आपके एन्कोडिंग में मुद्रण योग्य वर्ण) शामिल होंगे
यह कोड गोल्फ है, इसलिए सबसे कम बाइट्स जीतते हैं!

code-golf string

— जूलियन लचनीट
स्रोत

रेटिना , 29 बाइट्स

!ms`^(.+?)(?!.+^\1)(?<!^\1.+)

इनपुट और आउटपुट स्ट्रिंग्स की अलग-अलग सूचियों को फीडफीड-अलग किया जाता है।

इसे ऑनलाइन आज़माएं! (सुविधा के लिए अल्पविराम-जुदाई के साथ टेस्ट सूट।)

व्याख्या

यह बस एक ही regex के साथ सभी उपसर्गों से मेल खाता है और उन्हें प्रिंट करता है ( !)। mऔर मैच लाइन शुरुआत और मैच लाइनफीड sबनाने के लिए सामान्य रेगेक्स संशोधक हैं ।^.

^(.+?)      # Match the shortest possible prefix of a line and capture
            # it in group 1.
(?!.+^\1)   # Make sure that this prefix does not show up in a line after
            # the current one.
(?<!^\1.+)  # Make sure that this prefix does not show up in a line before
            # the current one.

— मार्टिन एंडर
स्रोत

10

पायथन 2 , 87 86 बाइट्स

lambda a:[b[:min(i for i in range(len(b))if sum(s[:i]==b[:i]for s in a)<2)]for b in a]

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

lambda a:[[b[:i]for i in range(len(b))if sum(s[:i]==b[:i]for s in a)<2][0]for b in a]85 बाइट्स के लिए

— कर्टिस बेकटेल

जगह len(b)के साथ 4**82 और बाइट्स की बचत होती है, यह सोचते हैं कि तार नहीं रह गया होगा 65536 से अधिक वर्ण

— कर्टिस बेकटेल

8

जावास्क्रिप्ट (ईएस 6), 81 78 74 70 बाइट्स

स्ट्रिंग के एक सरणी के रूप में इनपुट लेता है।

a=>a.map(s=>[...s].reduce((y,c)=>a.some(x=>x!=s&!x.indexOf(y))?y+c:y))

प्रारूपित और टिप्पणी की गई

a =>                          // given an array of strings 'a'
  a.map(s =>                  // for each string 's' in 'a':
    [...s].reduce((y, c) =>   //   starting with 'y' = first character of 's',
                              //   for each subsequent character 'c' of 's':
      a.some(x =>             //     if we find a string 'x' in 'a' such that:
        x != s &              //       - 'x' is different from 's'
        !x.indexOf(y)         //       - and 'y' appears at the beginning of 'x'
      ) ?                     //     then:
        y + c                 //       append 'c' to 'y'
      :                       //     else:
        y                     //       keep 'y' unchanged
    )                         //   end of reduce(): returns the correct prefix
  )                           // end of map()

परीक्षण के मामलों

कोड स्निपेट दिखाएं

let f =

a=>a.map(s=>[...s].reduce((y,c)=>a.some(x=>x!=s&!x.indexOf(y))?y+c:y))

console.log(JSON.stringify(f(["Monday","Tuesday","Wednesday","Thursday","Friday"])))
console.log(JSON.stringify(f(["one","two","three","four","five","six","seven"])))
console.log(JSON.stringify(f(["red","orange","yellow","green","blue","purple"])))

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

70 भी, लेकिन बिल्कुल अन्य: codegolf.stackexchange.com/a/113270/32091

— Qwertiy

के लिए +1 reduce।

— नील

6

जेली , 14 बाइट्स

;\w@þ=1Si1⁸ḣð€

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

;\w@þ=1Si1⁸ḣð€  Monadic link. Argument: A (string array)

            ð   Collect all links to the left into a chain (arity unknown) and
                begin a dyadic chain.
             €  Map the previous chain over A. The current chain is dyadic and the
                mapped one inherits its arity. Thus, the right will be A for all
                invocations, while the left argument will iterate over A.
                For each string s in A, the following happens.
;\                Cumulative reduce by concatenation; yield all prefixes of s.
  w@þ             Window index swapped table; for each string t in A and each
                  prefix p of s, find the index of the substring t in p.
                  The first index is 1; 0 means not found.
     =1           Compare the indices with 1, returning 1 iff t begins with p.
       S          Sum the Booleans across columns, counting the number of strings
                  in A that begin with a given prefix.
        i1        Find the first index of 1, the shortest prefix that is unique
                  across all strings in A.
          ⁸       Head; truncate s to the computed length.

— डेनिस
स्रोत

6

हास्केल , 48 बाइट्स

[_]#x=""
a#(c:y)=c:[z|d:z<-a,c==d]#y
f=map=<<(#)

इसे ऑनलाइन आज़माएं!

fमुख्य कार्य है, Stringएस की सूची लेना और वापस लौटना String। इसकी परिभाषा के लिए एक राक्षसी शॉर्टकट है f a=map (a#) a।
a#xस्ट्रिंग xऔर सूची को देखता है और aसबसे छोटा उपसर्ग खोजने की कोशिश करता है xजो अद्वितीय है a। यदि aएक भी तत्व है, तो बस खाली स्ट्रिंग का उपयोग करें। यदि aपहले से ही एक तत्व नहीं है, तो पहले वर्ण को xकाटें, फ़िल्टर करें और aउसी वर्ण से शुरू करने वाले तत्वों को काटें , फिर पुन: प्रयास करें।

— अर्जन जोहान्सन
स्रोत

4

मैथेमेटिका, 64 बाइट्स

#&@@@StringCases[#,Shortest@x__/;Tr@Boole@StringStartsQ[#,x]<2]&

— मार्टिन एंडर
स्रोत

3

जेली , 14 12 बाइट्स

ḣ€JṙLḶ$ḟ/€Ḣ€

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

ḣ€JṙLḶ$ḟ/€Ḣ€  Main link. Argument: A (string array)

  J           Yield the 1-based indices of A, i.e., [1, ..., len(A)].
ḣ€            Head each; for each string s in A, take the first 1, ..., and len(A) 
              characters. This builds the 2D array of prefixes of all strings in A.
    LḶ$       Length-unlength; yield [0, ..., len(A)-1].
   ṙ          Rotate the 2D array 0, ..., and len(A)-1 units to the left.
       ḟ/€    Reduce filterfalse each; for each rotation, remove all prefixes from
              the first set that also occur in later sets.
          Ḣ€  Head each; for each rotation, keep only the shortest unique prefix.

— डेनिस
स्रोत

जरा सोच कर देखिए, आपके यहां 2 जवाब क्यों हैं? मैं उन दोनों को पसंद करता हूं, लेकिन मैं सोच रहा हूं कि आपके पास यहां दो जेली उत्तर क्यों हैं। :)

— हाइपरन्यूट्रीनो

यदि मेरे पास दो समान रूप से प्रतिस्पर्धी दृष्टिकोण हैं लेकिन पर्याप्त रूप से अलग-अलग दृष्टिकोण हैं, तो मैं आमतौर पर उन्हें अलग-अलग उत्तरों में पोस्ट करता हूं।

— डेनिस

अच्छी बात। हाँ, मैं सोच रहा था। :) वह एक अच्छा विचार है; मेरे पास आमतौर पर एक से अधिक दृष्टिकोण नहीं हैं: पी

— हाइपरएनुट्रिनो

2

सी ++ 11 (मिनगव), 198 बाइट्स

#import<list>
#import<iostream>
f(std::list<std::string>l){int i,m;for(auto s:l){for(i=0,m=1;++i<s.length();)for(auto t:l)if(t!=s&&t.substr(0,i)==s.substr(0,i))m=i+1;std::cout<<s.substr(0,m)<<" ";}}

के साथ बुलाना:

int main()
{
    f({"Monday", "Tuesday", "Wednesday", "Thursday", "Friday"});
}

voidफ़ंक्शन से पहले पहचानकर्ता को जोड़ने से इसे अन्य कंपाइलरों पर भी संकलित करना चाहिए, जिससे लंबाई में 5 बाइट्स जोड़ सकते हैं।

— Steadybox
स्रोत

यह होना चाहिए void f..., यह अन्यथा काम नहीं करता ... + 5 बाइट्स, दुर्भाग्य से। कार्य, जहाँ तक मुझे पता है, C ++ में टाइप

— स्पेसिफिकर्स की

इसके अलावा, बकाया दृष्टिकोण! C / C ++ में गोल्फ करना दर्दनाक हो सकता है

— श्री Xcoder

@ Mr.Xcoder यह MinGW संकलक पर संकलित करता है, हालांकि मैं उपयोग कर रहा हूं। तो यह एक संकलक विस्तार या अपरिभाषित व्यवहार है।

— स्टेयडबॉक्स

मुझे लगता है कि यह संकलक विस्तार के बारे में है, जीसीसी पर यह काम नहीं करता है ...

— श्री एक्सकोडर

1

जब तक कोड में काम करने वाला एक वातावरण है, तब तक यह मान्य है

— भूमिगत

2

जावास्क्रिप्ट ईएस 6, 70 वर्ण

s=>(s+'#'+s).replace(/(\w+?)(\w*)(?=(\W(?!\1(?!\2))\w+)+$)|#.+/g,"$1")

f=s=>(s+'#'+s).replace(/(\w+?)(\w*)(?=(\W(?!\1(?!\2))\w+)+$)|#.+/g,"$1")

console.log(f("one,two,three,four,five,six,seven")==="o,tw,th,fo,fi,si,se")
console.log(f("red,orange,yellow,green,blue,purple")==="r,o,y,g,b,p")
console.log(f("one,two,three,four,five,six,seven".split`,`)==="o,tw,th,fo,fi,si,se")
console.log(f("red,orange,yellow,green,blue,purple".split`,`)==="r,o,y,g,b,p")

स्निपेट का विस्तार करें

— Qwertiy
स्रोत

2

PHP, 131 120 119 118 बाइट्स

धन्यवाद @ Jörg के लिए preg_grep।

for(;a&$s=$argv[++$k];$i=+$t=!print"$t
")for(;a&$s[$i]&&1<count(preg_grep("(^".preg_quote($t.=$s[$i++]).")",$argv)););

कमांड लाइन तर्कों से इनपुट लेता है; प्रिंट प्रत्येक पंक्ति में एक परिणाम देता है। इसे ऑनलाइन
चलाएं -nrया इसके लिए प्रयास करें ।

यदि इनपुट में कुछ भी शुरू होता है तो वह विफल हो सकता है -।
+15 बाइट्स को ठीक करने के लिए: दूसरे के $argvसाथ बदलें array_slice($argv,1)।
PHP 7.1 में पैदावार चेतावनी; की जगह a&के साथ ""<(+1 बाइट) ठीक करने के लिए।
-12 बाइट्स यदि इनपुट में कोई रेगेक्स विशेष वर्ण नहीं है: पहले
डालें और साथ बदलें ।&($t.=$c)&&". preg_quote($t.=$c)."$t

टूट - फूट

for(;a&$s=$argv[++$k];      # loop $s through arguments
    $i=+$t=!                # 3. reset $i and $t to empty
    print"$t\n")            # 2. print abbreviation
    for(;a&($c=$s[$i++])    # 1. loop $c through characters
        &&1<count(              # 3. if count==1, break loop
            preg_grep("(^"      # 2. find matching arguments
                . preg_quote(
                $t.=$c          # 1. append $c to abbreviation
            ).")",$argv)
        );
    );

नॉन-रेगेक्स संस्करण, ~~131~~ 130 बाइट्स

for($a=$argv;a&$s=$a[++$k];$i=+$t=!print"$t
")for($n=1;$n&&a&$c=$s[$i++];)for($n=$m=1,$t.=$c;a&$u=$a[$m++];)$n-=0===strpos($u,$t);

PHP 7.1 के लिए ठीक करने के लिए पहले और अंतिम (+2 बाइट्स) के a&साथ बदलें ""<।

टूट - फूट

for($a=$argv;a&$s=$a[++$k];     # loop through arguments
    $i=+$t=!print"$t\n")            # 2. print abbreviation, reset $i and $t to empty
    for($n=1;$n&&a&$c=$s[$i++];)    # 1. loop through characters while $n<>0
        for($n=$m=1,                    # reset $n and $m to 1
            $t.=$c;                     # append current character to prefix
            a&$u=$a[$m++];              # loop through arguments:
        )$n-=0===strpos($u,$t);         # -$n = number of matching strings -1

पूरी तरह से निर्बाध नोट:
strstr($u,$t)==$uऔर 0===strpos($u,$t)एक ही लंबाई और एक ही परिणाम है।

— टाइटस
स्रोत

0x0Aइसके बजाय एक वास्तविक न्यूलाइन वर्ण ( ) का उपयोग करें \n, यह एक बाइट बचाएगा;)।

— ब्लैकहोल

@ ब्लेकहोल धन्यवाद; मैं इस बार भूल गया।

— टाइटस

1

PHP, 127 बाइट्स

अमान्य सरणियों के साथ काम नहीं करता है

<?foreach($a=$_GET as$k=>$v)for($i=0,$c=2,$s="";$c>1;$r[$k]=$s)$c=count(preg_grep("_^".($s.=$v[$i++])._,$a));echo join(",",$r);

PHP, 132 बाइट्स

<?foreach($a=$_GET as$v)for($i=0,$s="";a&$v[$i];)if(count(preg_grep("_^".($s.=$v[$i++])._,$a))==1){$r[]=$s;break;}echo join(",",$r);

ऑनलाइन संस्करण

151 बाइट्स विशेष वर्णों का समर्थन करती हैं

<?foreach($a=$_GET as$v)for($i=0,$s="";a&$v[$i];)if(count(preg_grep("_^".preg_quote($s=substr($v,0,++$i),_)._,$a))==1){$r[]=$s;break;}echo join(",",$r);

PHP, 140 बाइट्स

<?foreach($a=$_GET as$k=>$v)for($i=0;a&$v[$i];)if(count(preg_grep("#^".($s=substr($v,0,++$i))."#",$a))==1){$r[]=$s;break;}echo join(",",$r);

— जार्ग हुल्सरमन
स्रोत

यह विफल हो जाएगा यदि इनपुट में रेगेक्स विशेष वर्ण हैं। Itesd में 131 के बजाय 113 बाइट्स हैं यदि नहीं।

— टाइटस

@ टिट्स इस मामले में मैं preg_quoteकेवल 10 बाइट्स जोड़ सकता हूं

— जॉर्ग ह्यूल्सरमैन

यदि इनपुट सम्‍मिलित है तो यह भी विफल हो जाएगा 0। लेकिन आप एक बाइट के साथ बचा सकते हैं $i=+$s=""।

— टाइटस

और आप count()-count()सामान हटा सकते हैं : इनपुट वैध होने की गारंटी है (-21 बाइट्स)। मुझे लगता है कि मैं इसे 120 बाइट्स में ठीक कर सकता हूं और गोल्फ कर सकता हूं। $_GETएक अच्छा विचार था!

— टाइटस

@ मुझे पता ही नहीं चला कि केवल वैध सरणियों की अनुमति है। हाँ यह विफल होता अगर स्ट्रिंग में एक शून्य होता लेकिन इससे एक विचार पैदा होता

— Jörg Hülsermann

0

क्लोजर, 118 बाइट्स

#(reduce(partial map(fn[a b](or a b)))(for[i(range 1e2)S[(for[c %](take i c))]](for[s S](if(=((frequencies S)s)1)s))))

यह उपसर्गों की लंबाई तक काम करता है 1e2लेकिन एक ही बाइट काउंट अप-टू-सपोर्ट कर सकता है 1e9। iउपसर्गों की लंबाई छोरों, लंबाई के Ssubstrings के अनुक्रम है i। अंतिम forउन सबस्ट्रिंग्स को प्रतिस्थापित करता है जिनके साथ nilएक से अधिक बार होता है। कटौती प्रत्येक स्ट्रिंग के लिए पहला गैर-शून्य मान रखती है, बहुत बुरा orकार्य नहीं है इसलिए मुझे इसे लपेटना पड़ा।

यह वास्तव में जैसे पात्रों की सूचियों की सूची देता है ((\M) (\T \u) (\W) (\T \h) (\F)), लेकिन मुझे लगता है कि यह स्वीकार्य है। क्लोजर स्ट्रिंग्स के साथ काफी वर्बोज़ है, और subsइसके StringIndexOutOfBoundsExceptionविपरीत फेंक देगा take।

पूर्ण उदाहरण:

(def f #(reduce(partial map(fn[a b](or a b)))(for[i(range 1e2)S[(for[c %](take i c))]](for[s S](if(=((frequencies S)s)1)s)))))

(f ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"])
(f (re-seq #"[^,]+" "one,two,three,four,five,six,seven"))
(f (re-seq #"[^,]+" "red,orange,yellow,green,blue,purple"))

— NikoNyrh
स्रोत

0

SQL (PostgreSQL 9.4 स्वाद), 219 बाइट्स

अब सबसे लंबे उत्तर के लिए :) मुझे नहीं लगता कि यह जावा को भी हरा सकता है। मैं इससे कुछ दूर दाढ़ी बनाने की कोशिश करूंगा। नेस्टेड प्रश्नों में से एक से छुटकारा पाने की उम्मीद है, लेकिन मेरी संभावना पसंद नहीं है।
यह मानता है कि एक तालिका है जिसमें काम करने के लिए तार शामिल हैं। चूंकि यह एसक्यूएल है इसलिए रिटर्न का ऑर्डर टेबल ऑर्डर के समान होने की गारंटी नहीं है और इस मामले में संभावना नहीं है। यदि यह एक समस्या है तो मैं हटा दूंगा।

SELECT R FROM(SELECT*,RANK()OVER(PARTITION BY A ORDER BY C,N)Z FROM(SELECT*,SUM(1)OVER(PARTITION BY R)C FROM(SELECT*FROM A JOIN LATERAL(select left(A,n)R,N FROM generate_series(1,length(A))S(n))L ON 1=1)X)Y)Z WHERE Z=1

एसक्यूएल फिडेल
स्पष्टीकरण

  SELECT *
  FROM A 
    JOIN LATERAL(SELECT LEFT(A,n)R,N 
    FROM generate_series(1,length(A))S(n))L ON 1=1

अंतरतम क्वेरी स्ट्रिंग में विभाजन के लिए पंक्तियों को बनाने generate_seriesऔर LATERALलंबाई में विभाजित करने के लिए एक सम्मिलित करता है , इसलिए 'एक' 'ओ', 'ऑन', 'वन' बन जाता है। वापसी में पात्रों की संख्या भी रखी गई है।

SELECT 
  *,
  SUM(1)OVER(PARTITION BY R)C
FROM ( ... )X

फिर हम उन रिकॉर्डों की संख्या जोड़ते हैं जिनके परिणाम समान हैं। उदाहरण के लिए, चार और पाँच के 'f' में 2 हैं, लेकिन 'fo' और 'fi' में से प्रत्येक में एक है। OVERएसक्यूएल में बयान काफी शक्तिशाली हो सकता है। COUNT(*)सामान्य तरीका होगा, लेकिन SUM(1)वही परिणाम देता है।

SELECT 
  *,
  RANK()OVER(PARTITION BY A ORDER BY C,N)Z
FROM ( ... )Y

फिर हम प्रत्येक इनपुट के लिए परिणामों को न्यूनतम पुनरावृत्ति और वर्णों के आधार पर रैंक करते हैं। ROW_NUMBERयहाँ भी काम करेगा, लेकिन अब है।

SELECT R FROM ( ... )Z WHERE Z=1;

अंत में हम प्रत्येक शब्द के लिए निम्नतम रैंक संख्या का चयन करते हैं।

— MickyT
स्रोत

0

शुद्ध बैश , 146 बाइट्स

for i in $@;{ K=1;U=${i::1};((M++));L=;while [[ `for v in $@;{ ((L++));(($L!=$M))&&echo ${v::K}||:;}` =~ $U ]];do U=${i::K};((K++));done;echo $U;}

इसे ऑनलाइन आज़माएं!

— आर। कप
स्रोत

0

APL (Dyalog) , 27 बाइट्स

{⍵↑¨⍨1⍳⍨¨↓+/(↑,\¨⍵)∘.(⊃⍷)⍵}

इसे ऑनलाइन आज़माएं!

{ एक अनाम फ़ंक्शन, जहां argument तर्क का प्रतिनिधित्व करता है ...

∘.( एक फंक्शन टेबल जहाँ फंक्शन होता है

⊃ का पहला तत्व

⍷ बूलियन सूची "बाएं तर्क यहां सही तर्क में शुरू होता है?"

) जहां सही तर्क हैं

⍵ तर्क

( और बायाँ तर्क है

↑ पंक्तियों वाली एक तालिका

,/ के उपसर्ग

¨ की प्रत्येक

⍵ तर्क

+/ योग भर (मायने रखता है कि इस उपसर्ग के साथ कितने तर्क हैं)

↓ पंक्तियों की सूची में विभाजित तालिका

⍳⍨¨ प्रत्येक में, पहले का स्थान ढूंढें

1 एक (यानी पहला उपसर्ग जो केवल एक तर्क देता है)

↑¨⍨ प्रत्येक स्थान के लिए, इसी तत्व के कई वर्ण लेता है

⍵ बहस

} अनाम फ़ंक्शन का अंत

— एडम
स्रोत

0

पॉवरशेल, 151 139 बाइट्स

$x,$w=@(),$args[0];$w|%{$k=$_;$a='';foreach($l in [char[]]$k){$a+=$l;if($a-notin$x-and!($w|?{$_-ne$k-and$_-like"$a*"})){$x+=$a;break;}}};$x

अगर ऐसा करने का एक बेहतर तरीका है, तो दिलचस्पी है। बिना लेबल वाले नेस्टेड लूप में प्रदर्शन करने में सक्षम होने के लिए foreach(ओवर |%) का उपयोग करना पड़ा break।

संपादित करें: AdmBorkBork से 2 गोल्फ

— टो
स्रोत

1

मैं सीधे कोड के माध्यम से नहीं गया हूं, लेकिन निश्चित रूप से आप -notinइसके बजाय -not$x.contains($a)और कुछ बाइट्स को बचाने !($w...के -not($w...लिए उपयोग कर सकते हैं , हाँ?

— AdmBorkBork

0

एपीएल, 26 बाइट्स

{⍵↑¨⍨1+⌈/+/¨∘.(∧\=∧≢)⍨↓↑⍵}

स्पष्टीकरण:

↓↑⍵: ⍵सबसे लंबे स्ट्रिंग की लंबाई से मेल खाने के लिए प्रत्येक स्ट्रिंग को पैड करें
∘.(... )⍨: तार की प्रत्येक संभावित जोड़ी के लिए, साझा उपसर्ग खोजें:
- ≢: सरणी असमानता
- ∧: तथा
- =: वस्तु की समानता
- ∧\: और स्कैन (केवल प्रमुख मैचों को रखें)
+/¨: साझा किए गए उपसर्गों की लंबाई देते हुए, तालिका में प्रत्येक वेक्टर का योग करें
⌈/: प्रत्येक स्तंभ में अधिकतम मान ज्ञात करें
1+: प्रत्येक स्ट्रिंग को अद्वितीय रखने के लिए आवश्यक वर्णों की मात्रा देते हुए, एक जोड़ें
⍵↑¨⍨: प्रत्येक स्ट्रिंग से कई वर्ण लें

परीक्षा:

      {⍵↑¨⍨1+⌈/+/¨∘.(∧\=∧≢)⍨↓↑⍵}'Monday' 'Tuesday' 'Wednesday' 'Thursday' 'Friday'
┌─┬──┬─┬──┬─┐
│M│Tu│W│Th│F│
└─┴──┴─┴──┴─┘
      {⍵↑¨⍨1+⌈/+/¨∘.(∧\=∧≢)⍨↓↑⍵}'one' 'two' 'three' 'four' 'five' 'six' 'seven'
┌─┬──┬──┬──┬──┬──┬──┐
│o│tw│th│fo│fi│si│se│
└─┴──┴──┴──┴──┴──┴──┘
      {⍵↑¨⍨1+⌈/+/¨∘.(∧\=∧≢)⍨↓↑⍵}'red' 'orange' 'yellow' 'green' 'blue' 'purple'
┌─┬─┬─┬─┬─┬─┐
│r│o│y│g│b│p│
└─┴─┴─┴─┴─┴─┘

— मारीनस
स्रोत

0

क्यू, 93 बाइट्स

{n:1;{$[any e:(,/)1<{(+/)i like x}each i:z#'x;[z+:1;y:?[e;z#'x;i];.z.s[x;y;z]];y]}[x;n#'x;n]}

पुनरावर्ती हल, स्ट्रिंग को इनपुट के रूप में लेता है, प्रत्येक स्ट्रिंग के पहले n तत्वों को प्रत्येक पुनरावृत्ति के साथ प्राप्त करता है। यदि उन तत्वों में से कोई भी अद्वितीय नहीं है, तो यह उन्हें पहले n + 1 तत्वों के साथ बदल देता है।

— डैनियल प्लेनव्यू
स्रोत

एक सरणी संक्षिप्त करें

लक्ष्य:

विशिष्टता:

उदाहरण:

और ज्यादा उदाहरण:

टिप्पणियाँ:

रेटिना , 29 बाइट्स

व्याख्या

पायथन 2 , 87 86 बाइट्स

जावास्क्रिप्ट (ईएस 6), 81 78 74 70 बाइट्स

प्रारूपित और टिप्पणी की गई

परीक्षण के मामलों

जेली , 14 बाइट्स

यह काम किस प्रकार करता है

हास्केल , 48 बाइट्स

मैथेमेटिका, 64 बाइट्स

जेली , 14 12 बाइट्स

यह काम किस प्रकार करता है

सी ++ 11 (मिनगव), 198 बाइट्स

जावास्क्रिप्ट ईएस 6, 70 वर्ण

PHP, 131 120 119 118 बाइट्स

PHP, 127 बाइट्स

PHP, 132 बाइट्स

151 बाइट्स विशेष वर्णों का समर्थन करती हैं

PHP, 140 बाइट्स

क्लोजर, 118 बाइट्स

SQL (PostgreSQL 9.4 स्वाद), 219 बाइट्स

शुद्ध बैश , 146 बाइट्स

APL (Dyalog) , 27 बाइट्स

पॉवरशेल, 151 139 बाइट्स

एपीएल, 26 बाइट्स

क्यू, 93 बाइट्स