ATUALIZAÇÃO : O envio de Pyth de isaacg é o vencedor!

Muitos de vocês devem ter ouvido falar que existe uma versão mais legal do JavaScript na cidade (leia ES6), que possui um método String.prototype.repeatpara que você possa fazer

"Hello, World!".repeat(3)

e pegue

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

como a saída.

Seu trabalho é escrever uma função ou um programa em um idioma de sua escolha, que detecta se uma string foi submetida a essa transformação.

ou seja, a sequência de entrada pode ser representada como uma nrepetição exata de uma sequência menor. A saída (como instrução de retorno da função ou STDOUT) deve ser verdadeira se a sequência puder ser ou falsificada se a sequência não puder ser representada como uma repetição de uma sequência menor.

Alguma amostra de entrada:

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

Observe que a última entrada é falsa, portanto ndeve ser maior que1

Regras completas

• Escreva uma função / programa em qualquer idioma para inserir (via argumento da função / linha de comando args / STDIN) uma string
• Retorne / imprima o valor da verdade se a sequência especificada for formada através de uma repetição exata de uma sequência menor, repetindo pelo menos duas vezes.
• O tamanho máximo da sequência de entrada é idealmente Infinito
• A cadeia pode ter todos os caracteres ASCII possíveis
• Este é um código de golfe, pelo que o menor código em caracteres vence.

Pitão , 9

/:+zz1_1z

Ou

}z:+zz1_1

Ambas são traduções aproximadas da resposta python do @ xnor, exceto que elas recebem a entrada do STDIN e a imprimem. O primeiro é equivalente a:

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

0 para Falso, 1 para Verdadeiro.

A segunda linha é equivalente a:

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

Falso para Falso, Verdadeiro para Verdadeiro.

O compilador oficial do Pyth tinha um bug relacionado ao segundo, que acabei de corrigir, então o primeiro é o meu envio oficial.

Python (24)

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

Verifica se a cadeia de caracteres é uma subcadeia de si concatenada duas vezes, eliminando o primeiro e o último caracteres para evitar correspondências triviais. Se for, deve ser uma permutação cíclica não trivial de si mesma e, portanto, a soma de segmentos repetidos.

Regex (sabor ECMAScript), 11 bytes

Parece um trabalho para regex!

^([^]+)\1+$

Teste aqui.

Eu escolhi o ECMAScript, porque é o único sabor (eu sei) que [^]corresponde a qualquer caractere. Em todos os outros, eu precisaria de um sinalizador para alterar o comportamento .ou usar [\s\S]três caracteres a mais.

Dependendo de como contamos a bandeira, é claro que isso pode ser um byte mais curto. Por exemplo, se estivermos contando padrão + sinalizadores (por exemplo, ignorando delimitadores), o equivalente PCRE / Perl será

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

Qual é 10 bytes, ignorando os delimitadores.

Teste aqui.

Isso corresponde apenas às seqüências de caracteres que consistem em pelo menos duas repetições de alguma substring.

Aqui está uma função ES6 completa de 26 bytes, mas afirmo que os envios de expressões regulares geralmente são válidos:

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

CJam, 9

q__+)@+#)

Semelhante à idéia 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←⍞

A explicação
⍞ utiliza a entrada de seqüência de caracteres da tela
x←atribuída à variável x
,⍨concatena a seqüência de caracteres que ela
x⍷procura xna sequência resultante. Retorna uma matriz que consiste em 1 na posição inicial de uma partida e 0 em outro lugar.
+/soma a matriz,
2<verifique se a soma é maior que 2 (pois haverá 2 correspondências triviais)

CJam, 10 bytes

Eu peguei o bug CJam. Minha primeira resposta, então provavelmente pode ser jogado um pouco mais:

q__+(;);\#

Saídas -1 para FALSE e um número> = 0 para TRUE

GolfScript, 10 bytes

..+(;);\?)

Mais uma implementação da idéia inteligente do xnor.

Python - 59 57

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

Festa pura, 30 bytes

Porta simples da resposta inteligente do @ xnor :

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

O código de saída é 0 para TRUE e 1 para FALSE:

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

Observe que =~dentro [[ ... ]]é o operador regex no bash . No entanto, "qualquer parte do padrão pode ser citada para forçá-lo a corresponder como uma sequência" . Então, como geralmente acontece com o bash, é muito importante fazer uma citação correta - aqui, queremos apenas verificar se há uma sub-correspondência de string e não uma correspondência de regex.

TI-BASIC - 32

Eu pensei em experimentar uma linguagem tokenizada. Execute com a string em Ans, retornará 0 se false e o comprimento da string repetida se true.

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

Incrível como é uma linha.

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

Certamente esta é a única solução válida? Por exemplo, a palavra (string) nananão é necessariamente criada a partir de"na".repeat(2)

ECMAScript 6 (34 36 )

Outra resposta do ES6, mas sem usar repeate usar o truque do xnor :

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

Deve ser executado no console de um navegador compatível com ES6, como o 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;}

Acabou sendo bastante longo, mas as funções externas são sempre assim. Me ocorreu que eu poderia reescrever todas as funções de string substituindo-as por um loop ou por uma recursiva. Mas na minha experiência, ficaria mais tempo e, francamente, não quero tentar isso.

Após algumas pesquisas, vi soluções de alto desempenho, mas não tão inteligentes (e curtas) quanto as do xnor. apenas para ser original ... reescrevi a mesma idéia em c.

explicação:

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 )

Não é um vencedor, mas parece que deveria haver pelo menos uma resposta realmente no ES6 para esta pergunta que realmente usa a repeatfunção:

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

Deve ser executado no console de um navegador compatível com ES6, como o Firefox.

Faz muitas iterações desnecessárias, mas por que prolongar apenas para evitar isso, certo?

• Editar # 1: salvou alguns bytes convertendo-o em uma função. Graças ao Optimizer!
• Edit # 2: Graças a hsl pelo truque do operador spread para economizar mais bytes!
• Edit # 3: E obrigado a Rob W. por mais 3 bytes!

Gelatina , 3 bytes

ṙJċ

Experimente online!

O mesmo que esta resposta (talvez o desafio posterior seja uma generalização dessa?).

Java 8, 28 bytes

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

Experimente online.

Explicação:

Verifica se a String de entrada corresponde ao regex, onde é String#matchesincluído implicitamente ^...$para corresponder à String inteira.
Explicação do próprio regex:

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

Portanto, basicamente verifica se uma substring é repetida duas ou mais vezes (suportando novas linhas).