İşte tüm 2x2 ikili matrisler

#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  

İki ikili kare matris , yatay veya dikey eksenlerdeki herhangi bir sayıda yansıma ile~ diğerine eşlenebiliyorsa , ilişki altında eşdeğerdir .

#1 ~ #2dikey eksendeki yansıma altında, sadece bunlardan birini tutmamız gerekiyor (hangisinin önemli olduğu önemli değil). Aynı şekilde #3 ~ #12, #6 ~ #9vb.

HEDEF tek bir girdi alan ve çıktıdaki tüm matrisler yukarıdaki ilişki altında farklı olacak şekilde mevcut Nolduğu kadar çok sayıda N x Nikili matris basan bir program üretmektir .

Elle dalgalanan sahte kodda, kabul edilebilir bir çözüm

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

Giriş için N=2geçerli bir çıkış

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

Fakat aynı eşdeğerlik sınıfından farklı matrisler seçerek başka bir geçerli çıktı

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

Matrislerin sırası önemli değildir, eşdeğer matrislerden belirli bir seçim önemli değildir ve boşluk önemli değildir, ancak okunabilir olduğu sürece istediğiniz matrisleri çıktılar.

Çıktı ayrıntılı olmalıdır.

En kısa kod kazanır.

EDIT: Bu benim ilk golf yazı ve kazanan kriterler fikrimi değiştirdim.

Özellikle kısalık / golf için tasarlanmamış bir dilde en kısa kod kazanır.

Umarım bu kriteri post-hoc değiştirmek kötü bir davranış değildir, ancak bence bunu "normal" bir dilde yapmak çok daha ilginç bir öneridir.

J, 66 56 53 bayt

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

Kaba kuvvet arama.

kullanım

   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

açıklama

[:~.,~{.@/:~@(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

Jöle , 19 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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.

Pyth - 24 23 21 bayt

Tüm yansımaları elde etmenin daha iyi bir yolunu bulmak istiyorum.

Bana 2 bayt golf @ Pietu1998 için teşekkürler!

hM.gS+K_Bk_MMKcRQ^`T*

Burada çevrimiçi deneyin .

Tam bir açıklama yapmadan önce golf için bekleyecek, ancak aslında tüm ikili matrisleri yapar, daha sonra .golası tüm yansımaların sıralı listesine göre onları keser, sonra her gruptan sadece bir tane alır.

Haskell, 100 bayt

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

Kullanım örneği: f 2-> [["00","00"],["00","01"],["00","11"],["01","01"],["01","10"],["01","11"],["11","11"]].

Nasıl çalışır:

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 

JavaScript (ES6), 195 bayt

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

Birleştirilmiş tüm matris girişlerini temsil eden dizeleri döndürür, örn . Ortada 111101111a olan 3 × 3 1s matrisini temsil eder 0. Açıklama:

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

Mathematica, 94 bayt

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

JavaScript (ES6), 184

Bu, Neil'inkine oldukça benziyordu, ancak javascript'teki tüm hileler çantasında çok çeşitli değil.

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`")

Daha az golf

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
}

Test Dikkat, giriş 4 için bile çalışma süresi aşırı uzun

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>