Скільки коштує моя матриця кубиків?


21

Вхідні дані

Непорожня двійкова матриця, що складається з 3х3 підматриць, розміщених поруч.

Завдання

Ваше завдання - визначити дійсні шаблони кісток (як описано нижче) серед підматриць 3x3. Кожен дійсний зразок вартує значення відповідних кісток. Недійсні візерунки мають значення 0.

Вихідні дані

Сума дійсних значень кісток.

Шаблони з кістки

1:(0,0,00,1,00,0,0)2:(1,0,00,0,00,0,1)або(0,0,10,0,01,0,0)3:(1,0,00,1,00,0,1)або(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)або(1,1,10,0,01,1,1)

Приклад

Очікуваний вихід для наступної матриці дорівнює 14, оскільки вона містить кубики 5 , 6 і 3 , за якими слідує недійсний шаблон (зліва направо і зверху вниз).

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

Правила

  • І ширина, і висота матриці гарантовано кратні 3.
  • Ви повинні проігнорувати підматриці, які неправильно вирівняні в сітці (див. 3-й тестовий випадок). Більш офіційно та припускаючи 0-індексацію: координати верхньої лівої комірки кожної підматриці, що розглядається, мають вигляд .(3х,3у)
  • Це .

Тестові кейси

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

Відповіді:


5

Пітон 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 байт
Істон Борнемейер


Позбудьтесь обох примірників //3та використовуйте '0'+''.join...для збереження двох байтів :)
Джонатан Аллан

... поєднайте це з перерахуванням, щоб зберегти ще два: ось
Джонатан Аллан


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

Спробуйте в Інтернеті!

Я помітив, що маю таку ж думку про @Heteira

Історія:

  • 171 : -10 байт завдяки @JayCe!
  • 161 : -3 байти завдяки @Giuseppe!
  • 158 : -13 байт збережено!
  • 145 : -2 байти завдяки @Giuseppe!
  • 143 : -6 байт збережено!
  • 137 : -3 байти завдяки @JayCe!

1
збережіть 5 байтів, стиснувши список номерів - посилання на приклади занадто довгі, щоб залишити коментар
JayCe

1
Ще 3 байти з використаннямdim
JayCe


1
Є додаткова пара дужок, навколо (2^(8:0))яких можна видалити.
Джузеппе

1
Я додаю забуте до catвиводу intToUtf8: зберегти 3 байти
JayCe

4

Perl 6 , 113 105 97 94 байт

{sum (|@_[*;^3+3*$_]for ^@_[0]).rotor(9).map:{"@āđŅŕLJ@@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 
        "@āđŅŕ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

Желе ,  29 28 байт

-1 дякую містеру Xcoder (використовуйте для заміни ṢṪ)

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

Монадійне посилання.

Спробуйте в Інтернеті! Або запустити тести .

Як?

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на кодовій сторінці Jelly )


може працювати замість ṢṪ-1.
Містер Xcoder

... так, це буде (я думав, що я економив над використанням M>. <). Чи можна щось розумне зробити з ŒṪмене цікаво ...
Джонатан Аллан


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×33×н

¶

M!`.{9}

Об'єднайте всі блоки разом, а потім розділіть їх на 9 рядків.

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

Зберігайте лише дійсні шаблони кісток (два шаблони для 6, тоді один відповідає будь-якому номеру від 0до 5, хоча, 0звичайно, не сприятиме підрахунку нижче.)

1

Порахуйте кіски на дійсних кубиках.


1

Рубін , 151 байт

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

Спробуйте в Інтернеті!

Лямбда, що приймає 2d масив ints (або рядків, я думаю). Черпає натхнення у відповіді Джо Кінга . Мені здається, що нарізання кісток із матриці входу зайняло багато місця, тому я цілком міг перемогти. На щастя, робота з нулями лише коштувала мені кілька байтів.

Безголівки:

->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 байт

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

Я мав би придумати щось розумніше.


Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.