Ingresso

Una stringa alfanumerica s.

Produzione

La stringa più corta che si verifica esattamente una volta come sottostringa (contigua) in s. Le occorrenze sovrapposte vengono considerate distinte. Se sono presenti più candidati della stessa lunghezza, è necessario emetterli tutti nell'ordine in cui si verificano. In questa sfida, la stringa vuota si presenta n + 1volte in una stringa di lunghezza n.

Esempio

Considera la stringa

"asdfasdfd"

La stringa vuota si presenta 10 volte al suo interno, quindi non è un candidato per occorrenza univoca. Ciascuna delle lettere "a", "s", "d", e "f"si verifica almeno due volte, in modo che non sono candidati sia. Sottostringhe "fa"e "fd"si verificano solo una volta e in questo ordine, mentre tutte le altre stringhe di lunghezza 2 si verificano due volte. Quindi l'output corretto è

["fa","fd"]

Regole

Sono consentite sia le funzioni che i programmi completi e le scappatoie standard non lo sono. L'esatta formattazione dell'output è flessibile, entro limiti ragionevoli. In particolare, non è consentito produrre output per la stringa vuota, ma non è possibile generare un errore. Vince il conteggio dei byte più basso.

Casi test

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

Classifica

Ecco la classifica linguistica che ho promesso.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

# 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>

Pyth, 27 26 byte

&zhfTmf!/>zhxzYYm<>zkdUzUz

Provalo qui.

Si noti che a causa di un bug nel compilatore online, il caso stringa vuota funziona correttamente solo sulla versione della riga di comando, che può essere trovata qui.

Puoi anche curare il bug dando una nuova riga come input per il compilatore online.

Spiegazione:

                                   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.

Python 3, 124 123 111 96 byte

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)

Cerca le stringhe in modo tale che la prima occorrenza da sinistra sia uguale alla prima occorrenza da destra. La +1in rangeè per ospitare il caso stringa vuota.

Ora se solo Python avesse avuto un .count()conteggio delle partite sovrapposte , allora sarebbe stato un po 'più breve.

Mathematica, 95 94 79 byte

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

StringCasesmi dà tutte le sottostringhe possibili, Tallye Casesfiltra quelle che appaiono più di una volta e MinimalBytrova quelle che sono le più corte.

GolfScript, 44 byte

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

Accetta input come stringa su stdin e output in una sintassi a doppio array: ad es [["b"] ["c"]]. Demo online

Dissezione

: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

Questo è organizzato in modo tale che non è richiesto alcun caso speciale per la stringa vuota (che ho incluso come caso di prova nella demo online collegata sopra).

CJam, 52 43 40 byte

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

L'input è la stringa senza virgolette

Spiegazione :

]]                                       "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";

Esempio:

asdfdfasddfdfaddsasadsasadsddsddfdsasdf

Produzione

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

Provalo online qui

Scala, 120 byte

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

Ho iniziato con 140 che almeno si inserisce già in un tweet.

(                                        // 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
)

JavaScript (ES6), 109 110

Modifica la ricerca invece di indexOf, poiché la stringa di input è alfanumerica. Grazie @IsmaelMiguel

Funzione ricorsiva, ricerca di sottostringhe che iniziano con la lunghezza 1 e salgono.

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]

Ungolfed e spiegato

 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
 }

Test nella console FireFox / FireBug

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

Produzione

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

Java, 168 176 233

Ecco un esempio di loop nidificato piuttosto semplice.

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++;}}

O un po ' più leggibile:

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++;
            }
}

Haskell, 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)

Per usarlo:

f "asdfdfasddfdfaddsasadsasadsddsddfdsasdf"

Che dà:

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

Btw. Odio l'ultima riga del mio codice (ripetizione di h y). Qualcuno suggerisce di sbarazzarsene?

J, 61 58 44 42 40 38 37 byte

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

Ecco una versione suddivisa nei singoli componenti della soluzione:

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

• x #/. ycalcola per ogni elemento distinto in xquanto spesso si verifica in y. Se usiamo questo come y #/. y, otteniamo il per ogni elemento distinto nel ysuo conteggio. Ad esempio, a #/. aper i a =. 1 2 2 3 4 4rendimenti 1 2 1 2.
• 1 = ycontrolla quali elementi ysono uguali 1. Ad esempio, i 1 = a #/. arendimenti 1 0 1 0.
• u~è il riflesso di un verbo monadico u. Questo è, u~ yè lo stesso di y u y. Quindi, #/.~ yè lo stesso di #/.~ y. Se applicato a un verbo diadico, u~è il passivo di u. Cioè, x u~ yè lo stesso di y u x. Questi sono usati in parecchi altri posti che non menziono esplicitamente.
• ~. yè il nocciolo di y, un vettore con i duplicati rimossi. Ad esempio, i ~. arendimenti 1 2 3 4.
• x # y( copia ) seleziona dagli yelementi negli indici in cui xcontiene a 1.
• Pertanto, (1 = y #/. y) # (~. y)crea un vettore di quegli elementi di ycui appaiono una sola volta. In tacita notazione, questo verbo è scritto come ~. #~ 1 = #/.~; chiamiamo questa frase unqsper il resto della spiegazione.

• x ]\ ycrea un xda 1 + y - xarray di tutti infissi del vettore ydi lunghezza x. Ad esempio, i 3 ]\ 'asdfasdfdrendimenti

  asd
  sdf
  dfa
  fas
  asd
  sdf
  dfd
  

• # yè il conteggio di y, cioè il numero di elementi in y.

• u\ ysi applica ua ciascun prefisso di y. Per inciso, #\ ycrea un vettore di numeri interi da 1a #y.
• < ymette yin una scatola. Ciò è necessario perché le matrici non possono essere sfilacciate e calcoliamo una serie di suffissi di lunghezze diverse; un array inscatolato conta come uno scalare.

• Pertanto, (i. # y) <@:unqs@(]\) ygenera un vettore di #yarray inscatolati della lunghezza k (per tutti 0 ≤ k < #y) infissi di y che si verificano esattamente una volta. La forma tacita di questo verbo è i.@# <@unqs@(]\) ]o i.@# <@(~. #~ 1 = #/.~)@(]\) ]se non usiamo il unqsnome. Chiamiamo questa frase allsbsqper il resto di questa spiegazione. Ad esempio, allsbsq 'asdfasdfd'produce:

  ┌┬─┬──┬───┬────┬─────┬──────┬───────┬────────┐
  ││ │fa│dfa│sdfa│asdfa│asdfas│asdfasd│asdfasdf│
  ││ │fd│fas│dfas│sdfas│sdfasd│sdfasdf│sdfasdfd│
  ││ │  │dfd│fasd│dfasd│dfasdf│dfasdfd│        │
  ││ │  │   │sdfd│fasdf│fasdfd│       │        │
  ││ │  │   │    │asdfd│      │       │        │
  └┴─┴──┴───┴────┴─────┴──────┴───────┴────────┘
  

• (#@> y) # yprende dal vettore di array inscatolati yquelli che non sono vuoti.

• {. yprende il primo elemento del vettore y.
• > yrimuove la casella da y.
• Pertanto, > {. (#@> y) # yproduce il primo array non vuoto non boxato dal vettore di array boxed y. Questa frase è scritta >@{.@(#~ #@>)in tacita notazione.

• Infine, [: >@{.@(#~ #@>) allsbsqassembla la frase precedente con allsbsqper creare una soluzione al problema che abbiamo. Ecco la frase completa con spazi:

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

Haskell, 135 byte

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]]

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

Groovy (regex Java su implementazione Oracle), 124

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

Testato su Groovy 2.4 + Oracle JRE 1.7. Il regex dovrebbe funzionare da Java 6 a Java 8, poiché il bug che consente al codice sopra di funzionare non è stato risolto. Non sono sicuro per la versione precedente, poiché esiste un bug look-behind in Java 5 che è stato corretto in Java 6.

Il regex trova la stringa più corta che non ha una sottostringa duplicata altrove, in ogni posizione nella stringa di input. Il codice esterno si occupa del filtraggio.

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

• Dato che le stringhe possono sovrapporsi, circondo il tutto in prospettiva (?=...).
• (.*?) ricerche dalla sottostringa più breve
• (?=(.*)) cattura il resto della stringa per contrassegnare la posizione corrente.
• (?<=^(?!.*\1(?!\2$)).*)è un'emulazione di look-behind a lunghezza variabile, che sfrutta il bug di implementazione che consente (?<=.*)di superare il controllo della lunghezza.

• (?!.*\1(?!\2$))verifica semplicemente che non sia possibile trovare la stessa sottostringa altrove. Il (?!\2$)respinge la posizione originale in cui è abbinato lo stringa.

  Il limite del costrutto look-around esterno non si applica al costrutto look-around nidificato. Pertanto, il look-look negativo nidificato in (?!.*\1(?!\2$))realtà controlla l'intera stringa, non solo fino al limite destro del look-behind.

Rebol, 136 byte

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]
    ]
]

Esempio di utilizzo:

>> 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"]

NB. Suppongo che il cuore del codice sia come funziona la findparte. Spero che questo possa aiutare a spiegare ...

>> 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

Haskell, 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

Brachylog , 10 byte

sᶠ≡ᵍ~gˢlᵍt

Provalo online!

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.

Anche ᵍse non ordina in base al valore in base al quale raggruppa, invece ordina i gruppi in base alla prima occorrenza di ciascun valore, le prime occorrenze di ogni lunghezza sono in ordine decrescente. Non sono sicuro al 100% che il filtro di unicità non sia in grado di rovinare tutto, ma non ho ancora trovato un caso di prova che fallisce.

05AB1E , 10 byte

Œʒ¢}é.γg}н

Non restituisce nulla per una stringa vuota.

Provalo online o verifica tutti i casi di test .

Spiegazione:

Π          # 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)

Questo sfrutta il fatto che 05AB1E ha solo 1il valore di verità e tutto il resto come falsità. La sottostringa unica più corta è sempre garantita per verificarsi esattamente una volta per tutte le possibili stringhe di input. (Per una stringa di input contenente solo gli stessi caratteri (ie aaaaa), le stringhe di input stesse come sottostringa si verificano una sola volta, quindi il risultato è ["aaaaa"]. Per una stringa di input con pattern ripetitivo (cioè "abcabc"), ci sono ancora sottostringhe uniche che solo si verifica una volta ( ["abca","abcab","abcabc","bca","bcab","bcabc","ca","cab","cabc"]), quindi ciò comporterà ["ca"].)

Python 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

Perl 5 -a , 114 87 byte

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

Provalo online!

Vecchio metodo: 114 byte