Problem:

Im Schach gibt es eine bekannte Regel, nach der durch Wiederholung gezogen wird. Wenn dieselbe Position 3 Mal (oder öfter) wiederholt wird, kann der Spieler, der beabsichtigt, den Zug auszuführen, der diese Wiederholung verursacht, ein Unentschieden fordern.

Manchmal ist dies eine leichte Aufgabe für einen Schiedsrichter, wenn die letzten Züge nur die Spieler sind, die sich vorwärts und rückwärts bewegen. Manchmal ist es weniger trivial, wenn sich Teile signifikant zwischen wiederholten Positionen bewegt haben.

Das Problem bei dieser Herausforderung besteht darin, einen Wahrheitswert auszugeben, wenn die beanspruchte Position durch Wiederholung gezogen wurde (wurde dreimal oder öfter gesehen), und einen Falschwert, wenn die beanspruchte Position nicht durch Wiederholung gezogen wurde, wenn eine Liste von Bewegungen in Koordinatenschreibweise gegeben ist wie unten beschrieben oder eine beliebige Notation Ihrer Wahl (aber Sie müssen die Testfälle konvertieren).

Was ist eine Position?

In einem realen Szenario würde die Position von Dingen beeinflusst, z. B. ob ein Spieler eine Burg errichten kann oder ob ein En-Passant möglich ist. Sie sollten diese in Ihrer Lösung des Problems nicht berücksichtigen. In diesem Problem wird eine Position einfach durch die Konfiguration der Teile auf der Tafel definiert. Für die Zwecke dieses Problems werden also zwei Positionen als gleich angesehen, wenn jedes Quadrat auf beiden Brettern von demselben Teil derselben Farbe besetzt ist. Dies muss nicht das exakte Stück sein, zum Beispiel könnten die weißen Ritter Quadrate tauschen und wenn alle anderen Stücke die Kriterien erfüllen, wäre dies immer noch die gleiche Position.

Wie sieht eine gültige Notation aus?

Obwohl ich weiter auf die Koordinaten-Notation eingehen werde, steht es Ihnen frei, Eingaben durch ein von Ihnen gewähltes Notationssystem vorzunehmen. Unter der Vorraussetzung, dass:

• Jedes Element in der Notation beschreibt eines oder alle der folgenden Elemente: die beteiligten Elemente; ob Scheck, Schachmatt, Doppelscheck, Schachmatt oder Patt geliefert wurden; wenn eine unbegleitete Gefangennahme stattgefunden hat; die Ausgangsposition; die endgültige Position.
• Möglicherweise enthält Ihre Notation keine Informationen zur Wiederholung.

Solange diese Kriterien erfüllt sind, akzeptiere ich gerne, solange Sie in Ihrer Antwort angeben, Ihr Notationssystem. Dies können zB 0 indizierte Zeilen-, Spaltentupel sein oder was auch immer für Ihr Programm sinnvoll ist.

Koordinatenschreibweise

Die Koordinatennotation ist eine Notation, die lediglich die Bewegungen als Koordinatensystem beschreibt.

Eine Bewegung wird als erste Koordinate aus dem Satz {A1-H8}und dann als Zielkoordinate erneut aus demselben Satz beschrieben. So würde das Königsgambit aussehen (als Sammlung von Streichern)

{"E2-E4","E7-E5","F2-F4"}

Ich glaube, es ist die beste Schreibweise für dieses Problem, da es nicht mit irrelevanten Informationen übersät ist, z. B. ob eine Prüfung stattgefunden hat oder welche Art von Stück sich bewegt. Wie bereits erwähnt, kann die Notation von Ihnen gewählt werden, Sie können also eine andere Notation verwenden, z. B. eine algebraische Notation, oder Sie können diese Notation anpassen (z. B. die Bindestriche entfernen oder als Liste von Tupeln verwenden).

Regeln:

• Sie sollten nicht berücksichtigen, ob eine Position oder Bewegung gültig ist, sondern nur, ob sie Wiederholungen verursacht
• Sie können davon ausgehen, dass keine Rochade- und Bauernförderung stattfindet.
• Sie sollten eine Liste von Zeichenfolgen als Eingabe und Ausgabe eines Wahrheits- oder False-Werts verwenden, der davon abhängt, ob die dritte (oder mehrere) Wiederholungen im letzten Zug stattgefunden haben
• Das Spiel beginnt immer an der Standardstartposition für Schach. Die Ausgangsposition kann zur Wiederholung angerechnet werden.
• Ein Draw durch Wiederholung ist nicht aufgetreten, wenn die Position durch den letzten Zug nicht wiederholt wird

Allgemeine Regeln:

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes.
  Lassen Sie sich von Code-Golf-Sprachen nicht davon abhalten, Antworten mit Nicht-Codegolf-Sprachen zu veröffentlichen. Versuchen Sie, für jede Programmiersprache eine möglichst kurze Antwort zu finden.
• Für Ihre Antwort gelten Standardregeln mit Standard-E / A-Regeln. Daher dürfen Sie STDIN / STDOUT, Funktionen / Methoden mit den richtigen Parametern und vollständige Programme vom Rückgabetyp, verwenden. Ihr Anruf.
• Standardlücken sind verboten.
• Fügen Sie nach Möglichkeit einen Link mit einem Test für Ihren Code hinzu (z. B. TIO ).
• Es wird außerdem dringend empfohlen, eine Erklärung für Ihre Antwort hinzuzufügen.

Testfälle

Sie sollten wahrheitsgemäße Werte zurückgeben für:

{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8"} 
{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8"}
{"B1-C3","B8-C6","D2-D4","D7-D5","D1-D3","D8-D6","C3-B1","C6-B8","B1-C3","B8-C6","D3-D1","D6-D8","D1-D3","D8-D6"}
{"D2-D4","B8-C6","E2-E4","C6-D4","D1-E2","D4-E6","E2-F3","E6-D4","F3-D1","D4-C6","D1-E2","C6-D4","E1-D1","D4-C6","D1-E1","C6-D4"}
{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","B1-C3"}

Und falsche Werte für:

{}
{"E2-E4","E7-E5","F2-F4"}
{"B1-C3","B8-C6","C3-B1","C6-B8","B1-C3","B8-C6","C3-B1","C6-B8","F2-F4","F7-F5"}
{"E2-E4","E7-E5","G1-F3","B8-C6","F1-C4","G8-F6","F3-G5","D7-D5","E4-D5","F6-D5","G5-F7"}
{"D2-D4","B8-C6","E2-E4","C6-D4","D1-E2","D4-C6","E2-D1","C6-D4","D1-E2","D4-C6","E2-D1"}
{"B1-C3","B8-C6","C3-B5","C6-B4","B5-D4","B4-D5","D4-C6","D5-C3","C6-B8","C3-B1","B8-C6","B1-C3","C6-B8","C3-B1"}
{"E2-E4","E7-E5","D1-E2","E8-E7","E1-D1","D8-E8","E2-E1","E7-D8","E1-E2","E8-E7","E2-E1","E7-E8"}

APL (Dyalog Extended) , 55 49 47 45 44 Byte ^SBCS

-4 danke an ngn.

Volles Programm. Prompts für die Reversed Liste der Reversed Koordinatenpaare:
 zB {"B1-C3","B8-C6"}ist[[[8,2],[6,3]],[[1,2],[3,3]]]

2≤≢s∩{0,∘⊃@⍺⊃s,←⊂⍵}/⎕,⊂(⊖⍪-)¯4↑⍉6,⍪5,∘⌽⍥⍳s←3

Probieren Sie es online! (Beinhaltet die Utility-Funktion, Coordsdie das OP-Format übersetzt)

Richten Sie eine Liste von Staaten ein:

s←3 zuweisen drei bis s(für s tates)

Da 3 kein gültiger Board-Status ist, hat dies keinen Einfluss auf unsere Wiederholungsanzahl und wir benötigen den Pass-Through-Wert der Zuweisung.

Erstellen Sie eine Schachbrett-Darstellung:

5… Verwerfen, um die folgende abgeleitete Funktion zwischen 5 und 3 anzuwenden:
 ⍥⍳ beide Argumente auf ihre Indexe erweitern;
  [1,2,3,4,5]… [1,2,3]
 ,∘⌽ Die linke Seite verkettet mit der Rückseite der rechten Seite
  [1,2,3,4,5,3,2,1]repräsentiert diese die Offiziere

⍪ zu Tisch machen;
 [[1],
  [2],
  [3],
  [4],
  [5],
  [3],
  [2],
  [1]]

6, stellen Sie (zu jeder Reihe) sechs voran, die Bauern darstellen;
 [[6,1],
  [6,2],
  [6,3],
  [6,4],
  [6,5],
  [6,3],
  [6,2],
  [6,1]]

⍉ transponieren;
 [[6,6,6,6,6,6,6,6],
  [1,2,3,4,5,3,2,1]]

¯4↑ nimm negative (dh die letzten) vier (Zeilen), die mit Nullen aufgefüllt sind und leere Quadrate darstellen;
 [[0,0,0,0,0,0,0,0],
  [0,0,0,0,0,0,0,0],
  [6,6,6,6,6,6,6,6],
  [1,2,3,4,5,3,2,1]]

(… ) Wenden darauf folgende implizite Funktion an:

 - negieren (dies stellt die entgegengesetzte Farbe dar);
  [[ 0, 0, 0, 0, 0, 0, 0, 0],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [-6,-6,-6,-6,-6,-6,-6,-6],
   [-1,-2,-3,-4,-5,-3,-2,-1]]

  ⊖⍪ stapeln Sie das umgedrehte Argument darüber und geben Sie uns die Vollpension;
  [[ 1, 2, 3, 4, 5, 3, 2, 1],
   [ 6, 6, 6, 6, 6, 6, 6, 6],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [ 0, 0, 0, 0, 0, 0, 0, 0],
   [-6,-6,-6,-6,-6,-6,-6,-6],
   [-1,-2,-3,-4,-5,-3,-2,-1]]

Erstelle eine Liste von Zügen, gefolgt vom Ausgangszustand:

⊂ füge das bei (um es als eine Einheit zu behandeln)

⎕, Fordern Sie die Liste der Züge an und stellen Sie diese vor den Ausgangszustand

Reduzieren Sie * um eine Funktion, die den aktuellen Status an die Liste anfügt und einen Zug ausführt:

{… }/ Reduzieren sich um folgendes anonymes Lambda:

 ⍵ das richtige argument (der aktuelle stand)

 ⊂ legen Sie es bei, um es als eine Einheit zu behandeln

 s,← In-Place Hängt es an die Liste der Bundesstaaten an

 ⊃ offenbaren Sie es, um diesen Zustand zu verwenden

 ... @⍺ an den Elementen mit den beiden Koordinaten, die das linke Argument darstellt, setzen Sie:
  0 eine Null,
  , gefolgt
  ∘ vom
  ⊃ ersten Wert,
^{verschiebt den Wert an der ersten Koordinate effektiv zur zweiten Koordinate und hinterlässt eine Null}

Überprüfen Sie, ob wir drei oder mehr Endzustände haben:

s∩ der Schnittpunkt aller Staaten mit diesem letzten; die Teilmenge der damit identischen Zustände

≢ zähle sie auf

2≤ prüfe, ob es zwei oder mehr gibt (dh drei oder mehr einschließlich des Endzustands)

* APL ist rechtsassoziativ, daher wird die Funktion zuerst mit dem Anfangszustand als rechtes Argument und dem Anfangszug als linkes Argument aufgerufen, und das Ergebnis, der neue Zustand, wird mit dem zweiten Zug als neues linkes Argument zum neuen rechten Argument usw. Das Endergebnis ist die

R , 180 177 144 Bytes

function(M,`+`=rep,l=c(1:5,3:1,6+8,0+16)){z=rev(Reduce(function(x,y){x[y[2:1]]=x[y]*1:0;x},M,c(l,-rev(l)),,T));sum(sapply(z,identical,el(z)))>2}

Probieren Sie es online!

-3 Bytes dank Giuseppe
-29 Bytes dank der Verwendung von Nick Kennedy Reduceund -rev(l)
-4 Bytes durch Umkehrungz

Nimmt als Eingabe einen Vektor von ganzen Zahlen zwischen 1 und 64, der die Quadrate bezeichnet. Das TIO enthält eine Funktion zur Umwandlung in dieses Format. Die verschiedenen Teile werden als ganze Zahlen zwischen 1 und 6 und zwischen -1 und -6 gespeichert.

Erläuterung:

function(M,                                # M is the vector of moves 
         `+` = rep,
         l = c(1:5, 3:1, 6 + 8, 0 + 16)) { # initial position of white pieces
  z = rev(Reduce(function(x, y) {
    x[y[2:1]] = x[y] * 1:0                 # a piece moves from y[1] to y[2]; y[1] becomes 0
    x
  }, M, c(l, -rev(l)), , T))
  sum(sapply(z, identical, el(z))) > 2    # find number of past positions identical to the last position
}

Jelly , 41 37 Bytes

Ø0;6x8;“Ġ²F’D¤UN;ƊW;µị@⁹Ṫ¤¦0⁹¦$\ċṪ$>1

Probieren Sie es online!

Ein monadischer Link, der die Eingabe als eine Liste von Paaren von 1-indizierten Zeilensprüngen verwendet [from, to]und eine 1 für Draws und eine 0 für Not zurückgibt.

Beachten Sie, dass der Fußzeilencode auf TIO die vom OP gelieferten Bewegungen in das numerische Format übersetzt, aber gemäß der Diskussion unter der Frage wäre das numerische Format eine gültige Eingabe gewesen.

Erläuterung

Ø0                                    | 0,0
  ;6                                  | concatenate to 6 (pawn)
    x8                                | repeat each 8 times (two blank rows and 1 row of pawns)
      ;“Ġ²F’D¤                        | concatenate to 1,2,3,4,5,3,2,1
              UN;Ɗ                    | concatenate a negated flipped version to this one
                  W;                  | wrap as a list and concatenate the input list to the board
                    µ                 | start a new monadic chain
                              $\      | reduce using the two links below
                     ị@⁹Ṫ¤¦           | replace the item pointed to by the second coordinate by the value of the one at the first
                           0⁹¦        | replace the item at first coordinate with zero
                                ċṪ$   | finally count the items equal to the final one (not including it)
                                   >1 | and check of >1

JavaScript (Node.js) ,  121  111 Byte

[sq0, sq1]$[0..63]$$\text{a8}=0$$\text{b8}=1$$\text{h1}=63$ .

Gibt einen Booleschen Wert zurück.

a=>[a,...a].map(([x,y])=>r=b[b[b[y]=b[x],x]=0,b]=-~b[b],b=[...'89ABCA981111111'+10n**32n+0x7e5196ee74377])&&r>2

Probieren Sie es online!

Wie?

Stücke

Die zur Identifizierung der Teile verwendeten Werte spielen keine Rolle, solange es einen eindeutigen Wert pro Teiletyp gibt.

Wir gebrauchen:

• 0 für leere Felder
• 1 / 8 / 9 / A / B / C für ♟ / ♜ / ♞ / ♝ / ♛ / ♚
• 2 / 3 / 4 / 5 / 6 / 7 für ♙ / ♖ / ♘ / ♗ / ♕ / ♔

Vorstand und Ausgangsposition

$b$

• '89ABCA981111111' → die 8 schwarzen Hauptfiguren, gefolgt von den ersten 7 schwarzen Bauern
• 10n**32n$\text{h7}$$1$$0$ )
• 0x7e5196ee74377→ alle weißen Stücke (bis 2222222234567543in Dezimalstellen)

was in ... endet:

    a b c d e f g h
  +----------------
8 | 8 9 A B C A 9 8
7 | 1 1 1 1 1 1 1 1
6 | 0 0 0 0 0 0 0 0
5 | 0 0 0 0 0 0 0 0
4 | 0 0 0 0 0 0 0 0
3 | 0 0 0 0 0 0 0 0
2 | 2 2 2 2 2 2 2 2
1 | 3 4 5 6 7 5 4 3

Verfolgen Sie die Positionen

$b$$b$

Deshalb machen wir:

b[b] = -~b[b]

Kommentiert

a =>                    // a[] = input
  [ a,                  // dummy entry to mark the initial position as encountered once
    ...a                // append the actual data
  ].map(([x, y]) =>     // for each pair of squares [x, y] in this array:
    r =                 //   store the last result in r
    b[                  //   update b[b]:
      b[                //     update b[x]:
        b[y] = b[x],    //       set b[y] to b[x]
        x               //       set b[x] ...
      ] = 0,            //     ... to 0
      b                 //     set b[b] ...
    ] = -~b[b],         //   ... to b[b] + 1 (or 1 if b[b] is undefined)
    b = [...(…)]        //   initialize b[] (see above)
  )                     // end of map()
  && r > 2              // return true if the last result is greater than 2

Java 10, 336 330 287 285 282 276 Bytes

m->{var V=new java.util.HashMap();int i=64,A[]=new int[i];var t="";for(;i-->0;)t+=A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1);V.put(t,1);for(var a:m){for(t="",A[a[1]]=A[a[0]],A[a[0]]=0,i=64;i-->0;)t+=A[i];V.compute(t,(k,v)->v!=null?(int)v+1:1);}return(int)V.get(t)>2;}

-11 Bytes dank @Arnauld durch den Wechsel i%56<8?"ABCDECBA".charAt(i%56%7):i%48<16?1:0zu i%56<8?i%8*35%41%10%8+2:9>>i/16&1.

Eingabe als 2D-Array von Ganzzahlen, bei denen $a1=0, b1=1, ..., h8=63$(dh {"E2-E4",...ist [[12,28],...).

Probieren Sie es online aus.

Erläuterung:

m->{                   // Method with 3D character array parameter and boolean return-type
  var V=new java.util.HashMap();
                       //  Create a Map to store the occurrences of the board-states
  int i=64,            //  Index integer, starting at 64
      A[]=new int[i];  //  Create the 8 by 8 board
  var t="";            //  Temp-String, starting empty
  for(;i-->0;)         //  Loop `i` in the range (64,0]:
    t+=                //    Append the string `t` with:
      A[i]=            //     Fill the `i`'th cell with:
        i%56<8?        //      If it's either the first or eighth row:
         i%8*35%41%10%8+2
                       //       Fill it with 2,7,3,5,9,3,7,2 based on index `i`
        :9>>i/16&1)    //      Else if it's either the second or seventh row:
                       //       Fill it with 1
                       //      Else (the third, fourth, fifth, or sixth rows):
                       //       Fill it with 0
        *(i/32*2-1);   //      Then multiply it by -1 or 1 depending on whether `i`
                       //      is below 32 or not
  V.put(t,1);          //  Then set string `t` in the map to 1 for the initial state
  for(var a:m){        //  Loop over each of the input's integer-pairs:
    for(t="",          //   Make the String empty again
        A[a[1]]=       //   Set the to-cell of the current integer-pair of the input to:
          A[a[0]],     //    The value in the from-cell of the same integer-pair
        A[a[0]]=0,     //   And then empty this from-cell
        i=65;i-->0;)   //   Inner loop `i` in the range (64,0]:
          t+=A[i];     //    Append the `i`'th value to the String `t`
    V.compute(t,(k,v)->v!=null?(int)v+1:1);}
                       //   Increase the value in the map for String `t` as key by 1
  return(int)V.get(t)  //  Return whether the value in the map for the last String `t`
          >2;}         //  is at least 3

Die Werte der Stücke nach dem Befüllen A[i]=(i%56<8?i%8*35%41%10%8+2:9>>i/16&1)*(i/32*2-1)sind:

     a  b  c  d  e  f  g  h
  +------------------------
1 | -2 -7 -3 -5 -9 -3 -7 -2
2 | -1 -1 -1 -1 -1 -1 -1 -1
3 |  0  0  0  0  0  0  0  0
4 |  0  0  0  0  0  0  0  0
5 |  0  0  0  0  0  0  0  0
6 |  0  0  0  0  0  0  0  0
7 |  1  1  1  1  1  1  1  1
8 |  2  7  3  5  9  3  7  2

Probieren Sie es online aus.

Holzkohle , 62 Bytes

≔↨²³⁴⁵⁶⁴³²χηＦ⁴⁸⊞η÷⁻⁴⁰ι³²Ｆ…η⁸⊞η±ιＦθ«⊞υ⮌η§≔η⊟ι§η§ι⁰§≔η⊟ι⁰»›№υ⮌η¹

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Nimmt Eingaben als ein Array von Zahlenpaaren an, bei denen die Quadrate nummeriert A1sind B1, ... H8(0-indiziert), sodass beispielsweise der erste Testfall als dargestellt wird, [[[1, 18], [57, 42], [18, 1], [42, 57], [1, 18], [57, 42], [18, 1], [42, 57]]]und gibt ein aus, -wenn die Position durch Wiederholung gezogen wird. Konvertierungsprogramm. Alles in einem. Erläuterung:

≔↨²³⁴⁵⁶⁴³²χη

Teilen Sie die Nummer 23456432in einzelne Ziffern auf. Diese repräsentieren die weißen Stücke.

Ｆ⁴⁸⊞η÷⁻⁴⁰ι³²

Fügen Sie die Bauern und die leeren Reihen hinzu. Die weißen Bauern haben Wert 1und die schwarzen Bauern -1.

Ｆ…η⁸⊞η±ι

Fügen Sie eine negierte Kopie der weißen Teile hinzu, die die schwarzen Teile darstellen.

Ｆθ«

Schleife über die Züge.

⊞υ⮌η

Speichern Sie eine Kopie des Boards. (Das Umkehren ist die golfenste Art, das Board zu kopieren.)

§≔η⊟ι§η§ι⁰

Aktualisieren Sie das Ziel mit dem Quelltext.

§≔η⊟ι⁰

Entfernen Sie das Quellstück.

»›№υ⮌η¹

Stellen Sie fest, ob die aktuelle Position mehrmals angezeigt wurde.

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

n=>{var j=new List<char[]>();var d=("ABCDECBATTTTTTTT"+new string('Z',32)+7777777712345321).ToArray();foreach(var(a,b)in n){j.Add(d.ToArray());d[b]=d[a];d[a]='Z';}return j.Count(r=>r.SequenceEqual(d))>1;}

Nimmt Eingaben als Liste von Tupeln von Ganzzahlen, wobei die erste Ganzzahl die Position ist, von der aus verschoben werden soll, und die zweite die Position, zu der verschoben werden soll. 0 stellt A1 dar, 1 ist A2 und 63 ist H8.

Probieren Sie es online!

n=>{
  var j=new List<char[]>();    //Initialize a list to save states of a board
  var d=("ABCDECBATTTTTTTT" +  //White pieces
  new string('Z',32) +         //Empty spaces
  7777777712345321)            //Black pieces
  .ToArray(); //Initialize the chessboard
  foreach(var(a,b)in n){       //Foreach (source square, destination square) in the input
    j.Add(d.ToArray());        //  Add the current board to the list
    d[b]=d[a];                 //  Set the destination square to the source square's value
    d[a]='Z';                  //  And set the souce square to empty
  }
  return j.Count(         //Return that the amount...
    r=>r.SequenceEqual(d) //  of past positions that are equal to the current position...
  )>1;                    //is at least two
}

Java (JDK) , 246 245 244 Bytes

import java.util.*;n->{var j=new ArrayList<char[]>();var d=("ABCDECBATTTTTTTT"+"".repeat(32)+7777777712345321l).toCharArray();for(var k:n){j.add(d.clone());d[k[1]]=d[k[0]];d[k[0]]=1;}return j.stream().filter(x->Arrays.equals(d,x)).count()>1;}

Probieren Sie es online!

import java.util.*;                   //Import the java.util package

n->{                                  //Function taking in int[][], 
                                      //where each int[] is a a pair of numbers
  var j = new ArrayList<char[]>();    //List to save each position of the chessboard
  var d =                             //The chessboard's starting position
    ("ABCDECBATTTTTTTT" +             //  All the white pieces
    "&#1".repeat(32) +                //  Plus the empty squares
    7777777712345321l)                //  And the black pieces
  .toCharArray();                     //Split to array of chars
  for(var k:n){                       //Foreach [sourceSquare, destinationSquare] in input
    j.add(d.clone());                 //  Add the current position to the list
    d[ k[1] ] = d[ k[0] ];            //  Set the destination square's value
                                      //  to the source squares
    d[ k[0] ] = 1;                    //  And clear the source square 
}                                     //End foreach
return j.stream()                     //Convert list of states to stream
  .filter(x ->                        //Filter each position by
    Arrays.equals(d,x)                //  if the position equals the final position 
  ).count() > 1;                      //And return if there are at least two
                                      //positions that are left
}