Dada uma entrada n, escreva um programa ou função que produz / retorna a soma das somas digitais de ntodas as bases de 1 a n.

Exemplo:

n = 5

Crie o intervalo [1...n]:[1,2,3,4,5]

Para cada elemento x, obtenha uma matriz dos xdígitos base de n: [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]

base- bijectiva 1de 5 seja[1,1,1,1,1]

base- 2(binária) de 5 é[1,0,1]

base 3de 5 é[1,2]

base 4de 5 é[1,1]

base 5de 5 é[1,0]

Soma os dígitos: 13

Casos de teste:

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

A sequência pode ser encontrada no OEIS: A131383

Pontuação:

código-golfe : A finalização com a menor pontuação vence.

Tela , 3 bytes

┬］∑

Experimente aqui!

Lona batendo Jelly?

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

Haskell , 46 bytes

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

Experimente online!

Explicação

A função \b n -> mapM(pure[0..b])[1..n]gera todas as strings em ordem lexicográfica. Por exemplo:$[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]]

A indexação nele com (!!n)isso pode ser usada para converter nem base b+1, mas isso não funcionará para unário (base ), mas estamos somando os resultados. Podemos até salvar alguns bytes com e usando base- vez de uma para a base uma vez que faltam que é o mesmo que ao somar.$1$( n + 1 ) 1 [ 1 , … , 1 ⏟ n  vezes ] [ n ]a <- [1..n]$(n+1)$$1$$[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$$[n]$

Usar do-notation apenas concatena todas as listas em vez de aninhá-las:

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

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

Experimente online!

Explicação

Alguns parênteses estão implícitos e podem ser adicionados (mais leve que o parênteses "oficial"):

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

Este é um monádico no topo. Dado um argumento Y, essa função se comporta como:

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

As duas funções são aplicadas em ordem. Começaremos do caminho certo:

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

Existem três funções neste trem, portanto, este é um garfo. Dado um argumento Y, ele atua como:

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

Podemos facilmente reduzir isso (o monádico ⊢retorna seu argumento, portanto chamado identidade ):

Y,Y(⍴⊤⊣)¨⍳Y

Agora, sabemos que Yé um número inteiro (escalar simples, ou seja, número ou caractere), já que recebemos um. Portanto ⍳Y, com ⎕IO=1, retorna 1 2 ... Y. ⍳Yna verdade, retorna uma matriz com forma Y( Ydeve ser um vetor), onde cada escalar é o próprio índice na matriz (é por isso que a monádica ⍳é chamada de gerador de índice ). Esses índices são vetores, exceto no caso em que 1≡⍴Yonde estão escalares (este é o nosso caso).

Vamos analisar a função do meio (⍴⊤⊣)¨, a seguir. ⍴⊤⊣é o operando de ¨( each ) e a função é diádica; portanto, o ¨operador remodelará primeiro cada argumento de comprimento 1 para a forma do outro (ou seja, pega o elemento e o usa para substituir todos os escalares do outro argumento) e, em seguida, aplique a função a cada par dos dois argumentos. Neste caso, ⍳Yé um vector e Yum escalar, portanto, se n≡⍴⍳Y, em seguida, Yirá ser convertido em n⍴Y( ⍴representa a forma (monadic) e remodelar () funções diádicos). Ou seja, em termos mais simples, Yserá convertido em uma matriz contendo Ytempos Y.

Agora, para cada par, vamos chamar o argumento esquerdo Xe o direito Z(para que não entremos em conflito com a entrada Y). ⍴⊤⊣é uma bifurcação diádica, então ela será expandida para:

(X⍴Z)⊤X⊣Z

Vamos fazer o primeiro passo fácil de reduzir X⊣Zpara X(diádico ⊣é a função esquerda ):

(X⍴Z)⊤X

O ⍴in X⍴Zé, novamente, a função remodelar , portanto X⍴Z, no nosso caso, são simplesmente Xtempos Z. ⊤é a função de codificação . Dadas duas matrizes de números, em que a matriz esquerda é a base de cada dígito no resultado (não precisa ser inteiro ou positivo), ou seja, a codificação e a direita é uma matriz de números, retorna a matriz transposta daqueles números na codificação especificada (transposição é a reversão das dimensões de uma matriz em relação aos seus elementos). A representação de um dígito é baseada no quociente da divisão do número e no produto das bases menos significativas. Se houver uma base 0, ela atua como base + ∞. Os escalares dos argumentos são todos simples. Como Xé um número inteiro positivo, eX⍴Zé um vetor de elementos iguais, este é realmente apenas um caso de conversão Xpara base Ze remodelação para Xdígitos. Para , ( na base ) não pode ter mais de dígitos, pois tem dígitos. Portanto, é suficiente para nossos propósitos.$X,Z\in\mathbb N$$X_Z$$X$$Z$$X$$X_1$$X$X⍴Z

O resultado de Y(⍴⊤⊣)¨⍳Yé, portanto, Yconvertido em cada base de 1 para Y, possivelmente com zeros à esquerda. No entanto, há um problema: no APL, a base 1 não é especial, enquanto esse desafio é especial, então precisamos incluir a soma dos dígitos da base 1 de Ynós mesmos. Felizmente, esta soma é apenas Y, uma vez , então a soma é simplesmente . Daqui resulta que temos que adicionar algum lugar à matriz. É assim que nós fazemos:$Y_1=\underbrace{[1,1,...,1]}_Y$$Y\times1=Y$Y

Y,Y(⍴⊤⊣)¨⍳Y

Eu já incluí esta parte aqui. Dyadic ,é a concatenar função, ele concatena seus argumentos em seus últimos eixos, e os erros se isso não é possível. Aqui, simplesmente concatenamos o escalar Ypara o vetor Y(⍴⊤⊣)¨⍳Y, para incrementar a soma pela qual calcularemos Y, conforme explicado acima.

A parte final é a função esquerda do nosso topo +/∘∊:

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

∘é o operador de composição . f∘g Yé o mesmo que f g Y. No entanto, estamos usando aqui para que nosso trem não bata no ∊. Então, podemos reduzir:

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

Agora, é hora da soma, mas espere ... há um problema. A matriz não é plana, portanto, não podemos somar seus elementos antes de nivelá-la primeiro. A função alistar∊ nivela uma matriz. Agora que o array foi achatado, finalmente usamos +/para somar. /é o operador de redução , ele aplica uma função diádica entre os elementos de uma matriz em seu penúltimo eixo, com prioridade da direita para a esquerda. Se a classificação (número de dimensões, ou seja, comprimento da forma) da matriz não diminuir, a matriz será incluída, embora esse não seja o caso aqui. A função aplicada aqui é +, qual é a vantagemfunção que adiciona os pares nos últimos eixos de duas matrizes (e erros se as matrizes não puderem ser adicionadas assim). Aqui, ele simplesmente adiciona dois números várias vezes para que a redução seja concluída.

Eis que nosso trem:

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

Ruby , 39 37

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

O único golfe aqui é remover algum espaço em branco. Experimente online

Python 2 , 57 bytes

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

Isso usa a fórmula que funciona desde .

Experimente online!

Java 8, 76 65 bytes

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

-11 bytes graças a @ OlivierGrégoire .

Experimente online.

Explicação:

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 bytes

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)

Experimente aqui! Define uma função , chamada como . Usa a fórmula dada na resposta de Dennis .$f$$f\left(n\right)$

Aqui está o gráfico resultante (aponte para ):$(65, 932)$

Desmos, 56 bytes

Isso pode não funcionar em todos os navegadores, mas funciona no meu. Basta copiar e colar a fórmula. Este é no link acima.$f_2(n)$

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

SAS, 81 74 bytes

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

A entrada é inserida após a cards;instrução, em novas linhas, da seguinte forma:

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

Gera um conjunto de dados que contém a resposta s(junto com variáveis ​​auxiliares), com uma linha para cada valor de entrada

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

Japonês -x, 6 bytes

ÆìXÄ x

Tente

õ!ìU c

Tente

J , 24 23 bytes

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

Experimente online!

05AB1E (herdado) , 5 bytes

LвOO+

Experimente online!

Explicação:

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

Em 05AB1E (legado), a base 1 de 5 é [0,0,0,0,0], não [1,1,1,1,1]. Portanto, depois de somar o intervalo, adicione a entrada para contabilizar a base 1 ausente.

Estou usando 05AB1E (legado) porque no atual 05AB1E, a base 1 de 5 é [1]. Para explicar isso, eu precisaria diminuir o resultado em 1 ou remover o primeiro elemento do intervalo, que custaria 1 byte.

Perl 6 , 45 41 bytes

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

-4 bytes graças a Jo King

Experimente online!

Espaço em branco , 153 bytes

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

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente online (apenas com espaços brutos, guias e novas linhas).

Porta da minha resposta do Java 8 , porque o Whitespace não possui nenhum recurso de conversão Base.

Exemplo de execução: 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

O programa para com um erro: Nenhuma saída encontrada. (Embora eu possa adicionar três novas linhas finais NNNpara se livrar desse erro.)

R , 60 bytes

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

Experimente online!

Falha n>143desde que 144^144é maior do que um doublepode obter. Agradecemos a Josh Eller por sugerir a substituição log(n,i)por simplesmente n.

O abaixo irá trabalhar para n>143; não tenho certeza em que ponto ele irá parar de funcionar.

R , 67 bytes

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

Experimente online!

Usa o n%/%i^(0:log(n,i))%%imétodo clássico para extrair os idígitos base nde cada base b>1, depois os soma e acumula a soma em F, que é inicializada e 0, em seguida, adicionando n(a 1representação básica de n) Fe retornando o resultado. Pois n=1, ele pula as bases e simplesmente adiciona na F.

Python 2 , 61 bytes

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

Experimente online!

Embora essa seja a solução de Dennis mais longa, ela considera o método divertido demais para não ser compartilhado.

O objetivo é se dedicar tanto ao corte do último dígito n->n/bquanto ao incremento da base b->b+1, mas queremos impedir que a base seja aumentada depois que um ou mais dígitos foram cortados. Isso é feito transformando a base em bum flutuador, para que, após a atualização n->n//b, o flutuador seja binfectado ncom sua flutuabilidade. Dessa forma, se né um float ou não, é um sinalizador de bit para se removemos algum dígito n.

Exigimos que a condição 1/n==0seja atendida para recorrer ao incremento b, que os números inteiros nsatisfazem porque a divisão do piso é feita, mas os flutuadores falham. ( n=1também falha, mas não queremos recursá-lo de qualquer maneira.) Caso contrário, os flutuadores funcionam como números inteiros na função porque temos o cuidado de fazer a divisão do piso n//b, e a saída é um número inteiro.

C (gcc), 67 56 bytes

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

Porta da minha resposta Java 8 .
-11 bytes graças ao golfe de @ OlivierGrégoire na minha resposta Java.

Experimente online.

Explicação:

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 bytes

Esta versão é quase idêntica à minha resposta principal, mas depende do fluxo aritmético para interromper a recursão. O valor mais alto suportado depende do tamanho da pilha de chamadas.

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

Experimente online!

JavaScript (ES6),  51 48  44 bytes

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

Experimente online!

Comentado

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 bytes

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

Experimente online!

Casca , 6 bytes

Eu realmente gostaria que houvesse algo como Mpor cmap:(

Σ§ṁ`Bḣ

Experimente online ou teste tudo!

Explicação

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

Como alternativa, 6 bytes

ΣΣṠMBḣ

Experimente online ou teste tudo!

Explicação

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

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

Experimente online!

Gelatina , 4 bytes

bRFS

Experimente online!

Como funciona

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.

Anexo , 25 bytes

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

Experimente online!

Explicação

{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

Carvão , 12 bytes

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

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

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

1

Experimente online! O link inclui casos de teste. Explicação:

.+
$*

Converta para unário.

1
11$`;$_¶

$n + 1$

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

Use divmod repetido para converter o número original em cada base.

1+;

Exclua a lista de bases, deixando apenas os dígitos da conversão de base.

1

Pegue a soma e converta para decimal.

Desmos, 51 bytes

Inspirado pela resposta de Conor O'Brien e olhando para a entrada da OEIS, criei minha própria solução Desmos:

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

Experimente online!

APL (NARS), 29 caracteres, 58 bytes

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

pequeno teste de como usar:

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