Pontuação: 6,5,4 (AKA Ship, Captain, and Crew)

8

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

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

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

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  ] ]
Veskah
fonte
Caso de teste sugerido: Um em que o valor 5 esteja presente duas vezes, como [2,5,2,5,6]. Minha solução atual funciona para todos os quatro casos de teste (usando um método muito ruim de classificar os valores e remover a sub-lista [4,5,6]), que obviamente falha quando 5está presente duas vezes.
Kevin Cruijssen 08/08/19
6
A idéia central é boa, no entanto, a maneira como ela foi redigida me parece pertencer a uma de nossas categorias de itens a serem evitados ao escrever desafios , a saber: "adicionar cotão desnecessário" . Analisar os dados não parece ser a parte principal do desafio, mas pode levar metade do código.
Jonathan Allan
1
@ JonathanAllan É um jogo sobre dados, então eu dei a eles. Concordo que fazê-los validar rostos seria fofo, portanto, não faz parte do desafio. Matrizes de dados também permitem soluções interessantes, porque apenas marcar 654 com números inteiros não é muito difícil ou tão único.
Veskah 9/08/19
1
@ JonathanAllan Vou lembrar disso no futuro, mas não vou mudar as especificações agora.
Veskah 9/08/19
1
@Veskah sim definitivamente não altere as especificações agora! Aqui é para muitos desafios mais divertido :)
Jonathan Allan

Respostas:

4

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.
Mr. Xcoder
fonte
3

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.

Lynn
fonte
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)

Experimente online!

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

Chas Brown
fonte
3

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
Brincadeira
fonte
1
Eu acho que você pode economizar 1 byte se você tomar uma lista de listas em vez de um monte de matrizes e usar .flatem vez de .[*;*], como esta
Ramillies
3

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 
sundar - Restabelecer Monica
fonte
3

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!

Kroppeb
fonte
1
Eu não li o desafio, mas se você deseja que seu programa seja gerado 0instantaneamente false, o acréscimo |∧0no final deve fazer o trabalho.
Fatalize 8/08/19
1
Eu acho que você pode economizar 2 bytes adiando o ḍ₅: Experimente online!
sundar - Restabelece Monica 8/08/18
1
Mais 2 bytes podem ser salvos usando o operador ~ e evitando a necessidade I: Experimente online! (note que eu também adicionei o |∧0aqui).
Sundar - Restabelece Monica 8/08/18
3

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
digEmAll
fonte
isso é incrível ! salve 3 bytes
JayCe
também eu acho que você pode fazer c(m)para achatar mem vez dem[1:45]
Jayce
@ JayCe: é claro, muito obrigado!
precisa saber é o seguinte
56 bytes utilizando a atribuição em linha
Giuseppe
2

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
Sok
fonte
2

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
Kevin Cruijssen
fonte
2

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 .

Arnauld
fonte
2

Dyalog APL , 28 27 bytes

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

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

ratoeira
fonte
1

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.

Neil
fonte
1

Oitava , 54 bytes

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

Experimente online!

Porta da minha resposta MATL.

sundar - Restabelecer Monica
fonte