Dada una entrada n, escriba un programa o función que genere / devuelva la suma de las sumas digitales de ntodas las bases 1 a n.

Ejemplo:

n = 5

Crea el rango [1...n]:[1,2,3,4,5]

Para cada elemento x, obtenga una matriz de los xdígitos base de n: [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]

base biyectiva 1de 5 es[1,1,1,1,1]

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

base 3de 5 es[1,2]

base 4de 5 es[1,1]

base 5de 5 es[1,0]

Suma los dígitos: 13

Casos de prueba:

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 secuencia se puede encontrar en OEIS: A131383

Tanteo:

code-golf : gana la presentación con la puntuación más baja.

Lienzo , 3 bytes.

┬］∑

Pruébalo aquí!

¿Lienzo golpeando a 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

Pruébalo en línea!

Explicación

La función \b n -> mapM(pure[0..b])[1..n]genera todas las cadenas en orden lexicográfico. Por ejemplo:$[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]]

Al indexarlo con (!!n)esto se puede usar para convertir na base b+1, sin embargo, esto no funcionará para unary (base- ), pero estamos sumando los resultados. Incluso podemos guardar algunos bytes con y usando base- lugar de una para base- ya que nos falta que es lo mismo que Al resumir.$1$a <- [1..n]$(n+1)$$1$$[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$$[n]$

Usar do-notation solo concatena todas las listas en lugar de anidarlas:

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

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

Pruébalo en línea!

Explicación

Algunos paréntesis están implícitos y se pueden agregar (más claro que el paréntesis "oficial"):

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

Esta es una cima monádica. Dado un argumento Y, esta función se comporta como:

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

Las dos funciones se aplican en orden. Comenzaremos por el correcto:

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

Hay tres funciones en este tren, por lo que este es un tenedor. Dado un argumento Y, actúa como:

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

Podemos reducir fácilmente a esto (monadic ⊢devuelve su argumento, por lo tanto, se llama identidad ):

Y,Y(⍴⊤⊣)¨⍳Y

Ahora, sabemos que Yes un número entero (escalar simple, es decir, número o carácter), ya que se nos da uno. Por lo tanto ⍳Y, con ⎕IO=1, vuelve 1 2 ... Y. ⍳Yen realidad devuelve una matriz con forma Y( Ydebe ser un vector), donde cada escalar es el índice de sí mismo en la matriz (es por eso que monadic ⍳se llama generador de índice ). Estos índices son vectores, excepto el caso donde 1≡⍴Y, donde son escalares (este es nuestro caso).

Analicemos la función del medio (⍴⊤⊣)¨, siguiente. ⍴⊤⊣es el operando de ¨( cada uno ), y la función es diádica, por lo que el ¨operador primero cambiará la forma de cada argumento de longitud 1 a la forma del otro (es decir, tome el elemento y úselo para reemplazar cada escalar en el otro argumento) , y luego aplica la función a cada par de los dos argumentos. En este caso, ⍳Yes un vector y Yes un escalar, por lo tanto, si n≡⍴⍳Y, entonces Yse convertirá en n⍴Y( ⍴representa las funciones de forma (monádica) y remodelar (diádica). Es decir, en términos más simples, Yse convertirá en una matriz que contiene Ytiempos Y.

Ahora, para cada par, llamemos al argumento izquierdo Xy al derecho Z(para que no entremos en conflicto con la entrada Y). ⍴⊤⊣es un tenedor diádico, por lo que se expandirá a:

(X⍴Z)⊤X⊣Z

Hagamos el primer paso fácil de reducir X⊣Za X(dyadic ⊣es la función izquierda ):

(X⍴Z)⊤X

La función ⍴in X⍴Zes, nuevamente, la función de remodelación , por lo que X⍴Z, en nuestro caso, son simplemente Xtiempos Z. ⊤es la función de codificación Dadas dos matrices de números, donde la matriz izquierda es la base de cada dígito en el resultado (no necesita ser entero o positivo), es decir, la codificación, y la derecha es una matriz de números, devuelve la matriz transpuesta de esos números en la codificación especificada (la transposición es la inversión de las dimensiones de una matriz en relación con sus elementos). La representación de un dígito se basa en el cociente de la división del número y el producto de las bases menos significativas. Si alguna base es 0, actúa como base + ∞. Los escalares de los argumentos son todos simples. Como Xes un entero positivo, yX⍴Zes un vector de elementos iguales, esto es realmente solo un caso de conversión Xa base Zy remodelación a Xdígitos. Para , ( en base ) no puede tener más de dígitos, ya que tiene dígitos. Por lo tanto, es suficiente para nuestros propósitos.$X,Z\in\mathbb N$$X_Z$$X$$Z$$X$$X_1$$X$X⍴Z

El resultado de Y(⍴⊤⊣)¨⍳Y, por lo tanto, se Yconvierte a cada base de 1 a Y, posiblemente con ceros a la izquierda. Sin embargo, hay un problema: en APL, la base 1 no está en mayúsculas especiales, mientras que este desafío sí lo hace en casos especiales, por lo que debemos incluir la suma de los dígitos de base 1 de Ynosotros mismos. Afortunadamente, esta suma es sólo Y, ya que , por lo que la suma es simplemente . Se deduce que tenemos que agregar en algún lugar de la matriz. Así es como lo hacemos:$Y_1=\underbrace{[1,1,...,1]}_Y$$Y\times1=Y$Y

Y,Y(⍴⊤⊣)¨⍳Y

Ya he incluido esta parte aquí. Dyadic ,es la función catenada , concatena sus argumentos en sus últimos ejes y errores si eso no es posible. Aquí, simplemente concatenamos el escalar Yal vector Y(⍴⊤⊣)¨⍳Y, de modo que incrementemos la suma por la que vamos a calcular Y, como se explicó anteriormente.

La parte final es la función izquierda de nuestra cima +/∘∊:

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

∘es el operador de redacción . f∘g Yes el mismo que f g Y. Sin embargo, lo estamos usando aquí para que nuestro tren no se bifurque en el ∊. Entonces, podemos reducir:

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

Ahora es el momento de la suma, pero espera ... hay un problema. La matriz no es plana, por lo que no podemos simplemente sumar sus elementos antes de aplanarla primero. La función enlist∊ aplana una matriz. Ahora que la matriz ha sido aplanada, finalmente la utilizamos +/para sumarla. /es el operador de reducción , aplica una función diádica entre los elementos de una matriz en su penúltimo eje, con prioridad de derecha a izquierda. Si el rango (número de dimensiones, es decir, la longitud de la forma) de la matriz no disminuye, la matriz se encierra, aunque este no es el caso aquí. La función que se aplica aquí es +, que es el plusfunción que agrega los pares en los últimos ejes de dos matrices (y errores si las matrices no se pueden agregar así). Aquí, simplemente agrega dos números varias veces para que se complete la reducción.

He aquí, nuestro tren:

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

Ruby , 39 37

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

El único juego de golf aquí es eliminar algunos espacios en blanco. Pruébalo en línea

Python 2 , 57 bytes

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

Pruébalo en línea!

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

Pruébalo en línea.

Explicación:

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)

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

$(65, 932)$

Desmos, 56 bytes

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

La entrada se ingresa después de la cards;declaración, en líneas nuevas, así:

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

Emite un conjunto de datos que contiene la respuesta s(junto con las variables auxiliares), con una fila para cada valor de entrada

Sin golf:

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 bytes

ÆìXÄ x

Intentalo

õ!ìU c

Intentalo

J , 24 23 bytes

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

Pruébalo en línea!

05AB1E (heredado) , 5 bytes

LвOO+

Pruébalo en línea!

Explicación:

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

En 05AB1E (heredado), la base 1 de 5 es [0,0,0,0,0], no [1,1,1,1,1]. Por lo tanto, después de sumar el rango, agregue la entrada para tener en cuenta la base 1 que falta.

Estoy usando 05AB1E (heredado) porque en el 05AB1E actual, la base 1 de 5 es [1]. Para dar cuenta de esto, necesitaría disminuir el resultado en 1 o eliminar el primer elemento del rango, los cuales costarían 1 byte.

Perl 6 , 45 41 bytes

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

-4 bytes gracias a Jo King

Pruébalo en línea!

Espacio en blanco , 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]

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

El puerto de mi respuesta Java 8 , porque Whitespace no tiene ninguna conversión de base integrada.

Ejemplo de ejecución: 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

El programa se detiene con un error: no se encontró ninguna salida. (Aunque podría agregar tres líneas nuevas NNNpara eliminar ese error).

R , 60 bytes

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

Pruébalo en línea!

Falla n>143porque 144^144es más grande de lo que se doublepuede obtener. Gracias a Josh Eller por sugerir reemplazarlo log(n,i)simplemente n.

Lo siguiente funcionará para n>143; No estoy seguro de en qué punto dejará 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}

Pruébalo en línea!

Utiliza el n%/%i^(0:log(n,i))%%imétodo clásico para extraer los idígitos de base npara cada base b>1, luego los suma y acumula la suma F, que se inicializa 0, luego agrega n(la 1representación de base de n) Fy devuelve el resultado. Para n=1, se salta las bases y simplemente se agrega 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))

Pruébalo en línea!

Aunque esta es la solución de Dennis en la que se basa, el método me parece demasiado divertido para no compartirlo.

El objetivo es recurrir tanto al cortar el último dígito n->n/bcomo al incrementar la base b->b+1, pero queremos evitar que la base se incremente después de que uno o más dígitos hayan sido cortados. Esto se logra haciendo que la base sea bflotante, de modo que después de la actualización n->n//b, el flotante binfecte ncon su flotabilidad. De esta manera, si nes flotante o no, es un indicador de bits para saber si hemos eliminado algún dígito n.

Requerimos que 1/n==0se cumpla la condición para que se repita en incrementos b, que los enteros nsatisfacen porque la división del piso se realiza, pero las flotaciones fallan. ( n=1también falla, pero no queremos repetirlo de todos modos). De lo contrario, los flotantes funcionan como enteros en la función porque tenemos cuidado de hacer la división del piso n//b, y la salida es un flotante de números enteros.

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

Puerto de mi respuesta Java 8 .
-11 bytes gracias al golf de @ OlivierGrégoire en mi respuesta Java.

Pruébalo en línea.

Explicación:

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 versión es casi idéntica a mi respuesta principal, pero se basa en el flujo subyacente aritmético para detener la recurrencia. El valor admitido más alto depende del tamaño de la pila de llamadas.

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

Pruébalo en línea!

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)

Pruébalo en línea!

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

Pruébalo en línea!

Casco , 6 bytes

Realmente deseo que haya algo como Mpara cmap:(

Σ§ṁ`Bḣ

¡Pruébalo en línea o prueba todo!

Explicación

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

Alternativamente, 6 bytes

ΣΣṠMBḣ

¡Pruébalo en línea o prueba todo!

Explicación

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

Pruébalo en línea!

Jalea , 4 bytes

bRFS

Pruébalo en línea!

Cómo 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.

Adjunto , 25 bytes

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

Pruébalo en línea!

Explicación

{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

Carbón de leña , 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

Pruébalo en línea! El enlace incluye casos de prueba. Explicación:

.+
$*

Convierte a unario.

1
11$`;$_¶

$n + 1$

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

Use divmod repetido para convertir el número original a cada base.

1+;

Elimine la lista de bases, dejando solo los dígitos de conversión de base.

1

Toma la suma y convierte a decimal.

Desmos, 51 bytes

Inspirado por la respuesta de Conor O'Brien y mirando la entrada de OEIS, se me ocurrió mi propia solución Desmos:

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

Pruébalo en línea!

APL (NARS), 29 caracteres, 58 bytes

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

pequeña prueba sobre cómo usar:

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