Puntuación 6,5,4 (también conocido como Barco, Capitán y Tripulación)

8

Inspirado y saqueado de este desafío de dados por Arnauld

Entrada

Se le da una matriz de dados de 5x1 o 1x5 (su elección) que consiste en submatrices binarias de 3x3.

Objetivo

Dada una matriz de dados válida, debe calificarla usando las reglas de 6,5,4 que son las siguientes:

  • Si la tirada contiene 6,5,4, suma los otros dos dados y ese es tu puntaje. Por ejemplo, 4, X, 5,6, Y = X + Y
  • De lo contrario, el puntaje es 0. Ej. 5,5,5,4,1 = 0

Artículo de wiki para el juego

Patrones de dados

1:(0,0,00,1,00,0,0)2:(1,0,00,0,00,0,1)or(0,0,10,0,01,0,0)3:(1,0,00,1,00,0,1)or(0,0,10,1,01,0,0)4:(1,0,10,0,01,0,1)5:(1,0,10,1,01,0,1)6:(1,0,11,0,11,0,1)or(1,1,10,0,01,1,1)

Reglas

  • Se garantiza que la matriz solo contendrá caras válidas, pero incluirá las permutaciones 2,3 y 6. También puede tomarlo en cualquier orientación de la manera que sea conveniente. Indique la orientación elegida en su respuesta.
  • Salida de la puntuación calculada
  • Las lagunas estándar están prohibidas
  • Este es el .

Ejemplos

// 2,5,2,4,6: Output should be: 4
[ [ 0,0,1 ],
  [ 0,0,0 ],
  [ 1,0,0 ], 
  [ 1,0,1 ],
  [ 0,1,0 ],
  [ 1,0,1 ], 
  [ 0,0,1 ],
  [ 0,0,0 ],
  [ 1,0,0 ], 
  [ 1,0,1 ],
  [ 0,0,0 ],
  [ 1,0,1 ], 
  [ 1,1,1 ],
  [ 0,0,0 ],
  [ 1,1,1 ] ]

// 1,6,2,4,6: Output should be: 0
[ [ 0,0,0, 1,0,1, 1,0,0, 1,0,1, 1,1,1  ],
  [ 0,1,0, 1,0,1, 0,0,0, 0,0,0, 0,0,0  ],
  [ 0,0,0, 1,0,1, 0,0,1, 1,0,1, 1,1,1  ] ]

// 5,6,6,4,6: Output should be: 12
[ [ 1,0,1, 1,0,1, 1,1,1, 1,0,1, 1,1,1  ],
  [ 0,1,0, 1,0,1, 0,0,0, 0,0,0, 0,0,0  ],
  [ 1,0,1, 1,0,1, 1,1,1, 1,0,1, 1,1,1  ] ]

// 3,3,4,5,6: Output should be: 6
[ [ 0,0,1, 1,0,0, 1,0,1, 1,0,1, 1,1,1  ],
  [ 0,1,0, 0,1,0, 0,0,0, 0,1,0, 0,0,0  ],
  [ 1,0,0, 0,0,1, 1,0,1, 1,0,1, 1,1,1  ] ]

// 2,5,2,5,6: Output should be: 0
[ [ 0,0,1, 1,0,1, 1,0,0, 1,0,1, 1,1,1  ],
  [ 0,0,0, 0,1,0, 0,0,0, 0,1,0, 0,0,0  ],
  [ 1,0,0, 1,0,1, 0,0,1, 1,0,1, 1,1,1  ] ]
Veskah
fuente
Caso de prueba sugerido: Uno donde el valor 5 está presente dos veces, como [2,5,2,5,6]. Mi solución actual funciona para los cuatro casos de prueba (al usar un método muy malo para ordenar los valores y eliminar la sublista [4,5,6]), que por supuesto falla cuando 5está presente dos veces.
Kevin Cruijssen
66
La idea central es buena, sin embargo, la forma en que se ha redactado me parece que cae dentro de una de nuestras categorías de cosas para evitar al escribir desafíos , a saber, "agregar pelusas innecesarias" . Analizar los dados no parece ser la parte principal del desafío, pero puede tomar la mitad del código.
Jonathan Allan
1
@ JonathanAllan Es un juego sobre dados, así que les di dados. Estoy de acuerdo en que hacer que validen caras sería esponjoso, por lo tanto, no es parte del desafío. Las matrices de dados también permiten soluciones interesantes porque solo anotar 654 con enteros no es muy difícil ni tan único.
Veskah el
1
@ JonathanAllan Lo tendré en cuenta para el futuro pero no cambiaré las especificaciones ahora.
Veskah
1
@Veskah sí, definitivamente no cambies las especificaciones ahora. Aquí hay muchos más desafíos divertidos :)
Jonathan Allan

Respuestas:

4

05AB1E , 15 bytes

3ôO<O©3LsK_P®O*

Pruébalo en línea! o echa un vistazo a una suite de prueba

Utiliza el mismo truco que usan Chas Brown y Lynn: disminuir cada número entero en cada submatriz 3x3 en lugar de restar 15 al final. Espera entrada en formato de columna.

Cómo funciona

3ôO<OD3LsK_PsO* – Full program.
3ô              – Split the input in 3x3 matrices representing dice faces.
  O<O           – Sum each, subtract one and sum each again.
                  This works because after the first O there are 3 elements in each
                  list and there are 5 lists in total, so 3 * 5 = 15 = 4 + 5 + 6.
     ©          – Copy this to the register.
      3LsK      – Push [1, 2, 3] and perform set subtraction. In this scenario, we
                  have already subtracted 3 from each list, so [1, 2, 3] represent
                  the actual dice values [4, 5, 6]. If the resulting list is empty,
                   that means that those values do exist in our roll. Therefore:
          _P    – Produce a list of zeros of that length and take the product
                  (4,5,6 isn't in the dice roll if the list is empty 
                  and this method assures that in this case the product is 1, else 0)
            ®O* – Sum what's in the register and multiply by that.
Sr. Xcoder
fuente
3

Jalea , 14 bytes

s3§’§µ3Rœ-⁸ṆaS

Pruébalo en línea!

Acepta una columna de dados.

                  With the input (a 15×3 binary matrix):
s3                 Split into threes: now we have 5 dice, each a 3×3 matrix.
  §                Sum-each. Now we have a list of triples.
   ’               Decrement: turn each triple [x,y,z] into [x−1,y−1,z−1].
    §              Sum-each. Now we have a list of dice pip sums minus 3.
     µ            With these sums X:
      3Rœ-⁸        Subtract them from {1, 2, 3} as a multiset.
           Ṇ       Is the result empty? (This means {1, 2, 3} ⊆ X.)
            aS     If so, yield sum(X). Else the result stays 0.

Al igual que la respuesta de Python de Chas Brown, esto compensa cada valor de dados en −3, por lo que no necesitamos restar 15 (4 + 5 + 6) de la última suma.

Lynn
fuente
3

Python 2 , 81 bytes

f=lambda a,r=[]:a and f(a[3:],r+[sum(sum(a[:3],[]))-3])or({1,2,3}<=set(r))*sum(r)

Pruébalo en línea!

Se espera que todas las entradas estén en forma de columna.

Chas Brown
fuente
3

Perl 6 , 48 46 bytes

Gracias a Ramillies por -2 bytes

{(^3+4⊂.flat.rotor(9)>>.sum)*(.flat.sum-15)}

Pruébalo en línea!

Un bloque de código anónimo que toma la matriz verticalmente y devuelve un entero.

Explicación:

{                                          } # Anonymous code block
                             (.flat.sum-15)  # Get the total sum of the array minus 15
                            * # Multiply by:
 (^3+4                    )    # Whether 4,5,6 is a sub-array of:
       .flat.rotor(9)>>.sum     # The value of each dice
Jo King
fuente
1
Creo que puede guardar 1 byte si toma una Lista de listas en lugar de un montón de Arrays y las usa en .flatlugar de .[*;*], de esta manera
Ramillies
3

MATL , 12 bytes

9es3-I:ymp*s

Pruébalo en línea!

Toma la entrada en orientación horizontal como una matriz de 3x15. El truco de @Chas Brown de restar 3 temprano (en lugar de 15 más tarde) guardó varios bytes de diferentes maneras.

9e      % reshape input to have 9 rows - each dice matrix is linearized into a column
s       % sum each column (to get dice values)
3-      % subtract 3 from each value, let's call this array A
I:      % form range 1 to 3
y       % bring a copy of array A to the top of stack
m       % check if each of 1, 2, 3 are members of A
        %  returns a logical array of 3 boolean values
p       % product of that result - 0 if any were not members, 1 if they all were
*       % multiply the original array A by this result 
s       % sum 
sundar - Restablece a Monica
fuente
3

Brachylog , 23 22 bytes

+ᵐ-₁ᵐḍ₅+ᵐJo⊇~⟦₁3∧J+|∧0
  • +3 bytes pero imprime 0 en lugar de falso si no 4,5,6 (Fatalize)
  • - 2 4 bytes (sundar)

Uno de mis primeros programas de branchylog. Probablemente se pueda jugar más al golf. Imprime falso si no hay 4,5,6. idk cómo hacer que salga 0.

Pruébalo en línea!

Kroppeb
fuente
1
No he leído el desafío, pero si quieres que tu programa 0salga de manera instantánea false, agregar |∧0al final debería hacer el trabajo.
Fatalize
1
Creo que puede ahorrar 2 bytes posponiendo ḍ₅: ¡ Pruébelo en línea!
sundar - Restablece a Mónica el
1
Se pueden guardar 2 bytes más utilizando el operador ~ y evitando la necesidad I: ¡ Pruébelo en línea! (Tenga en cuenta que también he agregado el |∧0aquí).
sundar - Restablece a Mónica el
3

R , 56 bytes

function(m)sum(x<-by(c(m),0:44%/%9,sum)-3)*all(1:3%in%x)

Pruébalo en línea!

  • -6 bytes gracias a JayCe
  • -1 byte gracias a Giuseppe
digEmAll
fuente
esto es asombroso! guardar 3 bytes
JayCe
También creo que puedes hacer c(m)para aplanar en mlugar dem[1:45]
JayCe
@ JayCe: por supuesto, muchas gracias!
digEmAll
56 bytes con asignación en línea
Giuseppe
2

Pyth , 20 bytes

*-ssQ15}j456TySsMc5s

Espera entrada como una columna de dados (como en el caso de prueba 1). Pruébelo en línea aquí , o verifique todos los casos de prueba a la vez aquí .

*-ssQ15}j456TySsMc5sQ   Implicit: Q=eval(input()), T=10
                        Trailing Q inferred
                   sQ   Flatten input into a single array
                 c5     Chop into 5 pieces
               sM       Take the sum of each piece
              S         Sort
             y          Take the power set
       }                Does the above contain...
        j456T           ... [4,5,6]? 1 if so, 0 otherwise <a>
  ssQ                   Deep sum of input (total pips)
 -   15                 Subtract 15 <b>
*                       Multiply <a> and <b>, implicit print
Sok
fuente
2

05AB1E , 30 29 22 bytes

3ôOOJ456vyõ.;}Dg<iSOë0

Toma las matrices de dados una debajo de la otra.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

3ô              # Split into sub-lists of 3, so we now have our dices
                #  i.e. [[A],[B],[C],[D],[E],[F],...] → [[[A],[B],[C]],[[D],[E],[F]],...]
  OO            # Sum each row, and then sum the total
                #  i.e. [[0,0,1],[0,0,0],[1,0,0]] → [1,0,1] → 2
    J           # Join everything together to a single string
                #  [5,4,2,5,6] → '54256'
     456v    }  # For each `y` in [4,5,6]:
         yõ.;   #  Replace the first occurrence with an empty string
                #  i.e. '54256' → '52'
D               # Duplicate the result
 g              # Take the length
                #  i.e. '52' → 2
  <i            # If the length is exactly 2 (and thus we've successfully removed [4,5,6]):
    SO          #  Split the string into digits again, and sum them as result
  ë             # Else:
    0           #  The result is 0 instead
Kevin Cruijssen
fuente
2

JavaScript (ES6), 78 bytes

Toma entrada como una columna de dados.

a=>!(a+0).replace(/.{18}/g,s=>(t+=n=s.split`1`.length,a|=1<<n),t=-20)|a>223&&t

Pruébalo en línea!

¿Cómo?

Al hacerlo a + 0, implícitamente aplanamos y coaccionamos la matriz de entrada a una cadena y agregamos un final "0", que da exactamente 5x18 = 90 caracteres.

Por ejemplo, el primer caso de prueba conduce a:

0,0,1,0,0,0,1,0,0,1,0,1,0,1,0,1,0,1,0,0,1,0,0,0,1,0,0,1,0,1,0,0,0,1,0,1,1,1,1,0,0,0,1,1,10
\____dice #1____/ \____dice #2____/ \____dice #3____/ \____dice #4____/ \____dice #5____/

Para cada subcadena de dados s de 18 caracteres, calculamos el número n de pips + 1 y actualizamos el número total de pips t con:

t += n = s.split`1`.length

Reutilizamos la matriz de entrada a como una máscara de bits para realizar un seguimiento de cada dado que se encontró al menos una vez:

a |= 1 << n

Si el rollo contiene al menos un 4 , un 5 y un 6 , la máscara de bits a tendrá los siguientes bits establecidos:

11100000 (224 in decimal)

Probamos esto haciendo a > 223. Si tiene éxito, devolvemos t . Debido a que contamos un pip extra para cada dado y porque no queremos contar 4 + 5 + 6 en el resultado, t se inicializa a - (5 + (4 + 5 + 6)) = -20 .

Arnauld
fuente
2

Dyalog APL , 28 27 bytes

{+/⍵×∧/∨/⍉⍵∘.=⍳33+(+/¨,¨)

Pruébalo en línea!

Toma una matriz 1x5 de matrices de dados 3x3 como entrada.

+/¨,¨suma los valores de pip de cada uno de los dados. Luego reste 3, use ∨/⍉⍵∘.=⍳3para verificar si hay al menos una instancia de (1, 2, 3), Y los resultados junto con ∧/y multiplique el resultado (0 o 1) por la suma de los valores de dados ajustados ( +/⍵).

ratonera
fuente
1

Retina 0.8.2 , 45 bytes

¶

M!`.{9}
%M`1
O`
¶

G`4.*5.*6
.
$*
1{15}

1

Pruébalo en línea! Toma dados verticales. Explicación:

¶

M!`.{9}

Cambie la forma de los dados en 5 filas individuales.

%M`1

Obtenga los valores de cada fila.

O`

Clasifícalos en orden.

Únete a ellos en una sola cuerda.

G`4.*5.*6

Asegúrese de que los tres dados requeridos estén presentes.

.
$*

Convierte cada dado en unario.

1{15}

Resta los 4, 5 y 6 correspondientes.

1

Suma y convierte a decimal.

Neil
fuente
1

Octava , 54 bytes

@(M)sum(prod(ismember(1:3,v=sum(reshape(M,9,5))-3))*v)

Pruébalo en línea!

Puerto de mi respuesta MATL.

sundar - Restablece a Monica
fuente