Đầu vào

Một ma trận nhị phân không rỗng bao gồm các ma trận phụ 3x3 đặt cạnh nhau.

Bài tập

Nhiệm vụ của bạn là xác định các mẫu súc sắc hợp lệ (như được mô tả bên dưới) trong số các ma trận phụ 3x3. Mỗi mẫu hợp lệ có giá trị của xúc xắc tương ứng. Các mẫu không hợp lệ có giá trị 0.

Đầu ra

Tổng các giá trị xúc xắc hợp lệ.

Mô hình súc sắc

\begin{aligned} 1 : (\begin{matrix} 0, 0, 0 \\ 0, 1, 0 \\ 0, 0, 0 \end{matrix}) & 2 : (\begin{matrix} 1, 0, 0 \\ 0, 0, 0 \\ 0, 0, 1 \end{matrix}) or (\begin{matrix} 0, 0, 1 \\ 0, 0, 0 \\ 1, 0, 0 \end{matrix}) \\ 3 : (\begin{matrix} 1, 0, 0 \\ 0, 1, 0 \\ 0, 0, 1 \end{matrix}) or (\begin{matrix} 0, 0, 1 \\ 0, 1, 0 \\ 1, 0, 0 \end{matrix}) & 4 : (\begin{matrix} 1, 0, 1 \\ 0, 0, 0 \\ 1, 0, 1 \end{matrix}) \\ 5 : (\begin{matrix} 1, 0, 1 \\ 0, 1, 0 \\ 1, 0, 1 \end{matrix}) & 6 : (\begin{matrix} 1, 0, 1 \\ 1, 0, 1 \\ 1, 0, 1 \end{matrix}) or (\begin{matrix} 1, 1, 1 \\ 0, 0, 0 \\ 1, 1, 1 \end{matrix}) \end{aligned}

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

Thí dụ

Đầu ra dự kiến cho ma trận sau là 14 vì nó chứa xúc xắc 5 , 6 và 3 , theo sau là một mẫu không hợp lệ (từ trái sang phải và từ trên xuống dưới).

(\begin{matrix} 1, 0, 1, 1, 1, 1 \\ 0, 1, 0, 0, 0, 0 \\ 1, 0, 1, 1, 1, 1 \\ 1, 0, 0, 0, 0, 0 \\ 0, 1, 0, 0, 1, 0 \\ 0, 0, 1, 0, 1, 0 \end{matrix})

$\pmatrix{1,0,1,1,1,1\\ 0,1,0,0,0,0\\ 1,0,1,1,1,1\\ 1,0,0,0,0,0\\ 0,1,0,0,1,0\\ 0,0,1,0,1,0}$

Quy tắc

Cả chiều rộng và chiều cao của ma trận đều được đảm bảo là bội số của 3.
Bạn phải bỏ qua các ma trận phụ không được căn chỉnh chính xác trên lưới (xem trường hợp thử nghiệm thứ 3). Chính thức hơn và giả sử lập chỉ mục 0: tọa độ của ô trên cùng bên trái của mỗi ma trận con được xem xét có dạng . $(3x, 3y)$
Đây là mã golf .

Các trường hợp thử nghiệm

// 0
[ [ 1,0,0 ],
  [ 0,0,1 ],
  [ 1,0,0 ] ]

// 2
[ [ 0,0,1 ],
  [ 0,0,0 ],
  [ 1,0,0 ] ]

// 0 (0 + 0)
[ [ 0,0,1,0,1,0 ],
  [ 0,0,0,1,0,0 ],
  [ 0,0,1,0,1,0 ] ]

// 9 (3 + 3 + 3)
[ [ 1,0,0,0,0,1,1,0,0 ],
  [ 0,1,0,0,1,0,0,1,0 ],
  [ 0,0,1,1,0,0,0,0,1 ] ]

// 6 (6 + 0)
[ [ 1,0,1 ],
  [ 1,0,1 ],
  [ 1,0,1 ],
  [ 1,0,1 ],
  [ 1,0,0 ],
  [ 1,0,1 ] ]

// 14 (5 + 6 + 3 + 0)
[ [ 1,0,1,1,1,1 ],
  [ 0,1,0,0,0,0 ],
  [ 1,0,1,1,1,1 ],
  [ 1,0,0,0,0,0 ],
  [ 0,1,0,0,1,0 ],
  [ 0,0,1,0,1,0 ] ]

// 16 (1 + 2 + 3 + 4 + 0 + 6)
[ [ 0,0,0,1,0,0,1,0,0 ],
  [ 0,1,0,0,0,0,0,1,0 ],
  [ 0,0,0,0,0,1,0,0,1 ],
  [ 1,0,1,1,1,1,1,0,1 ],
  [ 0,0,0,1,0,1,1,0,1 ],
  [ 1,0,1,1,1,1,1,0,1 ] ]

code-golf array-manipulation binary-matrix

— Arnauld
nguồn

5

Python 3 , 195 189 byte

-6 byte nhờ @Jo King

lambda m:sum({16:1,257:2,68:2,273:3,84:3,325:4,341:5,455:6,365:6}.get(int(''.join(str(e)for c in m[3*i:][:3]for e in c[3*j:][:3]),2),0)for i in range(len(m)//3)for j in range(len(m[0])//3))

Hãy thử trực tuyến! (189) ~~Hãy thử trực tuyến! (195)~~

Phiên bản có thể đọc được của con người:

# 3x3 part matrix to dice, beginning at coordinates 3*i, 3*j
def single_matrix_to_dice(matrix, i, j):
    # Example: matrix = [[0, 0, 0], [0, 1, 0], [0, 0, 0]], i=0, j=0 (result is 1)

    matrix_string = ''.join(
        str(e) for column in matrix[3*i:3*i+3] 
        for entry in column[3*j:3*j+3]
    ) # Slicing the matrix so that only the valid entries remain, here '000010000'

    # Interpreting the matrix string as binary number, here 16
    binary_number = int(matrix_string,2)

    # binary representations of all valid dice rolls
    dct = {16:1,257:2,68:2,273:3,84:3,325:4,341:5,455:6,365:6}

    return dct.get(binary_number, 0)

def f(matrix):
    return sum(
        single_matrix_to_dice(matrix, i, j) for i in range(len(m)//3) 
        for j in range(len(m[0])//3))
    ) # len(m)/3 would generate a float, so len(m)//3 is used

— Cú đen Kai
nguồn

Tôi tự hỏi nếu bạn có thể rút ngắn điều này một chút bằng cách thực hiện thao tác tương tự trên chuyển vị của ma trận. Bằng cách đó, bạn có thể xóa tất cả các mục trùng lặp trong bản đồ của mình thêm 6 byte mỗi mục. Chỉ cần thêm bước chuyển đổi trong <18 byte

— Easton Bornemeier

188 byte .

— Jonathan Frech

Loại bỏ cả hai trường hợp //3và sử dụng '0'+''.join...để lưu hai byte :)

— Jonathan Allan

... kết hợp điều đó với liệt kê để tiết kiệm thêm hai: tại đây

— Jonathan Allan

2

165 byte .

— Jonathan Frech

5

R , 134 byte

function(m,d=dim(m)/3-1){for(a in 0:d)for(b in 0:d[2])F=F+sum(y<-m[1:3+a*3,1:3+b*3])*sum(y*2^(8:0))%in%utf8ToInt("āDđTŅŕǇŭ");F}

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

Tôi nhận thấy tôi có cùng ý tưởng về @Heteira

Lịch sử :

~~171~~ : -10 byte nhờ @JayCe!
~~161~~ : -3 byte nhờ @Giuseppe!
~~158~~ : -13 byte được lưu!
~~145~~ : -2 byte nhờ @Giuseppe!
~~143~~ : -6 byte được lưu!
~~137~~ : -3 byte nhờ @JayCe!

— đàoEmAll
nguồn

1

lưu 5 byte bằng cách nén danh sách các số - liên kết với các ví dụ quá dài để đăng dưới dạng nhận xét

— JayCe

1

Thêm 3 byte bằng cách sử dụngdim

— JayCe

ma thuật đen nhiều hơn cho hai byte nữa

— JayCe

1

Có thêm một cặp dấu ngoặc đơn xung quanh (2^(8:0))có thể được gỡ bỏ.

— Giuseppe

1

Tôi thêm quên vào catđầu ra của intToUtf8: lưu 3 byte

— JayCe

4

Perl 6 , 113 105 97 94 byte

{sum (|@_[*;^3+3*$_]for ^@_[0]).rotor(9).map:{"@āđŅŕǇ@@DT@@ŭ".ords.first(:2[$_],:k)%7}}

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

Chia ma trận thành các ma trận phụ 3x3, chuyển đổi chín 1 và 0 thành cơ sở 2 và sau đó lập chỉ mục cho nó thành một danh sách các số nguyên cho giá trị.

Giải trình:

{  #Start anonymous code block
  sum   # Sum of all
     (|@_[*;^3+3*$_]   # Get the n*3 to n*3+3th elements in every sub-list
           for ^@_[0]) # For n in the range 0 to width (divide by 3 to avoid warnings)
     .rotor(9)  # Split this list into groups of 9 (split the dice up)
     .map:{     # And map each die to 
        "@āđŅŕǇ@@DT@@ŭ".ords  # In the list of integers
           .first(      # The first appearance of 
               :2[$_],  # The dice converted from a list of 0s and 1s to base 2
                 :k     # Returning the index
             )%7        # And modulo by 7 to get the alternate versions of 2, 3 and 6
          }
}

— Jo vua
nguồn

4

Thạch , 29 28 byte

-1 nhờ ông Xcoder (sử dụng Ṁđể thay thế ṢṪ)

s€3ZẎs3µZU,ƊṀṙ1FḄ“°€⁼-Ḍ?‘i)S

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

Hãy thử trực tuyến! Hoặc chạy thử nghiệm .

Làm sao?

s€3ZẎs3µZU,ƊṀṙ1FḄ“°€⁼-Ḍ?‘i)S - Link: list of lists of 1s and 0s
s€3                          - split each into threes
   Z                         - transpose
    Ẏ                        - tighten
     s3                      - split into threes -> the sub-matrices in column-major order
       µ                  )  - for each sub-matrix, say D:
           Ɗ                 -   last three links as a monad:
        Z                    -     transpose D
         U                   -     reverse each -> D rotated a quarter turn clockwise
          ,                  -     pair with D
            Ṁ                -   get the maximum of the two orientations
             ṙ1              -   rotate left by one (to ensure FḄ will yield integers <256 for all non-zero valued D)
               F             -   flatten
                Ḅ            -   convert from binary
                         i   -   first 1-based index in (0 if not found):
                 “°€⁼-Ḍ?‘    -     code-page indices list = [128,12,140,45,173,63]
                           S - sum

Ví dụ: khi một ma trận phụ là:

[[1,0,1],
 [1,0,1],
 [1,0,1]]

Sau đó ZU,Ɗmang lại:

[[[1, 1, 1],
  [0, 0, 0],
  [1, 1, 1]],   ...which has maximum (Ṁ):    ...and after ṙ1:
 [[1, 0, 1],                   [[1, 1, 1],         [[0, 0, 0],
  [1, 0, 1],                    [0, 0, 0],          [1, 1, 1],
  [1, 0, 1]]]                   [1, 1, 1]]          [1, 1, 1]]

... làm phẳng [0, 0, 0, 1, 1, 1, 1, 1, 1], chuyển đổi từ nhị phân, là 63mục thứ sáu trong danh sách chỉ mục trang mã “°€⁼-Ḍ?‘( ?là byte 3Ftrong trang mã của Jelly )

— Jonathan Allan
nguồn

Ṁcó thể hoạt động thay vì ṢṪ-1.

— Ông Xcoder

... vâng, điều đó sẽ xảy ra (tôi nghĩ rằng tôi đã tiết kiệm khi sử dụng M>. <). Có thể làm điều gì đó thông minh với ŒṪtôi không ...

— Jonathan Allan

3

Japt `-x` , 36 byte

Bây giờ nó đang trở nên thú vị. Tôi chắc chắn có thể chơi golf xuống nhiều hơn

ò3 ®®ò3Ãy f@"0ıtŵġdťƍǧ"øºXm¬¬Í+H)d
c

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

— Luis felipe De jesus Munoz
nguồn

2

Võng mạc 0.8.2 , 90 byte

+`(...)(.+¶)(...)(.+¶)(...)
$1¶$3¶$5¶$2$4
¶

M!`.{9}
G`111000111|(101){3}|(.)0(.0).0\3\2
1

Hãy thử trực tuyến! Giải trình:

+`(...)(.+¶)(...)(.+¶)(...)
$1¶$3¶$5¶$2$4

$3\times 3$ $3\times n$

¶

M!`.{9}

Nối tất cả các khối lại với nhau và sau đó chia lại thành các hàng gồm 9 cột.

G`111000111|(101){3}|(.)0(.0).0\3\2

Chỉ giữ các mẫu súc sắc hợp lệ (hai mẫu cho 6, sau đó một mẫu phù hợp với bất kỳ số nào từ 0đến 5, mặc dù 0tất nhiên sẽ không đóng góp vào số lượng bên dưới.)

Đếm số pips trên xúc xắc hợp lệ.

— Neil
nguồn

1

Ruby , 151 byte

->m{m.each_slice(3).flat_map{|r|r.transpose.each_slice(3).map{|d|" \x10āđŅŕǇ  DT  ŭ".chars.map(&:ord).index(d.flatten.join.to_i 2)&.%7}-[p]}.sum}

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

Một lambda chấp nhận một mảng int 2d (hoặc chuỗi, tôi đoán vậy). Lấy cảm hứng từ câu trả lời của Jo King . Tôi cảm thấy việc cắt xúc xắc ra khỏi ma trận đầu vào chiếm rất nhiều không gian, vì vậy tôi có thể bị ruồng bỏ. May mắn thay, việc xử lý các nils chỉ tiêu tốn của tôi một số byte.

Ung dung:

->m{
  m.each_slice(3).flat_map{|r|             # Split into groups of 3 rows
    r.transpose.each_slice(3).map{|d|      # Split into groups of 3 columns
      " \x10āđŅŕǇ  DT  ŭ".chars.map(&:ord) # [0,16,257,273,325,341,455,0,0,68,84,0,0,365]
        .index(                            # Find in that array
          d.flatten.join.to_i 2            #   the die flattened into a bitstring (nil if not found)
        )&.%7                              # Safe-modulo 7 (leaves nils as nil)
    }-[p]                                  # Remove nils
  }.sum                                    # Add 'em up
}

— benj2240
nguồn

1

Clojure, 197 byte

#(apply +(for[R[range]i(R 0(count %)3)j(R 0(count(% 0))3)](case(apply +(map *(iterate(partial * 2)1)(for[x(R 3)y(R 3)]((%(+ i x))(+ j y)))))16 1 257 2 68 2 273 3 84 3 325 4 3 4 1 5 455 6 365 6 0)))

Tôi nên nghĩ ra một cái gì đó thông minh hơn.

— NikoNyrh
nguồn

1

Python 2 , 159 byte

f=lambda a:a>[]and sum(u'ȀāDđTŅȀŕȀǇŭ'.find(unichr(int(J(J(map(str,r[i:i+3]))for r in a[:3]),2)))/2+1for i in range(0,len(a[0]),3))+f(a[3:])
J=''.join

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

Hat tip cho Jonathan Frech cho phương pháp mã hóa unicode.

— Chas Brown
nguồn

Ma trận súc sắc của tôi đáng giá bao nhiêu?

Đầu vào

Bài tập

Đầu ra

Mô hình súc sắc

Thí dụ

Quy tắc

Các trường hợp thử nghiệm

Python 3 , 195 189 byte

Phiên bản có thể đọc được của con người:

R , 134 byte

Perl 6 , 113 105 97 94 byte

Giải trình:

Thạch , 29 28 byte

Làm sao?

Japt -x , 36 byte

Võng mạc 0.8.2 , 90 byte

Ruby , 151 byte

Clojure, 197 byte

Python 2 , 159 byte

Japt `-x` , 36 byte