ได้รับการป้อนข้อมูลnเขียนโปรแกรมหรือฟังก์ชั่นที่เอาท์พุท / ผลตอบแทนรวมของผลรวมของดิจิตอลnสำหรับทุกฐาน n1

ตัวอย่าง:

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

bijective base- 1ของ5 คือ[1,1,1,1,1]

base- 2(ไบนารี) ของ5 คือ[1,0,1]

ฐาน3ของ5 คือ[1,2]

ฐาน4ของ5 คือ[1,1]

ฐาน5ของ5 คือ[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 : การส่งที่มีคะแนนต่ำสุดชนะ

Canvas ขนาด 3 ไบต์

┬］∑

ลองที่นี่!

แคนวาสตีผ้าใบ

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

Haskell , 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]]

โดยการจัดทำดัชนีด้วย(!!n)สิ่งนี้สามารถใช้ในการแปลงnเป็นฐานb+1ได้ แต่สิ่งนี้จะไม่ทำงานสำหรับ unary (ฐาน$1$ ) แต่เราสรุปผล .. เรายังสามารถบันทึกไบต์จำนวนหนึ่งด้วยa <- [1..n]และใช้ base- $(n+1)$แทนที่จะทำงานรอบฐาน$1$เนื่องจากเราขาด$[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$ซึ่งเหมือนกับ$[n]$เมื่อรวมกัน

การใช้คำdoอธิบายประกอบจะเชื่อมรายการทั้งหมดแทนที่จะซ้อนกัน:

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

เราสามารถลดสิ่งนี้ได้อย่างง่ายดาย (monadic ⊢ส่งคืนการโต้แย้งจึงเรียกว่าidentity ):

Y,Y(⍴⊤⊣)¨⍳Y

ตอนนี้เรารู้แล้วว่าYเป็นจำนวนเต็ม (สเกลาร์ง่าย ๆ คือจำนวนหรือตัวอักษร) เนื่องจากเราได้รับมา ดังนั้นจึง⍳Yมีผลตอบแทน⎕IO=1 จริง ๆ แล้วคืนค่าอาร์เรย์ที่มีรูปร่าง( ต้องเป็นเวกเตอร์) โดยที่ scalar ทุกตัวเป็นดัชนีของตัวเองในอาร์เรย์ (นั่นคือเหตุผลที่ monadic เรียกว่า1 2 ... Y⍳YYY⍳กำเนิดดัชนี ) ดัชนีเหล่านี้เป็นเวกเตอร์ยกเว้นกรณี1≡⍴Yที่พวกเขาอยู่ที่สเกลาร์ (นี่คือกรณีของเรา)

ลองแยกฟังก์ชั่นตรงกลาง(⍴⊤⊣)¨, ต่อไป ⍴⊤⊣คือตัวถูกดำเนินการของ¨( แต่ละตัว ) และฟังก์ชั่นคือ dyadic ดังนั้น¨ผู้ประกอบการจะต้องปรับเปลี่ยนอาร์กิวเมนต์แรกที่มีความยาว 1 อาร์กิวเมนต์ให้เป็นรูปร่างของอีกรูปแบบหนึ่ง (นั่นคือรับองค์ประกอบและใช้เพื่อแทนที่สเกลาร์ทุกตัวในอาร์กิวเมนต์อื่น) แล้วใช้ฟังก์ชันกับแต่ละคู่ของอาร์กิวเมนต์สองตัว ในกรณีนี้⍳Yเป็นเวกเตอร์และYเป็นสเกลาดังนั้นถ้าn≡⍴⍳Yไปแล้วYจะถูกแปลงเป็นn⍴Y( ⍴หมายถึงรูปร่าง (เอก) และReshape (dyadic ฟังก์ชั่น)) นั่นคือในแง่ง่ายYจะถูกแปลงเป็นอาร์เรย์ที่มีYYเวลา

ทีนี้สำหรับแต่ละคู่เราจะเรียกอาร์กิวเมนต์ซ้ายXและขวาZ(เพื่อเราจะไม่ขัดแย้งกับอินพุตY) ⍴⊤⊣เป็นส้อม dyadic ดังนั้นมันจะขยายไปที่:

(X⍴Z)⊤X⊣Z

ขอให้เป็นขั้นตอนแรกของการลดง่ายX⊣ZไปX(dyadic ⊣เป็นซ้ายฟังก์ชั่น):

(X⍴Z)⊤X

⍴ในX⍴Zเป็นอีกครั้งที่Reshapeฟังก์ชั่นดังนั้นX⍴Zในกรณีของเราเป็นเพียงครั้งX คือการเข้ารหัสเป็นเวกเตอร์ขององค์ประกอบที่เท่ากันนี่เป็นเพียงกรณีของการแปลงเป็นเบสและการเปลี่ยนรูปร่างเป็นตัวเลข สำหรับX , Z ∈ N , X Z ( XในฐานZ ) ไม่สามารถมีตัวเลขได้มากกว่าXเนื่องจากX 1มีXหลัก ดังนั้นเพียงพอสำหรับวัตถุประสงค์ของเราZ⊤ฟังก์ชั่นการกำหนดตัวเลขสองอาร์เรย์โดยที่อาเรย์ด้านซ้ายเป็นฐานของแต่ละหลักในผลลัพธ์ (ไม่จำเป็นต้องเป็นจำนวนเต็มหรือบวก) เช่นการเข้ารหัสและด้านขวาคืออาร์เรย์ของตัวเลขส่งคืนอาเรย์ของสิ่งเหล่านั้น ตัวเลขในการเข้ารหัสที่ระบุ (การโอนย้ายคือการกลับรายการของขนาดของอาร์เรย์ที่สัมพันธ์กับองค์ประกอบ) การแสดงตัวเลขนั้นขึ้นอยู่กับความฉลาดของการหารจำนวนและผลคูณของเบสที่มีนัยสำคัญน้อยกว่า ถ้าฐานใด ๆ0มันทำหน้าที่เป็นฐาน + ∞ สเกลาของการโต้แย้งนั้นง่ายทั้งหมด เนื่องจากXเป็นจำนวนเต็มบวกและX⍴ZXZX$X,Z\in\mathbb N$$X_Z$$X$$Z$$X$$X_1$$X$X⍴Z

ผลลัพธ์ของY(⍴⊤⊣)¨⍳Yคือดังนั้นYแปลงเป็นแต่ละฐานจาก 1 ถึงYอาจเป็นศูนย์นำหน้า อย่างไรก็ตามมีปัญหาหนึ่งคือใน APL ฐาน 1 ไม่ได้เป็นกรณีพิเศษในขณะที่ความท้าทายนี้ทำให้เป็นกรณีพิเศษเราจึงต้องรวมผลรวมของตัวเลขหลัก 1 ของYเรา โชคดีที่ผลรวมนี้เป็นเพียงYตั้งแต่$Y_1=\underbrace{[1,1,...,1]}_Y$ดังนั้นผลรวมเป็นเพียง$Y\times1=Y$ Y มันตามมาว่าเราต้องเพิ่มYบางแห่งลงในอาร์เรย์ นี่เป็นวิธีที่พวกเราทำ:

Y,Y(⍴⊤⊣)¨⍳Y

ฉันรวมส่วนนี้ไว้แล้ว Dyadic ,เป็นฟังก์ชั่นcatenateมันเชื่อมต่อข้อโต้แย้งบนแกนสุดท้ายของพวกเขาและข้อผิดพลาดหากไม่สามารถทำได้ ที่นี่เราเพียงแค่เชื่อมสเกลาร์Yกับเวกเตอร์Y(⍴⊤⊣)¨⍳Yเพื่อรวมผลรวมที่เราจะคำนวณโดยYดังที่อธิบายไว้ข้างต้น

ส่วนสุดท้ายคือฟังก์ชั่นด้านซ้ายของบนของเรา+/∘∊:

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

∘เป็นผู้ประกอบการเขียน เป็นเช่นเดียวกับf∘g Y f g Yอย่างไรก็ตามเราใช้มันที่นี่เพื่อให้รถไฟของเราไม่แยกจาก∊กัน ดังนั้นเราสามารถลด:

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

ทีนี้ถึงเวลาหาผลรวมแล้ว แต่รอ ... มีปัญหา อาร์เรย์ไม่แบนดังนั้นเราจึงไม่สามารถรวมองค์ประกอบของมันก่อนจะทำให้แบนก่อน เกณฑ์ฟังก์ชั่น∊flattens อาร์เรย์ ตอนนี้อาเรย์ถูกทำให้แบนในที่สุดเราก็ใช้+/หาผลรวม /เป็นตัวดำเนินการลดจะใช้ฟังก์ชัน dyadic ระหว่างองค์ประกอบของอาร์เรย์บนแกนที่สองถึงครั้งสุดท้ายโดยมีลำดับความสำคัญจากขวาไปซ้าย หากอันดับ (จำนวนมิติคือความยาวของรูปร่าง) ของอาร์เรย์ไม่ลดลงอาร์เรย์นั้นจะถูกล้อมรอบแม้ว่าจะไม่เป็นเช่นนั้นก็ตาม ฟังก์ชั่นที่ใช้ที่นี่คือ+ซึ่งเป็นเครื่องหมายบวกฟังก์ชันที่เพิ่มคู่ในแกนสุดท้ายของสองอาร์เรย์ (และข้อผิดพลาดหากไม่สามารถเพิ่มอาร์เรย์ดังกล่าวได้) ที่นี่จะเพิ่มตัวเลขสองครั้งหลายครั้งเพื่อให้การลดเสร็จสิ้น

ดูเถิดและดูเถิดรถไฟของเรา:

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

ทับทิม , 39 37

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

การเล่นกอล์ฟเพียงอย่างเดียวที่นี่คือการลบช่องว่างออก ลองออนไลน์

Python 2 , 57 ไบต์

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

ลองออนไลน์!

Java 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;}

-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`

Desmos, 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)

ลองที่นี่! กำหนดฟังก์ชั่น$f$เรียกว่า $f\left(n\right)$. ใช้สูตรที่กำหนดในคำตอบที่เดนนิส

นี่คือกราฟผลลัพธ์ (ชี้ไปที่ $(65, 932)$):

Desmos, 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(พร้อมกับตัวแปรตัวช่วย) ด้วยแถวสำหรับแต่ละค่าที่ป้อนเข้า

Ungolfed:

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

Japtap -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 (ดั้งเดิม) ฐาน 1 จาก 5 คือ [0,0,0,0,0] ไม่ใช่ [1,1,1,1,1] ดังนั้นหลังจากรวมช่วงแล้วให้เพิ่มอินพุตไปยังบัญชีสำหรับฐานที่ขาดหายไป 1

ฉันกำลังใช้ 05AB1E (ดั้งเดิม) เพราะใน 05AB1E ปัจจุบันฐาน 1 จาก 5 คือ [1] ในการพิจารณาเรื่องนี้ฉันจะต้องลดผลลัพธ์ทีละ 1 หรือลบองค์ประกอบแรกของช่วงซึ่งทั้งสองจะมีราคา 1 ไบต์

Perl 6 , 45 41 ไบต์

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

-4 ไบต์ขอบคุณ Jo King

ลองออนไลน์!

ช่องว่าง 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ของฉันเพราะช่องว่างไม่มีการแปลงฐาน builtins เลย

ตัวอย่างการเรียกใช้: 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^144มีขนาดใหญ่กว่า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มันข้ามฐานและเป็นเพียงการเพิ่มการnF

Python 2 , 61 ไบต์

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

ลองออนไลน์!

แม้ว่านี่จะนานกว่า ทางออกของเดนนิสแต่ฉันก็พบว่าวิธีการดังกล่าวไม่น่าแบ่งปัน

เป้าหมายคือการเติมเงินทั้งสองเมื่อกระโดดออกจากตัวเลขสุดท้าย n->n/bและเพิ่มฐานb->b+1แต่เราต้องการป้องกันไม่ให้ฐานเพิ่มขึ้นหลังจากที่ตัวเลขหนึ่งหลักหรือมากกว่าถูกตัดออก นี่คือความสำเร็จโดยทำให้ฐานbลอยดังนั้นหลังจากการปรับปรุงn->n//bลอยbติดเชื้อnด้วยความลอยของมัน ด้วยวิธีนี้ไม่ว่าnจะเป็นการลอยหรือไม่เป็นบิตธงว่าเราได้ลบตัวเลขใด ๆ ออกจาก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 คำตอบของฉัน
-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'

JavaScript (ES6), 42 ไบต์

รุ่นนี้เกือบจะเหมือนกันกับคำตอบหลักของฉัน แต่อาศัยการคำนวณทางคณิตศาสตร์น้อยเพื่อหยุดการเรียกซ้ำ ค่าสูงสุดที่รองรับขึ้นอยู่กับขนาดของสแตกการโทร

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

ลองออนไลน์!

JavaScript (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¨⊂⍵}

ลองออนไลน์!

Husk , 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 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการใช้รหัสเวอร์ชันอย่างละเอียด ถ่านไม่สามารถแปลงเป็นฐาน 1 ได้ แต่โชคดีที่ผลรวมหลักนั้นเหมือนกับการแปลงเป็นฐาน$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$`;$_¶

แสดงรายการหมายเลขทั้งหมดตั้งแต่ 2 ถึง $n + 1$ (เนื่องจากง่ายกว่าการแปลงฐาน 1)

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

ใช้ divmod ซ้ำเพื่อแปลงหมายเลขเดิมเป็นฐาน

1+;

ลบรายการฐานโดยเหลือเพียงหลักการแปลงฐาน

1

นำผลรวมและแปลงเป็นทศนิยม

Desmos, 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