Diberikan input n, tulis program atau fungsi yang menghasilkan / mengembalikan jumlah jumlah digital dari nsemua basis 1 ke n.

Contoh:

n = 5

Buat rentang [1...n]:[1,2,3,4,5]

Untuk setiap elemen x, dapatkan array dari xdigit-digit dasar n: [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]

base- 1of bijective 5 adalah[1,1,1,1,1]

base- 2(binary) dari 5 is[1,0,1]

dasar- 3dari 5 is[1,2]

dasar- 4dari 5 is[1,1]

dasar- 5dari 5 is[1,0]

Jumlahkan angka: 13

Kasus uji:

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

Urutannya dapat ditemukan di OEIS: A131383

Mencetak:

code-golf : Kiriman dengan skor terendah menang.

Kanvas , 3 byte

┬］∑

Coba di sini!

Kanvas mengalahkan 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

Cobalah online!

Penjelasan

Fungsi \b n -> mapM(pure[0..b])[1..n], menghasilkan semua string dalam urutan leksikografis. Sebagai contoh:$[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]]

Dengan mengindeks ke dalamnya dengan (!!n)ini dapat digunakan untuk mengkonversi nke basis b+1, namun ini tidak akan bekerja untuk unary ( basis- ), tetapi kami menjumlahkan hasilnya .. Kami bahkan dapat menyimpan beberapa byte dengan dan menggunakan basis- daripada mencari-cari basis- karena kita kehilangan yang sama dengan saat menjumlahkan.$1$( n + 1 ) 1 [ 1 , … , 1 ⏟ n  kali ] [ n ]a <- [1..n]$(n+1)$$1$$[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$$[n]$

Menggunakan do-notation hanya menggabungkan semua daftar alih-alih bersarang:

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

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

Cobalah online!

Penjelasan

Beberapa tanda kurung tersirat dan dapat ditambahkan (lebih ringan dari tanda kurung "resmi"):

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

Ini adalah puncak monadik. Diberikan argumen Y, fungsi ini berperilaku seperti:

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

Dua fungsi diterapkan secara berurutan. Kami akan mulai dari yang benar:

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

Ada tiga fungsi di kereta ini, jadi ini garpu. Diberikan argumen Y, itu bertindak sebagai:

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

Kita dapat dengan mudah mengurangi hal ini (monadik ⊢mengembalikan argumennya, karenanya disebut identitas ):

Y,Y(⍴⊤⊣)¨⍳Y

Sekarang, kita tahu bahwa itu Yadalah bilangan bulat (skalar sederhana, yaitu angka atau karakter), karena kita diberi satu. Karena itu ⍳Y, dengan ⎕IO=1, pengembalian 1 2 ... Y. ⍳Ysebenarnya mengembalikan array dengan bentuk Y( Yharus vektor), di mana setiap skalar adalah indeks dari dirinya sendiri dalam array (itu sebabnya monadik ⍳disebut generator indeks ). Indeks-indeks ini adalah vektor, kecuali untuk kasus di mana 1≡⍴Y, di mana mereka adalah skalar (ini adalah kasus kami).

Mari kita parsing fungsi tengah (⍴⊤⊣)¨,, selanjutnya. ⍴⊤⊣adalah operan dari ¨( masing-masing ), dan fungsinya adalah diadik, sehingga ¨operator akan terlebih dahulu membentuk kembali setiap argumen panjang-1 ke bentuk yang lain (yaitu, mengambil elemen dan menggunakannya untuk mengganti setiap skalar dalam argumen lain) , dan lalu terapkan fungsi untuk setiap pasangan dari dua argumen. Dalam hal ini, ⍳Yadalah vektor dan Yskalar, jadi, jika n≡⍴⍳Y, maka Yakan dikonversi menjadi n⍴Y( ⍴mewakili bentuk (monadik) dan membentuk kembali fungsi (dyadic)). Artinya, secara lebih sederhana, Yakan dikonversi ke array yang berisi Ywaktu Y.

Sekarang, untuk setiap pasangan, sebut saja argumen kiri Xdan kanan Z(agar kita tidak bertentangan dengan input Y). ⍴⊤⊣adalah garpu diad, sehingga akan diperluas ke:

(X⍴Z)⊤X⊣Z

Mari kita buat langkah pertama yang mudah X⊣Zuntuk mengurangi menjadi X(diad ⊣adalah fungsi kiri ):

(X⍴Z)⊤X

The ⍴dalam X⍴Zadalah, sekali lagi, membentuk kembali fungsi, sehingga X⍴Z, dalam kasus kami, hanya Xkali Z. ⊤adalah fungsi encode . Diberikan dua array angka, di mana array kiri adalah basis dari setiap digit dalam hasil (tidak perlu bilangan bulat atau positif), yaitu pengkodean, dan kanan adalah array angka, mengembalikan array yang ditransposisikan dari mereka angka dalam pengkodean yang ditentukan (transposisi adalah pembalikan dimensi array relatif terhadap elemen-elemennya). Representasi digit didasarkan pada hasil bagi dari pembagian angka dan produk dari basis yang kurang signifikan. Jika ada pangkalan 0, ia bertindak sebagai basis + ∞. Skalaral argumen semuanya sederhana. Karena Xbilangan bulat positif, danX⍴Zadalah vektor elemen yang sama, ini benar-benar hanya kasus konversi Xke basis Zdan membentuk kembali ke Xangka. Untuk $X,Z\in\mathbb N$ , $X_Z$ ( $X$ dalam basis $Z$ ) tidak boleh memiliki lebih dari $X$ digit, karena $X_1$ memiliki $X$ digit. Karena itu, X⍴Zsudah cukup untuk keperluan kita.

Y(⍴⊤⊣)¨⍳YOleh karena itu, hasilnya Ydikonversi ke setiap basis dari 1 hingga Y, mungkin dengan nol di depan. Namun, ada satu masalah: di APL, basis 1 tidak khusus, sementara tantangan ini khusus, jadi kita harus memasukkan jumlah digit basis-1 dari Ydiri kita sendiri. Untungnya, jumlah ini hanya Y, karena $Y_1=\underbrace{[1,1,...,1]}_Y$ , sehingga jumlahnya hanya $Y\times1=Y$ . Oleh karena itu kita harus menambahkan Ysuatu tempat ke dalam array. Beginilah Cara kita melakukanya:

Y,Y(⍴⊤⊣)¨⍳Y

Saya sudah memasukkan bagian ini di sini. Dyadic ,adalah fungsi catenate , ia menggabungkan argumennya pada sumbu terakhir mereka, dan kesalahan jika itu tidak mungkin. Di sini, kita cukup menggabungkan skalar Yke vektor Y(⍴⊤⊣)¨⍳Y, sehingga kita menambah jumlah yang akan kita hitung Y, seperti dijelaskan di atas.

Bagian akhir adalah fungsi kiri atas kami, +/∘∊:

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

∘adalah operator menulis . f∘g Ysama dengan f g Y. Namun, kami menggunakannya di sini sehingga kereta kami tidak membayar pada ∊. Jadi, kita dapat mengurangi:

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

Sekarang, waktunya untuk penjumlahan, tapi tunggu ... ada masalah. Array tidak rata, jadi kita tidak bisa menjumlahkan elemen-elemennya sebelum meratakannya terlebih dahulu. The Terdaftar fungsi ∊merata array. Sekarang array telah diratakan, akhirnya kita gunakan +/untuk menjumlahkannya. /adalah mengurangi operator, berlaku fungsi diad antara unsur-unsur array pada kedua-untuk-terakhir porosnya, dengan prioritas kanan-ke-kiri. Jika peringkat (jumlah dimensi, yaitu panjang bentuk) dari array tidak berkurang, array kemudian ditutup, meskipun ini tidak terjadi di sini. Fungsi yang diterapkan di sini adalah +, yang merupakan plusfungsi yang menambahkan pasangan pada sumbu terakhir dari dua array (dan kesalahan jika array tidak dapat ditambahkan seperti itu). Di sini, ia hanya menambahkan dua angka beberapa kali sehingga pengurangan selesai.

Lihatlah, kereta kami:

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

Ruby , 39 37

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

Satu-satunya golf di sini adalah menghilangkan spasi. Cobalah online

Python 2 , 57 byte

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

Cobalah online!

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 terima kasih kepada @ OlivierGrégoire .

Cobalah online.

Penjelasan:

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)

$f$$f\left(n\right)$

$(65, 932)$

Desmos, 56 byte

$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;

Masukan dimasukkan setelah cards;pernyataan, pada baris baru, seperti:

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

Keluaran dataset yang berisi jawaban s(bersama dengan variabel pembantu), dengan baris untuk setiap nilai input

Tidak Disatukan:

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

Cobalah

õ!ìU c

Cobalah

J , 24 23 byte

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

Cobalah online!

05AB1E (warisan) , 5 byte

LвOO+

Cobalah online!

Penjelasan:

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

Dalam 05AB1E (warisan), basis 1 dari 5 adalah [0,0,0,0,0], bukan [1,1,1,1,1]. Karena itu setelah menjumlahkan rentang, tambahkan input ke akun untuk basis 1 yang hilang.

Saya menggunakan 05AB1E (warisan) karena pada 05AB1E saat ini, basis 1 dari 5 adalah [1]. Untuk menjelaskan ini, saya perlu mengurangi hasil dengan 1 atau menghapus elemen pertama dari rentang, yang keduanya akan menelan biaya 1 byte.

Perl 6 , 45 41 byte

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

-4 byte terima kasih kepada Jo King

Cobalah online!

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

Huruf S(spasi), T(tab), dan N(baris baru) ditambahkan hanya sebagai penyorotan.
[..._some_action]ditambahkan sebagai penjelasan saja.

Cobalah online (dengan spasi, tab, dan hanya baris baru).

Port of Java 8 saya menjawab , karena Whitespace tidak memiliki builtin Base konversi sama sekali.

Contoh dijalankan: 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

Program berhenti dengan kesalahan: Tidak ditemukan jalan keluar. (Meskipun saya bisa menambahkan tiga baris tambahan NNNuntuk menghilangkan kesalahan itu.)

R , 60 byte

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

Cobalah online!

Gagal n>143karena 144^144lebih besar dari yang doublebisa didapat. Terima kasih kepada Josh Eller karena menyarankan penggantian log(n,i)dengan sederhana n.

Di bawah ini akan berfungsi untuk n>143; tidak yakin pada titik mana ia akan berhenti bekerja.

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}

Cobalah online!

Gunakan n%/%i^(0:log(n,i))%%imetode klasik untuk mengekstraksi idigit nbasis untuk setiap basis b>1, lalu menjumlahkannya dan mengakumulasikan jumlah F, yang diinisialisasi 0, kemudian menambahkan n( 1representasi basis n) ke Fdan mengembalikan hasilnya. Untuk n=1, itu melompat dasar dan hanya menambahkan nuntuk 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))

Cobalah online!

Meskipun ini adalah solusi Dennis yang lebih lama dari yang didasarkan, saya menemukan metode terlalu lucu untuk tidak berbagi.

Tujuannya adalah untuk melakukan pengulangan pada saat memotong digit terakhir n->n/bdan menambah basis b->b+1, tetapi kami ingin mencegah kenaikan basis setelah satu atau lebih digit dikunci. Hal ini dicapai dengan menjadikan base bsebagai float, sehingga setelah pembaruan n->n//b, float bmenginfeksi ndengan floatness-nya. Dengan cara ini, apakah nfloat atau tidak adalah flag-bit untuk apakah kami telah menghapus digit apa pun dari n.

Kami mensyaratkan bahwa kondisi 1/n==0terpenuhi untuk berulang menjadi incrementing b, yang nmemuaskan bilangan bulat karena pembagian lantai dilakukan, tetapi mengapung gagal. ( n=1juga gagal tetapi kita tetap tidak ingin mengulanginya.) Jika tidak, float berfungsi seperti bilangan bulat dalam fungsi karena kita berhati-hati untuk melakukan pembagian lantai n//b, dan hasilnya adalah float bilangan bulat .

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

Port of Java 8 saya jawab .
-11 byte berkat golf @ OlivierGrégoire pada jawaban Java saya.

Cobalah online.

Penjelasan:

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

Versi ini hampir identik dengan jawaban utama saya tetapi bergantung pada aritmatika underflow untuk menghentikan rekursi. Nilai yang didukung tertinggi tergantung pada ukuran tumpukan panggilan.

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

Cobalah online!

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)

Cobalah online!

Berkomentar

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

Cobalah online!

Sekam , 6 byte

Saya benar-benar berharap ada sesuatu seperti Muntuk cmap:(

Σ§ṁ`Bḣ

Cobalah online atau uji semua!

Penjelasan

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

Atau, 6 byte

ΣΣṠMBḣ

Cobalah online atau uji semua!

Penjelasan

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

Cobalah online!

Jelly , 4 byte

bRFS

Cobalah online!

Bagaimana itu bekerja

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.

Attache , 25 byte

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

Cobalah online!

Penjelasan

{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

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

Retina 0.8.2 , 49 byte

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

1

Cobalah online! Tautan termasuk kasus uji. Penjelasan:

.+
$*

Konversikan ke unary.

1
11$`;$_¶

$n + 1$

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

Gunakan divmod berulang untuk mengkonversi nomor asli ke setiap basis.

1+;

Hapus daftar pangkalan, hanya menyisakan digit konversi basis.

1

Ambil jumlah dan konversikan ke desimal.

Desmos, 51 byte

Terinspirasi oleh jawaban Conor O'Brien dan melihat entri-OEIS saya datang dengan solusi Desmos saya sendiri:

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

Cobalah online!

APL (NARS), 29 karakter, 58 byte

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

sedikit tes tentang cara menggunakan:

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