Uma sequência de caracteres se repete se contiver duas substrings consecutivas equivalentes.

Por exemplo, 2034384538452repete-se, pois contém 3845duas vezes consecutivas.

Portanto, seu desafio é decidir se uma sequência contém uma subseqüência de substring. Você pode considerar a entrada como uma string ou uma matriz de caracteres.

Você nunca receberá uma entrada vazia e o comprimento da substring (se existir) pode ser 1 ou mais.

Eu uso 1e 0aqui como meus valores de verdade e falsidade, mas você pode usar valores diferentes, desde que eles sejam verdade e falsidade em seu idioma.

Exemplos:

abcab -> 0
bdefdefg -> 1
Hello, World! -> 1
pp.pp/pp -> 1
q -> 0
21020121012021020120210121020121012021012102012021020121012021020120210121020120210201210120210121020121012021020120210121020121012021012102012021020121012021012102012101202102012021012102012021020121012021020120210121020121012021012102012021020121012021020120210121020120210201210120210121020121012021020120210121020120210201210120210201202101210201210120210121020120210201210120210121020121012021020120210121020121012021012102012021020121012021020120210121020120210201210120210121020121012021020120 -> 0

(O último exemplo foi gerado a partir da quantidade de unidades entre cada zero na sequência Thue-Morse)

Retina , 6 bytes

(.+)\1

Experimente online!

Valor positivo para a verdade; zero para falsey.

Como funciona

Retorna o número de correspondências da regex /(.+)\1/g.

Braquilog , 3 bytes

s~j

Experimente online!

s~j
s    exists a sublist of input
 ~j  which is the result of a juxtaposition of something

Gelatina , 6 5 bytes

Ẇµ;"f

Este é um programa completo. O TIO não pode lidar com o último caso de teste sem truncá-lo.

Experimente online! (último caso de teste truncado para 250 dígitos)

Como funciona

Ẇµ;"f  Main link. Argument: s (string)

Ẇ      Words; generate all substrings of s.
 µ     New chain. Argument: A (substring array)
  ;"   Vectorized concatenation; concatenate each substring with itself.
    f  Filter; keep "doubled" substrings that are also substrings.
       This keeps non-empty string iff the output should be truthy, producing
       non-empty output (truthy) in this case and empty output (falsy) otherwise.

Mathematica, 32 bytes

StringMatchQ[___~~x__~~x__~~___]

Java, 27 bytes

a->a.matches(".*(.+)\\1.*")

Praticamente uma duplicata da resposta da Retina , mas não há como o Java ficar mais curto.

05AB1E , 5 bytes

Œ2×åZ

Experimente online!

Saídas 1 como valor verdadeiro e 0 como valor falso

Explicação

Œ2×åZ
Π    # Substrings of input
 2×   # duplicate them (vectorized)
   å  # Is the element in the input? (vectorized)
    Z # Maximum value from list of elements

Python , 38 bytes

import re
re.compile(r'(.+)\1').search

Experimente online!

Bocejo, um regex. Verifica se a sequência contém uma sequência de um ou mais caracteres, .+seguida pela mesma sequência que acabou de ser capturada. O objeto de pesquisa de saída é Truthy se houver pelo menos uma correspondência, como pode ser verificado por bool.

Usar compileaqui salva ao escrever um lambda:

lambda s:re.search(r'(.+)\1',s)

Python , 54 bytes

f=lambda s:s>''and(s in(s*2)[1:-1])|f(s[1:])|f(s[:-1])

Experimente online!

Procura por um substring que é composto de dois ou mais iguais cadeias concatenadas, como verificado por s in(s*2)[1:-1]como nos esta resposta . As seqüências de caracteres são geradas recursivamente escolhendo cortar o primeiro ou o último caractere. Isso é exponencial, portanto expira o tempo no caso de teste grande.

Quase acidentes:

f=lambda s,p='':s and(s==p)*s+f(s[1:],p+s[0])+f(s[:-1])
f=lambda s,i=1:s[i:]and(2*s[:i]in s)*s+f(s[1:])+f(s,i+1)

O primeiro não usa o Python inpara verificar substrings e, portanto, pode ser adaptado para outras linguagens.

Pitão - 10 9 8 bytes

f}+TTQ.:

Retorna uma lista de todas as substrings repetidas (que, se não houver alguma, é uma lista vazia, que é falsa)

Tente

Explicação:

f}+TTQ.:
      .:    # All substrings of the input (implicit):
f           # filter the list of substrings T by whether...
  +TT       # ...the concatenation of the substring with itself...
 }   Q      # ...is a substring of the input

Cheddar , 60 bytes

n->(|>n.len).any(i->(|>i).any(j->n.index(n.slice(j,i)*2)+1))

Experimente online!

PHP , 32 bytes

<?=preg_match('#(.+)\1#',$argn);

Experimente online!

PHP , 38 bytes

<?=preg_match('#(.+)(?(1)\1)#',$argn);

Experimente online!

Python 3 , 73 66 bytes

-7 bytes graças a @LeakyNun

lambda s:any(2*s[j:i]in s for i in range(len(s))for j in range(i))

Experimente online!

Perl 6 , 11 bytes

{?/(.+)$0/}

Teste-o

Expandido:

{        # bare block lambda with implicit parameter ｢$_｣

  ?      # Boolify the following
         # (need something here so it runs the regex instead of returning it)

  /      # a regex that implicitly matches against ｢$_｣
    (.+) # one or more characters stored in $0
     $0  # that string of characters again
  /
}

PHP, 32 bytes

<?=preg_match('#(.+)\1#',$argn);

Corra como cano com -F. Desculpe Jörg, eu não tinha notado que você postou o mesmo .

versão não regex, 84 82 bytes

    for($s=$argn;++$e;)for($i=0;~$s[$i];)substr($s,$i,$e)==substr($s,$e+$i++,$e)&&die

sai com o código de retorno 0para repetição, atinge o tempo limite (e sai com erro) para nenhum. Corra como cano com -nr.
assume entrada ASCII imprimível; substituir ~com a&qualquer ASCII.

JavaScript (ES6), 19 bytes

s=>/(.+)\1/.test(s)

Pitão, 15 bytes

.E.nm.bqNYtdd./

Tente!

V , 6 bytes

ø¨.«©±

Experimente online!

Suíte de teste!

O programa gera 0valores falsey e um número inteiro positivo para valores positivos.

(Observe que houve um pequeno bug, então eu tive que ganhar 1 byte. Agora, após a correção do bug, poderei substituir .«por \x82)

Explicação

ø                     " This is a recent addition to V. This command takes in a regex
                      " and replaces the line with the number of matches of the regex
 ¨.«©±                " The compressed regex. This decompresses to \(.\+\)\1

Japt, 8 + 1 = 9 8 bytes

f"(.+)%1

Experimente online . Saídas nullpara falsy, e uma matriz contendo todas as seqüências repetidas para truthy.

Explicação

 f"(.+)%1
Uf"(.+)%1" # Implicit input and string termination
Uf         # Find in the input
  "(.+)%1" #   a sequence followed by itself
 f         # and return the matched substring
           # output the return value

Queijo Cheddar, 16 bytes

@.test(/(.+)\1/)

Esta é uma função. Experimente online!