Dies wird aus dieser Frage entnommen (mit Erlaubnis des Kurses). Ich zitiere:

Erstellen Sie eine Funktion, die eine Zeichenfolge akzeptiert. Je nachdem, ob die Eingabe nur aus einer wiederholten Zeichenfolge besteht, sollte sie true oder false zurückgeben . Die Länge des angegebenen Strings ist immer größer als 1 und die Zeichenfolge muss mindestens eine Wiederholung haben.

Einige Beispiele:

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

Insbesondere kann die Prüfung auf eine Zeichenfolge, die ausschließlich aus sich wiederholenden Teilzeichenfolgen besteht ( Update ), eine beliebige wahre oder falsche Darstellung ausgeben, aber bitte keine Fehlerausgabe. Streng alphhanumerische Zeichenfolgen. Ansonsten Standard Code Golfregeln. Dies ist Code Golf, daher gewinnt die kürzeste Antwort in Bytes für jede Sprache.

Brachylog , 4 3 Bytes

ġ=Ṁ

Probieren Sie es online!

Erläuterung

ġ=Ṁ    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.

Das Programm druckt, true.ob die Bedingungen erfüllt werden können und false.wenn nicht.

JavaScript (ES6), 22 Byte

Gibt einen Booleschen Wert zurück.

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

Probieren Sie es online!

Ohne regulären Ausdruck  33  29 Bytes

Gibt entweder null(falsch) oder ein Objekt (wahr) zurück.

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

Probieren Sie es online!

$s$

grep, 19

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

Prüfung

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

Ausgabe:

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

Japt , 6 Bytes

²é ¤øU

Dank @Shaggy ein Byte gespeichert

Probieren Sie es 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 Danke an Olivier Grégoire!
Langweilige Regex-Antwort

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

Probieren Sie es online!

Es ist nur 1 Byte länger als die Python Antwort aaaaa ich jetzt gebunden bin :)

Excel, 26 Bytes

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

Eingaben von A1, Ausgaben für jede Zelle, in die Sie diese Formel einfügen.

R , 28 Bytes

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

Probieren Sie es online!

Einfache Regex-Version. R ist (manchmal) sehr ähnlich zu Python, dies ist also ähnlich zu TFelds Python 2-Regex-Antwort, wenn auch kürzer!

Frage (falls jemand die Antwort kennt)

Ich bin immer noch verwirrt, warum dies funktioniert, da die Teilzeichenfolge beliebig lang sein kann und immer funktioniert und immer noch funktioniert, wenn ich einen Buchstaben vor eine gültige Zeichenfolge setze, z. B. "cABABABABAB". Wenn ich persönlich den regulären Ausdruck lese, sehe ich (.+), welcher jede Gruppe von beliebiger Länge erfasst. Und dann \\1+$wiederholt sich die erfasste Gruppe beliebig oft bis zum Ende.

Warum erfasst es also nicht einfach "AB" und stellt fest, dass es bis zum Ende der Zeichenfolge wiederholt wird, zumal keine Einschränkung festgelegt ist, wo die Teilzeichenfolge beginnen kann?

Retina 0.8.2 , 9 Bytes

^(.+)\1+$

Probieren Sie es online! Link enthält Testfälle.

Gelee ,  5  4 Bytes

Ich sehe jetzt, dass der beste Weg ist, der Methode von xnor zu folgen !

Ḋ;Ṗw

Ein monadischer Link, der eine Liste von Zeichen akzeptiert und eine Ganzzahl ausgibt - die kürzestmögliche Länge eines sich wiederholenden Slice oder Null, falls keine vorhanden ist. Beachten Sie, dass Null falsch ist, während Zahlen ungleich Null in Jelly wahr sind.

Probieren Sie es online!

Wie?

Ḋ;Ṗ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+$/

Probieren Sie es online!

Python 2 , 24 Bytes

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

Probieren Sie es online!

Schamlos aus Xnors Antwort auf die ursprüngliche Frage gestohlen .

Intuitivere Version:

Python 2 , 59 55 53 Bytes

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

Probieren Sie es online!

Langweilige Regex-Version:

Python 2 , 44 Bytes

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 24 23 Bytes

StringMatchQ[x__..~~x_]

Probieren Sie es 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{

Probieren Sie es hier aus!

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

J , ^{26 25 15} 14 Bytes

Mit der xnor-Methode

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

Probieren Sie es online!

Original (zwei verschiedene Ansätze)

J , 25 Bytes

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

Probieren Sie es online!

J , 26 Bytes

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

Probieren Sie es online!

PowerShell, 23 bis 24 Byte

+1 Byte, um die Regeln vollständig zu erfüllen

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

Probieren Sie es online!

Ziemlich langweilig. Basierend auf den anderen Antworten von Regex. Zum Glück wird PowerShell nicht \als Fluchtcharakter verwendet!

C # (Visual C # Interactive Compiler) , 70 Byte

xnors schamlose Anpassung ( 46 Bytes )

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

Meine Nicht-Regex-Lösung:

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

Erläuterung:

Ersetzen Sie jede mögliche Teilzeichenfolge, die am Index 0 beginnt, durch eine leere Zeichenfolge. Wenn das Ergebnis eine leere Zeichenfolge ist, besteht die Zeichenfolge vollständig aus dieser Teilzeichenfolge. Da dies das Auswerten der gesamten Zeichenfolge mit sich selbst umfasst, muss die Anzahl der erwarteten Ergebnisse größer als 1 sein.

Beispiel: abcabc

Mögliche Teilstrings ab Index 0:

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

Wenn wir sie durch leere Zeichenketten ersetzen

Substring          Result

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

Da es eine andere Teilzeichenfolge als 'abcabc' gibt, die eine leere Zeichenfolge zurückgibt, besteht die Zeichenfolge vollständig aus einer anderen Teilzeichenfolge ('abc').

Probieren Sie es online!

Python 3 , 62 60 56 54 Bytes

-4 Bytes Danke an ArBo

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

1. Durchlaufen Sie alle möglichen Präfixe in der Zeichenfolge.
2. Versuchen Sie, die Zeichenfolge aus dem Präfix zu erstellen.
3. Geben Sie zurück, ob dies mit einem Präfix überhaupt erfolgreich ist.

Probieren Sie es online!

Japt , 10 Bytes

Gibt eine positive Zahl zurück, wenn wahr, und 0, wenn falsch. Wenn Sie eine Bool-Ausgabe möchten, fügen Sie einfach -¡flag hinzu

å+ 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

Probieren Sie es online!

Schale , 6 Bytes

Ṡ€ȯhtD

Probieren Sie es online!

Ich glaube, dies ist ein Byte mehr als optimal, aber ich konnte keine Anordnung finden, die die explizite Komposition ȯunnötig machte.

Erläuterung

Ṡ€      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->""]=="")]&

wobei durchgehend #die Eingabezeichenfolge darstellt und

StringCases[#,<pattern>]

findet Teilstrings der Eingabezeichenfolge, die mit dem Muster übereinstimmen

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

Dieses Muster erfordert Übereinstimmungen, xmuss am Anfang der Zeichenfolge beginnen und die Bedingung erfüllen, dass (1) die Übereinstimmung nicht die gesamte Eingabezeichenfolge ist und (2) das Auftreten der Übereinstimmung in der Eingabezeichenfolge durch die leere Zeichenfolge ersetzt wird Wir erhalten die leere Zeichenfolge. Abschließend wird die Liste der Übereinstimmungen mit der leeren Liste verglichen.

{}!=

ist, Truewenn die Liste der Übereinstimmungen nicht leer ist und Falsewenn die Liste der Übereinstimmungen leer ist.

Testfälle:

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

und

{}!=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)))

Verwendet textwrap.wrap(dank dieser Antwort ), um die Zeichenfolge in Stücke zu teilen n, um jede mögliche Länge der sich wiederholenden Teilzeichenfolge zu testen. Die getrennten Teile werden dann miteinander verglichen, indem sie zu einem Satz hinzugefügt werden. Wenn alle Teile gleich sind und die Menge die Länge 1 hat, muss die Zeichenfolge eine sich wiederholende Zeichenfolge sein. Ich habe <2stattdessen verwendet, ==1weil es ein Byte spart und die Länge der Eingabezeichenfolge garantiert größer als Null war.

Wenn es keine gibt, nfür die sich wiederholende Teilzeichenfolgen der Länge ndie gesamte Zeichenfolge ausmachen, geben Sie false für die gesamte Funktion zurück.

05AB1E , 5 Bytes

Die Methode von xnor aus der vorherigen Frage scheint auch in 05AB1E optimal zu sein.

«¦¨så

Probieren Sie es online! oder als Test Suite

Erläuterung

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

Sauber , 73 Bytes

Regex wird nicht verwendet.

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

Probieren Sie es online!

Definiert $ :: [Char] -> Bool.
Überprüft, ob die angegebene Zeichenfolge ein Präfix für die Wiederholung einer vom Ende abgeleiteten Teilzeichenfolge ist.

C ++ (gcc) , 36 Bytes

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

Probieren Sie es online!

Ein weiterer Port von xnors Lösung. Verwendet ein Makro, um das Argument in den Ausdruck zu erweitern. Es wird angenommen, dass das Argument vom Typ ist std::string.

QlikView-Variable, 27 Byte

Dies sollte als Variable definiert werden, mit der Sie Parameter übergeben können, z. B. $1als Eingabewert.

Es gibt 0oder zurück -1(entspricht der TRUE()Funktion von QlikView ).

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

Schnelle 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}

Probieren Sie es online!

Icon , 46 Bytes

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

Probieren Sie es online!

Ein weiterer Port von xnors Lösung.

K (oK) , 29 Bytes

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

Probieren Sie es online!

Rot , 72 Bytes

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

Probieren Sie es online!

Rückgabe 1fürTrue

T-SQL, 47 Bytes

Verwendung der @ Xnor- Methode :

DECLARE @ varchar(max)='ababab'

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

Behalten Sie die alte Antwort bei, da sie ein paar nette Golfer enthält (67 Bytes):

DECLARE @y varchar(max)='abababa'

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

Erläuterung: Dieses Skript versucht wiederholt, die Eingabe '@y' durch die ersten '@'-Zeichen der Eingabe' @y 'zu ersetzen, während' @ 'erhöht wird.

Wenn Sie 'ab' in 'ababab' durch nichts ersetzen, haben Sie eine leere Zeichenfolge

Irgendwann wird das Ergebnis leer sein. Wenn dies passiert, wenn die Schleifenvariable der Länge des Varchars entspricht, ist das Kriterium false / 0, da '@' = len (@y) (es gab kein wiederholtes Varchar).

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

Darin kann man golfen

@/len(@y)^1

weil die Länge von '@y' nicht 0 sein kann und '@' niemals die Länge von @y überschreitet.

Probieren Sie es online aus