我最近阅读了图论，尤其是超立方体，并思考了在其上构造路径的有趣方法。这是我想出的。

如您所知，您可以通过将所有由1和组成的n元组0作为顶点并连接它们（只要它们的位数不同）来构造n维超立方体。如果将这些二进制数字解释为整数，则最终会得到一个顶点编号正确的图形。例如n=3：

假设您想在这个超立方体上散步，然后从顶点开始0。现在，如何确定下一个要访问的顶点？我想出的规则是获取当前a顶点的数量，翻转它mod(a,n)的位（从零开始的索引），然后转到最终的顶点。正式地，该规则可以递归定义为

a[m+1] = xor(a[m], 2^mod(a[m],n)).

通过遵循此规则，您将始终停留在立方体上并沿着边缘移动。结果路径如下所示

如您所见，您将走一圈！实际上，在所有维度和所有起点上，您的路径最终都会成环。例如n=14，a[0]=0它看起来像这样

对于狂热的漫步者来说，他计划的路线长度是至关重要的信息。因此，您的工作是编写将超多维数据集维度n作为起始顶点的函数或程序a[0]作为输入，并在结果循环中输出顶点数。

测试用例

n   a[0]   Output
-----------------
3   0      6
14  0      50
5   6      8
17  3      346

规则

• 禁止出现标准漏洞
• 输出/输入可以采用任何合适的格式
• 您可以假设a[0]是有效的顶点

计分

以字节为单位的最短代码获胜。

如果您有关于此主题的其他信息，我们将很高兴听到！

果冻，9个字节

%⁴2*^µÐḶL

接受两个命令行参数。

%⁴2*^µÐḶL        A monadic link. Inputs: a_0. b also taken from command line.
%⁴2*^              Variadic link. Input: a
%⁴                   a modulo b. ⁴ is second input, b.
  2*                 Get 2 to that power
    ^                and bitwise xor with a.
     µ             Start a new, monadic link (input: a_0)
      ÐḶ             All elements of the cycle created when the preceding link
                     is applied repeatedly, starting with a_0.
        L            Length.

在这里尝试。

哈斯克尔124

import Data.Bits
(y:z:w)%(x:s)|x==y||x==z=[i|(i,r)<-zip[1..]s,r==x]!!0|0<1=w%s
g n=(tail>>=(%)).iterate(\a->xor a$2^mod a n)

这是通过两个指针在不同速度下变通找到圆的，并且大量使用/滥用Haskell的列表方法（例如，两个指针实际上是列表）。

g是计算答案的函数。给它n，然后a[0]它将把数字返回给您（请注意，n应将其定义为类型Int以避免类型歧义）。

JavaScript（ES6），69个字节

(n,a)=>{g=m=>m^1<<m%n;for(c=1,b=a;(b=g(g(b)))!=(a=g(a));)c++;return c}

为（23，10）返回18812。

MATL，38 37 28字节

xi`vt0)2y1G\^Z~yywP=fn~]2M1$

这适用于该语言的当前版本（15.0.0）。

在线尝试！

说明

x       % take first input: n. Delete (gets copied into clipboard G)
i       % take second input: initial value of a
`       % do...while loop
  v     %   concatenate all stack contents vertically
  t0)   %   duplicate. Get last element of that array: current a
  2     %   push 2
  y     %   duplicate second-top element in stack: current a
  1G    %   push first input (n)
  \     %   a modulo n
  ^     %   2 raised to that
  Z~    %   xor of that with current a
  yy    %   duplicate top two elements in stack: array of old a's and new a
  w     %   swap: move array of old a's to top
  P     %   reverse that array. So first entry is most recent a (before current)
  =f    %   indices of old values that equal current value. There may be 0 or 1
  n~    %   is it empty?
]       % if so, continue with a new iteration
2M      % push array of indices. It contains exactly 1 index
1$      % set 1 input for implicit display function, so it only displays the index

Pyth，22 17字节

Lx^2%bQbl.uyNuyGE

说明：

Lx^2%bQbl.uyNuyGE     Implicit: Q=first line n. E=second line a[0].
Lx^2%bQb              y = lambda b: do one iteration
                      Then
             uyGE     Apply y until a previous result is found.
                      This makes sure we're in the cycle.
         .uyN         Then apply y again until a previous result is found.
                      Keep all intermediate values but not the repeat.
        l             Get the length; i.e. the length of the cycle.

在这里尝试。