Cadena generadora más corta, lexicográficamente más pequeña

Una cadena x genera una cadena ysi yes una subcadena de una repetición infinita de x. Por ejemplo abcgenera bcabcab.

Escriba un programa para encontrar la cadena más corta, lexicográficamente más pequeña que generará la entrada. Se le da en la entrada estándar una sola línea de texto. Debe imprimir la cadena generadora a la salida estándar. Por ejemplo:

entrada

bcabcabca

salida

abc

El código más corto gana. Puede suponer que la entrada contiene solo los caracteres az (y una nueva línea final si lo desea).

Ruby 1.9, 40 caracteres

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

Asume que la entrada no es terminada por una nueva línea. También es probablemente ridículamente lento para obtener resultados más grandes.

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

Python 88 185 caracteres

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

Salida:

bcabcabca
abc

aaa
a

abc
abc

cccbbcccbbcccbb
bbccc

barfoofoobarfoofoo
arfoofoob

bacabac
abacbac

Haskell, 299 128 caracteres

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

Gracias a jloy! Ahora la versión es mucho más corta y creo que es correcta.

Python, 121 137 129 caracteres

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)

EDITAR: se corrigió el error detectado por JiminP

Ruby 1.9, 36

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

Utiliza el mismo enfoque que la solución de Ventero.

Pitón, 161 159 166 140 141 134 132 caracteres

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

EDITAR : Golfed el código después de leer el comentario de Jules Olléon. Se eliminó un 'error' que bcdabcdabda como resultado abbc.

EDIT2 : Se corrigió el error ( abaaresultados aaa) detectado por Jules Olléon.

No conozco bien Python, por lo que este código probablemente no sea "golf".

Amo esta regla:

Puede suponer que la entrada contiene solo los caracteres az ...

Salidas, entradas

bcdabcd
abcd

bcabcabca
abc


abcdabcd
abcd

bcdabcdab
abcd

barfoofoobarfoofoobar
arfoofoob

cccbbcccbbcccbb
bbccc

aaaaaaaaaaaaaaaa
a

thequickbrownfox
brownfoxthequick

ababa
ab

abaa
aab

Mathematica 124 bytes

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

Los espacios en blanco y las nuevas líneas (en presencia de punto y coma en los extremos de las líneas) no tienen significado en Mathematica y se incluyen aquí para facilitar la lectura.

La entrada va entre comillas en la primera línea. Si se relanza como una función, eso toma la entrada de cadena de la siguiente manera:

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" *)

entonces son 128 bytes.

El Forbucle toma los primeros icaracteres de la entrada y los repite al menos hasta la longitud de la entrada, luego verifica si la entrada es una subcadena del resultado. Habiendo encontrado la longitud del período de la cadena, el StringPartitioncomando concatena dos copias de ese período y toma todas las subcadenas de esa longitud (básicamente obtiene todas las permutaciones cíclicas), luego First@Sortencuentra la primera de ellas cuando se ordena lexicográficamente.

javascript 96 Chars.

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

Plunkr de trabajo