Bazı polyomino'muz olduğunu ve bunları benzersiz bir şekilde tanımlamak istediğimizi düşünün , ancak polyominolar döndürülebilir, bu yüzden onları körü körüne hash etmek bize bir parça ve bir rotasyon için aynı parmak izini vermez (genel olarak).

Örneğin, L-tetromino'muz varsa

x
x
xx

bunlardan herhangi biriyle aynı parmak izine sahip olmasını istiyoruz:

         xx
  x       x      xxx
xxx  ,    x  or  x

Not: Sadece düzlemde rotasyonlara izin veriyoruz (yani, tek taraflı polyominos'lardır) ve bu nedenle aşağıdaki polyomino farklı olacaktır:

 x
 x
xx 

Meydan okuma

Bu zorluğun görevi, $m\times n$ Boolean / $0,1$ değerli bir matris / liste / string / .. alan bir parmak izi fonksiyonu / programı uygulamaktır. . Parmak izi, olası tüm rotasyonlar için eşit olmalıdır (genel olarak 4).

Giriş çıkış

• $m \geq 1$ ve$n \geq 1$ (yani boş bir polomino yok)
• $m,n$ olabildiğince küçük olduğu garanti edilir (yani, $0$ tümü $m$ ve n'ye uyacak şekilde kesilir$n$
• girdinin
  • basitçe bağlandı
  • deliği yok
• çıktı bir polyomino'nun olası her dönüşü için aynı olan bir dize olmalıdır

Örnekler

İşte bazı denklik sınıfları, her sınıf için parmak izi aynı olmalı ve iki farklı sınıftan herhangi iki poliomino için farklı olmaları gerekir.

L-tetromino'nun örnekten dönüşleri:

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

Birim polikomino:

[[1]]

Bir $5\times 1$ bar:

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

Bir $2\times 2$ köşe:

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

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

Çevrimiçi deneyin!

Liste karşılaştırması açısından dört rotasyonun en büyüğünü alır. Dayanarak FlipTack çözümüyle .

Kod, Python 2'nin farklı türdeki nesneleri karşılaştırma yeteneğini kullanır. Temel vaka değeri herhangi bir listeden daha küçük olduğu 0için zararsızdır max. Ayrıca, zipgiriş bir liste listesindeyken bir tuples listesi üretir, ancak tuples listelerden daha büyüktür, bu nedenle giriş listelerinin listesi asla bir rakip değildir. Bu yüzden 4 yerine 5 kez döndürüyoruz, böylece ilk listenin geliştirilmiş bir sürümüne geri dönüyoruz. (İzin verilen bir girdi biçimi ise, tuples listesini almak da işe yarayacaktır.)

Python 3 , 63 bayt

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

Çevrimiçi deneyin!

Dönüşü en az lexografik olarak bulur ve yazdırır.

Bir lambda formu aynı bayt sayısında gelir:

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

Çevrimiçi deneyin!

Jöle , 5 bayt

ZU$ƬṂ

Çevrimiçi deneyin!

Tam program.

Sadece tüm olası dönüşleri üretir ve sözlük minimumunu seçer.

Tekton listelerinin kaydırılmadığını unutmayın [] çıktıya . Girişte singleton listelerinin var olacağı tek durum, aynı boyuttaki yatay bir çizgi ile aynı olan dikey bir çizgi (birim poliomino dahil) olacağından, ). Dış []tarafın da bulunmayacağı tek durum birim poliminondur.

Temiz , 136 bayt

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

Çevrimiçi deneyin!

Test doğrulayıcıyı içerir.

K (ngn / k) , 16 bayt

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

Çevrimiçi deneyin!

dönme dakikası

{ } argüman ile işlev x

{+|x}döndür, yani ters ( |) ve transpoze ( +)

3{ }\ara sonuçları koruyarak 3 kez uygulayın; bu 4 rotasyonun bir listesini döndürür

a: atamak a

< ascend (sıralama artan permütasyonu hesapla)

* ilk

a@abununla dizin

Japt -g, 6 bayt

4Æ=zÃñ

Dene

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

Shaggy sayesinde -2 bayt

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

Çevrimiçi deneyin!

J , 18 bayt

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

Çevrimiçi deneyin!

Polyomino'nun lexicograpically sort rotasyonları listesindeki ilk öğeyi döndürür.

Açıklama:

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

3FÂø})Σ˜

@Shaggy sayesinde -2 bayt .

Çevrimiçi deneyin veya tüm test senaryolarını doğrulayın .

Açıklama:

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)

NOT: Minimum ile almak ßveya Wdolaylı olarak düzleştirmek, böylece çıktı0 . Ve sıralama, {bir matris listesi için işe yaramaz gibi görünüyor, bu yüzden Σ˜bunun yerine kullanıyorum.