Задавши вхід 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]]

біективна основа 1- 5 є[1,1,1,1,1]

база- 2(бінарний) of 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$( n + 1 ) 1 [ 1 , … , 1 ⏟ n  разів ] [ n ]a <- [1..n]$(n+1)$$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)

Ми можемо легко звестись до цього (монадик ⊢повертає свій аргумент, звідси називається ідентичність ):

Y,Y(⍴⊤⊣)¨⍳Y

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

Розберемо середню функцію,, (⍴⊤⊣)¨next. ⍴⊤⊣є операндом ¨( кожний ), а функція є діадичною, тому ¨оператор спочатку переформує кожен аргумент довжиною-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⍴ZXZX$X,Z\in\mathbb N$$X_Z$$X$$Z$$X$$X_1$$X$X⍴Z

Y(⍴⊤⊣)¨⍳YYYYY$Y_1=\underbrace{[1,1,...,1]}_Y$$Y\times1=Y$Y

Y,Y(⍴⊤⊣)¨⍳Y

Я вже включив сюди цю частину. Dyadic ,- це функція катенату , вона об'єднує свої аргументи на останніх осях, і помилки, якщо це неможливо. Тут ми просто прив'язуємо скаляр 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`

Десмос, 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)$

Десмос, 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(разом із допоміжними змінними) з рядком для кожного вхідного значення

Безголівки:

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 (спадщина) , 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 взагалі немає вбудованої базової конверсії.

Приклад виконання: 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, а вихід - це float з цілим числом.

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

Парі / GP , 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.

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

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

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

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

Використовуйте повторний divmod для перетворення оригінального номера в кожну базу.

1+;

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

1

Візьміть суму і перерахуйте в десяткові.

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

Натхненний відповіддю Конора О'Браєна і дивлячись на запис OEIS, я придумав своє власне рішення Десмос:

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