С учетом входных данных nнапишите программу или функцию, которая выводит / возвращает сумму цифровых сумм nдля всех базисов от 1 до n.

Пример:

n = 5

Создайте диапазон [1...n]:[1,2,3,4,5]

Для каждого элемента xполучите массив базовых xцифр n: [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]

биективен base- 1из 5 IS[1,1,1,1,1]

базовый 2(двоичный) из 5 is[1,0,1]

base- 3из 5 IS[1,2]

base- 4из 5 IS[1,1]

base- 5из 5 IS[1,0]

Суммируйте цифры: 13

Тестовые случаи:

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

Последовательность может быть найдена на OEIS: A131383

Подсчет очков:

code-golf : выигрывает представление с наименьшим количеством очков.

Холст , 3 байта

┬］∑

Попробуй это здесь!

Холст бить желе?

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

Haskell , 46 байтов

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

Попробуйте онлайн!

объяснение

Функция \b n -> mapM(pure[0..b])[1..n]генерирует все строки $[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]]

Индексирование в него с помощью (!!n)этого может использоваться для преобразования nв основание b+1, однако это не будет работать для унарного (base- $1$ ), но мы суммируем результаты. Мы можем даже сохранить некоторые байты с a <- [1..n]помощью и использовать base- $(n+1)$ вместо обходного пути для base-$1$ поскольку мы пропускаем $[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$ что аналогично $[n]$ при суммировании.

Использование do-notation просто объединяет все списки вместо их вложения:

λ [ 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 байтов

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

Попробуйте онлайн!

объяснение

Некоторые скобки подразумеваются и могут быть добавлены (легче, чем «официальные» скобки):

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

Это монадическая верхушка. Учитывая аргумент Y, эта функция ведет себя так:

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

Две функции применяются по порядку. Начнем с правильного:

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

В этом поезде три функции, так что это вилка. Учитывая аргумент Y, он действует как:

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

Мы можем легко свести это к следующему (monadic ⊢возвращает свой аргумент, который называется идентичностью ):

Y,Y(⍴⊤⊣)¨⍳Y

Теперь мы знаем, что Yэто целое число (простой скаляр, то есть число или символ), так как нам дано одно. Следовательно ⍳Y, с ⎕IO=1, возвращает 1 2 ... Y. ⍳Yфактически возвращает массив с формой Y( Yдолжен быть вектором), где каждый скаляр является индексом самого себя в массиве (поэтому monadic ⍳называется генератором индекса ). Эти индексы являются векторами, за исключением случая 1≡⍴Y, когда они являются скалярами (это наш случай).

Давайте разберем среднюю функцию (⍴⊤⊣)¨, далее. ⍴⊤⊣является операндом ¨( каждого ), а функция является двоичной, поэтому ¨оператор сначала преобразует каждый аргумент длины 1 в форму другого (то есть берет элемент и использует его для замены каждого скаляра в другом аргументе). , а затем примените функцию к каждой паре двух аргументов. В этом случае, ⍳Yявляется вектором , и Yявляется скаляром, так что , если n≡⍴⍳Y, то Yбудет преобразован в n⍴Y( ⍴представляет собой форму (монадическая) и изменить форму (двоично) функций). То есть, в более простых сроках, Yбудет преобразован в массив, содержащий Yвремена Y.

Теперь для каждой пары давайте назовем левый аргумент Xи правый Z(чтобы мы не конфликтовали с входными данными Y). ⍴⊤⊣это диадическая вилка, поэтому она расширится до:

(X⍴Z)⊤X⊣Z

Давайте сделать простой первый шаг снижения X⊣Zк X(диадическим ⊣является левой функцией):

(X⍴Z)⊤X

⍴В X⍴Zэто, опять же , Reshape функция, поэтому X⍴Z, в нашем случае, это просто Xраз Z. ⊤это функция кодирования . Учитывая два массива чисел, где левый массив является базой каждой цифры в результате (не обязательно должен быть целым или положительным), т. Е. Кодировка, а право - это массив чисел, возвращает транспонированный массив тех числа в указанной кодировке (транспонирование - это обращение размеров массива относительно его элементов). Представление цифры основано на частном деления числа и произведении менее значимых оснований. Если любая база есть 0, она действует как база + ∞. Скаляры аргументов все просты. Так Xкак является положительным целым числом, иX⍴Zявляется вектором равных элементов, это на самом деле просто случай преобразования Xв основание Zи преобразования в Xцифры. Для $X,Z\in\mathbb N$ , $X_Z$ ( $X$ в базе $Z$ ) не может содержать более $X$ цифр, поскольку $X_1$ имеет $X$ цифр. Поэтому X⍴Zвполне достаточно для наших целей.

Результат Y(⍴⊤⊣)¨⍳Y, таким образом, Yпревращает в каждую базу от 1 до Y, возможно , с ведущими нулями. Тем не менее, есть одна проблема: в APL база 1 не имеет специального случая, в то время как эта задача имеет особый случай, поэтому мы должны включить сумму цифр базы-1 Yсамих себя. К счастью, эта сумма просто Y, так как $Y_1=\underbrace{[1,1,...,1]}_Y$ , поэтому сумма просто$Y\times1=Y$ . Отсюда следует, что мы должны добавитьYкуда-нибудь в массив. Вот как мы это делаем:

Y,Y(⍴⊤⊣)¨⍳Y

Я уже включил эту часть здесь. Dyadic ,- это функция catenate , она объединяет свои аргументы на последних осях и ошибки, если это невозможно. Здесь мы просто объединяем скаляр Yс вектором Y(⍴⊤⊣)¨⍳Y, так что мы увеличиваем сумму, по которой будем вычислять Y, как объяснено выше.

Последняя часть - это левая функция нашей вершины +/∘∊:

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

∘это оператор сочинения . f∘g Yтак же, как f g Y. Тем не менее, мы используем его здесь, чтобы наш поезд не раскошелился на ∊. Итак, мы можем уменьшить:

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

Теперь пришло время для суммы, но подождите ... есть проблема. Массив не является плоским, поэтому мы не можем просто суммировать его элементы, прежде чем сгладить его первым. Enlist функция ∊сглаживает массив. Теперь, когда массив был сведен, мы, наконец, используем его +/для суммирования. /является оператором уменьшения , он применяет двоичную функцию между элементами массива на его второй-последней оси с приоритетом справа налево. Если ранг (число измерений, то есть длина формы) массива не уменьшается, массив затем включается, хотя здесь это не так. Функция, которая применяется здесь +, это плюсфункция, которая добавляет пары на последних осях двух массивов (и выдает ошибки, если массивы не могут быть добавлены таким образом). Здесь он просто добавляет два числа несколько раз, чтобы уменьшение было завершено.

И вот, наш поезд

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

Руби , 39 37

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

Единственный гольф здесь удаляет некоторые пробелы. Попробуйте онлайн

Python 2 , 57 байт

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

Попробуйте онлайн!

Java 8, 76 65 байт

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

-11 байт благодаря @ OlivierGrégoire .

Попробуйте онлайн.

Объяснение:

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 байт

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 байт

$f_2(n)$

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

SAS, 81 74 байта

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

Ввод вводится после cards;оператора в новых строках, например:

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

Выводит набор данных, содержащий ответ s(вместе с вспомогательными переменными), со строкой для каждого входного значения

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 байт

ÆìXÄ x

Попытайся

õ!ìU c

Попытайся

J , 24 23 байт

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

Попробуйте онлайн!

05AB1E (legacy) , 5 байтов

LвOO+

Попробуйте онлайн!

Объяснение:

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

В 05AB1E (унаследованном) основание 1 из 5 составляет [0,0,0,0,0], а не [1,1,1,1,1]. Поэтому после суммирования диапазона добавьте вход для учета недостающей базы 1.

Я использую 05AB1E (устаревшее), потому что в текущем 05AB1E база 1 из 5 - [1]. Чтобы учесть это, мне нужно либо уменьшить результат на 1, либо удалить первый элемент диапазона, оба из которых будут стоить 1 байт.

Perl 6 , 45 41 байт

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

-4 байта благодаря Джо Кингу

Попробуйте онлайн!

Пробел , 153 байта

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

Буквы S(пробел), T(табуляция) и N(новая строка) добавляются только как подсветка.
[..._some_action]добавлено только в качестве объяснения.

Попробуйте онлайн (только с необработанными пробелами, вкладками и новыми строками).

Порт моего Java 8 ответа , потому что в Whitespace вообще нет встроенных преобразований Base.

Пример выполнения: 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

Программа останавливается с ошибкой: выход не найден. (Хотя я мог бы добавить три завершающих символа новой строки, NNNчтобы избавиться от этой ошибки.)

R , 60 байтов

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

Попробуйте онлайн!

Сбой, n>143потому 144^144что больше, чем doubleможет получить. Спасибо Джошу Эллеру за предложение заменить log(n,i)простоn .

Ниже будет работать для n>143; не уверен, в какой момент он перестанет работать.

R , 67 байт

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

Попробуйте онлайн!

Использует классический n%/%i^(0:log(n,i))%%iметод для извлечения базовых iцифр для nкаждой базы b>1, затем суммирует их и накапливает сумму F, которую инициализирует 0, затем добавляет n(базовое 1представление n) Fи возвращает результат. Ибо n=1он пропускает базы и просто добавляет nк F.

Python 2 , 61 байт

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

Попробуйте онлайн!

Хотя это дольше решение Дениса, на котором оно основано, я нахожу метод слишком забавным, чтобы не делиться им.

Цель состоит в том, чтобы выполнить рекурсию как при обрезании последней цифры, так n->n/bи приращении базы b->b+1, но мы хотим предотвратить увеличение базы после того, как одна или несколько цифр были обрезаны. Это достигается за счет того, что основание bявляется поплавком, так что после обновления n->n//bпоплавок bзаражается nсвоей плавучестью. Таким образом, nявляется ли число с плавающей точкой или нет, это бит-флаг для того, удалили ли мы какие-либо цифры n.

Мы требуем, чтобы условие 1/n==0выполнялось для приращения b, которому nудовлетворяют целые числа, потому что деление по полу выполнено, но с плавающей точкой не получается. ( n=1также терпит неудачу, но мы все равно не хотим возвращаться к нему.) В противном случае, функции с плавающей запятой работают так же, как целые числа в функции, потому что мы осторожны при делении по этажам n//b, и выводом является число с плавающей точкой.

C (gcc), 67 56 байт

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

Порт моего Java 8 ответа .
-11 байтов благодаря гольфу @ OlivierGrégoire на моем ответе на Java.

Попробуйте онлайн.

Объяснение:

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 байта

Эта версия почти идентична моему основному ответу, но полагается на арифметический недостаток, чтобы остановить рекурсию. Максимальное поддерживаемое значение зависит от размера стека вызовов.

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

Попробуйте онлайн!

JavaScript (ES6),  51 48  44 байт

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

Попробуйте онлайн!

комментарии

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 байта

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

Попробуйте онлайн!

Шелуха , 6 байт

Я очень хочу, чтобы было что-то вроде Mдля cmap:(

Σ§ṁ`Bḣ

Попробуйте онлайн или протестируйте все!

объяснение

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

В качестве альтернативы 6 байтов

ΣΣṠMBḣ

Попробуйте онлайн или протестируйте все!

объяснение

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

Пари / ГП , 30 байт

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

Попробуйте онлайн!

Желе , 4 байта

bRFS

Попробуйте онлайн!

Как это устроено

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.

Атташе , 25 байт

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

Попробуйте онлайн!

объяснение

{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

Древесный уголь , 12 байт

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

Попробуйте онлайн! Ссылка на подробную версию кода. Древесный уголь не может конвертировать в базу 1, но, к счастью, сумма цифр такая же, как и в базе$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

Сетчатка 0.8.2 , 49 байт

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

1

Попробуйте онлайн! Ссылка включает в себя тестовые случаи. Объяснение:

.+
$*

Преобразовать в одинарный.

1
11$`;$_¶

Перечислите все числа от 2 до $n + 1$ (так как это проще, чем конверсия по основанию 1).

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

Используйте многократный divmod для преобразования исходного числа в каждую базу.

1+;

Удалите список баз, оставив только цифры преобразования базы.

1

Возьмите сумму и конвертируйте в десятичную.

Десмос, 51 байт

Вдохновленный ответом Конора О'Брайена и глядя на запись OEIS, я придумал собственное решение Desmos:

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

Попробуйте онлайн!

APL (NARS), 29 символов, 58 байтов

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

небольшой тест о том, как использовать:

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