Étant donné une entrée n, écrivez un programme ou une fonction qui génère / renvoie la somme des sommes numériques de npour toutes les bases 1 à n.

Exemple:

n = 5

Créez la gamme [1...n]:[1,2,3,4,5]

Pour chaque élément x, obtenez un tableau des xchiffres de base de n: [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]

base- bijective 1de 5 est -[1,1,1,1,1]

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

base- 3de 5 est[1,2]

base- 4de 5 est[1,1]

base- 5de 5 est[1,0]

Additionnez les chiffres: 13

Cas de 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 séquence se trouve sur OEIS: A131383

Notation:

code-golf : la soumission avec le score le plus bas gagne.

Canevas , 3 octets

┬］∑

Essayez-le ici!

Toile battant la gelée?

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

Haskell , 46 octets

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

Essayez-le en ligne!

Explication

La fonction \b n -> mapM(pure[0..b])[1..n]génère toutes les chaînes $[0 \dotsc b]^n$ dans l'ordre lexicographique. Par exemple:

mapM(pure[0..2])[0..1] == [[0,0],[0,1],[0,2],[1,0],[1,1],[1,2],[2,0],[2,1],[2,2]]

En l'indexant avec, (!!n)ceci peut être utilisé pour convertir nen base b+1, mais cela ne fonctionnera pas pour unaire (base- $1$ ), mais nous résumons les résultats. Nous pouvons même enregistrer quelques octets avec a <- [1..n]et en utilisant base- $(n+1)$ plutôt qu'une solution de contournement pour la base- $1$ car il nous manque $[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$ ce qui revient au même que $[n]$ lors de la sommation.

L'utilisation de do-notation concatène simplement toutes les listes au lieu de les imbriquer:

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

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

Essayez-le en ligne!

Explication

Certaines parenthèses sont implicites et peuvent être ajoutées (plus légères que la parenthèse "officielle"):

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

Ceci est un sommet monadique. Étant donné un argumentY , cette fonction se comporte comme:

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

Les deux fonctions sont appliquées dans l'ordre. Nous allons commencer par la bonne:

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

Il y a trois fonctions dans ce train, c'est donc une fourchette. Étant donné un argumentY , il agit comme:

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

On peut facilement se réduire à cela (monadic ⊢renvoie son argument, donc appelé identité ):

Y,Y(⍴⊤⊣)¨⍳Y

Maintenant, nous savons que Yc'est un entier (scalaire simple, c'est-à-dire un nombre ou un caractère), car on nous en donne un. Par conséquent ⍳Y, avec ⎕IO=1, renvoie 1 2 ... Y. ⍳Yrenvoie en fait un tableau avec une forme Y( Ydoit être un vecteur), où chaque scalaire est l'index de lui-même dans le tableau (c'est pourquoi monadic ⍳est appelé le générateur d'index ). Ces indices sont des vecteurs, sauf dans le cas où 1≡⍴Y, où ils sont scalaires (c'est notre cas).

Analysons la fonction intermédiaire (⍴⊤⊣)¨, ensuite. ⍴⊤⊣est l'opérande de ¨( chacun ), et la fonction est dyadique, donc l' ¨opérateur remodèlera d'abord chaque argument de longueur 1 à la forme de l'autre (c'est-à-dire, prendre l'élément et l'utiliser pour remplacer chaque scalaire dans l'autre argument) , puis appliquez la fonction à chaque paire des deux arguments. Dans ce cas, ⍳Yest un vecteur et Yest un scalaire, donc, si n≡⍴⍳Y, alors Ysera converti en n⍴Y( ⍴représente les fonctions de forme (monadique) et de remodelage (dyadique)). C'est-à-dire, en termes plus simples, Ysera converti en un tableau contenant des Ytemps Y.

Maintenant, pour chaque paire, appelons l'argument gauche Xet le droit Z(afin de ne pas entrer en conflit avec l'entrée Y). ⍴⊤⊣est une fourchette dyadique, elle s'étendra donc à:

(X⍴Z)⊤X⊣Z

Faisons la première étape facile de réduire X⊣Zà X(dyadique ⊣est la fonction de gauche ):

(X⍴Z)⊤X

Le ⍴in X⍴Zest, encore une fois, la fonction de remodelage , donc X⍴Z, dans notre cas, c'est simplement le Xtemps Z. ⊤est le fonction d' encodage . Étant donné deux tableaux de nombres, où le tableau de gauche est la base de chaque chiffre du résultat (n'a pas besoin d'être entier ou positif), c'est-à-dire l'encodage, et le droit est un tableau de nombres, renvoie le tableau transposé de ceux nombres dans l'encodage spécifié (la transposition est l'inversion des dimensions d'un tableau par rapport à ses éléments). La représentation d'un chiffre est basée sur le quotient de la division du nombre et le produit des bases les moins significatives. Si une base l'est 0, elle agit comme base + ∞. Les scalaires des arguments sont tous simples. Puisque Xest un entier positif, etX⍴Zest un vecteur d'éléments égaux, c'est vraiment juste un cas de conversion Xen base Zet de remodelage en Xchiffres. Pour $X,Z\in\mathbb N$ , $X_Z$ ( $X$ dans la base $Z$ ) ne peut pas avoir plus de $X$ chiffres, car $X_1$ a $X$ chiffres. Par conséquent, X⍴Zest suffisant pour nos fins.

Le résultat de Y(⍴⊤⊣)¨⍳Yest donc Yconverti en chaque base de 1 à Y, éventuellement avec des zéros non significatifs. Cependant, il y a un problème: dans APL, la base 1 n'est pas dans un boîtier spécial, alors que ce défi le fait dans un cas spécial, nous devons donc inclure la somme des chiffres de base 1 de Ynous - mêmes. Heureusement, cette somme est juste Y, puisque $Y_1=\underbrace{[1,1,...,1]}_Y$ , de sorte que la somme est simplement $Y\times1=Y$ . Il s'ensuit que nous devons ajouter Yquelque part dans le tableau. C'est comme ça qu'on le fait:

Y,Y(⍴⊤⊣)¨⍳Y

J'ai déjà inclus cette partie ici. Dyadique ,est la fonction caténate , elle concatène ses arguments sur leurs derniers axes, et les erreurs si ce n'est pas possible. Ici, nous concaténons simplement le scalaire Yau vecteur Y(⍴⊤⊣)¨⍳Y, afin d'incrémenter la somme que nous allons calculer Y, comme expliqué ci-dessus.

La dernière partie est la fonction gauche de notre sommet, +/∘∊:

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

∘est l' opérateur de composition . f∘g Yest le même que f g Y. Cependant, nous l'utilisons ici pour que notre train ne bifurque pas sur le ∊. Ainsi, nous pouvons réduire:

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

Maintenant, il est temps pour la somme, mais attendez ... il y a un problème. Le tableau n'est pas plat, nous ne pouvons donc pas simplement additionner ses éléments avant de l'aplatir en premier. La Enlist fonction ∊aplatit un tableau. Maintenant que le tableau a été aplati, nous utilisons enfin +/pour le résumer. /est l' opérateur de réduction , il applique une fonction dyadique entre les éléments d'un tableau sur son avant-dernier axe, avec une priorité de droite à gauche. Si le rang (nombre de dimensions, c'est-à-dire la longueur de la forme) du tableau ne diminue pas, le tableau est alors inclus, bien que ce ne soit pas le cas ici. La fonction qui est appliquée ici est +, ce qui est le plusfonction qui ajoute les paires sur les derniers axes de deux tableaux (et des erreurs si les tableaux ne peuvent pas être ajoutés comme ça). Ici, il ajoute simplement deux nombres plusieurs fois pour que la réduction soit terminée.

Et voilà, notre train:

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

Rubis , 39 37

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

Le seul golf ici est de supprimer des espaces. Essayez-le en ligne

Python 2 , 57 octets

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

Essayez-le en ligne!

Java 8, 76 65 octets

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

-11 octets grâce à @ OlivierGrégoire .

Essayez-le en ligne.

Explication:

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 octets

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 octets

$f_2(n)$

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

SAS, 81 74 octets

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

L'entrée est entrée après l' cards;instruction, sur des retours à la ligne, comme ceci:

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

Génère un ensemble de données contenant la réponse s(avec des variables d'aide), avec une ligne pour chaque valeur d'entrée

Non 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 octets

ÆìXÄ x

Essayez-le

õ!ìU c

Essayez-le

J , 24 23 octets

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

Essayez-le en ligne!

05AB1E (hérité) , 5 octets

LвOO+

Essayez-le en ligne!

Explication:

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

Dans 05AB1E (hérité), la base 1 de 5 est [0,0,0,0,0], pas [1,1,1,1,1]. Par conséquent, après avoir additionné la plage, ajoutez l'entrée pour tenir compte de la base manquante 1.

J'utilise 05AB1E (hérité) car dans le 05AB1E actuel, la base 1 sur 5 est [1]. Afin de tenir compte de cela, je devrais soit décrémenter le résultat de 1, soit supprimer le premier élément de la plage, qui coûteraient tous les deux 1 octet.

Perl 6 , 45 41 octets

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

-4 octets grâce à Jo King

Essayez-le en ligne!

Espace , 153 octets

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

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté à titre d'explication uniquement.

Essayez-le en ligne (avec des espaces bruts, des tabulations et des nouvelles lignes uniquement).

Port de ma réponse Java 8 , car Whitespace n'a pas du tout de conversion de base.

Exemple d'exécution: 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

Le programme s'arrête avec une erreur: aucune sortie trouvée. (Bien que je puisse ajouter trois sauts de ligne NNNpour se débarrasser de cette erreur.)

R , 60 octets

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

Essayez-le en ligne!

Échoue n>143car 144^144est plus grand que ce que l' doubleon peut obtenir. Merci à Josh Eller d' avoir suggéré de remplacer log(n,i)simplementn .

Ce qui suit fonctionnera pour n>143; Je ne sais pas à quel moment il cessera de fonctionner.

R , 67 octets

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

Essayez-le en ligne!

Utilise la n%/%i^(0:log(n,i))%%iméthode classique pour extraire les ichiffres de base npour chaque base b>1, puis les additionne et accumule la somme F, qui est initialisée en 0, puis en ajoutant n(la 1représentation de base de n) Fet en renvoyant le résultat. Car n=1, il saute les bases et ajoute simplement nà F.

Python 2 , 61 octets

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

Essayez-le en ligne!

Bien que ce soit plus la solution de Dennis sur laquelle elle est basée, je trouve la méthode trop amusante pour ne pas la partager.

Le but est de répéter à la fois en supprimant le dernier chiffre n->n/bet en incrémentant la base b->b+1, mais nous voulons empêcher l'augmentation de la base après qu'un ou plusieurs chiffres ont été supprimés. Ceci est réalisé en faisant de la base bun flottant, de sorte qu'après la mise à jour n->n//b, le flotteur binfecte navec son flottement. De cette façon, qu'il s'agisse d' nun flottant ou non est un indicateur de bit pour savoir si nous avons supprimé des chiffres de n.

Nous exigeons que la condition 1/n==0soit remplie pour reculer en incrémentation b, ce que les entiers nsatisfont car la division du plancher est effectuée, mais les flottants échouent. ( n=1échoue également, mais nous ne voulons pas en parler de toute façon.) Sinon, les flottants fonctionnent exactement comme des entiers dans la fonction, car nous faisons attention à la division du plancher n//bet la sortie est un flottant de nombre entier.

C (gcc), 67 56 octets

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

Port de ma réponse Java 8 .
-11 octets grâce au golf de @ OlivierGrégoire sur ma réponse Java.

Essayez-le en ligne.

Explication:

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 octets

Cette version est presque identique à ma réponse principale mais s'appuie sur un sous-dépassement arithmétique pour arrêter la récursivité. La valeur prise en charge la plus élevée dépend de la taille de la pile d'appels.

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

Essayez-le en ligne!

JavaScript (ES6),  51 48  44 octets

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

Essayez-le en ligne!

Commenté

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 octets

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

Essayez-le en ligne!

Husk , 6 octets

Je souhaite vraiment qu'il y avait quelque chose comme Mpour cmap:(

Σ§ṁ`Bḣ

Essayez-le en ligne ou testez tout!

Explication

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

Alternativement, 6 octets

ΣΣṠMBḣ

Essayez-le en ligne ou testez tout!

Explication

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

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

Essayez-le en ligne!

Gelée , 4 octets

bRFS

Essayez-le en ligne!

Comment ça marche

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.

Attaché , 25 octets

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

Essayez-le en ligne!

Explication

{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

Fusain , 12 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Le charbon de bois ne peut pas être converti en base 1, mais heureusement, la somme des chiffres est la même que la conversion en base$n + 1$. Explication:

    θ           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 octets

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

1

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

.+
$*

Convertissez en unaire.

1
11$`;$_¶

Liste tous les numéros de 2 à $n + 1$ (car c'est plus facile que la conversion de base 1).

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

Utilisez divmod répété pour convertir le nombre d'origine à chaque base.

1+;

Supprimez la liste des bases, en ne laissant que les chiffres de conversion de base.

1

Prenez la somme et convertissez-la en décimale.

Desmos, 51 octets

Inspiré par la réponse de Conor O'Brien et en regardant l'entrée OEIS, j'ai trouvé ma propre solution Desmos:

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

Essayez-le en ligne!

APL (NARS), 29 caractères, 58 octets

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

petit test sur la façon d'utiliser:

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