ลองนึกภาพเรามีบางpolyominoและต้องการที่จะระบุตัวตนของพวกเขา แต่ polyominos สามารถหมุนเพื่อสุ่มสี่สุ่มห้า hashing พวกเขาจะไม่ให้เราลายนิ้วมือเหมือนกันสำหรับชิ้นส่วนและการหมุนดังกล่าว (ทั่วไป)

ตัวอย่างเช่นถ้าเรามี L-tetromino

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 \geq 1$
• คุณรับประกันได้ว่ามีขนาดเล็กที่สุดเท่าที่จะเป็นไปได้ (เช่นทั้งหมดถูกตัดให้พอดีกับและ$m,n$$0$$m$$n$
• คุณรับประกันได้ว่าอินพุตเป็น
  • เชื่อมต่อได้ง่าย
  • ไม่มีหลุม
• เอาต์พุตจะต้องเป็นสตริงที่เหมือนกันสำหรับแต่ละการหมุนของโพลีโนมินที่เป็นไปได้

ตัวอย่าง

นี่คือคลาสที่เทียบเท่าสำหรับแต่ละคลาสนั้นลายนิ้วมือจะต้องเหมือนกัน & สำหรับสองโพลีโม่อสจากคลาสที่แตกต่างกันสองคลาสที่พวกเขาต้องแตกต่างกัน

การหมุนของ L-tetromino จากตัวอย่าง:

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

Polyomino หน่วย:

[[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-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 ไบต์

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) ซึ่งเหมือนกับเส้นแนวนอนที่มีขนาดเท่ากัน ) กรณีเดียวที่ด้านนอก[]จะไม่อยู่อย่างใดอย่างหนึ่งคือหน่วย 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))]

ลองออนไลน์!

รวมถึงการตรวจสอบการทดสอบ

K (ngn / k) , 16 ไบต์

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

ลองออนไลน์!

นาทีของการหมุน

{ } ฟังก์ชั่นที่มีข้อโต้แย้ง x

{+|x}หมุนเช่นย้อนกลับ ( |) และ transpose ( +)

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)

หมายเหตุ: Taking ขั้นต่ำด้วยßหรือโดยปริยายจะแผ่เพื่อส่งออกจะW 0และการเรียงลำดับด้วย{ดูเหมือนจะไม่ทำงานกับรายการเมทริกซ์ซึ่งเป็นเหตุผลที่ฉันใช้Σ˜แทน