Una cadena de caracteres se repite si contiene dos subcadenas consecutivas que son equivalentes.

Por ejemplo, 2034384538452 repite ya que contiene 3845dos veces, consecutivamente.

Por lo tanto, su desafío es decidir si una cadena contiene una subcadena repetida. Puede tomar la entrada como una cadena o una matriz de caracteres.

Nunca recibirá una entrada vacía, y la longitud de la subcadena (si existe) puede ser 1 o más.

Utilizo 1y 0aquí como mis valores de verdad y falsedad, pero puede usar valores diferentes, siempre que sean verdaderos y falsos en su idioma.

Ejemplos:

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

(El último ejemplo se generó a partir de la cantidad de unos entre cada cero en la secuencia Thue-Morse)

Retina , 6 bytes

(.+)\1

Pruébalo en línea!

Valor positivo para la verdad; cero para falsey.

Cómo funciona

Devuelve el número de coincidencias de la expresión regular /(.+)\1/g.

Brachylog , 3 bytes

s~j

Pruébalo en línea!

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

Jalea , 6 5 bytes

Ẇµ;"f

Este es un programa completo. TIO no puede manejar el último caso de prueba sin truncarlo.

Pruébalo en línea!(último caso de prueba truncado a 250 dígitos)

Cómo 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.*")

Prácticamente un duplicado de la respuesta de Retina , pero no hay forma de que Java se acorte.

05AB1E , 5 bytes

Œ2×åZ

Pruébalo en línea!

Emite 1 como valor verdadero y 0 como valor falso

Explicación

Œ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

Pruébalo en línea!

Bostezo, una expresión regular. Comprueba si la cadena contiene una cadena de uno o más caracteres .+seguidos de la misma cadena que se acaba de capturar. El objeto de búsqueda de salida es Verdad si hay al menos una coincidencia, como puede comprobarse bool.

Usar compileaquí ahorra sobre escribir una 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])

Pruébalo en línea!

Busca una subcadena que se compone de dos o más cadenas iguales concatenadas, como se verifica s in(s*2)[1:-1]en esta respuesta . Las subcadenas se generan de forma recursiva al elegir cortar el primer o el último carácter. Esto es exponencial, por lo que se agota el tiempo en el caso de prueba grande.

Casi falla:

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)

El primero no usa Python inpara verificar subcadenas, por lo que podría adaptarse a otros idiomas.

Pyth - 10 9 8 bytes

f}+TTQ.:

Devuelve una lista de todas las subcadenas repetidas (que si no hay ninguna, es una lista vacía, que es falsa)

Intentalo

Explicación:

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

Pruébalo en línea!

PHP , 32 bytes

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

Pruébalo en línea!

PHP , 38 bytes

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

Pruébalo en línea!

Python 3 , 73 66 bytes

-7 bytes gracias a @LeakyNun

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

Pruébalo en línea!

Perl 6 , 11 bytes

{?/(.+)$0/}

Pruébalo

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

Ejecutar como tubería con -F. Lo siento Jörg, no me había dado cuenta de que habías publicado lo mismo .

versión no regex, 84 82 bytes

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

sale con código de retorno 0para una repetición, agota el tiempo de espera (y sale con error) para ninguno. Ejecutar como tubería con -nr.
asume entrada ASCII imprimible; reemplazar ~con a&cualquier ASCII.

JavaScript (ES6), 19 bytes

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

Pyth, 15 bytes

.E.nm.bqNYtdd./

¡Intentalo!

V , 6 bytes

ø¨.«©±

Pruébalo en línea!

¡Banco de pruebas!

El programa genera 0valores falsey y un número entero positivo para valores positivos.

(Tenga en cuenta que hubo un pequeño error, así que tuve que ganar 1 byte. Ahora, después de la corrección del error, podré reemplazarlo .«por\x82 )

Explicación

ø                     " 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

Pruébalo en línea . Salidas nullpara falsedad, y una matriz que contiene todas las cadenas repetidas para verdad.

Explicación

 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

Cheddar, 16 bytes

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

Esta es una función. Pruébalo en línea!