द्विआधारी मैट्रिक्स उत्पन्न करें जो प्रतिबिंबों तक अलग हैं

Question

यहां सभी 2x2 बाइनरी मैट्रिसेस हैं

#0  #1  #2  #3  #4  #5  #6  #7  #8  #9  #10 #11 #12 #13 #14 #15
--  --  --  --  --  --  --  --  --  --  --  --  --  --  --  --  
00  00  00  00  01  01  01  01  10  10  10  10  11  11  11  11  
00  01  10  11  00  01  10  11  00  01  10  11  00  01  10  11  

दो बाइनरी स्क्वायर मैट्रिसेस रिलेशन के तहत बराबर होते हैं ~यदि किसी को क्षैतिज या वर्टिकल वेस में किसी भी संख्या पर प्रतिबिंब द्वारा मैप किया जा सकता है ।

#1 ~ #2ऊर्ध्वाधर अक्ष में प्रतिबिंब के तहत इसलिए हमें केवल इनमें से एक को रखने की आवश्यकता है (यह कोई फर्क नहीं पड़ता कि कौन सा)। इसी तरह #3 ~ #12, #6 ~ #9और इसी तरह ।

लक्ष्य एक ऐसा प्रोग्राम तैयार करना है जो एक एकल इनपुट लेता है Nऔर कई N x Nबाइनरी मैट्रिसेस के रूप में प्रिंट करता है जैसे कि आउटपुट में सभी मैट्रिसेस उपरोक्त संबंध के तहत अलग हैं।

हाथ से लहरदार छद्मकोड में, एक स्वीकार्य समाधान होगा

define M[i] = N by N matrix with bit pattern equal to i

for i = 0 to (2^(N^2)) - 1
    valid = true
    for j = i+1 to (2^(N^2)) - 1
        if (equivalent(M[i], M[j]))
            valid = false
            break
    if (valid)
        print (M[i])

इनपुट के लिए N=2एक वैध आउटपुट होगा

00  00  00  01  10  01  11
00  01  11  01  01  11  11

लेकिन एक ही समतुल्य वर्ग से अलग-अलग मैट्रिस का चयन करके एक और वैध आउटपुट होगा

00  10  11  11  11  10  01
00  00  00  10  11  10  10

मैट्रिसेस का क्रम मायने नहीं रखता, समतुल्य मैट्रिस से विशेष पसंद कोई फर्क नहीं पड़ता, और व्हाट्सएप कोई फर्क नहीं पड़ता, हालांकि मैट्रिसेस को आउटपुट करते हैं जब तक कि आप मानव-पठनीय हैं।

आउटपुट संपूर्ण होना चाहिए।

सबसे छोटा कोड जीतता है।

संपादित करें: यह मेरी पहली गोल्फ पोस्ट है और मैंने अपने मानदंड को जीत के मापदंड पर बदल दिया है।

किसी भाषा में सबसे छोटा कोड विशेष रूप से संक्षिप्तता / गोल्फ जीत के लिए नहीं बनाया गया है ।

मुझे उम्मीद है कि इस कसौटी के बाद के पद को बदलने के लिए यह बुरा शिष्टाचार नहीं है, लेकिन मुझे लगता है कि इसे "सामान्य" भाषा में करना अधिक दिलचस्प प्रस्ताव है।

Comments

PPCG में आपका स्वागत है! यह एक अच्छी पहली चुनौती है, लेकिन मैं लोगों को एक लचीले प्रारूप में परिणाम देने की सलाह दूंगा (उदाहरणों की सूची के रूप में प्रत्येक मैट्रिक्स)। इस तरह से लोग चुनौती के बहुत दिलचस्प मूल पर ध्यान केंद्रित कर सकते हैं (सममितियों तक अद्वितीय मैट्रिस ढूंढना) इसके बजाय आउटपुट स्वरूपण के बारे में चिंता करने के लिए (जो आसानी से बस कई बाइट्स ले सकता है और मुख्य चुनौती की गोल्फिंग कम कर सकता है महत्वपूर्ण)।

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

प्रतिक्रिया के लिए धन्यवाद, आप दोनों, मैंने तदनुसार प्रश्न संपादित किया है।

— स्पै्रफ

मुझे एक समतुल्यता के रूप में घुमाव शामिल करने के लिए लुभाया गया था। मुझे प्रत्येक बिट को समतुल्यता के रूप में सम्मिलित करने का भी लालच था। मुझे एक समानता के रूप में पंक्तियों / स्तंभों के क्रमपरिवर्तन को शामिल करने के लिए भी लुभाया गया था। अंत में, मैंने आवश्यकताओं को काफी सरल रखने के लिए एक मनमाना निर्णय लिया। एक बदलाव पोस्ट करने के लिए स्वतंत्र महसूस करें।

— स्पै्रफ

हमने अतीत में इस पर चर्चा की है और कोड गोल्फ प्रतियोगिताओं में कुछ भाषाओं को छोड़कर या दंडित करने के खिलाफ शासन किया है , जिसका अर्थ है कि चुनौती जो ऐसा करती है उसे विषय से अलग माना जाना चाहिए। इसके अलावा, स्वीकृत उत्तर चुनौती को जीतने वाला उत्तर है , जिसका अर्थ है कोड गोल्फ सवालों के लिए सबसे छोटा कोड। सारांश: आप किसी भी सवाल का जवाब स्वीकार करने के लिए नहीं करना चाहते हैं सब पर है, तो नहीं है। हालाँकि, यदि आप एक उत्तर को स्वीकार करते हैं, तो उसे सबसे छोटा होना चाहिए।

— डेनिस

अंत में, जम्मू भाषा है नहीं एक गोल्फ भाषा है, लेकिन एक उच्च स्तरीय, सामान्य प्रयोजन, उच्च प्रदर्शन प्रोग्रामिंग भाषा है जो 25 साल के लिए ही अस्तित्व में है। यहां तक ​​कि अपने वर्तमान नियमों के साथ, आपने अभी भी गलत उत्तर को स्वीकार किया है।

— डेनिस

Answer 1

जे, 66 56 53 बाइट्स

[:~.,~{.@/:~@(2:_&(][:,(;|.;|."1)&>)<)@$"#.2#:@i.@^*:

जानवर बल खोज।

प्रयोग

   f =: [:~.,~{.@/:~@(2:_&(][:,(;|.;|."1)&>)<)@$"#.2#:@i.@^*:
   f 2
┌───┬───┬───┬───┬───┬───┬───┐
│0 0│0 0│0 0│0 1│0 1│0 1│1 1│
│0 0│0 1│1 1│0 1│1 0│1 1│1 1│
└───┴───┴───┴───┴───┴───┴───┘
   # f 3
168
   # f 4
16576

व्याख्या

[:~.,~{.@/:~@(2:_&(][:,(;|.;|."1)&>)<)@$"#.2#:@i.@^*:  Input: integer n
                                                   *:  Square n
                                           2      ^    Compute m = 2 ^ (n ^ 2)
                                               i.@     Make a range [0, m)
                                            #:@        Convert each to binary digits
    ,~                                                    Pair, make [n, n]
                                       $"#.            Reshape each binary list
                                                          to a matrix with size [n, n]
             (                       )@                Operate on each
                                    <                    Box it, call x
              2:                                         The constant 2
                _&(                )                     Repeat that many times on x
                       (        )&>                        For each box
                            |."1                             Reverse by column
                         |.                                  Reverse by row
                           ;                                 Join them
                        ;                                    Join with initial
                    [:,                                    Flatten
                   ]                                       Return that as the new x
         /:~@                                          Sort each
      {.@                                              Take the head of each
[:~.                                                   Unique and return

Answer 2

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

Ṛ€;U;
2ḶṗṗµWdz¡Ṃµ€Q

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

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

2ḶṗṗµWdz¡Ṃµ€Q  Main link. Argument: n (integer)

2Ḷ             Unlength 2; yield [0, 1].
  ṗ            Cartesian product; construct all vectors of {0, 1}^n.
   ṗ           Cartesian product; construct all vectors of ({0, 1}^n)^n.
               This yields A, the array of all binary n×n matrices.
    µ     µ€   Begin a new, monadic chain and apply it to all matrices M in A.
     W           Wrap; yield [M].
      dz¡        Call the helper link n times, initially with argument [M], then
                 on the previous return value.
         Ṃ       Take the minimum of the results.
               This replaces all matrices with the lexicographical minimum of their
               equivalence classes, mapping equivalent matrices to the same matrix.
            Q  Unique; deduplicate the resulting array of matrices.

Ṛ€;U;          Helper link. Argument: L (array of matrices)

Ṛ€             Reverse the order of the rows of each M in L.
   U           Reverse the order of the columns of each M in L.
  ;            Concatenate the resulting matrix arrays.
    ;          Concatenate the result with L.

Answer 3

पायथ - 24 23 21 बाइट्स

सभी प्रतिबिंब प्राप्त करने का बेहतर तरीका तलाशना चाहते हैं।

मुझे 2 बाइट्स देने के लिए @ Pietu1998 का ​​धन्यवाद!

hM.gS+K_Bk_MMKcRQ^`T*

इसे यहाँ ऑनलाइन आज़माएँ ।

पूरी व्याख्या करने से पहले गोल्फिंग की प्रतीक्षा करने के लिए जा रहा है, लेकिन यह अनिवार्य रूप से सभी संभव बाइनरी .gमैट्रिस बनाता है, फिर उन्हें सभी संभावित प्रतिबिंबों की क्रमबद्ध सूची द्वारा रौप करता है, फिर केवल प्रत्येक समूह से एक लेता है।

Comments

अगर मुझे लगता है कि तर्क 3के साथ आउटपुट शुरू होता है [['000', '000', '00'],तो लापता शून्य को ध्यान दें।

— स्पै्रफ

@spraff वूप्स, मैंने इसके ^2Qबजाय किया Q^2। फिक्स मुझे एक बाइट भी बचाता है:

— माल्टीसेन

@spraff ने इसे ठीक किया।

— माल्टीसेन

मुझे पूरा यकीन है कि आप _MMइसके बजाय कर सकते हैं mC_Cd।

— पुरकाकूदरी

@ Pietu1998 ओह हाँ, धन्यवाद!

— माल्टीसेन

Answer 4

हास्केल, 100 बाइट्स

import Data.List
r=reverse
e#n=mapM id$e<$[1..n]
f n=nubBy(\a b->elem a[r b,r<$>b,r$r<$>b])$"01"#n#n

प्रयोग उदाहरण: f 2-> [["00","00"],["00","01"],["00","11"],["01","01"],["01","10"],["01","11"],["11","11"]]।

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

e#n=mapM id$e<$[1..n]        -- helper function: creates a list of all combinations
                             -- of the elements of e of length n
                             -- "01" # 2 -> ["00","01","10","11"]

                   "01"#n#n  -- creates all binary n x n matrices
nubBy                        -- remove duplicates according to the equivalence
                             -- relation
   \a b ->                   -- a equals b if
       a elem                -- a is an element of
         [r b,r<$>b,r$r<$>b] -- the list of reflections of b 

Answer 5

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

n=>[...Array(p=1<<n*n)].map(_=>(p++).toString(2).slice(1)).filter((s,i,a)=>![1,0,1].some(c=>a.indexOf((c?b.reverse():b=b.map(s=>[...s].reverse().join``)).join``)<i,b=s.match(eval(`/.{${n}}/g`))))

सभी मैट्रिक्स प्रविष्टियों का प्रतिनिधित्व करने वाले स्ट्रिंग स्ट्रिंग जैसे उदा । बीच में ए के साथ 1111011113 × 3 मैट्रिक्स का प्रतिनिधित्व करता है । स्पष्टीकरण:10

n=>[...Array(p=1<<n*n)].map(            Enumerate all binary matrices
 _=>(p++).toString(2).slice(1)          Convert to padded binary
).filter((s,i,a)=>![1,0,1].some(        Check reflections of each matrix
 c=>a.indexOf((c?b.reverse():           Reverse the order of lines
  b=b.map(s=>[...s].reverse().join``    Or reverse each line
  )).join``)<i,                         Has this been seen before?
 b=s.match(eval(`/.{${n}}/g`))))        Reshape string into a square

Comments

एक पुनरावर्ती नंबर-टू-बाइनरी फ़ंक्शन बिल्कुल समान लंबाई है:.map(f=(x=p++)=>x>1?f(x>>1)+x%2:"")

— ETHproductions

Answer 6

गणितज्ञ, 94 बाइट्स

DeleteDuplicatesBy[{0,1}~Tuples~{#,#},Sort@Join[Join@@Outer[Reverse,{#},{1,2,{1,2}},1],{#}]&]&

Comments

हाय JHM! जवाब के लिए धन्यवाद। मुझे गणितज्ञ बहुत अच्छी तरह से समझ में नहीं आता है, तो क्या आप थोड़ा सा स्पष्टीकरण जोड़ सकते हैं कि क्या चल रहा है? (मैंने आपके अन्य हाल के उत्तर पर एक ही बात पोस्ट की है। कुछ स्पष्टीकरण देना इस साइट पर जवाब के लिए एक मजबूत उम्मीद है)

— इस्कैग

Answer 7

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

यह नील के समान ही निकला, लेकिन जावास्क्रिप्ट में चाल के सभी बैग में इतना विविधता नहीं है।

n=>eval("r=x=>[...x].reverse();for(l='',i=m=1<<n*n;i<m+m;i++)a=i.toString(2).slice(1).match(eval(`/.{${n}}/g`)),[b=a.map(x=>r(x).join``),r(a),r(b)].some(x=>~l.search(x))?0:l+=a+`\n`")

कम गोल्फ वाला

n=>{
  r = x =>[...x].reverse();
  for(l = '', i = m = 1<<n*n; i < m+m; i++)
    a = i.toString(2).slice(1).match(eval(`/.{${n}}/g`)), // base matrix as an array of strings
    b = a.map(x => r(x).join``), // horizontal reflection
    c = r(a), // vertical reflection
    d = r(b), // both reflections
    // check if already found 
    [b, c, d].some(x => ~l.search(x)) // using search, arrays are converted to comma separated strings 
      ? 0 
      : l += a+`\n` // add new found to list (again as a comma separated string)
  return l
}

टेस्ट खबरदार, इनपुट 4 के लिए भी रनिंग टाइम अधिक लंबा है

f=n=>eval("r=x=>[...x].reverse();for(l='',i=m=1<<n*n;i<m+m;i++)a=i.toString(2).slice(1).match(eval(`/.{${n}}/g`)),[b=a.map(x=>r(x).join``),r(a),r(b)].some(x=>~l.search(x))?0:l+=a+`\n`")

function update() {
  var i=+I.value;
  
  result = f(i)
  count = result.split('\n').length
  O.textContent = count+'\n'+result
}

update()

Input <select id=I onchange="update()"><option>2<option>3<option>4<option>5</select>
<pre id=O></pre>