如果反复在其自己的输出上调用该函数最终达到原始编号，则可以认为具有输入并提供输出的函数（或程序）具有一个循环。例如，采用以下功能：

Input:  n    1 2 3 4 5 6
Output: f(n) 5 7 1 3 4 9

如果我们开始n=1，f(n)=5，f(f(n))=f(5)=4，f(f(f(n)))=f(4)=3，f(f(f(f(n))))=f(3)=1。

这是书面的(1 5 4 3)。由于此循环中有4个唯一数字，因此这是一个长度为4的循环。

您面临的挑战是编写一个具有每个可能长度的循环的程序或函数。也就是说，必须有一个长度为1，长度为2的循环，依此类推。

另外，您的函数/程序必须从正整数到正整数，并且必须是双射的，这意味着在所有正整数上，每个可能的输出值都必须有一个准确的输入值。换句话说，函数/程序必须计算正整数的排列。

详细信息：允许使用任何标准输入/输出系统，包括STDIN，STDOUT，函数参数，返回等。禁止使用标准漏洞。

您无需担心数据类型的限制-例如，仅在假设int或float可以容纳任何值的情况下保留以上属性。

对于非正整数的输入，该函数的行为没有任何限制，这些输入/输出将被忽略。

计分是按字节计的代码高尔夫球，最短的代码获胜。

Pyth，11个 8字节

.<W-0zz1

比我以前的答案无聊得多。

每个包含0位数的数字都映射到其自身。任何其他数字都映射到其数字旋转了1的数字。因此，例如：

1 -> 1
10 -> 10
15 -> 51 -> 15
104 -> 104
123 -> 231 -> 312 -> 123

Python 2，56 55 54字节

n=input()
a=b=1
while a+b<=n:a+=b;b+=1
print(n+~a)%b+a

这是前21个输出：

[1, 3, 2, 6, 4, 5, 10, 7, 8, 9, 15, 11, 12, 13, 14, 21, 16, 17, 18, 19, 20]

如果将列表分成几块，则模式很明显：

 1    2  3    4  5  6    7  8  9  10    11  12  13  14  15    16  17  18  19  20  21
[1]  [3, 2]  [6, 4, 5]  [10, 7, 8, 9]  [15, 11, 12, 13, 14]  [21, 16, 17, 18, 19, 20]

Pyth，25个字节

+hK/*J/h@h*8tQ2 2tJ2%-QKJ

该序列与@ Sp3000相同，但是格式为封闭式。封闭形式为：

Python3，40个字节

n=input();print([n[1:]+n[0],n]['0'in n])

每个包含0位数的数字都映射到其自身。任何其他数字都映射到其数字旋转了1的数字。因此，例如：

1 -> 1
10 -> 10
15 -> 51 -> 15
104 -> 104
123 -> 231 -> 312 -> 123

Ruby，22 + 1 = 23

使用命令行标志-p，运行

~/(.)(.?)/
$_=$1+$'+$2

当输入数字的字符串表示形式（没有尾随换行符）时，它将保持第一个数字不变，然后将剩余的数向左旋转，因此1234变为1342。

可以使用将该字符减少到21个字符 $_=$1+$'+$2if/(.)(.)/，但是会显示警告。

Ruby，16 + 1 = 17

使用命令行标志-p，运行

$_=$_[/.0*$/]+$`

这是比我的其他答案更复杂的功能，但碰巧更容易打高尔夫球（并且可以忍受尾随换行符）。它使用输入的最后一个非零数字加上任何结尾的零，并将其移至数字的开头。如此9010300成为3009010。具有n个非零数字的任何数字将成为n长度循环的一部分。

输入是通过STDIN在任何基础中的字符串，输出是在该基础中的字符串。

Python，43岁

Sp3000函数的逆函数，以递归方式实现。

f=lambda n,k=1:n>k and k+f(n-k,k+1)or n%k+1

该函数是一个周期，然后是两个周期，然后是三个周期，...

(1)(2 3)(4 5 6)(7 8 9 10)(11 12 13 14 15)...

该运算对数字起n%k+1一个k循环的作用1..k。要找到合适k的方法，请将所有内容k=1依次向下移动，然后依次k=2类推，直到n<=k。

Pyth，15个字节

到目前为止，最短的答案是使用数字运算而不是字符串运算。

.|.&Q_=.&_=x/Q2

    Q                input
            /Q2      input div 2
           x   Q     that XOR input
          =          assign that to Q
         _           negate that
       .&       Q    that AND Q
      =              assign that to Q
     _               negate that
  .&                 input AND that
.|               Q   that OR Q

此功能对二进制表示的影响是将最右边的1s块扩展到下一个0；或如果没有0，则将其重置为单个1：

10010110100000 ↦  
10010110110000 ↦  
10010110111000 ↦  
10010110111100 ↦  
10010110111110 ↦  
10010110111111 ↦
10010110100000  

Pyth，26个字节，有趣的变体

.|.&Q_h.&/Q2+Qy=.&/Q2_h.|y

    Q                           input
         /Q2                    input div 2
             Q                  input
                  /Q2           input div 2
                         yQ     twice input
                       .|  Q    that OR input
                     _h         NOT that
                .&              (input div 2) AND that
               =                assign that to Q
              y                 twice that
            +                   input plus that
       .&                       (input div 2) AND that
     _h                         NOT that
  .&                            input AND that
.|                          Q   that OR Q

对所有 1s块（不仅是最右边的1s）同时执行上述操作-仍仅使用按位和算术运算。

1000010001001 ↦
1100011001101 ↦
1110011101001 ↦
1111010001101 ↦
1000011001001 ↦
1100011101101 ↦
1110010001001 ↦
1111011001101 ↦
1000011101001 ↦
1100010001101 ↦
1110011001001 ↦
1111011101101 ↦
1000010001001

Swift 1.2，66个字节

func a(b:Int){var c=0,t=1,n=b
while n>c{n-=c;t+=c++}
print(n%c+t)}

Input:  1,   2, 3,  4, 5, 6,   7, 8, 9, 10,   11, 12, 13, 14, 15
Output: 1,   3, 2,  5, 6, 4,   8, 9, 10, 7,   12, 13, 14, 15, 11

Brachylog，5个字节

∋0&|↺

在线尝试！

@orlp的Pyth答案的端口。简洁明了：

∋0    % If input contains a 0 (since input is a single number, "contains" ∋ treats it as an array 
      %   of its digits, so this means "if any of input's digits are 0")
&     % Then output is the input
|     % Otherwise
↺     % Circularly shift the input once, and unify that with the output

我原本想移植@ Sp3000的Python解决方案，但这花了多达23个字节：

⟧∋B-₁⟦++₁A≤?;A--₁;B%;A+

在线尝试！

JavaScript（ES6），43个字节

f=(n,i=1,j=1)=>n>j?f(n,++i,j+i):n++<j?n:n-i

Matlab的（189）

  function u=f(n),if(~n|n==1)u=n;else,u=n;y=factor(n);z=y(y~=2);if ~isempty(z),t=y(y~=max(y));if isempty(t),u=y(end)*2^(nnz(y)-1);else,g=max(t);e=primes(g*2);u=n/g*e(find(e==g)+1);end,end,end

• 功能：

  根据其素数映射任何整数，如果数字为nil或分解为2或1，则该数字将映射到自身，否则我们选择此数的最大素数，然后将剩余的不同素数递增最接近的数更大的首要因素，直到我们达到多少biggest_prime^n地方n是所有因素全部指数的总和，一旦我们达到这个量，我们转向max_prime*2^(n-1)，我们再次重现同样的周期。

Matlab的（137）

  function u=h(n),if(~n|n==1)u=n;else,u=n;y=factor(n);z=y(y~=2);if~isempty(z),e=nnz(y);f=nnz(z);if(~mod(e,f)&e-f)u=n/2^(e-f);else,u=u*2;end

• 一种稍微相似的方法，将不等于{0,1,2 ^ n}的任何数字逐渐乘以2直到我们偶然发现其指数2可被其他素因子的指数之和整除。然后我们转到循环的开始除以2^(sum of exponents of other primes)。其他的麻木被映射到他们自己。