给定输入n，编写一个程序或函数，输出/返回n所有基数1到2 的数字和的和n。
n = 5
创建范围[1...n]：[1,2,3,4,5]
对于每个元素x，获取一个由以下x位数组成的数组n： [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]
双射碱基1的5 就是[1,1,1,1,1]
is的基数2（二进制）5[1,0,1]
碱基3的5 IS[1,2]
碱基4的5 IS[1,1]
碱基5的5 IS[1,0]
对数字求和： 13
1 1
2 3
3 6
4 8
5 13
6 16
7 23
8 25
9 30
10 35
36 297
37 334
64 883
65 932
序列可在OEIS上找到：A131383
code-golf：得分最低的提交者获胜。
Answers:
f n=sum$do a<-[1..n];mapM(pure[0..a])[1..n]!!n函数\b n -> mapM(pure[0..b])[1..n]，按字典顺序生成所有字符串。例如：
mapM(pure[0..2])[0..1] == [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2]]通过(!!n)使用它索引，可以用于转换n为base b+1，但是这不适用于一元（base- ），但是我们对结果求和。我们甚至可以a <- [1..n]使用base- ，而不是一个变通的碱基，因为我们缺少这是一样的总结的时候。
使用do-notation只是串联所有列表，而不是嵌套它们：
λ [ mapM (pure [0..a]) [1..5] !! n | a <- [1..5] ]
[[0,0,1,0,1],[0,0,0,1,2],[0,0,0,1,1],[0,0,0,1,0],[0,0,0,0,5]]
λ do a <- [1..5]; mapM (pure [0..a]) [1..5] !! n
[0,0,1,0,1,0,0,0,1,2,0,0,0,1,1,0,0,0,1,0,0,0,0,0,5]+/∘∊⊢,⊢(⍴⊤⊣)¨⍳暗含了一些括号，可以添加它们（比“正式的”括号要浅）：
+/∘∊(⊢,(⊢(⍴⊤⊣)¨⍳))这是单子上面。给定一个参数Y，此函数的行为类似于：
+/∘∊(⊢,(⊢(⍴⊤⊣)¨⍳))Y依次应用这两个功能。我们将从正确的位置开始：
⊢,(⊢(⍴⊤⊣)¨⍳)这是这列火车的三个功能，所以这是一个叉子。给定一个参数Y，它的作用是：
(⊢Y),((⊢Y)(⍴⊤⊣)¨⍳Y)我们可以轻松地简化为这个（monadic ⊢返回其参数，因此称为identity）：
Y,Y(⍴⊤⊣)¨⍳Y现在，我们知道这Y是一个整数（简单的标量，即数字或字符），因为我们得到了一个。因此⍳Y，有了⎕IO=1回报1 2 ... Y。⍳Y实际上返回一个具有形状的数组Y（Y必须是向量），其中每个标量都是数组中自身的索引（这就是为什么monadic ⍳称为索引生成器）的原因。这些索引是向量，除了的情况下1≡⍴Y，它们是标量（这是我们的情况）。
(⍴⊤⊣)¨接下来，我们来分析中间函数。⍴⊤⊣是¨（each）的操作数，并且函数是二进位的，因此¨运算符将首先将每个length-1参数重塑为另一个参数的形状（即，使用元素并用它替换另一个参数中的每个标量） ，然后将该函数应用于两个参数的每对。在这种情况下，⍳Y是一个向量和Y是一个标量，所以，如果n≡⍴⍳Y，然后Y将被转换为n⍴Y（⍴表示形状（一元）和重塑（二元）函数）。也就是说，更简单地说，Y将被转换为包含Ytimes 的数组Y。
现在，对于每对，我们分别调用left参数X和right 参数Z（这样我们就不会与input冲突Y）。⍴⊤⊣是二叉叉，因此它将扩展为：
(X⍴Z)⊤X⊣Z让我们轻松地简化X⊣Z为X（二进位⊣为左函数）：
(X⍴Z)⊤X在⍴在X⍴Z是，同样，重塑功能，因此X⍴Z，在我们的情况下，仅仅是X时间Z。⊤是编码功能。给定两个数字数组，其中左边的数组是结果中每个数字的基数（不需要是整数或正数），即编码，右边的是数字数组，返回这些数字的转置数组指定编码中的数字（转置是相对于其元素的数组尺寸的反转）。数字的表示基于数字除法和次有效基数乘积的商。如果任何底为0，则充当底+∞。参数的标量都很简单。因为X是一个正整数，并且X⍴ZXZXX⍴Z
Y(⍴⊤⊣)¨⍳YYYYYY
Y,Y(⍴⊤⊣)¨⍳Y我已经在这里包括了这部分。二进,是链状的功能，它加到他们的最后轴的参数，如果这是不可能的错误。在这里，我们将标量简单地连接Y到vector Y(⍴⊤⊣)¨⍳Y，以便Y如上所述增加要计算的总和。
最后一部分是我们顶部的左功能+/∘∊：
+/∘∊Y,Y(⍴⊤⊣)¨⍳Y∘是组合运算符。f∘g Y是一样的f g Y。但是，我们在这里使用它是为了让我们的火车不会叉车∊。因此，我们可以减少：
+/∊Y,Y(⍴⊤⊣)¨⍳Y现在，是时候进行总和了，但是等等...这是一个问题。数组不是平坦的，因此我们不能只对它的元素求和才先对其进行展平。该招募函数∊变平的阵列。现在，数组已被展平，我们终于+/可以对它求和了。/是reduce运算符，它以倒数第二个优先级在其倒数第二个轴上的数组元素之间应用二元函数。如果数组的等级（维数，即形状的长度）没有减少，则将数组包围起来，尽管这里不是这种情况。这里应用的功能是+，这是加号该函数将对添加到两个数组的最后一个轴上（如果不能像这样添加数组，则会出错）。在这里，它简单地多次将两个数字相加，从而完成了归约。
瞧，我们的火车：
+/∘∊⊢,⊢(⍴⊤⊣)¨⍳+/∘∊⊢,⊢⊤¨⍨⊢⍴¨⍳
n（37b）左右的括号：->n{(2..n).sum{|b|n.digits(b).sum}+n}
n->{int r=n,b=n,N;for(;b>1;b--)for(N=n;N>0;N/=b)r+=N%b;return r;}-11个字节，感谢@OlivierGrégoire。
说明：
n->{ // Method with integer as both parameter and return-type
int r=n, // Result-sum, starting at the input to account for Base-1
b=n, // Base, starting at the input
N; // Temp integer
for(;b>1 // Loop the Base `b` in the range [n, 1):
;b--) // After every iteration: Go to the next Base (downwards)
for(N=n; // Set `N` to the input `n`
N>0; // Loop as long as `N` isn't 0 yet:
N/=b) // After every iteration: Divide `N` by the Base `b`
r+=N%b; // Increase the result `r` by `N` modulo the Base `b`
return r;} // Return the result-sum `r`f\left(n\right)=\sum_{b=2}^{n+1}\sum_{i=0}^{n-1}\operatorname{mod}\left(\operatorname{floor}\left(\frac{n}{b^i}\right),b\right)
这是结果图（指向
f(n)=\sum_{b=2}^{n+1}\sum_{i=0}^{n-1}mod(floor(n/b^i),b)
^n 。
\sum_{b=2}^{n+1}为n+\sum_{b=2}^n保存另外2个字节
SAS，81 74字节
data;input n;s=n;do b=2to n;do i=0to n;s+mod(int(n/b**i),b);end;end;cards;
在cards;语句之后以换行符输入输入，如下所示：
data;input n;s=n;do b=2to n;do i=0to n;s+mod(int(n/b**i),b);end;end;cards;
1
2
3
4
5
6
7
8
9
10
36
37
64
65
输出包含答案的数据集s（以及辅助变量），每个输入值均带有一行
取消高尔夫：
data; /* Implicit dataset creation */
input n; /* Read a line of input */
s=n; /* Sum = n to start with (the sum of base 1 digits of n is equal to n) */
do b=2to n; /* For base = 2 to n */
do i=0to n; /* For each place in the output base (output base must always have less than or equal to n digits) */
/* Decimal value of current place in the output base = b^i */
/* Remainder = int(b / decimal_value) */
/* Current place digit = mod(remainder, base) */
s+mod(int(n/b**i),b);
end;
end;
cards;
1
2
3
LвOO+
说明：
LвOO+ //Full program
L //push [1 .. input]
в //for each element b, push digits of input converted to base b
O //sum each element
O //sum each sum
+ //add input
在05AB1E（旧版）中，5的基数1为[0,0,0,0,0]，而不是[1,1,1,1,1]。因此，在对范围求和后，请添加输入以解决缺少的基数1。
我使用的是05AB1E（旧版），因为在当前的05AB1E中，以5为底的1为[1]。为了解决这个问题，我要么需要将结果减1，要么删除范围的第一个元素，这两个元素都将花费1个字节。
[S S S N
_Push_0][S N
S _Duplicate_0][T N
T T _Read_STDIN_as_integer][T T T _Retrieve_input][S N
S _Duplicate_input][N
S S N
_Create_Label_OUTER_LOOP][S N
S _Duplicate_top][S S S T N
_Push_1][T S S T _Subtract][N
T S S N
_If_0_Jump_to_Label_PRINT][S S S N
_Push_0][S N
S _Duplicate_0][T T T _Retrieve_input][N
S S T N
_Create_Label_INNER_LOOP][S N
S _Duplicate][N
T S S S N
_If_0_Jump_to_Label_AFTER_INNER_LOOP][S N
T _Swap_top_two][S T S S T N
_Copy_1st_item_to_top][S T S S T T N
_Copy_3rd_item_to_top][T S T T _Modulo][T S S S _Add][S N
T _Swap_top_two][S T S S T S N
_Copy_2nd_item_to_top][T S T S _Integer_divide][N
S N
T N
_Jump_to_Label_INNER_LOOP][N
S S S S N
_Create_Label_AFTER_INNER_LOOP][S N
N
_Discard_top][S T S S T S N
_Copy_2nd_item_to_top][T S S S _Add][S N
T _Swap_top_two][S S S T N
_Push_1][T S S T _Subtract][N
S N
N
_Jump_to_Label_OUTER_LOOP][N
S S S N
_Create_Label_PRINT][S N
N
_Discard_top][T N
S T _Print_as_integer]
字母S（空格），T（制表符）和N（换行符）仅作为突出显示而添加。
[..._some_action]仅作为说明添加。
在线尝试（仅使用空格，制表符和换行符）。
我的Java 8 Answer的端口，因为空白根本没有内置的Base转换。
示例运行： input = 3
Command Explanation Stack Heap STDIN STDOUT STDERR
SSSN Push 0 [0]
SNS Duplicate 0 [0,0]
TNTT Read STDIN as integer [0] {0:3} 3
TTT Retrieve input from heap 0 [3] {0:3}
SNS Duplicate 3 [3,3] {0:3}
NSSN Create Label_OUTER_LOOP [3,3] {0:3}
SNS Duplicate 3 [3,3,3] {0:3}
SSSTN Push 1 [3,3,3,1] {0:3}
TSST Subtract (3-1) [3,3,2] {0:3}
NTSSN If 0: Jump to Label_PRINT [3,3] {0:3}
SSSN Push 0 [3,3,0] {0:3}
SNS Duplicate 0 [3,3,0,0] {0:3}
TTT Retrieve input from heap 0 [3,3,0,3] {0:3}
NSSTN Create Label_INNER_LOOP [3,3,0,3] {0:3}
SNS Duplicate 3 [3,3,0,3,3] {0:3}
NTSSSN If 0: Jump to Label_AFTER_IL [3,3,0,3] {0:3}
SNT Swap top two [3,3,3,0] {0:3}
STSSTN Copy (0-indexed) 1st [3,3,3,0,3] {0:3}
STSSTTN Copy (0-indexed) 3rd [3,3,3,0,3,3] {0:3}
TSTT Modulo (3%3) [3,3,3,0,0] {0:3}
TSSS Add (0+0) [3,3,3,0] {0:3}
SNT Swap top two [3,3,0,3] {0:3}
STSSTSN Copy (0-indexed) 2nd [3,3,0,3,3] {0:3}
TSTS Integer divide (3/3) [3,3,0,1] {0:3}
NSNTN Jump to LABEL_INNER_LOOP [3,3,0,1] {0:3}
SNS Duplicate 1 [3,3,0,1,1] {0:3}
NTSSSN If 0: Jump to Label_AFTER_IL [3,3,0,1] {0:3}
SNT Swap top two [3,3,1,0] {0:3}
STSSTN Copy (0-indexed) 1st [3,3,1,0,1] {0:3}
STSSTTN Copy (0-indexed) 3rd [3,3,1,0,1,3] {0:3}
TSTT Modulo (1%3) [3,3,1,0,1] {0:3}
TSSS Add (0+1) [3,3,1,1] {0:3}
SNT Swap top two [3,3,1,1] {0:3}
STSSTSN Copy (0-indexed) 2nd [3,3,1,1,3] {0:3}
TSTS Integer divide (1/3) [3,3,1,0] {0:3}
NSNTN Jump to LABEL_INNER_LOOP [3,3,1,0] {0:3}
SNS Duplicate 0 [3,3,1,0,0] {0:3}
NTSSSN If 0: Jump to Label_AFTER_IL [3,3,1,0] {0:3}
NSSSSN Create Label_AFTER_IL [3,3,1,0] {0:3}
SNN Discard top [3,3,1] {0:3}
STSSTSN Copy (0-indexed) 2nd [3,3,1,3] {0:3}
TSSS Add (1+3) [3,3,4] {0:3}
SNT Swap top two [3,4,3] {0:3}
SSSTN Push 1 [3,4,3,1] {0:3}
TSST Subtract (3-1) [3,4,2] {0:3}
NSNN Jump to LABEL_OUTER_LOOP [3,4,2] {0:3}
SNS Duplicate 2 [3,4,2,2] {0:3}
SSSTN Push 1 [3,4,2,2,1] {0:3}
TSST Subtract (2-1) [3,4,2,1] {0:3}
NTSSN If 0: Jump to Label_PRINT [3,4,2] {0:3}
SSSN Push 0 [3,4,2,0] {0:3}
SNS Duplicate 0 [3,4,2,0,0] {0:3}
TTT Retrieve input from heap 0 [3,4,2,0,3] {0:3}
NSSTN Create Label_INNER_LOOP [3,4,2,0,3] {0:3}
SNS Duplicate 3 [3,4,2,0,3,3] {0:3}
NTSSSN If 0: Jump to Label_AFTER_IL [3,4,2,0,3] {0:3}
SNT Swap top two [3,4,2,3,0] {0:3}
STSSTN Copy (0-indexed) 1st [3,4,2,3,0,3] {0:3}
STSSTTN Copy (0-indexed) 3rd [3,4,2,3,0,3,2] {0:3}
TSTT Modulo (3%2) [3,4,2,3,0,1] {0:3}
TSSS Add (0+1) [3,4,2,3,1] {0:3}
SNT Swap top two [3,4,2,1,3] {0:3}
STSSTSN Copy (0-indexed) 2nd [3,4,2,1,3,2] {0:3}
TSTS Integer divide (3/2) [3,4,2,1,1] {0:3}
NSNTN Jump to LABEL_INNER_LOOP [3,4,2,1,1] {0:3}
SNS Duplicate 1 [3,4,2,1,1,1] {0:3}
NTSSSN If 0: Jump to Label_AFTER_IL [3,4,2,1,1] {0:3}
SNT Swap top two [3,4,2,1,1] {0:3}
STSSTN Copy (0-indexed) 1st [3,4,2,1,1,1] {0:3}
STSSTTN Copy (0-indexed) 3rd [3,4,2,1,1,1,2] {0:3}
TSTT Modulo (1%2) [3,4,2,1,1,1] {0:3}
TSSS Add (1+1) [3,4,2,1,2] {0:3}
SNT Swap top two [3,4,2,2,1] {0:3}
STSSTSN Copy (0-indexed) 2nd [3,4,2,2,1,2] {0:3}
TSTS Integer divide (1/2) [3,4,2,2,0] {0:3}
NSNTN Jump to LABEL_INNER_LOOP [3,4,2,2,0] {0:3}
SNS Duplicate 0 [3,4,2,2,0,0] {0:3}
NTSSSN If 0: Jump to Label_AFTER_IL [3,4,2,2,0] {0:3}
NSSSSN Create Label_AFTER_IL [3,4,2,2,0] {0:3}
SNN Discard top [3,4,2,2] {0:3}
STSSTSN Copy (0-indexed) 2nd [3,4,2,2,4] {0:3}
TSSS Add (2+4) [3,4,2,6] {0:3}
SNT Swap top two [3,4,6,2] {0:3}
SSSTN Push 1 [3,4,6,2,1] {0:3}
TSST Subtract (2-1) [3,4,6,1] {0:3}
NSNN Jump to LABEL_OUTER_LOOP [3,4,6,1] {0:3}
SNS Duplicate 1 [3,4,6,1,1] {0:3}
SSSTN Push 1 [3,4,6,1,1,1] {0:3}
TSST Subtract (1-1) [3,4,6,1,0] {0:3}
NTSSN If 0: Jump to Label_PRINT [3,4,6,1] {0:3}
NSSSSN Create Label_PRINT [3,4,6,1] {0:3}
SNN Discard top [3,4,6] {0:3}
TNST Print top (6) to STDOUT as int [3,4] {0:3} 6
error
程序因错误而停止：未找到出口。（尽管我可以添加三个结尾的换行符NNN来消除该错误。）
function(n){if(n-1)for(i in 2:n)F=F+sum(n%/%i^(0:n)%%i)
n+F}失败的n>143原因144^144在于double无法获得。由于乔希埃勒的建议更换log(n,i)与简单n。
以下适用于n>143；不知道它将在什么时候停止工作。
function(n){if(n-1)for(i in 2:n)F=F+sum(n%/%i^(0:log(n,i))%%i)
n+F}采用经典的n%/%i^(0:log(n,i))%%i方法来提取碱基i位数n为每个基站b>1，然后对其求和，并积聚在总和F，其被初始化为0，然后加入n（基1的表示n），以F与返回结果。为此n=1，它跳过了基础，仅添加n到中F。
0:log(n,i)您不能使用而不使用0:n？n的任何基数表示形式中始终最多只能有n个数字，并且初始log(n,i)数字之后的所有内容都应为0，因此不会影响总和。
n=144，因为它143^143已经存在1.6e308并144^144评估为Inf。谢谢！
f=lambda n,b=2.:n and n%b+f(n//b,b)+(n//b>1/n==0and f(n,b+1))尽管这是基于Dennis的解决方案的更长的时间，但我发现该方法太有趣了，无法共享。
目标是递减最后一位数字n->n/b并增加底数b->b+1，但是我们要防止一位或多位数字被底掉后底数增加。这是通过使基础b成为浮动对象来实现的，因此在更新之后n->n//b，浮动对象b会感染n其浮动对象。这样，是否n浮点数就是我们是否已从中删除任何数字的位标记n。
我们要求1/n==0满足条件才能递归为递增b，整数已n满足，因为完成了底数划分，但浮点运算失败。（n=1同样会失败，但无论如何我们都不想对其进行递归。）否则，浮点数就像函数中的整数一样工作，因为我们要小心进行楼底除法n//b，并且输出是整数浮点数。
b,a,s;e(n){for(b=a=n;a>1;a--)for(s=n;s;s/=a)b+=s%a;n=b;}我的Java 8答案端口。
-11个字节感谢@OlivierGrégoire在我的Java答案中打的高尔夫球。
说明：
b, // Result integer
a, // Base integer
s; // Temp integer
e(n){ // Method with integer as parameter
for(b=a=n; // Set the result `b` to input `n` to account for Base-1
// And set Base `a` to input `n` as well
a>1 // Loop the Base `a` in the range [input, 1):
;a--) // After every iteration: Go to the next Base (downwards)
for(s=n; // Set `s` to input `n`
s; // Inner loop as long as `s` is not 0 yet:
s/=a) // After every iteration: Divide `s` by Base `a`
b+=s%a; // Add `s` modulo Base `a` to the result `b`
n=b;} // Set input `n` to result `b` to 'return it'这个版本几乎与我的主要答案相同，但是依靠算术下溢来停止递归。支持的最高值取决于调用堆栈的大小。
f=(n,b=1,x)=>b>n?n:~~x%b+f(n,b+!x,x?x/b:n)f=(n,b=2,x=n)=>b>n?n:x%b+f(n,b+!x,x?x/b|0:n)f = ( // f = recursive function taking:
n, // - n = input
b = 2, // - b = current base, initialized to 2
x = n // - x = current value being converted in base b
) => //
b > n ? // if b is greater than n:
n // stop recursion and return n, which is the sum of the digits of n
// once converted to unary
: // else:
x % b + // add x modulo b to the final result
f( // and add the result of a recursive call:
n, // pass n unchanged
b + !x, // increment b if x = 0
x ? // if x is not equal to 0:
x / b | 0 // update x to floor(x / b)
: // else:
n // reset x to n
) // end of recursive call我真的希望有什么样M的cmap:(
Σ§ṁ`Bḣ
Σ§ṁ`Bḣ -- example input: 5
§ -- fork the argument..
ḣ -- | range: [1,2,3,4,5]
`B -- | convert argument to base: (`asBase` 5)
ṁ -- | and concatMap: cmap (`asBase` 5) [1,2,3,4,5]
-- : [1,1,1,1,1,1,0,1,1,2,1,1,1,0]
Σ -- sum: 13
ΣΣṠMBḣ
ΣΣṠMBḣ -- example input: 5
Ṡ -- apply ..
ḣ -- | range: [1,2,3,4,5]
.. to function applied to itself
MB -- | map over left argument of base
-- : [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]
Σ -- flatten: [1,1,1,1,1,1,0,1,1,2,1,1,1,0]
Σ -- sum: 13
{Sum!`'^^ToBase[_,2:_]'_}
{Sum!`'^^ToBase[_,2:_]'_}
{ } anonymous lambda, input: _
example: 5
ToBase[_, ] convert `_`
2:_ ...to each base from 2 to `_`
example: [[1, 0, 1], [1, 2], [1, 1], [1, 0]]
'_ append `_`
example: [[1, 0, 1], [1, 2], [1, 1], [1, 0], 5]
^^ fold...
`' the append operator over the list
example: [1, 0, 1, 1, 2, 1, 1, 1, 0, 5]
Sum! take the sum
example: 13
.+
$*
1
11$`;$_¶
+`\b(1+);(\1)+
$1;$#2$*1,
1+;
1
在线尝试！链接包括测试用例。说明：
.+
$*
转换为一元。
1
11$`;$_¶
列出所有数字，从2到 （因为比基础1转换更容易）。
+`\b(1+);(\1)+
$1;$#2$*1,
使用重复的divmod将原始数字转换为每个基数。
1+;
删除基准列表，仅保留基准转换数字。
1
取总和并转换为小数。
受Conor O'Brien的回答启发，并查看OEIS条目，我想到了自己的Desmos解决方案：
h(n)=n^2-\sum_{p=2}^n(p-1)\sum_{k=1}^n floor(n/p^k)
227 -> 9999。也：1383 -> 345678。