Biorąc pod uwagę dane wejściowe n, napisz program lub funkcję, która wypisuje / zwraca sumę sum cyfrowych ndla wszystkich baz 1 do n.

Przykład:

n = 5

Utwórz zakres [1...n]:[1,2,3,4,5]

Dla każdego elementu xuzyskaj tablicę xcyfr podstawowych n: [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]

bijective base- 1of 5 is[1,1,1,1,1]

base- 2(binarny) z 5 jest[1,0,1]

Base- 3o 5 Is[1,2]

Base- 4o 5 Is[1,1]

Base- 5o 5 Is[1,0]

Zsumuj cyfry: 13

Przypadki testowe:

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

Sekwencję można znaleźć w OEIS: A131383

Punktacja:

code-golf : Zgłoszenie z najniższą liczbą punktów wygrywa.

Płótno , 3 bajty

┬］∑

Wypróbuj tutaj!

Płótno bijące galaretkę?

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

Haskell , 46 bajtów

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

Wypróbuj online!

Wyjaśnienie

Funkcja \b n -> mapM(pure[0..b])[1..n]generuje wszystkie ciągi $[0 \dotsc b]^n$ porządku leksykograficznym. Na przykład:

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

Indeksując w nim za pomocą (!!n)tego można użyć do konwersji nna base b+1, jednak to nie zadziała dla unary (base- $1$ ), ale sumujemy wyniki. Możemy nawet zapisać niektóre bajty za a <- [1..n]pomocą base- $(n+1)$ zamiast obejścia dla podstawy $1$ ponieważ brakuje nam $[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$ co jest takie samo jak $[n]$ podczas sumowania.

Użycie do-notacji po prostu łączy wszystkie listy zamiast ich zagnieżdżania:

λ [ 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 bajtów

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

Wypróbuj online!

Wyjaśnienie

Niektóre nawiasy są sugerowane i można je dodać (jaśniejsze niż „oficjalne” nawiasy):

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

To monadyczny szczyt. Biorąc pod uwagę argument Y, funkcja ta zachowuje się jak:

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

Obie funkcje są stosowane w kolejności. Zaczniemy od właściwej:

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

W tym pociągu są trzy funkcje, więc jest to widelec. Podany argument Ydziała jak:

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

Możemy łatwo ⊢sprowadzić się do tego (monadic zwraca swój argument, stąd nazywany tożsamością ):

Y,Y(⍴⊤⊣)¨⍳Y

Teraz wiemy, że Yjest to liczba całkowita (prosty skalar, tj. Liczba lub znak), ponieważ otrzymaliśmy jeden. Dlatego ⍳Yz ⎕IO=1zwraca 1 2 ... Y. ⍳Yfaktycznie zwraca tablicę o kształcie Y( Ymusi być wektorem), gdzie każdy skalar jest indeksem samej tablicy (dlatego monadyczny ⍳nazywany jest generatorem indeksu ). Wskaźniki te są wektorami, z wyjątkiem przypadku, gdy1≡⍴Y , w którym są skalarami (tak jest w naszym przypadku).

(⍴⊤⊣)¨Następnie przeanalizujmy środkową funkcję . ⍴⊤⊣jest operandem ¨( każdego ), a funkcja jest dyadyczna, więc ¨operator najpierw przekształci każdy argument długości-1 na kształt drugiego (to znaczy weź element i użyje go, aby zastąpić każdy skalar w drugim argumencie) , a następnie zastosuj funkcję do każdej pary dwóch argumentów. W tym przypadku ⍳Yjest wektorem i Yjest skalarem, więc jeśli n≡⍴⍳Y, to Yzostanie przekonwertowany na n⍴Y( ⍴reprezentuje funkcje kształtu (monadyczne) i przekształcenia (dyadyczne)). Innymi słowy, Yzostanie przekonwertowany na tablicę zawierającą Yczasy Y.

Teraz dla każdej pary nazwijmy lewy argument Xi prawy Z(abyśmy nie kolidowali z danymi wejściowymi Y). ⍴⊤⊣jest widmowym widelcem, więc rozszerzy się do:

(X⍴Z)⊤X⊣Z

Zróbmy pierwszy prosty krok do zredukowania X⊣Zdo X( funkcja lewostronna⊣ to dyadic ):

(X⍴Z)⊤X

⍴W X⍴Zto, ponownie, Reshape funkcja, więc X⍴Z, w naszym przypadku, to po prostu Xczasy Z. ⊤jest funkcją kodowania . Biorąc pod uwagę dwie tablice liczb, gdzie lewa tablica jest podstawą każdej cyfry w wyniku (nie musi być liczbą całkowitą ani dodatnią), tj. Kodowanie, a prawa tablica liczb, zwraca transponowaną tablicę tych liczb liczby w określonym kodowaniu (transpozycja to odwrócenie wymiarów tablicy w stosunku do jej elementów). Reprezentacja cyfry opiera się na ilorazie podziału liczby i iloczynie mniej istotnych zasad. Jeśli jakakolwiek baza jest 0, działa jako baza + ∞. Skalary argumentów są proste. Ponieważ Xjest dodatnią liczbą całkowitą iX⍴Zjest wektorem równych elementów, tak naprawdę jest to tylko przypadek konwersji Xna bazę wystarczy do naszych celów.Zi przekształcanie Xcyfr. Dla $X,Z\in\mathbb N$ , $X_Z$ ($X$ w podstawie$Z$ ) nie może mieć więcej niż$X$ cyfr, ponieważ$X_1$ ma$X$ cyfr. W związku z tym,X⍴Z

Dlatego wynik Y(⍴⊤⊣)¨⍳Yjest Ykonwertowany na każdą bazę z 1 na Y, być może z wiodącymi zerami. Jest jednak jeden problem: w APL podstawa 1 nie jest specjalnym opakowaniem, podczas gdy to wyzwanie ma szczególny przypadek, więc musimy uwzględnić sumę cyfr podstawy 1 Y. Na szczęście, ta suma jest po prostu Y, ponieważ $Y_1=\underbrace{[1,1,...,1]}_Y$, a więc po prostu sumą$Y\times1=Y$. Wynika z tego, że musimy dodaćYgdzieś do tablicy. Tak to robimy:

Y,Y(⍴⊤⊣)¨⍳Y

Włączyłem już tę część tutaj. Dwójkowym ,jest catenate funkcja, to skleja swoje argumenty na ich ostatnie osi, a błędy, jeśli nie jest to możliwe. Tutaj po prostu łączymy skalar Yz wektorem Y(⍴⊤⊣)¨⍳Y, dzięki czemu zwiększamy sumę, którą będziemy obliczać Y, jak wyjaśniono powyżej.

Ostatnia część to lewa funkcja naszego na szczycie +/∘∊:

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

∘jest operatorem tworzenia . f∘g Yjest taki sam jak f g Y. Jednak używamy go tutaj, aby nasz pociąg nie rozwidlał się na ∊. Możemy więc zmniejszyć:

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

Czas na sumę, ale poczekaj ... jest problem. Tablica nie jest płaska, więc nie możemy po prostu zsumować jej elementów przed spłaszczeniem jej w pierwszej kolejności. Zaciągnąć funkcja ∊spłaszcza tablicę. Teraz, gdy tablica została spłaszczona, w końcu używamy jej +/do podsumowania. /jest operatorem redukcji , stosuje funkcję dyadyczną między elementami tablicy na osi od drugiej do ostatniej, z priorytetem od prawej do lewej. Jeśli ranga (liczba wymiarów, tj. Długość kształtu) tablicy nie zmniejsza się, tablica jest wówczas zamknięta, chociaż tutaj tak nie jest. Zastosowana tutaj funkcja +to plusfunkcja, która dodaje pary na ostatnich osiach dwóch tablic (i błędy, jeśli tablic nie można dodać w ten sposób). Tutaj po prostu dodaje dwie liczby wiele razy, aby redukcja została zakończona.

Oto nasz pociąg:

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

Ruby , 39 37

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

Jedynym golfem tutaj jest usunięcie białych znaków. Wypróbuj online

Python 2 , 57 bajtów

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

Wypróbuj online!

Java 8, 76 65 bajtów

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

-11 bajtów dzięki @ OlivierGrégoire .

Wypróbuj online.

Wyjaśnienie:

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 bajtów

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 bajtów

$f_2(n)$

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

SAS, 81 74 bajtów

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

Dane wejściowe są wprowadzane po cards;wyrażeniu, w znakach nowej linii, tak:

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

Wysyła zestaw danych zawierający odpowiedź s(wraz ze zmiennymi pomocniczymi) z wierszem dla każdej wartości wejściowej

Nie golfowany:

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 bajtów

ÆìXÄ x

Spróbuj

õ!ìU c

Spróbuj

J , 24 23 bajty

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

Wypróbuj online!

05AB1E (starsza wersja) , 5 bajtów

LвOO+

Wypróbuj online!

Wyjaśnienie:

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

W 05AB1E (starsza wersja) podstawa 1 z 5 wynosi [0,0,0,0,0], a nie [1,1,1,1,1]. Dlatego po zsumowaniu zakresu dodaj dane wejściowe, aby uwzględnić brakującą bazę 1.

Używam 05AB1E (starsza wersja), ponieważ w bieżącym 05AB1E podstawa 1 z 5 to [1]. Aby to wyjaśnić, musiałbym albo zmniejszyć wynik o 1, albo usunąć pierwszy element zakresu, z których oba kosztowałyby 1 bajt.

Perl 6 , 45 41 bajtów

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

-4 bajty dzięki Jo Kingowi

Wypróbuj online!

Biała spacja , 153 bajty

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

Litery S(spacja), T(tab) i N(nowa linia) dodane tylko jako wyróżnienia.
[..._some_action]dodano tylko jako wyjaśnienie.

Wypróbuj online (tylko z surowymi spacjami, tabulatorami i nowymi wierszami).

Port mojej odpowiedzi w języku Java 8 , ponieważ Whitespace nie ma żadnych wbudowanych konwersji bazowych.

Przykładowy przebieg: 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

Program zatrzymuje się z błędem: nie znaleziono wyjścia. (Chociaż mógłbym dodać trzy końcowe znaki nowej linii, NNNaby pozbyć się tego błędu).

R , 60 bajtów

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

Wypróbuj online!

Zawiedziony, n>143ponieważ 144^144jest większy niż doublemożna uzyskać. Dzięki Joshowi Ellerowi za zasugerowanie zamiany na log(n,i)po prostun .

Poniższe będzie działać dla n>143; nie jestem pewien, w którym momencie przestanie działać.

R , 67 bajtów

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

Wypróbuj online!

Używa klasycznej n%/%i^(0:log(n,i))%%imetody do wyodrębnienia icyfr npodstawowych dla każdej bazy b>1, a następnie sumuje je i gromadzi sumę F, która jest inicjowana 0, a następnie dodawana n(podstawowa 1reprezentacja n) Fi zwracana jest wynik. Za n=1to przeskakuje podstaw i po prostu dodaje nsię do F.

Python 2 , 61 bajtów

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

Wypróbuj online!

Chociaż jest to dłuższe rozwiązanie Dennisa, na którym jest oparte, uważam tę metodę za zbyt zabawną, aby się nią nie dzielić.

Celem jest powtórzenie zarówno po wykreśleniu ostatniej cyfry, jak n->n/bi zwiększeniu podstawy b->b+1, ale chcemy zapobiec zwiększeniu podstawy po usunięciu jednej lub więcej cyfr. Osiąga się to poprzez uczynienie podstawy bpływakiem, tak że po aktualizacji n->n//bpływak binfekuje nswoją pływalnością. W ten sposób, czy njest liczbą zmiennoprzecinkową, czy nie jest flagą bitową, czy usunęliśmy z niej jakieś cyfryn .

Wymagamy, aby warunek 1/n==0został spełniony, aby powracał do inkrementacji b, które liczby całkowite nspełniają, ponieważ podział podłogi jest zakończony, ale liczba zmienna nie działa. ( n=1również się nie udaje, ale i tak nie chcemy się na nim powtarzać.) W przeciwnym razie zmiennoprzecinkowe działają tak jak liczby całkowite w funkcji, ponieważ staramy się dokonywać podziału podłogi n//b, a wynikiem jest liczba zmiennoprzecinkowa.

C (gcc), 67 56 bajtów

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

Port mojej odpowiedzi Java 8 .
-11 bajtów dzięki golfowi @ OlivierGrégoire na mojej odpowiedzi Java.

Wypróbuj online.

Wyjaśnienie:

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 bajty

Ta wersja jest prawie identyczna z moją główną odpowiedzią, ale polega na niedopełnieniu arytmetycznym, aby zatrzymać rekurencję. Najwyższa obsługiwana wartość zależy od wielkości stosu wywołań.

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

Wypróbuj online!

JavaScript (ES6),  51 48  44 bajtów

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

Wypróbuj online!

Skomentował

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 bajty

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

Wypróbuj online!

Łuska , 6 bajtów

Naprawdę chciałbym, że istnieje coś takiego jak Mza cmap:(

Σ§ṁ`Bḣ

Wypróbuj online lub przetestuj wszystko!

Wyjaśnienie

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

Alternatywnie 6 bajtów

ΣΣṠMBḣ

Wypróbuj online lub przetestuj wszystko!

Wyjaśnienie

ΣΣṠ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 bajtów

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

Wypróbuj online!

Galaretka , 4 bajty

bRFS

Wypróbuj online!

Jak to działa

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 bajtów

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

Wypróbuj online!

Wyjaśnienie

{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

Węgiel drzewny , 12 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Węgiel drzewny nie może przekonwertować na bazę 1, ale na szczęście suma cyfr jest taka sama jak konwersja na bazę$n + 1$. Wyjaśnienie:

    θ           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 bajtów

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

1

Wypróbuj online! Link zawiera przypadki testowe. Wyjaśnienie:

.+
$*

Konwertuj na unary.

1
11$`;$_¶

Wymień wszystkie liczby od 2 do $n + 1$ (ponieważ jest to łatwiejsze niż konwersja podstawowa 1).

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

Użyj powtarzanego divmod, aby przekonwertować oryginalny numer na każdą bazę.

1+;

Usuń listę zasad, pozostawiając tylko podstawowe cyfry konwersji.

1

Weź sumę i przelicz na dziesiętne.

Desmos, 51 bajtów

Zainspirowany odpowiedzią Conora O'Briena i patrząc na wpis OEIS wymyśliłem własne rozwiązanie Desmos:

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

Wypróbuj online!

APL (NARS), 29 znaków, 58 bajtów

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

mały test jak używać:

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