Представьте, что у нас есть некоторые polyomino и мы хотели бы однозначно идентифицировать их, однако polyominos можно вращать, поэтому слепое их хеширование не даст нам одинаковых отпечатков пальцев для части и ее поворота (в целом).

Например, если у нас есть L-тетромино

x
x
xx

мы хотели бы иметь такой же отпечаток пальца, как любой из них:

         xx
  x       x      xxx
xxx  ,    x  or  x

Примечание. Мы допускаем только повороты на плоскости (т. Е. Они являются односторонними многочленами), и поэтому следующий полиомино будет другим:

 x
 x
xx 

Вызов

Задача для этой задачи состоит в том, чтобы реализовать функцию / программу снятия отпечатков пальцев, которая принимает булеву / -значную матрицу / список списков / строку / .., кодирующую polyomino, и возвращает строку - отпечаток пальца Полимин. Отпечаток пальца должен быть одинаковым для всех возможных поворотов (в общем 4).$m\times n$$0,1$

Ввод, вывод

• $m \geq 1$n ≥ 1 и (т. е. нет пустого polyomino)$n \geq 1$
• вы гарантировано, что настолько малы, насколько это возможно (т.е. все обрезаются, чтобы соответствовать и$m,n$$0$$m$$n$
• вы гарантировано, что вход
  • просто подключен
  • не имеет отверстий
• вывод должен быть строкой, которая является одинаковой для каждого возможного поворота polyomino

Примеры

Вот некоторые классы эквивалентности, для каждого класса отпечаток должен быть одинаковым, а для любых двух полиоминиумов из двух разных классов они должны отличаться.

Вращения L-тетромино из примера:

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

J-тетромино:

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

Блок полиомино:

[[1]]

$5\times 1$ бар:

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

$2\times 2$ угол:

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

W-пентомино:

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

Python 2 , 48 байт

f=lambda l,z=5:z and max(l,f(zip(*l)[::-1],z-1))

Попробуйте онлайн!

Принимает самое большое из четырех вращений с точки зрения сравнения списка. Основано на решении FlipTack .

Код использует способность Python 2 сравнивать объекты разных типов. Базовое значение 0безвредно, maxпоскольку оно меньше любого списка. Кроме того, zipвыдает список кортежей, в то время как входные данные представляют собой список списков, но кортежи больше, чем списки, поэтому входной список списков никогда не является претендентом. Вот почему мы вращаемся 5 раз, а не 4, чтобы мы вернулись к дублированной версии исходного списка. (Взятие списка кортежей также будет работать, если это допустимая форма ввода.)

Python 3 , 63 байта

def f(m):M=[];exec("m=[*zip(*m[::-1])];M+=m,;"*4);return min(M)

Попробуйте онлайн!

Находит вращение с лексографическим минимумом и печатает его.

Лямбда-форма входит с тем же количеством байтов:

lambda m,M=[]:exec("m=[*zip(*m[::-1])];M+=m,;"*4)or min(M[-4:])

Попробуйте онлайн!

Желе , 5 байт

ZU$ƬṂ

Попробуйте онлайн!

Полная программа.

Просто генерирует все возможные повороты и выбирает лексикографический минимум.

Обратите внимание, что одноэлементные списки не включаются в []вывод. Это не имеет значения, поскольку единственным случаем, когда на входе будут существовать одноэлементные списки, будет вертикальная линия (включая единицу polyomino), которая совпадает с горизонтальной линией с таким же размером (где те не обернуты ). Единственный случай, когда внешнее []тоже не будет существовать - это единица полиомино.

Чисто , 136 байт

import StdEnv,Data.List
r=reverse;t=transpose;f=flatten
$l=[if((a==b)==(c==d))'x''X'\\a<-f l&b<-f(r(map r l))&c<-f(r(t l))&d<-f(t(r l))]

Попробуйте онлайн!

Включает в себя тестовый верификатор.

К (нгн / к) , 16 байт

{a@*<a:3{+|x}\x}

Попробуйте онлайн!

мин оборотов

{ } функция с аргументом x

{+|x}повернуть, т.е. перевернуть ( |) и переставить ( +)

3{ }\применять 3 раза, сохраняя промежуточные результаты; это возвращает список из 4 вращений

a: назначить в a

< вознесение (вычисление сортировки по возрастанию)

* первый

a@индекс aс этим

Japt -g, 6 байт

4Æ=zÃñ

Попытайся

           :Implicit input of 2d-array U
4Æ         :Map the range [0,4)
   z       :  Rotate U 90 degrees
  =        :  Reassign to U
    Ã      :End map
     ñ     :Sort
           :Implicit output of first element

J , 16 байт

-2 байта благодаря Shaggy

[:/:~|.@|:^:(<4)

Попробуйте онлайн!

J , 18 байт

0{[:/:~|.@|:^:(<4)

Попробуйте онлайн!

Возвращает первый элемент в списке лексикографически отсортированных вращений полиомино.

Объяснение:

            ^:(<4)  - do the verb on the left 4 times, storing all the steps
       |.@|:        - tranpose and reverse
    /:~             - sort up the 4 matrices
  [:                - cap the fork
0{                  - take the first matrix  

05AB1E , 10 8 байт

3FÂø})Σ˜

-2 байта благодаря @Shaggy .

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

3F  }       # Loop 3 times
  Â         #  Bifurcate (short for Duplicate & Reverse) the top of the stack
            #  (which is the input-matrix implicitly the first iteration)
   ø        #  Transpose: swap rows/columns
     )      # After the loop, wrap everything on the stack in a list
      Σ˜    # Sort this list of matrices by their flattened array (and output implicitly)

ПРИМЕЧАНИЕ. Принятие минимума с ßили Wбудет неявно сглаживаться, поэтому будет выводиться 0. И сортировка с помощью {, кажется, не работает для списка матриц, поэтому я использую Σ˜вместо этого.