Terinspirasi dan dijarah dari tantangan dadu oleh Arnauld

Memasukkan

Anda diberi matriks dadu 5x1 atau 1x5 (pilihan Anda) yang terdiri dari sub-matriks biner 3x3.

Tujuan

Diberikan matriks dadu yang valid, Anda harus skor menggunakan aturan 6,5,4 yang adalah sebagai berikut:

• Jika gulungan berisi 6,5,4, tambahkan dua dadu lainnya dan itu adalah skor Anda. Misal 4, X, 5,6, Y = X + Y
• Jika tidak, skornya adalah 0. Misalnya 5,5,5,4,1 = 0

Artikel wiki untuk game

Pola dadu

$$\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}$$

Aturan

• Matriks dijamin hanya berisi wajah yang valid tetapi akan mencakup permutasi 2,3 dan 6. Anda juga dapat mengambilnya dalam orientasi mana pun dengan cara apa pun yang nyaman. Harap sebutkan orientasi yang dipilih dalam jawaban Anda.
• Keluarkan skor yang dihitung
• Celah Standar dilarang
• Ini adalah kode-golf .

Contohnya

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

3ôO<O©3LsK_P®O*

Cobalah online! atau Lihatlah test suite!

Menggunakan trik yang sama seperti yang digunakan Chas Brown dan Lynn: mengurangi setiap bilangan bulat di setiap sub-matriks 3x3 daripada mengurangi 15 di akhir. Mengharapkan input dalam format kolom.

Bagaimana itu bekerja

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.

Jelly , 14 byte

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

Cobalah online!

Menerima kolom dadu.

                  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.

Sama seperti jawaban Python Chas Brown, ini mengimbangi setiap nilai dadu dengan −3 sehingga kita tidak perlu mengurangi 15 (4 + 5 + 6) dari jumlah terakhir.

Python 2 , 81 byte

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

Cobalah online!

Semua input diharapkan dalam bentuk kolom.

Perl 6 , 48 46 byte

Terima kasih kepada Ramillies untuk -2 byte

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

Cobalah online!

Blok kode anonim yang mengambil matriks secara vertikal dan mengembalikan integer.

Penjelasan:

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

9es3-I:ymp*s

Cobalah online!

Mengambil input dalam orientasi horizontal sebagai matriks 3x15. Trik @Chas Brown mengurangi 3 awal (bukan 15 nanti) menyimpan banyak byte dengan cara yang berbeda.

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 byte

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

• +3 byte tetapi mencetak 0 bukannya false jika tidak 4,5,6 (Fatalize)
• - 2 4 byte (jam matahari)

Salah satu program branchylog pertama saya. Mungkin bisa bermain golf lebih banyak. Mencetak false jika tidak ada 4,5,6. idk bagaimana membuatnya keluaran 0.

Cobalah online!

R , 56 byte

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

Cobalah online!

• -6 byte terima kasih kepada JayCe
• -1 byte terima kasih kepada Giuseppe

Pyth , 20 byte

*-ssQ15}j456TySsMc5s

Mengharapkan input sebagai kolom dadu (seperti dalam kasus uji 1). Cobalah online di sini , atau verifikasi semua uji sekaligus di sini .

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

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

Membawa matriks dadu di bawah satu sama lain.

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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 byte

Mengambil input sebagai kolom dadu.

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

Cobalah online!

Bagaimana?

Dengan melakukan a + 0, kami secara implisit meratakan dan memaksa array input ke string dan menambahkan trailing "0", yang memberikan tepat 5x18 = 90 karakter.

Misalnya, test case pertama mengarah ke:

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

Untuk setiap dadu substring s dari 18 karakter, kita menghitung jumlah n pips + 1 dan kami memperbarui jumlah pips t dengan:

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

Kami menggunakan kembali larik input a sebagai bitmask untuk melacak setiap dadu yang ditemui setidaknya sekali:

a |= 1 << n

Jika gulungan berisi setidaknya satu 4 , satu 5 dan satu 6 , bitmask a akan memiliki bit-bit berikut ini:

11100000 (224 in decimal)

Kami menguji ini dengan melakukan a > 223. Jika berhasil, kami mengembalikan t . Karena kami menghitung satu pip ekstra untuk setiap dadu dan karena kami tidak ingin menghitung 4 + 5 + 6 dalam hasilnya, t diinisialisasi ke - (5 + (4 + 5 + 6)) = -20 .

Dyalog APL , 28 27 byte

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

Cobalah online!

Mengambil matriks 1x5 dari matriks dadu 3x3 sebagai input.

+/¨,¨menambahkan nilai pip dari masing-masing dadu. Kemudian kurangi 3, gunakan ∨/⍉⍵∘.=⍳3untuk memeriksa apakah ada setidaknya satu contoh masing-masing (1, 2, 3), DAN hasilnya bersama-sama dengan ∧/dan gandakan hasilnya (0 atau 1) dengan jumlah nilai dadu yang disesuaikan ( +/⍵).

Retina 0.8.2 , 45 byte

¶

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

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

1

Cobalah online! Mengambil dadu vertikal. Penjelasan:

¶

M!`.{9}

Bentuk kembali dadu menjadi 5 baris individu.

%M`1

Dapatkan nilai dari setiap baris.

O`

Urutkan sesuai urutan.

¶

Bergabung dengan mereka menjadi satu string.

G`4.*5.*6

Pastikan ketiga dadu yang diperlukan ada.

.
$*

Konversi masing-masing mati ke unary.

1{15}

Kurangi pencocokan 4, 5 dan 6.

1

Jumlahkan dan konversikan ke desimal.

Jelly , 18 byte

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

Tautan monadik

Cobalah online!

Oktaf , 54 byte

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

Cobalah online!

Port jawaban MATL saya.

Ruby , 78 byte

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

Cobalah online!