रोटेशन अपरिवर्तनीय फिंगरप्रिंटिंग

Question

कल्पना कीजिए कि हमारे पास कुछ पॉलीमिनो हैं और वे विशिष्ट रूप से उनकी पहचान करना चाहेंगे, हालांकि पॉलीमिनोस को घुमाया जा सकता है, इसलिए नेत्रहीन हैशिंग उन्हें एक टुकड़े और उसके रोटेशन (सामान्य रूप में) के लिए एक ही फिंगरप्रिंट नहीं देंगे।

उदाहरण के लिए यदि हमारे पास L-tetromino है

x
x
xx

हम यह चाहेंगे कि इनमें से कोई भी एक ही फिंगरप्रिंट हो:

         xx
  x       x      xxx
xxx  ,    x  or  x

नोट: हम केवल विमान पर घुमाव की अनुमति देते हैं (अर्थात, वे एक तरफा पॉलीमिनोस हैं) और इसलिए निम्नलिखित पॉलोमिनो एक अलग होगा:

 x
 x
xx 

चुनौती

इस चुनौती के लिए कार्य एक फिंगरप्रिंटिंग-फंक्शन / प्रोग्राम को कार्यान्वित करना है जो एक $m\times n$ बुलियन / $0,1$ लेवी मैट्रिक्स / सूचियों की सूची / स्ट्रिंग / ले जाता है। एक पॉलोमिनो को एन्कोडिंग करता है और एक स्ट्रिंग लौटाता है - एक पॉलीमिनो का फिंगरप्रिंट । सभी संभावित घुमाव (सामान्य 4 में) के लिए फिंगरप्रिंट समान होना चाहिए।

इनपुट आउटपुट

• $m \geq 1$ और$n \geq 1$ (यानी। कोई खाली Polyomino)
• आप गारंटी देते हैं कि $m,n$ जितना संभव हो उतना छोटा है (यानी सभी $0$ को $m$ और n को फिट करने के लिए ट्रिम किया गया है$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]]

जे-टेट्रोमिनो:

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

डब्ल्यू 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]]

Comments

संबंधित ।

— ბიმო

अगर मैं हमेशा ""(खाली स्ट्रिंग) आउटपुट करता हूं, तो क्या मैंने सभी आवश्यकताओं को पूरा किया है?

— डैनियल वैगनर

@ डैनियलवाग्नेर: "[..] दो अलग-अलग वर्गों के किसी भी दो पॉलीमिनोस के लिए [उंगलियों के निशान] अलग होना चाहिए " - इसलिए नहीं, यह अमान्य होगा।

— '14:59

किसी सरणी के सभी संभव घुमावों को आउटपुट करना, लगातार मान्य क्रमबद्ध है? उदाहरण

— शैगी

@ शैगी: हाँ, यह सभी मानदंडों को पूरा करेगा।

— ბიმო

Answer 1

पायथन 2 , 48 बाइट्स

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

इसे ऑनलाइन आज़माएं!

सूची तुलना के मामले में चार घुमावों में सबसे बड़ा है। FlipTack के समाधान के आधार पर ।

कोड विभिन्न प्रकार की वस्तुओं की तुलना करने के लिए पायथन 2 की क्षमता का उपयोग करता है। आधार मामले का मूल्य इसके 0लिए हानिरहित है maxक्योंकि यह किसी भी सूची से छोटा है। इसके अलावा, zipइनपुट की सूचियों की सूची के दौरान ट्यूपल्स की एक सूची तैयार करता है, लेकिन ट्यूपल्स सूची की तुलना में बड़े होते हैं, इसलिए इनपुट सूची-ऑफ-सूचियां कभी भी दावेदार नहीं होती हैं। यही कारण है कि हम 4 के बजाय 5 बार घुमाते हैं, ताकि हम प्रारंभिक सूची के एक tuplified संस्करण पर वापस जाएं। (टुपल्स की एक सूची लेना भी कारगर होगा, यदि यह इनपुट का एक स्वीकृत रूप है।)

Answer 2

पायथन 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:])

इसे ऑनलाइन आज़माएं!

Comments

lambda58 के रूप में प्राप्त कर सकते हैं lambda m,M=[]:exec("m=[*zip(*m[::-1])];M+=m,;"*4)or min(M)। काम करता है क्योंकि execहमेशा लौटता है None।

— nedla2004

@ nedla2004 जो केवल एक बार चलाया जा सकता है, और फिर Mपहले से ही आबादी के रूप में

— धूमिल

@ nedla2004 ... लेकिन समस्या के लिए लेखांकन M[-4:]आपको उसी बाइट की गिनती तक पहुंचा सकता है।

— FlipTack

मैं देख रहा हूं, मैं जिस परीक्षण का उपयोग कर रहा था, वह उसी "हैश" के साथ इनपुट की जांच कर रहा था, इसलिए मैं कभी उसमें नहीं भागा। यह समझ आता है।

— nedla2004

Answer 3

जेली , 5 बाइट्स

ZU$ƬṂ

इसे ऑनलाइन आज़माएं!

पूरा कार्यक्रम।

बस सभी संभव रोटेशन उत्पन्न करता है और न्यूनतम lexicographic चुनता है।

ध्यान दें कि सिंगलटन सूची []आउटपुट में नहीं लिपटी हैं । इससे कोई फर्क नहीं पड़ता, क्योंकि एकमात्र मामले में जहां सिंगलटन सूचियां इनपुट में मौजूद होंगी, एक वर्टिकल लाइन (यूनिट पॉलीओमिनो सहित) होगी, जो कि एक ही आकार के साथ एक क्षैतिज रेखा के समान है (जहां लोग लिपटे नहीं हैं) )। एकमात्र मामला जहां बाहरी []मौजूद नहीं होगा या तो यूनिट पॉलोमिनो है।

Comments

जब मैंने चुनौती पढ़ी तो मुझे पता था कि यह होगा :)

— ngn

Answer 4

क्लीन , 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))]

इसे ऑनलाइन आज़माएं!

परीक्षण सत्यापनकर्ता शामिल हैं।

Answer 5

के (ngn / k) , 16 बाइट्स

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

इसे ऑनलाइन आज़माएं!

घुमाव का मिनट

{ } तर्क के साथ कार्य करें x

{+|x}घुमाएँ, अर्थात उल्टा ( |) और पारगमन ( +)

3{ }\मध्यवर्ती परिणामों को संरक्षित करने के लिए 3 बार लागू करें; यह 4 चक्करों की सूची देता है

a: को आवंटित a

< चढ़ना (क्रमबद्ध-बढ़ते क्रमांकन की गणना)

* प्रथम

a@aउस के साथ सूचकांक

Answer 6

जाप -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

Comments

क्या -gझंडा जरूरी है? सॉर्ट का मतलब यह होना चाहिए कि सभी प्रारंभिक घुमाव एक ही सूची के साथ समाप्त होते हैं ताकि पूरी सूची फिंगरप्रिंट के रूप में ठीक काम करे जब तक कि मुझे कुछ याद न हो।

— कामिल दकरी

@KamilDrakari, आप अच्छी तरह से सही हो सकते हैं - जैसे मैंने कहा, मुझे यकीन नहीं है कि मैंने चुनौती को पूरी तरह से समझ लिया है। हालांकि, इसे छोड़ने में कोई बुराई नहीं है, लेकिन यह किसी भी बाइट की लागत नहीं है।

— झबरा

@KamilDrakari: यह आवश्यक नहीं है, लेकिन यह कोई नुकसान भी नहीं है क्योंकि इसे बायटेकाउंट की ओर नहीं गिना जाता है।

— ბიმო

Answer 7

जे , 16 बाइट्स

-2 बाइट्स शैगी को धन्यवाद

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

इसे ऑनलाइन आज़माएं!

जे , 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  

Comments

@ शगुन थैंक्स!

— गैलेन इवानोव

Answer 8

05AB1E , 10 8 बाइट्स

3FÂø})Σ˜

-2 बाइट्स @ शुग्गी को धन्यवाद ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

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। और इसके साथ छँटाई करना {मैट्रिसेस की सूची के लिए काम नहीं करता है, यही कारण है कि मैं Σ˜इसके बजाय उपयोग करता हूं ।

Comments

@ शगुन थैंक्स! :) उस स्थिति में अंतिम दो बाइट्स को हटाया जा सकता है, क्योंकि इसके बाद }अगर कुछ भी नहीं आता है, तो इसका मतलब है।

— केविन क्रूज़सेन

आज मैंने 05AB1E के बारे में कुछ सीखा! :) यह जाप में भी ऐसा ही है।

— झबरा