Eingang

Eine nicht leere binäre Matrix bestehend aus 3x3 Submatrizen, die nebeneinander angeordnet sind.

Aufgabe

Ihre Aufgabe ist es, gültige Würfelmuster (wie unten beschrieben) unter den 3x3-Submatrizen zu identifizieren. Jedes gültige Muster ist den Wert der entsprechenden Würfel wert. Ungültige Muster sind 0 wert.

Ausgabe

Die Summe der gültigen Würfelwerte.

Würfelmuster

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

Beispiel

Die erwartete Ausgabe für die folgende Matrix ist 14, da sie die Würfel 5 , 6 und 3 enthält , gefolgt von einem ungültigen Muster (von links nach rechts und von oben nach unten).

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

Regeln

• Sowohl die Breite als auch die Höhe der Matrix betragen garantiert ein Vielfaches von 3.
• Sie müssen Untermatrizen ignorieren, die auf dem Raster nicht richtig ausgerichtet sind (siehe 3. Testfall). Formaler und unter der Annahme einer 0-Indexierung: Die Koordinaten der oberen linken Zelle jeder zu betrachtenden Untermatrix haben die Form .$(3x, 3y)$
• Das ist Code-Golf .

Testfälle

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

Python 3 , 195 189 Bytes

-6 Bytes dank @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))

Probieren Sie es online! (189) Online ausprobieren! (195)

Vom Menschen lesbare Version:

# 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

R , 134 Bytes

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ŅŕLJŭ");F}

Probieren Sie es online!

Mir ist aufgefallen, dass ich die gleiche Idee von @Heteira hatte

Geschichte :

• 171 : -10 Bytes dank @JayCe!
• 161 : -3 Bytes dank @ Giuseppe!
• 158 : -13 Bytes gespeichert!
• 145 : -2 Bytes dank @ Giuseppe!
• 143 : -6 Bytes gespeichert!
• 137 : -3 Bytes dank @JayCe!

Perl 6 , 113 105 97 94 Bytes

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

Probieren Sie es online!

Teilt die Matrix in Untermatrizen von 3x3 auf, konvertiert die neun Einsen und Nullen zur Basis 2 und indiziert sie dann in eine Liste von Ganzzahlen für den Wert.

Erläuterung:

{  #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 
        "@āđŅŕLJ@@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
          }
}

Jelly ,  29 28 Bytes

-1 dank Mr. Xcoder ( Ṁzum Ersetzen verwenden ṢṪ)

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

Eine monadische Verbindung.

Probieren Sie es online! Oder führen Sie die Tests durch .

Wie?

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

Zum Beispiel, wenn eine Untermatrix ist:

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

Dann ZU,Ɗergibt sich:

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

... was sich in was abflacht [0, 0, 0, 1, 1, 1, 1, 1, 1], was aus dem Binären konvertiert, 63was der sechste Eintrag in der Codepage-Indexliste ist “°€⁼-Ḍ?‘( ?Byte 3Fin Jellys Codepage )

Japt -x , 36 Bytes

Jetzt wird es interessant. Ich bin sicher, dass man noch mehr Golf spielen kann

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

Probieren Sie es online!

Retina 0.8.2 , 90 Bytes

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

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

Probieren Sie es online! Erläuterung:

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

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

¶

M!`.{9}

Füge alle Blöcke zusammen und teile sie dann wieder in 9 Spalten auf.

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

Behalten Sie nur gültige Würfelmuster bei (zwei Muster für 6, dann stimmt eines mit einer beliebigen Anzahl von 0bis überein 5, obwohl dies 0natürlich nicht zur unten angegebenen Anzahl beiträgt.)

1

Zählen Sie die Pips auf den gültigen Würfeln.

Rubin , 151 Bytes

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

Probieren Sie es online!

Ein Lambda, das ein 2d-Array von Ints (oder Strings, denke ich) akzeptiert. Lässt sich von Jo Kings Antwort inspirieren . Ich habe das Gefühl, dass das Herausschneiden der Würfel aus der Eingabematrix viel Platz in Anspruch nimmt, sodass ich möglicherweise überfordert bin. Glücklicherweise hat mich der Umgang mit Nullen nur eine Handvoll Bytes gekostet.

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āđŅŕLJ  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
}

Clojure, 197 Bytes

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

Ich hätte mir etwas schlaueres einfallen lassen sollen.

Python 2 , 159 Bytes

f=lambda a:a>[]and sum(u'ȀāDđTŅȀŕȀLJŭ'.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

Probieren Sie es online!

Hutspitze an Jonathan Frech für den Unicode-Codierungsansatz.