Une chaîne de caractères se répète si elle contient deux sous-chaînes consécutives équivalentes.

Par exemple, se 2034384538452répète car il contient 3845deux fois de suite.

Par conséquent, votre défi consiste à décider si une chaîne contient une sous-chaîne répétitive. Vous pouvez prendre l'entrée comme une chaîne ou un tableau de caractères.

Vous ne recevrez jamais une entrée vide et la longueur de la sous-chaîne (si elle existe) peut être 1 ou plus.

J'utilise 1et 0ici comme mes valeurs de vérité et de fausseté, mais vous pouvez utiliser des valeurs différentes, tant qu'elles sont véridiques et fausses dans votre langue.

Exemples:

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

(Le dernier exemple a été généré à partir du nombre de uns entre chaque zéro dans la séquence Thue-Morse)

Rétine , 6 octets

(.+)\1

Essayez-le en ligne!

Valeur positive pour véridique; zéro pour falsey.

Comment ça fonctionne

Renvoie le nombre de correspondances de l'expression régulière /(.+)\1/g.

Brachylog , 3 octets

s~j

Essayez-le en ligne!

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

Gelée , 6 5 octets

Ẇµ;"f

Ceci est un programme complet. TIO ne peut pas gérer le dernier cas de test sans le tronquer.

Essayez-le en ligne! (dernier cas de test tronqué à 250 chiffres)

Comment ça fonctionne

Ẇµ;"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 octets

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

Java, 27 octets

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

Quasiment un double de la réponse Retina , mais il n'y a aucun moyen que Java raccourcisse.

05AB1E , 5 octets

Œ2×åZ

Essayez-le en ligne!

Sorties 1 comme valeur vraie et 0 comme valeur fausse

Explication

Œ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 octets

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

Essayez-le en ligne!

Bâillement, une expression régulière. Vérifie si la chaîne contient une chaîne d'un ou plusieurs caractères .+suivie de la même chaîne qui vient d'être capturée. L'objet de recherche en sortie est Truthy s'il y a au moins une correspondance, comme cela peut être vérifié par bool.

L'utilisation compileici permet d'économiser sur l'écriture d'un lambda:

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

Python , 54 octets

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

Essayez-le en ligne!

Recherche une sous-chaîne composée de deux chaînes égales ou plus concaténées, comme vérifié par s in(s*2)[1:-1]comme dans cette réponse . Les sous-chaînes sont générées de manière récursive en choisissant de couper le premier ou le dernier caractère. C'est exponentiel, donc il expire sur le grand cas de test.

Évités de justesse:

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)

Le premier n'utilise pas Python inpour vérifier les sous-chaînes, et pourrait donc être adapté à d'autres langages.

Pyth - 10 9 8 octets

f}+TTQ.:

Renvoie une liste de toutes les sous-chaînes répétitives (qui s'il n'y en a pas, est une liste vide, qui est fausse)

Essayez-le

Explication:

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 octets

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

Essayez-le en ligne!

PHP , 32 octets

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

Essayez-le en ligne!

PHP , 38 octets

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

Essayez-le en ligne!

Python 3 , 73 66 octets

-7 octets grâce à @LeakyNun

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

Essayez-le en ligne!

Perl 6 , 11 octets

{?/(.+)$0/}

Essaye-le

Étendu:

{        # 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 octets

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

Exécuter en tant que tuyau avec -F. Désolé Jörg, je n'avais pas remarqué que tu avais posté le même .

version non regex, 84 82 octets

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

quitte avec code retour 0pour une répétition, expire (et quitte avec erreur) pour aucune. Exécuter en tant que tuyau avec -nr.
suppose une entrée ASCII imprimable; remplacer ~par a&pour tout ASCII.

JavaScript (ES6), 19 octets

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

Pyth, 15 octets

.E.nm.bqNYtdd./

Essayez!

V , 6 octets

ø¨.«©±

Essayez-le en ligne!

Suite de tests!

Les résultats du programme 0 génère des valeurs de falsey et un entier positif pour les valeurs positives.

(Notez qu'il y avait un petit bug, donc j'ai dû gagner 1 octet. Maintenant, après la correction du bug, je pourrai le remplacer .«par\x82 )

Explication

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

f"(.+)%1

Essayez-le en ligne . Les sortiesnull pour faux, et un tableau contenant toutes les chaînes répétitives pour vérité.

Explication

 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 octets

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

Ceci est une fonction. Essayez-le en ligne!