Isto é retirado desta questão (com permissão de curso). Vou citar:

Crie uma função que use uma string e ela retorne true ou false com base em se a entrada consiste em apenas uma sequência de caracteres repetida. O comprimento de uma determinada sequência é sempre maior que 1 e a sequência de caracteres deve ter pelo menos uma repetição.

Alguns exemplos:

'aa' //true
'aaa' //true
'abcabcabc' //true
'aba' //false
'ababa' //false
'weqweqweqweqweqw' // false

Especificamente, a verificação de uma string estritamente composta por substrings repetidos ( Update ) pode gerar qualquer representação verdadeira ou falsa, mas nenhum erro de saída, por favor. Strings estritamente alfanuméricos. Caso contrário, regras de golfe com código padrão. Este é o Code Golf, portanto, a resposta mais curta em bytes para cada idioma vence.

Braquilog , 4 3 bytes

ġ=Ṁ

Experimente online!

Explicação

ġ=Ṁ    Implicit input, say "abcabc"
ġ      Split into chunks of equal lengths (except maybe the last one): ["abc","abc"]
 =     Apply the constraint that all of the chunks are equal,
  Ṁ    and that there are multiple of them.

O programa imprime true.se as restrições podem ser satisfeitas e, false.se não.

JavaScript (ES6), 22 bytes

Retorna um valor booleano.

s=>/^(.*)\1+$/.test(s)

Experimente online!

Sem uma expressão regular,  33  29 bytes

Retorna null(falsy) ou um objeto (truthy).

s=>(s+s).slice(1,-1).match(s)

Experimente online!

Nota: tecnicamente, $s$ é convertido em uma expressão regular para match () , portanto o título acima é uma mentira.

grep, 19

grep -qxE '(.+)\1+'

Teste

while read; do 
  <<<"$REPLY" grep -qxE '(.+)\1+' && t="true" || t="false"
  echo "$REPLY: $t"
done < infile 

Saída:

aa: true
aaa: true
abcabcabc: true
aba: false
ababa: false
weqweqweqweqweqw: false

Japonês , 6 bytes

²é ¤øU

Guardou um byte graças a @Shaggy

Experimente online!

        Implicit input, stored in variable 'U'
²       U+U, "abcabc" -> "abcabcabcabc"
 é      Rotate 1 char to the right "abcabcabcabc" -> "cabcabcabcab"
   ¤    Remove first two chars, "cabcabcabcab" -> "bcabcabcab"
    øU  Check if U is in the above

Java, 25 24 bytes

-1 byte graças a Olivier Grégoire!
Resposta regex chata

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

Experimente online!

É apenas 1 byte a mais do que a resposta python aaaaa , estou empatado agora :)

Excel, 26 bytes

=FIND(A1,A1&A1,2)<=LEN(A1)

Entradas de A1, saídas para qualquer célula que você colocar nesta fórmula.

R , 28 bytes

grepl("(.+)\\1+$",scan(,''))

Experimente online!

Versão simples do Regex. R é (às vezes) muito semelhante ao Python, então isso é semelhante à resposta regex do TFeld no Python 2, embora mais curta!

Pergunta (se alguém souber a resposta)

Ainda estou confuso por que isso funciona, pois a substring pode ter qualquer tamanho e sempre funcionará, e ainda funciona quando adiciono uma letra à frente de uma string válida, como "cABABABABAB". Se eu pessoalmente ler o regex, vejo (.+), que captura qualquer grupo de qualquer tamanho. E depois\\1+$ que repete o grupo capturado inúmeras vezes até o final.

Então, por que ele não captura apenas "AB" e descobre que é repetido até o final da string, principalmente porque não há nenhuma restrição especificada sobre onde a substring pode começar?

Retina 0.8.2 , 9 bytes

^(.+)\1+$

Experimente online! O link inclui casos de teste.

Geléia ,  5  4 bytes

Vejo agora que a melhor maneira é seguir o método do xnor !

Ḋ;Ṗw

Um link monádico que aceita uma lista de caracteres e gera um número inteiro - o menor comprimento possível de uma fatia repetida ou zero, se não houver nenhum. Observe que zero é falsey, enquanto números diferentes de zero são verdadeiros no Jelly.

Experimente online!

Quão?

Ḋ;Ṗw - Link: list of characters, S   e.g. "abcabcabc"   or "abababa"
Ḋ    - dequeue S                           "bcabcabc"       "bababa"
  Ṗ  - pop from S                         "abcabcab"       "ababab"
 ;   - concatenate                "bcabcabcabcabcab"       "bababaababab"
   w - first index of sublist     3  ^---here!             0  (not found)

Perl 5 -p , 14 bytes

$_=/^(.*)\1+$/

Experimente online!

Python 2 , 24 bytes

lambda s:s in(s*2)[1:-1]

Experimente online!

Roubado descaradamente da resposta de xnor à pergunta original.

Versão mais intuitiva:

Python 2 , 59 55 53 bytes

lambda s:s in[len(s)/i*s[:i]for i in range(1,len(s))]

Experimente online!

Versão regex chata:

Python 2 , 44 bytes

lambda s:re.match(r'(.+)\1+$',s)>0
import re

Experimente online!

Wolfram Language (Mathematica) , 24 23 bytes

StringMatchQ[x__..~~x_]

Experimente online!

StringMatchQ[           (*a function that checks if its input (string) matches:*)
             x__..      (*a sequence of one or more characters, repeated one or more times*)
                  ~~x_] (*and one more time*)

Pyke , 4 bytes

+tO{

Experimente aqui!

+    -    input+input
 t   -   ^[1:]
  O  -  ^[:-1]
   { - input in ^

J , ^{26 25 15} 14 bytes

Usando o método xnor

+./@E.}:@}.@,~

Experimente online!

original (duas abordagens diferentes)

J , 25 bytes

1<1#.(#%#\)=<\+/@E.&:>"{]

Experimente online!

J , 26 bytes

1<1#.-@#\([:(-:##{.)<\)"{]

Experimente online!

PowerShell, 23 24 bytes

+1 byte para corresponder totalmente às regras

"$args"-match"^(.+)\1+$"

Experimente online!

Muito chato. Com base nas outras respostas do Regex. Felizmente, o PowerShell não usa \como caractere de escape!

C # (compilador interativo do Visual C #) , 70 bytes

adaptação descarada do xnor ( 46 bytes )

s=>(s+s).Substring(1,s.Length*2-2).Contains(s)

Minha solução não Regex:

s=>s.Select((x,y)=>y).Count(z=>s.Replace(s.Substring(0,z+1),"")=="")>1

Explicação:

Substitua todas as subseqüências possíveis iniciadas no índice 0 por uma sequência vazia. Se o resultado for uma sequência vazia, a sequência será totalmente composta dessa substring. Como isso inclui avaliar a sequência inteira com ela mesma, a quantidade de resultados esperados deve ser maior que 1.

Exemplo: abcabc

Possíveis substrings começando no índice 0:

'a', 'ab', 'abc', 'abca', 'abcab', 'abcabc'

Se os substituirmos por cadeias vazias

Substring          Result

'a'         =>     'bcbc'
'ab'        =>     'cc'
'abc'       =>     ''
'abca'      =>     'bc'
'abcab'     =>     'c'
'abcabc'    =>     ''

Como existe uma substring diferente de 'abcabc' que retorna uma string vazia, a string é totalmente composta de outra substring ('abc')

Experimente online!

Python 3 , 62 60 56 54 bytes

-4 bytes thanx ao ArBo

lambda s:s in(len(s)//l*s[:l]for l in range(1,len(s)))

1. Iterar sobre todos os prefixos possíveis na string.
2. Tente criar a string fora do prefixo.
3. Retorne se isso é bem-sucedido com qualquer prefixo.

Experimente online!

Japonês , 10 bytes

Retorna um número positivo se for verdade e 0 se falsey. Se você quiser uma saída bool, basta adicionar -¡sinalizador

å+ k@rXÃÊÉ

å+ k@rXÃÊÉ      Full program. Implicit input U.
                    e.g: U = "abcabcabc"
å+              Take all prefixes 
                         U = ["a","ab","abc","abca","abcab","abcabc","abcabca","abcabcab","abcabcabc"]
   k@           Filter U by:
     rXÃ        Values that return false (empty string)
                when replacing each prefix in U
                e.g: ["bcbcbc","ccc","","bcabc","cabc","abc","bc","c",""]
                                take ↑                             and ↑
                     U = ["abc","abcabcabc"]
         ÊÉ     Get U length and subtract 1. Then return the result

Experimente online!

Casca , 6 bytes

Ṡ€ȯhtD

Experimente online!

Sinto que esse é um byte a mais do que o ideal, mas não consegui encontrar um arranjo que tornasse a composição explícita ȯdesnecessária.

Explicação

Ṡ€      Find the argument in the result of applying the following function to the argument
  ȯhtD  Duplicate the argument, then remove the first and last elements.

Mathematica 11.x, 74 bytes

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&

onde, por toda parte # representa a sequência de entrada e

StringCases[#,<pattern>]

localiza substrings da string de entrada que correspondem ao padrão

StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="") 

Esse padrão requer correspondências, x deve começar no início da sequência e deve satisfazer a condição de que (1) a correspondência não é a sequência de entrada inteira e (2) se substituirmos as ocorrências da correspondência na sequência de entrada pela sequência vazia nós obtemos a string vazia. Por fim, comparando a lista de correspondências com a lista vazia,

{}!=

é True se a lista de correspondências não for vazia e Falsese a lista de correspondências estiver vazia.

Casos de teste:

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aa"]
(*  True  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aaa"]
(*  True  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["abcabc"]
(*  True  *)

e

{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aba"]
(*  False  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["ababa"]
(*  False  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["weqweqweqweqweqw"]
(*  False  *)

Python 3, 84 bytes

import textwrap
lambda s:any(len(set(textwrap.wrap(s,l)))<2 for l in range(1,len(s)))

Utiliza textwrap.wrap(graças a esta resposta ) para dividir a cadeia em pedaços de comprimento npara testar cada comprimento possível de substring repetido. As partes divididas são comparadas entre si adicionando-as a um conjunto. Se todas as peças forem iguais e o conjunto tiver comprimento 1, a sequência deverá ser repetida. Eu usei em <2vez de, ==1porque ele salva um byte, e o comprimento da string de entrada foi garantido maior que zero.

Se não houver nquais substrings repetidos de comprimento ncompõem a cadeia inteira, retorne false para toda a função.

05AB1E , 5 bytes

O método xnor da pergunta anterior também parece ótimo no 05AB1E.

«¦¨så

Experimente online! ou como um conjunto de testes

Explicação

«       # append input to input
 ¦¨     # remove the first and last character of the resulting string
   så   # check if the input is in this string

Limpar \ limpo , 73 bytes

Não usa regex.

import StdEnv,Data.List
$s=or[isPrefixOf s(cycle t)\\t<-tl(tails s)|t>[]]

Experimente online!

Define $ :: [Char] -> Bool.
Verifica se a string especificada é um prefixo da repetição de qualquer sub-string retirada do final.

C ++ (gcc) , 36 bytes

#define f(x)(x+x).find(x,1)<x.size()

Experimente online!

Outra porta da solução do xnor. Usa uma macro para expandir o argumento na expressão. O argumento é assumido como sendo do tipo std::string.

Variável QlikView, 27 bytes

Isso deve ser definido como uma variável, que permite passar parâmetros, por exemplo, $1como seu valor de entrada.

Ele retorna 0ou -1(equivalente à TRUE()função do QlikView ).

=substringcount($1&$1,$1)>2

Rápido, 196 bytes

func r(s:String)->Bool{guard let k=s.dropFirst().firstIndex(where:{$0==s.first}) else{return false};let v=s[...k].dropLast();var w=v;while s.hasPrefix(w) && s.count>=(w+v).count{w+=v};return s==w}

Experimente online!

Ícone , 46 bytes

procedure f(s);return find(s,(s||s)[2:-1]);end

Experimente online!

Outra porta da solução do xnor.

K (oK) , 29 bytes

{0<+/(1=#?:)'(0N,'1_!#x)#\:x}

Experimente online!

Vermelho , 72 bytes

func[s][repeat i length? s[parse s[copy t i skip some t end(return 1)]]]

Experimente online!

Retorna 1paraTrue

T-SQL, 47 bytes

Usando o método do @ Xnor :

DECLARE @ varchar(max)='ababab'

PRINT sign(charindex(@,left(@+@,len(@)*2-1),2))

Mantendo a resposta antiga, pois contém um bom jogo de golfe (67 bytes):

DECLARE @y varchar(max)='abababa'

,@ INT=0WHILE
replace(@y,left(@y,@),'')>''SET
@+=1PRINT @/len(@y)^1

Explicação: Este script está tentando repetidamente substituir a entrada '@y' pelos primeiros caracteres '@' da entrada '@y' por nada, enquanto aumenta '@'.

se você substituir 'ab' em 'ababab' por nada, você terá uma string vazia

Eventualmente, o resultado ficará vazio. Se isso acontecer quando a variável de loop for igual ao comprimento do varchar, o critério será falso / 0 porque '@' = len (@y) (não houve varchar repetido).

iif(@=len(@y),0,1)

pode ser jogado neste

@/len(@y)^1

porque o comprimento de '@y' não pode ser 0 e '@' nunca excederá o comprimento @y.

Experimente online