क्या यह वर्ग सममित है?

Question

एक प्रोग्राम या फ़ंक्शन लिखिए जो 4 × 4 टेक्स्ट ग्रिड में होता है जिसमें वास्तव में 4 A's, 4 B' s, 4 C's और 4 D' s शामिल होते हैं:

ACDC
BBCA
BADD
ABCD

ABCDकी किसी व्यवस्था में हो सकता है लेकिन वहाँ हमेशा प्रत्येक के 4 हो जाएगा। आप मान सकते हैं कि इनपुट वैध है। यदि आप चाहें तो यह भी मान सकते हैं कि इसमें एक नई रूपरेखा है और / या यह पढ़ने के क्रम में एक पंक्ति के रूप में आती है, उदा ACDCBBCABADDABCD। यदि वांछित (लेकिन यह सब है) तो आप वर्णों ABCDको क्रमशः 0123या 1234क्रमशः बदल सकते हैं ।

यदि टेक्स्ट ग्रिड में चिंतनशील या घूर्णी समरूपता है, तो एक सत्य मान का उत्पादन करें। विशेष रूप से:

• यदि समरूपता की एक केंद्रीय क्षैतिज रेखा है। जैसे

  BACD
  BACD 
  BACD \___ bottom mirrors top
  BACD /
  

• यदि सममिति की एक केंद्रीय ऊर्ध्वाधर रेखा है। जैसे

  BCCB
  DAAD
  CAAC
  BDDB
    \/___ right mirrors left
  

• यदि समरूपता की एक विकर्ण रेखा है (दोनों दिशा में)। जैसे

       ___ diagonally mirrored
      /
  ABDC
  BACD
  DCAB
  CDBA
      \___ diagonally mirrored
  

• यदि 90 ° घूर्णी समरूपता है। जैसे

  BDAB
  ACCD    same if rotated 90 degrees (or 180 or 270)
  DCCA
  BADB
  

• यदि 180 ° घूर्णी समरूपता है। जैसे

  DBCA
  BDCA    same if rotated 180 degrees
  ACDB
  ACBD
  

(ध्यान दें कि अनुवादिक समरूपता यहाँ खेलने में नहीं आती है।)

यदि ग्रिड में ऊपर वर्णित समरूपताओं में से एक नहीं है, तो एक मिथ्या मूल्य का उत्पादन करें। उदाहरण के लिए बहुत पहले उदाहरण ग्रिड।

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

क्या हम इनपुट के रूप में चार स्ट्रिंग्स की सूची ले सकते हैं?

— मार्टिन एंडर

@MartinEnder हाँ, ठीक है।

— केल्विन के शौक

मैंने अभी पढ़ा और सोचा कि "नोप" लोल

— शॉन वाइल्ड

यदि आप वर्ग को टाइल करने के लिए सोचते थे तो आप अनुवाद संबंधी समरूपता को भी ध्यान में रख सकते थे।

— नील

@ Adám No. कोई और इनपुट प्रारूप नहीं। मुझे लगता है कि मुझे वास्तव में मार्टिन की अनुमति नहीं देनी चाहिए थी।

— केल्विन के शौक

Answer 1

सीजेएम, 16 बाइट्स

{{z_W%_}4*;])e=}

एक अनाम ब्लॉक जो इनपुट को ढेर के ऊपर चार तारों की एक सूची के रूप में उम्मीद करता है और 0असममित इनपुट के लिए एक (झूठा) छोड़ देता है और सममितीय इनपुट के लिए एक सकारात्मक पूर्णांक (सत्य)।

इसका परीक्षण यहां करें। या एक पूर्ण परीक्षण सूट चलाते हैं।

व्याख्या

वर्ग के समरूपता क्रम 8 के विकर्ण समूह के तत्व हैं (जो वर्ग के सिर्फ 4 घुमाव हैं और वर्ग के कुछ परिलक्षित संस्करण के समान 4 घुमाव)। एक एकल क्रमचय के बार-बार आवेदन से इस समूह को उत्पन्न करना संभव नहीं है। लेकिन दो प्रतिबिंब हमेशा कुछ रोटेशन देते हैं। इसलिए, पूरे समूह को दो प्रतिबिंबों के बीच चार बार बारी-बारी से उत्पन्न किया जा सकता है। (हमें केवल यह सुनिश्चित करने की आवश्यकता है कि दो प्रतिबिंब 90 डिग्री या 270 डिग्री रोटेशन दें, न कि 0 या 180।)

चुनौती पूछती है कि क्या इनपुट वर्ग अन्य 7 समरूपताओं में से किसी के बराबर है। तो यह जवाब बस उन सभी को उत्पन्न करता है और फिर जाँचता है कि इनपुट दूसरों के बीच है या नहीं।

{      e# Run this block 4 times.
  z_   e# Transpose the grid and duplicate it. (This is one type of reflection.)
  W%_  e# Reverse the lines and duplicate it. (This is another type of
       e# reflection. Together they rotate the grid by 90 degrees.)
}4*    e# The last element will be the original grid again.
;      e# Discard one copy of that original grid.
]      e# Wrap all symmetries in a list.
)      e# Pull off the original grid.
e=     e# Count how many times it appears among the other symmetries.

यह देखने के लिए कि किस प्रकार दोहराया गया zऔर W%सभी समरूपता उत्पन्न करता है, इस "आरेख" पर एक नज़र डालें:

     0123
     4567
     89ab
     cdef

     original

 z   048c       W%       37bf
-->  159d  ----------->  26ae
     26ae                159d
     37bf                048c

     diag. refl.         rot. 90 degrees ccw

 z   3210       W%       fedc
-->  7654  ----------->  ba98
     ba98                7654
     fedc                3210

     vert. refl.        rot. 180 degrees

 z   fb73       W%       c840
-->  ea62  ----------->  d951
     d951                ea62
     c840                fb73

     antidiag. refl.     rot. 270 degrees ccw

 z   cdef       W%       0123
-->  89ab  ----------->  4567
     4567                89ab
     0123                cdef

     horiz. refl.        original

Comments

वाह, क्या आप इसे समझा सकते हैं? क्या आपके पास सभी घुमाव / फ़्लिप के लिए अंतर्निहित है?

— अदम

@ Adám मैं थोड़ा सा पूर्ण विवरण जोड़ूंगा, लेकिन zट्रांज़ोज़ है और W%लाइनों को उलट देता है, इसलिए मैं केवल उन लोगों के बार-बार आवेदन करके सभी समरूपता पैदा कर रहा हूं।

— मार्टिन एंडर

बेशक, पहले मूल्य के बारे में कुछ खास नहीं है, लेकिन दुख की बात यह है कि मतगणना के अधिक शुद्धतावादी दृष्टिकोण है कि क्या आपको 8 अलग-अलग मूल्य मिलते हैं, इसकी लागत अधिक है।

— पीटर टेलर

Answer 2

अजगर, 11 बाइट्स

<7.u?%Y2CN_

परीक्षण सूट

यह मार्टिन के पारगमन और रिवर्स तकनीक का उपयोग करता है, लेकिन एक मोड़ के साथ। जबकि अन्य समाधानों ने स्पष्ट रूप से सभी 8 समरूपताएं उत्पन्न की हैं, फिर मूल के दिखावे की संख्या गिना, यह कार्यक्रम पायथ के .uफ़ंक्शन का उपयोग करता है ।

.uसमारोह "जब तक दोहराने पाया जाता है लागू करें" है। इस मामले में, हम वैकल्पिक रूप से स्थानांतरित करते हैं और दोहराते हैं जब तक कि पुनरावृत्ति नहीं होती है, तब परिणामों को एक सूची में जमा करते हैं। फिर, मैं पिछले 7 मूल्यों को हटाता हूं, इसलिए केवल एक मूल्य शेष होगा यदि कोई समरूपता नहीं थी, और सभी 8 प्रतिबिंब और पुनरावृत्ति उत्पन्न होने के बाद पहली पुनरावृत्ति हुई।

स्पष्टीकरण:

<7.u?%Y2CN_
<7.u?%Y2CN_NQ    Implicit variables
                 Q = eval(input())
  .u        Q    Starting with Q, apply the following until a repeat occurs, 
                 then accumulate all values into a list.
    ?%Y2         If the iteration number is odd
        CN       Transpose
          _N     Else reverse
<7               Remove the last 7 results

Answer 3

05AB1E , 13 बाइट्स

4Fø€JÂD}\\)¹å

व्याख्या

मार्टिन द्वारा अपने सीजेएम उत्तर में विशेषज्ञ द्वारा बताई गई विधि का उपयोग करता है ।

4F     }       # 4 times do:
  ø€J          # zip and join each
     ÂD        # bifurcate, duplicate
        \\     # delete the top 2 items on the stack
          )    # wrap stack in list
           ¹å  # check if input is in that list

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

Answer 4

पर्ल, 61 60 बाइट्स

के लिए +3 शामिल है -p0a

एसटीडीआईएन पर इनपुट स्क्वायर दें, कोई समरूपता के लिए 0 प्रिंट करता है, अन्यथा कुछ सकारात्मक संख्या

./symmetry.pl
DBCA
BDCA
ACDB
ACBD
^D

symmetry.pl:

#!/usr/bin/perl -p0a
s,.,chop$F[$i++/($j-4?1:4)%4],eg;$\+=$$_++;++$j<8&&redo}{

Answer 5

डायलाग एपीएल , 37 19 17 बाइट्स

@ng ने इसे 20 बाइट्स तक घटा दिया!

8>≢(∪⊢,⌽¨,⍉¨)⍣≡⊂⎕

TryAPL ऑनलाइन!

Comments

⍉¨⌽∘⍉¨कामों के बजाय भी।

— NGN

@ngn किया। धन्यवाद। कल मिलते हैं।

— अड्म

Answer 6

ब्रेकीलॉग , 38 36 बाइट्स

@eL:1fbeL
(L;?:raL)(.;L$\.;L$/.;Lr.)

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

यह इनपुट के रूप में तार की एक सूची की उम्मीद करता है। यह true.या तो प्रिंट करता है false.।

व्याख्या

• मुख्य विधेय:

  @eL    Split each line into a list of chars ; call that list of lists L
  :1f    Find all symmetries
  b      Remove the first one (the identity)
  eL     L is an element of that list of symmetries
  

• 1 समर्पित करें: आउटपुट इनपुट के 8 समरूपों में से एक है।

  (
      L             L = Input
  ;             Or
      ?:raL         L = reverse all lines of the input
  )
  (
      .             Output = L
  ;             Or
      L$\.          Output = transpose of L    
  ;             Or
      L$/.          Output = antitranspose of L
  ;             Or
      Lr.           Output = reverse of L
  )
  

Answer 7

TSQL, 229 बाइट्स

ज्ञात हो कि TSQL में घूर्णन के लिए कोई बिल्ड-इन नहीं है, इसलिए यह कोड में शामिल है।

golfed:

DECLARE @1 char(16)=
'BCCBDAADCAACBDDB'

,@i INT=0,@ varchar(16)=''WHILE @i<16SELECT @+=substring(@1,@i*4%16+@i/4+1,1),@i+=1SELECT sign(count(*))FROM(SELECT LEFT(x,8)a,RIGHT(x,4)b,substring(x,9,4)c FROM(values(@1),(@))x(x))x WHERE c+b=reverse(a)or a=reverse(b+c)or a=b+c

Ungolfed:

DECLARE @1 char(16)=
'BCCBDAADCAACBDDB'

,@i INT=0,@ varchar(16)=''
WHILE @i<16
  SELECT @+=substring(@1,@i*4%16+@i/4+1,1),@i+=1

SELECT sign(count(*))
FROM
  (SELECT LEFT(x,8)a,RIGHT(x,4)b,substring(x,9,4)c
   FROM(values(@1),(@))x(x))x
WHERE c+b=reverse(a)or a=reverse(b+c)or a=b+c

बेला

Answer 8

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

यह जाँचता है कि क्या कोई आवश्यक परिवर्तन संख्यात्मक सारणी का उपयोग करते हुए मूल के बराबर है। इनपुट को चार तार की सूची के रूप में लिया जाता है।

from numpy import*
A=array(map(list,input()))
R=rot90
T=transpose(A)
print any([all(A==Z)for Z in(A[:,::-1],A[::-1],R(A),R(A,2),R(A,3),T,R(T,2))])

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

सिंगल स्ट्रिंग के रूप में इनपुट लेना एक चार लंबा है, साथ में A=array(list(input())).reshape(4,4)। A[:,::-1]के रूप में ही है fliplr(A)। A[::-1]के रूप में ही है flipud(A)।

Comments

शायद के map(list,input())बजाय का उपयोग करें[list(r)for r in input()]

— Cyoce

@Cyoce धन्यवाद। Idk मैं कैसे चूक गया।

— mbomb007

anyएक जनरेटर अभिव्यक्ति लेता है, इसलिए आप वर्ग ब्रैकेट की बाहरी जोड़ी को गिराकर कुछ बाइट्स बचा सकते हैं।

— TheBikingViking

@ TheBikingViking मैंने पहले ही कोशिश कर ली थी। यदि आप एक जनरेटर पास करते हैं, तो यह एक जनरेटर देता है, जिससे printबयान काम नहीं करता है। मेरे ऑनलाइन कोड को डाउनलोड करने और इसे देखने के लिए इस तरह से चलाने का प्रयास करें।

— mbomb007

आह अच्छा। मुझे एहसास नहीं था कि यह टूट जाएगा print।

— TheBikingViking

Answer 9

पायथन 3, 99 बाइट्स

def f(x):
 t=x;c=[]
 for i in range(7):*t,=[map(''.join,zip(*t)),t[::-1]][i%2];c+=t,
 return x in c

एक फ़ंक्शन जो इनपुट लेता है, तर्क के माध्यम से, स्ट्रिंग्स और रिटर्न की सूची Trueया Falseप्रासंगिक के रूप में।

यह @ मार्टिनएंडर के उत्तर के समान दृष्टिकोण का उपयोग करता है ।

यह काम किस प्रकार करता है

def f(x)                Function with input list of strings x
 t=x;c=[]               Initilaise temporary square t and combination list c
 for i in range(7):...  For i in range [0,6]:
 [...][i%2]              If i is even:
 zip(*t)                  transpose(t)
 *t,=map(''.join,...)     t = t with each line concatenated (such that t is in the same
                          format as x)
                         Else:
 *t,=t[::-1]              t = reverse(t)
 c+=t,                   Append t to c
 return x in c           Return True if x is in c else return False

Ideone पर इसे आज़माएं

Answer 10

जावास्क्रिप्ट (ईएस 6), 131 बाइट्स

s=>[...`0101010`].map(c=>+c?``+b.reverse():`${b=b.map((s,i)=>s.replace(/./g,(_,j)=>b[j][i]))}`,b=a=s.match(/..../g)).includes(``+a)

यदि आप सीधे 4 तार की एक सरणी पास करते हैं तो 17 बाइट्स निकाले जा सकते हैं। मैंने बिट-ट्विडलिंग ( "0123301223011230"प्रारूप में इनपुट ) की कोशिश की, लेकिन मुझे 199 बाइट्स ले गए:

s=>[...'0101010'].map(c=>r=+c?r<<24&255<<24|r<<8&255<<16|r>>8&255<<8|r>>>24:r&0xc0300c03|r<<6&806093568|r<<12&3075<<16|r<<18&3<<24|r>>6&0xc0300c|r>>12&49200|r>>18&192,r=n=parseInt(s,4)|0).includes(n)