Corda generatrice più corta, lessicograficamente più piccola

Una stringa x genera una stringa yse yè una sottostringa di una ripetizione infinita di x. Ad esempio abcgenera bcabcab.

Scrivi un programma per trovare la stringa più breve, lessicograficamente più piccola, che genererà l'input. In input standard viene fornita una singola riga di testo. È necessario stampare la stringa di generazione sull'output standard. Per esempio:

ingresso

bcabcabca

produzione

abc

Il codice più corto vince. Puoi supporre che l'input contenga solo i caratteri az (e una nuova riga finale se vuoi).

Ruby 1.9, 40 caratteri

gets;a=?a;a.next!until(a*~/$/)[$_];$><<a

Presuppone che l'input non sia terminato da una nuova riga. Inoltre è probabilmente ridicolmente lento per risultati più grandi.

$ echo -n "bcabcabca" | ruby genlex.rb 
abc
$ echo -n "barfoobarfoobarfoo" | ruby1.9 genlex.rb 
arfoob

Python 88 185 caratteri

import re
s=raw_input()
m=s.index(min(s))
s=s[m:]+s[:m]
i=0
while s.replace(s[:i],''):i+=1
m=min(s[:i])
s=re.findall('%s[\w]*?(?=%s|$)'%(m,m),s[:i])
m=s.index(min(s))
print ''.join(s[m:]+s[:m])

Produzione:

bcabcabca
abc

aaa
a

abc
abc

cccbbcccbbcccbb
bbccc

barfoofoobarfoofoo
arfoofoob

bacabac
abacbac

Haskell, 299 128 caratteri

import Data.List
main=interact(\z->minimum$filter(\w->isInfixOf z$concat$replicate(length z)w) $filter((/=)"")$inits=<<tails z)

Grazie a Jloy! Ora la versione è molto più corta e credo sia corretta.

Python, 121 137 129 caratteri

s=raw_input()
n=len(s)
l=[(s+s)[i/n:i/n+i%n+1]for i in range(n*n)]
print min(filter(lambda x:(x*len(s)).find(s)+1,sorted(l)),key=len)

EDIT: corretto il bug individuato da JiminP

Ruby 1.9, 36

$><<(?a..gets).find{|s|(s*~/$/)[$_]}

Utilizza lo stesso approccio della soluzione Ventero.

Pitone, 161 159 166 140 141 134 132 caratteri

y=raw_input();i=n=l=len(y)
while i:
 if (y[:i]*l)[:l]==y:n=i
 i-=1
x=y[:n];y=x*2
while i<n:
 x=min(x,y[i:i+n])
 i+=1
print x

EDIT : golfato il codice dopo aver letto il commento di Jules Olléon. Rimosso un "bug" che bcdabcdabrisulta abbc.

EDIT2 : corretto il bug ( abaarisultati aaa) individuato da Jules Olléon.

Non conosco bene Python, quindi questo codice probabilmente non è "golfato".

Adoro questa regola:

Si può presumere che l'input contenga solo i caratteri az ...

Entrate uscite

bcdabcd
abcd

bcabcabca
abc


abcdabcd
abcd

bcdabcdab
abcd

barfoofoobarfoofoobar
arfoofoob

cccbbcccbbcccbb
bbccc

aaaaaaaaaaaaaaaa
a

thequickbrownfox
brownfoxthequick

ababa
ab

abaa
aab

Mathematica 124 byte

x = StringLength@(y = "");
For[i = 1, ! (s = y~StringTake~i)~StringRepeat~x~StringContainsQ~y,i++];
First@Sort@StringPartition[s <> s, i, 1]

Gli spazi bianchi e le nuove righe (in presenza di punti e virgola alle estremità delle righe) non hanno significato in Mathematica e sono inclusi qui per la leggibilità.

L'input va tra le virgolette nella prima riga. Se rifuso come una funzione, questo accetta l'input di stringa in questo modo:

f=(x=StringLength@(y=#);For[i=1,!(s=y~StringTake~i)~StringRepeat~x~StringContainsQ~y,i++];First@Sort@StringPartition[s<>s,i,1])&

f@"bca"

(* "abc" *)

f@"abaa"

(* "aab" *)

quindi sono 128 byte.

Il Forloop prende i primi icaratteri dell'input e li ripete almeno fino alla lunghezza dell'input, quindi controlla se l'input è una sottostringa del risultato. Avendo trovato la lunghezza del periodo della stringa, il StringPartitioncomando concatena due copie di quel periodo e prende tutte le sottostringhe di quella lunghezza (fondamentalmente ottiene tutte le permutazioni cicliche), quindi First@Sorttrova la prima quando viene ordinata lessicograficamente.

javascript 96 caratteri.

var temp = {},len = str.length;
for(i in str) 
temp[str[i]] = true;
Object.keys(temp).join(""); 

Working Plunkr