Combien vaut ma matrice de dés?


21

Contribution

Une matrice binaire non vide composée de sous-matrices 3x3 mises côte à côte.

Tâche

Votre tâche consiste à identifier des modèles de dés valides (comme décrit ci-dessous) parmi les sous-matrices 3x3. Chaque modèle valide vaut la valeur des dés correspondants. Les modèles invalides valent 0.

Production

La somme des valeurs de dés valides.

Modèles de dés

1:(0,0,00,1,00,0,0)2:(1,0,00,0,00,0,1)ou(0,0,10,0,01,0,0)3:(1,0,00,1,00,0,1)ou(0,0,10,1,01,0,0)4:(1,0,10,0,01,0,1)5:(1,0,10,1,01,0,1)6:(1,0,11,0,11,0,1)ou(1,1,10,0,01,1,1)

Exemple

La sortie attendue pour la matrice suivante est 14 car elle contient les dés 5 , 6 et 3 , suivis d'un motif invalide (de gauche à droite et de haut en bas).

(1,0,1,1,1,10,1,0,0,0,01,0,1,1,1,11,0,0,0,0,00,1,0,0,1,00,0,1,0,1,0)

Règles

  • La largeur et la hauteur de la matrice sont garanties être des multiples de 3.
  • Vous devez ignorer les sous-matrices qui ne sont pas correctement alignées sur la grille (voir le 3e cas de test). Plus formellement et en supposant une indexation 0: les coordonnées de la cellule en haut à gauche de chaque sous-matrice à considérer sont de la forme .(3X,3y)
  • C'est du .

Cas de test

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

Réponses:


5

Python 3 , 195 189 octets

-6 octets grâce à @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))

Essayez-le en ligne! (189) Essayez-le en ligne! (195)

Version lisible par l'homme:

# 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

Je me demande si vous pourriez raccourcir cela légèrement en faisant la même opération sur la transposition de la matrice également. De cette façon, vous pouvez supprimer toutes les entrées en double de votre carte qui ajoutent 6 octets chacune. Juste besoin d'ajouter l'étape de transposition en <18 octets
Easton Bornemeier


Débarrassez-vous des deux instances de //3et utilisez '0'+''.join...pour économiser deux octets :)
Jonathan Allan

... combinez cela avec énumérer pour sauver deux autres: ici
Jonathan Allan


5

R , 134 octets

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}

Essayez-le en ligne!

J'ai remarqué que j'avais la même idée de @Heteira

Histoire :

  • 171 : -10 octets grâce à @JayCe!
  • 161 : -3 octets grâce à @Giuseppe!
  • 158 : -13 octets enregistrés!
  • 145 : -2 octets grâce à @Giuseppe!
  • 143 : -6 octets enregistrés!
  • 137 : -3 octets grâce à @JayCe!

1
économisez 5 octets en compressant la liste des nombres - lien avec des exemples trop longs pour poster un commentaire
JayCe

1
3 octets de plus en utilisantdim
JayCe


1
Il y a une paire de parenthèses supplémentaires (2^(8:0))qui peut être supprimée.
Giuseppe

1
J'ajoute oublié à catla sortie de intToUtf8: enregistrer 3 octets
JayCe

4

Perl 6 , 113 105 97 97 94 octets

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

Essayez-le en ligne!

Divise la matrice en sous-matrices de 3x3, convertit les neuf 1 et 0 en base 2, puis l'indexe en une liste d'entiers pour la valeur.

Explication:

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

4

Gelée ,  29 28 octets

-1 merci à M. Xcoder (utilisé pour remplacer ṢṪ)

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

Un lien monadique.

Essayez-le en ligne! Ou exécutez les tests .

Comment?

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

Par exemple, lorsqu'une sous-matrice est:

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

Puis les ZU,Ɗrendements:

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

... qui s'aplatit en [0, 0, 0, 1, 1, 1, 1, 1, 1], qui, en convertissant de binaire, est 63qui est la sixième entrée dans la liste d'index de page de code “°€⁼-Ḍ?‘( ?étant l'octet 3Fdans la page de code de Jelly )


pourrait fonctionner au lieu de ṢṪ-1.
M. Xcoder

... oui (je pensais que j'économisais sur l'utilisation de M>. <). Peut-on faire quelque chose d'intelligent avec ŒṪje me demande ...
Jonathan Allan


2

Retina 0.8.2 , 90 octets

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

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

Essayez-le en ligne! Explication:

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

3×33×n

¶

M!`.{9}

Joignez tous les blocs ensemble, puis divisez-les en rangées de 9 colonnes.

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

Ne conservez que des modèles de dés valides (deux modèles pour 6, puis un correspond à n'importe quel nombre de 0à 5, bien que 0cela ne contribuera bien sûr pas au décompte ci-dessous.)

1

Comptez les pépins sur les dés valides.


1

Rubis , 151 octets

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

Essayez-le en ligne!

Un lambda acceptant un tableau 2d d'entiers (ou de chaînes, je suppose). S'inspire de la réponse de Jo King . J'ai l'impression que trancher les dés hors de la matrice d'entrée a pris beaucoup de place, donc je risque d'être dépassé. Heureusement, gérer les nils ne m'a coûté qu'une poignée d'octets.

Non golfé:

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

1

Clojure, 197 octets

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

J'aurais dû trouver quelque chose de plus intelligent.


En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.