Yansımaya göre farklı ikili matrisler üretme


14

İş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.


5
PPCG'ye Hoşgeldiniz! Bu güzel bir ilk zorluk, ancak sonuçların esnek bir biçimde (örneğin, bir liste listesi olarak her matris) çıktı vermesine izin vermenizi öneririm. Bu şekilde, çıktıyı biçimlendirmek konusunda endişelenmek zorunda kalmadan (aynı zamanda çok fazla bayt alabilen ve ana zorluğun golfünü daha az hale getirebilen), meydan okumaların çok ilginç çekirdeğine (simetrilere kadar benzersiz matrisler bulmak) odaklanabilirsiniz. önemli).
Martin Ender

Geri bildiriminiz için teşekkürler, ikiniz de soruyu buna göre düzenledim.
spraff

2
Eşdeğer olarak rotasyonları dahil etmeye cazip geldim. Ayrıca, her bir bitin bir eşdeğerlik olarak ters çevrilmesini de dahil etmek istedim. Ayrıca, denklik olarak satır / sütun permütasyonlarını dahil etmeye cazip geldim. Sonunda, gereksinimleri oldukça basit tutmak için keyfi bir karar verdim. Bir varyasyon yayınlamaktan çekinmeyin.
spraff

1
Bunu geçmişte tartıştık ve kod golf yarışmalarında belirli dilleri hariç tutmaya veya cezalandırmaya karşı karar verdik ; Ayrıca, kabul edilen cevap mücadeleyi kazanan cevaptır , bu da kod golf soruları için en kısa kod anlamına gelir. Özetle: Herhangi cevabı kabul etmek istemiyorsanız hiç , o zaman yapma. Ancak, bir cevabı kabul ederseniz, en kısa cevap olmalıdır.
Dennis

1
Son olarak, J dil olduğu değil golf dil, ancak 25 yıldır var olan bir üst düzey, genel amaçlı, yüksek performanslı programlama dili. Mevcut kurallarınızla bile, yine de yanlış cevabı kabul ettiniz.
Dennis

Yanıtlar:


1

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

4

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.

2

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.


Bunu argüman ile çalıştırırsam 3çıkış [['000', '000', '00'],sonunda sıfırın eksik olduğunu not edin.
16:20

@ spraff whoops, ^2Qbunun yerine yaptım Q^2. fix de beni bir bayt kurtarıyor: D
Maltysen

@ spraff düzeltti.
Maltysen

Bunun _MMyerine yapabileceğine eminim mC_Cd.
PurkkaKoodari

@ Pietu1998 oh evet, teşekkürler!
Maltysen

1

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 

1

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

.map(f=(x=p++)=>x>1?f(x>>1)+x%2:"")
Yinelenen bir sayıdan

1

Mathematica, 94 bayt

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

1
Merhaba JHM! Cevap için teşekkürler. Mathematica'yı çok iyi anlamıyorum, neler olduğuna dair biraz açıklama ekleyebilir misiniz? (Aynı şeyi diğer son yanıtınıza da gönderdim. Biraz açıklama yapmak bu sitede cevaplar için güçlü bir beklenti)
isaacg

0

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>

Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.