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

$$\begin{align} &1:\pmatrix{\color{gray}0,\color{gray}0,\color{gray}0\\\color{gray}0,1,\color{gray}0\\\color{gray}0,\color{gray}0,\color{gray}0} &&2:\pmatrix{1,\color{gray}0,\color{gray}0\\\color{gray}0,\color{gray}0,\color{gray}0\\\color{gray}0,\color{gray}0,1}\text{or}\pmatrix{\color{gray}0,\color{gray}0,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,\color{gray}0,\color{gray}0}\\ &3:\pmatrix{1,\color{gray}0,\color{gray}0\\\color{gray}0,1,\color{gray}0\\\color{gray}0,\color{gray}0,1}\text{or}\pmatrix{\color{gray}0,\color{gray}0,1\\\color{gray}0,1,\color{gray}0\\1,\color{gray}0,\color{gray}0} &&4:\pmatrix{1,\color{gray}0,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,\color{gray}0,1}\\ &5:\pmatrix{1,\color{gray}0,1\\\color{gray}0,1,\color{gray}0\\1,\color{gray}0,1} &&6:\pmatrix{1,\color{gray}0,1\\1,\color{gray}0,1\\1,\color{gray}0,1}\text{or}\pmatrix{1,1,1\\\color{gray}0,\color{gray}0,\color{gray}0\\1,1,1} \end{align}$$

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 código de golf .

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

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.

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.

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.

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

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 

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!

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

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

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

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 .

Dyalog APL , 28 27 bytes

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

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 ( +/⍵).

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.

Jalea , 18 bytes

s3§§µṬṚḄ>55×S_15»0

Un enlace monádico

Pruébalo en línea!

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.

Ruby , 78 bytes

->a{s=->x{x.flatten.sum};t=4,5,6;q=a.each_slice(3).map(&s);(t&q==t)?s[a]-15:0}

Pruébalo en línea!