Hãy tưởng tượng chúng ta có một số polyomino và muốn xác định duy nhất chúng, tuy nhiên polyominos có thể được xoay, do đó, việc băm chúng một cách mù quáng sẽ không cho chúng ta cùng một dấu vân tay và một vòng quay của chúng (nói chung).

Ví dụ: nếu chúng ta có L-tetromino

x
x
xx

chúng tôi muốn nó có cùng dấu vân tay như bất kỳ thứ nào trong số này:

         xx
  x       x      xxx
xxx  ,    x  or  x

Lưu ý: Chúng tôi chỉ cho phép quay trên mặt phẳng (nghĩa là chúng là polyominos một phía) và do đó polyomino sau sẽ là một dạng khác:

 x
 x
xx 

Thử thách

Nhiệm vụ cho thử thách này là triển khai chức năng / chương trình lấy dấu vân tay, lấy $m\times n$ Boolean / $0,1$ ma trận -valued / danh sách liệt kê / chuỗi / .. mã hóa một polyomino và trả về một chuỗi - dấu vân tay của một polyomino . Dấu vân tay phải bằng nhau cho tất cả các phép quay có thể (nói chung 4).

Đầu ra đầu vào

• $m \geq 1$ và$n \geq 1$ (tức. không polyomino trống)
• bạn được đảm bảo rằng $m,n$ càng nhỏ càng tốt (ví dụ: tất cả $0$ được cắt bớt để phù hợp với $m$ và $n$
• bạn được đảm bảo rằng đầu vào là
  • kết nối đơn giản
  • không có lỗ
• đầu ra phải là một chuỗi giống nhau cho mỗi vòng quay có thể có của một polyomino

Ví dụ

Dưới đây là một số lớp tương đương, đối với mỗi lớp, dấu vân tay phải giống nhau & đối với bất kỳ hai polyominos nào từ hai lớp khác nhau, chúng phải khác nhau.

Các phép quay của L-tetromino từ ví dụ:

[[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-tetromino:

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

Các polyomino đơn vị:

[[1]]

Một thanh $5\times 1$ :

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

Một $2\times 2$ góc:

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

W-pentomino:

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

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

Hãy thử trực tuyến!

Lấy số lớn nhất trong bốn phép quay về mặt so sánh danh sách. Dựa trên giải pháp của FlipTack .

Mã này sử dụng khả năng của Python 2 để so sánh các đối tượng thuộc các loại khác nhau. Giá trị trường hợp cơ bản 0là vô hại maxvì nó nhỏ hơn bất kỳ danh sách nào. Ngoài ra, ziptạo một danh sách các bộ dữ liệu trong khi đầu vào là danh sách các danh sách, nhưng các bộ dữ liệu lớn hơn danh sách để danh sách đầu vào của danh sách không bao giờ là đối thủ. Đây là lý do tại sao chúng tôi xoay 5 lần thay vì 4, để chúng tôi quay lại phiên bản tuplified của danh sách ban đầu. (Lấy danh sách các bộ dữ liệu cũng sẽ hoạt động, nếu đó là một dạng đầu vào được phép.)

Python 3 , 63 byte

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

Hãy thử trực tuyến!

Tìm phép quay với mức tối thiểu từ vựng và in ra.

Một dạng lambda xuất hiện ở cùng một số byte:

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

Hãy thử trực tuyến!

Thạch , 5 byte

ZU$ƬṂ

Hãy thử trực tuyến!

Chương trình đầy đủ.

Đơn giản chỉ cần tạo ra tất cả các phép quay có thể và chọn mức tối thiểu từ vựng.

Lưu ý rằng danh sách singleton không được bao bọc trong []đầu ra. Điều đó không thành vấn đề, vì trường hợp duy nhất mà danh sách đơn lẻ tồn tại trong đầu vào sẽ là một đường thẳng đứng (bao gồm cả polyomino đơn vị), giống như một đường ngang có cùng kích thước (nơi các danh sách không được bọc ). Trường hợp duy nhất mà bên ngoài []sẽ không tồn tại là polyomino đơn vị.

Sạch , 136 byte

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

Hãy thử trực tuyến!

Bao gồm kiểm tra xác minh.

K (ngn / k) , 16 byte

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

Hãy thử trực tuyến!

phút quay

{ } chức năng với đối số x

{+|x}xoay, tức là đảo ngược ( |) và hoán vị ( +)

3{ }\áp dụng 3 lần bảo quản kết quả trung gian; cái này trả về một danh sách 4 phép quay

a: giao cho a

< tăng dần (tính toán hoán vị tăng dần)

* Đầu tiên

a@chỉ số avới điều đó

Japt -g, 6 byte

4Æ=zÃñ

Thử nó

           :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 byte

-2 byte nhờ Shaggy

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

Hãy thử trực tuyến!

J , 18 byte

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

Hãy thử trực tuyến!

Trả về mục đầu tiên trong danh sách các phép quay được sắp xếp theo từ vựng của polyomino.

Giải trình:

            ^:(<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 byte

3FÂø})Σ˜

-2 byte nhờ @Shaggy .

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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)

LƯU Ý: Lấy mức tối thiểu bằng ßhoặc Wsẽ hoàn toàn làm phẳng, do đó sẽ xuất ra 0. Và sắp xếp với {dường như không hoạt động cho một danh sách ma trận, đó là lý do tại sao tôi sử dụng Σ˜thay thế.