Lấy cảm hứng và bị cướp bóc từ thử thách súc sắc này của Arnauld

Đầu vào

Bạn được cung cấp một ma trận súc sắc 5x1 hoặc 1x5 (sự lựa chọn của bạn) bao gồm các ma trận phụ 3x3 nhị phân.

Mục tiêu

Đưa ra một ma trận súc sắc hợp lệ, bạn phải chấm điểm bằng cách sử dụng các quy tắc 6,5,4 như sau:

• Nếu cuộn chứa 6,5,4, cộng hai con xúc xắc khác lại với nhau và đó là điểm số của bạn. Ví dụ: 4, X, 5,6, Y = X + Y
• Mặt khác, điểm số là 0. Ví dụ: 5,5,5,4,1 = 0

Wiki bài viết cho trò chơi

Mô hình súc sắc

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

Quy tắc

• Ma trận được đảm bảo chỉ chứa các mặt hợp lệ nhưng sẽ bao gồm các hoán vị 2,3 và 6. Bạn cũng có thể mang nó theo bất kỳ hướng nào theo bất kỳ cách nào thuận tiện. Vui lòng nêu định hướng đã chọn trong câu trả lời của bạn.
• Xuất số điểm tính toán
• Lỗ hổng tiêu chuẩn bị cấm
• Đây là môn đánh gôn .

Ví dụ

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

Hãy thử trực tuyến! hoặc Kiểm tra một bộ thử nghiệm!

Sử dụng thủ thuật tương tự như Chas Brown và Lynn sử dụng: giảm từng số nguyên trong mỗi ma trận con 3x3 thay vì trừ 15 ở cuối. Mong đợi đầu vào ở định dạng cột.

Làm thế nào nó hoạt động

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.

Thạch , 14 byte

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

Hãy thử trực tuyến!

Chấp nhận một cột súc sắc.

                  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.

Giống như câu trả lời Python của Chas Brown, điều này bù cho mỗi giá trị xúc xắc bằng −3 để chúng ta không cần phải trừ 15 (4 + 5 + 6) từ tổng cuối cùng.

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)

Hãy thử trực tuyến!

Tất cả các đầu vào dự kiến ​​sẽ ở dạng cột.

Perl 6 , 48 46 byte

Cảm ơn Ramillies cho -2 byte

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

Hãy thử trực tuyến!

Một khối mã ẩn danh lấy ma trận theo chiều dọc và trả về một số nguyên.

Giải trình:

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

Hãy thử trực tuyến!

Đưa đầu vào theo hướng ngang dưới dạng ma trận 3x15. Thủ thuật của @Chas Brown là trừ 3 sớm (thay vì 15 sau) đã lưu nhiều byte theo nhiều cách khác nhau.

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 nhưng in ra 0 thay vì sai nếu không có 4,5,6 (Fatalize)
• - 2 4 byte (đồng hồ mặt trời)

Một trong những chương trình Branchylog đầu tiên của tôi. Có lẽ có thể được chơi golf nhiều hơn. In sai nếu không có 4,5,6. idk làm thế nào để làm cho nó đầu ra 0.

Hãy thử trực tuyến!

R , 56 byte

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

Hãy thử trực tuyến!

• -6 byte nhờ JayCe
• -1 byte nhờ Giuseppe

Pyth , 20 byte

*-ssQ15}j456TySsMc5s

Dự kiến ​​đầu vào là một cột súc sắc (như trong trường hợp thử nghiệm 1). Dùng thử trực tuyến tại đây hoặc xác minh tất cả các trường hợp thử nghiệm cùng một lúc tại đây .

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

Đưa các con xúc xắc bên dưới nhau.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Đưa đầu vào như một cột súc sắc.

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

Hãy thử trực tuyến!

Làm sao?

Bằng cách thực hiện a + 0, chúng tôi hoàn toàn làm phẳng và ép buộc mảng đầu vào thành một chuỗi và thêm một dấu "0", cho ra chính xác 5x18 = 90 ký tự.

Chẳng hạn, trường hợp thử nghiệm đầu tiên dẫn đến:

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

Đối với mỗi con xúc xắc substring s 18 ký tự, ta tính số n của pip + 1 và chúng tôi cập nhật tổng số pip t với:

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

Chúng tôi sử dụng lại mảng đầu vào a dưới dạng bitmask để theo dõi từng con xúc xắc đã gặp ít nhất một lần:

a |= 1 << n

Nếu cuộn chứa ít nhất một 4 , một 5 và một 6 , bitmask a sẽ có các bit sau:

11100000 (224 in decimal)

Chúng tôi kiểm tra điều này bằng cách làm a > 223. Nếu thành công, chúng tôi trở lại t . Vì chúng tôi đếm thêm một pip cho mỗi con xúc xắc và vì chúng tôi không muốn đếm 4 + 5 + 6 trong kết quả, t được khởi tạo thành - (5 + (4 + 5 + 6)) = -20 .

APL Dyalog , 28 27 byte

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

Hãy thử trực tuyến!

Lấy ma trận 1x5 của ma trận xúc xắc 3x3 làm đầu vào.

+/¨,¨cộng các giá trị pip của mỗi con xúc xắc. Sau đó trừ 3, sử dụng ∨/⍉⍵∘.=⍳3để kiểm tra xem có ít nhất một trường hợp mỗi (1, 2, 3), VÀ kết quả cùng với ∧/và nhân kết quả (0 hoặc 1) với tổng các giá trị xúc xắc được điều chỉnh ( +/⍵).

Võng mạc 0.8.2 , 45 byte

¶

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

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

1

Hãy thử trực tuyến! Đưa xúc xắc dọc. Giải trình:

¶

M!`.{9}

Định hình lại xúc xắc thành 5 hàng riêng lẻ.

%M`1

Lấy các giá trị của mỗi hàng.

O`

Sắp xếp chúng theo thứ tự.

¶

Tham gia chúng thành một chuỗi duy nhất.

G`4.*5.*6

Đảm bảo rằng ba con xúc xắc cần thiết có mặt.

.
$*

Chuyển đổi từng die thành unary.

1{15}

Trừ các kết hợp 4, 5 và 6.

1

Tổng và chuyển thành số thập phân.

Thạch , 18 byte

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

Một liên kết đơn âm

Hãy thử trực tuyến!

Octave , 54 byte

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

Hãy thử trực tuyến!

Cổng câu trả lời MATL của tôi.

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}

Hãy thử trực tuyến!