¿Cuánto vale mi matriz de dados?

21

Entrada

Una matriz binaria no vacía que consta de 3x3 submatrices puestas una al lado de la otra.

Tarea

Su tarea es identificar patrones de dados válidos (como se describe a continuación) entre las submatrices 3x3. Cada patrón válido vale el valor de los dados correspondientes. Los patrones inválidos valen 0.

Salida

La suma de los valores de dados válidos.

Patrones de dados

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

Ejemplo

El resultado esperado para la siguiente matriz es 14 porque contiene los dados 5 , 6 y 3 , seguidos de un patrón no válido (de izquierda a derecha y de arriba a abajo).

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

Reglas

  • Se garantiza que tanto el ancho como la altura de la matriz serán múltiplos de 3.
  • Debe ignorar las submatrices que no están alineadas correctamente en la cuadrícula (consulte el tercer caso de prueba). Más formalmente y suponiendo la indexación 0: las coordenadas de la celda superior izquierda de cada submatriz a considerar son de la forma .(3X,3y)
  • Este es el .

Casos de prueba

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

Respuestas:

5

Python 3 , 195 189 bytes

-6 bytes gracias a @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))

Pruébalo en línea! (189) ¡ Pruébalo en línea! (195)

Versión legible para humanos:

# 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
Black Owl Kai
fuente
Me pregunto si podría acortar esto ligeramente haciendo la misma operación en la transposición de la matriz también. De esa manera, podría eliminar todas las entradas duplicadas en su mapa que agreguen 6 bytes cada una. Solo necesito agregar el paso de transposición en <18 bytes
Easton Bornemeier
188 bytes .
Jonathan Frech
Deshágase de ambas instancias //3y úselo '0'+''.join...para guardar dos bytes :)
Jonathan Allan
... combine eso con enumerate para salvar dos más: aquí
Jonathan Allan
2
165 bytes .
Jonathan Frech
5

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}

Pruébalo en línea!

Noté que tenía la misma idea de @Heteira

Historia:

  • 171 : -10 bytes gracias a @JayCe!
  • 161 : -3 bytes gracias a @Giuseppe!
  • 158 : -13 bytes guardados!
  • 145 : -2 bytes gracias a @Giuseppe!
  • 143 : -6 bytes guardados!
  • 137 : -3 bytes gracias a @JayCe!
digEmAll
fuente
1
ahorre 5 bytes comprimiendo la lista de números - enlace con ejemplos demasiado largos para publicar como comentario
JayCe
1
3 bytes más usandodim
JayCe
1
Hay un par adicional de paréntesis alrededor del (2^(8:0))cual se pueden eliminar.
Giuseppe
1
Agrego olvidado a catla salida de intToUtf8: guardar 3 bytes
JayCe
4

Perl 6 , 113105 97 94 bytes

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

Pruébalo en línea!

Divide la matriz en submatrices de 3x3, convierte los nueve 1s y 0s en base 2 y luego la indexa en una lista de enteros para el valor.

Explicación:

{  #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
          }
}
Jo King
fuente
4

Jalea ,  29 28 bytes

-1 gracias al Sr. Xcoder (usar para reemplazar ṢṪ)

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

Un enlace monádico.

Pruébalo en línea! O ejecuta las pruebas .

¿Cómo?

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

Por ejemplo, cuando una submatriz es:

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

Luego ZU,Ɗproduce:

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

... que se aplana [0, 0, 0, 1, 1, 1, 1, 1, 1], que, convirtiendo de binario, es 63la sexta entrada en la lista de índice de la página de códigos “°€⁼-Ḍ?‘( ?siendo byte 3Fen la página de códigos de Jelly )

Jonathan Allan
fuente
podría funcionar en lugar de ṢṪpara -1.
Sr. Xcoder
... sí lo hará (pensé que estaba ahorrando usando M>. <). ¿Se puede hacer algo inteligente? ŒṪMe pregunto ...
Jonathan Allan
3

Japt -x , 36 bytes

Ahora se está poniendo interesante. Estoy seguro de que se puede jugar golf aún más

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

Pruébalo en línea!

Luis felipe De jesus Munoz
fuente
2

Retina 0.8.2 , 90 bytes

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

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

Pruébalo en línea! Explicación:

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

3×33×norte

¶

M!`.{9}

Une todos los bloques y luego vuelve a dividirlos en filas de 9 columnas.

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

Solo mantenga patrones de dados válidos (dos patrones para 6, luego uno coincide con cualquier número de 0a 5, aunque 0por supuesto no contribuirá a la cuenta a continuación).

1

Cuente las pepitas en los dados válidos.

Neil
fuente
1

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

Pruébalo en línea!

Una lambda que acepta una matriz 2D de entradas (o cadenas, supongo). Se inspira en la respuesta de Jo King . Siento que cortar los dados de la matriz de entrada tomó mucho espacio, por lo que bien podría ser superado. Afortunadamente, tratar con nils solo me costó unos pocos bytes.

Sin 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
}
benj2240
fuente
1

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

Debería haber inventado algo más inteligente.

NikoNyrh
fuente
1

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

Pruébalo en línea!

Felicitaciones a Jonathan Frech por el enfoque de codificación Unicode.

Chas Brown
fuente