Eine Aktivität, die ich manchmal mache, wenn ich gelangweilt bin, besteht darin, ein paar Zeichen in übereinstimmenden Paaren zu schreiben. Ich zeichne dann Linien (über die Spitzen, niemals unter), um diese Charaktere zu verbinden. Zum Beispiel könnte ich $abcbac$ schreiben und dann die Linien zeichnen als:

Oder ich schreibe $abbcac$

Sobald ich diese Linien gezeichnet habe, versuche ich, geschlossene Schleifen um Blöcke zu zeichnen, damit meine Schleife keine der Linien schneidet, die ich gerade gezeichnet habe. Zum Beispiel können wir im ersten die einzige Schleife um das ganze Ding zeichnen, aber im zweiten können wir eine Schleife nur um das $b$ s (oder alles andere) zeichnen.

Wenn wir ein wenig damit herumspielen, werden wir feststellen, dass einige Zeichenfolgen nur so gezeichnet werden können, dass geschlossene Schleifen alle oder keine Buchstaben enthalten (wie in unserem ersten Beispiel). Wir werden solche Zeichenfolgen als gut verknüpfte Zeichenfolgen bezeichnen.

Beachten Sie, dass einige Zeichenfolgen auf verschiedene Arten gezeichnet werden können. Zum Beispiel kann $bbbb$ auf beide der folgenden Arten gezeichnet werden (und ein drittes nicht enthalten):

oder

Wenn einer dieser Wege so gezeichnet werden kann, dass eine geschlossene Schleife einige der Zeichen enthält, ohne eine der Linien zu schneiden, ist die Zeichenfolge nicht richtig verknüpft. (so $bbbb$ ist nicht gut verknüpft)

Aufgabe

Ihre Aufgabe ist es, ein Programm zu schreiben, um Zeichenfolgen zu identifizieren, die gut verknüpft sind. Ihre Eingabe besteht aus einer Zeichenfolge, bei der jedes Zeichen gerade oft vorkommt, und Ihre Ausgabe sollte einen von zwei unterschiedlichen konsistenten Werten enthalten, einen, wenn die Zeichenfolgen gut verknüpft sind, und den anderen.

Darüber hinaus muss das Programm eine gut angebundenen String Bedeutung

• Jedes Zeichen erscheint in Ihrem Programm gerade oft.

• Es sollte den Wahrheitswert ausgeben, wenn es selbst übergeben wird.

Ihr Programm sollte in der Lage sein, die richtige Ausgabe für eine beliebige Zeichenfolge aus druckbaren ASCII-Zeichen oder für Ihr eigenes Programm zu erstellen. Mit jedem Zeichen erscheint eine gerade Anzahl von Malen.

Antworten werden nach ihrer Länge in Bytes bewertet, wobei weniger Bytes eine bessere Bewertung darstellen.

Hinweis

Eine Zeichenfolge ist nicht gut verknüpft, wenn eine zusammenhängende, nicht leere, strikte Teilzeichenfolge vorhanden ist, sodass jedes Zeichen in dieser Teilzeichenfolge eine gerade Anzahl von Malen vorkommt.

Testfälle

abcbac -> True
abbcac -> False
bbbb -> False
abacbc -> True
abcbabcb -> True
abcbca -> False

Regex (ECMAScript 2018 oder .NET), 140 126 118 100 98 82 Byte

^(?!(^.*)(.+)(.*$)(?<!^\2|^\1(?=(|(<?(|(?!\8).)*(\8|\3$){1}){2})*$).*(.)+\3$)!?=*)

Dies ist viel langsamer als die 98-Byte-Version, da die ^\1vom Lookahead übrig bleibt und somit danach ausgewertet wird. Unten sehen Sie einen einfachen Umschalter, der die Geschwindigkeit wieder herstellt. Aus diesem Grund können die beiden unten aufgeführten TIOs nur einen kleineren Testfall als zuvor ausführen, und der .NET-Test ist zu langsam, um seinen eigenen regulären Ausdruck zu überprüfen.

Probieren Sie es online! (ECMAScript 2018)
Probieren Sie es online! (.NETZ)

Um 18 Bytes (118 → 100) zu löschen , habe ich schamlos eine wirklich nette Optimierung aus Neils Regex gestohlen , die die Notwendigkeit vermeidet, einen Lookahead in den negativen Lookbehind zu setzen (was einen uneingeschränkten Regex von 80 Bytes ergibt). Danke, Neil!

Das wurde obsolet, als es dank der Ideen von jaytea unglaubliche 16 weitere Bytes verlor (98 → 82), was zu einem uneingeschränkten Regex von 69 Bytes führte! Es ist viel langsamer, aber das ist Golf!

Beachten Sie, dass die (|(No-Ops für eine gute Verknüpfung des regulären Ausdrucks dazu führen, dass der Ausdruck unter .NET sehr langsam ausgewertet wird. Sie haben diesen Effekt in ECMAScript nicht, da optionale Übereinstimmungen mit der Breite Null als Nicht-Übereinstimmungen behandelt werden .

ECMAScript verbietet Quantifizierer für Behauptungen. Dies erschwert das Golfen bei eingeschränkten Quellenanforderungen . Zu diesem Zeitpunkt ist es jedoch so gut, dass ich nicht glaube, dass eine Aufhebung dieser besonderen Einschränkung weitere Golfmöglichkeiten eröffnen würde.

Ohne die zusätzlichen Zeichen, die erforderlich sind, um die Einschränkungen zu umgehen ( 101 bis 69 Byte):

^(?!(.*)(.+)(.*$)(?<!^\2|^\1(?=((((?!\8).)*(\8|\3$)){2})*$).*(.)+\3))

Es ist langsam, aber diese einfache Bearbeitung (für nur 2 zusätzliche Bytes) gewinnt die verlorene Geschwindigkeit wieder und mehr:

^(?!(.*)(.+)(.*$)(?<!^\2|(?=\1((((?!\8).)*(\8|\3$)){2})*$)^\1.*(.)+\3))

^
(?!
    (.*)               # cycle through all starting points of substrings;
                       # \1 = part to exclude from the start
    (.+)               # cycle through all ending points of non-empty substrings;
                       # \2 = the substring
    (.*$)              # \3 = part to exclude from the end
    (?<!               # Assert that every character in the substring appears a total
                       # even number of times.
        ^\2            # Assert that our substring is not the whole string. We don't
                       # need a $ anchor because we were already at the end before
                       # entering this lookbehind.
    |                  # Note that the following steps are evaluated right to left,
                       # so please read them from bottom to top.
        ^\1            # Do not look further left than the start of our substring.
        (?=
            # Assert that the number of times the character \8 appears in our
            # substring is odd.
            (
                (
                    ((?!\8).)*
                    (\8|\3$) # This is the best part. Until the very last iteration
                             # of the loop outside the {2} loop, this alternation
                             # can only match \8, and once it reaches the end of the
                             # substring, it can match \3$ only once. This guarantees
                             # that it will match \8 an odd number of times, in matched
                             # pairs until finding one more at the end of the substring,
                             # which is paired with the \3$ instead of another \8.
                ){2}
            )*$
        )
        .*(.)+         # \8 = cycle through all characters in this substring
        # Assert (within this context) that at least one character appears an odd
        # number of times within our substring. (Outside this negative lookbehind,
        # that is equivalent to asserting that no character appears an odd number
        # of times in our substring.)
        \3             # Skip to our substring (do not look further right than its end)
    )
)

Ich schrieb es Vorgriff - Molekular (unter Verwendung von 103 69 Bytes) , bevor es an variabler Länge Lookbehind Umwandlung:

^(?!.*(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$))

^
(?!
    .*(?*(.+)(.*$))       # cycle through all non-empty substrings;
                          # \1 = the current substring;
                          # \2 = the part to exclude from the end
    (?!                   # Assert that no character in the substring appears a
                          # total even number of times.
        ^\1$              # Assert that our substring is not the whole string
                          # (i.e. it's a strict substring)
    |
        (?*(.)+.*\2$)    # \3 = Cycle through all characters that appear in this
                          # substring.
        # Assert (within this context) that this character appears an odd number
        # of times within our substring.
        (
            (
                ((?!\3).)*
                (\3|\2$)
            ){2}
        )*$
    )
)

Und um meine Regex selbst besser zu verknüpfen, habe ich eine Variante der oben genannten Regex verwendet:

(?*(.+)(.*$))(?!^\1$|(?*(.)+.*\2$)((((?!\3).)*(\3|\2$)){2})*$)\1

In der Verwendung mit regex -xml,rs -ogibt dies eine strenge Teilzeichenfolge der Eingabe an, die eine gerade Zahl für jedes Zeichen enthält (sofern vorhanden). Sicher, ich hätte ein Nicht-Regex-Programm schreiben können, um dies für mich zu tun, aber wo wäre der Spaß dabei?

Gelee, 20 Bytes

ĠẈḂẸẆṖÇ€Ạ
ĠẈḂẸ
ẆṖÇ€Ạ

Probieren Sie es online!

Die erste Zeile wird ignoriert. Es ist nur da, um die Bedingung zu erfüllen, dass jedes Zeichen eine gerade Anzahl von Malen erscheint.

In der nächsten Zeile Ġwerden die Indizes zuerst nach ihrem Wert gruppiert. Wenn wir dann die Länge jeder Unterliste in der resultierenden Liste ( Ẉ) nehmen, erhalten wir die Häufigkeit, mit der jedes Zeichen erscheint. Um zu überprüfen, ob einer dieser Werte ungerade ist , erhalten wir den letzten Wert Ḃjeder Zählung und fragen, ob dort Ẹein wahrer Wert (ungleich Null) vorhanden ist.

Daher gibt diese Hilfsverknüpfung zurück, ob ein Teilstring nicht eingekreist werden kann.

Im Hauptlink nehmen wir alle Teilzeichenfolgen von input ( Ẇ) und Ṗop vom letzten (damit wir nicht prüfen, ob die gesamte Zeichenfolge eingekreist werden kann) und führen den Hilfslink ( Ç) auf einer €Teilzeichenfolge aus. Das Ergebnis ist dann, ob alle ẠTeilzeichenfolgen nicht eingekreist werden können.

J , 34 Bytes

2:@':.,|~*'>1(#.,)*/@(1>2|#/.~)\.\

Probieren Sie es online!

-8 Bytes dank FrownyFrog

Original

J , 42 Bytes

(*#'.,012&|@~#')=1#.[:,([:*/0=2&|@#/.~)\.\

Probieren Sie es online!

Erläuterung

(*#'.,012&|@~#') = 1 #. [: , ([: */ 0 = 2&|@#/.~)\.\

(*#'.,012&|@~#')                                       NB. this evaluates to 1
                                                       NB. while supplying extra
                                                       NB. chars we need.  hence...
                 =                                     NB. does 1 equal...
                   1 #.                                NB. the sum of...
                        [: ,                           NB. the flatten of...
                             (                  )\.\   NB. the verb in parens applied
                                                       NB. to every suffix of every
                                                       NB. prefix, ie, all contiguous 
                                                       NB. substrings
                             ([: */ 0 = 2&|@#/.~)      NB. def of verb in paren:
                                             /.~       NB. when we group by each
                                                       NB. distinct char...
                              [: */                    NB. is it the case that
                                                       NB. every group...
                                           @#          NB. has a length...
                                    0 = 2&|            NB. divisible by 2...

Python 3.8 (Vorabversion) , 66 Byte

lambda l,b={id}:len({str(b:=b^{c})for(c)in l})<len(l)#,<^fmnost{}#

Probieren Sie es online!

Die Ära der Zuweisungsausdrücke steht vor der Tür. Mit dem in Python 3.8 enthaltenen PEP 572 wird Golfen niemals so sein wie zuvor. Sie können die frühen Entwickler - Vorschau 3.8.0a1 installieren hier .

Mithilfe von Zuweisungsausdrücken können Sie :=einer Variablen inline zuweisen, während Sie diesen Wert auswerten. Zum Beispiel (a:=2, a+1)gibt (2, 3). Dies kann natürlich verwendet werden, um Variablen zur Wiederverwendung zu speichern, aber hier gehen wir einen Schritt weiter und verwenden sie als Akkumulator in einem Verständnis.

Dieser Code berechnet beispielsweise die kumulativen Summen [1, 3, 6]

t=0
l=[1,2,3]
print([t:=t+x for x in l])

Beachten Sie, wie bei jedem Durchlauf durch das Listenverständnis die kumulative Summe tum erhöht xund der neue Wert in der vom Verständnis erstellten Liste gespeichert wird.

In ähnlicher Weise wird b:=b^{c}der Zeichensatz aktualisiert, bum umzuschalten, ob er Zeichen enthält c, und es wird der neue Wert von ausgewertet b. Der Code [b:=b^{c}for c in l]iteriert also über die Zeichen cin lund akkumuliert den Zeichensatz, der ungerade oft in jedem nicht leeren Präfix angezeigt wird.

Diese Liste wird auf Duplikate überprüft, indem stattdessen ein Set-Verständnis erstellt wird und überprüft wird, ob die Länge kleiner als die von ist s, was bedeutet, dass einige Wiederholungen reduziert wurden. Wenn dies der Fall ist, bedeutet die Wiederholung, dass in dem szwischen diesen Zeitpunkten gesehenen Teil jedes Zeichen auf eine gerade Anzahl von Zahlen gestoßen ist, wodurch die Zeichenfolge nicht gut verknüpft ist. In Python ist es nicht zulässig, dass Mengen von Mengen nicht komprimierbar sind. Daher werden die inneren Mengen stattdessen in Zeichenfolgen konvertiert.

Die Menge bwird als optionales Argument initialisiert und im Funktionsumfang erfolgreich geändert. Ich befürchtete, dass die Funktion dadurch nicht wiederverwendbar wird, aber sie scheint zwischen den Läufen zurückgesetzt zu werden.

Für die Quellenbeschränkung werden ungepaarte Zeichen am Ende in einen Kommentar eingefügt. Schreiben for(c)in leher als for c in ldie zusätzlichen Pars kostenlos storniert. Wir legen idden Anfangssatz an b, der harmlos ist, da er als jeder Satz beginnen kann, aber der leere Satz kann nicht geschrieben werden, {}da Python ein leeres Wörterbuch erstellt. Da die Buchstaben iund dzu denen gehören, die gepaart werden müssen, können wir die Funktion iddort platzieren.

Beachten Sie, dass der Code negierte Boolesche Werte ausgibt, sodass er sich selbst korrekt angibt False.

Python 2 , 74 Bytes

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)

Probieren Sie es online!

Durchläuft die Zeichenfolge und verfolgt dabei Pden Zeichensatz, der bisher ungerade oft gesehen wurde. In der Liste dwerden alle früheren Werte von gespeichert P, und wenn die aktuelle Pbereits angezeigt wird d, bedeutet dies, dass in den Zeichen, die seit dieser Zeit angezeigt wurden, jedes Zeichen eine gerade Anzahl von Malen aufgetreten ist. Wenn ja, prüfen Sie, ob wir die gesamte Eingabe durchlaufen haben: Wenn ja, akzeptieren Sie, weil die gesamte Zeichenfolge wie erwartet gepaart ist, und lehnen Sie sie ansonsten ab.

Nun zur Quellenbeschränkung. Charaktere, die gepaart werden müssen, werden an verschiedenen harmlosen Stellen abgelegt, die nachfolgend unterstrichen sind:

bmn0=f=lambda s,P={0},d=[]:s<" "if(P in d)else+f(s[f<s:],P^{s[0^0]},[P]+d)
_____              _              _      _    _    ___        ___    

Der f<sWert wird 0beim Pairing eines ausgewertet f, wobei der Funktionsname auch fso genutzt wird, dass er definiert ist (zum Zeitpunkt des Funktionsaufrufs). Der 0^0Wert absorbiert ein ^Symbol.

Die 0in P={0}ist bedauerlich: in Python {}auswertet auf eine leere dict statt einer leeren Menge , wie wir wollen, und hier können wir in jedem Nicht-Zeichenelement setzen und es wird harmlos sein. Ich sehe jedoch nichts, was ich noch hinzufügen könnte, und habe a eingefügt 0und dupliziert bmn0, was 2 Bytes kostet. Beachten Sie, dass anfängliche Argumente ausgewertet werden, wenn die Funktion definiert wird. Daher können hier keine Variablen eingegeben werden, die wir selbst definieren.

Perl 6 , 76 Bytes

*.comb[^*X+(^*).map(^*)].grep({$_&[&]($_)}).none.Bag{*}.none%2#*^+XBob2rec%#

Probieren Sie es online!

Ein beliebiges Lambda, das eine None-Junction von None-Junctions zurückgibt, die auf einen Wahrheits- / Falsey-Wert verfälscht werden kann. Ich würde empfehlen, nicht das zu entfernen ?, was das Rückgabeergebnis beeinträchtigt, da sonst die Ausgabe ziemlich groß wird .

Diese Lösung ist ein wenig komplizierter als nötig, aufgrund mehrerer beteiligten Funktionen nicht verknüpft werden, zum Beispiel .., all, >>, %%usw. Ohne die Quelle Einschränkung, diese 43 Bytes sein könnte:

*.comb[^*X.. ^*].grep(?*).one.Bag{*}.all%%2

Probieren Sie es online!

Erläuterung:

*.comb                     # Split the string to a list of characters
      [^*X+(^*).map(^*)]   # Get all substrings, alongside some garbage
                        .grep({$_&[&]($_)})        # Filter out the garbage (empty lists, lists with Nil values)
                                           .none                 # Are none of
                                                .Bag{*}          # The count of characters in each substring
                                                       .none%2   # All not divisible by 2

                                               #*^+XBob2rec%#    And garbage to even out character counts

Perl 5 -p, 94, 86, 78 Bytes

m-.+(?{$Q|=@q&grp,$\|=$&eq$_^!grep+/^/&(@m=$g=~/\Q$_/g),($g=$&)=~/./g})(?!)-}{

Ausgang 0, wenn gut verknüpft, sonst 1.

78 Bytes

86 Bytes

94 Bytes

Wie es funktioniert

• -pmit }{Endtrick zur Ausgabe $\am Ende
• m-.+(?{.. })(?!)-, um Code über alle nicht leeren Teilzeichenfolgen auszuführen ( .+entspricht zuerst der gesamten Zeichenfolge und nach der Ausführung von Code zwischen (?{.. })Rückverfolgungen wegen fehlgeschlagener erzwungener(?!)
• $Q|=@q&grp, Müll wegen Quellenbeschränkung
• $\|=Ganzzahl bitweise oder Zuweisung, wenn es fast eine 1 gibt, $\ist 1 (wahr), standardmäßig ist sie leer (falsch)
• $&eq$_der Fall, in dem der sbustring die gesamte Zeichenfolge ist, wird bitweise ^mit "kein ungerades Zeichen Vorkommen" xored
• ($g=$&)=~/./gKopieren Sie die übereinstimmende Teilzeichenfolge in $g(da diese nach der nächsten Regex-Übereinstimmung überbewertet wird) und geben Sie das Zeichenfeld der Teilzeichenfolge zurück.
• /^/ Müll, der zu 1 ausgewertet wird
• grep1 &(@m=$g=~/\Q$_/g),für jedes Zeichen in der Teilzeichenfolge erhält das Array von Zeichen in $gÜbereinstimmung mit sich selbst, das Array in Skalar wird auf seine Größe ausgewertet, und grepdas Filtern der Zeichen mit ungerader Häufigkeit 1&xentsprichtx%2==1

Netzhaut , 150 bis 96 Bytes

^(?!(.*)(.+)(.*)$(?<!^\2|^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

Probieren Sie es online! Link enthält Testfälle, einschließlich sich selbst. Bearbeiten: Mit Hilfe von @Deadcode die ursprüngliche Regex ein wenig runtergolfen und dann etwas weniger aufwändig zurückgepolstert, um das Quell-Layout beizubehalten. Erläuterung:

^(?!(.*)(.+)(.*)$

Stellen Sie sicher, dass keine Teilzeichenfolge \3vorhanden ist, die den folgenden Einschränkungen entspricht.

(?<!^\2|

Stellen Sie sicher, dass es sich bei der Teilzeichenfolge nicht um die gesamte Originalzeichenfolge handelt.

^\1(?:(^?(?:(?!\6).)*\6){2})*(|(?!\6).)*(?!.+\6.*\3$)(.){1,}\3)(?!,<)?)

Stellen Sie sicher, dass es kein Zeichen gibt \6, das:

• Es wird nicht zwischen dem Zeichen selbst (exklusiv) und dem Ende der Teilzeichenfolge angezeigt
• es erscheint eine gerade Anzahl von Malen zwischen dem Start der Teilzeichenfolge und sich selbst (exklusiv)

Um die Einschränkung des Quelllayouts zu umgehen, habe ich ((((mit (?:(^?(?:(und ((mit ersetzt (|(. Ich hatte noch eine Quellenbeschränkung ))und die Zeichen !()1<{}übrig, also habe ich a +in geändert {1,}und das Unnützige eingefügt (?!,<)?, um den Rest zu konsumieren.

C # (Visual C # Interactive Compiler) , 208 206 200 198 Bytes

x=>!x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&!Enumerable.Repeat(x.Count,x.Count*x.Count).Where(
(l,i)=>i%l>0&!x.Skip(i/l).Take(i%l).GroupBy(c=>c).Any(g=>g.Count()%2>0)
).Any()/*>!oyAnC0EmeablR*WhiS/T*/

Probieren Sie es online!

-2 Bytes dank @KevinCruijssen!

Endlich unter 200, also könnte ich jetzt mit dem Golfen fertig sein :) Am Ende habe ich einen zweiten TIO erstellt, um die Dinge basierend auf einer vorherigen Antwort zu testen.

Probieren Sie es online!

Dinge, die diese Aufgabe schwierig machten:

• Gleichheitsoperator ==war nicht erlaubt
• Erhöhen / Zuweisen-Operator ++war nicht zulässig
• Linq - All()Funktion wurde nicht erlaubt

Kommentierter Code unten:

// anonymous function that takes an IList as input
x=>
  // the first condition makes sure the string even
  // counts of each character
  !x.GroupBy(c=>c).Any(g=>g.Count()%2>0)&
  // the second condition generates all proper substrings of x
  // and tests for any that contain even character counts
  // the string length `l` is repeated `l*l` times
  !Enumerable.Repeat(x.Count,x.Count*x.Count)
    .Where((l,i)=>
      // check that the substring length is greater than 0
      i%l>0&
      // use skip/take to generate a substring
      // and check for a character count thats odd
      // negate the result meaning we have found
      // a substring that invalidates the input
      !x.Skip(i/l).Take(i%l)
        .GroupBy(c=>c).Any(g=>g.Count()%2>0)
    )
    // if any invalid substrings are found
    // then the result in invalid
    // the comment string at the end is needed
    // to make the program well-linked
    .Any()/*>!oyAnC0EmeablR*WhiS/T*/

Python 2 , 108 Bytes

lambda d,e=enumerate:min(max(d[l:l+b].count(k)%2for(k)in d)for b,c in e(d[2:],2)for l,f in e(d) )#b =:x+.%2#

Probieren Sie es online!

-2 danke an Ørjan Johansen .

Brachylog , 16 Bytes

sᶠb∋p~j&sᶠb∋p~j&

Probieren Sie es online!

Druck false.für truthy Instanzen und true.für falsy Instanzen. Die TIO-Version ist zu langsam, um mit sich selbst fertig zu werden, aber sie ist klar verknüpft, da es sich um eine Zeichenfolge mit eindeutigen Zeichen handelt, die zweimal wiederholt wird.

Erläuterung

    Input is a string: "abcacbaa"
sᶠ  Find all substrings: ["abcacbaa","abcacba","abcacb",..,"a"]
b   Behead (now the proper substrings remain): ["abcacba","abcacb",..,"a"]
∋   Take one of them: "abcacb"
p   Permute it: "abcabc"
~j  It is some string repeated twice: "abc"
&   Get the input again: "abcacbaa"
    Then repeat the above.
    If the constraints can be satisfied, the result is true, otherwise false.

05AB1E , 22 20 Bytes

Œε¢Pà}KŒIKεSIS¢ÈP}àÈ

1Wird ausgegeben, wenn die Zeichenfolge gut verknüpft ist und 0wenn die Zeichenfolge nicht gut verknüpft ist.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

Das Basisprogramm ist ŒsKεsS¢ÈP}à( 11 Byte ), das ausgibt, 0wenn es gut und 1nicht gut verknüpft ist. Das Trailing È(is_even) ist ein Semi-No-Op, das die Ausgabe invertiert, also 1für gut verknüpfte Zeichenfolgen und 0für nicht gut verknüpfte Zeichenfolgen. Die anderen Teile sind No-Ops, um die Herausforderungsregeln einzuhalten.

Œε¢Pà}K         # No-ops: substrings, map, count, product, maximum, close map, remove
                # Due to the last remove, we're back at the (implicit) input again
Π              # Take the substrings of the input
 IK             # Remove the input itself from that list of substrings
   ε            # Map each substring to:
    S           #  No-op: transform the substring into a list of characters
     IS         #  Get the input-string as a list of characters
       ¢        #  Count the occurrence of each character in the current substring
        È       #  Check which counts are even (1 if truthy; 0 if falsey)
         P      #  Take the product of that
          }à    # After the map: check if any are truthy by taking the maximum
            È   # Semi no-op: check if this maximum is even (0 becomes 1; 1 becomes 0)
                # (and output the result implicitly)