Bullen und Räuber: Reverse Regex Golf

76

Hinweis : Diese Herausforderung ist jetzt geschlossen. Alle zukünftigen Polizistenbeiträge werden für die akzeptierte Antwort nicht berücksichtigt. Dies soll sicherstellen, dass in Zukunft niemand mehr eine sehr einfache Regex veröffentlichen kann, die nur ungerissen bleibt, weil sich niemand mehr für die Herausforderung interessiert.

Die Herausforderung der Polizei

Sie müssen einen kurzen, verschleierten regulären Ausdruck schreiben, der die folgende Spezifikation erfüllt:

  • Sie können jeden Geschmack wählen, der online frei testbar ist. Es gibt eine gute Liste von Online-Testern bei StackOverflow . Insbesondere Regex101 sollte für den Einstieg hilfreich sein, da es PCRE-, ECMAScript- und Python- Varianten unterstützt. Sie können das Zeitlimit erhöhen, indem Sie bei Bedarf auf den Schraubenschlüssel in der rechten oberen Ecke klicken. Bitte geben Sie den von Ihnen gewählten Tester in Ihrer Antwort an.

    Wenn kein geeigneter Tester für Ihren Geschmack verfügbar ist, können Sie auch einen Online-Dolmetscher wie ideone verwenden und ein kleines Skript in der Host-Sprache schreiben, mit dem die Benutzer Ihre Einreichung testen können.

  • Sie können jede Funktion dieser Art verwenden, die die Hostsprache nicht direkt aufruft (wie die Code-Evaluierungsfunktionen von Perl).
  • Ebenso können Sie beliebige Modifikatoren verwenden (sofern diese Ihrem Geschmack entsprechen), es sei denn, sie führen zu einer Codebewertung.
  • Ihr regulärer Ausdruck muss mindestens eine Zeichenfolge S akzeptieren und mindestens eine Zeichenfolge T ablehnen , von denen jede mindestens 16 und nicht länger als 256 Zeichen ist, und das in einem angemessenen Zeitraum (nicht wesentlich länger als eine Minute). S und T können Unicode-Zeichen enthalten, die nicht ASCII-Zeichen sind, sofern Sie sie in den Online-Tester eingeben können. Jedes Paar solcher Zeichenfolgen ist ein Schlüssel für Ihre Einreichung.
  • Ihr regulärer Ausdruck kann bei jeder anderen Eingabe beliebig lange dauern.

Der Kern der Herausforderung besteht darin, einen Regex herzustellen, dessen Schlüssel schwer zu finden ist. Das heißt, es sollte entweder schwer zu sagen sein, mit welcher Zeichenfolge es nicht übereinstimmt oder mit welcher Zeichenfolge es übereinstimmt (oder möglicherweise sogar beides, wenn der reguläre Ausdruck Tage benötigt, um alle Zeichenfolgen außer den Zeichenfolgen des Schlüssels zu beenden).

Die Herausforderung der Räuber

Alle Benutzer, einschließlich derer, die ihre eigenen Regex (e) eingereicht haben, werden aufgefordert, andere Beiträge zu "knacken". Ein Beitrag wird geknackt, wenn einer seiner Schlüssel im zugehörigen Kommentarbereich veröffentlicht wird.

Wichtig: Stellen Sie sicher, dass beide Strings zwischen 16 und 256 Zeichen enthalten, auch wenn für einen Teil des Schlüssels fast jeder String verwendet werden kann.

Wenn eine Einreichung 72 Stunden lang ohne Änderung oder Rissbildung besteht, kann der Autor einen gültigen Schlüssel offenlegen, indem er ihn in seiner Antwort in einen Spoiler-Tag umwandelt. Dadurch wird seine Antwort "sicher", dh es kann nicht mehr geknackt werden.

Es ist nur ein Cracking-Versuch pro Einsendung pro Benutzer zulässig. Wenn ich zum Beispiel an Benutzer X sende: "Ihr Schlüssel ist 0123456789abcdef/ fedcba9876543210." Wenn ich mich irre, lehnt Benutzer X meine Vermutung als falsch ab und ich kann keine weiteren Vermutungen für diese Übermittlung mehr einreichen, aber ich kann trotzdem andere Übermittlungen knacken (und andere können diese Übermittlung immer noch knacken).

Gebrochene Einsendungen werden von der Konkurrenz ausgeschlossen (sofern sie nicht "sicher" sind). Sie sollten nicht bearbeitet oder gelöscht werden. Wenn ein Autor einen neuen regulären Ausdruck einreichen möchte, sollte er dies in einer separaten Antwort tun.

Knacken Sie nicht Ihre eigene Vorlage!

Hinweis: Bei langen Zeichenfolgen in Kommentaren ohne Leerzeichen fügt SE manuelle Zeilenumbrüche in Form von zwei Unicode-Zeichen ein. Wenn Sie also einen Schlüssel in Backticks posten, der so lang ist, dass er in Zeilenumbrüche zwischen nicht-Leerzeichen eingeschlossen ist, ist es nicht möglich, den Schlüssel direkt wieder in einen Regex-Tester zu kopieren. In diesem Fall senden Sie bitte einen Permalink zum entsprechenden Regex-Tester mit dem Regex des Polizisten und Ihrem Schlüssel. Die meisten Tester bieten diese Funktion an.

Wertung

Die Punktzahl eines Polizisten entspricht der Größe seines regulären Ausdrucks in Byte (Muster plus Modifikatoren, potenzielle Begrenzer werden nicht gezählt), sofern er nicht geknackt wurde. Die niedrigste Punktzahl einer "sicheren" Einreichung gewinnt.

Die Punktzahl eines Räubers ist die Anzahl der Einreichungen, die er geknackt hat. Im Falle eines Unentschiedens wird die Gesamtbyte-Größe der von ihnen geknackten Einsendungen als Unentschiedener verwendet. Hier gewinnt die höchste Bytezahl.

Wie oben erwähnt, kann jeder Cop als Räuber teilnehmen und umgekehrt.

Ich werde separate Bestenlisten für die beiden Teile der Herausforderung führen.

Bestenlisten

Letzte Aktualisierung: 19.10.2014, 20:33 UTC

Polizei:

Beiträge in Kursivschrift sind noch nicht sicher.

  1. Nneonneo , 841 Bytes
  2. Wumpus Q. Wumbley , 10.602 Bytes
  3. Sp3000 , 52.506 Bytes
  4. user23013 , 53,884 bytes
  5. Nneonneo , 656.813 Bytes

Räuber:

  1. user23013 , Cracked: 11, Gesamtgröße : 733 + 30 + 2.447 + 71 + 109 + 121 + 97 + 60 + 141 + 200.127 + 7.563 = 211.499 Bytes
  2. nneonneo , geknackt : 10, Gesamtgröße : 4.842 + 12.371 + 150 + 3.571 + 96 + 168 + 395 + 1.043 + 458 + 17.372 = 40.466 Byte
  3. Wumpus Q. Wummelig , Gebrochen: 6, Gesamtgröße : 22 + 24 + 158 + 32 + 145.245 + 145.475 = 290.956 Bytes
  4. Dennis , Gebrochen: 2, Gesamtgröße: 70 + 73 = 143 Bytes
  5. harius , Gebrochen: 1, Gesamtgröße : 9.998 Bytes
  6. g.rocket , Gebrochen: 1, Gesamtgröße : 721 Bytes
  7. stokastisch , Gebrochen: 1, Gesamtgröße : 211 Bytes
  8. Sp3000 , Gebrochen: 1, Gesamtgröße : 133 Bytes
  9. TwiNight , Cracked: 1, Gesamtgröße : 39 Bytes
Martin Ender
quelle
6
Ich frage mich, wie viele Codezeilen wir zusammen geschrieben haben, um diese Rätsel zu konstruieren und zu lösen ... und ob es sich lohnen würde, alles zu sammeln und auf Github zu kleben, wenn wir fertig sind. Jeder kann beitragen, was er hat (Encoder, Decoder, Löser, die sowohl erfolgreich als auch erfolglos sind), so wie er ist, unkommentiert und hackisch, wie er auch sein mag. Mit einer README, wenn Sie Lust dazu haben. Es wäre wie bei unserer Konferenz.
Es werden zwar keine neuen Antworten mehr gepostet, aber es kann sich lohnen, die Frage irgendwann zu schließen. Andernfalls ist es möglich, dass jemand antwortet, wenn das Interesse nachlässt und länger unbestritten bleibt.
Nneonneo
@nneonneo Hm, ich mag es normalerweise nicht, meine Herausforderungen abzuschließen, aber in diesem Fall kann es eine gute Idee sein. Ich denke sogar, dass die letzten 3 Einträge bereits von weniger Aufmerksamkeit profitiert haben. Ich werde eine Frist für Freitag setzen.
Martin Ender
@ MartinBüttner: Ich denke, es muss Standard für Cops & Robbers-Herausforderungen sein, ein Ablaufdatum zu haben. Herausforderungen bleiben nur so lange interessant. (Für die Aufzeichnung, diese Herausforderung ist wahrscheinlich immer noch mein persönlicher Favorit, aber ich kann in dieser Meinung voreingenommen sein :)
nneonneo

Antworten:

19

.NET regulärer Ausdruck, 841 Byte [Sicher!]

Jetzt, da ich einen sicheren Zugang habe, wollen wir sehen, wie klein ich den regulären Ausdruck machen kann!

^(?<a>){53}((0(((?<-a>)(?<A>){7}|){997}((?<-b>)(?<B>){7}|){997}((?<-c>)(?<C>){7}|){997}((?<-d>)(?<D>){7}|){997}((?<-e>)(?<E>){7}|){997}((?<-f>)(?<F>){7}|){997}((?<-g>)(?<G>){7}|){997}(?<A>){5})|1(((?<-a>)(?<A>){3}|){997}((?<-b>)(?<B>){3}|){997}((?<-c>)(?<C>){3}|){997}((?<-d>)(?<D>){3}|){997}((?<-e>)(?<E>){3}|){997}((?<-f>)(?<F>){3}|){997}((?<-g>)(?<G>){3}|){997}(?<A>)))((?<-A>){997}(?<B>)|){9}((?<-A>)(?<a>)|){997}((?<-B>){997}(?<C>)|){9}((?<-B>)(?<b>)|){997}((?<-C>){997}(?<D>)|){9}((?<-C>)(?<c>)|){997}((?<-D>){997}(?<E>)|){9}((?<-D>)(?<d>)|){997}((?<-E>){997}(?<F>)|){9}((?<-E>)(?<e>)|){997}((?<-F>){997}(?<G>)|){9}((?<-F>)(?<f>)|){997}((?<-G>){997}|){9}((?<-G>)(?<g>)|){997}){256}$(?<-a>){615}(?(a)(?!))(?<-b>){59}(?(b)(?!))(?<-c>){649}(?(c)(?!))(?<-d>){712}(?(d)(?!))(?<-e>){923}(?(e)(?!))(?<-f>){263}(?(f)(?!))(?<-g>){506}(?(g)(?!))

Schön gemacht :

^(?<a>){53}
(
    (0(
        ((?<-a>)(?<A>){7}|){997}
        ((?<-b>)(?<B>){7}|){997}
        ((?<-c>)(?<C>){7}|){997}
        ((?<-d>)(?<D>){7}|){997}
        ((?<-e>)(?<E>){7}|){997}
        ((?<-f>)(?<F>){7}|){997}
        ((?<-g>)(?<G>){7}|){997}
        (?<A>){5})
    |1(
        ((?<-a>)(?<A>){3}|){997}
        ((?<-b>)(?<B>){3}|){997}
        ((?<-c>)(?<C>){3}|){997}
        ((?<-d>)(?<D>){3}|){997}
        ((?<-e>)(?<E>){3}|){997}
        ((?<-f>)(?<F>){3}|){997}
        ((?<-g>)(?<G>){3}|){997}
        (?<A>))
    )
    ((?<-A>){997}(?<B>)|){9}((?<-A>)(?<a>)|){997}
    ((?<-B>){997}(?<C>)|){9}((?<-B>)(?<b>)|){997}
    ((?<-C>){997}(?<D>)|){9}((?<-C>)(?<c>)|){997}
    ((?<-D>){997}(?<E>)|){9}((?<-D>)(?<d>)|){997}
    ((?<-E>){997}(?<F>)|){9}((?<-E>)(?<e>)|){997}
    ((?<-F>){997}(?<G>)|){9}((?<-F>)(?<f>)|){997}
    ((?<-G>){997}|){9}      ((?<-G>)(?<g>)|){997}
){256}$

(?<-a>){615}(?(a)(?!))
(?<-b>){59}(?(b)(?!))
(?<-c>){649}(?(c)(?!))
(?<-d>){712}(?(d)(?!))
(?<-e>){923}(?(e)(?!))
(?<-f>){263}(?(f)(?!))
(?<-g>){506}(?(g)(?!))

Eigenschaften:

  • Kurz , 841 Bytes
  • Golf gespielt und von Hand geschrieben
  • Es ist nicht bekannt, ob ein NP-hartes Problem vorliegt
  • Zeitüberschreitung bei den meisten ungültigen Eingaben :)
  • Getestet unter http://regexhero.net/tester/ , dauert die gültige Eingabe ca. 5 Sekunden

Vielen Dank an Sp3000 und user23013, die mich an .NET regex gewöhnt haben.


Nach 72 Stunden enthülle ich den Schlüssel, um diese Einreichung sicher zu machen.

Spiel :

1110111111110010000110011000001011011110101111000011101011110011001000000111111111001010000111100011111000000100011110110111001101011001000101111110010111100000000010110001111011011111100000011001101110011111011010100111011101111001110111010001111011000000

Nicht übereinstimmend :Aren'tHashFunctionsFun?

Erläuterung:

Dieser reguläre Ausdruck implementiert eine sehr einfache und ziemlich dumme Hash-Funktion. Die Hash-Funktion berechnet eine einzelne Ganzzahl xals Ausgabe. xBeginnt gleich 53. Es wird basierend auf jedem gefundenen Zeichen angepasst: Wenn es ein sieht 0, wird es gesetzt x = 7x + 5, und wenn es ein sieht 1, wird es gesetzt x = 3x + 1. xist dann mod 997 7 reduziert . Das Endergebnis wird gegen eine vordefinierte Konstante geprüft; Der reguläre Ausdruck stimmt nicht überein, wenn der Hash-Wert nicht gleich ist.

Sieben Erfassungsgruppen (ag) werden zum Speichern der Base-997-Ziffern verwendet x, wobei sieben weitere Erfassungsgruppen (AG) als temporärer Speicher dienen. Ich verwende die Erweiterung "Balancing Capture Groups" von .NET Regex, um Ganzzahlen in Capture Groups zu speichern. Technisch gesehen ist die jeder Erfassungsgruppe zugeordnete Ganzzahl die Anzahl der von dieser Gruppe erfassten nicht ausgeglichenen Übereinstimmungen. Das "Erfassen" einer leeren Zeichenfolge mit (?<X>)erhöht die Anzahl der Erfassungen und das "Ausgleichen" der Gruppe mit (?<-X>)verringert die Anzahl der Erfassungen (was zu einem Übereinstimmungsfehler führt, wenn die Gruppe keine Erfassungen hat). Beide können wiederholt werden, um feste Konstanten zu addieren und zu subtrahieren.

Dieser Hash-Algorithmus ist nur einer, den ich mir in Eile ausgedacht habe, und er ist der kleinste Hash-Algorithmus, den ich mir einfallen lassen konnte und der mit Additionen und Multiplikationen einigermaßen sicher erschien. Es ist definitiv keine Kryptoqualität und es gibt wahrscheinlich Schwachstellen, die es ermöglichen, eine Kollision in weniger als 997 7/2 Hash-Bewertungen zu finden.

nneonneo
quelle
Ich hatte eine Idee ... Dann gab ich auf, weil ich nicht mehr als 500 GB freien Speicherplatz auf meiner Festplatte habe.
Jimmy23013
3
Wenn ich es jetzt in 3 ungerissenen Einsendungen sehe, registriere ich offiziell meine völlige Unkenntnis des Zwecks des Konstrukts (?<a>){53}. Es scheint, als würde das leere Muster a53 Mal in einer benannten Gruppe erfasst . Also a=""52 mal wiederholen? Aber ich weiß nicht genau, ob (?<das in Microsofts Vorstellung von einem regulären Ausdruck dasselbe bedeutet. Ihre Dokumentation erwähnt es nicht einmal . Wenn sogar ein Regexp-Wettbewerb mit undokumentierten Microsoft-Erweiterungen endet, die über die Unix-Leute rollen, hat meine Existenz keinen Zweck.
Es ist eine Gruppenerfassung, die 53-mal nichts erfasst. .NET hat eine Erweiterung namens Balancing Group Captures, die ihre Antwort auf das Paren Matching ist. Jede benannte Gruppe verhält sich wie ein Stapel und (?<a>){53}drückt die leere Zeichenfolge 53 Mal. Sie können den Stapel mit öffnen (?<-a>). Hoffentlich ist jetzt klar, warum dieses Konstrukt so nützlich ist.
Nneonneo
2
@ WumpusQ.Wumbley Ich bin die Unix-Leute, die das nützlich fanden.
Jimmy23013
4
@ WumpusQ.Wumbley MSDN enthält eine ganze Seite zum Gruppieren von Konstrukten . Welches kann aus der Schnellreferenz gefunden werden . Welches ist der erste Treffer für ".net Regex-Referenz" , analog zu Ihrem Perl-Suchbegriff. (Gleiches gilt für "Syntax", "Handbuch" oder "Spezifikation").
Martin Ender
29

Basic Regex, 656813 Bytes [sicher!]

Der reguläre Ausdruck, um alle regulären Ausdrücke zu beenden. Ein letztes Hoch in die Nacht.

Testbar unter PCRE, Perl, Python und vielen anderen.

bzip2'd und base64-codierte Version auf Pastebin: http://pastebin.com/9kprSWBn (Pastebin wollte die Raw-Version nicht, weil sie zu groß war).

Um sicherzustellen, dass Sie den richtigen regulären Ausdruck erhalten, können Sie überprüfen, ob es sich um den MD5-Hash handelt

c121a7604c6f819d3805231c6241c4ef

oder überprüfen Sie, ob es mit beginnt

^(?:.*[^!0-9@-Za-z].*|.{,255}|.{257,}|.[U-Za-z].{34}[12569@CDGHKLOPSTWXabefijmnqruvyz].{8}[02468@BDFHJLNPRTVXZbdfhjlnprtvxz].{210}

und endet mit

.{56}[7-9@-DM-Tc-js-z].{121}[3-6A-DI-LQ-TYZabg-jo-rw-z].{28}[!0-9@-T].{48})$

Der Schlüssel ist immer noch eine schöne komfortable 256 Bytes.

Ich habe diesen Regex mit Python getestet, aber beachte, dass dieser Regex keine speziellen Funktionen von Python verwendet. In der Tat werden mit Ausnahme von (?:)(als Gruppierungsmechanismus) keinerlei Besonderheiten einer Regex-Engine verwendet: lediglich grundlegende Zeichenklassen, Wiederholungen und Verankerungen. Daher sollte es in einer großen Anzahl von regulären Ausdrucksengines testbar sein.

Nun, eigentlich kann ich die Schwierigkeit immer noch steigern, vorausgesetzt, jemand löst die kleineren Probleme nicht sofort ... aber ich wette, die Leute werden Probleme mit einem 1 GB großen Regex haben ...


Nach 72 Stunden bleibt dieser Beitrag ungerissen! So enthülle ich jetzt den Schlüssel, um die Einreichung sicher zu machen. Dies ist die erste sichere Einreichung, nachdem mehr als 30 Einreichungen von hartnäckigen Räubern hintereinander geknackt wurden.

Spiel : Massive Regex Problem Survives The Night!
Non-Spiel :rae4q9N4gMXG3QkjV1lvbfN!wI4unaqJtMXG9sqt2Tb!0eonbKx9yUt3xcZlUo5ZDilQO6Wfh25vixRzgWUDdiYgw7@J8LgYINiUzEsIjc1GPV1jpXqGcbS7JETMBAqGSlFC3ZOuCJroqcBeYQtOiEHRpmCM1ZPyRQg26F5Cf!5xthgWNiK!8q0mS7093XlRo7YJTgZUXHEN!tXXhER!Kenf8jRFGaWu6AoQpj!juLyMuUO5i0V5cz7knpDX0nsL

Regex Erklärung:

Der reguläre Ausdruck wurde aus einem "harten" 3SAT-Problem mit einer absichtlich eingeführten zufälligen Lösung generiert. Dieses Problem wurde unter Verwendung des Algorithmus von [Jia, Moore & Strain, 2007] generiert: "Generieren von hart erfüllbaren Formeln durch täuschendes Ausblenden von Lösungen". In jedes Byte des Schlüssels werden sechs boolesche Variablen gepackt, was insgesamt 1536 Variablen entspricht.
Der reguläre Ausdruck selbst ist recht einfach: Er drückt jede der 7680 3SAT-Klauseln als invertierte Bedingung aus (gemäß den Gesetzen von de Morgan) und stimmt mit jeder Zeichenfolge überein, die nicht mit einer der 3SAT-Klauseln übereinstimmt. Daher ist der Schlüssel eine Zeichenfolge, die nicht mit dem regulären Ausdruck übereinstimmt, dh eine Zeichenfolge, die alle Klauseln erfüllt.

nneonneo
quelle
1
Also habe ich gerade versucht, einen 60-MB-Regex in Python zu laden. Vorhersehbar war es nicht zu glücklich. Das Kompilieren dauerte einige Minuten, aber das Coole daran ist, dass die Beantwortung von Fragen fast augenblicklich erfolgte. Ich vermute, dass das Laden einer 1-GB-Regex in Python einige Stunden dauern wird ...
nneonneo
3
Oder nicht so einfach. Basierend auf meinem ersten Versuch, es auf eine lösbare Größe herunterzuschneiden, werden wir ungefähr 2 ** 61 CPUs benötigen, um rechtzeitig fertig zu werden.
12
Die Herausforderung beginnt: "Sie müssen einen kurzen , verschleierten
regulären Ausdruck
5
@Ypnypn Bisher bestand die Herausforderung darin, überhaupt einen unknackbaren Regex auf das Brett zu bekommen - dieser scheint der erste zu sein, der diese Barriere
durchbricht
3
@ MartinBüttner: Danke! Ich habe es getan. Jetzt muss ich los und versuchen, einige dieser anderen NP-harten Regex-Probleme ...
nneonneo
17

ECMAScript (10602 Byte)

(Sprachnotiz: Ich sehe viele Beiträge mit der Bezeichnung "Ruby" oder "Python" oder was auch immer, wenn sie wirklich keine sprachspezifischen Funktionen verwenden. Diese erfordern nur (?!...)und zusätzlich (?=...)zu POSIX ERE Rückverweise. Diese Funktionen sind wahrscheinlich in Die Regexp-Engine Ihrer Lieblingssprache. Lassen Sie sich also nicht von der Herausforderung abhalten, da ich mich für die Verwendung des Javascript-Onlinetesters entschieden habe.)

Nur ein bisschen Spaß, nicht so rechenintensiv wie einige andere.

^(?!(.).*\1.|.+(.).*\2)(?=(.))(?=(((?![ҁѧѦЩ]{2}).)*(?=[ҁѧѦЩ]{2}).){2}(?!.*[ЩѦҁѧ]{2}))(?=(((?![ɿqԼϚ]{2}).)*(?=[ϚqԼɿ]{2}).){2}(?!.*[ԼϚɿq]{2}))(?=((?![ϼλҡՄ]{2}).)*(?=[ҡλϼՄ]{2}).(?!.*[Մλϼҡ]{2}))(?=(((?![ʯֆɎF]{2}).)*(?=[FֆʯɎ]{2}).){2}(?!.*[FɎֆʯ]{2}))(?=(((?![AɔbУ]{2}).)*(?=[ɔbAУ]{2}).){3}(?!.*[ɔAbУ]{2}))(?=(((?![ʈͽՄɒ]{2}).)*(?=[ͽՄɒʈ]{2}).){2}(?!.*[ͽՄɒʈ]{2}))(?=(((?![ϙшѭϢ]{2}).)*(?=[Ϣϙѭш]{2}).){2}(?!.*[ѭшϙϢ]{2}))(?=(((?![ՐɏƋѠ]{2}).)*(?=[ƋՐɏѠ]{2}).){2}(?!.*[ѠƋՐɏ]{2}))(?=(((?![Жտʓo]{2}).)*(?=[Жտʓo]{2}).){2}(?!.*[Жʓտo]{2}))(?=(((?![ƆʙƸM]{2}).)*(?=[ƆʙMƸ]{2}).){2}(?!.*[ƆʙMƸ]{2}))(?=(((?![dNѤѯ]{2}).)*(?=[ѤѯNd]{2}).){2}(?!.*[ѤѯdN]{2}))(?=(((?![ҎvȵҜ]{2}).)*(?=[vҜȵҎ]{2}).){2}(?!.*[ҎvҜȵ]{2}))(?=(((?![ҹɀҀҤ]{2}).)*(?=[ɀҤҀҹ]{2}).){2}(?!.*[ҹҤҀɀ]{2}))(?=(((?![OɄfC]{2}).)*(?=[fOɄC]{2}).){3}(?!.*[ɄOfC]{2}))(?=((?![ǷϗЋԒ]{2}).)*(?=[ЋϗԒǷ]{2}).(?!.*[ԒϗЋǷ]{2}))(?=((?![էҹϞҀ]{2}).)*(?=[ҹҀէϞ]{2}).(?!.*[ϞէҹҀ]{2}))(?=(((?![QԶϧk]{2}).)*(?=[QkϧԶ]{2}).){2}(?!.*[ϧԶkQ]{2}))(?=(((?![cիYt]{2}).)*(?=[իYct]{2}).){2}(?!.*[tcYի]{2}))(?=(((?![ɐҷCɄ]{2}).)*(?=[CɄɐҷ]{2}).){3}(?!.*[CҷɐɄ]{2}))(?=(((?![ҥմѾϢ]{2}).)*(?=[ϢѾմҥ]{2}).){2}(?!.*[մϢѾҥ]{2}))(?=((?![Ϛǝjɰ]{2}).)*(?=[Ϛǝjɰ]{2}).(?!.*[jɰϚǝ]{2}))(?=((?![ϭBѾҸ]{2}).)*(?=[ѾҸϭB]{2}).(?!.*[ѾҸBϭ]{2}))(?=((?![ϼλyՎ]{2}).)*(?=[λՎyϼ]{2}).(?!.*[λՎyϼ]{2}))(?=((?![MԋƆƻ]{2}).)*(?=[ƻƆԋM]{2}).(?!.*[MƆԋƻ]{2}))(?=(((?![uԳƎȺ]{2}).)*(?=[uԳƎȺ]{2}).){3}(?!.*[ȺƎuԳ]{2}))(?=((?![ɂƐϣq]{2}).)*(?=[qϣƐɂ]{2}).(?!.*[ɂƐϣq]{2}))(?=(((?![ϫճωƺ]{2}).)*(?=[ωϫճƺ]{2}).){2}(?!.*[ճƺϫω]{2}))(?=((?![ζɏΞƋ]{2}).)*(?=[ɏƋζΞ]{2}).(?!.*[ɏƋζΞ]{2}))(?=(((?![Ӄxԏϣ]{2}).)*(?=[Ӄxԏϣ]{2}).){2}(?!.*[ԏxϣӃ]{2}))(?=(((?![ԈʄʫԻ]{2}).)*(?=[ԻʄԈʫ]{2}).){2}(?!.*[ʫԈԻʄ]{2}))(?=(((?![ɒէƣʈ]{2}).)*(?=[ʈɒէƣ]{2}).){2}(?!.*[ʈƣɒէ]{2}))(?=(((?![Ϥϟƺϫ]{2}).)*(?=[Ϥϫϟƺ]{2}).){3}(?!.*[ƺϫϤϟ]{2}))(?=((?![ɋȡþͼ]{2}).)*(?=[ȡþͼɋ]{2}).(?!.*[þͼȡɋ]{2}))(?=((?![ҡʈԄՄ]{2}).)*(?=[ʈԄՄҡ]{2}).(?!.*[ՄԄҡʈ]{2}))(?=(((?![ʌkȿՌ]{2}).)*(?=[Ռȿkʌ]{2}).){3}(?!.*[kՌȿʌ]{2}))(?=(((?![gǝժʮ]{2}).)*(?=[ǝgʮժ]{2}).){2}(?!.*[gǝʮժ]{2}))(?=((?![ɧƸȝՊ]{2}).)*(?=[ƸɧȝՊ]{2}).(?!.*[ՊȝɧƸ]{2}))(?=(((?![ɜȶʟɀ]{2}).)*(?=[ɀȶʟɜ]{2}).){3}(?!.*[ȶɀʟɜ]{2}))(?=((?![ƅѿOf]{2}).)*(?=[ѿfƅO]{2}).(?!.*[Oѿfƅ]{2}))(?=(((?![GҠƪԅ]{2}).)*(?=[ҠGԅƪ]{2}).){2}(?!.*[GԅƪҠ]{2}))(?=(((?![Һӻѩͽ]{2}).)*(?=[ӻͽҺѩ]{2}).){2}(?!.*[ͽҺѩӻ]{2}))(?=(((?![ʊLՅϪ]{2}).)*(?=[ՅʊLϪ]{2}).){3}(?!.*[LʊϪՅ]{2}))(?=(((?![ɅՈƪԅ]{2}).)*(?=[ƪԅՈɅ]{2}).){2}(?!.*[ԅՈƪɅ]{2}))(?=((?![ʇɊƈѹ]{2}).)*(?=[Ɋƈʇѹ]{2}).(?!.*[ʇƈѹɊ]{2}))(?=(((?![նЏYI]{2}).)*(?=[IYնЏ]{2}).){2}(?!.*[նЏIY]{2}))(?=((?![ͼխɷȡ]{2}).)*(?=[ͼȡɷխ]{2}).(?!.*[ɷխȡͼ]{2}))(?=((?![ҝɞҎv]{2}).)*(?=[ɞҎvҝ]{2}).(?!.*[Ҏҝvɞ]{2}))(?=(((?![eƪGω]{2}).)*(?=[Geƪω]{2}).){3}(?!.*[ƪeGω]{2}))(?=(((?![ɂɿƱq]{2}).)*(?=[Ʊqɿɂ]{2}).){2}(?!.*[Ʊqɂɿ]{2}))(?=((?![ƣЖoɒ]{2}).)*(?=[Жɒoƣ]{2}).(?!.*[ƣoɒЖ]{2}))(?=(((?![Ҵԉձϻ]{2}).)*(?=[ձԉϻҴ]{2}).){2}(?!.*[ϻԉձҴ]{2}))(?=((?![ɆɟѧE]{2}).)*(?=[EѧɆɟ]{2}).(?!.*[ѧEɆɟ]{2}))(?=((?![ѪɝȾѸ]{2}).)*(?=[ѪѸɝȾ]{2}).(?!.*[ѪѸȾɝ]{2}))(?=(((?![ßΩԂɥ]{2}).)*(?=[ɥΩßԂ]{2}).){2}(?!.*[ɥßԂΩ]{2}))(?=(((?![ӃդƐϣ]{2}).)*(?=[ƐդӃϣ]{2}).){2}(?!.*[ϣդƐӃ]{2}))(?=(((?![ѪլѸԿ]{2}).)*(?=[ԿѪѸլ]{2}).){2}(?!.*[ԿѪլѸ]{2}))(?=((?![ɉшƻϙ]{2}).)*(?=[ɉƻшϙ]{2}).(?!.*[ϙƻɉш]{2}))(?=((?![ѹփʯΨ]{2}).)*(?=[ʯփΨѹ]{2}).(?!.*[ѹʯփΨ]{2}))(?=((?![ƕϯʮҏ]{2}).)*(?=[ƕҏʮϯ]{2}).(?!.*[ҏϯʮƕ]{2}))(?=((?![ՌȿSբ]{2}).)*(?=[բՌSȿ]{2}).(?!.*[SȿբՌ]{2}))(?=(((?![ИщɌK]{2}).)*(?=[ɌщИK]{2}).){2}(?!.*[ɌИщK]{2}))(?=(((?![aҵɸւ]{2}).)*(?=[ւҵaɸ]{2}).){2}(?!.*[aւɸҵ]{2}))(?=(((?![լѸխɷ]{2}).)*(?=[ɷѸլխ]{2}).){2}(?!.*[խɷլѸ]{2}))(?=(((?![ՉLʝϥ]{2}).)*(?=[LϥʝՉ]{2}).){2}(?!.*[ՉϥʝL]{2}))(?=((?![ʬϬȝɣ]{2}).)*(?=[Ϭɣȝʬ]{2}).(?!.*[ȝɣϬʬ]{2}))(?=(((?![ɺȴҵւ]{2}).)*(?=[ȴɺҵւ]{2}).){3}(?!.*[ҵȴɺւ]{2}))(?=(((?![ΞʇɊζ]{2}).)*(?=[ζɊʇΞ]{2}).){2}(?!.*[ΞɊζʇ]{2}))(?=(((?![դփӃΨ]{2}).)*(?=[ΨփդӃ]{2}).){2}(?!.*[ΨփդӃ]{2}))(?=((?![ԳuҦc]{2}).)*(?=[uԳҦc]{2}).(?!.*[ҦucԳ]{2}))(?=(((?![ԻЭɌщ]{2}).)*(?=[ԻɌщЭ]{2}).){2}(?!.*[ɌщԻЭ]{2}))(?=((?![ЉջѮӺ]{2}).)*(?=[ӺЉѮջ]{2}).(?!.*[ѮӺЉջ]{2}))(?=(((?![ӿѤɹN]{2}).)*(?=[ӿɹѤN]{2}).){3}(?!.*[ѤNɹӿ]{2}))(?=(((?![ƕʮBg]{2}).)*(?=[Bʮgƕ]{2}).){3}(?!.*[Bʮgƕ]{2}))(?=((?![կƛȸԓ]{2}).)*(?=[ƛȸԓկ]{2}).(?!.*[կԓƛȸ]{2}))(?=(((?![ɥДȸh]{2}).)*(?=[ɥhДȸ]{2}).){2}(?!.*[ɥhȸД]{2}))(?=(((?![ʁԺեW]{2}).)*(?=[եWԺʁ]{2}).){2}(?!.*[ԺʁWե]{2}))(?=((?![ɮςϿʢ]{2}).)*(?=[ʢϿɮς]{2}).(?!.*[ɮςʢϿ]{2}))(?=(((?![ձУAƾ]{2}).)*(?=[ƾУձA]{2}).){2}(?!.*[УAձƾ]{2}))(?=(((?![ԻϠɌʄ]{2}).)*(?=[ʄɌԻϠ]{2}).){2}(?!.*[ϠɌʄԻ]{2}))(?=((?![ɜҥմȶ]{2}).)*(?=[ҥȶɜմ]{2}).(?!.*[ҥȶɜմ]{2}))(?=(((?![ƏՀթϞ]{2}).)*(?=[թՀƏϞ]{2}).){2}(?!.*[ƏՀթϞ]{2}))(?=((?![ҩɃȽϛ]{2}).)*(?=[ɃȽϛҩ]{2}).(?!.*[ҩϛɃȽ]{2}))(?=((?![ҠȺԃD]{2}).)*(?=[ȺҠԃD]{2}).(?!.*[DԃҠȺ]{2}))(?=((?![ɆʊLϥ]{2}).)*(?=[LϥʊɆ]{2}).(?!.*[ʊϥɆL]{2}))(?=(((?![ͽѩɒЖ]{2}).)*(?=[ͽɒѩЖ]{2}).){2}(?!.*[ѩɒЖͽ]{2}))(?=(((?![ςϪʢƩ]{2}).)*(?=[ƩʢςϪ]{2}).){3}(?!.*[ςƩϪʢ]{2}))(?=(((?![ҁϥѧɆ]{2}).)*(?=[ϥѧҁɆ]{2}).){2}(?!.*[ѧҁϥɆ]{2}))(?=((?![Жϗѩʓ]{2}).)*(?=[ʓϗЖѩ]{2}).(?!.*[ʓЖϗѩ]{2}))(?=(((?![ʁեɋþ]{2}).)*(?=[ʁɋեþ]{2}).){2}(?!.*[þեʁɋ]{2}))(?=((?![Mnƻɉ]{2}).)*(?=[Mɉƻn]{2}).(?!.*[ƻMnɉ]{2}))(?=(((?![HʬϬѺ]{2}).)*(?=[HѺʬϬ]{2}).){2}(?!.*[ϬѺʬH]{2}))(?=(((?![cիըҦ]{2}).)*(?=[ըҦիc]{2}).){2}(?!.*[cիҦը]{2}))(?=((?![ȸɥկΩ]{2}).)*(?=[ɥΩկȸ]{2}).(?!.*[ɥȸկΩ]{2}))(?=(((?![ʫҝԲɞ]{2}).)*(?=[ʫԲɞҝ]{2}).){2}(?!.*[ʫɞԲҝ]{2}))(?=(((?![ҺЋϗѩ]{2}).)*(?=[ѩҺϗЋ]{2}).){3}(?!.*[ҺѩЋϗ]{2}))(?=((?![ʯΨɎч]{2}).)*(?=[ʯΨɎч]{2}).(?!.*[ʯΨɎч]{2}))(?=(((?![ѮɔЉA]{2}).)*(?=[ЉɔѮA]{2}).){2}(?!.*[ѮɔAЉ]{2}))(?=(((?![ʞӶdN]{2}).)*(?=[dNʞӶ]{2}).){2}(?!.*[ӶNdʞ]{2}))(?=(((?![ԀŋҔɴ]{2}).)*(?=[ŋԀҔɴ]{2}).){3}(?!.*[ҔɴŋԀ]{2}))(?=(((?![ΠЪƏթ]{2}).)*(?=[ƏΠթЪ]{2}).){3}(?!.*[ΠթЪƏ]{2}))(?=(((?![OՌѿբ]{2}).)*(?=[ՌOբѿ]{2}).){2}(?!.*[OբՌѿ]{2}))(?=((?![ɮȾʢѪ]{2}).)*(?=[ɮȾʢѪ]{2}).(?!.*[ѪȾɮʢ]{2}))(?=((?![ЪϤՋΠ]{2}).)*(?=[ϤΠЪՋ]{2}).(?!.*[ՋΠЪϤ]{2}))(?=((?![Մͽӻϼ]{2}).)*(?=[ͽϼՄӻ]{2}).(?!.*[ϼͽՄӻ]{2}))(?=((?![ԋҳѦЩ]{2}).)*(?=[ѦԋЩҳ]{2}).(?!.*[ѦЩҳԋ]{2}))(?=((?![gҶҸB]{2}).)*(?=[BҶgҸ]{2}).(?!.*[ҸBgҶ]{2}))(?=(((?![ɢλҡѥ]{2}).)*(?=[λҡɢѥ]{2}).){2}(?!.*[ѥλɢҡ]{2}))(?=(((?![AϻЉձ]{2}).)*(?=[ϻձЉA]{2}).){2}(?!.*[ϻձЉA]{2}))(?=((?![tRիp]{2}).)*(?=[Rtpի]{2}).(?!.*[tpRի]{2}))(?=(((?![ɮȹϿÞ]{2}).)*(?=[ϿɮÞȹ]{2}).){2}(?!.*[ϿɮȹÞ]{2}))(?=((?![ϯժʮџ]{2}).)*(?=[ժџϯʮ]{2}).(?!.*[џϯʮժ]{2}))(?=(((?![HʬȠҨ]{2}).)*(?=[HҨȠʬ]{2}).){2}(?!.*[ȠҨʬH]{2}))(?=((?![ՒԉPϻ]{2}).)*(?=[ԉϻPՒ]{2}).(?!.*[PϻԉՒ]{2}))((?=Գ[նƎuc]|ƕ[Bʮȴҏ]|ϣ[ԏɂӃƐ]|Ʊ[ɿϬӄɂ]|Ѿ[ϭϢҸҥ]|ͽ[ѩӻՄɒ]|ɷ[խͼլ]|փ[դiѹΨ]|ϛ[ɅɃȽՀ]|Ԃ[ɥѭմß]|խ[ȡɐѸɷ]|P[ȠՒԉ]|ӷ[ЩEՊƆ]|Ə[ΠթƣϞ]|ч[xɎΨ]|ʄ[ԈϠԻҺ]|Љ[AѮϻջ]|ɒ[ʈƣЖͽ]|ʞ[ӶɔNЦ]|Ɛ[ϣɰqդ]|ʮ[ϯժƕg]|ɥ[ȸДԂΩ]|Ҕ[ŋՐɺɴ]|χ[Ԏѯ]|Ջ[ΠϤԾտ]|Ɏ[чʯֆ]|ҥ[մѬѾȶ]|ɞ[ҝҎԲ]|ҏ[ƕՐϯɺ]|Հ[ϛթϞw]|y[ϼԈҝՎ]|λ[ѥՎϼҡ]|Մ[ͽҡϼʈ]|ϟ[ϫϤԾ]|Ћ[ǷϠҺϗ]|ʫ[ԲԈҝԻ]|ǝ[gjɰժ]|Ԅ[ҡҹʟʈ]|ʌ[kՌэC]|ȶ[ҥЊɜʟ]|Ɍ[щИԻϠ]|ի[Rtըc]|Ո[ƪƺЪɅ]|ƺ[ՈϤϫω]|ß[ԂΩɜҤ]|I[նЏљ]|ҷ[ȡэCɐ]|Ц[ςbʞɹ]|Ǝ[ǂȺԳG]|ӄ[ƱӾѺ]|ʇ[ζiɊѹ]|ֆ[ɎF]|ɏ[ѠΞƋ]|Բ[ɞʫЭ]|Ի[ɌЭʫʄ]|ƪ[ԅωGՈ]|ȡ[խɋͼҷ]|Ϡ[ɌдʄЋ]|ɋ[эʁþȡ]|U[ɝɄՅʝ]|ɺ[ҵȴҏҔ]|Ƚ[ԅϛDҩ]|Ɋ[ƈʇΞ]|ժ[Φʮǝџ]|Ӿ[ӄɂԏ]|Ψ[Ӄчʯփ]|Ω[Ղկßɥ]|щ[KɌЭ]|ɉ[nҶшƻ]|Ժ[WԱե]|G[ƎeҠƪ]|ղ[կՂՑɃ]|Ӷ[ԷʞdѮ]|u[ȺԳQҦ]|Ѡ[ɴɏՐ]|ƛ[ԓՑѿկ]|ɜ[ɀմßȶ]|Ҵ[ԉձʡɧ]|ȿ[kSՌԃ]|ɂ[qӾϣƱ]|Պ[ӷɧƸʡ]|Щ[ѧѦӷԋ]|Ⱦ[ѪɝʢՅ]|Ƀ[ղҩwϛ]|Ҏ[vҜɞ]|ɐ[ҷɄɝխ]|ԏ[ϣxӾ]|Ҁ[ҹϞҤw]|մ[ԂҥɜϢ]|ҳ[ДԋϙѦ]|Ϛ[jɰqԼ]|w[ҀՀɃՂ]|E[ӷɟѧʡ]|У[μAbƾ]|ձ[ҴϻƾA]|ɟ[ɆμEƾ]|Ҥ[ҀßՂɀ]|v[ȵҎՎҝ]|ш[ϢϙɉҸ]|Ͽ[ɹɮςÞ]|O[fCՌѿ]|ʁ[ԶեWɋ]|ȹ[ÞԿɮ]|Ϟ[ՀէҀƏ]|ԋ[ƻҳЩƆ]|ƅ[fԓՉѿ]|ω[ƺeճƪ]|ʈ[ɒԄՄէ]|Ԉ[ʫʄӻy]|Ƌ[ζՐϯɏ]|ɰ[ǝƐΦϚ]|ȴ[ƕϭւɺ]|Δ[Չhҁԓ]|Π[ՋЪoƏ]|Ϫ[ʢƩʊՅ]|ӻ[ҺԈͽϼ]|ʝ[ՉLfU]|Ծ[ϟrՋ]|þ[ɋեͼ]|ӿ[ѤɹÞ]|բ[ՌՑSѿ]|ҡ[λՄɢԄ]|ɸ[ȻՃaҵ]|д[ϠИǷ]|ճ[ωϫл]|ɀ[ҹҤʟɜ]|л[ճeљ]|Ϥ[ϟЪƺՋ]|c[ԳYҦի]|Ռ[Oʌբȿ]|ն[ԳǂYI]|Ʌ[ԅϛՈթ]|ҝ[yɞʫv]|p[ƜRt]|ƣ[էƏɒo]|Ҷ[Ҹɉgj]|A[УձɔЉ]|Þ[ȹϿӿ]|Ƿ[дЋԒ]|k[QԶȿʌ]|ջ[ՒӺЉ]|Ɇ[ʊѧϥɟ]|ʢ[ςϪɮȾ]|ѭ[ДϢϙԂ]|ʘ[ЏƜt]|ѹ[ʇʯփƈ]|ʟ[Ԅȶɀɢ]|ϯ[ҏƋʮџ]|լ[ԿɷѸ]|Ƹ[ՊʙƆȝ]|N[ɹʞdѤ]|ς[ЦϿʢƩ]|ǂ[eƎљն]|ѧ[ɆEҁЩ]|ɴ[ѠҔԀ]|Ʉ[ɐfCU]|ҹ[ԄҀէɀ]|Ւ[ջPϻ]|ѥ[ɢλaՃ]|o[ΠտЖƣ]|g[BҶʮǝ]|Կ[լѪȹ]|Џ[ʘIY]|Y[ctЏն]|Ҡ[ȺDGԅ]|Ѧ[Щҁҳh]|Ѻ[HϬӄ]|ɹ[NЦϿӿ]|ԓ[ƛƅΔȸ]|f[OƅɄʝ]|L[ʝʊՅϥ]|ϼ[yӻλՄ]|џ[ζժiϯ]|ҩ[SɃȽՑ]|Ʃ[Ϫμbς]|դ[փƐӃΦ]|Ѯ[ӶӺЉɔ]|ƻ[ɉԋϙM]|ѩ[ҺϗͽЖ]|ʊ[μɆϪL]|Ж[ɒʓѩo]|B[ƕҸgϭ]|ԅ[ҠɅƪȽ]|ɔ[ʞѮAb]|ϗ[ЋʓԒѩ]|Ɔ[ӷMƸԋ]|љ[лǂI]|ȸ[ɥԓhկ]|q[ƐɿϚɂ]|Ҹ[шҶBѾ]|ʡ[ҴƾEՊ]|Ԏ[dχԷ]|j[ϚnǝҶ]|Ҧ[uըcϧ]|ϻ[ՒЉԉձ]|ʙ[ƸԼɣM]|ե[ʁþԺ]|Ƞ[PHҨ]|Φ[ɰդiժ]|Њ[ɢaѬȶ]|b[ɔƩЦУ]|Չ[ʝƅϥΔ]|ϧ[ԶҦWQ]|Ճ[ѥɸȵՎ]|Ҩ[ɧԉȠʬ]|ҁ[ΔѧѦϥ]|Ց[ҩƛղբ]|ɿ[qԼɣƱ]|μ[УƩɟʊ]|e[ωǂGл]|Һ[Ћʄѩӻ]|ѯ[dѤχ]|Ԓ[Ƿюϗ]|ҵ[ɸɺŋւ]|տ[Ջʓro]|ϙ[ѭƻҳш]|R[իԱp]|Ɯ[pʘ]|r[Ծюտ]|ƈ[ɊѹF]|M[ʙnƆƻ]|i[փʇΦџ]|ƾ[ձУʡɟ]|ɝ[ѸȾɐU]|ю[Ԓʓr]|Д[hҳѭɥ]|a[Њѥւɸ]|Յ[LUϪȾ]|ϭ[ѬBѾȴ]|Ѹ[Ѫɝխլ]|D[ԃȽҠS]|Ⱥ[ԃuƎҠ]|Ȼ[ŋȵɤɸ]|э[ʌԶҷɋ]|Ѥ[ѯӿN]|ԃ[ȺDȿQ]|ȵ[ҜȻՃv]|S[բȿҩD]|Ղ[ҤwΩղ]|ɢ[ѥҡʟЊ]|ɣ[Ϭɿȝʙ]|Վ[yvλՃ]|Ϭ[ɣʬƱѺ]|Ӄ[ϣxΨդ]|թ[ƏɅЪՀ]|ȝ[ʬƸɧɣ]|Ԁ[ɤɴŋ]|ѿ[ƅOƛբ]|H[ȠʬѺ]|F[ֆƈʯ]|Ѫ[ѸȾɮԿ]|է[ʈƣϞҹ]|ʯ[ѹFɎΨ]|ŋ[ȻҔԀҵ]|ɤ[ԀҜȻ]|ԉ[ҴPҨϻ]|ͼ[ȡɷþ]|t[իʘpY]|Ϣ[ѭմѾш]|Э[щԲԻ]|ɮ[ʢѪϿȹ]|ϫ[ƺճϟ]|Ѭ[Њւϭҥ]|Լ[Ϛnɿʙ]|Ξ[ζɊɏ]|Է[ԎӺӶ]|Q[ϧkԃu]|ւ[ҵaѬȴ]|Ր[ѠҏҔƋ]|ը[իԱWҦ]|ʓ[տϗюЖ]|K[щИ]|Ӻ[ԷѮջ]|x[чӃԏ]|И[KɌд]|ʬ[HҨȝϬ]|Ա[RըԺ]|ɧ[ȝҴՊҨ]|n[jɉMԼ]|C[ʌҷɄO]|W[ϧըʁԺ]|h[ДѦΔȸ]|ϥ[ՉLɆҁ]|Ъ[ΠՈϤթ]|կ[Ωղƛȸ]|ζ[џΞʇƋ]|Ҝ[ɤҎȵ]|Զ[ϧkʁэ]|d[ԎNѯӶ]).){3,}\3

Testen Sie hier: http://regex101.com/r/kF2oQ3/1

(Heuschrecken zirpen)

Keine Abnehmer? Es ist seltsamerweise enttäuschend, daran zu denken, den Spoiler ohne Anzeichen dafür zu veröffentlichen, dass jemand ihn lange genug angeschaut hat, um zu verstehen, um welche Art von Problem es sich handelt.

Ich schreibe eine vollständige Erklärung, um sie später zu veröffentlichen, aber ich denke, ich wäre glücklicher, wenn mich jemand schlagen würde.

Als ich sagte, es sei nicht "rechenintensiv" ... es ist eine Instanz eines NP-vollständigen Problems, aber keine große Instanz.

Tipp: Es ist eine Art Bleistift-Papier-Puzzle. Aber ich wäre ziemlich beeindruckt, wenn Sie dieses Problem allein mit Bleistift und Papier lösen könnten (nachdem Sie den regulären Ausdruck in eine für den Druck geeignete Form dekodiert haben).

Spoilerzeit

Es gibt hier mehrere Ebenen von Spoilern. Wenn Sie den regulären Ausdruck noch nicht gelöst haben, möchten Sie es möglicherweise erneut versuchen, nachdem Sie nur den ersten Spoilerblock gelesen haben. Der eigentliche Schlüssel, der mit dem regulären Ausdruck übereinstimmt, befindet sich nach dem letzten Spoilerblock.

Dieser reguläre Ausdruck kodiert ein Slitherlink- Puzzle.

Sobald Sie herausgefunden haben, was los ist, und die Regexp in ein Slitherlink-Raster konvertieren, werden Sie schnell feststellen, dass es schwieriger ist als der durchschnittliche Slitherlink. Es ist auf einem 16x16 Quadrat-Raster, größer als die üblichen 10x10. Es ist auch etwas ungewöhnlich, wenn man keine 0Anhaltspunkte und einen relativen Mangel an hat 3. 0und 3sind die einfachsten Anhaltspunkte, mit denen man arbeiten kann, deshalb wollte ich Ihnen nicht viele davon geben.

Slitherlink-Puzzle

Zweite Verderbnisschicht:

Wenn Sie das Slitherlink-Puzzle lösen, gibt es eine zusätzliche Überraschung: Dieser Slitherlink bietet mehr als eine Lösung. Wenn Sie ein gewöhnlicher Slitherlink-Löser sind und die Gewohnheit haben, Abzüge auf der Grundlage einer einzigartigen Lösung vorzunehmen, hat Sie dies möglicherweise verwirrt. Wenn ja, bist du ein Betrüger und das ist deine Strafe! Teil der Aufgabe eines Rätsellösers ist es, herauszufinden, wie viele Lösungen es gibt.

Letzte Verderbnisschicht:

Die letzte Wendung: Die beiden Lösungen für den Slitherlink sind größtenteils identisch, aber eine ist etwas länger als die andere. Sie müssen die kurze finden. Wenn Sie nur die lange gefunden und als Zeichenfolge codiert hätten, die mit dem regulären Ausdruck übereinstimmt, wäre die Zeichenfolge 257 Zeichen lang. Der Pfad führt durch 256 Knoten, aber Sie müssen den ersten Knoten am Ende wiederholen, um die Schleife zu schließen. Und wenn Sie so weit gekommen wären, hätten Sie vielleicht gedacht, ich hätte einen Fehler gemacht und vergessen, diesen zusätzlichen Charakter zu zählen. Nee! und / oder Gotcha! (und / oder Boosh! und / oder Kakow!)

Die kurze Lösung ist 254 Segmente lang und codiert eine Zeichenfolge von 255 Zeichen, die der Schlüssel ist. Da Sie an jedem Knoten in der Schleife beginnen und im oder gegen den Uhrzeigersinn vorgehen können, gibt es 254 * 2 = 508 mögliche Antworten.

Slitherlink-Lösung

Non-Match: bananabananabanana
Match: ƜpRԱԺեþɋэʌkȿՌOfɄCҷɐխɷլԿѪɮȹÞӿѤNɹЦʞӶdѯχԎԷӺջՒϻЉAɔbУƾձҴԉҨʬHѺӄӾԏxчɎֆFƈɊΞζџiփΨӃϣɂƱϬɣɿqϚɰƐդΦժʮgBƕȴւҵɺҏϯƋՐѠɴҔŋԀɤȻɸaЊѬҥѾҸшɉҶjnMʙƸՊʡEɟμƩςʢϪʊLՅȾɝUʝՉϥҁѧЩӷƆԋҳϙѭϢմԂɥȸhΔԓƛѿբՑҩSDȽԅҠGeωƪՈɅϛɃwҀҤՂΩßɜȶʟɀҹԄҡλѥՃȵҜҎɞԲЭщɌИдϠʄԻʫҝyϼӻҺЋϗѩͽɒʈէϞՀթЪΠƏƣoտʓюrԾϟϤƺϫճлљIնǂƎԳuȺԃQϧԶʁWըիcYЏʘƜ
Proof: http://regex101.com/r/pJ3uM9/2


quelle
Herzlichen Glückwunsch zu den 72 Stunden! Sie können Ihre Antwort jetzt gegen Knacken sperren, indem Sie den Schlüssel aufdecken. Bis Sie dies tun, kann die Antwort immer noch geknackt werden.
Martin Ender
Ich habe versucht, aber nicht gefunden, dass es planar ist ...
Jimmy23013
14

Perlgeschmack, 158 [geknackt]

Hier ist mein erster Versuch:

(?(R)|^(?=[a-z]))((?!.*(?&K))(((?|([?-K])|(?'K'$)|(?'k'j'k'?)|(?'k'C[^_^]{3,33}))(?(3)\3|3)){3}(?(R)R(-.-)|(?R))(?'k'<grc>-(?!(?&k))\4(?(R)|\$\4(?5)$)))|(?R))

Teste es auf ideone.com

(?(R)|^(?=[a-z]))Das allererste Zeichen muss ein Kleinbuchstabe sein.
(?!.*(?&K))Die Zeichenfolge darf keine Buchstaben im ASCII-Bereich enthalten. [?-K]
(?|...|(?'k'j'k'?)|...)Übereinstimmungen j'k(die anderen Gruppen sind im Wesentlichen rote Heringe)
(?(3)\3|3){3}stimmen rekursiv mit der dritten Gruppe
(?(R)...|(?R))überein gesamte Regex einmal oder mit ein paar Zeichen übereinstimmen
...(?!(?&k))...Ich denke, das ist [?-K]wieder so, aber ich kann mich nicht erinnern,
(?(R)|...$)nach der Rekursion, einigen Gruppen zu entsprechen und die Zeichenfolge zu beenden,
|(?R)wenn etwas nicht übereinstimmt, dann ist es Zeit für eine unendliche Rekursion: D

grc
quelle
4
Match: j'k3j'kj'k3j'kj'kj'k3j'k3j'kj'k3j'kj'kj'k3R-k-<grc>-j'k<grc>-j'k$j'k-k-Nicht-Match: HOLYCRAPTHATWASEVIL(Match verfügbar unter ideone.com/pXaGaX zum Beweis)
16
Jeder, der versucht hat, dieses Problem zu lösen und sich halbwegs durchgesetzt hat, ist jetzt bereit, 2 Fehlerberichte und 3 Dokumentations-Patches für die Perl-Regexp-Engine zu senden. (Und wir alle für verschiedene Dinge)
7
+1 für coole Schlüssel und mit Emoticon in Ihrem Regex[^_^] (-.-)
Hälfte
@ WumpusQ.Wumbley Gut gemacht! Ich denke, die Räuber gewinnen diesen :(
grc
3
Mein vorheriger Kommentar war größtenteils ein Witz, aber vielleicht wäre eine Erklärung nett. Die Verwendung von Namen Einfanggruppen innen (?|...)ist schwierig, aber es ist dokumentiert. Siehe die Passage perlre, die mit beginnt. Be careful when using the branch reset pattern in combination with named captures.Der Trick ist, dass Gruppen mit derselben Nummer, aber unterschiedlichen Namen dieselbe Gruppe sind , während Gruppen mit demselben Namen, aber unterschiedlichen Nummern unterschiedliche Gruppen sind .
12

JS-Geschmack, 9998 Bytes [geknackt]

^(?!.*(.).*\1)(?=M)((?=!7|!D|!a|!§|!¾|!Ö|!ù|!Ě|!į|!Ň|"C|"s|"t|"¡|"°|"»|"è|"ñ|"÷|"ķ|"ļ|"Œ|#W|#k|#l|#o|#q|#¶|#À|#Â|#Æ|#č|%!|%1|%O|%ÿ|%Ĕ|%Ğ|%Ī|%ĭ|&e|&q|&Õ|&æ|&ü|&đ|&Ĩ|'%|'`|'k|'¯|'É|'í|'þ|'ė|'Ğ|'ĩ|'IJ|'ļ|'ł|,%|,'|,l|,ª|,®|,¸|,¹|,ã|,õ|,Ċ|,Ġ|,Ī|,İ|,Ņ|-U|-V|-»|-Ï|-Þ|-ì|0_|0u|0°|0Ġ|0İ|0ł|1#|1-|1g|1å|1é|1ą|1Ļ|1ń|2B|2O|2¬|2ë|2ò|2õ|2Ğ|2ĩ|2į|2IJ|2ļ|3d|3²|3Ï|3Þ|3ß|3ç|3ø|3ĉ|3ķ|3ĸ|3Ŀ|4c|4£|4ß|4ã|4Ċ|4ģ|4Ĩ|4ő|4Œ|5&|5Q|5û|5Ā|5ě|5ĩ|6ú|6Ķ|6Ł|7Q|7V|7e|7²|7Á|7Þ|7à|7đ|7Ġ|7ĵ|8w|8¯|8¾|8ņ|8ő|9H|9Y|9i|:6|:s|:¬|:ð|:ü|:Ĉ|:Ċ|:Ĵ|:ĸ|:Ŀ|;X|;®|;¯|;²|;¸|;Ó|;à|;ĥ|;Œ|<-|<t|<å|<ø|<Į|<Ľ|<ō|=&|=l|=¨|=Á|=Ý|=Č|=Ĩ|=Ń|>-|>±|>¸|>Ä|>à|>ð|>ó|>Ī|@B|@F|@_|@³|@´|@Ó|@Ü|@ã|@û|@Ğ|@ğ|@Ĭ|@İ|@Ŀ|A5|AV|A_|Ax|A¹|AÅ|AĞ|AĶ|Aņ|Aō|B¼|BÂ|Bä|Bç|BĊ|Bį|Bİ|BĻ|BŅ|C1|C<|CG|Cy|C~|C¼|Cì|Cù|Cō|DT|DU|Dc|Dj|D¤|DÂ|DÑ|DĀ|Dİ|E,|E¬|E¼|E×|Eā|Eė|Eń|FZ|Ft|F»|F¿|FÈ|FØ|Fç|Fì|Fć|FĬ|Fı|FŅ|Gj|Gl|Gv|G¯|Gâ|Gï|GĖ|Gę|GĦ|Gĭ|H8|HB|HS|Hu|H¥|HÃ|HÌ|Hø|HĆ|HĒ|HĬ|Hĭ|I=|It|I©|Iæ|IĿ|Iō|J1|J3|J5|JQ|JÉ|JÔ|J×|Jă|JIJ|K-|KP|KÄ|Kî|Kā|KĐ|Kġ|KĨ|KĴ|L!|LÐ|Lá|LĚ|LĠ|M5|M¿|MÅ|Må|MĈ|MŊ|N,|N2|N5|NB|Nh|NÂ|NØ|NÜ|NĖ|Nĝ|NŃ|O;|Of|O¯|O¸|Oå|OĈ|Oď|Oē|OIJ|P7|PQ|Pp|P£|Pđ|PĴ|Pŀ|Q7|QR|Q¥|QÝ|Qî|Qī|Qĸ|Qŀ|Qő|R0|RA|RI|RN|R¥|R¼|Rö|Rû|RĬ|RĮ|RŎ|S;|SC|ST|Sd|Sy|S§|TX|Td|Tw|Tª|T¿|Tõ|U0|U:|UÊ|Uĉ|Uę|UĢ|UĦ|Uį|UĶ|Uň|V:|Vq|Vs|V¦|VÂ|Vó|Vþ|Wh|WÅ|WÉ|Wê|Wô|Wģ|Wň|X:|XI|XS|X`|Xâ|Xċ|Xė|XĠ|Xģ|Y"|YX|Yb|Yn|Yo|Y£|Y§|YÌ|YÎ|YÚ|Yá|Yă|YĜ|Yĥ|YĿ|Yʼn|Z6|Z:|Z;|Z¶|Zå|Zæ|Zċ|Zĺ|ZŊ|_,|_-|_c|_g|_à|_ĉ|_Ħ|_ł|`I|`z|`ð|`ă|`IJ|`ij|a4|a9|aF|a½|aä|añ|aď|aĝ|aĸ|b&|b7|b¸|bÝ|bë|bĺ|bņ|bŊ|c&|cP|cr|cÄ|cÑ|cÖ|cČ|cę|cĩ|cIJ|cķ|cĿ|d"|dI|d¥|d¦|dä|dģ|eK|e²|eý|eą|eČ|eĔ|eIJ|eĶ|eń|fM|fm|f¥|fÇ|fÒ|fæ|fì|fć|fě|fĝ|g!|gN|gx|gz|gÍ|gĚ|gĞ|h"|h¬|h¶|hä|hì|hï|hĆ|hņ|hŋ|hŏ|i'|i9|i¢|i¤|iÓ|iÖ|iā|iĕ|iĝ|iį|iĶ|jH|jT|j£|jµ|j·|jø|jĸ|jŐ|k0|k2|kA|k~|k¨|k½|kÙ|l&|lX|lc|ln|l£|l¥|lµ|lÃ|lå|lé|lĩ|lŌ|lŒ|m-|mW|mÐ|mĘ|mĮ|mĸ|n!|n2|nJ|nU|n¬|n½|nĆ|nĒ|nĔ|nĭ|nŇ|o5|o<|oD|oM|oÖ|oĂ|ps|pz|pº|pê|pĢ|pĥ|pIJ|qK|qa|q§|qÛ|qç|qý|qă|qĒ|qĴ|qĶ|qń|rA|re|rj|r§|r«|r¿|rÃ|rß|rò|rĔ|rĖ|rĢ|rķ|sD|sc|sÍ|sĀ|tT|tW|ta|t£|t¯|t±|tÊ|tÑ|tĚ|tļ|uV|ua|ub|uf|u¦|u´|u»|u¾|uË|uØ|uĞ|uĪ|uĹ|v:|vi|vw|v§|v½|vÄ|vÈ|vÌ|vù|vĮ|vļ|vʼn|vŎ|w!|w0|wZ|wg|wÞ|wæ|wò|wù|wĥ|wħ|wŎ|xD|x©|x®|xá|xû|xģ|xľ|xł|yC|ya|yr|y²|yÉ|yò|yĆ|yĠ|yĵ|yŒ|zM|zi|z¯|zø|zú|zć|zđ|~5|~Y|~¨|~º|~Û|~å|~ê|~ô|~ü|~ą|~ĥ|~Ī|~İ|~Ľ|~ō|¡J|¡±|¡¼|¡Ê|¡Ë|¡Ñ|¡ã|¡Ă|¡Ġ|¡Ĩ|¡ī|¡Œ|¢@|¢G|¢±|¢º|¢ç|¢Đ|¢İ|¢Ŀ|£F|£e|£Þ|£ä|£Ĵ|¤P|¤p|¤¯|¤µ|¤þ|¤ď|¤Ģ|¤ī|¥Z|¥¤|¥È|¥Ñ|¥û|¥Ď|¦T|¦Y|¦Z|¦a|¦b|¦e|¦q|¦r|¦¡|¦³|¦ĩ|¦IJ|¦ĺ|§b|§n|§w|§¿|§Ç|§Đ|¨3|¨Ã|¨Ë|¨Î|¨ë|¨÷|¨Č|¨ġ|¨Ī|¨Ĺ|¨ł|¨Œ|©I|©Z|©Ý|©ë|©ü|©ġ|©ŋ|ªP|ªo|ªr|ª¨|ª¯|ª²|ª¾|ªÇ|ªÔ|ªÙ|ªĉ|«K|«p|«£|«¨|«©|«¬|«®|«Õ|«Þ|«ß|«ö|«Đ|¬!|¬j|¬ª|¬¼|¬À|¬Ã|¬Ì|¬ú|¬ő|®#|®´|®É|®č|®đ|®ī|®ʼn|¯9|¯g|¯n|¯¹|¯È|¯Ē|¯ę|¯ġ|°N|°d|°k|°m|°s|°²|°È|°Î|°ê|°ó|°ʼn|±%|±R|±Y|±r|±æ|±Ŀ|±ń|²D|²H|²U|²×|²ã|²ä|²ç|²ą|²ħ|³`|³Ë|³ã|³ë|³ò|³ô|³ø|³Ċ|³Ĥ|³Ŀ|´~|´§|´Ê|´è|´Ķ|´Ŏ|µ:|µC|µ¢|µØ|µó|µĠ|µģ|µĤ|¶!|¶0|¶7|¶Y|¶¤|¶À|¶Ö|¶Ħ|¶ő|·p|·Á|·Ç|·ë|·î|·Ļ|·Ŋ|¸X|¸Z|¸¦|¸÷|¸ú|¸Đ|¸ĝ|¹,|¹>|¹M|¹Z|¹a|¹¢|¹Ì|¹×|¹Ø|¹þ|¹ĉ|¹Ĩ|º>|ºj|ºá|ºç|ºý|ºć|»2|»c|»°|»Ä|»ñ|»Ġ|»Ŋ|¼3|¼F|¼c|¼d|¼x|¼y|¼Ä|¼É|¼û|¼Č|¼ē|¼Ĩ|¼Ĭ|¼Ĵ|¼Ĺ|½k|½Ø|½ø|½ħ|¾2|¾:|¾L|¾¿|¾Á|¾ñ|¾ô|¾÷|¾đ|¾ĥ|¾Ń|¿D|¿«|¿ö|¿ø|¿Ĕ|¿ę|¿Ļ|¿ō|À3|ÀW|À°|ÀÆ|Àđ|ÀĘ|ÀĞ|Àģ|Àİ|Á§|Áé|Áõ|ÁĜ|Áĝ|ÁĪ|Áʼn|Â&|ÂB|ÂM|¿|Âø|Âħ|Âĺ|ÂĻ|ÂŁ|Âʼn|Ã`|Ãt|â|é|ÃĆ|ÃĖ|Ãĥ|Ãĩ|Ä_|Ä¥|ÄÌ|ÄÞ|Äð|ÄĆ|Äİ|ÄŁ|Å@|ÅY|Å«|ÅĄ|Åı|Åĸ|Æ;|ÆK|Æv|Ƶ|ƹ|ƽ|ÆÇ|ÆÛ|Æõ|Æü|ÆĆ|ÆĤ|Çd|Ǻ|ÇĔ|Çě|Çģ|ÇĶ|ÇĽ|Èd|Èz|È~|È´|Ƚ|ÈÂ|Èæ|Èõ|ÈŅ|ÉH|ÉO|ÉÌ|Éï|ÉČ|Éę|ÉĬ|Éĭ|ÉĴ|ÉŎ|Ê%|Ê6|ÊI|Êk|Êy|ʳ|ÊÁ|Êñ|Êą|ÊŃ|Ë!|ËH|Ëh|˺|Ë»|ËÆ|Ëğ|ËŌ|Ì3|Ì7|ÌG|Ìp|Ì«|Ìè|Ìï|ÌĮ|ÌŎ|ÍZ|Íd|Í©|ÍÖ|Íá|Íê|Íø|Íā|ÍŊ|Î-|Î_|ÎÊ|Îæ|Îó|Îù|ÎĀ|ÎĐ|Îġ|Îĭ|ÎŇ|Ï"|Ï5|Ï7|ÏA|ÏH|Ïl|ϱ|Ϲ|ÏÈ|ÏØ|ÏÚ|ÏÛ|ÏĻ|Ïʼn|ÐR|з|ÐÀ|ÐÓ|ÐĒ|Ðě|ÐĶ|Ðľ|Ñ©|ѵ|ÑÅ|ÑÈ|Ñʼn|ÒV|ÒÇ|Òĉ|Òħ|ÒŃ|Ó2|ÓD|ÓÎ|Óç|Ó÷|Óù|ÓĈ|Óķ|ÔE|ÔJ|Ôf|Ôy|ÔÆ|ÔÞ|Ôâ|ÔĂ|ÔĨ|Õ3|ÕG|Õh|Õ¹|ÕÁ|ÕÐ|Õÿ|Õğ|Õī|Ö7|ÖB|Öª|Ö¼|Öÿ|Öħ|Öij|×6|×>|×f|×¢|×µ|×·|×Â|×Ê|×Ñ|×ã|ØG|د|ØÄ|ØÊ|Øé|Øë|ØĊ|ØŇ|ØŐ|Øő|Ù:|Ùh|Ùx|Ù²|Ùč|Ùē|Ùę|Ùě|ÙĨ|ÙŇ|ÚE|Úq|Ú®|ÚÄ|ÚÒ|ÚÜ|Úä|Úí|Úı|Úķ|Û'|ÛW|Ûo|Ût|ÛÓ|Ûô|Ûõ|Ûû|Ûʼn|Ûŋ|Ü!|ÜJ|ÜÆ|ÜŐ|ÝR|Ýg|Ýq|Ýu|ÝÜ|Ýß|Ýð|Ýø|Ýč|ÝĶ|Ýʼn|Þº|ÞÝ|ÞĂ|Þą|Þć|ÞĠ|ÞĨ|ßu|ßÀ|ßė|à4|àS|à`|àk|à§|àé|àø|àĊ|àę|àģ|àĬ|á3|á£|á¶|áÄ|áÏ|áÑ|áâ|áü|áČ|áĽ|áņ|áŌ|â#|âY|â£|âº|âÓ|âġ|âĭ|âı|âŐ|âŒ|ã,|ã1|ã7|ã8|ãé|ãĭ|ä3|ä6|äN|ä¢|ä©|ä¬|äÏ|äĖ|äį|äŏ|åN|å¡|å¾|åØ|åë|åû|åč|åě|æ7|æT|æt|æ¸|æá|æï|æā|æij|ç2|çA|çJ|çl|ç¥|ç¬|çĝ|çĸ|èl|èq|èÓ|èÙ|èČ|èĖ|èĩ|èņ|èʼn|èő|éV|éZ|é®|é´|éí|éó|éû|éą|éě|éĭ|éŃ|ê5|êv|ê«|ê¶|êº|êÃ|êÔ|êİ|ëB|ëb|ë¤|ë¨|ëÎ|ëę|ëĞ|ì#|ì,|ì=|ì>|ìQ|ìS|ìV|ìº|ìā|ìġ|íJ|íV|í~|í¶|íò|íø|íă|íė|íĭ|î<|î=|îD|îR|îµ|îÚ|îÛ|îå|îê|îþ|îĒ|îĜ|îğ|ï%|ï,|ïa|ïu|ïÀ|ïÁ|ïá|ïĄ|ïą|ïċ|ïġ|ïĿ|ïŁ|ïŌ|ð6|ðE|ðp|ð¬|ðÞ|ðä|ðĚ|ðğ|ðļ|ñ1|ñ2|ñX|ñi|ñá|ñú|ñû|ñü|ñį|ñŊ|òB|ò«|ò¿|òÝ|òê|òď|ó5|óÄ|óÇ|óÈ|óÓ|óÕ|óĨ|óļ|ô4|ôh|ôÖ|ôî|ôþ|ôğ|ôŅ|õo|õ¢|õ¶|õÆ|õÓ|õä|õČ|õĕ|õģ|ö7|ö@|ön|ö¢|öÉ|öÒ|öÛ|öâ|öĝ|÷-|÷J|÷p|÷Ò|÷Ģ|÷ĭ|÷ı|÷ʼn|ø,|øo|ø¥|øÆ|øç|øè|øù|øĤ|øĥ|øħ|øň|ù7|ù9|ùs|ùu|ù¹|ùÍ|ùĆ|ùę|ùě|ùĹ|úG|úÅ|úÕ|úÖ|úÜ|úã|úç|úĂ|úĦ|û%|û;|ûR|ûh|ûu|ûz|û´|ûÐ|ûë|ûń|ûŊ|ü_|ü²|üê|üē|üğ|üł|üŅ|ý8|ý¨|ý©|ýÍ|ýÜ|ýĄ|ýċ|ýĩ|ýı|ýIJ|ýĸ|ýł|ýň|ýŎ|þ;|þD|þJ|þT|þr|þ·|þè|þĆ|ÿO|ÿÒ|ÿæ|ÿð|ÿć|ÿğ|ÿŇ|ĀA|ĀR|Ā_|Āv|Āá|ĀĘ|Āģ|Āİ|ā6|āM|ā¸|āä|āĮ|ĂX|ĂÁ|ĂÕ|ĂĚ|Ăķ|ĂĹ|ă"|ă°|ă¸|ăÉ|ăĆ|ăĚ|ăğ|ăĸ|ăĻ|ăŃ|ĄG|ĄJ|ĄK|Ą`|Ąc|Ąd|Ąg|Ąl|Ą³|ĄÄ|ĄÊ|ĄÌ|Ąú|ĄĽ|ą;|ąL|ąc|ąd|ąo|ąr|ą®|ą±|ąÄ|ąÅ|ąÇ|ąÍ|ą×|ąĈ|ąĎ|ąĐ|ąĩ|ąŌ|Ć´|Ƹ|Ć¼|ĆÑ|ĆØ|Ćí|ĆĊ|Ćņ|ĆŌ|ć4|ćx|ćy|ć¦|ć«|ćù|ćŃ|Ĉ&|Ĉ8|ĈE|ĈK|Ĉn|Ĉ¨|Ĉà|Ĉé|Ĉû|Ĉđ|Ĉĥ|ĈĪ|Ĉī|Ĉņ|ĉ@|ĉa|ĉÇ|ĉ×|ĉĩ|ĉň|Ċ#|Ċb|Ċt|Ċ»|ĊÁ|ĊÚ|Ċä|Ċÿ|Ċĝ|Ċĩ|Ċį|ċ'|ċD|ċ¶|ċÖ|ċê|ċþ|ċğ|ċņ|ČM|Čs|Č£|ČĨ|Čį|č±|čÖ|čè|čć|čğ|čń|čʼn|Ď`|Ď¡|Ď·|Ď¾|Ď¿|Ďą|Ďij|Ďŋ|ď"|ď5|ď8|ď=|ďD|ďs|ďØ|ďÚ|ďí|ďġ|ďĩ|ďļ|ĐF|ĐS|Đg|Đk|Đn|Đv|Đ~|ĐÖ|ĐÚ|ĐÜ|Đâ|ĐĞ|đA|đf|đ´|đ¸|đ¿|đÈ|đÖ|đà|đĽ|đŀ|đŌ|Ē%|ĒH|ĒÍ|ĒĹ|ĒĻ|ĒŁ|ĒŃ|ĒŇ|ē;|ēG|ēa|ēe|ēq|ē¶|ē»|ē÷|ēň|Ĕ"|Ĕ4|ĔÃ|Ĕý|Ĕą|ĔĆ|ĔĚ|ĔĞ|ĔĨ|ĕ"|ĕm|ĕw|ĕ¨|ĕ®|ĕÌ|ĕÑ|ĕĤ|Ė#|ĖR|Ėe|Ėu|Ė~|Ė¯|Ėĩ|ĖĬ|ėH|ė¹|ėö|ėú|ėÿ|ėĨ|Ęs|ĘÝ|Ęą|ĘČ|Ęĝ|Ęī|Ęĺ|Ęʼn|ęA|ęk|ęp|ę»|ęè|ęą|ęĐ|ęĨ|Ě'|Ě9|Ěe|Ěm|Ěo|Ě£|Ěª|Ě¾|Ěå|Ěë|Ěă|ĚĎ|ĚĜ|ĚĞ|ěP|ěx|ěê|ěî|ěö|ěĂ|ěĤ|ěĭ|ěļ|Ĝ%|ĜÜ|ĜĽ|ĝJ|ĝh|ĝ¹|ĝÃ|ĝÈ|ĝĖ|ĝĞ|ĝŇ|ĝŒ|Ğ&|Ğe|Ğs|ĞÖ|ğX|ğ²|ğ´|ğ¼|ğÙ|ğò|ğĂ|ğđ|ğĕ|ğĨ|ğĬ|ĠB|Ġc|Ġµ|ĠÈ|Ġè|Ġì|Ġđ|Ġě|ġ5|ġ<|ġH|ġm|ġº|ġÒ|ġü|ġă|ġĶ|ġŀ|Ģ;|Ģ¤|Ģ«|ĢÍ|ĢØ|Ģù|Ģă|ĢĐ|Ģđ|ģ-|ģL|ģ«|ģë|ģþ|ģċ|ģČ|ģĨ|ģĻ|Ĥf|Ĥª|Ĥñ|ĥM|ĥN|ĥU|ĥf|ĥz|ĥ»|ĥõ|ĥň|Ħ`|Ħj|Ħu|Ħ°|Ħ´|ĦÁ|ĦÈ|ĦÕ|Ħæ|ĦĤ|ħ4|ħp|ħ¡|ħ¦|ħ¶|ħß|ħç|ħĴ|ħĵ|ĨC|Ĩ°|ĨÂ|ĨÌ|Ĩç|Ĩõ|ĨĔ|Ĩŏ|ĩ8|ĩl|ĩt|ĩw|ĩċ|ĩđ|ĩĥ|ĩī|ĩŅ|Ī4|Ī9|ĪP|Īz|Ī±|ĪÅ|ĪÈ|ĪÝ|Īä|Īđ|ĪĦ|ĪĬ|ĪĽ|īb|īl|ī¥|ī¦|īÌ|īì|īČ|īĎ|īĐ|Ĭ#|Ĭ4|ĬF|Ĭ¤|Ĭê|Ĭí|Ĭû|Ĭĝ|ĬŌ|ĭ1|ĭK|ĭL|ĭz|ĭ¡|ĭ¯|ĭÌ|ĭâ|ĭĘ|ĭě|ĭĺ|ĮM|ĮR|Įd|Įx|Į¤|ĮÃ|ĮË|ĮÚ|Įå|ĮĤ|ĮĦ|Įī|į&|įD|įI|į¥|į«|įÉ|įÕ|įÛ|įĉ|įđ|įĒ|İQ|İi|ݬ|ݾ|İÕ|İ×|İĄ|İĬ|İľ|ı4|ıa|ıd|ıe|ıf|ı¡|ıĐ|ıĖ|ıIJ|IJ:|IJT|IJU|IJm|IJÛ|IJķ|IJŎ|ij0|ijb|ij¢|ij«|ijé|ijí|ijĎ|ijĘ|ijķ|Ĵ#|ĴF|ĴG|Ĵµ|Ĵ¹|ĴÈ|ĴÏ|Ĵý|Ĵþ|ĴĖ|ĵ8|ĵE|ĵK|ĵ¦|ĵ±|ĵÙ|ĵó|ĵõ|ĵĹ|Ķ6|ĶE|Ķl|Ķm|Ķ£|Ķ²|ĶÅ|Ķ÷|ĶĀ|Ķă|ĶĆ|ķv|ķ«|ķå|ķĢ|ķŌ|ĸ9|ĸH|ĸ¼|ĸè|ĸý|ĸĕ|ĸį|ŧ|Ĺ·|ĹÇ|ĹÈ|Ĺġ|Ĺĩ|ĺ#|ĺ6|ĺp|ĺr|ĺu|ĺæ|ĺí|ĺĖ|Ļ@|ĻI|Ļn|Ļ£|Ļ¶|ĻÂ|Ļú|ĻĮ|ĻŎ|ļ=|ļK|ļO|ļ_|ļ´|ļÀ|ļÄ|ļó|Ľ>|ĽC|ĽD|ĽG|ĽZ|Ľk|Ľr|Ľ¼|ĽÌ|Ľâ|ĽĮ|ĽŒ|ľf|ľÙ|ľÞ|ľĂ|ľī|ľł|ľņ|ĿÊ|Ŀď|Ŀđ|ĿĚ|Ŀĵ|ĿĻ|Ŀŏ|ŀC|ŀM|ŀ®|ŀà|ŀð|ŀõ|ŀČ|ŁE|ŁÁ|ŁÄ|Łõ|Łķ|ŁĿ|ł4|łG|łu|ł¬|łÏ|łò|łČ|łč|łĐ|łŌ|Ń6|Ń¿|ŃÅ|ŃË|ŃÚ|Ńü|Ńě|Ńņ|ń4|ń<|ńE|ńx|ń»|ńÄ|ńď|ńĺ|Ņ,|ŅP|Ņe|Ņn|Ņo|Ņ©|Ņ¯|Ņ½|ŅÛ|ŅĂ|ņî|ņð|ņô|ņĈ|ņī|ņĬ|ņı|Ň8|Ň:|ŇD|ŇT|Ň_|Ňd|Ňu|Ňª|Ňā|Ňć|ŇĈ|Ňň|ňK|ňL|ň¬|ňÇ|ňÏ|ňþ|ňĐ|ňĠ|ňŐ|ʼnQ|ʼn_|ʼnf|ʼnÉ|ʼnË|ʼnĨ|ʼnŃ|Ŋ0|ŊM|ŊW|ŊÔ|ŊĠ|ŋC|ŋH|ŋK|ŋÍ|ŋÒ|ŋØ|ŋÞ|ŋı|ŋĹ|Ō,|Ōl|Ō³|Ōò|Ōā|ŌĖ|ŌĚ|ŌĬ|ŌĮ|Ōĸ|ŌŒ|ōJ|ō¿|ōÀ|ōÝ|ōʼn|Ŏ8|Ŏ;|ŎQ|ŎV|Ŏ§|ŎÄ|ŎÏ|ŎĎ|ŎŇ|ŏ=|ŏD|ŏV|ŏ¹|ŏÈ|ŏÒ|ŏč|ŏĐ|ŏī|ŏĿ|ŏʼn|Ő2|Ő<|ŐC|ŐX|Őg|Ől|Őp|Ő®|Őİ|ő8|ő¹|őÀ|őó|őć|őĊ|őĖ|őĦ|őķ|őĸ|őŀ|ŒB|Œv|ŒÀ|ŒÒ|Œā|Œĉ|Œė|ŒĜ|ŒĦ|Œķ|Œľ).){255}Ň$

Getestet auf Regex101

Jede übereinstimmende Zeichenfolge ist ein Hamilton-Pfad von Mbis Ň.
Ich weiß, das ist nicht sicher genug. Ich weiß auch nicht, wie man Probleme mit dem Hamilton-Pfad erzeugt. Es gibt zu viele Lösungen. Und wie Martin Büttner sagte, hat Mathematica das sofort getan . Dies ist jedoch nur ein anderer NP-vollständiger Ansatz als der von COTO. Fühlen Sie sich frei, diese Idee zu verbessern und neue Antworten zu posten.
Die ursprünglich von mir generierte Lösung lautet: https://regex101.com/r/tM1vX8/2

Die Lösung, die ich generiert habe:

MĈàękÙēGâġ<øÆv:ĴÏĻĮ¤ĢùĹ·îĜĽDÂŁEā6ĶĆŌĸ¼yò¿Ĕýı¡Ë!į&qKPpzđȽħ¶YÌïÁéVþèlåN2O¸úÜŐİľfćx®čńďļ=¨3d"÷ĭ¯9i'ĞsĀAÅĄ³`ðĚmĘĝŒBç¬ő¹>-ìS§nUĉňĠěĤª¾ôŅ,ĊtÊIĿĵ±RĬíăÉČĨŏĐÖij0°²ã1gÍáÑʼnŃÚÒÇģLÐĒ%ĪĦu¦añû´~ą;ĥ»créüêºjµó5ĩċğĕwŎÄ¥ĎŋØëÎæTXėH8ņībŊÔÞÝßÀWhäĖeIJÛõÓķ«ö7QŀCōJ×¢@_ł4£FZĺ#oĂÕÿŇ
jimmy23013
quelle
3
Übereinstimmungen : Siehe regex101.com/r/wK9hI1/1 Nicht übereinstimmen: good_job_user23013!
harius
14
Ich stelle mir vor, dass wir gerade in zwei Lager aufgeteilt sind: die, die CPU brennen und auf Glück hoffen, und die, die versuchen, P = NP in ein paar Tagen zu beweisen.
1
@ WumpusQ.Wumbley Und die von uns mit Mathematica. ;)
Martin Ender
2
Da Harius nicht kommentieren kann, wie er es geknackt hat, werde ich kurz umreißen, wie ich es gemacht habe: Das Muster kodiert tatsächlich einen gerichteten Graphen mit 256 Eckpunkten (dargestellt als Zeichen) und 2270 Kanten (dargestellt als Zeichenpaare, die zulässig sind konsekutiv sein) und jede Übereinstimmung ist ein Hamilton-Pfad durch diesen Graphen von Mbis Ň. Mathematica hat eine Funktion FindHamiltonianCycle. Wir können dies in einen Zyklus verwandeln, Ň -> Mindem wir eine neue Kante hinzufügen und sie verbinden Ňund Mdurchlaufen. Zum Glück findet Mathematica einen solchen Zyklus sofort. :)
Martin Ender
1
Nun, ich bin 3., aber ich wollte trotzdem meinen eigenen Pfadfinder fertigstellen. Es gab mir Folgendes
10

JS-kompatibler RegEx - 3.571 Bytes [geknackt]

Ich ... werde ... mindestens ... eine ... ungerissene ... Vorlage haben. o \ __ / o

[^,;]|^(.{,255}|.{257,})$|^(?!.*,;,,;;)|^(?!.*,;;,,;)|^(?!.*..,;;;,..,.)|^(?!.*.,.;.;.,.,,)|^(?!.*....,,....;;.;.;)|^(?!.*;.{8};,;;;..)|^(?!.*.{8};;.{6};,.,;)|^(?!.*..;....,.;;.{5};;...)|^(?!.*;,.;.{7},...;.{6};...)|^(?!.*...,.,..,,...,.{7};....)|^(?!.*.,;.;.{11};.{9};..,.)|^(?!.*.,.{6},....;.{11};,...,)|^(?!.*..;.{5};....,.{6};,.{12};.)|^(?!.*,,.,,.{8};.{11};.{10})|^(?!.*...,.{9};..,....;.{6},...;.{8})|^(?!.*.{6},.{8},.{6},.{8},..;.,....)|^(?!.*.{7};..;.{5},....;.{10};...;.{9})|^(?!.*..;.{7},.{5};;.{12},.{13},.)|^(?!.*.{5},..;...;.{5};..;.{6},.{22})|^(?!.*.{10},.{8},.{6},;.{14};.;.{6})|^(?!.*..,.;...,.{19};.;..;.{22})|^(?!.*.{6};..;.{14},,.{11};....,.{13})|^(?!.*.{8},.{12};.{19},.{6},;.{6},....)|^(?!.*.,.{11},...,.{7},.{16},.{11},.{6})|^(?!.*.{15};.{7};..;..,.{24},.{7},...)|^(?!.*...,,.{25};...;...;.{19},.{7})|^(?!.*.{26},....,....,.{15},.{6},.{6};....)|^(?!.*.{6};.,.{28};.{6},.{21},.;..)|^(?!.*.{21};..;..,.{22},.{21};,..)|^(?!.*.{5};.{22};,.{17};.{18},,.{8})|^(?!.*.{9};.{25};,.{20},.{6},.{14};.)|^(?!.*.,.{9},.{8};.{8};.{10};.,.{38})|^(?!.*.{18};.{8},.,.;.{5};.{6},.{41})|^(?!.*.{15},.{16};.{7};.{17};.{8};..,.{15})|^(?!.*.{18};.,.{25};..,..;.{13};.{24})|^(?!.*.{10};.{16},.{33};...;.{17},....,..)|^(?!.*.{13},.{46},.{9},.{11},,.,.{10})|^(?!.*.{14},.{33},.{18};....,.;.{16},....)|^(?!.*.{16};....;,.{8},.{30},.{31},.{6})|^(?!.*.{9},;.{15};.{22};.{30},.{16};...)|;.,,;;.;|,;,;,.,.|.;;,.;;;|;.;,,,.;|,...;.;.,,.;.|,.,.;.{5},,;|...;;....;;;;|;..,,,.;..;..|..;;,,..;.{7};.|;..,.,,...;...,...|...;;,.,.;.;.{6}|.;...;,....;.;...,|.;.{8};,.{6},.;.;|.{5},...,...;...;.;..;|...;....;..,..,.;..;...|...;.{5};,.{5},...,.;|;.,.{12},..;;.{7};|...;.{5},..;;.{9},..;.|.;,,..;.{13};....;..|.,;.{15},,...,.,..|.{8};.,....,...,..,.{9};|...;.;.{11},..,...;....;...|.,.,.{9};;....;..,.{10}|.{5};.,;....,.{15};..,|....;.{10};.;....,.{10},;...|....;.{8};;.{6},...;.{5};.{6}|..,;;.{16};....,;.{10}|.{18};.{9};,.,.,..;.|.{11},.{10};.;.;.{10};....,|....;.{11},.{10},..;.,.;.{8}|..,....,.;.{5},.{9},.{7};.{9}|.{7};.;.{5},.{13};.;.{7};...|.{5},.{15};;.{5},.{15},..;|.{12};...;..,.,..;.{5},.{17}|.{12},..;...;.{22},.,..,|.{10},.{11},.,.;.{11};;.{8}|.{11},.{9},.{5},...,.{14};.;....|;.{22};....,.;.{10};.{10};|.{13};...;.{13},.{6};.,.{10};.|.{11};....;.{17},.{9},.{5};,.|,.{14},.{12};.{6};...;.{14};...|..;.;.{19},.{16},.{5};.{6},...|.{27};..,;.{8};;.{8};.{7}|,.{6};.,.{20},.{13},.;.{11}|.{12};.{9},.{8};,.,.{17},.{10}|;.{22};..;.{5},..;....,.{22}|.{6},.{19};.{22};;,.{5};.{5}|;.{5},.{10};..;.;;.{39}|.{11};.{7};.;.{23};.{19};.;|,.{13};.{12},.,.{27};.{6},...|...;.;.{9};.{18};.;.{27},...|...;,.{12},..;.{28},.{15};..|....;.{8};..;...;.{17},.{19},.{14}|.{8};.{29};.{17};.{5};.{5};;...|...,..;.{14},.{8};.{12};.{18},.{10}|..;.;.{7};.{17},.{11},.{24},.{5}|;.{17},.;.{29};.{9};....;.{12}|.{5},..,.{6},.{16};;.{15},.{28}|...,.{12};..;.{10};.{31};.{14};|.{24},.{6},.{22},.,..,.{10};.{7}|.{10},.{12},.{5};.{12},.{7};.{23};.{8}|.{19};.,.{6},.{22},,.{7};.{22}|.{27};,.{14},..,.{7};.{15},.{12}|....;.{18},.{22},,..,.{27};....|...,.{11},.;.;.{9},.{46},.{11}|.{19},....,.{23},.{5},.{7};.{14},.{10}|.{19};,.{11};..,.{11};.{23};.{16}|.{11};.{34},.{14},.{9},.;.{13};|.{11};....,.{41},.{9};;.{8};.{14}|.{5};.;.,.{5};...;.,.{71}|.{6};.{13};....;....;.{20};.{24},.{16}|.{26};,.{19};....;.{11},.;.{26}|.{9},.{9},.{21},.{14};.{10};.{16};.{13}|.{10},.{5},.{9};.{13},...,.{24},.{28}|.{12},.{7};.{8};.{6};;.{36};.{23}|....;.{10},.{21};.{10};.{20},.{10},.{17}|.{19},.{7},.{17},.{9};.{13},.{22};.{10}|....,.{41};.{5},..,.{21};.{6};.{18}|.{25};....;.{28},.{12},.{19};.{8};.|.{10};....,.,.{22};.{11};.{44},.{5}

Löst sich auf praktisch jeder Saite sofort. Auf jeder JS-Konsole testbar.

+100 Wiederholungen für jeden, der dieses Biest knackt.

COTO
quelle
1
Herausforderung angenommen ...
Unihedron
10
Spiel : ThatWasActuallyFun. Nicht-Spiel : ,,;,;,,;,;;;,;,;,;;,,,,;,,,;,;;,,,,,,;;,,,,;;,;,,,;,;;;;,;;,;;,;,,;,,;,;;;,;,;,;;,,,;,;;;;,;,;;;,;,,;,,,;,,,,;,;;;;;;,,,,,;,;,;;;;;,;;;,;;,,,;;;,,;,;;,,,;,,,,,,;,;,,;;,,;;,,,;,;;,,,;,,;;,;,;,;;;;,,;,;,,;;;;;,,;,,;;,,;,,;;,,,,;,,;,,;;,;;;,,,,,;,,,,,,,,;,,,,.
Nneonneo
5
BITTE! NICHT! SEIN! DAMIT! SCHNELL!
TwiNight
6
Alter, du bist verrückt, diese RegExp hat 122 Abwechslungen, von denen 40 negative Lookaheads sind, WTG ++
CSᵠ
2
@nneonneo: Miese effiziente SAT-Löser. > ___ <Aber Requisiten, um das Problem zu transformieren und die verfügbaren Tools zu nutzen. Ich werde die 100 Wiederholungen so schnell wie möglich an eine Ihrer Antworten vergeben, was ungefähr 19 Stunden entspricht.
COTO
10

PCRE - 96 Byte UTF8, keine Begrenzer, keine Flags

[Besiegt] weil Nneonneo ein Weiser ist

(?<Warning>[You] \Will (*FAIL)!|\So just (*SKIP)this one!|\And (*ACCEPT)defeat!|[^\d\D]{16,255})

Hier gibt es nichts zu sehen, mach weiter ...

CSᵠ
quelle
1
Spiel So just *SKIPthis one!:; Keine This string is not accepted. This string is not accepted. This string is not accepted. This string is not accepted. This string is not accepted. This string is not accepted. This string is not accepted. This string is still not accepted. Snow leopards FTW.
Übereinstimmung
Dies ist keine PCRE-Syntax. Es ist eine einfache Perl-Syntax. (Die Backtracking-Modifikatoren funktionieren nicht auf PCRE, AFAIK)
nneonneo
6
Spiel : Do just this one!. Nicht-Spiel : WellThatWasTooEasy. (Getestet mit Perl 5.12 und Perl 5.18 auf meinem Computer)
nneonneo
@nneonneo richtig! PS: * VERBS gibt es in PCRE seit mindestens 5 Jahren, allerdings nicht ausreichend dokumentiert.
CSᵠ
@ COTO die Übereinstimmung ist falsch, NonMatch ist in Ordnung.
CSᵠ
8

JS-kompatibler RegEx - 733 Bytes [geknackt]

Versuchen wir es ein zweites Mal mit umgekehrten Metriken: einem massigen regulären Ausdruck, aber einem relativ kleinen Schlüssel (vor allem innerhalb der 256-Byte-Grenze).

[^a-e]|^(?:.{0,33}|.{35,}|.{11}.(?!babcde).{22}|.{17}.(?!daacde).{16}|.{23}.(?!ecacbd).{10}|.{29}.(?!ab).{4}|.{31}.(?!cd)..|(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.).(?!\4\8\1\2\3\10|\6\3\11\2\9\1|\6\2\9\3\4\11|\8\10\6\5\3\1|\1\8\4\5\3\7).{22}|(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.).{6}.(?!\15\14\16\19\21\12|\17\12\22\13\16\15|\19\14\12\20\18\21|\16\22\19\14\20\12|\21\19\13\18\15\22).{16}|(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.).{12}.(?!\31\32\24\28\26\23|\33\25\30\29\27\32|\28\27\23\24\29\30|\31\33\23\29\26\32|\26\28\25\24\23\33).{10}|(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.).{18}.(?!\34\39|\37\38|\34\37|\36\42|\43\41|\35\38|\40\35|\44\42).{4}|(.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.).{20}.(?!\51\45|\53\54|\47\46|\45\54|\50\51|\53\45|\52\51|\52\48|\48\55)..)$

Löst sich auf praktisch jeder Saite sofort. Getestet auf RegExr.

Erweitert (der Einfachheit halber):

[^a-e] |
^(?:
    .{0,33}|
    .{35,}|
    .{11}.(?!babcde).{22}|
    .{17}.(?!daacde).{16}|
    .{23}.(?!ecacbd).{10}|
    .{29}.(?!ab).{4}|
    .{31}.(?!cd)..|
    (.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.).(?!\4\8\1\2\3\10|\6\3\11\2\9\1|\6\2\9\3\4\11|\8\10\6\5\3\1|\1\8\4\5\3\7).{22}|
    (.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.).{6}.(?!\15\14\16\19\21\12|\17\12\22\13\16\15|\19\14\12\20\18\21|\16\22\19\14\20\12|\21\19\13\18\15\22).{16}|
    (.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.).{12}.(?!\31\32\24\28\26\23|\33\25\30\29\27\32|\28\27\23\24\29\30|\31\33\23\29\26\32|\26\28\25\24\23\33).{10}|
    (.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.).{18}.(?!\34\39|\37\38|\34\37|\36\42|\43\41|\35\38|\40\35|\44\42).{4}|
    (.)(.)(.)(.)(.)(.)(.)(.)(.)(.)(.).{20}.(?!\51\45|\53\54|\47\46|\45\54|\50\51|\53\45|\52\51|\52\48|\48\55)..
)$

Viel Glück an alle. ;)

COTO
quelle
5
Spiel aaaabaaacaaadaaacacdbbcabdeababcdedaacdeecacbdabcd
:,
@ user23013: Ich habe einen Riss erwartet, aber nicht ganz so schnell. Hast du es auf Papier gemacht?
COTO
1
Ja. Nach den ersten beiden langen Ausdrücken gibt es nur noch zwei Möglichkeiten. Und es gibt nur ein Zeichen, das nach drei nicht mehr bekannt ist, also kann ich einfach ein paar Mal versuchen, die Lösung zu finden.
Jimmy23013
8

.NET-Geschmack, 60 Bytes [geknackt]

^((\d)(?!(|(\d\d)*\d|(\d{3})*\d\d|(\d{5})*\d{4}|\d{6})\2))+$

Getestet mit Regex Storm .

Dennis
quelle
3
Spiel: 1234567890012345. Nicht-Spiel: 1111222233334444.
Jimmy23013
8
٠߀०০੦૦୦௦౦೦൦๐໐༠၀႐០᠐᥆᧐᭐᮰᱀᱐꘠꣐꤀꩐0Das sind also alle Ziffern in .NET ...
Jimmy23013 16.10.14
2
Das ist wahnsinnig, die Hälfte von denen ist nicht mal richtig in meinem Browser zu sehen
Sp3000 16.10.14
7

Python-Geschmack: 211 Bytes [geknackt]

Hinweis: Diese Antwort wurde vor der Regeländerung zur maximalen Schlüssellänge veröffentlicht

Dachte, ich würde den Ball ins Rollen bringen:

(((((((((((((((\)\\\(58\)5\(58\(\\5\))\15\)9)\14\\919\)\)4992\)5065\14\(5)\13\\\14\\71\13\(\13\)4\\\13\\)\12\12\\28\13)\11)\10\\7217)\9\\)\8\\04)\7\)\(\8\()\6\(183)\5)\4\)65554922\\7624\)7)\3\)8\(0)\2\4\\8\\8)\1

(Getestet auf RegExr )


Einfache Rückverweisauflösung der Zeichen \()0123456789

Sp3000
quelle
Ich kann Ihnen sagen, dass die akzeptierte Zeichenfolge ca. ist. 7 Millionen Zeichen lang. Was die tatsächliche Darstellung betrifft, vielleicht eine 7-MB-Textdatei irgendwo?
COTO
Ja, das ist so ziemlich der einzige Weg. Ich dachte, ich würde mit etwas anfangen, das nicht schwer zu entziffern ist, aber der Trick lag in der Generierung der Ausgabe. Wenn das
Minutenlimit
Wenn Sie die meines Erachtens einzige Zeichenfolge eingeben, die Ihrer Regex bei RegExr.com entspricht, stürzt mein Chrome-Browser zuverlässig ab. In Safari funktioniert es, aber RegExr meldet eine Zeitüberschreitung. Haben Sie es erfolgreich online getestet?
Emil
@Emil Ich habe es erfolgreich in Firefox getestet. Und ich warte immer noch darauf, es zu retten.
Jimmy23013
5
Der Schlüssel ist 5281064 Bytes nach meiner Zählung. Datei hier
hochgeladen
7

JS-kompatibler RegEx - 12.371 Bytes [geknackt]

Nach einiger Ermutigung von Martin, und zu sehen , dass andere Cops glücklich 600+ KB Regexes einreichen, entschied ich mich mit dem Sprung noch einmal zu übernehmen diesem (und prettified Version hier ).

Löst sich auf praktisch jeder Saite sofort. Auf jeder JS-Konsole testbar. Leider ist es aufgrund seiner Größe für viele Online-Regex-Tester nicht überprüfbar.

COTO
quelle
Ahaha, ich werde versuchen, nicht verrückt nach Regex-Größen zu werden - diese Herausforderung ist jedoch schwierig: / incriminates @ user23013
Sp3000 17.10.14
2
Spiel : this was not NP-hard. Non-Match :nerdnydeprdoypoypwwwdprelwsprwssddayaeeeysyaaaypowroplsaoprdaolasnoylaeaeadeosladnnosyoywyesorlrydwddadoeyponneeyaaapesenaalnneydaewndplredlerwaawlnrssapapaopnrdwnslowdoanlrernpwyyarpprwnrssdlaopsnnrnnnardpaessldalroleswnnooarlpllasapsesaorardwreylayrr
Nneonneo
Ich habe es nur brachial durchgesetzt (in Python hat es ~ 0,06 Sekunden gedauert) und vier zulässige Lösungen erhalten, aber aufgrund eines Fehlers in Ihrer Regex weist Ihre Regex viele weitere Lösungen zurück. (Grundsätzlich prüfen Sie nicht, ob jedes Zeichen in einer bestimmten "Teilzeichenfolge" verwendet wird, und Sie prüfen nicht, ob eine "Teilzeichenfolge" nur aus 84 Zeichen besteht.)
nneonneo
1
(Letzte Anmerkung: regexpal.com handhabt diesen regulären Ausdruck einwandfrei . Ich vermute, er verwendet wahrscheinlich nur die reguläre Ausdrucks- Engine des Browsers.)
Nneonneo
1
Bei 12 KB muss keine Verbindung zu einer externen Quelle hergestellt werden. SE-Antworten können aus bis zu 30.000 Zeichen bestehen.
Martin Ender
7

.NET-Geschmack, 458 Bytes [geknackt]

^(?=[01]{10},[01]{10}$)(0|1((?<=^.)(?<l>){512}|(?<=^..)(?<l>){256}|(?<=^...)(?<l>){128}|(?<=^.{4})(?<l>){64}|(?<=^.{5})(?<l>){32}|(?<=^.{6})(?<l>){16}|(?<=^.{7})(?<l>){8}|(?<=^.{8})(?<l>){4}|(?<=^.{9})(?<l>){2}|(?<=^.{10})(?<l>){1})(?(l)(?<-l>(?=.*,(?:0|1(?<m>){512})(?:0|1(?<m>){256})(?:0|1(?<m>){128})(?:0|1(?<m>){64})(?:0|1(?<m>){32})(?:0|1(?<m>){16})(?:0|1(?<m>){8})(?:0|1(?<m>){4})(?:0|1(?<m>){2})(?:0|1(?<m>){1})$))|){1024})*,(?<-m>){669043}(?(m)(?!)|)

Dieser ist einfach. Aber ich werde später einen härteren Beitrag schreiben.

Ich denke, ich bin der kryptografisch sicheren Antwort ziemlich nahe.

Auf RegexStorm getestet .

Hierbei handelt es sich im Wesentlichen um eine ganzzahlige Faktorisierung. Die übereinstimmende Zeichenfolge sollte die binäre Darstellung von zwei Ganzzahlen Aund sein B. Für jede 1 aus A, wird 512, 256, ..., 1 mal Gruppe l, die hinzugefügt werden kann, um zu erhalten A. Und für jedes Mal l, wird es passen BLook - Ahead verwendet und Bmal Gruppe m, die ähnlich AZeiten l. So mwird insgesamt A*Bmal abgestimmt . Schließlich wird die Gruppe m669043 mal entfernt und geprüft, ob keine weiteren vorhanden sind m. So A*Bmuss genau 669043. sein Aus

Gründen der Einfachheit: 669043 = 809 * 827und die Lösung ist die binäre Form dieser beiden Zahlen.

Diese Methode funktioniert nicht mit zu großen Zahlen, um die Sicherheit zu gewährleisten, da die Regex-Engine die Zahl um ein Vielfaches erhöhen muss. Aber ich habe eine neue Antwort gepostet , um mit Basis 289-Ganzzahlen zu arbeiten. Es hat ein 1536 Bit langes Produkt.

Vielen Dank auch an Martin Büttner für die Einführung der Bilanzkreisfunktion von .NET Regex in seiner Antwort .

jimmy23013
quelle
Diese Idee, wow ...
Sp3000
4
Spiel : 1100101001,1100111011. Non-Match :ThatsWhatIWantedToDo,Nice
Nneonneo
1
Ich denke, das einzige Problem ist, dass die Übereinstimmung exponentiell lange dauert und dass die Ziel-Ganzzahl als Wiederholungszahl ausgedrückt werden muss (daher ist sie höchstwahrscheinlich auf 32/64/128 Bits beschränkt, die alle für den Faktor trivial sind). Ich habe einige Ideen, wie ich diese Einschränkungen mit der Karatsuba-Multiplikation überwinden kann, aber dann erhalte ich log (n) ^ 2 große reguläre Ausdrücke ...
nneonneo
1
@ SP3000 pastebin.com/SW0YbQar Dies funktioniert. Ich bin mir nicht sicher warum. Vielleicht ist der Entwickler der Meinung, dass es keinen Sinn macht, leere Zeichenfolgen wiederholt abzugleichen.
Jimmy23013
1
@ Sp3000: überhaupt keine Überraschung; Sie fordern im Grunde die Regex-Engine auf, bis 800000+ zu zählen. Dies wird sehr langsam sein (insbesondere, wenn das "Zählen" über eine virtuelle Maschine mit Evaluator für reguläre Ausdrücke erfolgt).
Nneonneo
6

JS-kompatibler RegEx - 2.447 Bytes [geknackt]

Mein letzter Versuch.

Ich hoffe, dass dies mindestens ein paar Stunden dauert, bevor es geknackt wird. Danach gebe ich auf. : P

[^a-f]|^(?:.{0,51}|.{53,}|.{11}.(?!d).{40}|.{12}.(?!a).{39}|.{13}.(?!a).{38}|.{14}.(?!f).{37}|.{15}.(?!d).{36}|.{16}.(?!a).{35}|.{17}.(?!d).{34}|.{18}.(?!c).{33}|.{19}.(?!f).{32}|.{20}.(?!d).{31}|.{21}.(?!d).{30}|.{22}.(?!d).{29}|.{23}.(?!f).{28}|.{24}.(?!d).{27}|.{25}.(?!b).{26}|.{26}.(?!f).{25}|.{27}.(?!f).{24}|.{28}.(?!e).{23}|.{29}.(?!c).{22}|.{30}.(?!c).{21}|.{31}.(?!b).{20}|.{32}.(?!d).{19}|.{33}.(?!e).{18}|.{34}.(?!c).{17}|.{35}.(?!a).{16}|.{36}.(?!a).{15}|.{37}.(?!e).{14}|.{38}.(?!b).{13}|.{39}.(?!f).{12}|.{40}.(?!d).{11}|.{41}.(?!f).{10}|.{42}.(?!c).{9}|.{43}.(?!f).{8}|.{44}.(?!e).{7}|.{45}.(?!c).{6}|.{46}.(?!b).{5}|.{47}.(?!b).{4}|.{48}.(?!f).{3}|.{49}.(?!a).{2}|.{50}.(?!d).{1}|....(.)(.)(.).....(?!\1|\2|\3).{40}|.(.).(.)..(.).....{1}.(?!\4|\5|\6).{39}|...(.)(.).....(.).{2}.(?!\7|\8|\9).{38}|......(.)(.).(.)..{3}.(?!\10|\11|\12).{37}|....(.)(.)(.).....{4}.(?!\13|\14|\15).{36}|..(.)(.)(.).......{5}.(?!\16|\17|\18).{35}|(.).(.)......(.)..{6}.(?!\19|\20|\21).{34}|..(.).....(.).(.).{7}.(?!\22|\23|\24).{33}|(.)..(.)(.).......{8}.(?!\25|\26|\27).{32}|...(.).....(.)(.).{9}.(?!\28|\29|\30).{31}|.(.)(.).....(.)...{10}.(?!\31|\32|\33).{30}|.(.)...(.)..(.)...{11}.(?!\34|\35|\36).{29}|(.)(.).....(.)....{12}.(?!\37|\38|\39).{28}|...(.).(.).(.)....{13}.(?!\40|\41|\42).{27}|..(.)(.)..(.).....{14}.(?!\43|\44|\45).{26}|(.).(.)....(.)....{15}.(?!\46|\47|\48).{25}|(.)..(.)...(.)....{16}.(?!\49|\50|\51).{24}|(.)(.)(.).........{17}.(?!\52|\53|\54).{23}|.(.)..(.)(.)......{18}.(?!\55|\56|\57).{22}|(.)...(.)..(.)....{19}.(?!\58|\59|\60).{21}|.......(.)(.)(.)..{20}.(?!\61|\62|\63).{20}|.(.).....(.).(.)..{21}.(?!\64|\65|\66).{19}|..(.)..(.)...(.)..{22}.(?!\67|\68|\69).{18}|..(.).(.).....(.).{23}.(?!\70|\71|\72).{17}|...(.).(.)..(.)...{24}.(?!\73|\74|\75).{16}|.(.)(.)(.)........{25}.(?!\76|\77|\78).{15}|(.).(.).....(.)...{26}.(?!\79|\80|\81).{14}|.....(.)..(.).(.).{27}.(?!\82|\83|\84).{13}|(.).(.).(.).......{28}.(?!\85|\86|\87).{12}|..(.)...(.)..(.)..{29}.(?!\88|\89|\90).{11}|(.)....(.)..(.)...{30}.(?!\91|\92|\93).{10}|....(.).(.).(.)...{31}.(?!\94|\95|\96).{9}|...(.)..(.)(.)....{32}.(?!\97|\98|\99).{8}|..(.)..(.)..(.)...{33}.(?!\100|\101|\102).{7}|..(.).(.)(.)......{34}.(?!\103|\104|\105).{6}|..(.)(.)..(.).....{35}.(?!\106|\107|\108).{5}|.(.).....(.)(.)...{36}.(?!\109|\110|\111).{4}|..(.)....(.)(.)...{37}.(?!\112|\113|\114).{3}|...(.)..(.)...(.).{38}.(?!\115|\116|\117).{2}|....(.)(.)....(.).{39}.(?!\118|\119|\120).{1})$

Wie alle vorherigen Übermittlungen wird es sofort aufgelöst. Im Gegensatz zu früheren Einsendungen ist es für RegExr zu lang.

Erweitert:

[^a-f]|
^(?:
    .{0,51}|
    .{53,}|
    .{11}.(?!d).{40}|
    .{12}.(?!a).{39}|
    .{13}.(?!a).{38}|
    .{14}.(?!f).{37}|
    .{15}.(?!d).{36}|
    .{16}.(?!a).{35}|
    .{17}.(?!d).{34}|
    .{18}.(?!c).{33}|
    .{19}.(?!f).{32}|
    .{20}.(?!d).{31}|
    .{21}.(?!d).{30}|
    .{22}.(?!d).{29}|
    .{23}.(?!f).{28}|
    .{24}.(?!d).{27}|
    .{25}.(?!b).{26}|
    .{26}.(?!f).{25}|
    .{27}.(?!f).{24}|
    .{28}.(?!e).{23}|
    .{29}.(?!c).{22}|
    .{30}.(?!c).{21}|
    .{31}.(?!b).{20}|
    .{32}.(?!d).{19}|
    .{33}.(?!e).{18}|
    .{34}.(?!c).{17}|
    .{35}.(?!a).{16}|
    .{36}.(?!a).{15}|
    .{37}.(?!e).{14}|
    .{38}.(?!b).{13}|
    .{39}.(?!f).{12}|
    .{40}.(?!d).{11}|
    .{41}.(?!f).{10}|
    .{42}.(?!c).{9}|
    .{43}.(?!f).{8}|
    .{44}.(?!e).{7}|
    .{45}.(?!c).{6}|
    .{46}.(?!b).{5}|
    .{47}.(?!b).{4}|
    .{48}.(?!f).{3}|
    .{49}.(?!a).{2}|
    .{50}.(?!d).{1}|
    ....(.)(.)(.).....(?!\1|\2|\3).{40}|
    .(.).(.)..(.).....{1}.(?!\4|\5|\6).{39}|
    ...(.)(.).....(.).{2}.(?!\7|\8|\9).{38}|
    ......(.)(.).(.)..{3}.(?!\10|\11|\12).{37}|
    ....(.)(.)(.).....{4}.(?!\13|\14|\15).{36}|
    ..(.)(.)(.).......{5}.(?!\16|\17|\18).{35}|
    (.).(.)......(.)..{6}.(?!\19|\20|\21).{34}|
    ..(.).....(.).(.).{7}.(?!\22|\23|\24).{33}|
    (.)..(.)(.).......{8}.(?!\25|\26|\27).{32}|
    ...(.).....(.)(.).{9}.(?!\28|\29|\30).{31}|
    .(.)(.).....(.)...{10}.(?!\31|\32|\33).{30}|
    .(.)...(.)..(.)...{11}.(?!\34|\35|\36).{29}|
    (.)(.).....(.)....{12}.(?!\37|\38|\39).{28}|
    ...(.).(.).(.)....{13}.(?!\40|\41|\42).{27}|
    ..(.)(.)..(.).....{14}.(?!\43|\44|\45).{26}|
    (.).(.)....(.)....{15}.(?!\46|\47|\48).{25}|
    (.)..(.)...(.)....{16}.(?!\49|\50|\51).{24}|
    (.)(.)(.).........{17}.(?!\52|\53|\54).{23}|
    .(.)..(.)(.)......{18}.(?!\55|\56|\57).{22}|
    (.)...(.)..(.)....{19}.(?!\58|\59|\60).{21}|
    .......(.)(.)(.)..{20}.(?!\61|\62|\63).{20}|
    .(.).....(.).(.)..{21}.(?!\64|\65|\66).{19}|
    ..(.)..(.)...(.)..{22}.(?!\67|\68|\69).{18}|
    ..(.).(.).....(.).{23}.(?!\70|\71|\72).{17}|
    ...(.).(.)..(.)...{24}.(?!\73|\74|\75).{16}|
    .(.)(.)(.)........{25}.(?!\76|\77|\78).{15}|
    (.).(.).....(.)...{26}.(?!\79|\80|\81).{14}|
    .....(.)..(.).(.).{27}.(?!\82|\83|\84).{13}|
    (.).(.).(.).......{28}.(?!\85|\86|\87).{12}|
    ..(.)...(.)..(.)..{29}.(?!\88|\89|\90).{11}|
    (.)....(.)..(.)...{30}.(?!\91|\92|\93).{10}|
    ....(.).(.).(.)...{31}.(?!\94|\95|\96).{9}|
    ...(.)..(.)(.)....{32}.(?!\97|\98|\99).{8}|
    ..(.)..(.)..(.)...{33}.(?!\100|\101|\102).{7}|
    ..(.).(.)(.)......{34}.(?!\103|\104|\105).{6}|
    ..(.)(.)..(.).....{35}.(?!\106|\107|\108).{5}|
    .(.).....(.)(.)...{36}.(?!\109|\110|\111).{4}|
    ..(.)....(.)(.)...{37}.(?!\112|\113|\114).{3}|
    ...(.)..(.)...(.).{38}.(?!\115|\116|\117).{2}|
    ....(.)(.)....(.).{39}.(?!\118|\119|\120).{1}
)$
COTO
quelle
2
Spiel: aaaabaaacaaadaaa. Nicht-Spiel: fdeacdbfbdcadaafdadcfdddfdbffeccbdecaaebfdfcfecbbfad.
Jimmy23013
Ersetzen Sie es (.)durch das passende Zeichen und sortieren Sie es nach diesem Zeichen.
Jimmy23013
1
Beachten Sie, dass dies NP-vollständig, aber nicht kryptografisch sicher ist. Und es gibt zu viele Einschränkungen und zu wenige Variablen, um es schwierig zu machen.
Jimmy23013
1
@ user23013: Gut gespielt, Sir. ;) Und in der Tat glaube ich, dass dies auf SAT reduziert werden kann, was meine Absicht war. Es sind einfach nicht genug Teile da, um es schwierig zu machen, wie Sie sagen.
COTO
5

Python-Geschmack (721 Bytes) [geknackt]

Es ist Zeit für "Parsing Problem v2":

^(((?(8)S)(((?(9)I|\\)(?(3)\]|Z)((?(7)l|R)(((((((?(4)p)((?(7)x)(?(1)B|Z)(?(11)\()(?(9)X)(?(8)P|T)(?(6)a|E)((?(5)E)(((?(8)3|\[)((?(3)\(|1)((?(1)M|L)(?(3)v|b)(?(2)t|l)(?(1)q)(?(1)K|H)(?(2)\)|R)(?(3)O|K)(?(5)l|l)(((?(2)\[|3)((?(2)N)((?(2)\\)((?(1)E|\])(?(1)\[)([(?(1)Q)])(?(24)\[)(?(24)q))(?(24)g))(?(22)s|U)(?(22)H)(?(23)c|U))(?(24)Q)(?(24)Q)(?(24)H)(?(23)K|\[))(?(22)e|y))(?(24)\\)(?(21)P|4)(?(19)T)(?(24)\))))(?(24)M)(?(17)\()(?(24)2))(?(19)7)(?(21)t|X)(?(22)v))(?(24)\[)(?(19)A|L)(?(16)E|1))(?(19)1|c)(?(14)K|\\)(?(19)4|5)(?(24)\\)(?(20)r)))(?(24)B)(?(24)w)(?(24)5))(?(24)\())(?(24)\\))(?(24)T))(?(9)\[))(?(15)z|w))(?(24)K)\7F(?(24)m)(?(24)R))(?(24)\[))(?(24)h))(?(14)x|t)(?(3)R|M)(?(24)\])(?(24)w))(?(21)z|6)(?(16)r)()$

Getestet auf Regex101 .


Diese Regex ist effektiv "einen Baum in einem Wald verstecken". Der Großteil des regulären (?(id)yes-pattern|no-pattern)Ausdrucks besteht aus Ausdrücken, die dem entsprechenden Muster entsprechen, je nachdem, ob eine Gruppe mit der angegebenen ID vorhanden ist oder nicht. Die meisten dieser Ausdrücke tragen nicht zum Schlüssel bei, einige jedoch. Allerdings war in der Regex nicht so subtil versteckt, [(?(1):Q)]was eigentlich ein Zeichensatz ist , und \7was erfordert, dass Sie die Gruppen irgendwie im Auge behalten. Beide werden in jedem Editor mit Hervorhebungen angezeigt, sollten jedoch jeden stören, der nicht vorsichtig war.

Sp3000
quelle
Mann, das wird Arbeit kosten.
Stokastic
4
\ZRZTE[1LblHRKl3]?sHcKePT(7tvAE1K4r[zZTE[1LblHRKl3]?sHcKePT(7tvAE1K4rFxRzrStreichhölzer. apasst nicht
g.rocket
Zusätzlich wird die Menge aller möglichen Übereinstimmungen (mein vorheriger Kommentar) mit beiden ?durch ein beliebiges Zeichen in(?(1)Q)
g.rocket
(Auf Regex101 erfahren Sie genau, was abgeglichen werden soll, als die Übereinstimmung fehlgeschlagen ist. Dies hat das Auffinden der übereinstimmenden Elemente etwas vereinfacht (zumindest zum Erkennen von Tippfehlern in meiner Lösung).)
G. Rocket
Ich war in der Nähe, ich war nur fehlt das ?‚s
stokastic
5

Python-Geschmack (4842 Bytes) [geknackt]

Vielen Dank an @COTO für Ideen und Ratschläge

Ich mochte @ COTOs 3-SAT-Idee so sehr, dass ich dachte, ich würde versuchen, meine eigene Regex daraus zu machen. Ich bin mit der Theorie von 3-SAT allerdings nicht so vertraut, deshalb werde ich nur zu den RNG-Göttern beten und hoffe, dass ich genug Einschränkungen habe.

Ich habe versucht, den regulären Ausdruck unter 5000 Zeichen zu halten, um fair zu sein - offensichtlich wären längere reguläre Ausdrücke nicht zu knacken, aber es würde auch keinen Spaß machen, sie zu knacken.

[^01]|^(.{0,81}|.{83,}|....0.{10}1.{22}0.{43}|....0.{14}0.{35}0.{26}|....0.{16}0.{5}1.{54}|....0.{17}1.{34}0.{24}|....1.{11}0.{41}1.{23}|....1.{12}1.{27}1.{36}|....1.{22}1.{38}1.{15}|....1.{30}0.{35}1.{10}|....1.{46}0.1.{28}|....1.{6}1.{65}0....|...0....1.1.{71}|...0.{18}0.{23}0.{35}|...1.{11}1.{33}1.{32}|..0...0.{53}1.{21}|..0.{30}1.{17}0.{30}|..1.{41}0.{10}0.{26}|.0.{13}0.{39}1.{26}|.0.{18}0.{49}0.{11}|.0.{27}1.{36}0.{15}|.0.{31}11.{47}|.00.{37}1.{41}|.1.{32}0.{31}1.{15}|.1.{38}0.{25}0.{15}|.1.{7}0.{38}0.{33}|.{10}0.{14}0.{15}0.{40}|.{10}0.{15}1.{15}1.{39}|.{10}0.{27}1.{11}1.{31}|.{10}0.{39}0.{7}0.{23}|.{10}0.{42}10.{27}|.{10}0.{9}0.{38}0.{22}|.{10}1.{45}1.{16}0.{8}|.{10}1.{47}0.{15}0.{7}|.{10}1.{59}0.{5}1.{5}|.{11}0.{11}0.{54}0...|.{11}0.{29}1.{35}0....|.{11}1.{32}0.{25}1.{11}|.{11}1.{48}1.{6}1.{14}|.{11}11.{50}1.{18}|.{12}0.{27}1.{18}0.{22}|.{12}0.{45}1.{7}1.{15}|.{12}1.{15}0.{42}1.{10}|.{13}0.{40}1...0.{23}|.{13}1.{20}1.{5}1.{41}|.{13}1.{22}0.{31}0.{13}|.{13}1.{24}1.{39}1...|.{13}1.{58}0.{8}0|.{14}0.{22}0....1.{39}|.{14}0.{23}0.{23}1.{19}|.{14}0.{53}10.{12}|.{14}1.{19}1.{11}0.{35}|.{14}1.{19}1.{21}1.{25}|.{14}1.{23}0.{14}0.{28}|.{14}1.{24}1.{12}1.{29}|.{14}1.{35}0.{22}0.{8}|.{14}1.{48}0.{15}1..|.{14}1.{58}0....1...|.{14}1.{65}11|.{14}1.{6}1.0.{58}|.{15}0...01.{61}|.{15}0.{12}0.{30}0.{22}|.{15}0.{15}0.{34}0.{15}|.{15}0.{30}1.{25}0.{9}|.{15}0.{31}0.{32}1.|.{15}0.{36}0.{25}1...|.{15}1.{14}1.{21}1.{29}|.{15}1.{16}1.{16}1.{32}|.{15}1.{20}0.{32}1.{12}|.{16}0.{35}1.{24}0....|.{16}0.{36}1.{15}1.{12}|.{16}1.{13}1.{22}0.{28}|.{16}1.{16}1.{14}0.{33}|.{16}1.{48}1.0.{14}|.{17}1.{29}1.{31}0..|.{17}1.{47}1.{8}0.{7}|.{17}1.{9}0.{20}0.{33}|.{18}0..0.{59}1|.{18}0.{33}1.{6}0.{22}|.{18}0.{36}1.{24}1.|.{18}0.{39}0.{17}1.{5}|.{18}1..0.{35}0.{24}|.{18}1.{16}0.{7}1.{38}|.{19}0.{17}0.{8}1.{35}|.{19}1.{42}00.{18}|.{20}0.{25}1.{31}1...|.{20}0.{43}1.{12}0....|.{20}0.{8}1.{40}0.{11}|.{20}00.{56}1...|.{20}1.{38}0.{7}1.{14}|.{21}0.{39}1.{16}0...|.{22}1....0.{44}1.{9}|.{22}1..1.{20}1.{35}|.{23}0.{39}1.{8}0.{9}|.{23}0.{8}1.{41}1.{7}|.{23}1.{18}1.{25}0.{13}|.{23}1.{20}0.{6}0.{30}|.{24}0.{17}1.{16}0.{22}|.{24}0.{21}1.{13}0.{21}|.{24}1...1.{49}0...|.{24}1.{5}0.{37}0.{13}|.{24}1.{8}1.{37}0.{10}|.{25}0.{36}0....0.{14}|.{25}1....0.{29}0.{21}|.{25}1....1.{10}1.{40}|.{25}1.{13}1.{13}0.{28}|.{25}1.{40}0.{7}0.{7}|.{26}0.{13}1.{21}0.{19}|.{26}0.{13}1.{25}1.{15}|.{27}0.{20}1.{11}0.{21}|.{27}0.{36}0.{6}0.{10}|.{27}1....1.0.{47}|.{27}1...0.{13}1.{36}|.{27}1.{10}0.{26}0.{16}|.{27}1.{30}1.{15}0.{7}|.{28}0.{14}1.{37}0|.{28}0.{21}1.0.{29}|.{28}0.{26}0.{16}0.{9}|.{28}1.{18}1.{23}1.{10}|.{29}0.{17}0.0.{32}|.{29}1.{24}0.{19}1.{7}|.{29}1.{46}1....0|.{30}1.{18}1.{9}0.{22}|.{30}1.{28}0....1.{17}|.{32}0.{25}1.{6}1.{16}|.{33}0.{22}1.{12}0.{12}|.{33}0.{6}0.{11}0.{29}|.{33}1.{5}1.{31}0.{10}|.{34}0.{13}0.{8}0.{24}|.{34}1...1.{35}0.{7}|.{34}1..1.{29}1.{14}|.{34}1.{38}01.{7}|.{34}1.{5}0.{40}1|.{34}1.{6}1.{38}1.|.{34}1.{7}0.{31}0.{7}|.{34}11...1.{42}|.{35}0.{19}0..0.{23}|.{35}1.{12}1.{24}0.{8}|.{36}0.{6}1.{17}1.{20}|.{36}0.{7}1.{17}1.{19}|.{36}0.{8}0.{13}1.{22}|.{36}1.{14}0.{9}1.{20}|.{37}0.{26}1.{16}0|.{37}1.{27}0.{10}0.{5}|.{38}1.{21}1.{7}1.{13}|.{39}0..0.{20}0.{18}|.{39}0.{15}0.{19}1.{6}|.{40}0....0.{28}1.{7}|.{40}0.{15}1.0.{23}|.{40}0.{5}1.{16}0.{18}|.{40}0.{8}1.{29}1..|.{40}00.0.{38}|.{41}0.0.{20}0.{17}|.{41}00.{32}0.{6}|.{41}1.{16}1.{21}1.|.{41}1.{8}1.{18}0.{12}|.{42}1.{31}1.{6}1|.{42}11.{27}0.{10}|.{43}0.{34}10..|.{44}1.0.{10}1.{24}|.{45}0.{9}0.{5}0.{20}|.{45}1.{12}0.{22}1|.{45}1.{17}1....0.{13}|.{45}1.{9}0...0.{22}|.{46}0.{11}1.{19}1...|.{46}1.{24}0.{5}0....|.{47}11.{8}1.{24}|.{48}0.{12}1....0.{15}|.{48}0.{15}0.{13}1...|.{48}1...0.{13}0.{15}|.{48}1.{11}0..0.{18}|.{48}11.{21}0.{10}|.{49}1.{7}1.{14}0.{9}|.{51}1.{12}1.{5}1.{11}|.{54}0.{13}0.{6}1.{6}|.{54}1.{11}1.1.{13}|.{56}0.{16}0..1.{5}|.{56}1.{11}0.{6}0.{6}|.{58}1....1.{6}0.{11}|.{5}0.{17}0.{42}0.{15}|.{5}0.{23}1.{26}1.{25}|.{5}0.{34}1.{22}0.{18}|.{5}0.{6}1.{13}1.{55}|.{5}1.{12}0.{31}1.{31}|.{5}1.{16}0.{39}1.{19}|.{5}1.{16}1.1.{57}|.{5}1.{24}1.{15}1.{35}|.{5}1.{24}1.{47}1...|.{66}0.0.{5}1.{7}|.{6}0....1.{24}0.{45}|.{6}0.{19}0.{7}1.{47}|.{6}0.{23}0.{14}0.{36}|.{6}0.{25}1.{41}0.{7}|.{6}0.{46}1.{22}0.{5}|.{6}0.{52}11.{21}|.{6}1.{35}10.{38}|.{7}0.{20}0.{16}0.{36}|.{7}0.{34}1.{20}1.{18}|.{7}0.{6}0.{36}0.{30}|.{7}0.{7}0.{15}0.{50}|.{7}0.{8}1.{42}1.{22}|.{7}1.{5}1.{56}1.{11}|.{7}1.{67}0..1...|.{8}0.{10}0.{38}0.{23}|.{8}0.{41}11.{30}|.{8}0.{9}1.{37}1.{25}|.{8}1.{50}1.{14}1.{7}|.{9}0..1.{55}0.{13}|.{9}0.{21}1.{42}0.{7}|.{9}0.{59}00.{11}|.{9}0.{9}0....1.{57}|.{9}00.{41}1.{29}|.{9}1....0.{20}0.{46}|.{9}1...0.{41}1.{26}|.{9}1.{30}0.{16}1.{24}|.{9}1.{30}0.{37}1...|.{9}1.{30}1.{14}1.{26}|.{9}1.{40}01.{30}|0.{17}1.{34}0.{28}|0.{23}1.{43}1.{13}|0.{30}1.{26}1.{23}|1.{13}00.{66}|1.{28}0.{42}1.{9}|1.{36}0.{35}1.{8}|1.{42}1.{32}1.{5}|1.{49}0.{16}0.{14}|1.{52}0.{7}0.{20}|)$

Und hier ist es in einer Form, die ein bisschen leichter zu lesen ist:

[^01]|
^(
  .{0,81}|
  .{83,}|
  ....0.{10}1.{22}0.{43}|
  ....0.{14}0.{35}0.{26}|
  ....0.{16}0.{5}1.{54}|
  ....0.{17}1.{34}0.{24}|
  ....1.{11}0.{41}1.{23}|
  ....1.{12}1.{27}1.{36}|
  ....1.{22}1.{38}1.{15}|
  ....1.{30}0.{35}1.{10}|
  ....1.{46}0.1.{28}|
  ....1.{6}1.{65}0....|
  ...0....1.1.{71}|
  ...0.{18}0.{23}0.{35}|
  ...1.{11}1.{33}1.{32}|
  ..0...0.{53}1.{21}|
  ..0.{30}1.{17}0.{30}|
  ..1.{41}0.{10}0.{26}|
  .0.{13}0.{39}1.{26}|
  .0.{18}0.{49}0.{11}|
  .0.{27}1.{36}0.{15}|
  .0.{31}11.{47}|
  .00.{37}1.{41}|
  .1.{32}0.{31}1.{15}|
  .1.{38}0.{25}0.{15}|
  .1.{7}0.{38}0.{33}|
  .{10}0.{14}0.{15}0.{40}|
  .{10}0.{15}1.{15}1.{39}|
  .{10}0.{27}1.{11}1.{31}|
  .{10}0.{39}0.{7}0.{23}|
  .{10}0.{42}10.{27}|
  .{10}0.{9}0.{38}0.{22}|
  .{10}1.{45}1.{16}0.{8}|
  .{10}1.{47}0.{15}0.{7}|
  .{10}1.{59}0.{5}1.{5}|
  .{11}0.{11}0.{54}0...|
  .{11}0.{29}1.{35}0....|
  .{11}1.{32}0.{25}1.{11}|
  .{11}1.{48}1.{6}1.{14}|
  .{11}11.{50}1.{18}|
  .{12}0.{27}1.{18}0.{22}|
  .{12}0.{45}1.{7}1.{15}|
  .{12}1.{15}0.{42}1.{10}|
  .{13}0.{40}1...0.{23}|
  .{13}1.{20}1.{5}1.{41}|
  .{13}1.{22}0.{31}0.{13}|
  .{13}1.{24}1.{39}1...|
  .{13}1.{58}0.{8}0|
  .{14}0.{22}0....1.{39}|
  .{14}0.{23}0.{23}1.{19}|
  .{14}0.{53}10.{12}|
  .{14}1.{19}1.{11}0.{35}|
  .{14}1.{19}1.{21}1.{25}|
  .{14}1.{23}0.{14}0.{28}|
  .{14}1.{24}1.{12}1.{29}|
  .{14}1.{35}0.{22}0.{8}|
  .{14}1.{48}0.{15}1..|
  .{14}1.{58}0....1...|
  .{14}1.{65}11|
  .{14}1.{6}1.0.{58}|
  .{15}0...01.{61}|
  .{15}0.{12}0.{30}0.{22}|
  .{15}0.{15}0.{34}0.{15}|
  .{15}0.{30}1.{25}0.{9}|
  .{15}0.{31}0.{32}1.|
  .{15}0.{36}0.{25}1...|
  .{15}1.{14}1.{21}1.{29}|
  .{15}1.{16}1.{16}1.{32}|
  .{15}1.{20}0.{32}1.{12}|
  .{16}0.{35}1.{24}0....|
  .{16}0.{36}1.{15}1.{12}|
  .{16}1.{13}1.{22}0.{28}|
  .{16}1.{16}1.{14}0.{33}|
  .{16}1.{48}1.0.{14}|
  .{17}1.{29}1.{31}0..|
  .{17}1.{47}1.{8}0.{7}|
  .{17}1.{9}0.{20}0.{33}|
  .{18}0..0.{59}1|
  .{18}0.{33}1.{6}0.{22}|
  .{18}0.{36}1.{24}1.|
  .{18}0.{39}0.{17}1.{5}|
  .{18}1..0.{35}0.{24}|
  .{18}1.{16}0.{7}1.{38}|
  .{19}0.{17}0.{8}1.{35}|
  .{19}1.{42}00.{18}|
  .{20}0.{25}1.{31}1...|
  .{20}0.{43}1.{12}0....|
  .{20}0.{8}1.{40}0.{11}|
  .{20}00.{56}1...|
  .{20}1.{38}0.{7}1.{14}|
  .{21}0.{39}1.{16}0...|
  .{22}1....0.{44}1.{9}|
  .{22}1..1.{20}1.{35}|
  .{23}0.{39}1.{8}0.{9}|
  .{23}0.{8}1.{41}1.{7}|
  .{23}1.{18}1.{25}0.{13}|
  .{23}1.{20}0.{6}0.{30}|
  .{24}0.{17}1.{16}0.{22}|
  .{24}0.{21}1.{13}0.{21}|
  .{24}1...1.{49}0...|
  .{24}1.{5}0.{37}0.{13}|
  .{24}1.{8}1.{37}0.{10}|
  .{25}0.{36}0....0.{14}|
  .{25}1....0.{29}0.{21}|
  .{25}1....1.{10}1.{40}|
  .{25}1.{13}1.{13}0.{28}|
  .{25}1.{40}0.{7}0.{7}|
  .{26}0.{13}1.{21}0.{19}|
  .{26}0.{13}1.{25}1.{15}|
  .{27}0.{20}1.{11}0.{21}|
  .{27}0.{36}0.{6}0.{10}|
  .{27}1....1.0.{47}|
  .{27}1...0.{13}1.{36}|
  .{27}1.{10}0.{26}0.{16}|
  .{27}1.{30}1.{15}0.{7}|
  .{28}0.{14}1.{37}0|
  .{28}0.{21}1.0.{29}|
  .{28}0.{26}0.{16}0.{9}|
  .{28}1.{18}1.{23}1.{10}|
  .{29}0.{17}0.0.{32}|
  .{29}1.{24}0.{19}1.{7}|
  .{29}1.{46}1....0|
  .{30}1.{18}1.{9}0.{22}|
  .{30}1.{28}0....1.{17}|
  .{32}0.{25}1.{6}1.{16}|
  .{33}0.{22}1.{12}0.{12}|
  .{33}0.{6}0.{11}0.{29}|
  .{33}1.{5}1.{31}0.{10}|
  .{34}0.{13}0.{8}0.{24}|
  .{34}1...1.{35}0.{7}|
  .{34}1..1.{29}1.{14}|
  .{34}1.{38}01.{7}|
  .{34}1.{5}0.{40}1|
  .{34}1.{6}1.{38}1.|
  .{34}1.{7}0.{31}0.{7}|
  .{34}11...1.{42}|
  .{35}0.{19}0..0.{23}|
  .{35}1.{12}1.{24}0.{8}|
  .{36}0.{6}1.{17}1.{20}|
  .{36}0.{7}1.{17}1.{19}|
  .{36}0.{8}0.{13}1.{22}|
  .{36}1.{14}0.{9}1.{20}|
  .{37}0.{26}1.{16}0|
  .{37}1.{27}0.{10}0.{5}|
  .{38}1.{21}1.{7}1.{13}|
  .{39}0..0.{20}0.{18}|
  .{39}0.{15}0.{19}1.{6}|
  .{40}0....0.{28}1.{7}|
  .{40}0.{15}1.0.{23}|
  .{40}0.{5}1.{16}0.{18}|
  .{40}0.{8}1.{29}1..|
  .{40}00.0.{38}|
  .{41}0.0.{20}0.{17}|
  .{41}00.{32}0.{6}|
  .{41}1.{16}1.{21}1.|
  .{41}1.{8}1.{18}0.{12}|
  .{42}1.{31}1.{6}1|
  .{42}11.{27}0.{10}|
  .{43}0.{34}10..|
  .{44}1.0.{10}1.{24}|
  .{45}0.{9}0.{5}0.{20}|
  .{45}1.{12}0.{22}1|
  .{45}1.{17}1....0.{13}|
  .{45}1.{9}0...0.{22}|
  .{46}0.{11}1.{19}1...|
  .{46}1.{24}0.{5}0....|
  .{47}11.{8}1.{24}|
  .{48}0.{12}1....0.{15}|
  .{48}0.{15}0.{13}1...|
  .{48}1...0.{13}0.{15}|
  .{48}1.{11}0..0.{18}|
  .{48}11.{21}0.{10}|
  .{49}1.{7}1.{14}0.{9}|
  .{51}1.{12}1.{5}1.{11}|
  .{54}0.{13}0.{6}1.{6}|
  .{54}1.{11}1.1.{13}|
  .{56}0.{16}0..1.{5}|
  .{56}1.{11}0.{6}0.{6}|
  .{58}1....1.{6}0.{11}|
  .{5}0.{17}0.{42}0.{15}|
  .{5}0.{23}1.{26}1.{25}|
  .{5}0.{34}1.{22}0.{18}|
  .{5}0.{6}1.{13}1.{55}|
  .{5}1.{12}0.{31}1.{31}|
  .{5}1.{16}0.{39}1.{19}|
  .{5}1.{16}1.1.{57}|
  .{5}1.{24}1.{15}1.{35}|
  .{5}1.{24}1.{47}1...|
  .{66}0.0.{5}1.{7}|
  .{6}0....1.{24}0.{45}|
  .{6}0.{19}0.{7}1.{47}|
  .{6}0.{23}0.{14}0.{36}|
  .{6}0.{25}1.{41}0.{7}|
  .{6}0.{46}1.{22}0.{5}|
  .{6}0.{52}11.{21}|
  .{6}1.{35}10.{38}|
  .{7}0.{20}0.{16}0.{36}|
  .{7}0.{34}1.{20}1.{18}|
  .{7}0.{6}0.{36}0.{30}|
  .{7}0.{7}0.{15}0.{50}|
  .{7}0.{8}1.{42}1.{22}|
  .{7}1.{5}1.{56}1.{11}|
  .{7}1.{67}0..1...|
  .{8}0.{10}0.{38}0.{23}|
  .{8}0.{41}11.{30}|
  .{8}0.{9}1.{37}1.{25}|
  .{8}1.{50}1.{14}1.{7}|
  .{9}0..1.{55}0.{13}|
  .{9}0.{21}1.{42}0.{7}|
  .{9}0.{59}00.{11}|
  .{9}0.{9}0....1.{57}|
  .{9}00.{41}1.{29}|
  .{9}1....0.{20}0.{46}|
  .{9}1...0.{41}1.{26}|
  .{9}1.{30}0.{16}1.{24}|
  .{9}1.{30}0.{37}1...|
  .{9}1.{30}1.{14}1.{26}|
  .{9}1.{40}01.{30}|
  0.{17}1.{34}0.{28}|
  0.{23}1.{43}1.{13}|
  0.{30}1.{26}1.{23}|
  1.{13}00.{66}|
  1.{28}0.{42}1.{9}|
  1.{36}0.{35}1.{8}|
  1.{42}1.{32}1.{5}|
  1.{49}0.{16}0.{14}|
  1.{52}0.{7}0.{20}|
)$

Getestet auf Regex101 .


Der Regex sucht nach einer 82- Sstelligen Zeichenfolge mit 0 und 1. Es führt eine große Anzahl von Überprüfungen des Formulars durch (nach Anwendung von de Morgans) S[index1] != digit1ODER S[index2] != digit2ODER S[index3] != digit3, das die 3-SAT-Klauseln bildet. Die Regex-Größe ist linear in der Anzahl der Hinweise und logarithmisch in der Anzahl der Zeichen im Schlüssel (aufgrund der .{n}Notation). Um sicher zu sein, muss die Anzahl der Hinweise jedoch mit der Größe des Schlüssels übereinstimmen, und obwohl es durchaus möglich ist, auf diese Weise einen unknackbaren Schlüssel zu erstellen, wäre dies eine ziemlich lange Regel.

Sp3000
quelle
1
Spiel: x. Non-Match:0011001101000000000111010001101101011000010011011010000000010001011111000100010000
Nneonneo
Spiel: aaaabaaacaaadaaa. Nicht übereinstimmend: 011100110010001010111101001010010011110010011010110101010001101100101111111111+ 0000. Nur ein paar Sekunden langsamer ...
Jimmy23013
Wow das war schnell - habt ihr es brutal erzwungen?
Sp3000
1
@ Sp3000 Ich habe es fast manuell gemacht ... Überraschenderweise hat die statistische Methode funktioniert.
Jimmy23013
2
@ Sp3000: ich hätte es bruteforced aber das hat keinen spaß gemacht. Stattdessen habe ich Ihre Sequenz in eine 3SAT-Sequenz konvertiert und mit Minisat geknackt. Es dauerte 0,3 Sekunden (Zeitaufwand für die Konvertierung, ~ 10 Minuten)
Nneonneo
5

Perlgeschmack, 133 [geknackt]

Okay, dieser sollte schwerer zu brachialisieren sein:

^([^,]{2,}),([^,]{2,}),([^,]{2,}),(?=.\2+,)(?=.\3+,)\1+,(?=.\1+,)(?=.\3+,)\2+,(?=.\1+,)(?=.\2+,)\3+,(?=.{16,20}$)(\1{3}|\2{3}|\3{3})$

Und eine längere Version, die nicht Teil der Herausforderung ist:

^([^,]{3,}),([^,]{3,}),([^,]{3,}),([^,]{3,}),([^,]{3,}),([^,]{3,}),(?=.\2+,)(?=.\3+,)(?=.\4+,)(?=.\5+,)(?=.\6+,)\1+,(?=.\1+,)(?=.\3+,)(?=.\4+,)(?=.\5+,)(?=.\6+,)\2+,(?=.\1+,)(?=.\2+,)(?=.\4+,)(?=.\5+,)(?=.\6+,)\3+,(?=.\1+,)(?=.\2+,)(?=.\3+,)(?=.\5+,)(?=.\6+,)\4+,(?=.\1+,)(?=.\2+,)(?=.\3+,)(?=.\4+,)(?=.\6+,)\5+,(?=.\1+$)(?=.\2+$)(?=.\3+$)(?=.\4+$)(?=.\5+$)\6+$

Kann mit Regex101 (PCRE-Geschmack) getestet werden .


Die Idee hinter diesem Muster ist, dass wir mit Hilfe von Lookaheads ein einfaches System von Kongruenzgleichungen in einer Regex codieren können. Beispielsweise ^(?=(..)*$)(...)*$stimmt der reguläre Ausdruck mit jeder Zeichenfolge überein, deren Länge ein gemeinsames Vielfaches von 2 und 3 ist, dh ein Vielfaches von 6 . Dies kann als die Gleichung 2x ≡ 0 mod 3 gesehen werden . Wir können die Gleichung mithilfe von Erfassungsgruppen parametrisieren: Der reguläre Ausdruck ^(.*),(.*),(?=\1*$)\2*$stimmt mit Zeichenfolgen überein, bei denen die Anzahl der Zeichen nach dem letzten Komma ein gemeinsames Vielfaches der Länge der ersten und zweiten Teilübereinstimmung ist. Dies kann als die parametrisierte Gleichung ax ≡ 0 mod b angesehen werden , wobei a und b die Längen der beiden Submatches sind.

Der obige reguläre Ausdruck beginnt mit der Annahme von drei "Parametern" mit einer Länge von mindestens zwei und wird gefolgt von drei "Gleichungssystemen" (?=.\1+,)(?=.\2+,)\3+,derjenigen, die {ax + 1 ≤ 0 mod c, + 1 ≤ 0 mod c, ax entsprechen = by} , wobei a , b und c die Längen der entsprechenden Submatches sind. Dieses Gleichungssystem hat genau dann eine Lösung, wenn a und b gleichbedeutend mit c sind . Da wir drei solcher Systeme haben, eines für jede Teilübereinstimmung, müssen die Längen der Teilübereinstimmungen paarweise gleich hoch sein.

Der letzte Teil des regulären Ausdrucks ist dazu da, um sicherzustellen, dass eines der Submatches die Länge 6 hat . Dies zwingt die anderen beiden Submatches zu sein5 und 7 Zeichen lang, da kleinere Werte nicht koprimiert werden und größere Werte einen Schlüssel ergeben, der länger als 256 Zeichen ist. Die kleinsten Lösungen für die Gleichungen ergeben dann Teilfolgen der Längen 85 , 36 und 91 , die zu einer Folge der Länge 254 führen - ungefähr so ​​lange, wie wir bekommen können.

Der längere reguläre Ausdruck verwendet dasselbe Prinzip, nur mit 6 Parametern mit einer Länge von mindestens drei und ohne zusätzliche Einschränkungen. Die kleinste paarweise Coprime-Menge von sechs Ganzzahlen größer als 2 ist {3, 4, 5, 7, 11, 13} , was Teilzeichenfolgen mit den Mindestlängen 40041, 15016, 24025, 34321, 43681 und 23101 ergibt. Daher ist die kürzeste Zeichenfolge, die mit der längeren Regex übereinstimmt a{3},a{4},a{5},a{7},a{11},a{13},a{40041},a{15016},a{24025},a{34321},a{43681},a{23101} (bis zur Reihenfolge der Parameter). Das sind 180.239 Zeichen!

Ell
quelle
Das {16,20}.
Sp3000
2
Spiel aaaaa,aaaaaa,aaaaaaa,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
:, Nichtübereinstimmung
Ich denke, SE fügt aaus irgendeinem Grund zusätzliche s hinzu - azwischen den Kommas sollten 5,6,7,85,36,91,18 s stehen: /
Sp3000
@ Sp3000 Wähle eine Karte, eine beliebige Karte;) Ja, du hast sie geknackt. Es scheint, als ob einige der 'a' in Ihrem Kommentar nicht-ASCII sind, aber die Zahlen stimmen.
Ell
@Ell Die as sind alle ASCII-Zeichen, aber für jeden manuellen Zeilenumbruch, den SE durchführt, gibt es zwei nicht druckbare Unicode-Zeichen.
Martin Ender
5

.NET-Geschmack, 141 Bytes [geknackt]

(?=(?<![][])(?(c)(?!))((?<c>[[])|(?<-c>[]])){15,}(?(c)(?!))(?![][]))^.*$(?<=(?<![][])(?(c)(?!))((?<c>[[])|(?<-c>[]])){15,}(?(c)(?!))(?![][]))

Noch einer für die Räuber! Ich bin sicher, dass dies geknackt wird, aber ich hoffe, dass die Person, die es knackt, dabei etwas Interessantes über die .NET-Variante erfährt.

Getestet mit RegexStorm und RegexHero .

Ich dachte, dies wäre interessant, da es auf dem Zusammenspiel aller drei wichtigen Regex-Funktionen beruht, die Sie nur in .NET finden können: Lookbehinds mit variabler Länge, Balancing Groups und Matching von rechts nach links.

Bevor wir uns mit den .NET-Besonderheiten befassen, wollen wir uns mit den Zeichenklassen befassen. Zeichenklassen können nicht leer sein. Beginnt man also mit einem ], ist dies tatsächlich ein Teil der Klasse, ohne dass ein Escapezeichen erforderlich ist. Ebenso kann ein [in einer Zeichenklasse eindeutig als ein Mitglied der Klasse behandelt werden, ohne zu flüchten. Ist []]also genau das Gleiche, das mit einer einzelnen übereinstimmt \], und [[]das Gleiche \[und was noch wichtiger [][]ist, eine Zeichenklasse, die beide Klammern enthält.

Betrachten wir nun die Struktur des regulären Ausdrucks:(?=somePattern)^.*$(?<=somePattern). Das eigentliche Match ist also eigentlich alles, ^.*$aber wir wenden ein Muster zweimal an und verankern es einmal am Anfang und einmal am Ende.

Schauen wir uns dieses Muster an: (?<![][])Stellen Sie sicher, dass sich vor dem Muster keine eckigen Klammern befinden. (?![][])(am Ende) stellt sicher, dass es keine Klammer nach dem Muster gibt. Dies wird an den Enden einer Zeichenfolge oder neben einem anderen Zeichen erfüllt.
Diese Sache ist (?(c)(?!))anfangs eigentlich vorerst überflüssig, da sie nur sicherstellt, dass die genannte Erfassungsgruppe cnicht mit irgendetwas übereinstimmt. Wir tun müssen dies am Ende, so zumindest ist es schön und symmetrisch ist. Nun ist der wichtigste Teil des Musters , ist dies: ((?<c>[[])|(?<-c>[]])){15,}(?(c)(?!)). Diese Gruppen werden als Bilanzkreise bezeichnet und entsprechen hier einer Zeichenfolge von mindestens 15ausgewogene eckige Klammern. Über Bilanzkreise gibt es viel zu sagen - zu viel für diesen Beitrag, aber ich kann Sie auf eine ziemlich umfassende Diskussion verweisen, die ich vor einiger Zeit auf StackOverflow gepostet habe.

Okay, der Lookahead stellt also sicher, dass das Muster mit diesen ausgeglichenen eckigen Klammern beginnt - und dass keine weiteren eckigen Klammern daneben stehen.

Der Lookbehind am Ende enthält nun genau das gleiche Muster. Sollte das nicht überflüssig sein? Sollte so etwas nicht [][][][][][][][]beide Lookarounds erfüllen und dazu führen, dass das Muster übereinstimmt?

Nein, denn hier wird es schwierig. Obwohl nicht dokumentiert, werden .NET-Lookbehinds von rechts nach links abgeglichen. Aus diesem Grund ist .NET die einzige Variante, die Lookbehinds mit variabler Länge unterstützt. Normalerweise merkt man das nicht, weil die Reihenfolge der Übereinstimmungen irrelevant ist. In diesem speziellen Fall bedeutet dies jedoch, dass die öffnenden eckigen Klammern jetzt rechts von den schließenden eckigen Klammern stehen müssen. Der Lookbehind sucht also tatsächlich nach nicht übereinstimmenden eckigen Klammern, wie in ][][][oder ]]][[[. Deswegen brauche ich auch die Prüfung (?(c)(?!))am Anfang des Musters, denn das ist jetzt das Ende des Spiels.

Wir wollen also 15 (oder 16) passende Klammern am Anfang der Zeichenkette und 15 (oder 16) anti-passende Klammern am Ende der Zeichenkette. Aber diese beiden können aufgrund der nicht verbunden werden(?![][])Lookarounds. Also, was machen wir? Wir nehmen eine passende Zeichenfolge und eine Anti-Matching-Zeichenfolge und verbinden sie mit einem beliebigen Zeichen, zum Beispiel [][][][][[[[]]]]!][][][][]]]][[[[.

Ich denke, das lässt eine Frage offen ... wie um alles in der Welt habe ich herausgefunden, dass die Lookbehinds von rechts nach links passen? Nun, ich habe einmal etwas arkane Regex-Magie ausprobiert und konnte nicht herausfinden, warum mein Lookbehind nicht funktioniert. Also fragte ich die freundliche Q & A-Seite nebenan . Jetzt freue ich mich sehr über diese Funktion, da sie die Bilanzgruppen noch leistungsfähiger macht, wenn Sie wissen, wie man sie richtig einsetzt. :)

Martin Ender
quelle
1
Spiel: [][][][][][][][]a][][][][][][][][. Non-Match:That's interesting...
Jimmy23013
@ user23013 Yup! Das war schnell. Waren Sie schon mit diesen Macken von .NET vertraut? :)
Martin Ender
Ich wünschte, ich hätte 5 Minuten zuvor herausgefunden, wie eigenartig das Aussehen ist
TwiNight,
Nein, aber ich weiß bereits, dass Quantifizierer in PCRE nicht im Lookbehind erlaubt sind. Ich denke, dass es viel besser ist, rückwärts zu schauen.
Jimmy23013
@ MartinBüttner Also, um zu bestätigen, Lookbehinds passen tatsächlich von hinten nach vorne?
TwiNight
5

Python-Geschmack (200127 Bytes) [geknackt]

Nur damit wir (hoffentlich) einen Tag lang etwas sehen können, ist es Zeit, die großen Waffen herauszubringen :)

Das Problem bei 3-SAT- und Hamilton-Pfaden ist, dass die Komplexität in Bezug auf die Schlüsselgröße besteht. Dieses Mal habe ich etwas gewählt, das eher vom Regex als vom Schlüssel abhängt.

Hier ist es: Regex . Sie könnten diese Datei auch nützlich finden. (Keine Sorge, ich habe diesmal nichts Verrücktes darin versteckt;))

Ich habe RegexPlanet verwendet , um dieses zu testen - es war schwierig, etwas zu finden, das keine Zeitüberschreitung verursachte : /. Um zu überprüfen, ob eine Übereinstimmung vorliegt, prüfen Sie, ob Ihre Zeichenfolge unter angezeigt wird findall().

Viel Glück!


Der reguläre Ausdruck lautet einfach "Finde eine Zeichenfolge mit der Länge 64, die als gemeinsame Teilfolge in einem Satz von 20 Zeichenfolgen mit der Länge 5000 erscheint". Es gab jedoch wahrscheinlich zu viele Lösungen.

Sp3000
quelle
5
Spiel: d,mE~JZ0,_:3kBdLdgBSzJ!@MLrrAgKsf@Pl35N9bxsIf@ReVU>:YDg`d1MjL@_-. Non-Match:{ line|fold -w1 >filea; while line >filec; do fold -w1 <filec >fileb; diff -d --old-line-format= --new-line-format= --unchanged-line-format=%L filea fileb >filec;mv filec filea;done;cat filea;} <file1|tr -d $'\n'|head -c64;echo
Jimmy23013
Ahaha, ich bin geschlagen - ich denke, die Sequenzen waren zu lang und es gab zu viele Lösungen
Sp3000
@ user23013 Das hört sich nach viel an, ist aber eigentlich gar nicht so schlecht, da es 54375894091967550109295198216457840670243091223019263669103547576269058013890850350746679258443491681397628296680816641 mit unterschiedlichen zeichenlängen gibt.
Martin Ender
Ich liege falsch. Es gibt nicht nur 718406958841 Lösungen. Und mein Skript hat einen Fehler, also hat es das letzte Muster ignoriert. Aber die gemeinsame Folge der ersten 19 Muster war zufällig auch eine Folge der letzten
jimmy23013 17.10.14
@ MartinBüttner Ich meine, ich weiß nicht genau, wie viele Lösungen es gibt, und diese Zahl ist falsch. Ihre längste gemeinsame Subsequenz hat 718406958841 (korrigierter Wert: 97082021465) Subsequenzen der Länge 64. Es gibt jedoch auch andere CSs, die keine Subsequenzen von LCS sind.
Jimmy23013
5

Python, 145475 Bytes [geknackt]

Vielen Dank an den Wumpus, der mir beigebracht hat, wie wichtig es ist, unsere Indizes zu überprüfen :)

Gleicher Deal wie die letzte Lösung, nur hoffentlich diesmal nicht kaputt. Raw Regex: http://pastebin.com/MReS2R1k

EDIT: Es war nicht kaputt, aber anscheinend war es immer noch zu einfach. Zumindest wurde es nicht "sofort" gelöst;)

nneonneo
quelle
4
Non-Spiel: 1040060321170122554027333022674205250442151362365165773421664173556667110413375720720711725045122733213710556062114131057357354554245723416516004761215632214223735570625116160162051407026445600345370604702671021412723536217011007021752560474402200436670402Match:minisat2hoursCPU
Ayup. Du hast mich. Das war ziemlich schnell. Vielleicht muss ich doch meine 1GB Regex
rausschmeißen
5

Java Pattern / Oracle-Implementierung (75 Zeichen / 150 Byte UTF-16) [geknackt]

(Codename: Schlechter Kaffee 101)

Dies ist das PatternObjekt mit dem CANON_EQFlag, mit dem verwendet werden soll matches()(impliziter Anker):

Pattern.compile("(\\Q\u1EBF\\\\E)?+[\\w&&[\\p{L1}]\\p{Z}]+|\\1[\uD835\uDC00-\uD835\uDC33]{1927027271663633,2254527117918231}", Pattern.CANON_EQ)

Testen Sie Ihren Schlüssel hier auf ideone

Es ist garantiert ein Schlüssel. Lesen Sie den Spoiler, wenn Sie eine Bestätigung wünschen.

Wie Sie sehen können, handelt es sich nicht um einen normalen regulären Ausdruck. Es wird jedoch ohne Exceptiondie Java-Versionen 1.6.0u37 und 1.7.0u11 von Oracle ausgeführt und sollte zum Zeitpunkt des Schreibens auch für die aktuellste Version ausgeführt werden.

Dies macht Gebrauch von 4 Fehlern CANON_EQ:, Beibehaltung des erfassten Textes von fehlgeschlagenem Versuch, verlorener Zeichenklasse und Quantifiziererüberlauf.

n̴̖̋h̴̖̋ã̷͉h̷̭̿d̷̰̀ĥ̷̳
quelle
4
Übereinstimmung : "(?:e\u0302\u0301\\|\u00ea\u0301\\|\u1ebf\\|\u00ea\\\u0301|e\u0302\\\u0301|\u00ea\\\u0301|\u00ea\u0301\\|\u1ebf\\|e\\\u0302\u0301)\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00\uD835\uDC00"(zitierte Form). Nicht-Spiel : JavaRegexSoBuggy. ideone for match: ideone.com/DEesdk
nneonneo
Gefundene Bugs: (1) CANON_EQErweitert vorkomponierte Charaktere intern zu Abwechslungen, die im Inneren auf lustige Weise unterbrochen werden \Q\E. (2) Wiederholungslängen werden auf 32 Bits gekürzt; (3) Mit dem Zeichenklassen-Matcher ist etwas Seltsames los, das dazu führt, dass der Wechsel übersprungen wird (ich habe nicht genau herausgefunden, was der Fehler genau war).
Nneonneo
@ nneonneo: Deine Erklärung ist richtig. Aber du hast den Backref- \1Bug vergessen . Und ja, es gibt einen Fehler in der Charakterklasse. Wie haben Sie das alles in weniger als 2 Stunden herausgefunden?
n̴̖̋h̷͉̃a̷̭̿h̷̭̿d̸̡̅ẗ̵̨́
Ich habe vor 20 Minuten angefangen, daran zu arbeiten. Sie haben ziemlich deutlich gemacht, welche Teile des Problems welche Fehler hervorgehoben haben (da jeder Fehler im Grunde in einer eigenen Gruppe war), und ich habe herausgefunden, wie jeder Teil unabhängig befriedigt werden kann, und sie dann kombiniert. Ich hatte Glück, dass ich nicht wirklich herausfinden musste, was die Charakterklasse tat. (Ich hatte auch großes Glück, dass Java das "erweiterte" interne Muster ausspuckt, wenn Sie einen Syntaxfehler haben :)
nneonneo 17.10.14
Ebenfalls! Ich glaube nicht, dass die Speicherung von erfasstem Text unbedingt ein Fehler ist. So scheinen die Possessivquantifikatoren zu funktionieren. (Es ist auch eine ziemlich nützliche Eigenschaft für bestimmte Regex-Hacks ... hm ...)
Nneonneo
5

.NET-Geschmack, 17.372 Bytes [geknackt]

Dies ist immer noch eine einfache Version. Um mit längeren Zeichenfolgen arbeiten zu können, ist mehr Optimierung erforderlich.

Der reguläre Ausdruck ist hier: http://pastebin.com/YPE4zyBB

Ungolfed: http://pastebin.com/PLJp0KhF

Getestet mit RegexStorm und diesem Blog und RegExLib (alle Optionen deaktiviert ).

Die Lösung für diesen regulären Ausdruck ist die Faktorisierung von 5122188685368916735780446744735847888756487271329 = 2147852126374329492975359 * 2384795779221263457172831, wobei das Ergebnis zuerst in der Basis 289 codiert wird.

Jede Ziffer wird zunächst in zwei Basis-17-Zahlen aufgeteilt, um die Berechnungen zu beschleunigen. Auf diese Weise wird das Produkt auch im regulären Ausdruck codiert.

Jedes Ziffernpaar in den beiden Zahlen wird dann in Erfassungsgruppe a0zu multipliziert a38. Jeder von ihnen ist eine Ziffer des Produkts. Die aktuelle Position wird mit pund verfolgt q. Und der Übertrag wird nach der Multiplikation verarbeitet, während das Produkt verglichen wird.

Es befindet sich in der Basis 289, da zwei 1024-Bit-Zahlen mit jeweils 128 Basis-256-Ziffern akzeptiert wurden. Ich habe nicht daran gedacht, das Komma zu entfernen, sodass die vollständige Zeichenfolge mit der Basis 256 257 Zeichen umfassen würde.

Die 1536-Bit-Version ist da . Es akzeptiert zwei 768-Bit-Nummern. Die Zahlen in dieser einfachen Version haben jeweils nur 81 Bits.

jimmy23013
quelle
2
Match : Ľê¯6Aĝ4aþĀ,lŃŝĿBİŢŞĩï(entkommen:) \u013d\xea\xaf6A\u011d4a\xfe\u0100,l\u0143\u015d\u013fB\u0130\u0162\u015e\u0129\xef. Non-Match :VeryNiceMultiplier
Nneonneo
4

ECMAScript-Geschmack, 30 Bytes [geknackt]

^((?![\t- ]|[^\s])(.)(?!\2))+$

Hier ist eine ziemlich einfache für die Räuber zu knacken. Es ist konzeptionell nicht allzu schwierig, erfordert jedoch möglicherweise ein wenig Recherche (oder Skripterstellung). Ich habe nicht vor, mich in der Rangliste aufzulisten, aber wenn jemand es innerhalb von 72 Stunden knackt, zählt dies für die Punktzahl seines Räubers.

Getestet auf Regex101 und RegExr mit Chrome.

Nun, das ging schnell!

Der reguläre Ausdruck sollte mit jeder Zeichenfolge übereinstimmen, die aus verschiedenen Nicht-ASCII-Leerzeichen besteht. Ich habe jedoch ein .*vor dem vergessen \2, so dass es tatsächlich mit einer Zeichenfolge von Nicht-ASCII-Leerzeichen übereinstimmt, die keine zwei aufeinander folgenden identischen Zeichen enthält. Es gibt 18 solcher Zeichen im Unicode-Bereich bis zum Codepunkt 0xFFFF. Die von user23013 veröffentlichte Übereinstimmung ist eine solche Zeichenfolge, die aus 16 Zeichen besteht.

Martin Ender
quelle
1
Spiel (base64) wqDigZ/CoOKBn8Kg4oGfwqDigZ/CoOKBn8Kg4oGfwqDigZ/CoOKBnw==aaaabaaacaaadaaa
:,
Es ist nicht eindeutig, sondern nur abwechselnd mit nur zwei unterschiedlichen Zeichen.
Jimmy23013
@ user23013 Verdammt, ich habe einen .*im Lookahead vergessen . Guter Fang. Sollte gründlicher getestet haben.
Martin Ender
4

Rubinrot , 24 Bytes [geknackt]

^(?!.*(.+)\1)([\[\\\]]){256}$
Histokrat
quelle
Bitte fügen Sie einen Link zu einem Tester bei, auf dem Ihr vorgesehener Schlüssel funktioniert (z. B. rubular.com ). (Auch, Verschleierung / Golf-Pro-Tipp: Wenn Sie stattdessen PCRE verwenden, könnte die Zeichenklasse wie folgt geschrieben werden []\\[];))
Martin Ender
Link hinzugefügt. Ich vermute Wumpus hat es geknackt, könnte es mit einem Permalink auf rubular.com beweisen
Histokrat
2
Nicht-Spiel: soylentgreenispeople. Match verfügbar unter rubular.com/r/TCqjcaGsU1 hier nicht gepostet, da das Kommentarsystem lange Wörter verarbeitet.
@ WumpusQ.Wumbley Großartig! Wenn Sie die Nichtübereinstimmung in denselben Kommentar aufnehmen, können wir das gesamte Chaos darüber beseitigen.
Martin Ender
4

PHP, 168 Bytes [geknackt von nneonneo ]

^((?![!?$]*[^!?$]))?(?:[^!]\2?+(?=(!*)(\\\3?+.(?!\3)))){4}(?(1)|Ha! No one will ever get this one...)|(?!(?1))\Q\1?!($!?)?\E\1?!($!?)?(?<!.{12})\Q(?=(?1))\E(?=(?1))!\?$

Hier ist eine Regex-Demo .

PS Dieses Spiel ist schwer.

Eineder
quelle
2
Spiel : \1?!($!?)?!(?=(?1))!?. Non-Match :IncrementalRegexTestingWorks
Nneonneo
@ Nneonneo Ah, du bist zu gut;)
Unihedron
4

PCRE (1043 Bytes) [geknackt]

Nachdem zufällig generierte reguläre Ausdrücke versagt haben (die Ideen waren gut, aber ich konnte keine angemessenen Probleminstanzen generieren), habe ich beschlossen, diese manuell zu erstellen. Ich nenne es "Eine ganze Menge Regeln, die es zu befriedigen gilt".

^(?=^([^)(]*\(((?>[^)(]+)|(?1))*\)[^)(]*)*$)(?=^([^][]*\[((?>[^][]+)|(?3))*\][^][]*)*$)(?=^([^}{]*\{((?>[^}{]+)|(?5))*\}[^}{]*)*$)(?!^\(.*)(?!.*\(.{250}\).*)(?=.*\[.{250}\].*)(?=.*\{.{250}\}.*)(?=.*\[.\(\).\{\}.\].*)(?=.*\}...\[...\[...\]...\]...\{.*)(?=.*\(\(..\(\(.{68}\(\(\)\).{43}\)\)\)\).*)(?=.*\{..\{..\{.{65}\{\}\{\}.{33}\{\}.{107}\}\}.\}.*)(?=.*\[\{\{\[\(\{.*)(?=.*\[\[..\[.{6}\[.{6}\]\]...\]\].{6}\[..\]..\[\].*)(?=.*\]\]\}\}\}.\)\)\)\).{96}\]\}\}\]\]\]\}\]\]\].\)\]\].*)(?=.*\]..\).{6}\(.{7}\{.{5}\[...\[.{5}\{\[.*)(?=.*\[.{87}\{.{45}}{.{38}}.{27}\].*)(?=.*\(\{.{32}\(.{20}\{.{47}\].{43}\{\{.{25}\}\}.{18}\].{5}\}....\}.{5}\).*)(?=.*\{.{12}\(.{5}\(...\(...\{\[.\{\[\[.*)(?=.*\{\(.{21}\).{8}\}.{14}\[.{7}\]..\{.{5}\{\}....\}.*)(?=.*\(.\{.{49}\{.{16}\}.{25}\}.{66}\).*)(?!.*\(\{\(\(.*)(?!.*\(\)\[\].*)(?=(.*?\].*?\)){15,}.*)(?=(.*\[.*\(.*\{){5,9}.*)(?=.*\({3}.{105}\[{3}.{105}[^}{].*)(?=.*\(..\).{5}\(\)....\}\}\].\{\{\[.{22}\[.{35}\}\}\].*)(?!.*\(\(.{178}\])(?=(.*\[..\]){8,10}.*)(?!(.*\([^\(\)]{5}\(){4,}.*).{63}(.{6}).{130}\11.{51}$

Und erweitert:

^
(?=^([^)(]*\(((?>[^)(]+)|(?1))*\)[^)(]*)*$)
(?=^([^][]*\[((?>[^][]+)|(?3))*\][^][]*)*$)
(?=^([^}{]*\{((?>[^}{]+)|(?5))*\}[^}{]*)*$)
(?!^\(.*)
(?!.*\(.{250}\).*)
(?=.*\[.{250}\].*)
(?=.*\{.{250}\}.*)
(?=.*\[.\(\).\{\}.\].*)
(?=.*\}...\[...\[...\]...\]...\{.*)
(?=.*\(\(..\(\(.{68}\(\(\)\).{43}\)\)\)\).*)
(?=.*\{..\{..\{.{65}\{\}\{\}.{33}\{\}.{107}\}\}.\}.*)
(?=.*\[\{\{\[\(\{.*)
(?=.*\[\[..\[.{6}\[.{6}\]\]...\]\].{6}\[..\]..\[\].*)
(?=.*\]\]\}\}\}.\)\)\)\).{96}\]\}\}\]\]\]\}\]\]\].\)\]\].*)
(?=.*\]..\).{6}\(.{7}\{.{5}\[...\[.{5}\{\[.*)
(?=.*\[.{87}\{.{45}}{.{38}}.{27}\].*)
(?=.*\(\{.{32}\(.{20}\{.{47}\].{43}\{\{.{25}\}\}.{18}\].{5}\}....\}.{5}\).*)
(?=.*\{.{12}\(.{5}\(...\(...\{\[.\{\[\[.*)
(?=.*\{\(.{21}\).{8}\}.{14}\[.{7}\]..\{.{5}\{\}....\}.*)
(?=.*\(.\{.{49}\{.{16}\}.{25}\}.{66}\).*)
(?!.*\(\{\(\(.*)
(?!.*\(\)\[\].*)
(?=(.*?\].*?\)){15,}.*)
(?=(.*\[.*\(.*\{){5,9}.*)
(?=.*\({3}.{105}\[{3}.{105}[^}{].*)
(?=.*\(..\).{5}\(\)....\}\}\].\{\{\[.{22}\[.{35}\}\}\].*)
(?!.*\(\(.{178}\])
(?=(.*\[..\]){8,10}.*)
(?!(.*\([^\(\)]{5}\(){4,}.*)
.{63}(.{6}).{130}\11.{51}
$

Getestet auf Regex101 - abhängig von Ihrem Computer müssen Sie möglicherweise die maximale Ausführungszeit erhöhen .


Dieser reguläre Ausdruck kodiert eine ganze Reihe von Regeln, die nur erfüllt werden müssen. Jede Lösung wird genügen, es wird nur eine gefunden.

  • Die ersten drei Grundregeln erfordern, dass alle ([{Klammern innerhalb des Schlüssels separat abgeglichen werden müssen.
  • Die meisten Ausdrücke erfordern, dass sich eine bestimmte "Form" in der Tonart befindet oder nicht. Zum Beispiel erfordert die 8. Reihe etwas von der Form [.(.).].
  • Regeln wie (?=(.*\[.*\(.*\{){5,9}.*)zum Beispiel verlangen, dass die [({Abwechslung mindestens fünfmal erfolgt. Beachten Sie, dass insbesondere diese Zeile auf vielen Ebenen unbeabsichtigt abgehört wird.
  • Für die Rückreferenz ist es \11erforderlich, dass eine sechsstellige Teilzeichenfolge an bestimmten Positionen zweimal vorkommt.

Sp3000
quelle
2
Spiel : [((({.[.[](){{}{].{.(({){(.[]()....}}].{{[[....).[..]()(}..[..]([....(([{((({).](){.{}{}{}....}[[()[}}][{{[({[[[.]]}()]].{}.]{[..]{.[]]}}}())))(())[(.].{[.{[[..[()].()}{{.[...[}{.]..)]...{.])))).}}..([......{.....[.]}[...}.{[.}...}})}.))).]}}]]]}]]].)]]..}. Nicht-Spiel: WhatANastySetOfRulesYouHave.
Nneonneo
Ich habe die Ausführungszeit auf 50 Sekunden erhöht. Übrigens, wenn Sie nur die richtigen nicht-gierigen Quantifizierer verwenden (?=(.*\[.*\(.*\{){5,9}.*), müssen Sie die maximale Ausführungszeit (gleiches Ergebnis) nicht erhöhen - die Übereinstimmungen sind sofortig.
Nneonneo
@nneonneo Ahaha ja, das habe ich gemerkt, nachdem ich gepostet habe. Können Sie einen Pastebin-Link für Ihren Schlüssel veröffentlichen? SE Kommentare scheinen sich wieder zu zeigen
Sp3000
@nneonneo Auch wenn Sie so viele Punkte in Ihrer Lösung haben, hatte ich offensichtlich nicht genug Regeln: P
Sp3000
2
Hier ist ein Link zu regex101 mit meiner Lösung sichtbar: regex101.com/r/gP2aX7/1
nneonneo
4

.NET-Flavor (7563 Byte) [geknackt]

Inspiriert von der Idee von @ user23013

^(?:(?=1(?<1>){5632})|(?=0)).(?:(?=1(?<1>){79361})|(?=0)).(?:(?=1(?<1>){188421})|(?=0)).(?:(?=1(?<1>){164870})|(?=0)).(?:(?=1(?<1>){63496})|(?=0)).(?:(?=1(?<1>){116233})|(?=0)).(?:(?=1(?<1>){112138})|(?=0)).(?:(?=1(?<1>){47447})|(?=0)).(?:(?=1(?<1>){85005})|(?=0)).(?:(?=1(?<1>){17936})|(?=0)).(?:(?=1(?<1>){108053})|(?=0)).(?:(?=1(?<1>){88599})|(?=0)).(?:(?=1(?<1>){91672})|(?=0)).(?:(?=1(?<1>){178716})|(?=0)).(?:(?=1(?<1>){199710})|(?=0)).(?:(?=1(?<1>){166661})|(?=0)).(?:(?=1(?<1>){190496})|(?=0)).(?:(?=1(?<1>){184494})|(?=0)).(?:(?=1(?<1>){199203})|(?=0)).(?:(?=1(?<1>){116778})|(?=0)).(?:(?=1(?<1>){78891})|(?=0)).(?:(?=1(?<1>){192556})|(?=0)).(?:(?=1(?<1>){24995})|(?=0)).(?:(?=1(?<1>){1071})|(?=0)).(?:(?=1(?<1>){192561})|(?=0)).(?:(?=1(?<1>){108082})|(?=0)).(?:(?=1(?<1>){1593})|(?=0)).(?:(?=1(?<1>){26967})|(?=0)).(?:(?=1(?<1>){197983})|(?=0)).(?:(?=1(?<1>){97034})|(?=0)).(?:(?=1(?<1>){86965})|(?=0)).(?:(?=1(?<1>){60480})|(?=0)).(?:(?=1(?<1>){149571})|(?=0)).(?:(?=1(?<1>){100932})|(?=0)).(?:(?=1(?<1>){40519})|(?=0)).(?:(?=1(?<1>){173492})|(?=0)).(?:(?=1(?<1>){80972})|(?=0)).(?:(?=1(?<1>){115790})|(?=0)).(?:(?=1(?<1>){29265})|(?=0)).(?:(?=1(?<1>){91730})|(?=0)).(?:(?=1(?<1>){173140})|(?=0)).(?:(?=1(?<1>){52821})|(?=0)).(?:(?=1(?<1>){176726})|(?=0)).(?:(?=1(?<1>){170211})|(?=0)).(?:(?=1(?<1>){150105})|(?=0)).(?:(?=1(?<1>){23131})|(?=0)).(?:(?=1(?<1>){81503})|(?=0)).(?:(?=1(?<1>){77412})|(?=0)).(?:(?=1(?<1>){106086})|(?=0)).(?:(?=1(?<1>){4284})|(?=0)).(?:(?=1(?<1>){142610})|(?=0)).(?:(?=1(?<1>){167534})|(?=0)).(?:(?=1(?<1>){190577})|(?=0)).(?:(?=1(?<1>){147731})|(?=0)).(?:(?=1(?<1>){133748})|(?=0)).(?:(?=1(?<1>){194750})|(?=0)).(?:(?=1(?<1>){49257})|(?=0)).(?:(?=1(?<1>){49274})|(?=0)).(?:(?=1(?<1>){120767})|(?=0)).(?:(?=1(?<1>){172668})|(?=0)).(?:(?=1(?<1>){24703})|(?=0)).(?:(?=1(?<1>){108160})|(?=0)).(?:(?=1(?<1>){60546})|(?=0)).(?:(?=1(?<1>){56963})|(?=0)).(?:(?=1(?<1>){30340})|(?=0)).(?:(?=1(?<1>){95368})|(?=0)).(?:(?=1(?<1>){59530})|(?=0)).(?:(?=1(?<1>){53388})|(?=0)).(?:(?=1(?<1>){14477})|(?=0)).(?:(?=1(?<1>){28302})|(?=0)).(?:(?=1(?<1>){182927})|(?=0)).(?:(?=1(?<1>){59024})|(?=0)).(?:(?=1(?<1>){146200})|(?=0)).(?:(?=1(?<1>){153746})|(?=0)).(?:(?=1(?<1>){39571})|(?=0)).(?:(?=1(?<1>){134293})|(?=0)).(?:(?=1(?<1>){158362})|(?=0)).(?:(?=1(?<1>){170139})|(?=0)).(?:(?=1(?<1>){182940})|(?=0)).(?:(?=1(?<1>){7327})|(?=0)).(?:(?=1(?<1>){143525})|(?=0)).(?:(?=1(?<1>){119464})|(?=0)).(?:(?=1(?<1>){82090})|(?=0)).(?:(?=1(?<1>){170667})|(?=0)).(?:(?=1(?<1>){49522})|(?=0)).(?:(?=1(?<1>){69806})|(?=0)).(?:(?=1(?<1>){15535})|(?=0)).(?:(?=1(?<1>){16049})|(?=0)).(?:(?=1(?<1>){163358})|(?=0)).(?:(?=1(?<1>){181876})|(?=0)).(?:(?=1(?<1>){58044})|(?=0)).(?:(?=1(?<1>){16062})|(?=0)).(?:(?=1(?<1>){39616})|(?=0)).(?:(?=1(?<1>){31425})|(?=0)).(?:(?=1(?<1>){94404})|(?=0)).(?:(?=1(?<1>){86848})|(?=0)).(?:(?=1(?<1>){16589})|(?=0)).(?:(?=1(?<1>){195280})|(?=0)).(?:(?=1(?<1>){199377})|(?=0)).(?:(?=1(?<1>){43731})|(?=0)).(?:(?=1(?<1>){67534})|(?=0)).(?:(?=1(?<1>){106198})|(?=0)).(?:(?=1(?<1>){54999})|(?=0)).(?:(?=1(?<1>){52952})|(?=0)).(?:(?=1(?<1>){125828})|(?=0)).(?:(?=1(?<1>){169691})|(?=0)).(?:(?=1(?<1>){184542})|(?=0)).(?:(?=1(?<1>){177888})|(?=0)).(?:(?=1(?<1>){43233})|(?=0)).(?:(?=1(?<1>){127203})|(?=0)).(?:(?=1(?<1>){116518})|(?=0)).(?:(?=1(?<1>){117990})|(?=0)).(?:(?=1(?<1>){67815})|(?=0)).(?:(?=1(?<1>){62202})|(?=0)).(?:(?=1(?<1>){165611})|(?=0)).(?:(?=1(?<1>){197356})|(?=0)).(?:(?=1(?<1>){29933})|(?=0)).(?:(?=1(?<1>){90862})|(?=0)).(?:(?=1(?<1>){90863})|(?=0)).(?:(?=1(?<1>){149232})|(?=0)).(?:(?=1(?<1>){61681})|(?=0)).(?:(?=1(?<1>){137970})|(?=0)).(?:(?=1(?<1>){90357})|(?=0)).(?:(?=1(?<1>){47351})|(?=0)).(?:(?=1(?<1>){172509})|(?=0)).(?:(?=1(?<1>){78293})|(?=0)).(?:(?=1(?<1>){66303})|(?=0)).(?:(?=1(?<1>){66262})|(?=0)).(?:(?=1(?<1>){158471})|(?=0)).(?:(?=1(?<1>){5676})|(?=0)).(?:(?=1(?<1>){127242})|(?=0)).(?:(?=1(?<1>){51979})|(?=0)).(?:(?=1(?<1>){162060})|(?=0)).(?:(?=1(?<1>){27405})|(?=0)).(?:(?=1(?<1>){153874})|(?=0)).(?:(?=1(?<1>){150291})|(?=0)).(?:(?=1(?<1>){1814})|(?=0)).(?:(?=1(?<1>){193815})|(?=0)).(?:(?=1(?<1>){82200})|(?=0)).(?:(?=1(?<1>){59161})|(?=0)).(?:(?=1(?<1>){78620})|(?=0)).(?:(?=1(?<1>){123678})|(?=0)).(?:(?=1(?<1>){147232})|(?=0)).(?:(?=1(?<1>){71457})|(?=0)).(?:(?=1(?<1>){118562})|(?=0)).(?:(?=1(?<1>){129830})|(?=0)).(?:(?=1(?<1>){161841})|(?=0)).(?:(?=1(?<1>){60295})|(?=0)).(?:(?=1(?<1>){165426})|(?=0)).(?:(?=1(?<1>){107485})|(?=0)).(?:(?=1(?<1>){171828})|(?=0)).(?:(?=1(?<1>){166200})|(?=0)).(?:(?=1(?<1>){35124})|(?=0)).(?:(?=1(?<1>){160573})|(?=0)).(?:(?=1(?<1>){7486})|(?=0)).(?:(?=1(?<1>){169279})|(?=0)).(?:(?=1(?<1>){151360})|(?=0)).(?:(?=1(?<1>){6978})|(?=0)).(?:(?=1(?<1>){136003})|(?=0)).(?:(?=1(?<1>){56133})|(?=0)).(?:(?=1(?<1>){8520})|(?=0)).(?:(?=1(?<1>){87436})|(?=0)).(?:(?=1(?<1>){57162})|(?=0)).(?:(?=1(?<1>){197965})|(?=0)).(?:(?=1(?<1>){145230})|(?=0)).(?:(?=1(?<1>){95459})|(?=0)).(?:(?=1(?<1>){180564})|(?=0)).(?:(?=1(?<1>){157850})|(?=0)).(?:(?=1(?<1>){109399})|(?=0)).(?:(?=1(?<1>){191832})|(?=0)).(?:(?=1(?<1>){110223})|(?=0)).(?:(?=1(?<1>){75102})|(?=0)).(?:(?=1(?<1>){140639})|(?=0)).(?:(?=1(?<1>){49504})|(?=0)).(?:(?=1(?<1>){197987})|(?=0)).(?:(?=1(?<1>){52744})|(?=0)).(?:(?=1(?<1>){96615})|(?=0)).(?:(?=1(?<1>){13672})|(?=0)).(?:(?=1(?<1>){73068})|(?=0)).(?:(?=1(?<1>){104814})|(?=0)).(?:(?=1(?<1>){66929})|(?=0)).(?:(?=1(?<1>){23410})|(?=0)).(?:(?=1(?<1>){122686})|(?=0)).(?:(?=1(?<1>){44918})|(?=0)).(?:(?=1(?<1>){101752})|(?=0)).(?:(?=1(?<1>){3961})|(?=0)).(?:(?=1(?<1>){31807})|(?=0)).(?:(?=1(?<1>){54933})|(?=0)).(?:(?=1(?<1>){140096})|(?=0)).(?:(?=1(?<1>){49026})|(?=0)).(?:(?=1(?<1>){5507})|(?=0)).(?:(?=1(?<1>){96132})|(?=0)).(?:(?=1(?<1>){167303})|(?=0)).(?:(?=1(?<1>){57877})|(?=0)).(?:(?=1(?<1>){88461})|(?=0)).(?:(?=1(?<1>){111853})|(?=0)).(?:(?=1(?<1>){126531})|(?=0)).(?:(?=1(?<1>){110998})|(?=0)).(?:(?=1(?<1>){7575})|(?=0)).(?:(?=1(?<1>){7064})|(?=0)).(?:(?=1(?<1>){59289})|(?=0)).(?:(?=1(?<1>){122203})|(?=0)).(?:(?=1(?<1>){175005})|(?=0)).(?:(?=1(?<1>){28025})|(?=0)).(?:(?=1(?<1>){49057})|(?=0)).(?:(?=1(?<1>){6373})|(?=0)).(?:(?=1(?<1>){50084})|(?=0)).(?:(?=1(?<1>){70565})|(?=0)).(?:(?=1(?<1>){75178})|(?=0)).(?:(?=1(?<1>){142763})|(?=0)).(?:(?=1(?<1>){56237})|(?=0)).(?:(?=1(?<1>){32176})|(?=0)).(?:(?=1(?<1>){113073})|(?=0)).(?:(?=1(?<1>){149939})|(?=0)).(?:(?=1(?<1>){16308})|(?=0)).(?:(?=1(?<1>){12725})|(?=0)).(?:(?=1(?<1>){75190})|(?=0)).(?:(?=1(?<1>){54711})|(?=0)).(?:(?=1(?<1>){180664})|(?=0)).(?:(?=1(?<1>){68540})|(?=0)).(?:(?=1(?<1>){93117})|(?=0)).(?:(?=1(?<1>){161781})|(?=0)).(?:(?=1(?<1>){15808})|(?=0)).(?:(?=1(?<1>){130814})|(?=0)).(?:(?=1(?<1>){162379})|(?=0)).(?:(?=1(?<1>){80836})|(?=0)).(?:(?=1(?<1>){149943})|(?=0)).(?:(?=1(?<1>){16841})|(?=0)).(?:(?=1(?<1>){149452})|(?=0)).(?:(?=1(?<1>){182733})|(?=0)).(?:(?=1(?<1>){56270})|(?=0)).(?:(?=1(?<1>){163792})|(?=0)).(?:(?=1(?<1>){34770})|(?=0)).(?:(?=1(?<1>){101843})|(?=0)).(?:(?=1(?<1>){199124})|(?=0)).(?:(?=1(?<1>){129493})|(?=0)).(?:(?=1(?<1>){43990})|(?=0)).(?:(?=1(?<1>){113112})|(?=0)).(?:(?=1(?<1>){71129})|(?=0)).(?:(?=1(?<1>){61402})|(?=0)).(?:(?=1(?<1>){145852})|(?=0)).(?:(?=1(?<1>){98781})|(?=0)).(?:(?=1(?<1>){141790})|(?=0)).(?:(?=1(?<1>){163235})|(?=0)).(?:(?=1(?<1>){110566})|(?=0)).(?:(?=1(?<1>){117737})|(?=0)).(?:(?=1(?<1>){67050})|(?=0)).(?:(?=1(?<1>){68075})|(?=0)).(?:(?=1(?<1>){124047})|(?=0)).(?:(?=1(?<1>){181587})|(?=0)).(?:(?=1(?<1>){125429})|(?=0)).(?:(?=1(?<1>){112118})|(?=0)).(?:(?=1(?<1>){196088})|(?=0)).(?:(?=1(?<1>){25082})|(?=0)).(?:(?=1(?<1>){178684})|(?=0)).(?:(?=1(?<1>){13822})|(?=0)).(?<-1>){10094986}(?(1)(?!))$

Wir können einfach nicht genug NP-vollständige Probleme haben! Hier ist die erweiterte Version:

^
(?:(?=1(?<1>){5632})|(?=0)).
(?:(?=1(?<1>){79361})|(?=0)).
(?:(?=1(?<1>){188421})|(?=0)).
(?:(?=1(?<1>){164870})|(?=0)).
(?:(?=1(?<1>){63496})|(?=0)).
(?:(?=1(?<1>){116233})|(?=0)).
(?:(?=1(?<1>){112138})|(?=0)).
(?:(?=1(?<1>){47447})|(?=0)).
(?:(?=1(?<1>){85005})|(?=0)).
(?:(?=1(?<1>){17936})|(?=0)).
(?:(?=1(?<1>){108053})|(?=0)).
(?:(?=1(?<1>){88599})|(?=0)).
(?:(?=1(?<1>){91672})|(?=0)).
(?:(?=1(?<1>){178716})|(?=0)).
(?:(?=1(?<1>){199710})|(?=0)).
(?:(?=1(?<1>){166661})|(?=0)).
(?:(?=1(?<1>){190496})|(?=0)).
(?:(?=1(?<1>){184494})|(?=0)).
(?:(?=1(?<1>){199203})|(?=0)).
(?:(?=1(?<1>){116778})|(?=0)).
(?:(?=1(?<1>){78891})|(?=0)).
(?:(?=1(?<1>){192556})|(?=0)).
(?:(?=1(?<1>){24995})|(?=0)).
(?:(?=1(?<1>){1071})|(?=0)).
(?:(?=1(?<1>){192561})|(?=0)).
(?:(?=1(?<1>){108082})|(?=0)).
(?:(?=1(?<1>){1593})|(?=0)).
(?:(?=1(?<1>){26967})|(?=0)).
(?:(?=1(?<1>){197983})|(?=0)).
(?:(?=1(?<1>){97034})|(?=0)).
(?:(?=1(?<1>){86965})|(?=0)).
(?:(?=1(?<1>){60480})|(?=0)).
(?:(?=1(?<1>){149571})|(?=0)).
(?:(?=1(?<1>){100932})|(?=0)).
(?:(?=1(?<1>){40519})|(?=0)).
(?:(?=1(?<1>){173492})|(?=0)).
(?:(?=1(?<1>){80972})|(?=0)).
(?:(?=1(?<1>){115790})|(?=0)).
(?:(?=1(?<1>){29265})|(?=0)).
(?:(?=1(?<1>){91730})|(?=0)).
(?:(?=1(?<1>){173140})|(?=0)).
(?:(?=1(?<1>){52821})|(?=0)).
(?:(?=1(?<1>){176726})|(?=0)).
(?:(?=1(?<1>){170211})|(?=0)).
(?:(?=1(?<1>){150105})|(?=0)).
(?:(?=1(?<1>){23131})|(?=0)).
(?:(?=1(?<1>){81503})|(?=0)).
(?:(?=1(?<1>){77412})|(?=0)).
(?:(?=1(?<1>){106086})|(?=0)).
(?:(?=1(?<1>){4284})|(?=0)).
(?:(?=1(?<1>){142610})|(?=0)).
(?:(?=1(?<1>){167534})|(?=0)).
(?:(?=1(?<1>){190577})|(?=0)).
(?:(?=1(?<1>){147731})|(?=0)).
(?:(?=1(?<1>){133748})|(?=0)).
(?:(?=1(?<1>){194750})|(?=0)).
(?:(?=1(?<1>){49257})|(?=0)).
(?:(?=1(?<1>){49274})|(?=0)).
(?:(?=1(?<1>){120767})|(?=0)).
(?:(?=1(?<1>){172668})|(?=0)).
(?:(?=1(?<1>){24703})|(?=0)).
(?:(?=1(?<1>){108160})|(?=0)).
(?:(?=1(?<1>){60546})|(?=0)).
(?:(?=1(?<1>){56963})|(?=0)).
(?:(?=1(?<1>){30340})|(?=0)).
(?:(?=1(?<1>){95368})|(?=0)).
(?:(?=1(?<1>){59530})|(?=0)).
(?:(?=1(?<1>){53388})|(?=0)).
(?:(?=1(?<1>){14477})|(?=0)).
(?:(?=1(?<1>){28302})|(?=0)).
(?:(?=1(?<1>){182927})|(?=0)).
(?:(?=1(?<1>){59024})|(?=0)).
(?:(?=1(?<1>){146200})|(?=0)).
(?:(?=1(?<1>){153746})|(?=0)).
(?:(?=1(?<1>){39571})|(?=0)).
(?:(?=1(?<1>){134293})|(?=0)).
(?:(?=1(?<1>){158362})|(?=0)).
(?:(?=1(?<1>){170139})|(?=0)).
(?:(?=1(?<1>){182940})|(?=0)).
(?:(?=1(?<1>){7327})|(?=0)).
(?:(?=1(?<1>){143525})|(?=0)).
(?:(?=1(?<1>){119464})|(?=0)).
(?:(?=1(?<1>){82090})|(?=0)).
(?:(?=1(?<1>){170667})|(?=0)).
(?:(?=1(?<1>){49522})|(?=0)).
(?:(?=1(?<1>){69806})|(?=0)).
(?:(?=1(?<1>){15535})|(?=0)).
(?:(?=1(?<1>){16049})|(?=0)).
(?:(?=1(?<1>){163358})|(?=0)).
(?:(?=1(?<1>){181876})|(?=0)).
(?:(?=1(?<1>){58044})|(?=0)).
(?:(?=1(?<1>){16062})|(?=0)).
(?:(?=1(?<1>){39616})|(?=0)).
(?:(?=1(?<1>){31425})|(?=0)).
(?:(?=1(?<1>){94404})|(?=0)).
(?:(?=1(?<1>){86848})|(?=0)).
(?:(?=1(?<1>){16589})|(?=0)).
(?:(?=1(?<1>){195280})|(?=0)).
(?:(?=1(?<1>){199377})|(?=0)).
(?:(?=1(?<1>){43731})|(?=0)).
(?:(?=1(?<1>){67534})|(?=0)).
(?:(?=1(?<1>){106198})|(?=0)).
(?:(?=1(?<1>){54999})|(?=0)).
(?:(?=1(?<1>){52952})|(?=0)).
(?:(?=1(?<1>){125828})|(?=0)).
(?:(?=1(?<1>){169691})|(?=0)).
(?:(?=1(?<1>){184542})|(?=0)).
(?:(?=1(?<1>){177888})|(?=0)).
(?:(?=1(?<1>){43233})|(?=0)).
(?:(?=1(?<1>){127203})|(?=0)).
(?:(?=1(?<1>){116518})|(?=0)).
(?:(?=1(?<1>){117990})|(?=0)).
(?:(?=1(?<1>){67815})|(?=0)).
(?:(?=1(?<1>){62202})|(?=0)).
(?:(?=1(?<1>){165611})|(?=0)).
(?:(?=1(?<1>){197356})|(?=0)).
(?:(?=1(?<1>){29933})|(?=0)).
(?:(?=1(?<1>){90862})|(?=0)).
(?:(?=1(?<1>){90863})|(?=0)).
(?:(?=1(?<1>){149232})|(?=0)).
(?:(?=1(?<1>){61681})|(?=0)).
(?:(?=1(?<1>){137970})|(?=0)).
(?:(?=1(?<1>){90357})|(?=0)).
(?:(?=1(?<1>){47351})|(?=0)).
(?:(?=1(?<1>){172509})|(?=0)).
(?:(?=1(?<1>){78293})|(?=0)).
(?:(?=1(?<1>){66303})|(?=0)).
(?:(?=1(?<1>){66262})|(?=0)).
(?:(?=1(?<1>){158471})|(?=0)).
(?:(?=1(?<1>){5676})|(?=0)).
(?:(?=1(?<1>){127242})|(?=0)).
(?:(?=1(?<1>){51979})|(?=0)).
(?:(?=1(?<1>){162060})|(?=0)).
(?:(?=1(?<1>){27405})|(?=0)).
(?:(?=1(?<1>){153874})|(?=0)).
(?:(?=1(?<1>){150291})|(?=0)).
(?:(?=1(?<1>){1814})|(?=0)).
(?:(?=1(?<1>){193815})|(?=0)).
(?:(?=1(?<1>){82200})|(?=0)).
(?:(?=1(?<1>){59161})|(?=0)).
(?:(?=1(?<1>){78620})|(?=0)).
(?:(?=1(?<1>){123678})|(?=0)).
(?:(?=1(?<1>){147232})|(?=0)).
(?:(?=1(?<1>){71457})|(?=0)).
(?:(?=1(?<1>){118562})|(?=0)).
(?:(?=1(?<1>){129830})|(?=0)).
(?:(?=1(?<1>){161841})|(?=0)).
(?:(?=1(?<1>){60295})|(?=0)).
(?:(?=1(?<1>){165426})|(?=0)).
(?:(?=1(?<1>){107485})|(?=0)).
(?:(?=1(?<1>){171828})|(?=0)).
(?:(?=1(?<1>){166200})|(?=0)).
(?:(?=1(?<1>){35124})|(?=0)).
(?:(?=1(?<1>){160573})|(?=0)).
(?:(?=1(?<1>){7486})|(?=0)).
(?:(?=1(?<1>){169279})|(?=0)).
(?:(?=1(?<1>){151360})|(?=0)).
(?:(?=1(?<1>){6978})|(?=0)).
(?:(?=1(?<1>){136003})|(?=0)).
(?:(?=1(?<1>){56133})|(?=0)).
(?:(?=1(?<1>){8520})|(?=0)).
(?:(?=1(?<1>){87436})|(?=0)).
(?:(?=1(?<1>){57162})|(?=0)).
(?:(?=1(?<1>){197965})|(?=0)).
(?:(?=1(?<1>){145230})|(?=0)).
(?:(?=1(?<1>){95459})|(?=0)).
(?:(?=1(?<1>){180564})|(?=0)).
(?:(?=1(?<1>){157850})|(?=0)).
(?:(?=1(?<1>){109399})|(?=0)).
(?:(?=1(?<1>){191832})|(?=0)).
(?:(?=1(?<1>){110223})|(?=0)).
(?:(?=1(?<1>){75102})|(?=0)).
(?:(?=1(?<1>){140639})|(?=0)).
(?:(?=1(?<1>){49504})|(?=0)).
(?:(?=1(?<1>){197987})|(?=0)).
(?:(?=1(?<1>){52744})|(?=0)).
(?:(?=1(?<1>){96615})|(?=0)).
(?:(?=1(?<1>){13672})|(?=0)).
(?:(?=1(?<1>){73068})|(?=0)).
(?:(?=1(?<1>){104814})|(?=0)).
(?:(?=1(?<1>){66929})|(?=0)).
(?:(?=1(?<1>){23410})|(?=0)).
(?:(?=1(?<1>){122686})|(?=0)).
(?:(?=1(?<1>){44918})|(?=0)).
(?:(?=1(?<1>){101752})|(?=0)).
(?:(?=1(?<1>){3961})|(?=0)).
(?:(?=1(?<1>){31807})|(?=0)).
(?:(?=1(?<1>){54933})|(?=0)).
(?:(?=1(?<1>){140096})|(?=0)).
(?:(?=1(?<1>){49026})|(?=0)).
(?:(?=1(?<1>){5507})|(?=0)).
(?:(?=1(?<1>){96132})|(?=0)).
(?:(?=1(?<1>){167303})|(?=0)).
(?:(?=1(?<1>){57877})|(?=0)).
(?:(?=1(?<1>){88461})|(?=0)).
(?:(?=1(?<1>){111853})|(?=0)).
(?:(?=1(?<1>){126531})|(?=0)).
(?:(?=1(?<1>){110998})|(?=0)).
(?:(?=1(?<1>){7575})|(?=0)).
(?:(?=1(?<1>){7064})|(?=0)).
(?:(?=1(?<1>){59289})|(?=0)).
(?:(?=1(?<1>){122203})|(?=0)).
(?:(?=1(?<1>){175005})|(?=0)).
(?:(?=1(?<1>){28025})|(?=0)).
(?:(?=1(?<1>){49057})|(?=0)).
(?:(?=1(?<1>){6373})|(?=0)).
(?:(?=1(?<1>){50084})|(?=0)).
(?:(?=1(?<1>){70565})|(?=0)).
(?:(?=1(?<1>){75178})|(?=0)).
(?:(?=1(?<1>){142763})|(?=0)).
(?:(?=1(?<1>){56237})|(?=0)).
(?:(?=1(?<1>){32176})|(?=0)).
(?:(?=1(?<1>){113073})|(?=0)).
(?:(?=1(?<1>){149939})|(?=0)).
(?:(?=1(?<1>){16308})|(?=0)).
(?:(?=1(?<1>){12725})|(?=0)).
(?:(?=1(?<1>){75190})|(?=0)).
(?:(?=1(?<1>){54711})|(?=0)).
(?:(?=1(?<1>){180664})|(?=0)).
(?:(?=1(?<1>){68540})|(?=0)).
(?:(?=1(?<1>){93117})|(?=0)).
(?:(?=1(?<1>){161781})|(?=0)).
(?:(?=1(?<1>){15808})|(?=0)).
(?:(?=1(?<1>){130814})|(?=0)).
(?:(?=1(?<1>){162379})|(?=0)).
(?:(?=1(?<1>){80836})|(?=0)).
(?:(?=1(?<1>){149943})|(?=0)).
(?:(?=1(?<1>){16841})|(?=0)).
(?:(?=1(?<1>){149452})|(?=0)).
(?:(?=1(?<1>){182733})|(?=0)).
(?:(?=1(?<1>){56270})|(?=0)).
(?:(?=1(?<1>){163792})|(?=0)).
(?:(?=1(?<1>){34770})|(?=0)).
(?:(?=1(?<1>){101843})|(?=0)).
(?:(?=1(?<1>){199124})|(?=0)).
(?:(?=1(?<1>){129493})|(?=0)).
(?:(?=1(?<1>){43990})|(?=0)).
(?:(?=1(?<1>){113112})|(?=0)).
(?:(?=1(?<1>){71129})|(?=0)).
(?:(?=1(?<1>){61402})|(?=0)).
(?:(?=1(?<1>){145852})|(?=0)).
(?:(?=1(?<1>){98781})|(?=0)).
(?:(?=1(?<1>){141790})|(?=0)).
(?:(?=1(?<1>){163235})|(?=0)).
(?:(?=1(?<1>){110566})|(?=0)).
(?:(?=1(?<1>){117737})|(?=0)).
(?:(?=1(?<1>){67050})|(?=0)).
(?:(?=1(?<1>){68075})|(?=0)).
(?:(?=1(?<1>){124047})|(?=0)).
(?:(?=1(?<1>){181587})|(?=0)).
(?:(?=1(?<1>){125429})|(?=0)).
(?:(?=1(?<1>){112118})|(?=0)).
(?:(?=1(?<1>){196088})|(?=0)).
(?:(?=1(?<1>){25082})|(?=0)).
(?:(?=1(?<1>){178684})|(?=0)).
(?:(?=1(?<1>){13822})|(?=0)).
(?<-1>){10094986}
(?(1)(?!))
$

In jeder (?:(?=1(?<1>){n})|(?=0)).Zeile werden nleere Zeichenfolgen zu Gruppen zusammengefasst, 1wenn die Ziffer 1 gefunden wird, und nichts, wenn a 0gefunden wird. (?<-1>){10094986}(?(1)(?!))überprüft dann, ob die Gesamtzahl der leeren Zeichenfolgen in Gruppe 1 am Ende 10094986 beträgt. Daher ist es unser Ziel, eine Teilmenge der Zahlen zu finden, deren Gesamtzahl 10094986 beträgt. Dies ist genau das Teilmengen-Summenproblem, für das es sich um einen Sonderfall handelt das Rucksackproblem, und ist NP-vollständig.

Getestet auf Regex Hero (Regex Storm läuft in diesem Fall aus).

Sp3000
quelle
2
Spiel: 01111111111111111111111011001111111111011111111111111111111101111111111 11111111111111111111011111111000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000 (diese Leerzeichen entfernen). Nicht-Spiel: KnapsackAlgorithm . Es ist nicht einfach, Silverlight auf meinem Ubuntu-Computer zu installieren. Aber das hat bei einem anderen Tester funktioniert.
Jimmy23013
@ user23013 Hoppla, ich habe vergessen, dass Silverlight erforderlich ist. Aber ehrlich gesagt, entweder habe ich Pech oder es gibt viele Lösungen, denn das ist eine blöde lange Kette von Nullen am Ende.
Andererseits
Ich hatte in meiner letzten Antwort bereits mehr als 700 Bit Integer!
Jimmy23013
@ user23013 Und du sagst uns, wir sollen es faktorisieren? So gemein! : P
Sp3000
2
Die zu faktorisierende Ganzzahl ist 1536 Bit.
Jimmy23013
4

.NET-Variante (52506 Byte)

Teilmenge Summe, Deluxe Edition.

Regex hier , erweiterte Version hier , getestet auf RegExLib und Regex Hero


Match: 1000010001000000001101011000001101110101001010011101000101010011011101000001010101001000010010000111011101100101001101001111000111010101100000101000101010110001010101001100100001110010001101010101100010110011000000110110000000011111101000001000011111100010

Mismatch: Huzzah for NP-complete regexes

Dieser reguläre Ausdruck ist ein riesiges Teilmengenproblem und verwendet 16 Gruppen zum Speichern von Daten. Jeder 1in der Zeichenfolge steht für 16 10-Bit-Zahlen, die zusammen eine 160-Bit-Ganzzahl darstellen. Die letzten Zeilen des regulären Ausdrucks enthalten die Werte in den Gruppen, sodass die Gruppen 2 bis 16 auf 1023 aufsteigen (z. B. 1 * 1023 + 1024 werden zu 2 * 1023 + 1), da wir sonst nur 16 gleichzeitige Mini-Teilmengen lösen würden Summenprobleme im Gegensatz zu einem großen.

Sp3000
quelle
Herzlichen Glückwunsch zu den 72 Stunden! Sie können Ihre Antwort jetzt gegen Knacken sperren, indem Sie den Schlüssel aufdecken. Bis Sie dies tun, kann die Antwort immer noch geknackt werden.
Martin Ender
4

.NET-Version, 53.884 Byte [sicher]

Erstellt von GnuPG! Und durch pgpdump extrahiert. Es ist 1536 Bit, da längere Versionen auf dem Online-Tester fehlgeschlagen sind.

Der reguläre Ausdruck ist hier: http://pastebin.com/PkJnj9ME

Getestet am RegExLib (ohne ausgewählte Optionen). Ich hoffe, ich habe ihnen nicht zu viel Ärger gemacht.

Sie wollen wahrscheinlich knacken zuerst die einfache Version . Es ist dasselbe wie dieses, außer dass es einen viel kürzeren Schlüssel gibt.

Sie möchten wahrscheinlich auch diese Nummer:

1877387013349538768090205114842510626651131723107399383794998450806739516994144298310401108806926034240658300213548103711527384569076779151468208082508190882390076337427064709559437854062111632001332811449146722382069400055588711790985185172254011431483115758796920145490044311800185920322455262251745973830227470485279892907738203417793535991544580378895041359393212505410554875960037474608732567216291143821804979045946285675144158233812053215704503132829164251

Der Schlüssel

Spiel:

Ëòčĵċsïݲ¤ėGâĥÓŧÿÃiTüū&0EĚĵŒR@bĵ¤¿Ĉ=ķüÙļÞďYaŃīŲĢŪÕďųïyĘŊŢĝĪĘŠćĢmtŠîĽþĽłŶāĨĩģTő!ĺw=aŧïųţĨíœą¸Ëč!,ĵţ¨ŌąŜ7ć<ůū¹"VCæ>õêqKËĖ¡ôÕÂúëdčÜÇĺřGĝ¢ÈòTdĩŤŭi§aćŎŭųä«´3ĚΦîŇĬÒÕ¥ńü½å±ì³Jõ«D>ìYũʼn5öķ@ŪĠďàÂIĭųė!

Nicht übereinstimmend:

1111111111111111

Die Primzahlen:

1332079940234179614521970444786413763737753518438170921866494487346327879385305027126769158207767221820861337268140670862294914465261588406119592761408774455338383491427898155074772832852850476306153369461364785463871635843192956321
1409365126404871907363160248446313781336249368768980464167188493095028723639124224991540391841197901143131758645183823514744033123070116823118973220350307542767897614254042472660258176592286316247065295064507580468562028846326382331

Erklärung ist in der einfachen Version .

Das Generator-Skript (in CJam)

'~),'!i>"+.()?*\\[]{|}^$/,^-:#"-
'ǝ,'¡i>173c-+289<:T;

95:F;
95:G;

"
^
(?=["T",]{"FG+)`"}$)
(?=.{"F`"},)
(?!.*,.*,)
(?:
    (?(X)
        (?<-X>)
        (?(L)(?<-L>)(?<l>)|){16}
    |
        (?:
            "
            [T289,]z
            {[~17md["(?<l>){"\'}]["(?<L>){"@'}]]}%'|*
            "
        )
        (?<X>)
    )
    (?=.*,
        (?:
            (?(Y)
                (?<-Y>)
                (?(R)(?<-R>)(?<r>)|){16}
            |
                (?:
                    "
                    [T289,]z
                    {[~17md["(?<r>){"\'}]["(?<R>){"@'}]]}%'|*
                    "
                )
                (?<Y>)
            )

            (?(l)
                (?<-l>)(?<x>)
                (?(r)(?<-r>)(?<y>)(?<v>)|){16}
                (?(y)(?<-y>)(?<r>)|){16}
            |){16}
            (?(x)(?<-x>)(?<l>)|){16}

            (?(p)(?<-p>)(?<s>)(?<z>)|){"F2*(`"}
            (?(z)(?<-z>)(?<p>)|){"F2*(`"}
            (?(q)(?<-q>)(?<s>)(?<z>)|){"G2*(`"}
            (?(z)(?<-z>)(?<q>)|){"G2*(`"}
            "
            "
            (?(s)
                (?<-s>)
            "FG+(2**
            "
                (?(v)(?<-v>)(?<a"FG+(2*`">)|){256}
            "
            ["
            |
                (?(v)(?<-v>)(?<a"">)|){256}
            )
            "]aFG+(2*,W%m*{~\~@`\}/
            "
            (?(r)(?<-r>)|){16}
            (?<q>)
        ){"G2*`"}
        (?<-q>){"G2*`"}
    )
    (?(l)(?<-l>)|){16}
    (?<p>)
){"F2*`"},

"
[
l~17bW%_,FG+2*\- 0a*+
FG+2*,
]z
{
~:A`:B;:C;
"
(?<-a"B">){"C`"}
(?(a"B")(?<-a"B">){17}(?<a"A)`">)|){4100}
(?(a"B")(?!)|)"
}/

]:+N9c+-

Die Eingabe sollte die oben angegebene Zahl sein.

Nachdem Sie fertig sind, kann die Lösung von diesem Programm generiert werden:

'~),'!i>"+.()?*\\[]{|}^$/,^-:#"-
'ǝ,'¡i>173c-+289<:T;

95:F;
95:G;

{
r~289bW%_,FG:F;\- 0a*+
{T=}%
}2*',\

Die Eingabe sollte aus zwei ganzen Zahlen bestehen.

jimmy23013
quelle
Schade. RegExLib ist nicht verfügbar. Ich denke, die Leute sollten besser ein Silverlight oder einen lokalen Tester verwenden. Aber ich kann sie nicht testen.
Jimmy23013
RegexHero ist ein .NET-Tester im Browser, der Silverlight verwendet.
n̴̖̋h̴̖̋a̷̭̿h̷̭̿d̸̡̅ẗ̵̨́
Eine weitere Idee für große Ganzzahlen ist die Berechnung der Produktmodifikationsprimzahlen in der Nähe von 200. Sie sollte schneller sein. Aber der Code wäre viel länger und ich werde das nicht in ganzzahligen Faktorisierungsantworten tun.
Jimmy23013
Herzlichen Glückwunsch zu den 72 Stunden! Sie können Ihre Antwort jetzt gegen Knacken sperren, indem Sie den Schlüssel aufdecken. Bis Sie dies tun, kann die Antwort immer noch geknackt werden.
Martin Ender
4

PHP, 395 Bytes [geknackt von nneonneo ]

^( *)( *)( *)(['.-])((?!\4)(?4)+?)((?!\4|\5)(?4)++)\1\3whale
(?=.(.))\6.\7\4(?!\4|\6)([_\/])\3(?!(?11))\8\2(?=\2)\3\1_((?=\4+.).\5(?!\6)\5)(?!.?')\7\4
(?=.\7)\6.([,`])\3{2}(?=.((?!\8)[_\/])\11)\Q(_\E.\4{2}(?!\.)\5((?!\10)(?10)(?!\4+|\5|\6))\1\3{3}(\\)
(\3{3})\13\2{2}\1{1}\3+(?<=\S {10})\4\1\3\|
\1(?=\12)(?12)(?!`,)\10\4(\11{2})\4\14\10\15\9\8
\14{2}(?=\6)['-]\4(?<!-)\11\8\11\4\6\11\15\.-|(?!)

Ein besseres Puzzle als mein letzter Eintrag.

Hinweis: Der übereinstimmende Schlüssel ist mehrzeilig, wobei jede Zeile durch das neue Zeilenzeichen getrennt ist \n. Erstellen Sie einige ASCII-Grafiken neu!

Hier ist eine Regex-Demo .

Eineder
quelle
3
Übereinstimmung : 202e272d207768616c650a2d3a3a2e2f202f205f2e27273a2e0a2d3a2c2020285f5f2e2e27602020205c0a2020205c202020202020202020202e207c0a602c2e5f5f2e2020202c5f5f2e27272f0a2020202020202d2e5f2f5f2e2d5f5f5f2e2d(hexadezimal codiert). Nicht-Spiel : IDon'tThinkIGotTheRightPicture. Proof-Arbeitsbereich: regex101.com/r/gF9pU0/1
nneonneo
1
@ Nneonneo Wow! Sie haben es gelöst: D Aber das richtige Bild ist hier: regex101.com/r/oM9rC4/1
Unihedron
1
Ja, ich dachte, ich hätte nicht genug Platz (aber der Regex hat nicht zu stark nachgesehen). Und anscheinend habe ich .-'zu Beginn getauscht .'-. Ersteres ist im Nachhinein für die ASCII-Kunst viel plausibler;)
nneonneo
3

Perlgeschmack, 97 [geknackt]

Ich befürchte, dass dies aufgrund der Schlüssellängenbeschränkung zu einfach sein wird.

^([^,]+),(?!\1)([^,]+),(?!\1|\2,)([^,]+),(?!\1|(?:\2|\3),)([^,]+),(?=.\2+$)(?=.\3+$)(?=.\4+$)\1+$

Wenn Sie glauben, die Idee dahinter zu haben, probieren Sie die längere Version (nicht Teil der Herausforderung):

^((?:[^,]{3})+),(?!\1)([^,]+),(?!\1|\2,)([^,]+),(?!\1|(?:\2|\3),)([^,]+),(?!\1|(?:\2|\3|\4),)([^,]+),(?!\1|(?:\2|\3|\4|\5),)([^,]+),(?!\1|(?:\2|\3|\4|\5|\6),)([^,]+),(?!\1|(?:\2|\3|\4|\5|\6|\7),)([^,]+),(?=.\2+$)(?=.\3+$)(?=.\4+$)(?=.\5+$)(?=.\6+$)(?=.\7+$)(?=.\8+$)\1+$
Ell
quelle
1
Spiel: aaaaaaa,a,aa,aaa,aaaaaaa. Nicht-Spiel: aaaabaaacaaadaaa.
Jimmy23013
Längere Version: Match: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,a,aa,(diese Zeichen aaaa,aaaaaaa,aaaaaaaa,aaaaaaaaaaaaaa,aaaaaaaaaaaaaaaaaaaaaaaaaaaa,entfernen ) (diese Zeichen entfernen) aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa. Non-Match:aaaabaaacaaadaaa
Jimmy23013
@ user23013: Die Kurzversion ist korrekt! Ich wollte, dass die Erfassungsgruppen mindestens zwei Zeichen lang sind, was den Schlüssel etwas länger gemacht hätte, aber ich habe vergessen, ihn zu ändern: P Die längere Version ist jedoch falsch.
Ell
Diese Seite hat einige unsichtbare Sonderzeichen hinzugefügt, als ich sie gepostet habe. Ich denke, es ist jetzt behoben. (Ohne die (remove these characters).)
Jimmy23013
@ user23013 Ja, das ist eine Übereinstimmung. Ich hatte wirklich nicht vor, dass es so einfach wird: P
Ell