最近，我发现从正整数到有限的嵌套序列的双射映射f。挑战的目的是用您选择的语言来实现它。

映射

考虑一个号码ň与因素在那里。然后：

例如：

规则

• 您可以编写完整的程序或函数来执行此任务。
• 输出可以是可识别为序列的任何格式。
• 允许用于素数分解，素数测试等的内置。
• 不允许出现标准漏洞。
• 您的程序必须在10分钟内完成我机器上的最后一个测试用例。
• 这是代码高尔夫球，所以最短的代码获胜！

测试用例

• 10： {{},{{}},{}}
• 21： {{{}},{},{{}}}
• 42： {{{}},{},{{}},{}}
• 30030： {{{}},{{}},{{}},{{}},{{}},{}}
• 44100： {{{{}}},{{{}}},{{{}}},{},{}}
• 16777215： {{{{}}},{{}},{{}},{},{{}},{{}},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{},{{}}}
• 16777213：pastebin

Pyth，29个字节

L+'MhMtbmYhbL&JPby/LJf}TPTSeJ

示范

这定义了一个函数，'执行所需的映射。

y给定素分解，辅助函数递归执行映射。基本情况和素分解在中执行'。

CJam，51 48 44 42 41 39 34 33 31字节

{mf_W=)1|{mp},\fe=(0a*+{)J}%}:J

在CJam解释器中在线尝试。

感谢@MartinBüttner打高尔夫球3个字节！

感谢@PeterTaylor为3个字节打高尔夫球，并为另外1个字节铺平了道路！

至少在我的计算机上，下载文件所需的时间比运行该程序所需的时间更长...

输入输出

这是一个命名函数，该函数从STDIN弹出并整数，然后返回一个数组。

由于CJam不能区分空数组和空字符串–字符串只是一个仅包含字符的列表–因此，字符串表示将如下所示：

[[""] "" [""] ""]

引用以下嵌套数组

[[[]] [] [[]] []]

验证

$ wget -q pastebin.com/raw.php?i=28MmezyT -O test.ver
$ cat prime-mapping.cjam
ri
  {mf_W=)1|{mp},\fe=(0a*+{)J}%}:J
~`
$ time cjam prime-mapping.cjam <<< 16777213 > test.out

real    0m25.116s
user    0m23.217s
sys     0m4.922s
$ diff -s <(sed 's/ //g;s/""/{}/g;y/[]/{}/' < test.out) <(tr -d , < test.ver)
Files /dev/fd/63 and /dev/fd/62 are identical

怎么运行的

{                           }:J  Define a function (named block) J.
 mf                              Push the array of prime factors, with repeats.
   _W=                           Push a copy and extract the last, highest prime.
      )1|                        Increment and OR with 1.
         {mp},                   Push the array of primes below that integer.

                                 If 1 is the highest prime factor, this pushes
                                 [2], since (1 + 1) | 1 = 2 | 1 = 3.
                                 If 2 is the highest prime factor, this pushes
                                 [2], since (2 + 1) | 1 = 3 | 1 = 3.
                                 If p > 2 is the highest prime factor, it pushes
                                 [2 ... p], since (p + 1) | 1 = p + 2, where p + 1
                                 is even and, therefor, not a prime.

              \fe=               Count the number of occurrences of each prime
                                 in the factorization.

                                 This pushes [0] for input 1.

                  (              Shift out the first count.
                   0a*           Push a array of that many 0's.
                      +          Append it to the exponents.

                                 This pushes [] for input 1.

                       {  }%     Map; for each element in the resulting array:
                                   Increment and call J.

Mathematica，88个字节

f@1={};f@n_:=f/@Join[1+{##2},1&~Array~#]&@@SparseArray[PrimePi@#->#2&@@@FactorInteger@n]