Gegenseitig angreifende Königinnen

26

Ein 8x8-Schachbrett soll durch zwei verschiedene Werte dargestellt werden, wobei ein Wert ein leeres Quadrat und der andere eine Dame ist. In den folgenden Beispielen verwende ich 0en als leere Felder und 1en als Damen. Beispielsweise:

Königinnen auf einem Schachbrett

ist gegeben durch

1 0 1 1 1 0 0 0
1 0 1 0 1 0 1 1
1 0 1 0 1 1 0 1
0 1 0 1 0 1 0 0
0 1 1 0 0 1 0 1
1 0 0 0 1 0 0 0
0 1 0 0 0 1 1 1
0 1 1 1 0 1 0 1

Betrachten Sie die Anzahl der angreifenden Königinnenpaare, die mindestens ein Quadrat entfernt sind (zur Erinnerung: Königinnen greifen orthogonal und diagonal an). Im obigen Beispiel zeigt das folgende unglaubliche hässliche Diagramm alle diese Paare als Pfeile.

Angreifende Königinnen

Es wurden oben 43 Paare gefunden, die den folgenden Testfall ergeben:

Input:
1 0 1 1 1 0 0 0
1 0 1 0 1 0 1 1
1 0 1 0 1 1 0 1
0 1 0 1 0 1 0 0
0 1 1 0 0 1 0 1
1 0 0 0 1 0 0 0
0 1 0 0 0 1 1 1
0 1 1 1 0 1 0 1
Output: 43

Herausforderung

Schreiben Sie ein Programm, das bei einem Board-Status, der durch zwei unterschiedliche Werte dargestellt wird, die Anzahl der Königinnenpaare ausgibt, die sich gegenseitig mit mindestens einem Quadrat dazwischen angreifen.

  • Sie können in einem beliebigen Format eingeben, das am bequemsten ist und zwei Werte zur Darstellung der leeren Quadrate und Damen verwendet, z. B. eine Zeichenfolge von 64 "." S für leere Quadrate und "Q" s für Damen in Zeilen von unten nach oben (8x8) Matrix von Booleschen Werten, eine Liste mit ganzen Zahlen 0 und 1 usw., sofern dies in Ihrer Lösung erläutert wird
  • Die Ausgabe ist eine Ganzzahl
  • Es gelten Standard-E / A-Methoden und Standard-Regelungslücken sind verboten
  • Dies ist Codegolf, also gewinnt die kürzeste Antwort in Bytes

Testfälle:

Verwenden des 0- und 1-Formats, wobei 0 leere Felder und 1 Damen sind:

Input:
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
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
Output: 0

Input:
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
Output: 0

Input:
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 1 0 0 0 0 1 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 0
Output: 1

Input:
0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0
0 0 0 0 1 0 0 0
0 1 0 0 0 0 1 0
0 0 0 0 1 0 1 0
0 0 0 0 0 0 0 0
0 0 0 1 0 0 1 0
0 0 0 0 0 0 0 0
Output: 10

Input:
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
Output: 4

Input:
1 1 0 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 0 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1
Output: 11
code-golf  chess  binary-matrix 
— JMigst
quelle
Ich hätte fragen sollen, bevor ich meine 2. Version gepostet habe: Sind 254 für eine Dame und 0 für ein leeres Quadrat akzeptable Eingabewerte?
— Arnauld
@Arnauld Sie können in einem beliebigen Format eingeben , das für die Darstellung der leeren Quadrate und Damen zwei Werte verwendet. Also das ist sicher in
— Ordnung
Vielen Dank. Ich habe gefragt, weil ich denke, dass diese Regel ein bisschen zu nachgiebig sein könnte, wenn sie wörtlich genommen wird. Ich könnte darum bitten, einen String zu übergeben, der den größten Teil des JS-Codes für Königinnen enthält, und dies einfach im Programm auswerten. (Aber es kann durch eine Standardlücke verhindert werden. Ich bin nicht sicher.)
— Arnauld

Antworten:

14

Python 2 , 105 Bytes

lambda b:sum(b[i+d::d][:(8,7-i%8,i%8)[d%8%5]].find('1')*int(c)>0for i,c in enumerate(b)for d in[1,7,8,9])

Probieren Sie es online!

Erläuterung

Wir nehmen die Eingabe als Zeichenfolge von 64 Zeichen '0'oder '1'. Mit Hilfe von Stufenscheiben werfen wir von jeder Königin, der wir begegnen, vier "Sichtlinien". Wenn zum Beispiel i = 10 und d = 7 , wird die Dame als ♥ markiert und die Kacheln mit b[i+d::d]█ ausgewählt:

1 0 1 1 1 0 0 0
1 0 ♥ 0 1 0 1 1
1 █ 1 0 1 1 0 1
█ 1 0 1 0 1 0 █
0 1 1 0 0 1 █ 1
1 0 0 0 1 █ 0 0
0 1 0 0 █ 1 1 1
0 1 1 █ 0 1 0 1

Es ist klar, dass wir nicht wirklich wollen, dass sich die Vision so um das Board dreht. Also berechnen wir, wie weit der Rand des Brettes in jeder Richtung entfernt ist, und betrachten die Kacheln bei b[i+d::d][:…].

Für jedes Kachel-Richtungs-Paar zählen wir:

ray.find('1')*int(c)>0

Dies wird immer dann fehlschlagen, wenn

  • cist keine Königin; oder
  • Die Königin, die dieser Strahl sieht, ist zu nah ( findgibt 0 zurück). oder
  • Dieser Strahl sieht keine Königin ( findgibt −1 zurück).

Jedes Königinnenpaar wird nur einmal überprüft, da die Strahlen immer in Lesereihenfolge vorwärts geworfen werden, von einer "früheren" Königin zu einer "späteren".

— Lynn
quelle
10

JavaScript (ES7), 86 Byte

Nimmt Eingaben als ein Array von 64 Ganzzahlen mit 254 für eine Dame und 0 für ein leeres Quadrat.

a=>[s=0,6,7,8].map(d=>a.map(g=(n,p)=>(p%8-(p+=~d)%8)**2<n%4?a[p]?s+=n&1:g(n/2,p):0))|s

Probieren Sie es online!

Diese Version missbraucht den arithmetischen Unterlauf, um eine Stoppbedingung im rekursiven Teil zu erhalten.

JavaScript (ES7), 89 Byte

Nimmt Eingaben als ein Array von 64 Bit an.

a=>[s=0,6,7,8].map(d=>a.map(g=(n,p,x)=>(p%8-(p+=~d)%8)**2>1|p<0?0:a[p]?s+=!x&n:g(n,p)))|s

Probieren Sie es online!

Wie?

Wir rufen rekursiv eine benannte Rückruffunktion auf map(), um durch die Quadrate in einer bestimmten Richtung zu gehen. Obwohl wir den Inhalt des dritten Parameters des Rückrufs (das Array map()wurde aufgerufen) nicht wirklich benötigen , verwenden wir ihn indirekt, um zu wissen, ob es sich um die erste Iteration handelt oder nicht.

arr.map (Funktionsrückruf (currentValue [, index [, array]])

Dies ist die x- Variable im Code.

a =>                        // given the input array a[]
  [ s = 0,                  // initialize the sum s to 0
    6, 7, 8 ].map(d =>      // for each direction d in [0, 6, 7, 8]:
    a.map(g = (n, p, x) =>  //   for each square n at position p in a[]:
      (                     //     we are out of the board if:
        p % 8 -             //       - abs(p % 8 - p' % 8) is greater than 1
        (p += ~d) % 8       //         where p' = p - (d + 1)
      ) ** 2 > 1 |          //         (squaring is shorter than using Math.abs)
      p < 0 ?               //       - or p' is less than 0
        0                   //       if so, stop recursion
      :                     //     else:
        a[p] ?              //       if there's a queen on the target square:
          s +=              //         increment s if:
            !x &            //           x is undefined (this is not the 1st iteration)
            n               //           and n = 1 (there's a queen on the source square)
        :                   //       else:
          g(n, p)           //         do a recursive call to g(), with x undefined
    )                       //   end of inner map()
  ) | s                     // end of outer map(); return s
— Arnauld
quelle
8

Schnecken , 14 Bytes

A
rdaa7\1\0+\1

Probieren Sie es online!

Die Eingabe erfolgt im Format 0/1 ohne Leerzeichen innerhalb von Zeilen.

Snails wurde für eine 2D-Pattern-Matching-Language-Design-PPCG-Herausforderung erstellt . Am wichtigsten ist jedoch, dass standardmäßig die Anzahl der gefundenen Übereinstimmungen ausgegeben wird, was für diese Herausforderung perfekt ist.

A Legt die Option "Alle Pfade" fest, sodass jedes dieser Paare eine Übereinstimmung generiert, wenn sich eine Dame in mehreren Paaren befindet.

rdaa7Stellt die Übereinstimmungsrichtung auf S, SE, E und NE ein. Das Einstellen in alle Richtungen ( z) würde zu Doppelzählungen führen.

\1\0+\1entspricht a 1, dann einem oder mehreren 0s, dann einem anderen 1.

— TwiNight
quelle
6

APL (Dyalog Classic) , 41 39 32 Bytes

(+/+⌿-⌈⌿)2<⌿0⍪⊢,⍉,8 31⍴⊢,≠⍨,⌽,≠⍨

Probieren Sie es online!

≠⍨ ist "nicht gleich sich selbst" - eine 8x8 All-Null-Matrix

⊢,≠⍨,⌽,≠⍨- Wenn die ursprüngliche Matrix ist ABC..., gibt dieser Ausdruck Folgendes zurück:

A B C D E F G H 0 0 0 0 0 0 0 0 H G F E D C B A 0 0 0 0 0 0 0 0
I J K L M N O P 0 0 0 0 0 0 0 0 P O N M L K J I 0 0 0 0 0 0 0 0
Q R S T U V W X 0 0 0 0 0 0 0 0 X W V U T S R Q 0 0 0 0 0 0 0 0
Y Z A B C D E F 0 0 0 0 0 0 0 0 F E D C B A Z Y 0 0 0 0 0 0 0 0
G H I J K L M N 0 0 0 0 0 0 0 0 N M L K J I H G 0 0 0 0 0 0 0 0
O P Q R S T U V 0 0 0 0 0 0 0 0 V U T S R Q P O 0 0 0 0 0 0 0 0
W X Y Z A B C D 0 0 0 0 0 0 0 0 D C B A Z Y X W 0 0 0 0 0 0 0 0
E F G H I J K L 0 0 0 0 0 0 0 0 L K J I H G F E 0 0 0 0 0 0 0 0

8 31⍴ Formt es von 8x32 auf 8x31 um und verwendet die Elemente in der Reihenfolge der Zeilenmotive:

A B C D E F G H 0 0 0 0 0 0 0 0 H G F E D C B A 0 0 0 0 0 0 0
0 I J K L M N O P 0 0 0 0 0 0 0 0 P O N M L K J I 0 0 0 0 0 0
0 0 Q R S T U V W X 0 0 0 0 0 0 0 0 X W V U T S R Q 0 0 0 0 0
0 0 0 Y Z A B C D E F 0 0 0 0 0 0 0 0 F E D C B A Z Y 0 0 0 0
0 0 0 0 G H I J K L M N 0 0 0 0 0 0 0 0 N M L K J I H G 0 0 0
0 0 0 0 0 O P Q R S T U V 0 0 0 0 0 0 0 0 V U T S R Q P O 0 0
0 0 0 0 0 0 W X Y Z A B C D 0 0 0 0 0 0 0 0 D C B A Z Y X W 0
0 0 0 0 0 0 0 E F G H I J K L 0 0 0 0 0 0 0 0 L K J I H G F E

⊢,⍉, Stellt die ursprüngliche Matrix und ihre Transponierung voran (zusätzliche Leerzeichen für mehr Klarheit):

A B C D E F G H  A I Q Y G O W E  A B C D E F G H 0 0 0 0 0 0 0 0 H G F E D C B A 0 0 0 0 0 0 0
I J K L M N O P  B J R Z H P X F  0 I J K L M N O P 0 0 0 0 0 0 0 0 P O N M L K J I 0 0 0 0 0 0
Q R S T U V W X  C K S A I Q Y G  0 0 Q R S T U V W X 0 0 0 0 0 0 0 0 X W V U T S R Q 0 0 0 0 0
Y Z A B C D E F  D L T B J R Z H  0 0 0 Y Z A B C D E F 0 0 0 0 0 0 0 0 F E D C B A Z Y 0 0 0 0
G H I J K L M N  E M U C K S A I  0 0 0 0 G H I J K L M N 0 0 0 0 0 0 0 0 N M L K J I H G 0 0 0
O P Q R S T U V  F N V D L T B J  0 0 0 0 0 O P Q R S T U V 0 0 0 0 0 0 0 0 V U T S R Q P O 0 0
W X Y Z A B C D  G O W E M U C K  0 0 0 0 0 0 W X Y Z A B C D 0 0 0 0 0 0 0 0 D C B A Z Y X W 0
E F G H I J K L  H P X F N V D L  0 0 0 0 0 0 0 E F G H I J K L 0 0 0 0 0 0 0 0 L K J I H G F E

2<⌿0⍪Fügt 0s oben hinzu und vergleicht <jedes Element mit dem Element darunter, sodass wir in jeder vertikalen Gruppe von 1s eine 1 für die führende 1 erhalten und überall sonst 0s

+⌿-⌈⌿ Die Summen pro Spalte minus die Maxima pro Spalte - wir berechnen die Anzahl der Lücken zwischen den 1-Gruppen in jeder Spalte, 0, wenn es keine gibt

+/ Summe

— ngn
quelle
3

Retina 0.8.2 , 60 58 Bytes

1
¶1$';___¶
_
$n$%`7$*_
(.)(?=.*;(_)*)(?<-2>.)*
$1
m`^10+1

Probieren Sie es online! Nimmt die Eingabe als 8 durch Kommas getrennte 8-stellige Binärzeichenfolgen an, aber der Header konvertiert das bereitgestellte Format für Sie. Erläuterung:

1
¶1$';___¶

Erstellen Sie alle Teilzeichenfolgen des Boards, beginnend mit einer Dame. Fügen Sie jedem Teilstring einen Markierungswert hinzu. Bearbeiten: 2 Bytes wurden gespeichert, indem einige Müllstrings zurückgelassen wurden. diese werden effektiv ignoriert.

_
$n$%`7$*_

Teilen Sie jeden Marker in einen inklusiven Bereich auf und addieren Sie 7 zu den Nicht-Null-Elementen.

(.)(?=.*;(_)*)(?<-2>.)*
$1

Löschen Sie jede Zeichenfolge, die der Länge des Markers entspricht. Dies entspricht dem Finden jedes Ost-, Südwest-, Süd- oder Südoststrahls von jeder Königin.

m`^10+1

Zähle alle Strahlen, die durch mindestens ein leeres Feld gehen, bevor du eine andere Königin triffst.

— Neil
quelle
3

JavaScript (ES6) + SnakeEx , 38 Byte

s=>snakeEx.run('m:<*>10+1',s).length/2

Übernimmt Eingaben in das Formular '10111000\n10101011\n10101101\n01010100\n01100101\n10001000\n01000111\n01110101'. Es stellt sich heraus, dass SnakeEx auch außerhalb seiner ursprünglichen Herausforderung verwendet werden kann!

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