20

编写一个程序，确定给定的矩阵是否表示一个量子点。甲quandle是配备有单个（非可交换的，非结合）操作◃其遵循以下公理一组：

该操作已关闭，这意味着a◃b = c如果a和b是的元素。
该操作是自行分配的： (a◃b)◃c = (a◃c)◃(b◃c)。
操作是右整除：对于任何选择的对a和b，有单个唯一的c，使得c◃a = b
该操作是幂等的： a◃a = a

有限量子可以表示为方矩阵。以下是5阶夸德（source）的示例。

位于第n行第m列（索引为0）的值是n◃m的值。例如，在这个难题中，4◃1 = 3。从这个矩阵很容易看出一些量子特性：

由于只有值0-4出现在此5x5矩阵中，因此它是封闭的。
这是幂等的，因为矩阵对角线是0 1 2 3 4
它是可右除的，因为没有列包含任何重复的值。（行可以并且通常会。）

自我分配权的性质更难检验。可能会有捷径，但最简单的方法是遍历三个索引的每种可能组合以验证m[m[a][b]][c] = m[m[a][c]][m[b][c]]。

输入值

输入将是使用0索引或1索引（您的选择）的方矩阵的行列表。每个条目都是从0到8（或1到9）的单个数字。我会在输入格式上保持灵活性。一些可接受的格式包括：

矩阵或列表的语言最自然的格式，例如[[0 0 0][2 1 1][1 2 2]]或(0,0,0,2,1,1,1,2,2)。
由空格，换行符，逗号等分隔的值列表。
由所有串联在一起的值组成的单个字符串，例如000211122。

您还可以将矩阵的转置作为输入（将行与列交换）。只要确保在您的答案中注明。

输出量

一个真/假值，指示矩阵的状态为分位数。

纠缠的例子

非夸大的例子

没有关闭

不正确的自我分配

0 0 1 0
1 1 0 1
2 3 2 2
3 2 3 3

(3◃1)◃2 = 2◃2 = 2
(3◃2)◃(1◃2) = 3◃0 = 3

不可右除

不是幂等的

— 皮诺皮
source

1

“矩阵”一词具有误导性，因为这与线性代数无关。“桌子”会更好（或者也许是“凯利桌子”，但我认为严格来说，这仅适用于一组人）。

— 彼得·泰勒

7

Python 2中，104个 103 102字节

t=input();e=enumerate
[0%(a==A[a]in B>C[B[a]]==t[C[b]][C[a]])for(a,A)in e(t)for(b,B)in e(t)for C in t]

输入已转置。输出是通过退出代码进行的，因此0（成功）为真，而1（失败）为假。

在线尝试！

怎么运行的

e(t)以（索引，行）对的形式返回输入矩阵t的枚举行（表示操作符◃）。for(a,A)in e(t)，例如，对它们进行迭代，将索引存储在a中，将行本身存储在A中，因此A成为的快捷方式t[a]。

在前一个for(b,B)in e(t)和之间for C in t，我们迭代笛卡尔幂t ^3中所有可能的有序元组（a，b，c）。

对于这些元组，我们评估表达式

0%(a==A[a]in B>C[B[a]]==t[C[b]][C[a]])

当且仅当以下单个比较中的一个或多个相同时，带括号的布尔值的值为False。

a==A[a]将失败（对于一些价值一）当且仅当◃不幂等。
A[a]in B如果B不包含A的所有索引，则将失败。

由于阿具有Ñ指数和乙具有Ñ元素，非失败意味着元素乙匹配的索引甲，所以◃关闭且右整除。
B>C[B[a]] 是一种重言式，因为Python 2认为数字“比可迭代对象”小。
C[B[a]]==t[C[b]][C[a]]如果◃不是右自分配，将因某些值而失败。

如果任何一个比较返回False，则表达式(0%...)将抛出ZeroDivisionError。另外，如果◃没有关闭，A[a]或者C[b]也可能抛出IndexError。在两种情况下，程序均以状态代码1退出（失败）。

如果所有测试均通过，程序将正常退出，状态码为0（成功）。

— 丹尼斯
source

6

Haskell，100字节

此答案使用转置输入。

q m=and$(elem<$>v<*>m)++[a#a==a&&a#b#c==a#c#(b#c)|a<-v,b<-v,c<-v]where v=[0..length m-1];i#j=m!!j!!i

似乎我无法使用模式卫士来绑定中缀运算符，因此where在这种情况下我正在使用。

（第一个版本为108字节，但错过了幂等性测试，固定版本为120字节，后来的版本为108、103和98字节，但是我必须感谢@nimi意识到它们全都错了：当然，我需要做的正确-在进行任何危险的!!操作之前，需要进行除数测试（这意味着闭合），但是我仍然可以使用以后的大多数高尔夫创意，增加了102个字节，现在可以通过更改操作数的顺序进行改进#（无论如何，它可以更好地补偿换位）以更好地利用其与左侧的关联）

像这样使用：

*Main> q [[0,1,2,3],[0,1,3,2],[1,0,2,3],[0,1,2,3]]
False

— 克里斯蒂安·西弗斯
source

4

Python 2，138字节

def f(m):R=range(len(m));return all(m[i][i]==i<set(zip(*m)[i])==set(R)>m[m[j][k]][i]==m[m[j][i]][m[k][i]]for i in R for j in R for k in R)

m 是整数列表的列表。

在线尝试！

— 林恩
source

4

JavaScript（ES6），150字节

a=>!(a.some((b,i)=>b[i]-i)|a.some(b=>[...new Set(b)].sort()+''!=[...b.keys()])||a.some((_,i)=>a.some((_,j)=>a.some((b,k)=>b[a[j][i]]-a[b[j]][b[i]]))))

将输入作为整数列数组的数组。

— 尼尔
source

3

Mathematica，122个字节

(n_±m_:=#[[m,n]];#&@@Union[Sort/@#]==Range@l==Array[#±#&,l=Length@#]&&And@@Flatten@Array[±##2±#==(#2±#)±(#3±#)&,{l,l,l}])&

纯函数，以2D整数数组（1索引）作为输入，行和列与问题中的约定相反，并返回True或False。第一行将二进制中缀操作定义n_±m_为quandle操作。

对于lx l数组，闭合和可右分隔等于每行（在我的情况下）是的置换{1, ..., l}，而幂等则等于主对角线正好{1, ..., l}。因此#&@@Union[Sort/@#]==Range@l==Array[#±#&,l=Length@#]检测这三个条件。（这里使用的Sort/@#原因是我选择交换行和列的原因。）

对于右分配，我们使用逐字检查所有可能性Array[±##2±#==(#2±#)±(#3±#)&,{l,l,l}])。（请注意，由于代表要排列的三变量纯函数的第二个和第三个参数的序列，因此会±##2±#自动扩展为。）然后检查是否通过了每个测试。对于某些非封闭式量子点，当它尝试访问不存在的矩阵的一部分时可能会引发错误，但仍会返回正确的答案。(#2±#3)±###2&&And@@Flatten@

— 格雷格·马丁
source

±m__:=#[[m]];我认为。并且有一个Diagonal内置的。而且±是左关联的，所以你可以使用#2±#±(#3±#)，但如果我没有犯错，然后它是更短的重新分配#，以#3做#±#2±#3==#±#3±±##2&。并且也应该Flatten@用(...&~Array~{l,l,l}<>"")

— 马丁·恩德

我不知道您是否必须l=Length进入，Range@l因为应该首先评估该函数，因此，如果您反复使用该函数，我认为Range仍然可以使用上一个函数l，不是吗？

— Martin Ender

0

C ++ 14，175个字节

作为无名拉姆达，假设n要像std::vector<std::vector<int>>，并经由参考参数返回。0为假，其他所有为真。

#define F(x);for(x=-1;++x<s;){
[](auto m,int&r){int s=r=m.size(),a,b,c F(a)auto A=m[a];r*=s==A.size()&&A[a]==a;int u=0 F(b)u|=1<<m[b][a];r*=A[b]<s F(c)r*=m[A[b]][c]==m[A[c]][m[b][c]];}}r*=!(u-(1<<s)+1);}}

脱胶和用法：

#include<vector>
#include<iostream>

auto f=
#define F(x);for(x=-1;++x<s;){
[](auto m,int&r){
 int s=r=m.size(),a,b,c
 F(a)
  auto A=m[a];               //shortcut for this row
  r*=s==A.size()&&A[a]==a;   //square and idempotet
  int u=0                    //bitset for uniqueness in col
  F(b)
   u|=1<<m[b][a];            //count this item
   r*=A[b]<s                 //closed
   F(c)
    r*=m[A[b]][c]==m[A[c]][m[b][c]];
   }
  }
  r*=!(u-(1<<s)+1);          //check right-divisibility
 }
}
;

int main(){
 int r;
 std::vector<std::vector<int>>
  A = {
   {0, 0, 1, 1},
   {1, 1, 0, 0},
   {3, 3, 2, 2},
   {2, 2, 3, 3},
  },
  B = {
   {0, 2, 3, 4, 1},
   {0, 1, 2, 3, 4},
   {3, 4, 2, 2, 2},
   {3, 3, 3, 3, 3},
   {4, 1, 1, 1, 4},
  };
 f(A,r);
 std::cout << r << "\n";
 f(B,r);
 std::cout << r << "\n";
}

— 卡尔·纳普夫
source

建议int a,b,c,u,s=r=m.size()F代替int s=r=m.size(),a,b,c F，u=0;r*=s==A.size()&&a==A[a]F代替r*=s==A.size()&&A[a]==a;int u=0 F，r*=s>A[b]F代替r*=A[b]<s F和~u+(1<<s)代替u-(1<<s)+1

— ceilingcat

量子纠缠第一集：识别有限量子纠缠

输入值

输出量