อินพุต

เมทริกซ์ไบนารีที่ไม่ว่างเปล่าประกอบด้วยเมทริกซ์ย่อย 3x3 ที่วางแบบเคียงข้างกัน

งาน

งานของคุณคือการระบุรูปแบบลูกเต๋าที่ถูกต้อง (ดังที่อธิบายไว้ด้านล่าง) ในกลุ่มเมทริกซ์ย่อย 3x3 แต่ละรูปแบบที่ใช้ได้จะมีค่าเท่ากับค่าของลูกเต๋าที่เกี่ยวข้อง รูปแบบที่ไม่ถูกต้องมีค่า 0

เอาท์พุต

ผลรวมของค่าลูกเต๋าที่ถูกต้อง

รูปแบบลูกเต๋า

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

ตัวอย่าง

ผลลัพธ์ที่คาดหวังสำหรับเมทริกซ์ต่อไปนี้คือ14เนื่องจากประกอบด้วยลูกเต๋า5 , 6และ3ตามด้วยรูปแบบที่ไม่ถูกต้อง (จากซ้ายไปขวาและจากบนลงล่าง)

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

กฎระเบียบ

ทั้งความกว้างและความสูงของเมทริกซ์รับประกันได้ว่าจะเป็นทวีคูณของ 3
คุณต้องละเว้นเมทริกซ์ย่อยที่ไม่จัดแนวอย่างเหมาะสมบนกริด (ดูกรณีทดสอบที่ 3) อีกอย่างเป็นทางการและสมมติ 0 การจัดทำดัชนี: พิกัดของเซลล์บนซ้ายของแต่ละย่อยเมทริกซ์ได้รับการพิจารณาเป็นของแบบฟอร์ม ) $(3x, 3y)$
นี่คือรหัสกอล์ฟ

กรณีทดสอบ

// 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
แหล่งที่มา

5

Python 3 , 195 189 ไบต์

-6 ไบต์ขอบคุณ @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))

ลองออนไลน์! (189) ~~ลองออนไลน์! (195)~~

รุ่นที่มนุษย์อ่านได้:

# 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

— นกฮูกดำไก่
แหล่งที่มา

ฉันสงสัยว่าคุณสามารถย่อให้สั้นลงได้ด้วยการทำแบบเดียวกันกับทรานสโพสของเมทริกซ์ด้วย ด้วยวิธีนี้คุณสามารถลบรายการที่ซ้ำกันทั้งหมดในแผนที่ของคุณซึ่งเพิ่มได้ 6 ไบต์ต่อรายการ เพียงแค่ต้องเพิ่มขั้นตอนการโอนย้ายใน <18 ไบต์

— Easton Bornemeier

188 ไบต์

— Jonathan Frech

กำจัดทั้งสองอินสแตนซ์//3และใช้'0'+''.join...เพื่อบันทึกสองไบต์ :)

— Jonathan Allan

... รวมเข้ากับการแจกแจงเพื่อประหยัดอีกสอง: ที่นี่

— Jonathan Allan

2

165 ไบต์

— Jonathan Frech

5

R , 134 ไบต์

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}

ลองออนไลน์!

ฉันสังเกตเห็นว่าฉันมีความคิดแบบเดียวกันกับ @Heteira

ประวัติความเป็นมา

~~171~~ : -10 ไบต์ขอบคุณ @JayCe!
~~161~~ : -3 ไบต์ขอบคุณ @Giuseppe!
~~158~~ : บันทึก -13 ไบต์!
~~145~~ : -2 ไบต์ขอบคุณ @Giuseppe!
~~143~~ : บันทึก -6 ไบต์!
~~137~~ : -3 ไบต์ขอบคุณ @JayCe!

— digEmAll
แหล่งที่มา

1

บันทึก 5 ไบต์โดยการบีบอัดรายการตัวเลข - เชื่อมโยงกับตัวอย่างยาวเกินกว่าจะโพสต์เป็นความคิดเห็น

— JayCe

1

3 ไบต์ขึ้นไปใช้dim

— Jayce

เวทมนตร์สีดำเพิ่มขึ้นอีกสองไบต์

— JayCe

1

มีวงเล็บสองคู่(2^(8:0))ที่สามารถลบออกได้

— Giuseppe

1

ฉันลืมเพิ่มไปยังcatผลลัพธ์ของintToUtf8: บันทึก 3 ไบต์

— JayCe

4

Perl 6 , 113 105 97 94 ไบต์

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

ลองออนไลน์!

แบ่งเมทริกซ์ออกเป็นเมทริกซ์ย่อย 3x3 แปลงเก้า 1s และ 0s เป็นฐาน 2 แล้วทำดัชนีลงในรายการจำนวนเต็มสำหรับค่า

คำอธิบาย:

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

— โจคิง
แหล่งที่มา

4

เจลลี่ , 29 28 ไบต์

-1 ขอบคุณ Mr. Xcoder (ใช้ Ṁเพื่อแทนที่ṢṪ)

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

ลิงค์ monadic

ลองออนไลน์!หรือเรียกใช้การทดสอบ

อย่างไร?

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

ตัวอย่างเช่นเมื่อเมทริกซ์ย่อยคือ:

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

จากนั้นZU,Ɗให้ผลผลิต:

[[[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]]

... ซึ่งแบนไปถึง[0, 0, 0, 1, 1, 1, 1, 1, 1]ซึ่งแปลงจากไบนารี่63ซึ่งเป็นรายการที่หกในรายการดัชนีโค้ดเพจ“°€⁼-Ḍ?‘( ?เป็นไบต์3Fในโค้ดเพจของเยลลี่ )

— Jonathan Allan
แหล่งที่มา

ṀอาจทำงานแทนṢṪการ -1

— Mr. Xcoder

... ใช่มันจะ (ฉันคิดว่าฉันประหยัดกว่าการใช้M>. <) จะทำสิ่งที่ฉลาดกับŒṪฉันได้ไหม ...

— Jonathan Allan

3

Japt `-x` , 36 ไบต์

ตอนนี้มันเริ่มน่าสนใจ ฉันแน่ใจว่าสามารถลงสนามได้มากขึ้น

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

ลองออนไลน์!

— Luis felipe De jesus Munoz
แหล่งที่มา

2

เรติน่า 0.8.2 , 90 ไบต์

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

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

ลองออนไลน์! คำอธิบาย:

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

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

¶

M!`.{9}

เข้าร่วมบล็อกทั้งหมดเข้าด้วยกันแล้วแยกกลับเป็นแถว 9 คอลัมน์

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

เก็บรูปแบบลูกเต๋าที่ถูกต้องเท่านั้น (สองรูปแบบสำหรับ6แล้วหนึ่งตรงกับจำนวนใด ๆ จาก0ถึง5แม้ว่า0แน่นอนจะไม่นำไปสู่การนับด้านล่าง)

นับลูกเต๋าบนลูกเต๋าที่ถูกต้อง

— นีล
แหล่งที่มา

1

ทับทิมขนาด 151 ไบต์

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

ลองออนไลน์!

แลมบ์ดายอมรับอาร์เรย์ 2 มิติของ ints (หรือสตริงฉันเดา) ใช้แรงบันดาลใจจากคำตอบโจของพระบาทสมเด็จพระเจ้าอยู่หัว ฉันรู้สึกว่าการหั่นลูกเต๋าออกจากเมทริกซ์อินพุทนั้นใช้พื้นที่มากดังนั้นฉันจึงอาจโตได้ โชคดีที่การจัดการกับนิลส์มีค่าใช้จ่ายเพียงเล็กน้อยเท่านั้น

Ungolfed:

->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
แหล่งที่มา

1

Clojure, 197 ไบต์

#(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)))

ฉันควรคิดอะไรที่ฉลาดกว่านี้

— NikoNyrh
แหล่งที่มา

1

Python 2 , 159 ไบต์

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

ลองออนไลน์!

ปลายหมวกกับJonathan Frechสำหรับวิธีการเข้ารหัสแบบ Unicode

— Chas Brown
แหล่งที่มา

เมทริกซ์ลูกเต๋าของฉันมีค่าเท่าไหร่

อินพุต

งาน

เอาท์พุต

รูปแบบลูกเต๋า

ตัวอย่าง

กฎระเบียบ

กรณีทดสอบ

Python 3 , 195 189 ไบต์

รุ่นที่มนุษย์อ่านได้:

R , 134 ไบต์

Perl 6 , 113 105 97 94 ไบต์

คำอธิบาย:

เจลลี่ , 29 28 ไบต์

อย่างไร?

Japt -x , 36 ไบต์

เรติน่า 0.8.2 , 90 ไบต์

ทับทิมขนาด 151 ไบต์

Clojure, 197 ไบต์

Python 2 , 159 ไบต์

Japt `-x` , 36 ไบต์