Inspiriert und geplündert von dieser Würfelherausforderung von Arnauld

Eingang

Sie erhalten eine 5x1- oder 1x5-Würfelmatrix (nach Ihrer Wahl), die aus binären 3x3-Untermatrizen besteht.

Tor

Bei einer gültigen Würfelmatrix müssen Sie diese nach den folgenden Regeln von 6,5,4 bewerten:

• Wenn der Wurf 6,5,4 enthält, addieren Sie die beiden anderen Würfel und das ist Ihre Punktzahl. ZB 4, X, 5,6, Y = X + Y.
• Andernfalls ist die Punktzahl 0. ZB 5,5,5,4,1 = 0

Wiki-Artikel zum Spiel

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

Regeln

• Die Matrix enthält garantiert nur gültige Flächen, enthält jedoch die Permutationen 2,3 und 6. Sie können es auch in einer beliebigen Ausrichtung aufnehmen, wie es zweckmäßig ist. Bitte geben Sie in Ihrer Antwort die gewählte Ausrichtung an.
• Geben Sie die berechnete Punktzahl aus
• Standardlücken sind verboten
• Das ist Code-Golf .

Beispiele

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

3ôO<O©3LsK_P®O*

Probieren Sie es online aus! oder Schauen Sie sich eine Testsuite an!

Verwendet den gleichen Trick wie Chas Brown und Lynn: Dekrementieren jeder Ganzzahl in jeder 3x3-Submatrix, anstatt am Ende 15 zu subtrahieren. Erwartet eine Eingabe im Spaltenformat.

Wie es funktioniert

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.

Gelee , 14 Bytes

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

Probieren Sie es online aus!

Akzeptiert eine Würfelsäule.

                  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.

Genau wie bei Chas Browns Python-Antwort wird dadurch jeder Würfelwert um –3 versetzt, sodass wir nicht 15 (4 + 5 + 6) von der allerletzten Summe abziehen müssen.

Python 2 , 81 Bytes

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

Probieren Sie es online aus!

Es wird erwartet, dass alle Eingaben in Spaltenform erfolgen.

Perl 6 , 48 46 Bytes

Vielen Dank an Ramillies für -2 Bytes

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

Probieren Sie es online aus!

Ein anonymer Codeblock, der die Matrix vertikal nimmt und eine Ganzzahl zurückgibt.

Erläuterung:

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

9es3-I:ymp*s

Probieren Sie es online aus!

Nimmt die Eingabe in horizontaler Ausrichtung als 3x15-Matrix auf. @Chas Browns Trick, 3 früh (statt 15 später) zu subtrahieren, speicherte mehrere Bytes auf unterschiedliche Weise.

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 Bytes

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

• +3 Bytes, druckt aber 0 statt false aus, wenn kein 4,5,6 (Fatalize)
• - 2 4 Bytes (Sundar)

Eines meiner ersten Branchylog-Programme. Kann wahrscheinlich mehr Golf gespielt werden. Druckt falsch, wenn kein 4,5,6 vorhanden ist. idk wie man es 0 ausgeben lässt.

Probieren Sie es online aus!

R , 56 Bytes

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

Probieren Sie es online aus!

• -6 Bytes dank JayCe
• -1 Byte dank Giuseppe

Pyth , 20 Bytes

*-ssQ15}j456TySsMc5s

Erwartet die Eingabe als Würfelspalte (wie in Testfall 1). Versuchen Sie es online hier , oder prüfen Sie alle Testfälle auf einmal hier .

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

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

Nimmt die Würfelmatrizen untereinander.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Nimmt die Eingabe als Würfelspalte auf.

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

Probieren Sie es online aus!

Wie?

Auf diese Weise a + 0reduzieren und erzwingen wir implizit das Eingabearray zu einem String und fügen ein Trailing hinzu"0" reduzieren erzwingen , das genau 5x18 = 90 Zeichen ergibt .

Zum Beispiel führt der erste Testfall zu:

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

Für jeden Würfel-Teilstring s mit 18 Zeichen berechnen wir die Anzahl n von Pips + 1 und aktualisieren die Gesamtzahl von Pips t mit:

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

Wir verwenden das Eingabearray a erneut als Bitmaske, um jeden Würfel zu verfolgen, der mindestens einmal angetroffen wurde:

a |= 1 << n

Wenn die Rolle mindestens eine 4 , eine 5 und eine 6 enthält , werden für die Bitmaske a die folgenden Bits gesetzt:

11100000 (224 in decimal)

Wir testen dies, indem wir dies tun a > 223. Bei Erfolg geben wir t zurück . Da wir für jeden Würfel einen zusätzlichen Pip zählen und im Ergebnis nicht 4 + 5 + 6 zählen möchten , wird t auf - (5 + (4 + 5 + 6)) = -20 initialisiert .

Dyalog APL , 28 27 Bytes

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

Probieren Sie es online aus!

Nimmt eine 1x5-Matrix von 3x3-Würfelmatrizen als Eingabe.

+/¨,¨addiert die Pip-Werte jedes Würfels. Subtrahieren Sie dann 3, um ∨/⍉⍵∘.=⍳3zu überprüfen, ob jeweils mindestens eine Instanz von (1, 2, 3) vorhanden ist, UND die Ergebnisse zusammen mit ∧/und multiplizieren Sie das Ergebnis (0 oder 1) mit der Summe der angepassten Würfelwerte ( +/⍵).

Retina 0,8,2 , 45 Bytes

¶

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

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

1

Probieren Sie es online aus! Nimmt vertikale Würfel. Erläuterung:

¶

M!`.{9}

Formen Sie die Würfel in 5 einzelne Reihen um.

%M`1

Holen Sie sich die Werte jeder Zeile.

O`

Sortieren Sie sie in der richtigen Reihenfolge.

¶

Verbinden Sie sie zu einer einzigen Zeichenfolge.

G`4.*5.*6

Stellen Sie sicher, dass die drei erforderlichen Würfel vorhanden sind.

.
$*

Wandle jeden Würfel in unär um.

1{15}

Subtrahieren Sie die passenden 4, 5 und 6.

1

Summiere und konvertiere in Dezimalzahl.

Gelee , 18 Bytes

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

Eine monadische Verbindung

Probieren Sie es online aus!

Oktave , 54 Bytes

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

Probieren Sie es online aus!

Port meiner MATL-Antwort.

Ruby , 78 Bytes

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

Probieren Sie es online aus!