Dato un input n, scrivere un programma o una funzione che emetta / restituisca la somma delle somme digitali di nper tutte le basi 1 a n.

Esempio:

n = 5

Crea l'intervallo [1...n]:[1,2,3,4,5]

Per ogni elemento x, ottieni una matrice delle xcifre di base di n: [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]

la base biiettiva 1di 5 è[1,1,1,1,1]

base- 2(binario) di 5 is[1,0,1]

base 3di 5 è[1,2]

base 4di 5 è[1,1]

base 5di 5 è[1,0]

Somma le cifre: 13

Casi test:

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

La sequenza è disponibile su OEIS: A131383

punteggio:

code-golf : vince l'invio con il punteggio più basso.

Tela , 3 byte

┬］∑

Provalo qui!

Tela che batte 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

Provalo online!

Spiegazione

La funzione \b n -> mapM(pure[0..b])[1..n]genera tutte le stringhe in ordine lessicografico. Per esempio:$[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]]

Indicizzando in esso con (!!n)questo può essere usato per convertire nin base b+1, tuttavia questo non funzionerà per unario (base- ), ma stiamo sommando i risultati .. Possiamo persino salvare alcuni byte con e usando base- anziché una soluzione alternativa per base- poiché ci manca che è lo stesso di quando si sommano.$1$a <- [1..n]$(n+1)$$1$$[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$$[n]$

L'uso di do-notation concatena solo tutte le liste invece di annidarle:

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

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

Provalo online!

Spiegazione

Alcune parentesi sono implicite e possono essere aggiunte (più chiare delle parentesi "ufficiali"):

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

Questo è un monadico in cima. Dato un argomento Y, questa funzione si comporta come:

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

Le due funzioni vengono applicate in ordine. Partiamo da quello giusto:

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

Ci sono tre funzioni in questo treno, quindi questa è una forcella. Dato un argomento Y, agisce come:

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

Possiamo facilmente ridurre a questo (la monade ⊢restituisce il suo argomento, quindi chiamato identità ):

Y,Y(⍴⊤⊣)¨⍳Y

Ora sappiamo che Yè un numero intero (semplice scalare, cioè numero o carattere), dal momento che ne viene dato uno. Pertanto ⍳Y, con ⎕IO=1, ritorna 1 2 ... Y. ⍳Yin realtà restituisce un array con forma Y( Ydeve essere un vettore), dove ogni scalare è l'indice di se stesso nell'array (ecco perché monadic ⍳è chiamato generatore di indice ). Questi indici sono vettori, ad eccezione del caso in cui 1≡⍴Y, dove sono scalari (questo è il nostro caso).

Analizziamo la funzione centrale,, (⍴⊤⊣)¨dopo. ⍴⊤⊣è l'operando di ¨( ciascuno ) e la funzione è diadica, quindi l' ¨operatore rimodellerà prima ogni argomento di lunghezza 1 in base alla forma dell'altro (ovvero, prenderà l'elemento e lo userà per sostituire ogni scalare nell'altro argomento) e quindi applicare la funzione a ciascuna coppia dei due argomenti. In questo caso, ⍳Yè un vettore ed Yè uno scalare, quindi, se n≡⍴⍳Y, Yverrà convertito in n⍴Y( ⍴rappresenta le funzioni forma (monadica) e rimodella (diadica)). Cioè, in termini più semplici, Yverrà convertito in un array contenente Ytempi Y.

Ora, per ogni coppia, chiamiamo l'argomento sinistro Xe destro Z(in modo da non essere in conflitto con l'input Y). ⍴⊤⊣è un fork diadico, quindi si espanderà a:

(X⍴Z)⊤X⊣Z

Facciamo il primo semplice passo per ridurre X⊣Za X(diadica ⊣è la funzione sinistra ):

(X⍴Z)⊤X

L' ⍴a X⍴Zè, ancora una volta, il rimodellare funzione, così X⍴Z, nel nostro caso, è semplicemente Xvolte Z. ⊤è la funzione di codifica . Dati due array di numeri, in cui l'array di sinistra è la base di ogni cifra nel risultato (non è necessario che sia intero o positivo), ovvero la codifica, e la destra è un array di numeri, restituisce l'array trasposto di quelli numeri nella codifica specificata (la trasposizione è l'inversione delle dimensioni di un array rispetto ai suoi elementi). La rappresentazione di una cifra si basa sul quoziente della divisione del numero e sul prodotto delle basi meno significative. Se c'è una base 0, agisce come base + ∞. Gli scalari degli argomenti sono tutti semplici. Since Xè un numero intero positivo eX⍴Zè un vettore di elementi uguali, questo è davvero solo un caso di conversione Xin base Ze rimodellamento in Xcifre. Per , ( nella base ) non può avere più di cifre, poiché ha cifre. Pertanto, è abbastanza per i nostri scopi.$X,Z\in\mathbb N$$X_Z$$X$$Z$$X$$X_1$$X$X⍴Z

Pertanto, il risultato di Y(⍴⊤⊣)¨⍳Yviene Yconvertito in ogni base da 1 a Y, possibilmente con zeri iniziali. Tuttavia, c'è un problema: in APL, la base 1 non ha un case speciale, mentre questa sfida lo fa in casi speciali, quindi dobbiamo includere la somma delle cifre della base 1 di Ynoi stessi. Fortunatamente, questa somma è solo Y, dal momento che , in modo che la somma è semplicemente . Ne consegue che dobbiamo aggiungere da qualche parte nell'array. Così è come lo facciamo noi:$Y_1=\underbrace{[1,1,...,1]}_Y$$Y\times1=Y$Y

Y,Y(⍴⊤⊣)¨⍳Y

Ho già incluso questa parte qui. Dyadic ,è la funzione catenata , concatena i suoi argomenti sui loro ultimi assi ed errori se ciò non è possibile. Qui, concateniamo semplicemente lo scalare Yal vettore Y(⍴⊤⊣)¨⍳Y, in modo da aumentare la somma che calcoleremo Y, come spiegato sopra.

La parte finale è la funzione a sinistra della nostra cima, +/∘∊:

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

∘è l' operatore di composizione . f∘g Yè lo stesso di f g Y. Tuttavia, lo stiamo usando qui in modo che il nostro treno non si biforca ∊. Quindi, possiamo ridurre:

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

Ora è il momento della somma, ma aspetta ... c'è un problema. L'array non è piatto, quindi non possiamo semplicemente sommare i suoi elementi prima di appiattirlo per primo. La enlist funzione ∊appiattisce un array. Ora che l'array è stato appiattito, finalmente riusciamo +/a sommarlo. /è l' operatore di riduzione , applica una funzione diadica tra gli elementi di una matrice sul suo penultimo asse, con priorità da destra a sinistra. Se il rango (numero di dimensioni, cioè lunghezza della forma) dell'array non diminuisce, l'array viene quindi racchiuso, anche se qui non è così. La funzione che viene applicata qui è +, che è il vantaggiofunzione che aggiunge le coppie sugli ultimi assi di due array (ed errori se gli array non possono essere aggiunti in questo modo). Qui, aggiunge semplicemente due numeri un numero di volte in modo che la riduzione sia completata.

Ecco, il nostro treno:

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

Ruby , 39 37

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

L'unico golf qui è la rimozione di alcuni spazi bianchi. Provalo online

Python 2 , 57 byte

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

Questo utilizza la formula che funziona da .

Provalo 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 grazie a @ OlivierGrégoire .

Provalo online.

Spiegazione:

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

Ecco il grafico risultante (punto a ):$(65, 932)$

Desmos, 56 byte

Questo potrebbe non funzionare su tutti i browser, ma funziona sul mio. Basta copiare e incollare la formula. Questo è nel link sopra.$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;

L'input viene inserito dopo la cards;dichiarazione, su newline, in questo modo:

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

Emette un set di dati contenente la risposta s(insieme alle variabili helper), con una riga per ciascun valore di input

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

Japt -x, 6 byte

ÆìXÄ x

Provalo

õ!ìU c

Provalo

J , 24 23 byte

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

Provalo online!

05AB1E (legacy) , 5 byte

LвOO+

Provalo online!

Spiegazione:

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

In 05AB1E (legacy), la base 1 di 5 è [0,0,0,0,0], non [1,1,1,1,1]. Pertanto, dopo aver sommato l'intervallo, aggiungere l'input per tenere conto della base mancante 1.

Sto usando 05AB1E (legacy) perché nell'attuale 05AB1E, la base 1 di 5 è [1]. Per tener conto di ciò, avrei bisogno di ridurre il risultato di 1 o rimuovere il primo elemento dell'intervallo, entrambi i quali costerebbero 1 byte.

Perl 6 , 45 41 byte

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

-4 byte grazie a Jo King

Provalo online!

Spazio bianco , 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]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Provalo online (solo con spazi non elaborati, schede e nuove righe).

Porta della mia risposta Java 8 , perché Whitespace non ha alcun builtin di conversione Base.

Esempio di esecuzione: 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

Il programma si interrompe con un errore: nessuna uscita trovata. (Anche se potrei aggiungere tre nuove righe finali NNNper eliminare quell'errore.)

R , 60 byte

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

Provalo online!

Non funziona n>143poiché 144^144è più grande di quanto si doublepossa ottenere. Grazie a Josh Eller per aver suggerito di sostituire log(n,i)semplicemente n.

Di seguito funzionerà per n>143; non so a che punto smetterà di funzionare.

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}

Provalo online!

Utilizza il n%/%i^(0:log(n,i))%%imetodo classico per estrarre le icifre di base nper ogni base b>1, quindi le somma e accumula la somma in F, che è inizializzata a 0, quindi aggiungendo n(la 1rappresentazione di base di n) Fe restituendo il risultato. Per n=1, salta le basi e semplicemente aggiunge na 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))

Provalo online!

Sebbene questa sia la soluzione più lunga di Dennis su cui si basa, trovo il metodo troppo divertente per non condividere.

L'obiettivo è quello di ricorrere sia all'eliminazione dell'ultima cifra sia all'incremento n->n/bdella base b->b+1, ma vogliamo impedire che la base venga aumentata dopo che una o più cifre sono state eliminate. Ciò si ottiene rendendo la base bun galleggiante, in modo che dopo l'aggiornamento n->n//b, il galleggiante binfetti ncon il suo galleggiamento. In questo modo, indipendentemente dal fatto che nsia float o meno, è un bit-flag per indicare se abbiamo rimosso qualsiasi cifra n.

Richiediamo che la condizione 1/n==0sia soddisfatta per ricorrere all'incremento b, che i numeri interi nsoddisfano perché viene eseguita la divisione del piano, ma i float falliscono. ( n=1fallisce anche ma non vogliamo fare ancora affidamento su di esso.) Altrimenti, i float funzionano esattamente come numeri interi nella funzione perché stiamo attenti a fare la divisione del pavimento n//be l'output è un float a numero intero.

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

Porta della mia risposta Java 8 .
-11 byte grazie al golf di @ OlivierGrégoire sulla mia risposta Java.

Provalo online.

Spiegazione:

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

Questa versione è quasi identica alla mia risposta principale, ma si basa sul underflow aritmetico per fermare la ricorsione. Il valore supportato più alto dipende dalla dimensione dello stack di chiamate.

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

Provalo 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)

Provalo online!

Commentate

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

Provalo online!

Buccia , 6 byte

Vorrei davvero che ci fosse qualcosa di simile Mper cmap:(

Σ§ṁ`Bḣ

Provalo online o prova tutto!

Spiegazione

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

In alternativa, 6 byte

ΣΣṠMBḣ

Provalo online o prova tutto!

Spiegazione

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

Provalo online!

Gelatina , 4 byte

bRFS

Provalo online!

Come funziona

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:_]'_}

Provalo online!

Spiegazione

{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

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

Provalo online! Il link include casi di test. Spiegazione:

.+
$*

Converti in unario.

1
11$`;$_¶

$n + 1$

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

Usa il divmod ripetuto per convertire il numero originale su ciascuna base.

1+;

Elimina l'elenco di basi, lasciando solo le cifre di conversione della base.

1

Prendi la somma e converti in decimale.

Desmos, 51 byte

Ispirato dalla risposta di Conor O'Brien e guardando la voce OEIS, ho trovato la mia soluzione Desmos:

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

Provalo online!

APL (NARS), 29 caratteri, 58 byte

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

piccolo test su come usare:

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