Inspirado e saqueado deste desafio de dados por Arnauld

Entrada

Você recebe uma matriz de dados 5x1 ou 1x5 (sua escolha), que consiste em sub-matrizes binárias 3x3.

Objetivo

Dada uma matriz de dados válida, você deve pontuá-la usando as regras de 6,5,4, que são as seguintes:

• Se o rolo contiver 6,5,4, adicione os outros dois dados e essa é sua pontuação. Por exemplo, 4, X, 5,6, Y = X + Y
• Caso contrário, a pontuação é 0. Por exemplo, 5,5,5,4,1 = 0

Artigo do Wiki para o jogo

Padrões 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}$$

Regras

• A matriz é garantida para conter apenas faces válidas, mas incluirá as permutações 2,3 e 6. Você também pode levá-lo em qualquer orientação da maneira que for conveniente. Por favor, indique a orientação escolhida na sua resposta.
• Saída da pontuação calculada
• As brechas padrão são proibidas
• Isso é código-golfe .

Exemplos

// 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*

Experimente online! ou Confira uma suíte de testes!

Usa o mesmo truque usado por Chas Brown e Lynn: decrementando cada número inteiro em cada sub-matriz 3x3 em vez de subtrair 15 no final. Espera entrada no formato de coluna.

Como 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.

Gelatina , 14 bytes

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

Experimente online!

Aceita uma coluna 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.

Assim como a resposta em Python de Chas Brown, isso compensa cada valor de dados em -3, para que não precisemos subtrair 15 (4 + 5 + 6) da última soma.

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)

Experimente online!

Espera-se que toda a entrada esteja no formato de coluna.

Perl 6 , 48 46 bytes

Agradecimentos a Ramillies por -2 bytes

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

Experimente online!

Um bloco de código anônimo que pega a matriz verticalmente e retorna um número inteiro.

Explicação:

{                                          } # 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

Experimente online!

Recebe a entrada na orientação horizontal como uma matriz 3x15. O truque de @Chas Brown em subtrair 3 antecipadamente (em vez de 15 depois) salvou vários bytes de maneiras diferentes.

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 

Braquilog , 23 22 bytes

+ᵐ-₁ᵐḍ₅+ᵐJo⊇~⟦₁3∧J+|∧0

• +3 bytes, mas imprime 0 em vez de falso, se não 4,5,6 (Fatalizar)
• - 2 4 bytes (sundar)

Um dos meus primeiros programas de branchylog. Provavelmente pode ser jogado mais. Imprime false se não houver 4,5,6. idk como fazê-lo sair 0.

Experimente online!

R , 56 bytes

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

Experimente online!

• -6 bytes graças a JayCe
• -1 byte graças a Giuseppe

Pitão , 20 bytes

*-ssQ15}j456TySsMc5s

Espera entrada como uma coluna de dados (como no caso de teste 1). Experimente online aqui ou verifique todos os casos de teste de uma vez aqui .

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

Pega as matrizes de dados uma abaixo da outra.

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Recebe entrada como uma coluna de dados.

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

Experimente online!

Quão?

Ao fazê-lo a + 0, aplainamos e coagimos implicitamente a matriz de entrada a uma string e adicionamos um final "0", que fornece exatamente 5x18 = 90 caracteres.

Por exemplo, o primeiro caso de teste leva 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 substring de dados s de 18 caracteres, calculamos o número n de pips + 1 e atualizamos o número total de pips t com:

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

Reutilizamos a matriz de entrada a como uma máscara de bits para acompanhar cada dado encontrado pelo menos uma vez:

a |= 1 << n

Se o rolo contém, pelo menos, um 4 , um 5 e um 6 , a máscara de bits um terão os seguintes bits definidos:

11100000 (224 in decimal)

Testamos isso fazendo a > 223. Se for bem sucedido, retornamos t . Como contamos um pip extra para cada dado e porque não queremos contar 4 + 5 + 6 no resultado, t é inicializado com - (5 + (4 + 5 + 6)) = -20 .

Dyalog APL , 28 27 bytes

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

Experimente online!

Toma uma matriz 1x5 de matrizes de dados 3x3 como entrada.

+/¨,¨soma os valores de pip de cada dado. Subtraia 3, use ∨/⍉⍵∘.=⍳3para verificar se há pelo menos uma instância de cada (1, 2, 3) E os resultados juntamente com ∧/e multiplique o resultado (0 ou 1) pela soma dos valores de dados ajustados ( +/⍵).

Retina 0.8.2 , 45 bytes

¶

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

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

1

Experimente online! Toma dados verticais. Explicação:

¶

M!`.{9}

Remodelar os dados em 5 linhas individuais.

%M`1

Obtenha os valores de cada linha.

O`

Classifique-os em ordem.

¶

Junte-os a uma única string.

G`4.*5.*6

Verifique se os três dados necessários estão presentes.

.
$*

Converta cada dado em unário.

1{15}

Subtraia os 4, 5 e 6 correspondentes.

1

Soma e converta para decimal.

Gelatina , 18 bytes

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

Um link monádico

Experimente online!

Oitava , 54 bytes

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

Experimente online!

Porta da minha resposta 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}

Experimente online!