ACTUALIZACIÓN : ¡la presentación Pyth de isaacg es la ganadora!

Muchos de ustedes deben haber escuchado que hay una versión más fresca de JavaScript en la ciudad (lea ES6) que tiene un método String.prototype.repeatpara que puedan hacer

"Hello, World!".repeat(3)

y obten

"Hello, World!Hello, World!Hello, World!"

como la salida

Su trabajo es escribir una función o un programa en un idioma de su elección que detecte si una cadena se ha transformado.

es decir, la cadena de entrada se puede representar como una nrepetición de tiempos exactos de una cadena más pequeña. La salida (como la declaración de retorno de la función o STDOUT) debe ser veraz si la cadena puede ser o falsa si la cadena no se puede representar como una repetición de una cadena más pequeña.

Alguna entrada de muestra:

"asdfasdfasdf"  // true
"asdfasdfa"     // false
"ĴĴĴĴĴĴĴĴĴ"     // true
"ĴĴĴ123ĴĴĴ123"  // true
"abcdefgh"      // false

Tenga en cuenta que la última entrada es falsa, por lo tanto, ndebe ser mayor que1

Reglas completas

• Escriba una función / programa en cualquier idioma para ingresar (mediante argumento de función / línea de comando args / STDIN) una cadena
• Devuelve / Imprime un valor verdadero si la cadena dada se forma a través de una repetición exacta de una cadena más pequeña, repitiéndose al menos dos veces.
• El tamaño máximo de la cadena de entrada es idealmente Infinito
• La cadena puede tener todos los caracteres ASCII posibles
• Este es un código de golf por lo que gana el código más pequeño en caracteres.

Pyth , 9

/:+zz1_1z

O

}z:+zz1_1

Ambas son traducciones cercanas de la respuesta de Python de @ xnor, excepto que toman información de STDIN y la imprimen. El primero es equivalente a:

z = input()
print((z+z)[1:-1].count(z))

0 para falso, 1 para verdadero.

La segunda línea es equivalente a:

z = input()
print(z in (z+z)[1:-1])

Falso por Falso, Verdadero por Verdadero.

El compilador oficial de Pyth tenía un error relacionado con el segundo, que acabo de reparar, así que el primero es mi presentación oficial.

Pitón (24)

lambda s:s in(s+s)[1:-1]

Comprueba si la cadena es una subcadena de sí misma concatenada dos veces, eliminando el primer y el último carácter para evitar coincidencias triviales. Si es así, debe ser una permutación cíclica no trivial de sí mismo y, por lo tanto, la suma de segmentos repetidos.

Regex (sabor ECMAScript), 11 bytes

Suena como un trabajo para expresiones regulares!

^([^]+)\1+$

Pruébalo aquí.

Elegí ECMAScript, porque es el único sabor (lo sé) en el que [^]coincide con cualquier personaje. En todos los demás, necesitaría una bandera para cambiar el comportamiento .o usar [\s\S]tres caracteres más largos.

Dependiendo de cómo contamos la bandera, eso podría ser, por supuesto, un byte más corto. Por ejemplo, si estamos contando patrón + banderas (por ejemplo, ignorando delimitadores), el equivalente de PCRE / Perl sería

/^(.+)\1+$/s

Que es de 10 bytes, ignorando los delimitadores.

Pruébalo aquí.

Esto solo coincide con cadenas que consisten en al menos dos repeticiones de alguna subcadena.

Aquí hay una función ES6 completa de 26 bytes, pero mantengo que los envíos de expresiones regulares son generalmente válidos:

f=s->/^([^]+)\1+$/.test(s)

CJam, 9

q__+)@+#)

Similar a la idea de xnor.

q      " Read input. ";
__+    " Duplicate twice and concatenate them together. ";
)      " Remove the last character of the longer string. ";
@+     " Insert that character at the beginning of the shorter string. ";
#)     " Find the shorter string in the longer string, and increase by one. ";

APL, 11

2<+/x⍷,⍨x←⍞

La explicación
⍞ toma la entrada de la cadena desde las asignaciones de la pantalla
x←a la variable x
,⍨concatena la cadena con la propia
x⍷búsqueda xen la cadena resultante. Devuelve una matriz que consta de 1 en la posición inicial de una coincidencia y 0 en otro lugar.
+/suma la
2<verificación de la matriz si la suma es mayor que 2 (ya que habrá 2 coincidencias triviales)

CJam, 10 bytes

Capté el error de CJam. Mi primera respuesta, por lo que probablemente pueda jugar un poco más:

q__+(;);\#

Salidas -1 para FALSO y un número> = 0 para VERDADERO

GolfScript, 10 bytes

..+(;);\?)

Otra implementación más de la inteligente idea de xnor.

Python - 59 57

lambda s:any([s*n==s[:n]*len(s)for n in range(2,len(s))])

Bash puro, 30 bytes

Puerto simple de la respuesta inteligente de @xnor :

[[ ${1:1}${1:0: -1} =~ "$1" ]]

El código de salida es 0 para VERDADERO y 1 para FALSO:

$ for s in 'Hello, World!Hello, World!Hello, World!' 'asdfasdfasdf' 'asdfasdfa' 'ĴĴĴĴĴĴĴĴĴ' 'ĴĴĴ123ĴĴĴ123' 'abcdefgh'; do echo "./isrepeated.sh "\"$s\"" returns $(./isrepeated.sh "$s"; echo $?)"; done
./isrepeated.sh "Hello, World!Hello, World!Hello, World!" returns 0
./isrepeated.sh "asdfasdfasdf" returns 0
./isrepeated.sh "asdfasdfa" returns 1
./isrepeated.sh "ĴĴĴĴĴĴĴĴĴ" returns 0
./isrepeated.sh "ĴĴĴ123ĴĴĴ123" returns 0
./isrepeated.sh "abcdefgh" returns 1
$ 

Nota =~dentro [[ ... ]]es el operador de expresiones regulares en bash . Sin embargo, "se puede citar cualquier parte del patrón para forzarlo a que coincida como una cadena" . Entonces, como a menudo es el caso con bash, es muy importante hacer una cita correcta: aquí solo queremos verificar si hay una subcoincidencia de cadenas y no una coincidencia de expresiones regulares.

TI-BASIC - 32

Pensé en probar un lenguaje tokenizado. Ejecutar con la cadena en Ans, devuelve 0 si es falso y la longitud de la cadena repetida si es verdadero.

inString(sub(Ans+Ans,1,2length(Ans)-1),sub(Ans,length(Ans),1)+Ans

Increíble cómo es una línea.

ECMAScript 6 (189)

(function(){var S=String.prototype,r=S.repeat;S.isRepeated=function(){return!1};S.repeat=function(c){var s=new String(r.call(this,c));if(c>1)s.isRepeated=function(){return!0};return s}}());

< console.log("abc".isRepeated(),"abc".repeat(10).isRepeated());
> false true

¿Seguramente esta es la única solución válida? Por ejemplo, la palabra (cadena) nanano se crea necesariamente a partir de"na".repeat(2)

ECMAScript 6 (34 36 )

Otra respuesta de ES6, pero sin usar repeaty usar el truco de xnor :

f=i=>(i+i).slice(1,-1).contains(i)

Debe ejecutarse en la consola de un navegador compatible con ES6 como Firefox.

C 85

l,d;f(s){return l=strlen(s),strstr(d,strcpy(strcpy(d=alloca(l*2+1),s)+l,s)-1)-d-l+1;}

Resultó ser bastante largo, pero las funciones externas siempre son así. Se me ocurrió que podía reescribir cada función de cadena reemplazándolas por un bucle o una recursiva. Pero en mi experiencia, sería más largo y, francamente, no quiero probar eso.

Después de investigar un poco, vi soluciones de alto rendimiento pero no tan inteligentes (y cortas) como las de xnor. solo para ser original ... reescribí la misma idea en c.

explicación:

int length, 
    duplicate;
int is_repetition(char *input)
{
    // length = "abc" -> 3
    length = strlen(input);
    // alloca because the function name is as long as "malloc" 
    // but you don't have to call free() because it uses the stack
    // to allocate memory
    // duplicate = x x x x x x + x
    duplicate = alloca(length*2 + 1);
    // duplicate = a b c 0 x x + x
    strcpy(duplicate, input);
    // duplicate = a b c a b c + 0
    strcpy(duplicate + length, input);
    if (strstr(duplicate,duplicate + length - 1) != duplicate + length - 1)
        // repetition
        // e.g. abab -> abababab -> aba[babab]
        // -> first occurence of [babab] is not aba[babab]
        // but a[babab]ab -> this is a repetition
        return 1;
    else
        // not repetition
        // e.g. abc -> abcabc -> ab[cabc]
        // -> first occurence of [cabc] is ab[cabc]
        // it matches the last "cabc"
        return 0;
}

ECMAScript 6 (59 62 67 73 )

No es un ganador, pero parece que al menos debería haber una respuesta en ES6 para esta pregunta que realmente use la repeatfunción:

f=i=>[...i].some((_,j)=>i.slice(0,j).repeat(i.length/j)==i)

Debe ejecutarse en la consola de un navegador compatible con ES6 como Firefox.

Hace muchas iteraciones innecesarias, pero ¿por qué alargarlo solo para evitar eso, verdad?

• Edición n. ° 1: guardado unos pocos bytes al convertirlo en una función. Gracias a Optimizer!
• Edición n. ° 2: ¡ Gracias a hsl por el truco del operador de propagación para guardar más bytes!
• Edición # 3: ¡ Y gracias a Rob W. por otros 3 bytes!

Jalea , 3 bytes

ṙJċ

Pruébalo en línea!

Igual que esta respuesta (¿quizás el desafío posterior sea una generalización de esta?).

Java 8, 28 bytes

s->s.matches("(?s)(.+)\\1+")

Pruébalo en línea.

Explicación:

Comprueba si la cadena de entrada coincide con la expresión regular, donde se String#matchesagrega implícitamente ^...$para que coincida con la cadena completa.
Explicación de la expresión regular en sí:

^(s?)(.+)\1+$
^                Begin of the string
 (s?)            Enable DOTALL-mode, where `.` also matches new-lines
     (           Open capture group 1
      .+          One or more characters
        )        Close capture group 1
         \1+     Plus the match of the capture group 1, one or more times
            $    End of the string

Por lo tanto, básicamente verifica si una subcadena se repite dos o más veces (admite nuevas líneas).