다음은 모든 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

행렬의 순서는 중요하지 않으며 동등한 행렬의 특정 선택은 중요하지 않으며 공백은 중요하지 않습니다.하지만 사람이 읽을 수있는 한 원하는대로 행렬을 출력하십시오.

출력은 철저해야합니다.

가장 짧은 코드가 승리합니다.

편집 : 이것은 내 첫 번째 골프 게시물이며 우승 기준에 대해 마음을 바꿨습니다.

간결함 / 골프 승리를 위해 특별히 설계되지 않은 언어로 된 가장 짧은 코드 .

나는이 기준을 사후에 바꾸는 것이 나쁜 예절이 아니기를 바란다. 그러나 나는 "정상적인"언어로하는 것이 훨씬 더 흥미로운 제안 이라고 생각 한다.

J, 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

젤리 , 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.

Pyth- 24 23 21 바이트

모든 반사를 얻는 더 좋은 방법을 찾고 싶습니다.

2 바이트의 골프를 해주신 @ Pietu1998에게 감사드립니다!

hM.gS+K_Bk_MMKcRQ^`T*

여기에서 온라인으로 사용해보십시오 .

전체 설명을하기 전에 골프를 기다리 .g러 가야 하지만, 모든 가능한 이진 행렬을 만든 다음 가능한 모든 반사 목록을 기준으로 정렬 한 다음 각 그룹에서 하나씩 가져옵니다.

하스켈, 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 

자바 스크립트 (ES6), 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`))))

연결된 모든 행렬 항목을 나타내는 문자열을 반환합니다. 예를 들어 중간 111101111에 1s의 3 × 3 행렬을 나타냅니다 0. 설명:

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

수학, 94 바이트

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

자바 스크립트 (ES6), 184

이것은 Neil의 것과 매우 비슷하지만 자바 스크립트의 모든 트릭은 다양하지 않습니다.

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>