Count Mills in Nine Men's Morris


21

introduzione

Morris di Nine Mens (chiamato anche Mills) è un gioco da tavolo per due giocatori che si gioca sul seguente tabellone (immagine tratta dalla pagina Wikipedia collegata):

Consiglio di mulino

Ogni giocatore ha 9 uomini, colorati in bianco e nero. Le regole concrete non sono importanti per questa sfida, ma dai un'occhiata alla pagina di Wikipedia se sei interessato.

La sfida

Data una griglia come input, che rappresenta una certa boardstate, uscita il conteggio totale mulino mcon 0<=m<=8.
Tre uomini dello stesso colore formano un mulino quando si trovano in una fila diritta di punti collegati. b2a f2non è un mulino poiché gli uomini sono di colore diverso. Anche d2per d5non formerebbe un mulino poiché i tre punti devono essere collegati.
La scheda nell'immagine sopra contiene due mulini, ad esempio. Uno da f2a f6e uno da e3a e5.

Ingresso

La scheda è rappresentata come una griglia 2D con 24 punti che sono collegati come mostrato nell'immagine di esempio sopra. L'esempio utilizza lettere di a-gper le colonne e numeri di 1-7per le righe, ma è possibile scegliere qualsiasi formato di input ragionevole purché associ 24 coordinate univoche a uno dei seguenti stati:

  • Vuoto
  • Preso dal nero
  • Preso dal bianco

Il riconoscimento concreto spetta a te non sei limitato a "b" o "w" per i colori.

Oltre a ciò, il tuo input potrebbe non contenere ulteriori informazioni.

Note aggiuntive

  • Non è necessario mappare i punti con nessun tipo di valore. Se vuoi prendere l'input come un array 2D, va bene lo stesso. Ma tieni presente che non tutti i punti presenti vengono utilizzati e che devi considerare le connessioni tra di loro.
  • L'ingresso potrebbe essere vuoto, nel qual caso è necessario produrre zero (scheda vuota -> nessun mulino).
  • Poiché ogni giocatore ha 9 uomini, l'input non conterrà mai più di 18 punti presi.
  • È possibile tralasciare punti vuoti nell'input e quindi solo punti di input presi.
  • L'ingresso può essere ordinato in qualsiasi modo. Non puoi fare affidamento su un ordine specifico.
  • Si può presumere che l'input sarà sempre valido. Ciò significa che non ci saranno più di 9 uomini di ogni colore e che ogni punto sarà unico.

Regole

  • Chiarisci quale formato di input usi nella tua soluzione. Fornire un esempio di esecuzione del programma è fortemente incoraggiato.
  • Funzione o programma completo consentiti.
  • Regole predefinite per input / output.
  • Si applicano scappatoie standard .
  • Questo è , quindi vince il conteggio dei byte più basso. Tiebreaker è una presentazione precedente.

Casi test

Il formato di input qui è un elenco di tuple con le coordinate come nell'esempio sopra come primo elemento e lo stato del secondo elemento punto. Un punto preso dal bianco è contrassegnato come "w" e un punto preso dal nero come "b". Tutti gli altri punti vengono esclusi e sono vuoti.

[( "A4", "w"), ( "B2", "b"), ( "b4", "b"), ( "C4", "b"), ( "d1", "w") , ( "D2", "w"), ( "E3", "w"), ( "E4", "w"), ( "e5", "w"), ( "F2", "b") , ("f4", "b"), ("f6", "b"), ("g4", "w")] -> 2
[( "A1", "b"), ( "a4", "b"), ( "A7", "b"), ( "b4", "b"), ( "c4", "b") , ("d3", "w"), ("d2", "w"), ("d1", "w")] -> 3
[] -> 0
[("b4", "b"), ("a4", b "), (" c4 ", w")] -> 0
[("b4", "b"), ("a4", b "), (" c4 ", b")] -> 1
[("a1", "b"), ("a4", "b"), ("a7", "b"), ("b2", "b"), ("b4", "b") , ("b6", "b"), ("c3", "b"), ("c4", "b"), ("c5", "b"), ("e3", "w") , ("e4", "w"), ("e5", "w"), ("f2", "w"), ("f4", "w"), ("f6", "w") , ("g1", "w"), ("g4", "w"), ("g7", "w")] -> 8

Buona programmazione!



Presumo che i colori debbano essere contigui e allineati, ma non è chiaro. Ad esempio d2, d3, d5 dello stesso colore formano un mulino?
Robert Benson,

@RobertBenson No, non perché d3e d5non sono collegati. Regole dicono: Three men of the same color form a mill when they are in a straight row of connected points.. Ho aggiunto alcuni esempi in questa sezione per chiarire, grazie per il commento!
Denker,

Risposte:


4

APL (Dyalog Classic) , 26 25 byte

-1 grazie a FrownyFrog

≢{|∊(+/⍵⍪↓⍵),⊢/4 2⍴+⌿⍵}∩≢

Provalo online!

L'argomento è un array 3x3x3 di 1(nero), ¯1(bianco) e 0(vuoto). La prima dimensione è lungo la profondità di annidamento dei quadrati concentrici. Le altre due dimensioni sono lungo l'asse verticale e orizzontale.

000---------001---------002
 |           |           |
 |  100-----101-----102  |
 |   |       |       |   |
 |   |  200-201-202  |   |
 |   |   |       |   |   |
010-110-210     212-112-012
 |   |   |       |   |   |
 |   |  220-221-222  |   |
 |   |       |       |   |
 |  120-----121-----122  |
 |           |           |
020---------021---------022

Abbiamo un mulino ogni volta che la somma lungo qualsiasi asse produce un 3o ¯3, tranne che dobbiamo scartare i quattro angoli quando sommiamo lungo il primo asse.

{} è una funzione con argomento implicito

↓⍵è diviso - nel nostro caso trasforma un cubo 3x3x3 in una matrice 3x3 di vettori nidificati di lunghezza-3

⍵⍪↓⍵ prende il cubo originale e incolla la matrice 3x3 di 3 vettori al di sotto di esso, quindi otteniamo una matrice mista 4x3x3 di scalari e vettori

+/somma lungo l'ultimo asse; questo ha l'effetto combinato di sommare il cubo originale lungo l'ultimo asse ( +/⍵) e di sommarlo lungo l'asse centrale a causa della divisione che abbiamo fatto ( +/↓⍵)

Ora dobbiamo occuparci del caso speciale per il primo asse.

+⌿⍵ somma lungo il primo asse, restituendo una matrice 3x3

4 2⍴ ma non dobbiamo contare gli angoli, quindi lo rimodelliamo in una matrice 4x2 come questa:

ABC      AB
DEF  ->  CD
GHI      EF
         GH  ("I" disappears)

ora siamo interessati solo all'ultima colonna ( BDFH), quindi usiamo il linguaggio⊢/

,si concatena BDFHalla matrice ottenuta in precedenza per il 2o e 3o asse ( BDFHe la matrice ha entrambe una dimensione iniziale di 4)

appiattisce tutto ciò che abbiamo ottenuto finora in un singolo vettore

| accetta i valori assoluti

{ }∩≢ filtra solo i tre: la lunghezza (≢) dell'ingresso è sempre 3

li conta


Heh, stavo per suggerirlo.
Adám,

Puoi unirti a chat.stackexchange.com/rooms/52405/apl per un momento?
Adám,

≢{|∊(+/⍵⍪↓⍵),⊢/4 2⍴+⌿⍵}∩≢è uno più corto :)
FrownyFrog,

@FrownyFrog grazie! a cura di
ngn

4

JavaScript (ES6), 276 228 125 117 105 byte

a=>btoa`i·yø!9%z)ª»-ºü1j;ÝÈ%¥·¡ªÜ"·ç¹Ê1`.replace(/.../g,b=>(a[b[0]]+a[b[1]]+a[b[2]])/3&1||'').length

(quanto sopra contiene alcuni caratteri ASCII non stampabili che non verranno visualizzati qui, quindi ecco una versione senza quella btoache può essere copiata ed eseguita)

a=>'abcdefghijklmnopqrstuvwxajvdksglpbehqtwimrfnucox'.replace(/.../g,b=>(a[b[0]]+a[b[1]]+a[b[2]])/3&1||'').length

Rompe una stringa di riferimento in terzine di lettere che si abbinano alle chiavi del gruppo di fresatura. L'input ha la forma di un oggetto, in cui i tasti sono le lettere a-x, a partire dall'angolo in basso a sinistra e termina in alto a destra, spostandosi prima da sinistra a destra. I valori sono 1per bianco, -1per nero e 0per bianco.

Esempio

{b:1,d:-1,e:1,f:-1,i:1,k:-1,l:-1,m:1,n:-1,r:1,u:-1} => 2
{j:1,d:-1,k:-1,l:-1,b:1,e:1,i:1,m:1,r:1,f:-1,n:-1,u:-1,o:1} => 2
{a:-1,j:-1,v:-1,k:-1,l:-1,h:1,e:1,b:1} => 3
{} => 0
{k:-1,j:-1,l:1} => 0
{k:-1,j:-1,l:1} => 1
{a:-1,j:-1,v:-1,d:-1,k:-1,s:-1,g:-1,l:-1,p:-1,i:1,m:1,r:1,f:1,n:1,u:1,c:1,o:1,x:1} => 8

Questi esempi sono presi dagli esempi di OP, convertiti nell'oggetto lettera-chiave e numero-valore. Il primo proviene dall'immagine di esempio, mentre gli altri provengono dal set di esempi.


1
Bel lavoro! È possibile comprimere la stringa grande con atob.
ETHproductions

@ETHproductions Grazie! Sembra che stia usando caratteri ascii non stampabili, quindi ne includerò uno anche senza btoa. Inoltre ho trovato alcuni altri miglioramenti che lo abbattono ancora di più.
Mwr247,

2

Mathematica, 217 131 byte

Anche se sono sicuro che questo non sia particolarmente competitivo, ecco una voce per te.

Count[Total/@{{a1,d1,g1},{b2,d2,f2},{c3,d3,e3},{a4,b4,c4},{e4,f4,g4},{c5,d5,e5},{b6,d6,f6},{a7,d7,g7},{a1,a4,a7},{b2,b4,b6},{c3,c4,c5},{d1,d2,d3},{d5,d6,d7},{e3,e4,e5},{f2,f4,f6},{g1,g4,g7}}/.#/.{"w"->1,"b"->2},3|6]&

Esempio di input:

{a4 -> "w", b2 -> "b", b4 -> "b", c4 -> "b", d1 -> "w", d2 -> "w", e3 -> "w", e4 -> "w", e5 -> "w", f2 -> "b", f4 -> "b", f6 -> "b", g4 -> "w"}

Consentire nomi di coordinate a carattere singolo insinua banalmente 51 caratteri, rendendola una soluzione da 166 byte. Chiamare i giocatori 1 e 2 anziché "w" e "b" gioca a golf su altri 17 personaggi.

Quindi otteniamo

Count[Total/@{a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,a,j,v,d,k,s,g,l,p,b,e,h,q,t,w,r,i,m,f,u,n,c,o,x}~Partition~3,3|6]/.#&

Se capisco correttamente le regole di formattazione dell'input, dovresti essere in grado di accettarle come 1e 2. l'esempio usato we b, ma sono abbastanza certo che non ci siamo limitati a questo.
Mwr247,

@ Mwr247 Hai ragione. È possibile utilizzare qualsiasi formato desiderato, purché non aggiunga ulteriori informazioni. Lo chiarirò quando sarò a casa.
Denker,

1

APL (Dyalog Unicode) , 50 byte

"La soluzione degli oggetti"

Sebbene più lungo (29 caratteri) della soluzione di @ ngn , utilizza un approccio completamente diverso: l'input ha la stessa struttura generale di quella soluzione, ma tutti gli slot sono rappresentati come oggetti. Gli slot vuoti (inclusa la colonna centrale inesistente) devono essere oggetti vuoti. mentre tutti gli uomini neri devono essere riferimenti all'oggetto "uomo nero" e tutti gli uomini bianchi devono essere riferimenti all'oggetto "uomo bianco". Tutti gli oggetti possono facoltativamente avere bel D ISPLAY F ORM s per migliorare la leggibilità, e così la colonna centrale può opzionalmente essere reso invisibile.

+/1=(≢¨(,∪/,∪⌿⍤2),(⊢/4 2⍴∪⌿))

Provalo online!

+/ la somma di

1=(... ) quelli dentro

≢¨(... ) il conteggio di

  , il rannicchiato (appiattito)

  ∪/ set unici in tutto

  , concatenato a

  ∪⌿⍤2 set unici

,(... ) concatenato a

  ⊢/ la colonna più a destra di

  4 2⍴ il, rimodellato in quattro file e due colonne,

  ∪⌿ insiemi colonnari unici

Un operatore in cima , come fornito con AGL ( ä), ridurrebbe la lunghezza a 27 caratteri .

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.