循环是一个非常简单的代数结构。它是一个元组（G，+），其中G是一个集合，+是一个二元运算符G×G→G。即+从G中获取两个元素并返回一个新元素。还要求操作员满足两个属性

• 取消：对于每一个和b在ģ存在唯一的X和ÿ在ģ使得

  a + x = b
  y + a = b
  

• 身份：有一个ê在摹使得对于每一个在摹

  e + a = a
  a + e = a
  

如果您熟悉组的概念，您可能会注意到循环只是一个没有关联属性的组。

循环非常简单，因此人们喜欢添加更多规则以制作更有趣的新结构。一种这样的结构是穆方循环是一个循环，还满足以下四个标识的forall X，ÿ和ž在G ^

z + (x + (z + y)) = ((z + x) + z) + y
((y + z) + x) + z = y + (z + (x + z))
(z + x) + (y + z) = (z + (x + y)) + z
(z + x) + (y + z) = z + ((x + y) + z)

例如，以下Cayley表代表一个Moufang循环：

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

（如果您不熟悉，Cayley表是一个方矩阵M，其中M _i，j等于i + j。这是在集合上表示二进制运算符的便捷方法。）

我们可以很容易地证明一个身份0。取消很难显示，但是蛮力方法产生了这张表

b a → 0 1 2 3
↓
0     0 1 2 3
1     1 0 3 2
2     2 3 0 1
3     3 2 1 0

我们的元素是解决方案的地方

a + x = b = x + a

（您可能会注意到此表与我们的Cayley表相同。我将其留给读者练习，以弄清楚为什么这种Moufang循环是这种情况）

现在我们需要验证我们的结构的Moufang身份。有两种方法可以对特定结构执行此操作，第一种方法是认识到它是关联的，因此可以自动满足条件，但是这通常无法正常工作，因此我们宁愿蛮力执行结果。这里有3个自由变量，每个变量在每个表达式中都有4个值的潜力。这意味着我们必须执行7 * 4 ³或448个计算。我将省略原始计算，但是这里有一些Haskell可以用来验证这一点。

任务

给定正整数n作为输入输出，具有n阶的Moufang循环数。（组的顺序是集合的大小）

这是 代码高尔夫球，因此答案将以字节计分，而字节越少越好。

测试用例

这是前71个输入的Moufang循环数

1,1,1,2,1,2,1,5,2,2,1,6,1,2,1,19,1,5,1,6,2,2,1,20,2,2,5,5,1,4,1,122,1,2,1,18,1,2,2,19,1,7,1,5,2,2,1,103,2,5,1,6,1,17,2,17,2,2,1,18,1,2,4,4529,1,4,1,6,1,4,1

Python 3中，475个 410字节

感谢Mr.Xcoder节省了一些字节！

使用公式的对称性可以节省65个字节。是的，很多。

from itertools import*
n=int(input())
P=permutations
R=[*range(n)]
u=[]
A=all
S=sorted
for T in P(P(R),n):u+=[T]*(A(A(R==S(x)for x in
t)and any([*x]==S(x)for x in t)and
A(t[z][t[x][t[z][y]]]==t[t[t[z][x]][z]][y]and
t[t[z][x]][t[y][z]]==t[t[z][t[x][y]]][z]for x in R
for y in R for z in R)for t
in(T,[*zip(*T)]))and A(A(1-A(p[T[i][j]]==U[p[i]][p[j]]for i in R
for j in R)for p in P(R))for U in u))
print(len(u))

在线尝试！

and可以将某些替换为*，从而减少字节数，但会大大降低执行时间：

Python 3，??? 个字节

[TODO在这里放置代码]

（当然，并非所有因素都会*使程序运行速度大大降低，只有其中一些至关重要）

取消高尔夫：

from itertools import *
n = 4 # int(input())
rangeN = list(range(n))

def is_moufang_loop(T):
    A = tuple(zip(*T))
    return all(
        all(sorted(x) == rangeN for x in t)
        and any(list(x) == sorted(x) for x in t)
        and all(
                T[z][T[x][T[z][y]]] == T[T[T[z][x]][z]][y]
            and T[T[z][x]][T[y][z]] == T[T[z][T[x][y]]][z]
            for x in rangeN for y in rangeN for z in rangeN)
        for t in (T, A)
    )

def isomorphic(loop1, loop2):
    for p in permutations(rangeN):
        if all(
            p[loop1[i][j]] == loop2[p[i]][p[j]]
            for i in rangeN
            for j in rangeN
        ): return True
    return False

unique_moufang_loops = []
for x in [
        cayley_table 
        for cayley_table in permutations(permutations(rangeN), n)
        if is_moufang_loop(cayley_table)
]:
    if all(not isomorphic(x, y) for y in unique_moufang_loops):
        unique_moufang_loops.append(x)

print(len(unique_moufang_loops))

在线尝试！

_{没有滚动条...}

说明：

该程序非常简单。

• 每个可能的“二进制运算符”都由Cayley表（0索引）表示。
• “ identity”属性表示存在e，使得e第th行和e第th列都等于[0, 1, 2, ..., n-1]，这与

  数组T及其转置都具有等于的行[0, 1, 2, ..., n-1]。

• “取消”属性等效于

  每行和每一列都是的排列[0, 1, 2, ..., n-1]。

所以，这部分

all(
        all(sorted(x) == rangeN for x in t) 
        and any(list(x) == sorted(x) for x in t) 
        for t in (T, A))

的代码检查。（对于数组中的所有行T及其转置A，被排序rangeN的行等于，并且两者中都存在一行，T并且A等于被排序的行本身）

手动检查Moufang循环的四个条件。

z + (x + (z + y)) = ((z + x) + z) + y
((y + z) + x) + z = y + (z + (x + z))
(z + x) + (y + z) = (z + (x + y)) + z
(z + x) + (y + z) = z + ((x + y) + z)

在代码中，(a + b)表示为T[a][b]。（因为表示为Cayley表）。使用Python链接相等性比较来避免重复(z + x) + (y + z)。

但是，由于公式是对称的：

如果我们+在第一个公式中切换操作数，则得到第二个公式；如果我们切换的操作数+第三个公式中，我们得到与第四配方x和y换地方。

请注意，Cayley表的转置等效于交换了操作数的二进制运算符。（x + y -> y + x）

最后，从中选出所有候选Cayley表

permutations(permutations(rangeN), n) 

因此每一行都是rangeN（的[0, 1, 2, ..., n-1]）排列，并且有n不同的行。