Überprüfen Sie, ob eine Zeichenfolge vollständig aus derselben Teilzeichenfolge besteht

24

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.

code-golf  decision-problem 
— ouflak
quelle
4
Hm, ich würde diese Herausforderung als Betrogene schließen , dass man , aber ich bemerkte , dass die anderen Werte auf Zeichenanzahl. Vielleicht sollten wir stattdessen die andere schließen (sie hat auch eine akzeptierte Antwort), um sie zu täuschen.
— Erik der Outgolfer
— Erik der Outgolfer

Antworten:

11

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.

— Zgarb
quelle
Ich habe mich gerade damit abgemüht, etwas wie ~j↙oder =ṀcArbeit zu finden, bevor mir aufgefallen ist, dass Sie dies vor einer Stunde gepostet haben
— Unrelated String
4
Oh ja, das könnte ein Byte kürzer sein:ġ=Ṁ
— Unrelated String
( Ṁist eine Variable, die darauf beschränkt ist, eine Liste von zwei oder mehr Elementen zu sein)
— Nicht verwandte
1
@UnrelatedString Großartig, danke! Ich habe nicht daran gedacht, die Variablen-Wiki-Seite zu überprüfen.
— Zgarb
1
Viele tolle Antworten, und die LUA-Antwort hat einen besonderen Stellenwert in meinem Herzen. Die Antwort von Arnauld ist besonders süß, da die ursprüngliche Frage, auf der ich sie basierte (nicht die Dupe), tatsächlich mit Javascript markiert ist. Hauptsächlich, weil es für alle Sprachen die kürzeste ist und weil dies meine erste Frage ist, bekomme ich ein Abzeichen.
— 1.
9

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
— Thor
quelle
9

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
— Verkörperung der Ignoranz
quelle
Nice one :) Sie können das Ersetzen p<space>mit ²einem Byte zu speichern.
— Shaggy
9

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

— Benjamin Urquhart
quelle
3
Sie können das Finale entfernen, $da es sich bei der matchesMethode um eine exakte Übereinstimmung handelt und nicht standardmäßig um eine Teilzeichenfolgenübereinstimmung.
— Olivier Grégoire
Ich habe vergessen, matchesfügt seine eigene $Regex hinzu. Vielen Dank!
— Benjamin Urquhart
7

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.

— Sophia Lechner
quelle
Sie könnten 4 Bytes sparen, wenn Sie einen einbuchstabigen Bereichsnamen definieren (z. B. A) und diesen als Ihre Eingabe festlegen.
— i_saw_drones
@i_saw_drones - Ich denke, das wird von Standard-E / A-Regeln nicht zugelassen: Hier ist ein Link zu der Meta-Antwort , die für diese Methode gelten würde. es ist derzeit bei -36 Stimmen.
— Sophia Lechner
Entschuldigung, ich hatte diesen Beitrag nicht gesehen, obwohl ich darüber nachgedacht habe, ist er nicht A1auch eine "Variable", da er den Eingabewert enthält? :)
— i_saw_drones
1
Ich würde mich so fühlen, wenn ich etwas Besonderes mit der Tatsache täte, dass es speziell A1 ist, als ob ich mich irgendwie darauf verlassen würde, dass ROW (_) 1 ist. Wie auch immer, es ist nur die natürlichste Art, eine Excel-Funktion bereitzustellen eine beliebige Eingabe.
— Sophia Lechner
7

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?

— Sumner18
quelle
1
Interessanterweise scheint dies ein Fehler in der Regex-Engine von R zu sein. Wenn Sie die Option perl=TRUEhinzufügen, stimmt sie erwartungsgemäß mit cABABAB überein. Die grep -E '(.*)\1+$'Ausführung in Bash entspricht auch cABABAB, obwohl grep -EERE verwendet wird, das gleiche Regex-Aroma, das R unterstützen soll.
— Grimmy
2
Ich vermute, dass dies eine falsch angewendete Optimierung ist. Das Ändern von .+zu Beginn eines Musters zu ^.+ist eine wichtige Optimierung, aber wenn sich das .+Element innerhalb von Erfassungsparens befindet, ist es nicht mehr gültig.
— Grimmy
6

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)
— Jonathan Allan
quelle
3

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!

— Gabriel Mills
quelle
es kehrt truefüraabcabc
— mazzy
1
@mazzy gerade behoben!
— Gabriel Mills
3

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!

— Innat3
quelle
3

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!

— movatica
quelle
1
Gute Antwort! Das f=kann fallengelassen werden; anonyme Funktionen sind generell erlaubt. any
— Wenn
1
Netter Fang mit der Listenmitgliedschaft, danke! Ich werde nicht zu Python 2 wechseln, da dies wie das Wechseln der Sprache ist, was hier offensichtlich nicht der Punkt ist.
— Movatica
1
@movatica Setzen Sie im Header `f =` (\ ist das Zeilenfortsetzungszeichen in Python)
— Artemis unterstützt Monica
Ärgerlicherweise ist \ auch ein Fluchtcharakter. Hier, ohne Code-Formatierung, ist, was Sie in den Header einfügen sollten: f = \
— Artemis unterstützt Monica
2

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!

— Luis Felipe De Jesus Munoz
quelle
2

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.
— Sophia Lechner
quelle
2
€htD¹vermeidet die ȯ.
— Zgarb,
Das ist fantastisch! Ich hatte darüber nachgedacht, λ€htD¹aber ich wusste nicht, dass Lambdas implizit hinzugefügt werden
— Sophia Lechner,
2

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  *)
— Eric Towers
quelle
2

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.

— Delya Erricson
quelle
2

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
— Emigna
quelle
1
Natürlich. Ich wollte gerade eine 05AB1E-Antwort geben, als ich sah, dass keine da war. Der Kollege hat mir ein paar Fragen gestellt und über seinen Urlaub gesprochen. Ich blicke zurück auf den Bildschirm: eine neue Antwort. Tada, schlagen Sie noch einmal XD
— Kevin Cruijssen
@ KevinCruijssen: Das ist typisch. Ist mir auch ein paar Mal passiert;)
— Emigna
2

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.

— Οurous
quelle
2

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.

— jxh
quelle
1

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
— i_saw_drones
quelle
1

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!

— onnoweb
quelle
Ich benutze Swift nicht, aber ich bin sicher, dass zusätzliche Leerzeichen entfernt werden können
— Benjamin Urquhart
193 Bytes mit @ Benjamin's Vorschlag.
— Artemis unterstützt Monica
@ArtemisFowl oder sogar 123 Bytes
— Roman Podymov
1

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

— t-clausen.dk
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.