nSchreiben Sie bei einer gegebenen Eingabe ein Programm oder eine Funktion, die die Summe der digitalen Summen nfür alle Basen 1 bis 1 ausgibt / zurückgibt n.

Beispiel:

n = 5

Erstellen Sie den Bereich [1...n]:[1,2,3,4,5]

xErhalten Sie für jedes Element ein Array der Basisziffern xvon n: [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]

bijektive Basis 1von 5 ist[1,1,1,1,1]

Basis- 2(binär) von 5 ist[1,0,1]

Basis 3von 5 ist[1,2]

Basis 4von 5 ist[1,1]

Basis 5von 5 ist[1,0]

Summiere die Ziffern: 13

Testfälle:

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

Die Sequenz finden Sie in OEIS: A131383

Wertung:

Code-Golf : Die Einsendung mit der niedrigsten Punktzahl gewinnt.

Canvas , 3 Bytes

┬］∑

Probieren Sie es hier aus!

Leinwand schlagen Gelee?

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

Haskell , 46 Bytes

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

Probieren Sie es online!

Erläuterung

Die Funktion \b n -> mapM(pure[0..b])[1..n]generiert alle Zeichenfolgen in lexikografischer Reihenfolge. Beispielsweise:$[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]]

Indiziert man es mit (!!n)this, kann man es in nbase konvertieren. b+1Dies funktioniert jedoch nicht für unary (base- ), aber wir summieren die Ergebnisse. Wir können sogar einige Bytes mit base- speichern anstelle einer Umgehung für Basis- da fehlt was dasselbe ist wie beim summieren.$1$a <- [1..n]$(n+1)$$1$$[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$$[n]$

Mit do-notation werden nur alle Listen verkettet, anstatt sie zu verschachteln:

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

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

Probieren Sie es online!

Erläuterung

Einige Klammern sind impliziert und können hinzugefügt werden (leichter als die "offizielle" Klammerung):

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

Dies ist eine monadische Spitze. Bei einem gegebenen Argument Yverhält sich diese Funktion wie folgt:

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

Die beiden Funktionen werden der Reihe nach angewendet. Wir werden von der richtigen beginnen:

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

Das sind drei Funktionen in diesem Zug, das ist also eine Gabel. Wenn ein Argument vorliegt Y, handelt es wie folgt:

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

Wir können uns leicht darauf beschränken (monadic ⊢gibt sein Argument zurück, daher auch Identität genannt ):

Y,Y(⍴⊤⊣)¨⍳Y

Nun wissen wir, dass Yes sich um eine Ganzzahl handelt (einfacher Skalar, dh Zahl oder Zeichen), da uns eine gegeben wird. Daher kehrt ⍳Ymit ⎕IO=1zurück 1 2 ... Y. ⍳YGibt tatsächlich ein Array mit einer Form zurück Y( Ymuss ein Vektor sein), wobei jeder Skalar der Index seiner selbst im Array ist (deshalb wird monadisch ⍳als Indexgenerator bezeichnet ). Diese Indizes sind Vektoren, außer in dem Fall 1≡⍴Y, in dem sie Skalare sind (dies ist unser Fall).

Lassen Sie uns als (⍴⊤⊣)¨nächstes die mittlere Funktion analysieren . ⍴⊤⊣ist der Operand von ¨( each ), und die Funktion ist dyadisch, sodass der ¨Operator zuerst jedes Argument der Länge 1 in die Form des anderen umformt (dh das Element nimmt und es verwendet, um jeden Skalar im anderen Argument zu ersetzen). Wenden Sie die Funktion dann auf jedes Paar der beiden Argumente an. In diesem Fall ⍳Yist ein Vektor und Yist ein Skalar. Wenn also n≡⍴⍳Y, Ywird konvertiert in n⍴Y( ⍴repräsentiert die Form- (monadisch) und Umformungs- (dyadisch) Funktionen). Das heißt, einfacher ausgedrückt, Ywird in ein Array konvertiert, das YZeiten enthält Y.

Nennen wir nun für jedes Paar das linke Xund das rechte Argument Z(damit wir nicht mit der Eingabe in Konflikt geraten Y). ⍴⊤⊣ist eine dyadische Gabel, daher wird sie sich ausdehnen auf:

(X⍴Z)⊤X⊣Z

Machen wir den einfachen ersten Schritt der Reduktion X⊣Zauf X(dyadisch ⊣ist die linke Funktion):

(X⍴Z)⊤X

Das ⍴In X⍴Zist wieder die Umformfunktion , also X⍴Zin unserem Fall einfach Xmal Z. ⊤ist die Codierungsfunktion . Bei zwei Zahlenarrays, bei denen das linke Array die Basis jeder Ziffer im Ergebnis ist (muss nicht ganzzahlig oder positiv sein), dh die Codierung und das rechte Array ist ein Zahlenarray, wird das transponierte Array dieser Zahlen zurückgegeben Zahlen in der angegebenen Codierung (Transposition ist die Umkehrung der Abmessungen eines Arrays in Bezug auf seine Elemente). Die Darstellung einer Ziffer basiert auf dem Quotienten aus der Division der Zahl und dem Produkt der weniger signifikanten Basen. Wenn eine Basis vorhanden ist 0, fungiert sie als Basis + ∞. Die Skalare der Argumente sind alle einfach. Da Xist eine positive ganze Zahl, undX⍴ZIst ein Vektor gleicher Elemente, ist dies wirklich nur ein Fall der Umwandlung Xin Basis Zund der Umformung in XZiffern. Für , ( in der Basis ) nicht mehr als haben Ziffern, da hat Ziffern. Daher reicht es für unsere Zwecke.$X,Z\in\mathbb N$$X_Z$$X$$Z$$X$$X_1$$X$X⍴Z

Das Ergebnis von Y(⍴⊤⊣)¨⍳Ywird daher Yin jede Basis von 1 nach konvertiert Y, möglicherweise mit führenden Nullen. Es gibt jedoch ein Problem: In APL ist Basis 1 kein Sonderfall, wohingegen diese Herausforderung ein Sonderfall ist. Daher müssen wir die Summe der Basis-1-Ziffern von Yuns selbst einbeziehen. Glücklicherweise ist diese Summe einfachY , da ist . Daraus folgt, dass wir irgendwo in das Array hinzufügen müssen . So machen wir es:$Y_1=\underbrace{[1,1,...,1]}_Y$$Y\times1=Y$Y

Y,Y(⍴⊤⊣)¨⍳Y

Ich habe diesen Teil bereits hier aufgenommen. Dyadic ,ist die Catenate- Funktion, sie verkettet ihre Argumente auf der letzten Achse und gibt Fehler aus, wenn dies nicht möglich ist. Hier verketten wir einfach den Skalar Ymit dem Vektor Y(⍴⊤⊣)¨⍳Y, so dass wir die Summe, um die wir berechnen Y, erhöhen, wie oben erläutert.

Der letzte Teil ist die linke Funktion unserer Spitze +/∘∊:

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

∘ist der Compose- Operator. f∘g Yist das gleiche wie f g Y. Wir setzen es hier jedoch ein, damit unser Zug nicht auf die Straße fährt ∊. So können wir reduzieren:

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

Jetzt ist es Zeit für die Summe, aber warte ... es gibt ein Problem. Das Array ist nicht flach, daher können wir seine Elemente nicht einfach summieren, bevor wir es zuerst reduzieren. Die Enlist- Funktion ∊reduziert ein Array. Nun, da das Array abgeflacht wurde, verwenden wir es endlich, um es +/zu summieren. Wenn es sich /um den Reduktionsoperator handelt , wird eine dyadische Funktion zwischen den Elementen eines Arrays auf seiner vorletzten Achse mit der Priorität von rechts nach links angewendet. Wenn der Rang (Anzahl der Dimensionen, dh Länge der Form) des Arrays nicht abnimmt, wird das Array eingeschlossen, obwohl dies hier nicht der Fall ist. Die Funktion, die hier angewendet wird +, ist das PlusFunktion, die die Paare auf den letzten Achsen von zwei Arrays hinzufügt (und Fehler, wenn die Arrays nicht so hinzugefügt werden können). Hier werden einfach zwei Zahlen mehrmals hinzugefügt, damit die Reduzierung abgeschlossen ist.

Siehe, unser Zug:

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

Ruby , 39 37

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

Das einzige Golfspiel hier ist das Entfernen von Leerzeichen. Probieren Sie es online aus

Python 2 , 57 Bytes

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

Probieren Sie es online!

Java 8, 76 65 Bytes

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

-11 Bytes dank @ OlivierGrégoire .

Probieren Sie es online aus.

Erläuterung:

n->{           // Method with integer as both parameter and return-type
  int r=n,     //  Result-sum, starting at the input to account for Base-1
      b=n,     //  Base, starting at the input
      N;       //  Temp integer
  for(;b>1     //  Loop the Base `b` in the range [n, 1):
      ;b--)    //    After every iteration: Go to the next Base (downwards)
    for(N=n;   //   Set `N` to the input `n`
        N>0;   //   Loop as long as `N` isn't 0 yet:
        N/=b)  //     After every iteration: Divide `N` by the Base `b`
      r+=N%b;  //    Increase the result `r` by `N` modulo the Base `b`
  return r;}   //  Return the result-sum `r`

Desmos, 127 Bytes

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

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

$(65, 932)$

Desmos, 56 Bytes

$f_2(n)$

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

SAS, 81 74 Bytes

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

Die Eingabe erfolgt nach der cards;Anweisung in Zeilenumbrüchen wie folgt:

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

Gibt einen Datensatz mit der Antwort s(zusammen mit Hilfsvariablen) mit einer Zeile für jeden Eingabewert aus

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 Bytes

ÆìXÄ x

Versuch es

õ!ìU c

Versuch es

J , 24 23 Bytes

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

Probieren Sie es online!

05AB1E (Legacy) , 5 Byte

LвOO+

Probieren Sie es online!

Erläuterung:

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

In 05AB1E (Legacy) ist Basis 1 von 5 [0,0,0,0,0] und nicht [1,1,1,1,1]. Fügen Sie daher nach dem Summieren des Bereichs die Eingabe hinzu, um die fehlende Basis 1 zu berücksichtigen.

Ich verwende 05AB1E (Legacy), da in 05AB1E Basis 1 von 5 [1] ist. Um dies zu berücksichtigen, müsste ich entweder das Ergebnis um 1 dekrementieren oder das erste Element des Bereichs entfernen, was beide 1 Byte kosten würde.

Perl 6 , 45 41 Bytes

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

-4 Bytes dank Jo King

Probieren Sie es online!

Leerzeichen , 153 Bytes

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_STDIN_as_integer][T   T   T   _Retrieve_input][S N
S _Duplicate_input][N
S S N
_Create_Label_OUTER_LOOP][S N
S _Duplicate_top][S S S T   N
_Push_1][T  S S T   _Subtract][N
T   S S N
_If_0_Jump_to_Label_PRINT][S S S N
_Push_0][S N
S _Duplicate_0][T   T   T   _Retrieve_input][N
S S T   N
_Create_Label_INNER_LOOP][S N
S _Duplicate][N
T   S S S N
_If_0_Jump_to_Label_AFTER_INNER_LOOP][S N
T   _Swap_top_two][S T  S S T   N
_Copy_1st_item_to_top][S T  S S T   T   N
_Copy_3rd_item_to_top][T    S T T   _Modulo][T  S S S _Add][S N
T   _Swap_top_two][S T  S S T   S N
_Copy_2nd_item_to_top][T    S T S _Integer_divide][N
S N
T   N
_Jump_to_Label_INNER_LOOP][N
S S S S N
_Create_Label_AFTER_INNER_LOOP][S N
N
_Discard_top][S T   S S T   S N
_Copy_2nd_item_to_top][T    S S S _Add][S N
T   _Swap_top_two][S S S T  N
_Push_1][T  S S T   _Subtract][N
S N
N
_Jump_to_Label_OUTER_LOOP][N
S S S N
_Create_Label_PRINT][S N
N
_Discard_top][T N
S T _Print_as_integer]

Buchstaben S(Leerzeichen), T(Tabulator) und (Zeilenvorschub) werden Nnur als Hervorhebungen hinzugefügt.
[..._some_action]nur als Erklärung hinzugefügt.

Probieren Sie es online aus (nur mit Leerzeichen, Tabulatoren und Zeilenumbrüchen).

Port meiner Java 8 Antwort , da Whitespace überhaupt keine Base-Konvertierung eingebaut hat.

Beispiellauf: 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

Programm stoppt mit Fehler: Kein Exit gefunden. (Obwohl ich drei nachgestellte Zeilen hinzufügen könnte NNN, um diesen Fehler zu beseitigen .)

R , 60 Bytes

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

Probieren Sie es online!

Scheitert denn n>143da 144^144ist größer als doubleman bekommen kann. Vielen Dank an Josh Eller , der vorgeschlagen hat, log(n,i)durch simply zu ersetzen n.

Das Folgende wird funktionieren für n>143; Ich bin mir nicht sicher, wann es nicht mehr funktioniert.

R , 67 Bytes

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

Probieren Sie es online!

Verwendet die klassischen n%/%i^(0:log(n,i))%%iVerfahren die basen- zu extrahieren iZiffern nfür jede Base b>1, dann summiert sie und reichert sich in der Summe F, die initialisiert wird 0, dann Zugabe n(der 1Basisdarstellung n) zu Fund die Rückkehr des Ergebnisses. Für n=1, überspringt er die Grundlagen und fügt einfach nzu F.

Python 2 , 61 Bytes

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

Probieren Sie es online!

Obwohl dies länger ist als die Lösung von Dennis, auf der es basiert, finde ich die Methode zu amüsant, um sie nicht zu teilen.

Das Ziel besteht darin, sowohl das Löschen der letzten Ziffer n->n/bals auch das Inkrementieren der Basis zu wiederholen. b->b+1Wir möchten jedoch verhindern, dass die Basis erhöht wird, nachdem eine oder mehrere Ziffern gelöscht wurden. Dies wird erreicht, indem die Basis zu beinem Float gemacht wird, so dass n->n//bder Float nach dem Update mit seiner Floatness binfiziert nwird. Auf diese Weise nist es ein Bit-Flag , ob ein Float vorliegt oder nicht , um festzustellen, ob Ziffern aus entfernt wurden n.

Wir fordern, dass die Bedingung 1/n==0erfüllt ist, um in Inkremente überzugehen b, die Ganzzahlen nerfüllen, weil die Bodenteilung durchgeführt wird, Floats jedoch fehlschlagen. ( n=1Scheitert auch, aber wir möchten es trotzdem nicht wiederholen.) Andernfalls funktionieren Floats genau wie Ganzzahlen in der Funktion, da die Floor-Division sorgfältig durchgeführt n//bwird und die Ausgabe ein Float mit ganzen Zahlen ist.

C (gcc) 67 56 Bytes

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

Port meiner Java 8 Antwort .
-11 Bytes dank @ OlivierGrégoires Golf auf meiner Java-Antwort.

Probieren Sie es online aus.

Erläuterung:

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 Byte

Diese Version ist fast identisch mit meiner Hauptantwort, stützt sich jedoch auf einen arithmetischen Unterlauf, um die Rekursion zu stoppen. Der höchste unterstützte Wert hängt von der Größe des Aufrufstapels ab.

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

Probieren Sie es online!

JavaScript (ES6),  51 48  44 Byte

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

Probieren Sie es online!

Kommentiert

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 Byte

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

Probieren Sie es online!

Schale , 6 Bytes

Ich wünschte wirklich, es gäbe etwas Mfür cmap:(

Σ§ṁ`Bḣ

Probieren Sie es online aus oder testen Sie alle!

Erläuterung

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

Alternativ 6 Bytes

ΣΣṠMBḣ

Probieren Sie es online aus oder testen Sie alle!

Erläuterung

ΣΣṠMBḣ  -- example input: 5
  Ṡ     -- apply .. 
     ḣ  -- | range: [1,2,3,4,5]
           .. to function applied to itself
   MB   -- | map over left argument of base
        -- : [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]
 Σ      -- flatten: [1,1,1,1,1,1,0,1,1,2,1,1,1,0]
Σ       -- sum: 13

Pari / GP , 30 Bytes

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

Probieren Sie es online!

Gelee , 4 Bytes

bRFS

Probieren Sie es online!

Wie es funktioniert

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 Bytes

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

Probieren Sie es online!

Erläuterung

{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

Kohle , 12 Bytes

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

$n + 1$

    θ           First input
   Ｉ            Cast to integer
  Ｅ             Map over implicit range
        θ       First input
       Ｉ        Cast to integer
      ↨         Converted to base
           ι    Current index
         ⁺      Plus
          ²     Literal 2
     Σ          Sum
 Σ              Grand total
Ｉ               Cast to string
                Implicitly print

Retina 0.8.2 , 49 Bytes

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

1

Probieren Sie es online! Link enthält Testfälle. Erläuterung:

.+
$*

In Unary konvertieren.

1
11$`;$_¶

$n + 1$

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

Verwende wiederholtes divmod, um die ursprüngliche Zahl in jede Basis umzuwandeln.

1+;

Löschen Sie die Liste der Basen, und lassen Sie nur die Basisumrechnungsziffern übrig.

1

Nimm die Summe und rechne sie in eine Dezimalzahl um.

Desmos, 51 Bytes

Inspiriert von der Antwort von Conor O'Brien und dem OEIS-Eintrag, kam ich auf meine eigene Desmos-Lösung:

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

Probieren Sie es online!

APL (NARS), 29 Zeichen, 58 Byte

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

kleiner Test zur Verwendung von:

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