26

Lascia che una scacchiera 8x8 sia rappresentata da due valori distinti, con un valore che è un quadrato vuoto e l'altro che è una regina. Negli esempi seguenti, utilizzo 0 come quadrati vuoti e 1 come regine. Per esempio:

è dato da

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

Considera il numero di coppie di regine che stanno attaccando ognuna ad almeno un quadrato di distanza (come promemoria, le regine attaccano ortogonalmente e diagonalmente). Nell'esempio sopra, il seguente diagramma brutto incredibile mostra tutte queste coppie come frecce.

Ci sono 43 coppie trovate sopra dando il seguente caso di test:

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

Sfida

Scrivi un programma che, dato uno stato della scheda rappresentato da due valori distinti, genera il numero di coppie di regine che si attaccano a vicenda con almeno un quadrato tra loro.

È possibile immettere in qualsiasi formato sia più conveniente che utilizza due valori per rappresentare i quadrati e le regine vuoti, ad esempio una stringa di 64 "." S per i quadrati vuoti e "Q" per le regine da righe dal basso verso l'alto, un 8x8 matrice di booleani, un elenco di un elenco di numeri interi 0 e 1 ecc., purché sia spiegato nella soluzione
L'output è un numero intero
Si applicano i metodi I / O standard e sono vietate le scappatoie standard
Questo è il codice golf, quindi vince la risposta più breve in byte

Casi test:

Utilizzando il formato 0 e 1, con 0 vuoti quadrati e 1 regine:

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
fonte

Avrei dovuto chiedere prima di pubblicare la mia seconda versione: sono 254 per una regina e 0 per un quadrato vuoto valori di input accettabili?

— Arnauld,

@Arnauld Puoi inserire in qualunque formato sia più conveniente che usi due valori per rappresentare i quadrati e le regine vuoti. Quindi va bene di sicuro

— JMigst

Grazie. Ho chiesto perché penso che questa regola potrebbe essere un po 'troppo permissiva se presa alla lettera. Potrei chiedere di passare una stringa contenente la maggior parte del codice JS per le regine e valutarla nel programma. (Ma potrebbe essere impedito da una scappatoia predefinita. Non ne sono sicuro.)

— Arnauld

14

Python 2 , 105 byte

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

Provalo online!

Spiegazione

Prendiamo l'input come una stringa di 64 caratteri '0'o '1'. Usando gli step step, lanciamo quattro "linee di vista" da ogni regina che incontriamo. Ad esempio, quando i = 10 e d = 7 , contrassegnando la regina come ♥ e le tessere selezionate da b[i+d::d]come █:

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

Chiaramente, in realtà non vogliamo che la visione si avvolga attorno al tabellone in questo modo. Quindi calcoliamo quanto è distante il bordo del tabellone in ogni direzione e osserviamo le tessere b[i+d::d][:…].

Per ogni coppia direzione-piastrella contiamo:

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

Questo fallirà ogni volta

cnon è una regina; o
la regina che vede questo raggio è troppo vicina ( findrestituisce 0); o
questo raggio non vede una regina ( findrestituisce -1).

Ogni coppia di regine viene controllata una sola volta, poiché i raggi vengono sempre proiettati in avanti nell'ordine di lettura, da una regina "precedente" a una "successiva".

— Lynn
fonte

10

JavaScript (ES7), 86 byte

Prende l'input come un array di 64 numeri interi con 254 per una regina e 0 per un quadrato vuoto.

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

Provalo online!

Questa versione abusa del underflow aritmetico per ottenere una condizione di arresto nella parte ricorsiva.

JavaScript (ES7), 89 byte

Accetta l'input come una matrice di 64 bit.

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

Provalo online!

Come?

Chiamiamo in modo ricorsivo una funzione di richiamata denominata di map()camminare attraverso i quadrati in una determinata direzione. Anche se non abbiamo davvero bisogno del contenuto del terzo parametro del callback (l'array è map()stato chiamato), lo usiamo comunque indirettamente per sapere se è la prima iterazione o meno.

arr.map (funzione callback (currentValue [, index [, array]])

Questa è la variabile x nel codice.

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
fonte

8

Lumache , 14 byte

A
rdaa7\1\0+\1

Provalo online!

L'input è il formato 0/1, senza spazi all'interno delle linee.

Snails è stato creato per una sfida PPCG di progettazione linguistica che combina pattern 2D . Soprattutto, per impostazione predefinita genera il numero di corrispondenze trovate, il che è perfetto per questa sfida.

A imposta l'opzione "tutti i percorsi", in modo che se una regina è in più coppie, ciascuna di queste coppie genererebbe una corrispondenza.

rdaa7imposta la direzione della corrispondenza su S, SE, E e NE. L'impostazione su tutte le direzioni ( z) comporterebbe un doppio conteggio.

\1\0+\1corrisponde a 1, quindi a una o più 0s, quindi a un'altra 1.

— TwiNight
fonte

6

APL (Dyalog Classic) , 41 39 32 byte

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

Provalo online!

≠⍨ è "non uguale a se stesso" - una matrice 8x8 tutto zero

⊢,≠⍨,⌽,≠⍨- se la matrice originale è ABC..., questa espressione restituisce:

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⍴ lo rimodella da 8x32 a 8x31, riutilizzando gli elementi nell'ordine delle righe principali:

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

⊢,⍉, antepone la matrice originale e la sua trasposizione (spazi extra per maggiore chiarezza):

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⍪aggiunge 0 in alto e confronta usando <ogni elemento rispetto all'elemento sottostante, quindi otteniamo un 1 per il primo in ogni gruppo verticale di 1 e otteniamo 0 ovunque

+⌿-⌈⌿ le somme per colonna meno i massimi per colonna - calcoliamo il numero di spazi tra i gruppi 1 in ogni colonna, 0 se non ce ne sono

+/ somma

— NGN
fonte

5

Gelatina , 22 20 byte

t0ŒgL:2
Z,U;ŒD$€ẎÇ€S

Provalo online!

— user202729
fonte

Come funziona?

— Lirtosiast

@lirtosiast Non ricordo ...

— user202729

@lirtosiast Il primo collegamento conta il numero di coppie in 1D, il secondo collegamento prende la somma del primo collegamento su tutte le righe della tabella.

— user202729

3

Retina 0.8.2 , 60 58 byte

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

Provalo online! Accetta l'input come stringhe binarie di 8 caratteri separate da virgola 8, ma l'intestazione converte il formato fornito per te. Spiegazione:

1
¶1$';___¶

Crea tutte le sottostringhe del tabellone partendo da una regina. Suffissa un valore marcatore per ogni sottostringa. Modifica: salvato 2 byte lasciando dietro di sé alcune stringhe di immondizia; questi sono effettivamente ignorati.

_
$n$%`7$*_

Dividi ogni marker in un intervallo inclusivo e aggiungi 7 agli elementi diversi da zero.

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

Elimina ogni sequenza di caratteri uguale alla lunghezza del marcatore. Ciò equivale a trovare ogni raggio est, sud-ovest, sud o sud-est di ogni regina.

m`^10+1

Conta tutti i raggi che attraversano almeno un quadrato vuoto prima di incontrare un'altra regina.

— Neil
fonte

3

JavaScript (ES6) + SnakeEx , 38 byte

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

Accetta input nel modulo '10111000\n10101011\n10101101\n01010100\n01100101\n10001000\n01000111\n01110101'. Si scopre che SnakeEx può ancora essere usato al di fuori della sua sfida originale!

— LegionMammal978
fonte

2

K (ngn / k) , 45 byte

{+/0|-1++/0|-':x,'+x,+8 31#,/+x,a,(|x),a:0*x}

Provalo online!

— NGN
fonte

Regine che si attaccano a vicenda

Sfida

Casi test:

Python 2 , 105 byte

Spiegazione

JavaScript (ES7), 86 byte

JavaScript (ES7), 89 byte

Come?

Lumache , 14 byte

APL (Dyalog Classic) , 41 39 32 byte

Gelatina , 22 20 byte

Retina 0.8.2 , 60 58 byte

JavaScript (ES6) + SnakeEx , 38 byte

K (ngn / k) , 45 byte