입력이 주어지면 모든베이스 1 ~ n에 n대한 디지털 합계의 합계를 출력 / 반환하는 프로그램이나 함수를 작성하십시오 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 IS[1,1,1,1,1]

베이스 - 2의 (이진) 5 IS[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 : 점수가 가장 낮은 제출물이 이깁니다.

캔버스 , 3 바이트

┬］∑

여기 사용해보십시오!

젤리를 때리는 캔버스?

{ ]   map over 1..input (implicit "{")
 ┬      decode input from that base
   ∑  sum the resulting (nested) array

하스켈 , 46 바이트

f n=sum$do a<-[1..n];mapM(pure[0..a])[1..n]!!n

온라인으로 사용해보십시오!

설명

이 함수 \b n -> mapM(pure[0..b])[1..n]는 모든 문자열 을 사전 식 순서로 생성합니다. 예를 들면 다음과 같습니다.$[0 \dotsc b]^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]]

이것으로 색인을 작성 하면 base (!!n)로 변환 n하는 데 사용할 수 b+1있지만 단항 (base- )에서는 작동하지 않지만 결과를 합산합니다. base- 보다는 해결 방법 기지 - 대한 우리가 놓치고 있기 때문에 과 동일하다 합산 할 때.$1$( n + 1 ) 1 [ 1 , … , 1 ⏟ n  회 ] [ n ]a <- [1..n]$(n+1)$$1$$[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$$[n]$

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]

APL (Dyalog Unicode) , 14 바이트

+/∘∊⊢,⊢(⍴⊤⊣)¨⍳

온라인으로 사용해보십시오!

설명

일부 괄호는 암시되어 있으며 추가 할 수 있습니다 ( "공식"괄호보다 더 밝음).

+/∘∊(⊢,(⊢(⍴⊤⊣)¨⍳))

이것은 꼭대기에있는 수도원입니다. 인수가 주어지면 Y이 함수는 다음과 같이 동작합니다.

+/∘∊(⊢,(⊢(⍴⊤⊣)¨⍳))Y

두 기능이 순서대로 적용됩니다. 올바른 것부터 시작하겠습니다.

⊢,(⊢(⍴⊤⊣)¨⍳)

이 열차에는 세 가지 기능이 있으므로 포크입니다. 인수가 주어지면 Y다음과 같이 작동합니다.

(⊢Y),((⊢Y)(⍴⊤⊣)¨⍳Y)

우리는 이것을 쉽게 줄일 수 있습니다 (모나 딕 ⊢은 인수를 반환하므로 identity 라고합니다 ).

Y,Y(⍴⊤⊣)¨⍳Y

이제 우리 Y는 정수 (단순 스칼라, 즉 숫자 또는 문자) 임을 알 수 있습니다. 따라서 ⍳Y와 ⎕IO=1함께을 반환합니다 1 2 ... Y. ⍳Y실제로는 모양이있는 배열을 반환합니다 Y( Y벡터 여야 함). 여기서 모든 스칼라는 배열에서 자신의 인덱스입니다 (따라서 monadic ⍳를 인덱스 생성기 라고합니다 ). 이 인덱스는 스칼라 인 경우를 제외하고 벡터입니다 1≡⍴Y(이 경우는 우리의 경우입니다).

다음으로 중간 함수를 구문 분석해 봅시다 (⍴⊤⊣)¨. ⍴⊤⊣는 ¨( each ) 의 피연산자이고 함수는 2 진법이므로 ¨연산자는 먼저 각 길이 -1 인수를 다른 길이의 모양으로 재구성합니다 (즉, 요소를 가져 와서 다른 인수의 모든 스칼라를 대체하는 데 사용) 그런 다음 함수를 두 인수의 각 쌍에 적용하십시오. 이 경우, ⍳Y벡터이며, Y경우에 따라서, 스칼라는 n≡⍴⍳Y다음 Y으로 변환한다 n⍴Y( ⍴나타내는 형상 (모나드)와 모양 변경 (이항) 기능). 즉, 더 간단한 용어로 time을 Y포함하는 배열로 변환됩니다 .YY

이제 각 쌍에 대해 왼쪽 인수 X와 오른쪽을 호출하십시오 Z(입력과 충돌하지 않도록 Y). ⍴⊤⊣Dyadic 포크이므로 다음과 같이 확장됩니다.

(X⍴Z)⊤X⊣Z

다음과 같이 쉽게 축소 X⊣Z하는 첫 번째 단계를 만들어 봅시다 X(2 진 ⊣은 왼쪽 함수입니다).

(X⍴Z)⊤X

⍴에는 X⍴Z다시,이다 모양 변경 기능은, 그래서 X⍴Z, 우리의 경우, 단순히 X시간 Z. ⊤은 IS 인코딩 기능. 왼쪽 배열이 결과의 각 자릿수의 기본 (정수 또는 양수일 필요는 없음), 즉 인코딩이고, 오른쪽이 숫자 배열 인 경우, 두 배열의 숫자가 주어지면, 그 배열이 바뀐 배열을 반환합니다. 지정된 인코딩의 숫자 (조옮김은 해당 요소를 기준으로 배열의 차원을 반전 한 것입니다). 숫자의 표현은 숫자의 나눗셈과 덜 중요 한 밑의 곱의 몫에 근거합니다. 기준이 0인 경우 기준 + ∞로 작동합니다. 인수 스칼라는 모두 간단합니다. 이후는 X양의 정수이고,X⍴Z동일한 요소로 구성된 벡터입니다. 이것은 실제로 X밑 으로 변환 Z하고 X숫자로 재구성 하는 경우입니다 . 들면 , ( 베이스에서 )보다 더 가질 수 때문에, 숫자 갖는 숫자. 그러므로 우리의 목적에는 충분합니다.$X,Z\in\mathbb N$$X_Z$$X$$Z$$X$$X_1$$X$X⍴Z

결과는 Y(⍴⊤⊣)¨⍳Y따라서 인 Y1에서 각 기지국으로 전환 Y가능 선두 제로로. 그러나 한 가지 문제가 있습니다. APL에서는 밑 수가 1 인 경우는 특별하지 않지만,이 경우에는 그 경우가 다르므로 1 자릿수의 합계를 포함 Y해야합니다. 다행히도,이 합은이고 Y, 사람 의 합이 간단하므로 . 배열의 어딘가에 추가해야합니다 . 이것이 우리가 그것을 행한 방법이다:$Y_1=\underbrace{[1,1,...,1]}_Y$$Y\times1=Y$Y

Y,Y(⍴⊤⊣)¨⍳Y

나는 이미이 부분을 여기에 포함시켰다. Dyadic ,은 catenate 함수이며, 마지막 축에 인수를 연결하며, 가능하지 않은 경우 오류를 발생시킵니다. 여기서 우리는 단순히 스칼라 Y를 벡터에 연결하여 위에서 설명한 것처럼 Y(⍴⊤⊣)¨⍳Y계산할 합계를 증가시킵니다 Y.

마지막 부분은 상단의 왼쪽 기능입니다 +/∘∊.

+/∘∊Y,Y(⍴⊤⊣)¨⍳Y

∘는 IS 작성 연산자. f∘g Y와 동일합니다 f g Y. 그러나 우리는 열차가에 갈아 가지 않도록 여기에서 사용하고 있습니다 ∊. 따라서 다음을 줄일 수 있습니다.

+/∊Y,Y(⍴⊤⊣)¨⍳Y

이제 합의 시간이지만 기다려주십시오 ... 문제가 있습니다. 배열은 평평하지 않으므로 먼저 평평하게하기 전에 요소를 합칠 수 없습니다. 입대 함수 ∊배열을 병합. 이제 배열이 평평 해 졌으므로 마지막 +/으로 합산합니다. /는 IS 감소 연산자, 그것은 오른쪽에서 왼쪽으로 우선적으로, 그 마지막에서 두 번째 축에 배열 요소 사이의 이항 함수를 적용한다. 배열의 순위 (차원 수, 즉 모양의 길이)가 줄어들지 않으면 배열이 포함되지만 여기에 해당되지는 않습니다. 여기에 적용가요 기능 +은 IS, 플러스함수는 두 배열의 마지막 축에 쌍을 추가합니다 (그리고 배열을 추가 할 수없는 경우 오류가 발생합니다). 여기서는 단순히 두 번의 숫자를 여러 번 더하여 축소가 완료됩니다.

보라, 우리 기차 :

+/∘∊⊢,⊢(⍴⊤⊣)¨⍳

루비 , 39 37

->n{(2..n).sum{|b|n.digits(b).sum}+n}

여기서 유일한 골프는 공백을 제거하는 것입니다. 온라인으로 사용해보십시오

파이썬 2 , 57 바이트

lambda n:sum(n/(k/n+2)**(k%n)%(k/n+2)for k in range(n*n))

수식 이후부터 작동하는 .

온라인으로 사용해보십시오!

자바 8, 76 65 바이트

n->{int r=n,b=n,N;for(;b>1;b--)for(N=n;N>0;N/=b)r+=N%b;return r;}

@ OlivierGrégoire 덕분에 -11 바이트 .

온라인으로 사용해보십시오.

설명:

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`

데스 바이트, 127 바이트

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)

여기 사용해보십시오! 라는 함수 정의합니다 . Dennis의 답변에 제공된 수식을 사용합니다 .$f$$f\left(n\right)$

결과 그래프는 다음과 같습니다 ).$(65, 932)$

데스 모, 56 바이트

일부 브라우저에서는 작동하지 않을 수도 있지만 내 브라우저에서는 작동합니다. 수식을 복사하여 붙여 넣기 만하면됩니다. 이다 위의 링크이다.$f_2(n)$

f(n)=\sum_{b=2}^{n+1}\sum_{i=0}^{n-1}mod(floor(n/b^i),b)

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

Japt -x, 6 바이트

ÆìXÄ x

시도 해봐

õ!ìU c

시도 해봐

J , 24 23 바이트

+1#.1#.]#.inv"0~2+i.@<:

온라인으로 사용해보십시오!

05AB1E (레거시) , 5 바이트

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은 [1,1,1,1,1]이 아니라 [0,0,0,0,0]입니다. 따라서 범위를 합한 후 누락 된 기준 1을 설명하기 위해 입력을 추가하십시오.

현재 05AB1E에서 5의 1이 [1]이므로 05AB1E (레거시)를 사용하고 있습니다. 이를 설명하기 위해 결과를 1 씩 줄이거 나 범위의 첫 번째 요소를 제거해야합니다. 두 요소 모두 1 바이트입니다.

펄 6 , 45 41 바이트

{$^a+sum map {|polymod $a: $_ xx*},2..$a}

Jo King 덕분에 -4 바이트

온라인으로 사용해보십시오!

공백 , 153 바이트

[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 응답 포트입니다 .

예제 실행 : 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그 오류를 제거하기 위해 세 개의 후행 줄 바꿈 을 추가 할 수 있지만 )

R , 60 바이트

function(n){if(n-1)for(i in 2:n)F=F+sum(n%/%i^(0:n)%%i)
n+F}

온라인으로 사용해보십시오!

실패 n>143때문에 144^144A가보다 큰 double수 있습니다. 간단히 교체 할 것을 제안한 Josh Eller 에게 감사합니다 .log(n,i)n

아래에서 작동합니다 n>143. 어떤 시점에서 작동을 멈출 지 확신하지 못합니다.

R , 67 바이트

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.

파이썬 2 , 61 바이트

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으로 float 인지 아닌지 는에서 숫자를 제거했는지 여부에 대한 비트 플래그입니다 n.

우리는 1/n==0증분으로 재귀하기 위해 조건 이 충족되어야 합니다. 이는 플로어 분할이 완료 되었기 때문에 b정수가 n만족하지만 플로트는 실패합니다. ( n=1또한 실패하지만 어쨌든 재귀를 원하지 않습니다.) 그렇지 않으면 플로트 나누기를주의 n//b하여 출력은 정수 부동 소수점이므로 함수에서 정수처럼 정수가 작동 합니다.

C (gcc), 67 56 바이트

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 답변 포트 . Java 답변에 @ OlivierGrégoire 의 골프
덕분에 -11 바이트 .

온라인으로 사용해보십시오.

설명:

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'

자바 스크립트 (ES6), 42 바이트

이 버전은 내 대답과 거의 동일하지만 재귀를 중지하기 위해 산술 언더 플로를 사용합니다. 지원되는 최대 값은 호출 스택의 크기에 따라 다릅니다.

f=(n,b=1,x)=>b>n?n:~~x%b+f(n,b+!x,x?x/b:n)

온라인으로 사용해보십시오!

자바 스크립트 (ES6),  51 48  44 바이트

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

APL (Dyalog Unicode) , 22 바이트

{1⊥⍵,∊(1+⍳⍵-1)⊥⍣¯1¨⊂⍵}

온라인으로 사용해보십시오!

껍질 , 6 바이트

정말 뭔가가 있다고 소원 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

또는 6 바이트

ΣΣṠ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

Pari / GP , 30 바이트

n->n+sum(b=2,n,sumdigits(n,b))

온라인으로 사용해보십시오!

젤리 , 4 바이트

bRFS

온라인으로 사용해보십시오!

작동 원리

bRFS  Main link. Argument: n

 R    Range; yield [1, ..., n].
b     Convert n to back k, for each k to the right.
  F   Flatten the resulting 2D array of digits.
   S  Take the sum.

첨부 , 25 바이트

{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

숯 , 12 바이트

ＩΣＥＩθΣ↨Ｉθ⁺²ι

$n + 1$

    θ           First input
   Ｉ            Cast to integer
  Ｅ             Map over implicit range
        θ       First input
       Ｉ        Cast to integer
      ↨         Converted to base
           ι    Current index
         ⁺      Plus
          ²     Literal 2
     Σ          Sum
 Σ              Grand total
Ｉ               Cast to string
                Implicitly print

레티 나 0.8.2 , 49 바이트

.+
$*
1
11$`;$_¶
+`\b(1+);(\1)+
$1;$#2$*1,
1+;

1

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 설명:

.+
$*

단항으로 변환합니다.

1
11$`;$_¶

$n + 1$

+`\b(1+);(\1)+
$1;$#2$*1,

반복 된 divmod를 사용하여 원래 숫자를 각 밑수로 변환하십시오.

1+;

기본 변환 숫자 만 남기고 기본 목록을 삭제하십시오.

1

합계를 취하고 십진수로 변환하십시오.

데스 모, 51 바이트

Conor O'Brien의 답변에서 영감을 얻어 OEIS 항목을 살펴본 결과 내 자체 Desmos-solution을 찾았습니다.

h(n)=n^2-\sum_{p=2}^n(p-1)\sum_{k=1}^n floor(n/p^k)

온라인으로 사용해보십시오!

APL (NARS), 29 자, 58 바이트

{+/+/¨⍵{(⍺⍴⍨⌊1+⍺⍟⍵)⊤⍵}⍨¨1+⍳⍵}

사용 방법에 대한 작은 테스트 :

  h←{+/+/¨⍵{(⍺⍴⍨⌊1+⍺⍟⍵)⊤⍵}⍨¨1+⍳⍵}
  h¨1 2 4 10 36 37 64 65
1 3 8 35 297 334 883 932