生成二元矩阵，它们在反射之前是不同的

14

这是所有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

矩阵的顺序无关紧要，从等效矩阵中进行的特定选择也无关紧要，而空格也无关紧要，只要您可以理解，就可以输出矩阵。

输出必须是详尽的。

最短的代码获胜。

编辑：这是我的第一个高尔夫球场，我改变了对获胜标准的看法。

并非专为简洁/高尔夫而设计的语言中最短的代码。

我希望事后更改此标准不是不好的礼节，但我认为以“正常”语言进行更改是一个更有趣的主张。

code-golf  linear-algebra  matrix  abstract-algebra  binary-matrix 
— r
source
5
欢迎来到PPCG！这是一个不错的第一个挑战，但是我建议让人们以灵活的格式（例如，每个矩阵作为列表列表）输出结果。这样，人们可以专注于挑战的非常有趣的核心（将唯一的矩阵查找为对称），而不必担心格式化输出（这很容易占用同样多的字节，从而减少了挑战的难度）重要）。
— 马丁·恩德
谢谢你们的反馈，我已经相应地编辑了问题。
— spraff
2
我很想把轮换当成等价物。我也很想把每个位都等效。我也很想将行/列的排列包括在内。最后，我做出了一个任意决定，使要求保持相当简单。随时发布变化。
— spraff
1
过去我们已经讨论过此问题，并且禁止在代码高尔夫比赛中排除或惩罚某些语言，这意味着应将挑战视为异议。此外，可接受的答案是赢得挑战的答案，这意味着打高尔夫问题的代码最短。总结：如果你不想接受任何答案可言，那就不要。但是，如果您接受答案，则答案必须是最短的答案。
— 丹尼斯
1
最后，歼语言是不是一个高尔夫的语言，而是一种高层次的，通用的，高性能的编程已经存在了25年的语言。即使使用当前的规则，您仍然会接受错误的答案。
— 丹尼斯，

Answers:

1

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
— 英里
source
4

果冻，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.
— 丹尼斯
source
2

腐霉病-24 23 21字节

想寻找更好的方法来获得所有的思考。

感谢@ Pietu1998为我打高尔夫球2个字节！

hM.gS+K_Bk_MMKcRQ^`T*

在这里在线尝试。

在进行全面解释之前，要先等高尔夫运动，但这实际上使所有可能的二元矩阵成为可能，然后.g通过所有可能反射的排序列表将它们汇总起来，然后从每个组中只提取一个。

— 马尔蒂森
source
如果我使用参数运行3该输出，则开始会[['000', '000', '00'],在末尾注意缺少的零。
— spraff
@spraff糟糕，我^2Q代替了Q^2。修复程序也为我节省了一个字节：D
— Maltysen '16
@spraff修复了它。
— Maltysen '16
我很确定您可以_MM代替mC_Cd。
— PurkkaKoodari
@ Pietu1998哦，是的，谢谢！
— Maltysen '16
1

Haskell，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
— 妮米
source
1

JavaScript（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中间是a。说明：

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
— 尼尔
source
递归数字到二进制函数的长度完全相同：.map(f=(x=p++)=>x>1?f(x>>1)+x%2:"")
— ETHproductions '16
1

Mathematica，94个字节

DeleteDuplicatesBy[{0,1}~Tuples~{#,#},Sort@Join[Join@@Outer[Reverse,{#},{1,2,{1,2}},1],{#}]&]&
— 郑焕民
source
1
嗨，JHM！感谢您的回答。我对Mathematica的理解不是很好，所以您可以对正在发生的事情添加一些解释吗？（我在您最近的其他答案中也发表了同样的
— 观点
0

JavaScript（ES6），184

事实证明，这与尼尔（Neil）的非常相似，但是javascript中的所有技巧并不是那么多样化。

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>
展开摘要

— edc65
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.