Đưa ra một đầu vào n, viết một chương trình hoặc hàm xuất / trả tổng của các khoản tiền kỹ thuật số ncho tất cả các cơ sở 1 đến n.

Thí dụ:

n = 5

Tạo phạm vi [1...n]:[1,2,3,4,5]

Đối với mỗi phần tử x, hãy lấy một mảng gồm các xchữ số cơ bản của n: [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]

cơ sở- song ánh 1của 5 là[1,1,1,1,1]

cơ sở- 2(nhị phân) của 5 là[1,0,1]

cơ 3sở 5 là[1,2]

cơ 4sở 5 là[1,1]

cơ 5sở 5 là[1,0]

Tổng các chữ số: 13

Các trường hợp thử nghiệm:

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

Trình tự có thể được tìm thấy trên OEIS: A131383

Ghi điểm:

code-golf : Bài nộp có số điểm thấp nhất sẽ thắng.

Canvas , 3 byte

┬］∑

Hãy thử nó ở đây!

Canvas đập Jelly?

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

Haskell , 46 byte

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

Hãy thử trực tuyến!

Giải trình

Hàm \b n -> mapM(pure[0..b])[1..n], tạo tất cả các chuỗi theo thứ tự từ điển. Ví dụ:$[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]]

Bằng cách lập chỉ mục vào nó với (!!n)điều này có thể được sử dụng để chuyển đổi nsang cơ sở b+1, tuy nhiên điều này sẽ không hoạt động cho unary (cơ sở ), nhưng chúng tôi tổng hợp kết quả .. Chúng tôi thậm chí có thể lưu một số byte với và sử dụng cơ sở- thay vì xử lý xung quanh cơ sở- vì chúng tôi thiếu giống như khi tổng kết.$1$( n + 1 ) 1 [ 1 , ... , 1 ⏟ n  lần ] [ n ]a <- [1..n]$(n+1)$$1$$[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$$[n]$

Sử dụng dochú thích chỉ ghép nối tất cả các danh sách thay vì lồng chúng:

λ [ 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 byte

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

Hãy thử trực tuyến!

Giải trình

Một số dấu ngoặc đơn được ngụ ý và có thể được thêm vào (nhẹ hơn dấu ngoặc đơn "chính thức"):

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

Đây là một đỉnh đơn nguyên. Đưa ra một đối số Y, hàm này hoạt động như sau:

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

Hai chức năng được áp dụng theo thứ tự. Chúng ta sẽ bắt đầu từ bên phải:

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

Có ba chức năng trong chuyến tàu này, vì vậy đây là một ngã ba. Đưa ra một đối số Y, nó hoạt động như:

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

Chúng ta có thể dễ dàng giảm xuống điều này (monadic ⊢trả về đối số của nó, do đó được gọi là danh tính ):

Y,Y(⍴⊤⊣)¨⍳Y

Bây giờ, chúng ta biết rằng đó Ylà một số nguyên (vô hướng đơn giản, tức là số hoặc ký tự), vì chúng ta đã cho một số nguyên. Do đó ⍳Y, với ⎕IO=1, trả lại 1 2 ... Y. ⍳Ythực sự trả về một mảng có hình dạng Y( Yphải là một vectơ), trong đó mọi vô hướng là chỉ số của chính nó trong mảng (đó là lý do tại sao monadic ⍳được gọi là trình tạo chỉ mục ). Các chỉ số này là các vectơ, ngoại trừ trường hợp 1≡⍴Y, trong đó chúng là vô hướng (đây là trường hợp của chúng tôi).

Hãy phân tích hàm giữa (⍴⊤⊣)¨, tiếp theo. ⍴⊤⊣là toán hạng của ¨( mỗi ) và hàm là dyadic, do đó, ¨toán tử trước tiên sẽ định hình lại mỗi đối số độ dài-1 thành hình dạng của đối số khác (nghĩa là lấy phần tử và sử dụng nó để thay thế mọi vô hướng trong đối số khác) và sau đó áp dụng hàm cho từng cặp của hai đối số. Trong trường hợp này, ⍳Ylà một vectơ và Ylà một vô hướng, vì vậy, nếu n≡⍴⍳Y, sau đó Ysẽ được chuyển đổi thành n⍴Y( ⍴đại diện cho các hình dạng (monadic) và chức năng định hình lại (dyadic)). Đó là, về mặt đơn giản hơn, Ysẽ được chuyển đổi thành một mảng chứa Ythời gian Y.

Bây giờ, đối với mỗi cặp, hãy gọi đối số bên trái Xvà bên phải Z(để chúng ta không xung đột với đầu vào Y). ⍴⊤⊣là một ngã ba dyadic, vì vậy nó sẽ mở rộng sang:

(X⍴Z)⊤X⊣Z

Chúng ta hãy thực hiện bước đầu tiên dễ dàng để giảm X⊣Zxuống X(dyadic ⊣là chức năng bên trái ):

(X⍴Z)⊤X

Các ⍴trong X⍴Zlà, một lần nữa, Reshape chức năng, vì vậy X⍴Z, trong trường hợp của chúng tôi, chỉ đơn giản là Xlần Z. ⊤là hàm mã hóa . Cho hai mảng số, trong đó mảng bên trái là cơ sở của mỗi chữ số trong kết quả (không cần phải là số nguyên hoặc dương), tức là mã hóa và bên phải là một mảng các số, trả về mảng được chuyển đổi của các số đó các số trong mã hóa được chỉ định (hoán vị là sự đảo ngược kích thước của một mảng so với các phần tử của nó). Việc biểu diễn một chữ số dựa trên thương số của phép chia số và tích của các cơ sở ít quan trọng hơn. Nếu bất kỳ cơ sở nào 0, nó hoạt động như cơ sở +. Vô hướng của các đối số đều đơn giản. Vì Xlà số nguyên dương vàX⍴Zlà một vectơ của các phần tử bằng nhau, đây thực sự chỉ là một trường hợp chuyển đổi Xthành cơ sở Zvà định hình lại thành Xchữ số. Đối với , ( trong cơ sở ) không thể có nhiều hơn chữ số , vì có chữ sốDo đó, là đủ cho mục đích của chúng tôi.$X,Z\in\mathbb N$$X_Z$$X$$Z$$X$$X_1$$X$X⍴Z

Y(⍴⊤⊣)¨⍳YDo đó, kết quả là được Ychuyển đổi thành từng cơ sở từ 1 đến Y, có thể bằng các số 0 đứng đầu. Tuy nhiên, có một vấn đề: trong APL, cơ sở 1 không phải là trường hợp đặc biệt, trong khi thử thách này thực hiện trường hợp đặc biệt, vì vậy chúng tôi phải bao gồm tổng các chữ số cơ sở 1 của Ychính chúng tôi. May mắn thay, số tiền này chỉ là Y, kể từ , vì vậy số tiền chỉ đơn giản là . Theo sau chúng ta phải thêm một nơi nào đó vào mảng. Đây là cách chúng ta làm điều đó:$Y_1=\underbrace{[1,1,...,1]}_Y$$Y\times1=Y$Y

Y,Y(⍴⊤⊣)¨⍳Y

Tôi đã bao gồm phần này ở đây. Cặp đôi ,là làm cho nối tiếp chức năng, nó concatenates đối số của nó trên trục cuối cùng của họ, và các lỗi nếu đó là không thể. Ở đây, chúng ta chỉ cần ghép vô hướng Yvới vectơ Y(⍴⊤⊣)¨⍳Y, để chúng ta tăng tổng chúng ta sẽ tính theo Y, như đã giải thích ở trên.

Phần cuối cùng là chức năng bên trái của chúng tôi , +/∘∊:

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

∘là toán tử soạn thảo . f∘g Ycũng giống như f g Y. Tuy nhiên, chúng tôi đang sử dụng nó ở đây để tàu của chúng tôi không rẽ vào ∊. Vì vậy, chúng ta có thể giảm:

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

Bây giờ, đã đến lúc tổng hợp, nhưng chờ đợi ... có một vấn đề. Mảng không phẳng, vì vậy chúng ta không thể tổng hợp các phần tử của nó trước khi làm phẳng nó trước. Các Tranh thủ chức năng ∊flattens một mảng. Bây giờ mảng đã được làm phẳng, cuối cùng chúng ta sử dụng +/để tính tổng. /là giảm điều hành, nó áp dụng một hàm cặp đôi giữa các yếu tố của một mảng trên thứ hai-to-cuối cùng trục của nó, với ưu tiên từ phải sang trái. Nếu thứ hạng (số lượng kích thước, tức là chiều dài hình dạng) của mảng không giảm, thì mảng đó sẽ được bao quanh, mặc dù đây không phải là trường hợp ở đây. Hàm được áp dụng ở đây là +, đó là điểm cộnghàm thêm các cặp trên trục cuối cùng của hai mảng (và lỗi nếu các mảng không thể được thêm như thế). Ở đây, nó chỉ cần thêm hai số một số lần để quá trình giảm được hoàn thành.

Lo và kìa, tàu của chúng tôi:

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

Ruby , 39 37

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

Việc chơi golf duy nhất ở đây là loại bỏ một số khoảng trắng. Dùng thử trực tuyến

Python 2 , 57 byte

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

Công thức này sử dụng công thức hoạt động kể từ .

Hãy thử trực tuyến!

Java 8, 76 65 byte

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

-11 byte nhờ @ OlivierGrégoire .

Hãy thử trực tuyến.

Giải trình:

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`

Desmos, 127 byte

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)

Hãy thử nó ở đây! Xác định hàm , được gọi là . Sử dụng công thức được đưa ra trong câu trả lời của Dennis .$f$$f\left(n\right)$

Đây là biểu đồ kết quả (điểm tại ):$(65, 932)$

Desmos, 56 byte

Điều này có thể không hoạt động trên tất cả các trình duyệt, nhưng nó hoạt động trên của tôi. Chỉ cần sao chép và dán công thức. Đây là trong liên kết trên.$f_2(n)$

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

SAS, 81 74 byte

data;input n;s=n;do b=2to n;do i=0to n;s+mod(int(n/b**i),b);end;end;cards;

Đầu vào được nhập sau cards;câu lệnh, trên dòng mới, như vậy:

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

Xuất ra một tập dữ liệu chứa câu trả lời s(cùng với các biến của trình trợ giúp), với một hàng cho mỗi giá trị đầu vào

Ung dung:

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 byte

ÆìXÄ x

Thử nó

õ!ìU c

Thử nó

J , 24 23 byte

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

Hãy thử trực tuyến!

05AB1E (di sản) , 5 byte

LвOO+

Hãy thử trực tuyến!

Giải trình:

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

Trong 05AB1E (di sản), cơ sở 1 của 5 là [0,0,0,0,0], không phải [1,1,1,1,1]. Do đó, sau khi tính tổng phạm vi, hãy thêm đầu vào vào tài khoản cho cơ sở 1 bị thiếu.

Tôi đang sử dụng 05AB1E (di sản) bởi vì trong 05AB1E hiện tại, cơ sở 1 của 5 là [1]. Để giải thích cho điều này, tôi sẽ cần phải giảm kết quả bằng 1 hoặc loại bỏ phần tử đầu tiên của phạm vi, cả hai đều có giá 1 byte.

Perl 6 , 45 41 byte

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

-4 byte nhờ Jo King

Hãy thử trực tuyến!

Khoảng trắng , 153 byte

[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]

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.
[..._some_action]chỉ thêm vào giải thích.

Hãy thử trực tuyến (chỉ với không gian thô, tab và dòng mới).

Cổng câu trả lời Java 8 của tôi , bởi vì Whitespace không có nội dung chuyển đổi cơ sở nào cả.

Chạy ví dụ: 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

Chương trình dừng với một lỗi: Không tìm thấy lối ra. (Mặc dù tôi có thể thêm ba dòng mới NNNđể thoát khỏi lỗi đó.)

R , 60 byte

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

Hãy thử trực tuyến!

Thất bại n>143vì 144^144lớn hơn một doublecó thể nhận được. Cảm ơn Josh Eller đã đề nghị thay thế log(n,i)bằng đơn giản n.

Dưới đây sẽ làm việc cho n>143; không chắc chắn vào thời điểm nào nó sẽ ngừng hoạt động.

R , 67 byte

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

Hãy thử trực tuyến!

Sử dụng n%/%i^(0:log(n,i))%%iphương pháp cổ điển để trích xuất các ichữ số ncơ bản cho từng cơ sở b>1, sau đó tính tổng chúng và tích lũy tổng F, được khởi tạo 0, sau đó thêm n( 1biểu diễn cơ sở của n) vào Fvà trả về kết quả. Đối với n=1, nó bỏ qua các căn cứ và chỉ cần thêm nvào F.

Python 2 , 61 byte

f=lambda n,b=2.:n and n%b+f(n//b,b)+(n//b>1/n==0and f(n,b+1))

Hãy thử trực tuyến!

Mặc dù đây là giải pháp dài hơn của Dennis , nhưng tôi thấy phương pháp này quá thú vị để không chia sẻ.

Mục tiêu là để lặp lại cả việc loại bỏ chữ số cuối cùng n->n/bvà tăng số cơ sở b->b+1, nhưng chúng tôi muốn ngăn cơ sở không bị tăng sau khi một hoặc nhiều chữ số bị tắt. Điều này đạt được bằng cách làm cho đế bnổi, để sau khi cập nhật n->n//b, phao bị bnhiễm nvới độ nổi của nó. Theo cách này, việc ncó nổi hay không là cờ bit cho việc chúng ta đã xóa bất kỳ chữ số nào khỏi n.

Chúng tôi yêu cầu điều kiện 1/n==0được đáp ứng để tái diễn thành tăng dần b, điều này nthỏa mãn bởi vì việc phân chia sàn được thực hiện, nhưng việc thả nổi không thành công. ( n=1cũng thất bại nhưng dù sao chúng tôi cũng không muốn sử dụng lại nó.) Mặt khác, phao hoạt động giống như các số nguyên trong hàm vì chúng tôi cẩn thận thực hiện phân chia sàn n//bvà đầu ra là số nguyên.

C (gcc), 67 56 byte

b,a,s;e(n){for(b=a=n;a>1;a--)for(s=n;s;s/=a)b+=s%a;n=b;}

Cổng câu trả lời Java 8 của tôi .
-11 byte nhờ câu trả lời của @ OlivierGrégoire trên câu trả lời Java của tôi.

Hãy thử trực tuyến.

Giải trình:

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'

JavaScript (ES6), 42 byte

Phiên bản này gần giống với câu trả lời chính của tôi nhưng dựa vào dòng chảy số học để ngăn chặn đệ quy. Giá trị được hỗ trợ cao nhất phụ thuộc vào kích thước của ngăn xếp cuộc gọi.

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

Hãy thử trực tuyến!

JavaScript (ES6),  51 48  44 byte

f=(n,b=2,x=n)=>b>n?n:x%b+f(n,b+!x,x?x/b|0:n)

Hãy thử trực tuyến!

Đã bình luậ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 byte

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

Hãy thử trực tuyến!

Husk , 6 byte

Tôi thực sự ước rằng có một cái gì đó giống như Mcho cmap:(

Σ§ṁ`Bḣ

Hãy thử trực tuyến hoặc kiểm tra tất cả!

Giải trình

Σ§ṁ`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

Ngoài ra, 6 byte

ΣΣṠMBḣ

Hãy thử trực tuyến hoặc kiểm tra tất cả!

Giải trình

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

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

Hãy thử trực tuyến!

Thạch , 4 byte

bRFS

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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.

Tùy viên , 25 byte

{Sum!`'^^ToBase[_,2:_]'_}

Hãy thử trực tuyến!

Giải trình

{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

Than , 12 byte

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

$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

Võng mạc 0.8.2 , 49 byte

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

1

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Giải trình:

.+
$*

Chuyển đổi sang unary.

1
11$`;$_¶

$n + 1$

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

Sử dụng divmod lặp đi lặp lại để chuyển đổi số gốc cho từng cơ sở.

1+;

Xóa danh sách các cơ sở, chỉ để lại các chữ số chuyển đổi cơ sở.

1

Lấy tổng và chuyển thành số thập phân.

Desmos, 51 byte

Lấy cảm hứng từ câu trả lời của Conor O'Brien và nhìn vào mục OEIS tôi đã đưa ra giải pháp Desmos của riêng mình:

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

Hãy thử trực tuyến!

APL (NARS), 29 ký tự, 58 byte

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

kiểm tra nhỏ về cách sử dụng:

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