UPDATE : isaacg's Pyth Submission ist der Gewinner!

Viele von Ihnen müssen gehört haben, dass es eine coolere Version von JavaScript in der Stadt gibt (lesen Sie ES6), die eine Methode String.prototype.repeathat, mit der Sie dies tun können

"Hello, World!".repeat(3)

und bekomme

"Hello, World!Hello, World!Hello, World!"

als Ausgabe.

Ihre Aufgabe ist es, eine Funktion oder ein Programm in einer Sprache Ihrer Wahl zu schreiben, die erkennen, ob eine Zeichenkette einer solchen Transformation unterzogen wurde.

Das heißt, die Eingabezeichenfolge kann als genaue nWiederholung einer kleineren Zeichenfolge dargestellt werden. Die Ausgabe (als return-Anweisung der Funktion oder STDOUT) sollte wahr sein, wenn die Zeichenfolge fehlerhaft sein kann, oder wenn die Zeichenfolge nicht als Wiederholung einer kleineren Zeichenfolge dargestellt werden kann.

Einige Beispieleingaben:

"asdfasdfasdf"  // true
"asdfasdfa"     // false
"ĴĴĴĴĴĴĴĴĴ"     // true
"ĴĴĴ123ĴĴĴ123"  // true
"abcdefgh"      // false

Beachten Sie, dass die letzte Eingabe falsch ist und ndaher größer als sein sollte1

Regeln vervollständigen

• Schreiben Sie eine Funktion / ein Programm in einer beliebigen Sprache, um (über Funktionsargumente / Befehlszeilenargumente / STDIN) eine Zeichenfolge einzugeben
• Gibt den Wahrheitswert zurück / druckt ihn aus, wenn die angegebene Zeichenfolge durch exakte Wiederholung einer kleineren Zeichenfolge gebildet wird, die mindestens zweimal wiederholt wird.
• Die maximale Größe der Eingabezeichenfolge ist idealerweise Unendlich
• String kann alle möglichen ASCII-Zeichen enthalten
• Dies ist ein Code-Golf, so dass der kleinste Code in Zeichen gewinnt.

Pyth , 9

/:+zz1_1z

Oder

}z:+zz1_1

Dies sind beide enge Übersetzungen von @ xnors Python-Antwort, mit der Ausnahme, dass sie Eingaben von STDIN entgegennehmen und sie ausdrucken. Das erste ist äquivalent zu:

z = input()
print((z+z)[1:-1].count(z))

0 für falsch, 1 für wahr.

Die zweite Zeile entspricht:

z = input()
print(z in (z+z)[1:-1])

Falsch für Falsch, wahr für wahr.

Pyths offizieller Compiler hatte einen Fehler im Zusammenhang mit dem zweiten, den ich gerade gepatcht habe. Der erste ist also meine offizielle Einreichung.

Python (24)

lambda s:s in(s+s)[1:-1]

Überprüft, ob die Zeichenfolge eine zweimal verkettete Teilzeichenfolge ist, wobei das erste und das letzte Zeichen entfernt werden, um triviale Übereinstimmungen zu vermeiden. Wenn ja, muss es sich um eine nichttriviale zyklische Permutation von sich selbst und damit um die Summe der wiederholten Segmente handeln.

Regex (ECMAScript-Variante), 11 Byte

Klingt nach einem Job für Regex!

^([^]+)\1+$

Teste es hier.

Ich habe mich für ECMAScript entschieden, weil es (wie ich weiß) die einzige Variante ist, die [^]zu einem Zeichen passt. In allen anderen Fällen benötige ich entweder eine Markierung, um das Verhalten zu ändern, .oder verwende [\s\S]eine drei Zeichen längere Markierung.

Je nachdem, wie wir das Flag zählen, könnte das natürlich ein Byte kürzer sein. Wenn wir z. B. Muster + Flags zählen (z. B. Trennzeichen ignorieren), ist dies das PCRE / Perl-Äquivalent

/^(.+)\1+$/s

Das sind 10 Bytes, wobei die Begrenzer ignoriert werden.

Teste es hier.

Dies entspricht nur Zeichenfolgen, die aus mindestens zwei Wiederholungen einer Teilzeichenfolge bestehen.

Hier ist eine vollständige 26-Byte-ES6-Funktion, aber ich behaupte, dass Einsendungen von regulären Ausdrücken allgemein gültig sind:

f=s->/^([^]+)\1+$/.test(s)

CJam, 9

q__+)@+#)

Ähnlich wie die Idee von xnor.

q      " Read input. ";
__+    " Duplicate twice and concatenate them together. ";
)      " Remove the last character of the longer string. ";
@+     " Insert that character at the beginning of the shorter string. ";
#)     " Find the shorter string in the longer string, and increase by one. ";

APL, 11

2<+/x⍷,⍨x←⍞

Bei der Erläuterung werden
⍞ Zeichenfolgeneingaben vom Bildschirm übernommen,
x←die einer Variablen x
,⍨zugewiesen werden, die die Zeichenfolge mit der
x⍷Suche xin der resultierenden Zeichenfolge verknüpft. Gibt ein Array zurück, das aus Einsen an der Startposition einer Übereinstimmung und Nullen an einer anderen Stelle besteht.
+/summiert die Array-
2<Prüfung, wenn die Summe größer als 2 ist (da es 2 triviale Übereinstimmungen gibt)

CJam, 10 Bytes

Ich habe den CJam-Fehler entdeckt. Meine erste Antwort, damit kann man wohl noch etwas mehr golfen:

q__+(;);\#

Ausgänge -1 für FALSE und eine Zahl> = 0 für TRUE

GolfScript, 10 Bytes

..+(;);\?)

Eine weitere Implementierung von xnors cleverer Idee.

Python - 59 57

lambda s:any([s*n==s[:n]*len(s)for n in range(2,len(s))])

Pure Bash, 30 Bytes

Einfache Portierung der cleveren Antwort von @ xnor :

[[ ${1:1}${1:0: -1} =~ "$1" ]]

Der Exit-Code ist 0 für TRUE und 1 für FALSE:

$ for s in 'Hello, World!Hello, World!Hello, World!' 'asdfasdfasdf' 'asdfasdfa' 'ĴĴĴĴĴĴĴĴĴ' 'ĴĴĴ123ĴĴĴ123' 'abcdefgh'; do echo "./isrepeated.sh "\"$s\"" returns $(./isrepeated.sh "$s"; echo $?)"; done
./isrepeated.sh "Hello, World!Hello, World!Hello, World!" returns 0
./isrepeated.sh "asdfasdfasdf" returns 0
./isrepeated.sh "asdfasdfa" returns 1
./isrepeated.sh "ĴĴĴĴĴĴĴĴĴ" returns 0
./isrepeated.sh "ĴĴĴ123ĴĴĴ123" returns 0
./isrepeated.sh "abcdefgh" returns 1
$ 

Hinweis =~innerhalb [[ ... ]]ist der Regex - Operator in bash . Jedoch „kann ein beliebiger Teil des Musters zitiert werden sie zu zwingen , als String angepasst werden“ . Wie so oft bei bash, ist es sehr wichtig, die richtigen Anführungszeichen zu setzen - hier wollen wir nur auf einen String-Submatch und nicht auf eine Regex-Übereinstimmung prüfen.

TI-BASIC - 32

Ich dachte, ich würde eine Token-Sprache ausprobieren. Führen Sie den Befehl mit der Zeichenfolge in Ans aus, und geben Sie bei false 0 und bei true die Länge der wiederholten Zeichenfolge zurück.

inString(sub(Ans+Ans,1,2length(Ans)-1),sub(Ans,length(Ans),1)+Ans

Erstaunlich, wie es ein Einzeiler ist.

ECMAScript 6 (189)

(function(){var S=String.prototype,r=S.repeat;S.isRepeated=function(){return!1};S.repeat=function(c){var s=new String(r.call(this,c));if(c>1)s.isRepeated=function(){return!0};return s}}());

< console.log("abc".isRepeated(),"abc".repeat(10).isRepeated());
> false true

Das ist doch die einzig gültige Lösung? Beispielsweise wird das Wort (Zeichenfolge) nananicht unbedingt aus erstellt"na".repeat(2)

ECMAScript 6 (34 36 )

Eine weitere Antwort von ES6, aber ohne den Trickrepeat von xnor zu verwenden :

f=i=>(i+i).slice(1,-1).contains(i)

Muss in der Konsole eines ES6-fähigen Browsers wie Firefox ausgeführt werden.

C 85

l,d;f(s){return l=strlen(s),strstr(d,strcpy(strcpy(d=alloca(l*2+1),s)+l,s)-1)-d-l+1;}

Es hat sich als ziemlich lang herausgestellt, aber externe Funktionen sind immer so. Mir fiel ein, dass ich jede String-Funktion neu schreiben konnte, indem ich sie durch eine Schleife oder eine rekursive ersetzte. Aber meiner Erfahrung nach würde es länger dauern und ehrlich gesagt möchte ich das nicht ausprobieren.

Nach einigen Recherchen sah ich Lösungen für hohe Leistung, aber nicht so clever (und kurz) wie die von xnor. nur um originell zu sein ... ich habe die gleiche idee in c umgeschrieben.

Erläuterung:

int length, 
    duplicate;
int is_repetition(char *input)
{
    // length = "abc" -> 3
    length = strlen(input);
    // alloca because the function name is as long as "malloc" 
    // but you don't have to call free() because it uses the stack
    // to allocate memory
    // duplicate = x x x x x x + x
    duplicate = alloca(length*2 + 1);
    // duplicate = a b c 0 x x + x
    strcpy(duplicate, input);
    // duplicate = a b c a b c + 0
    strcpy(duplicate + length, input);
    if (strstr(duplicate,duplicate + length - 1) != duplicate + length - 1)
        // repetition
        // e.g. abab -> abababab -> aba[babab]
        // -> first occurence of [babab] is not aba[babab]
        // but a[babab]ab -> this is a repetition
        return 1;
    else
        // not repetition
        // e.g. abc -> abcabc -> ab[cabc]
        // -> first occurence of [cabc] is ab[cabc]
        // it matches the last "cabc"
        return 0;
}

ECMAScript 6 (59 62 67 73 )

Kein Gewinner, aber es scheint, dass es in ES6 mindestens eine Antwort auf diese Frage geben sollte, die tatsächlich die repeatFunktion verwendet:

f=i=>[...i].some((_,j)=>i.slice(0,j).repeat(i.length/j)==i)

Muss in der Konsole eines ES6-fähigen Browsers wie Firefox ausgeführt werden.

Es macht eine Menge unnötiger Iterationen, aber warum sollte es länger dauern, nur um das zu vermeiden, oder?

• Edit # 1: Sparte ein paar Bytes, indem du es in eine Funktion umwandelst. Danke an Optimizer!
• Edit # 2: Danke an hsl für den Spread-Operator-Trick, um mehr Bytes zu sparen!
• Edit # 3: Und danke an Rob W. für weitere 3 Bytes!

Gelee , 3 Bytes

ṙJċ

Probieren Sie es online!

Genauso wie diese Antwort (vielleicht ist die spätere Herausforderung eine Verallgemeinerung dieser?).

Java 8, 28 Bytes

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

Probieren Sie es online aus.

Erläuterung:

Überprüft, ob der Eingabe-String mit dem regulären Ausdruck übereinstimmt. Dabei wird String#matchesimplizit hinzugefügt ^...$, dass er mit dem gesamten String übereinstimmt.
Erklärung des regulären Ausdrucks selbst:

^(s?)(.+)\1+$
^                Begin of the string
 (s?)            Enable DOTALL-mode, where `.` also matches new-lines
     (           Open capture group 1
      .+          One or more characters
        )        Close capture group 1
         \1+     Plus the match of the capture group 1, one or more times
            $    End of the string

Es wird also grundsätzlich geprüft, ob eine Teilzeichenfolge zwei- oder mehrmals wiederholt wird (Unterstützung von Zeilenumbrüchen).