इनपुट

एक अल्फ़ान्यूमेरिक स्ट्रिंग s।

उत्पादन

सबसे छोटी स्ट्रिंग जो एक (सन्निहित) के रूप में ठीक एक बार घटित होती है s। अतिव्यापी घटनाओं को विशिष्ट के रूप में गिना जाता है। यदि एक ही लंबाई के कई उम्मीदवार हैं, तो आपको उन सभी को घटना के क्रम में आउटपुट करना होगा। इस चुनौती में, खाली स्ट्रिंग n + 1लंबाई की स्ट्रिंग में बार होती है n।

उदाहरण

स्ट्रिंग पर विचार करें

"asdfasdfd"

खाली स्ट्रिंग इसमें 10 बार होती है, इसलिए यह अद्वितीय घटना के लिए उम्मीदवार नहीं है। पत्र के प्रत्येक "a", "s", "d", और "f"कम से कम दो बार होता है, तो वे उम्मीदवारों या तो नहीं हैं। सबस्ट्रिंग "fa"और "fd"केवल एक बार और इस क्रम में पाए जाते हैं, जबकि लंबाई 2 के अन्य सभी सबस्ट्रिंग दो बार होते हैं। इस प्रकार सही आउटपुट है

["fa","fd"]

नियम

दोनों कार्यों और पूर्ण कार्यक्रमों की अनुमति है, और मानक कमियां नहीं हैं। आउटपुट का सटीक स्वरूपण लचीला है, इस कारण से। विशेष रूप से, खाली स्ट्रिंग के लिए कोई आउटपुट उत्पन्न करने की अनुमति नहीं है, लेकिन एक त्रुटि फेंकना नहीं है। सबसे कम बाइट गिनती जीतती है।

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

"" -> [""]
"abcaa" -> ["b","c"]
"rererere" -> ["ererer"]
"asdfasdfd" -> ["fa","fd"]
"ffffhhhhfffffhhhhhfffhhh" -> ["hffff","fffff","hhhhh","hfffh"]
"asdfdfasddfdfaddsasadsasadsddsddfdsasdf" -> ["fas","fad","add","fds"]

लीडरबोर्ड

यहाँ उप-भाषा लीडरबोर्ड है जो मैंने वादा किया था।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

<script src='https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js'></script><script>site = 'meta.codegolf',postID = 5314,isAnswer = true,QUESTION_ID = 45056;jQuery(function(){var u='https://api.stackexchange.com/2.2/';if(isAnswer)u+='answers/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJeRCD';else u+='questions/'+postID+'?order=asc&sort=creation&site='+site+'&filter=!GeEyUcJFJO6t)';jQuery.get(u,function(b){function d(s){return jQuery('<textarea>').html(s).text()};function r(l){return new RegExp('<pre class="snippet-code-'+l+'\\b[^>]*><code>([\\s\\S]*?)<\\/code><\/pre>')};b=b.items[0].body;var j=r('js').exec(b),c=r('css').exec(b),h=r('html').exec(b);if(c!==null)jQuery('head').append(jQuery('<style>').text(d(c[1])));if (h!==null)jQuery('body').append(d(h[1]));if(j!==null)jQuery('body').append(jQuery('<script>').text(d(j[1])))})})</script>

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

code-golf string

— Zgarb
स्रोत

संयुक्त निर्मित कार्यों में कोई सीमाएं?

— मार्टिन एंडर

3

@ मार्टिनबटनर इस चुनौती में, सब कुछ चला जाता है। यदि यह पर्याप्त उत्तर देता है, तो मैं एक उप-भाषा लीडरबोर्ड रखूंगा, इसलिए और भी अधिक सुसज्जित भाषाओं में एक सार्थक प्रतियोगिता हो सकती है।

— जर्गब

क्या आप मेरे कोड गोल्फ लीडरबोर्ड स्निपेट का उपयोग करना चाहते हैं ? तब आपको लीडरबोर्ड को अद्यतित रखने के लिए सभी संपादनों की निगरानी नहीं करनी होगी। यदि आप करते हैं, तो मैं इसे आपके लिए जोड़ सकता हूं, और मैं उन्हें हेडर प्रारूप से मिलान करने के लिए उत्तरों के माध्यम से जाऊंगा।

— मार्टिन एंडर

@ मार्टिनबटनर धन्यवाद, मैं इसकी सराहना करूंगा!

— जर्गब

सब कुछ कर दिया! मुझे पता है अगर कुछ काम नहीं करता है। (भविष्य में अपनी चुनौतियों के लिए इसे फिर से उपयोग करने के लिए स्वतंत्र महसूस करें।)

— मार्टिन एंडर

3

पायथ, 27 26 बाइट्स

&zhfTmf!/>zhxzYYm<>zkdUzUz

इसे यहाँ आज़माएँ।

ध्यान दें कि ऑनलाइन संकलक में एक बग के कारण, खाली स्ट्रिंग केस केवल कमांड लाइन संस्करण पर सही ढंग से काम करता है, जो यहां पाया जा सकता है।

आप ऑनलाइन कंपाइलर के इनपुट के रूप में एक नई लाइन देकर बग को ठीक कर सकते हैं।

स्पष्टीकरण:

                                   z = input(), implicit.
&z                                 Prints empty string if input is empty.
  hfT                              Take the first non-empty list from
     m                  Uz         A list of list of substrings of z, divided by length
                m<>zkdUz           with some shorter strings repeated later, to no effect.
      f                            Where the substrings are filtered on
       !/      Y                   There being 0 occurrences of the substring in
         >z                        The slice of z
           hxzY                    from the character after the first character
                                   of the first occurrence of the substring in z
                                   to the end of z.

— isaacg
स्रोत

खाली स्ट्रिंग इनपुट के लिए विफल।

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र मुझे लगता है कि ऑनलाइन कंपाइलर में एक बग है, वास्तव में। यह कमांड लाइन संस्करण पर काम करता है। वास्तव में, zकोई भी इनपुट ऑनलाइन विफल नहीं होता है, इसलिए यह निश्चित रूप से दुभाषिया में एक बग है।

— इसहाक

EOF नहीं देता है?

— ऑप्टिमाइज़र

@ ऑप्टीमाइज़र पाइथ को नईलाइन टर्मिनेटेड इनपुट की उम्मीद है, जो कि गलत हो सकता है।

— इसहाक

तो एक खाली स्ट्रिंग पास करना भी संभव नहीं है?

— ऑप्टिमाइज़र

13

पायथन 3, 124 123 111 96 बाइट्स

f=lambda s,n=1:[x for x in[s[i:i+n]for i in range(len(s)+1)]if s.find(x)==s.rfind(x)]or f(s,n+1)

स्ट्रिंग्स के लिए लग रहा है कि बाईं ओर से पहली घटना सही से पहली घटना के रूप में है। +1में rangeरिक्त स्ट्रिंग मामले के लिए समायोजित करने के लिए है।

अब यदि केवल पायथन में एक अतिशीत मैच की .count()गिनती होती , तो यह काफी कम होता।

— Sp3000
स्रोत

6

मैथेमेटिका, 95 94 79 बाइट्स

Cases[Tally@StringCases[#,___,Overlaps->All],{s_,1}:>s]~MinimalBy~StringLength&

StringCasesमुझे सभी संभव विकल्प मिलते हैं, Tallyऔर Casesउन लोगों को फ़िल्टर करते हैं जो एक से अधिक बार दिखाई देते हैं और MinimalByवे पाते हैं जो सबसे कम हैं।

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

क्या &कोड के अंत में कोई अतिरिक्त नहीं है ?

— डेविड जी। सारस

लड़का, तुम तेज़ हो!

— डेविड जी। सारस

4

GolfScript, 44 बाइट्स

:S;-1:x{;S,x):x-),{S>x<}%:^1/{^\/,2=},.!}do`

स्टड पर एक स्ट्रिंग के रूप में इनपुट लेता है और एक डबल-सरणी सिंटैक्स में आउटपुट होता है: उदा [["b"] ["c"]]। ऑनलाइन डेमो

विच्छेदन

:S;          # Store input in S and pop it
-1:x         # Store -1 in x
{            # do-while loop
  ;          #   Pop x the first time and [] every subsequent time
  S,x):x-),  #   Increment x and build an array [0 1 ... len(S)-x]
  {S>x<}%    #   Map that array to [substr(S,0,x) substr(S,1,x) ...]
  :^         #   Store in ^ (to avoid the token coalescing with the next char)
  1/         #   Split by length 1 to iterate over 1-elt arrays rather than strings
  {^\/,2=},  #   Filter to arrays which occur exactly once as a subarray of ^
  .!         #   Duplicate and test emptiness
}do          # end do-while loop: loop if the filtered array is empty
`            # Stringify for output

यह इस तरह से व्यवस्थित किया गया है कि खाली स्ट्रिंग के लिए कोई विशेष मामला आवश्यक नहीं है (जो मैंने ऊपर लिंक किए गए ऑनलाइन डेमो में एक परीक्षण मामले के रूप में शामिल किया है)।

— पीटर टेलर
स्रोत

3

CJam, 52 43 40 बाइट्स

]]q:Q,,{)Q,1$-),f{Q><}:R{R\a/,2=},}%{}=p

इनपुट बिना उद्धरण के स्ट्रिंग है

स्पष्टीकरण :

]]                                       "For empty string input case";
  q:Q                                    "Read the input and store in Q";
     ,,                                  "Take length of input and 0 to length array";
       {                          }%     "Map the above array on this code block";
        )Q                               "Increment the number in the current iteration, L";
         Q,1$                            "Take input's length and copy the above number";
             -)                          "Get upper limit of next loop to get substrings";
               ,f{   }                   "Get 0 to above number array and for each";
                  Q><                    "Get the L length substring at Ith index where";
                                         "I loops from 0 to Q, - L + 1";
                      :R                 "Store this list of substring of length L in R";
                        {R\a/,2=},       "Filter to get unique substrings";
                                    {}=  "Get the first non empty substring array";
                                         "This leaves nothing on stack if all are empty";
                                       p "Print the top stack element. At this point, its";
                                         "Either the first non empty substring array or";
                                         "the ]] i.e. [""] which we added initially";

उदाहरण:

asdfdfasddfdfaddsasadsasadsddsddfdsasdf

उत्पादन

["fas" "fad" "add" "fds"]

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

3

स्काला, 120 बाइट्स

readLine.inits.flatMap(_.tails).toList.groupBy(l=>l).filter(x=>x._2.length<2).map(_._1).groupBy(_.length).minBy(_._1)._2

मैंने 140 से शुरुआत की जो कम से कम पहले से ही एक ट्वीट में फिट बैठता है।

(                                        // added for comments
 readLine                                // input
.inits.flatMap(_.tails).toList           // get all substrings of that string
.groupBy(l=>l).filter(x=>x._2.length<2)  // remove substrings that occur more than once
.map(_._1).groupBy(_.length)             // take the substring and group by length
.minBy(_._1)._2                          // take the list of shortest substrings
)

— डोमिनिक मुलर
स्रोत

मैं सोचता हूं? (_)इसके बजाय सिर्फ पहचान के रूप में काम क्यों नहीं करता है l=>l?

— गर्व हैकेलर

मुझे भी आश्चर्य होता है। किसी तरह list.groupBy(_)एक ही है x => list.groupBy(x)। मुझे नहीं पता कि उन्होंने इसे क्यों लागू किया।

— डोमिनिक मुलर

3

जावास्क्रिप्ट (ईएस 6), 109 110

IndexOf के बजाय खोज संपादित करें, क्योंकि इनपुट स्ट्रिंग अल्फ़ान्यूमेरिक है। धन्यवाद @IsmaelMiguel

पुनरावर्ती कार्य, 1 और लंबाई के साथ शुरू होने वाले सबस्ट्रिंग की तलाश में।

F=(s,n=1,r)=>
s?[...s].map((a,i)=>~s.indexOf(a=s.substr(i,n),s.search(a)+1)?r:r=[...r||[],a])&&r||F(s,n+1):[s]

अनगढ़ और समझाया गया

 F = function(s, n=1) { // start with length 1
   var i, a, p, r;
   if (s == "") // special case for empty input string
     return [s];
   for (i = 0; i < s.length; i++) 
   // for each possibile substring of length n
   // (should stop at s.length-n+1 but going beyond is harmless)
   // Golfed: "[...s].map((a,i)" ... using i, a is overwrittem
   {
     a = s.substr(i, n); // substring at position i
     p = s.search(a); // p is the first position of substring found, can be i or less
     p = s.indexOf(a, p + 1) // p is now the position of a second instance of substring, or -1 if not found
     if (~p) // ~p is 0 if p is -1
     {
       ; // found more than once, do nothing
     }
     else
     {
       r = r || []; // if r is undefined, then it becomes an empty array
       r.push(a); // save substring 
       // Golfed: "r=[...r||[],a]"
     }
   }
   if (r) // if found some substring, saved in r
   {
     return r;
   }
   return F(s, n+1) // recursive retry for a bigger length
 }

फायरफॉक्स / फायरबग कंसोल में टेस्ट

;["", "abcaa", "rererere", "asdfasdfd", "ffffhhhhfffffhhhhhfffhhh", 
 "asdfdfasddfdfaddsasadsasadsddsddfdsasdf"]
.forEach(x=>console.log(x,F(x)))

उत्पादन

 [""]
abcaa ["b", "c"]
rererere ["ererer"]
asdfasdfd ["fa", "fd"]
ffffhhhhfffffhhhhhfffhhh ["hffff", "fffff", "hhhhh", "hfffh"]
asdfdfasddfdfaddsasadsasadsddsddfdsasdf ["fas", "fad", "add", "fds"]

— edc65
स्रोत

के .searchबजाय का उपयोग करें .indexOfऔर आप 2 बाइट्स बचाते हैं।

— इस्माइल मिगुएल

@IsmaelMiguel नहीं क्योंकि 1) खोज में ऑफ़सेट पैरामीटर 2 नहीं है) खोज एक regexp की उम्मीद करती है, और विशेष

— चार्ट

1

लेकिन पहले पर आप इसे सुरक्षित रूप से (अपने पर s.indexOf(a)+1) बदल सकते हैं । हालांकि यह है कि यह उन लोगों के साथ काम नहीं करेगा, आपको चिंता करने की जरूरत नहीं है! ओपी को उद्धृत करते हुए: " Input: An alphanumeric string s."

— इस्माइल मिगुएल

@IsmaelMiguel सही, धन्यवाद।

— edc65

1

@IsmaelMiguel मुझे एक रास्ता नहीं मिला ... मुझे सच्चाई या झूठ बोलने की ज़रूरत है, और किसी भी सरणी (यहां तक कि खाली []) जावास्क्रिप्ट में एक

— सत्य

3

जावा, 168 176 233

यहाँ एक बहुत बढ़िया नेस्टेड लूप उदाहरण है।

void n(String s){for(int l=0,i=0,t=s.length(),q=0;l++<t&q<1;i=0)for(String b;i<=t-l;)if(s.indexOf(b=s.substring(i,i+++l),s.indexOf(b)+1)<0){System.out.println(b);q++;}}

या थोड़ा अधिक पठनीय:

void t(String s){
    for(int l=0,i=0,t=s.length(),q=0;l++<t&q<1;i=0)
        for(String b;i<=t-l;)
            if(s.indexOf(b=s.substring(i,i++ +l),s.indexOf(b)+1)<0){
                System.out.println(b);
                q++;
            }
}

— Geobits
स्रोत

यदि आप पठनीयता चाहते हैं, तो +++यह दिखाने के लिए कि क्या यह मदद करेगा + ++या नहीं बंट रहा है ++ +... और यदि आप कुछ और बाइट्स बचाना चाहते हैं, तो ऐसा करने का एक तरीका हो सकता है q=1, आरंभ करने के q++साथ q=t, और l++<t&q<1जैसे कुछ के साथ प्रतिस्थापित करना t>l+=q। संभवतः इसे काम करने के लिए एक या दो अन्य संतानों को जोड़ने की आवश्यकता होती है।

— पीटर टेलर

@ अच्छी तरह से, पठनीय से मेरा ज्यादातर मतलब था "मुझे क्षैतिज रूप से स्क्रॉल करने की आवश्यकता नहीं है," लेकिन मैंने स्पष्ट किया +++। मैं इसे ट्विक करने की कोशिश कर रहा हूं (विशेषकर q, जो कुछ बेकार लगता है), लेकिन अभी तक कुछ भी ठोस नहीं मिला है।

— Geobits

@PeterTaylor जावा के लेक्सिंग नियमों के कारण, +++हमेशा हल होता है ++ +।

— फ़ूजएक्सएक्सल

@FUZxxl, मुझे संदेह है कि अधिकांश जावा उपयोगकर्ता भी जानते हैं, और इस साइट पर बहुत सारे लोग हैं जो जावा को नहीं जानते हैं।

— पीटर टेलर

1

— इंडेक्सऑफ का उपयोग ऑफ़एंड के बजाय इंडेक्सऑफ के

3

हास्केल, 169 162 155 153 151 138 120 115

import Data.List
l=length
q k=filter$(==)k.l
p y=q(minimum.map l$y)$y
f x=p$concat$q 1$group$sort$(tails x>>=inits)

इसके प्रयेाग के लिए:

f "asdfdfasddfdfaddsasadsasadsddsddfdsasdf"

जो देता है:

["add","fad","fas","fds"]

Btw। मुझे अपने कोड की अंतिम पंक्ति (दोहराव h y) से नफरत है । इससे छुटकारा पाने के लिए कोई संकेत देता है?

— RobAu
स्रोत

1

कैसे के बारे में आप को परिभाषित g y=q(minimum.(map l)$y)$y(कोष्ठकों के आसपास रहे हैं map lऔर उसके बाद की वास्तव में आवश्यकता?) f=g.concat.q 1.group.sort.concatMap inits.tails?

— फ़ूजएक्सएक्सएल

1

के >>=बजाय का उपयोग concatMap, यानी f x=p$concat$q 1$group$sort$(tails x>>=inits)2 बाइट बचाता है। Data.Ordआयात क्यों ?

— निमि

1

कोष्ठक qअनावश्यक हैं, चूंकि आप लिख सकते हैं filter$(==)k.l, जैसा कि अंतिम $और yएस से पहले रिक्त स्थान हैं p। आप आयात के बाद अर्धविराम को भी हटा सकते हैं ( Data.Ordवास्तव में अनावश्यक लगता है)।

— जर्बर्ग

Leksah संकलक $एक गैर-स्थान के बाद स्वीकार नहीं करता है। यह कुछ बाइट्स की दाढ़ी करेगा, लेकिन क्या यह भाषा की कल्पना में है?

— रोबू

1

जीएचसी इसे स्वीकार करेगा।

— जरगब

3

J, 61 58 44 42 40 38 37 बाइट्स

[:>@{.@(#~#@>)#\<@(~.#~1=#/.~)@(]\)]

यहां समाधान के अलग-अलग घटकों में एक संस्करण विभाजित किया गया है:

unqs =. ~. #~ 1 = #/.~               NB. uniques; items that appear exactly once
allsbsq =. #\ <@unqs@(]\) ]        NB. all unique subsequences
shrtsbsq =. [: >@{.@(#~ #@>) allsbsq NB. shortest unique subsequence

x #/. yप्रत्येक विशिष्ट तत्व के लिए गणना करता है xकि कितनी बार में होता है y। यदि हम इसका उपयोग करते हैं y #/. y, तो हमें yइसकी गणना में प्रत्येक अलग तत्व के लिए मिलता है । उदाहरण के लिए, a #/. aके लिए a =. 1 2 2 3 4 4पैदावार 1 2 1 2।
1 = yजाँच करता है कि कौन से आइटम के yबराबर हैं 1। उदाहरण के लिए, 1 = a #/. aपैदावार 1 0 1 0।
u~है कर्मकर्त्ता एक monadic क्रिया की u। यह है, के u~ yरूप में ही है y u y। इस प्रकार, के #/.~ yरूप में ही है #/.~ y। जब एक डायडिक क्रिया पर लागू किया जाता है, u~तो निष्क्रिय होता है u। जो है, x u~ yवही है y u x। ये कुछ अन्य स्थानों पर उपयोग किए जाते हैं जिनका मैं स्पष्ट रूप से उल्लेख नहीं करता हूं।
~. yकी डब है y, एक वेक्टर जो डुप्लिकेट हटा दिया गया है। उदाहरण के लिए, ~. aपैदावार 1 2 3 4।
x # y( प्रतिलिपि ) yउन सूचकांकों में से आइटम का चयन करता है , जिनमें xशामिल हैं a 1।
इस प्रकार, (1 = y #/. y) # (~. y)उन तत्वों का एक वेक्टर बनाता है yजो केवल एक बार दिखाई देते हैं। टैसीट नोटेशन में, इस क्रिया को इस प्रकार लिखा जाता है ~. #~ 1 = #/.~; आइए इस वाक्यांश unqsको बाकी स्पष्टीकरण के लिए कहते हैं।
x ]\ yएक बनाता xद्वारा 1 + y - xसभी की सरणी infixes वेक्टर की yलंबाई की x। उदाहरण के लिए, 3 ]\ 'asdfasdfdपैदावार
```
asd
sdf
dfa
fas
asd
sdf
dfd
```
# yकी संख्या है y, अर्थात् , तत्वों की संख्या y।
u\ yलागू होता है uप्रत्येक के लिए उपसर्ग की y। संयोग से, #\ yपूर्णांक से एक वेक्टर बनाता 1है #y।
< yyएक बॉक्स में डालता है । यह आवश्यक है क्योंकि सरणियों को रैगिंग नहीं किया जा सकता है और हम विभिन्न लंबाई के प्रत्ययों की एक सरणी की गणना करते हैं; एक बॉक्सिंग ऐरे एक स्केलर के रूप में गिना जाता है।
इस प्रकार, लंबाई k (सभी 0 ) k < ) y के infixes के बॉक्स के सरणियों का (i. # y) <@:unqs@(]\) yएक वेक्टर उत्पन्न करता है जो बिल्कुल एक बार होता है। इस क्रिया का मौन रूप है या यदि हम नाम का उपयोग नहीं करते हैं । आइए इस वाक्यांश को इस स्पष्टीकरण के बाकी हिस्सों के लिए कहते हैं । उदाहरण के लिए, पैदावार:#y#yi.@# <@unqs@(]\) ]i.@# <@(~. #~ 1 = #/.~)@(]\) ]unqsallsbsqallsbsq 'asdfasdfd'
```
┌┬─┬──┬───┬────┬─────┬──────┬───────┬────────┐
││ │fa│dfa│sdfa│asdfa│asdfas│asdfasd│asdfasdf│
││ │fd│fas│dfas│sdfas│sdfasd│sdfasdf│sdfasdfd│
││ │  │dfd│fasd│dfasd│dfasdf│dfasdfd│        │
││ │  │   │sdfd│fasdf│fasdfd│       │        │
││ │  │   │    │asdfd│      │       │        │
└┴─┴──┴───┴────┴─────┴──────┴───────┴────────┘
```
(#@> y) # yबॉक्स वाले सरणियों के वेक्टर से लेता है yजो खाली नहीं हैं।
{. yवेक्टर का पहला तत्व लेता है y।
> yसे बॉक्स निकालता है y।
इस प्रकार, > {. (#@> y) # yबॉक्सिंग सरणियों के वेक्टर से अनबॉक्स्ड पहला गैर-खाली सरणी प्राप्त करता है y। यह वाक्यांश >@{.@(#~ #@>)टैसीटेशन नोटेशन में लिखा गया है।
अंत में, हमारे पास मौजूद समस्या के समाधान के लिए [: >@{.@(#~ #@>) allsbsqपिछले वाक्यांश को असेंबल करता allsbsqहै। यहाँ रिक्त स्थान के साथ पूरा वाक्यांश है:
```
[: >@{.@(#~ #@>) i.@# <@(~. #~ 1 = #/.~)@(]\) ]
```

— FUZxxl
स्रोत

2

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

import Data.List
f ""=[""]
f g=map(snd)$head$groupBy(\a b->fst a==fst b)$sort[(length y,y)|[y]<-group$sort[x|x@(_:_)<-tails g>>=inits]]

— nimi
स्रोत

2

PHP, 171 152 134 125

function f($s){while(!$a&&++$i<strlen($s))for($j=0;$b=substr($s,$j++,$i);)strpos($s,$b)==strrpos($s,$b)&&($a[]=$b);return$a;}

http://3v4l.org/RaWTN

— स्टीफन
स्रोत

आपको स्पष्ट रूप से परिभाषित करने की आवश्यकता नहीं है $j=0। आगे, तुम्हारे पास है substr($s,$j++,$i)। परिभाषित किए बिना $j, आप इसे फिर से लिख सकते हैं substr($s,0+$j++,$i)और आप 2 बाइट्स बचा सकते हैं। ऐसा क्यों है? खैर, पहली बार, $jहोगा null। और अगर आप को प्रभावी ढंग से गुजर रहा हो जाएगा nullकरने के लिए substrहै, जो मुझे नहीं लगता कि अच्छी तरह से काम करेगा। का उपयोग करते हुए 0+$j++परिवर्तित कर देंगे nullकरने के लिए 0। यदि आप देखते हैं कि इसकी आवश्यकता नहीं है, तो इसके बिना आगे बढ़ें और केवल $j=0भाग निकालें ।

— इस्माइल मिगुएल

कोशिश की कि; यह काम नहीं करता है क्योंकि PHP में मजबूत स्कूपिंग नहीं है, इसलिए लूप के $jप्रत्येक पुनरावृत्ति के लिए इसे साफ़ और पुनर्निमित नहीं किया जाता while()है। जब तक यह अशक्त है (और इसलिए इसे कॉल 0द्वारा परिवर्तित किया जाएगा $j++), बाहरी लूप के भविष्य के पुनरावृत्तियों पर पहली बार इसके मूल्य पर छोड़ दिया गया है। यह इतना प्रारंभिक नहीं है जितना रीसेट करना। हालांकि सुझाव के लिए धन्यवाद :-)

— स्टीफन

यहां मैं आपको एक 141 बाइट्स लंबे समाधान की पेशकश करता हूं:

function f($s){$l=strlen($s);while(!$a&&++$i<$l)for($j=0;$j<$l;)($b=substr($s,$j++,$i))&(strpos($s,$b)==strrpos($s,$b)&&($a[]=$b));return$a;}

परिवर्तन: आपके सभी को हटा दिया ||1, एक जगह के बजाय बिटवाइज़ &( AND) का उपयोग &&किया, (2 बाइट्स बचाकर) के $j<$l&&[...]बाहर के हिस्से को स्थानांतरित किया forऔर कुछ अनावश्यक कोष्ठक हटा दिए।

— इस्माईल मिगुएल

1

एक 134 बाइट्स आपके लिए लंबे उपहार:

function f($s){$l=strlen($s);while(!$a&&++$i<$l)for($j=0;$j<$l;)strpos($s,$b=substr($s,$j++,$i))==strrpos($s,$b)&&($a[]=$b);return$a;}

पिछले कोड में किए गए परिवर्तन: इसे बनाने $b=substr($s,$j++,$i)में स्थानांतरित किया गया , अधिक आवश्यक कोष्ठकों को हटाया और अनावश्यक को हटा दिया । strpos($s,$b)strpos($s,$b=substr($s,$j++,$i))&

— इस्माईल मिगुएल

1

प्रबंधित थोड़ा और काटना :-) substr($s,$j++,$i)रिटर्न ""जब $jपहुँच स्ट्रिंग की लंबाई, और falseउसके बाद तो यह है कि काम भी पाश सशर्त छुट्टी के रूप में काम कर सकते हैं। फिर $lशेष का केवल एक उपयोग है , ताकि इसे भी समेकित किया जा सके।

— स्टीफन

2

ग्रूवी (ओरेकल कार्यान्वयन पर जावा रेगेक्स), 124

c={m=it=~/(?=(.*?)(?=(.*))(?<=^(?!.*\1(?!\2$)).*))/;o=m.collect({it[1]});o.findAll({it.size()==o.min({it.size()}).size()});}

Groovy 2.4 + Oracle JRE 1.7 पर परीक्षण किया गया। रेगेक्स को जावा 6 से जावा 8 के लिए काम करना चाहिए, क्योंकि बग जो कोड को काम करने की अनुमति देता है, वह तय नहीं है। पिछले संस्करण के लिए निश्चित नहीं है, क्योंकि जावा 5 में एक लुक-पीछे बग है जो जावा 6 में तय किया गया था।

रेगेक्स सबसे छोटी स्ट्रिंग को ढूँढता है जिसके पास इनपुट स्ट्रिंग में हर स्थिति में कहीं और डुप्लिकेट सबस्ट्रिंग नहीं है। बाहर का कोड फ़िल्टरिंग का ध्यान रखता है।

(?=(.*?)(?=(.*))(?<=^(?!.*\1(?!\2$)).*))

चूंकि तार ओवरलैप हो सकते हैं, मैं पूरी चीज को लुक-फॉरवर्ड में घेरता हूं (?=...)।
(.*?) सबसे छोटी प्रतिस्थापन से खोजें
(?=(.*)) वर्तमान स्थिति को चिह्नित करने के लिए स्ट्रिंग के बाकी हिस्सों को पकड़ता है।
(?<=^(?!.*\1(?!\2$)).*)वैरिएबल-लेंथ लुक-बैक का अनुकरण है, जो कार्यान्वयन बग का लाभ उठाता है जो (?<=.*)लंबाई की जांच को पास करने की अनुमति देता है।
(?!.*\1(?!\2$))बस जाँचता है कि आप कहीं और एक ही विकल्प नहीं ढूँढ सकते। (?!\2$)मूल स्थिति जहां सबस्ट्रिंग मिलान किया जाता है को खारिज कर दिया।

बाहरी लुक-अराउंड निर्माण की सीमा नेस्टेड लुक-अराउंड निर्माण पर लागू नहीं होती है। इसलिए, नेस्टेड नेगेटिव लुक-फॉरवर्ड (?!.*\1(?!\2$))वास्तव में पूरे स्ट्रिंग की जांच करता है, न कि केवल लुक-पीछे की सही सीमा तक।

— n̴̖̋h̷͉a̷̭̿h̸̡̅ẗ̵̨d̷̰ĥ̷̳
स्रोत

2

Rebol, 136 बाइट्स

f: func[s][repeat n length? b: copy s[unless empty? x: collect[forall s[unless find next find b t: copy/part s n t[keep t]]][return x]]]

Ungolfed:

f: func [s] [
    repeat n length? b: copy s [
        unless empty? x: collect [
            forall s [
                unless find next find b t: copy/part s n t [keep t]
            ]
        ][return x]
    ]
]

उपयोग उदाहरण:

>> f ""       
== none

>> f "abcaa"
== ["b" "c"]

>> f "rererere"
== ["ererer"]

>> f "asdfasdfd"
== ["fa" "fd"]

>> f "ffffhhhhfffffhhhhhfffhhh"
== ["hffff" "fffff" "hhhhh" "hfffh"]

>> f "asdfdfasddfdfaddsasadsasadsddsddfdsasdf"
== ["fas" "fad" "add" "fds"]

एनबी। मुझे लगता है कि कोड का दिल यह है कि findभाग कैसे काम कर रहा है। उम्मीद है कि यह समझाने में मदद करेगा ...

>> find "asdfasdfd" "df"
== "dfasdfd"

>> next find "asdfasdfd" "df"
== "fasdfd"

>> find next find "asdfasdfd" "df" "df"
== "dfd"

>> ;; so above shows that "df" is present more than once - so not unique
>> ;; whereas below returns NONE because "fa" found only once - ie. bingo!

>> find next find "asdfasdfd" "fa" "fa"
== none

— draegtun
स्रोत

1

हास्केल, 119

f s=[r|n<-[1..length s],l<-[map(take n)$take(length s-n+1)$iterate(drop 1)s],r<-[[j|j<-l,[j]==[r|r<-l,r==j]]],r/=[]]!!0

— गर्वित हेकलर
स्रोत

आप q = lengthकहीं भी रख सकते हैं और उपयोग कर सकते हैं q, कुछ बाइट्स को बंद कर सकते हैं

— रॉबुआ

1

ब्रेकीलॉग , 10 बाइट्स

sᶠ≡ᵍ~gˢlᵍt

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

sᶠ            The list of every substring of the input
  ≡ᵍ          grouped by identity,
    ~gˢ       with length-1 groups converted to their elements and other groups discarded,
       lᵍ     and grouped by their length,
         t    has the output as its last group.

हालाँकि ᵍयह स्वाभाविक रूप से उस मूल्य के आधार पर क्रमबद्ध नहीं होता है, जिसके द्वारा समूहों को प्रत्येक मूल्य की पहली घटना से क्रमबद्ध किया जाता है, हर लंबाई की पहली घटना घटते क्रम में होती है। मुझे 100% यकीन नहीं है कि विशिष्टता को फ़िल्टर करने में यह गड़बड़ नहीं हो सकती है, लेकिन मैं एक परीक्षण मामले के साथ नहीं आया हूं जो अभी तक विफल रहता है।

— असंबंधित स्ट्रिंग
स्रोत

1

05AB1E , 10 बाइट्स

Œʒ¢}é.γg}н

एक रिक्त स्ट्रिंग के लिए कुछ भी नहीं आउटपुट।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Œ           # Get all substrings of the (implicit) input-String
 ʒ          # Filter it by:
  ¢         #  Count how many times the current substring occurs in the (implicit) input-String
            #  (only 1 is truthy in 05AB1E, so the filter will leave unique substrings)
   }é       # After the filter: sort the remaining substrings by length
     .γg}   # Then group them by length as well
         н  # And only leave the first group containing the shortest substrings
            # (which is output implicitly as result)

यह 05AB1E का केवल सत्य 1मूल्य के रूप में लाभ उठाता है , और बाकी सब कुछ गलत है। सबसे छोटा अनोखा विकल्प हमेशा सभी संभावित इनपुट-स्ट्रिंग्स के लिए एक बार होने की गारंटी है। (केवल उसी वर्ण (यानी aaaaa) वाले इनपुट-स्ट्रिंग के लिए, इनपुट-स्ट्रिंग्स स्वयं के रूप में स्ट्रिंग बस एक बार होती है, इसलिए परिणाम होता है ["aaaaa"]। दोहराए जाने वाले पैटर्न (यानी "abcabc") के साथ एक इनपुट-स्ट्रिंग के लिए , अभी भी अद्वितीय सबस्ट्रिंग हैं। एक बार हो ( ["abca","abcab","abcabc","bca","bcab","bcabc","ca","cab","cabc"]), तो यह परिणाम देगा ["ca"]।)

— केविन क्रूज़सेन
स्रोत

0

अजगर 2, 150

import re
a=input()
r=range
l=len(a)
d=0
for i in r(l):
 if d:break
 for j in r(l-i):
  k=a[j:i+j+1]
  if len(re.findall("(?="+k+")",a))<2:d=1;print k

— KSFT
स्रोत

ग्रे क्षेत्र, इसे प्रिंट करना चाहिए "", लेकिन आप कुछ भी नहीं प्रिंट करते हैं।

— जकुबे

1

@Jakube "आउटपुट का सटीक स्वरूपण लचीला है"

— KSFT

लेकिन आपके पास कोई आउटपुट नहीं है।

— जकुबे

2

@ जाकुब यह रिक्त स्ट्रिंग है, जैसे यह माना जाता है। मेरे पास इसके आसपास उद्धरण नहीं हैं।

— KSFT

1

@Jakube मैं इसकी अनुमति दूंगा, क्योंकि खाली स्ट्रिंग वैसे भी एक विशेष मामला है।

— जर्गब

0

पर्ल 5 `-a` , 114 87 बाइट्स

map{//;(grep$' eq$_,@q)-1||($l||=y///c)-y///c||say}@q=map{"@F"=~/(?=(.{$_}))/g}1..y///c

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

पुरानी विधि: 114 बाइट्स

— Xcali
स्रोत

सबसे छोटा अनोखा सबस्ट्रिंग

इनपुट

उत्पादन

उदाहरण

नियम

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

लीडरबोर्ड

पायथ, 27 26 बाइट्स

स्पष्टीकरण:

पायथन 3, 124 123 111 96 बाइट्स

मैथेमेटिका, 95 94 79 बाइट्स

GolfScript, 44 बाइट्स

विच्छेदन

CJam, 52 43 40 बाइट्स

स्काला, 120 बाइट्स

जावास्क्रिप्ट (ईएस 6), 109 110

जावा, 168 176 233

हास्केल, 169 162 155 153 151 138 120 115

J, 61 58 44 42 40 38 37 बाइट्स

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

PHP, 171 152 134 125

ग्रूवी (ओरेकल कार्यान्वयन पर जावा रेगेक्स), 124

Rebol, 136 बाइट्स

हास्केल, 119

ब्रेकीलॉग , 10 बाइट्स

05AB1E , 10 बाइट्स

अजगर 2, 150

पर्ल 5 -a , 114 87 बाइट्स

पर्ल 5 `-a` , 114 87 बाइट्स