Eine Zeichenfolge wird wiederholt, wenn sie zwei aufeinanderfolgende Teilzeichenfolgen enthält, die äquivalent sind.

Beispielsweise werden 2034384538452Wiederholungen 3845nacheinander ausgeführt , da sie zweimal enthalten sind.

Daher müssen Sie entscheiden, ob eine Zeichenfolge eine sich wiederholende Teilzeichenfolge enthält. Sie können die Eingabe als Zeichenfolge oder als Zeichenfolge verwenden.

Sie erhalten niemals eine leere Eingabe, und die Länge der Teilzeichenfolge (falls vorhanden) kann 1 oder mehr betragen.

Ich verwende 1und 0hier als meine wahren und falschen Werte, aber Sie können andere Werte verwenden, solange sie in Ihrer Sprache wahr und falsch sind.

Beispiele:

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

(Das letzte Beispiel wurde aus der Anzahl der Einsen zwischen jeder Null in der Thue-Morse-Sequenz generiert.)

Netzhaut , 6 Bytes

(.+)\1

Probieren Sie es online!

Positiver Wert für Wahrhaftigkeit; Null für Falsey.

Wie es funktioniert

Gibt die Anzahl der Übereinstimmungen des regulären Ausdrucks zurück /(.+)\1/g.

Brachylog , 3 Bytes

s~j

Probieren Sie es online!

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

Gelee , 6 5 Bytes

Ẇµ;"f

Dies ist ein volles Programm. TIO kann den letzten Testfall nicht verarbeiten, ohne ihn abzuschneiden.

Probieren Sie es online! (letzter Testfall auf 250 Stellen gekürzt)

Wie es funktioniert

Ẇµ;"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.*")

Fast ein Duplikat der Retina-Antwort , aber es gibt keine Möglichkeit, dass Java kürzer wird.

05AB1E , 5 Bytes

Œ2×åZ

Probieren Sie es online!

Gibt 1 als Wahrheitswert und 0 als Falschwert aus

Erläuterung

Œ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

Probieren Sie es online!

Gähnen, ein Regex. Überprüft, ob die Zeichenfolge eine Zeichenfolge aus einem oder mehreren Zeichen enthält, .+gefolgt von derselben Zeichenfolge, die gerade erfasst wurde. Das Ausgabesuchobjekt ist Truthy, wenn mindestens eine Übereinstimmung vorliegt, die von überprüft werden kann bool.

Die Verwendung compilehier erspart das Schreiben eines Lambdas:

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

Probieren Sie es online!

Sucht nach einer Teilzeichenfolge, die aus zwei oder mehr gleichen, verketteten Zeichenfolgen besteht, s in(s*2)[1:-1]wie in dieser Antwort angekreuzt . Teilzeichenfolgen werden rekursiv generiert, indem entweder das erste oder das letzte Zeichen ausgeschnitten wird. Dies ist exponentiell, daher tritt bei dem großen Testfall eine Zeitüberschreitung auf.

Beinahe fehlgeschlagen:

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)

Der erste verwendet Python nicht inzum Prüfen von Teilzeichenfolgen und kann daher an andere Sprachen angepasst werden.

Pyth - 10 9 8 Bytes

f}+TTQ.:

Gibt eine Liste aller sich wiederholenden Teilzeichenfolgen zurück (falls keine vorhanden sind, handelt es sich um eine leere Liste, die falsch ist).

Versuch es

Erläuterung:

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

Probieren Sie es online!

PHP , 32 Bytes

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

Probieren Sie es online!

PHP , 38 Bytes

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

Probieren Sie es online!

Python 3 , 73 66 Bytes

-7 Bytes dank @LeakyNun

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

Probieren Sie es online!

Perl 6 , 11 Bytes

{?/(.+)$0/}

Probier es aus

Erweitert:

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

Als Rohr mit laufen lassen -F. Sorry Jörg, ich hatte nicht gemerkt das du das selbe gepostet hattest .

Nicht-Regex-Version, 84 82 Bytes

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

Exits mit Rückkehrcode 0für eine Wiederholung, Timeout (und Exits mit Fehler) für keine. Als Rohr mit laufen lassen -nr.
setzt druckbare ASCII-Eingabe voraus; ersetzen Sie ~mit a&für jedes mögliches ASCII.

JavaScript (ES6), 19 Byte

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

Pyth, 15 Bytes

.E.nm.bqNYtdd./

Versuch es!

V , 6 Bytes

ø¨.«©±

Probieren Sie es online!

Test Suite!

Das Programm gibt 0für falsche Werte und für positive Werte eine positive ganze Zahl aus.

(Beachten Sie, dass es ein kleiner Fehler war, so dass ich ein Byte zu gewinnen hatte. Jetzt , nach dem Bugfix, ich in der Lage sein , zu ersetzen .«mit \x82)

Erläuterung

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

Probieren Sie es online aus . Ausgaben nullfür falsy und ein Array, das alle sich wiederholenden Zeichenfolgen für truthy enthält.

Erläuterung

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

Dies ist eine Funktion. Probieren Sie es online!