Bir giriş verildiğinde n, n1'den 1'e kadar olan tüm tabanların dijital toplamlarının toplamını veren / veren bir program veya işlev yazın n.

Örnek:

n = 5

Aralığı yarat [1...n]:[1,2,3,4,5]

Her eleman için x, aşağıdakilerin taban xhanelerinin bir dizisini alın n: [[1,1,1,1,1],[1,0,1],[1,2],[1,1],[1,0]]

bijective base 1ait 5 DİR[1,1,1,1,1]

base 2of (ikili) 5 , IS[1,0,1]

base 3ait 5 DİR[1,2]

base 4ait 5 DİR[1,1]

base 5ait 5 DİR[1,0]

Rakamları topla: 13

Test durumları:

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

Dizi OEIS'te bulunabilir: A131383

puanlama:

code-golf : En düşük puanı alan gönderim kazanır.

Tuval , 3 bayt

┬］∑

Burada dene!

Tuvali yenen Jelly?

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

Haskell , 46 bayt

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

Çevrimiçi deneyin!

açıklama

İşlev \b n -> mapM(pure[0..b])[1..n], tüm dizeleri , sözlük sırasına göre oluşturur. Örneğin:$[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]]

İle içine endeksleme ile (!!n)bu dönüştürmek için kullanılabilir ntabanına b+1, ancak bu irade tekli (baz-için değil iş $1$ ), ama biz toplanmasıyla sonuçlarda .. Biz can hatta bazı bayt tasarrufu ile a <- [1..n]ve baz-kullanma $(n+1)$üs - $1$ için bir çalışma yerine , toparlarken [ n ] ile aynı olan $[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$ eksik olduğumuz için .$[n]$

do-Notation kullanmak sadece iç içe yerleştirmek yerine tüm listeleri birleştirir:

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

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

Çevrimiçi deneyin!

açıklama

Bazı parantezler ima edilmiştir ve eklenebilir ("resmi" parantezden daha hafif):

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

Bu bir monadik üstünde. Bir argüman verildiğinde Y, bu işlev şöyle davranır:

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

İki fonksiyon sırayla uygulanır. Doğru olandan başlayacağız:

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

Bu trende üç fonksiyon var, bu bir çatal. Bir argüman verildiğinde Y, şöyle davranır:

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

Bunu kolayca azaltabiliriz (monadiç ⊢argümanını, dolayısıyla kimliği olarak adlandırılır ):

Y,Y(⍴⊤⊣)¨⍳Y

Şimdi, bunun Ybir tamsayı olduğunu biliyoruz (basit skalar, yani sayı veya karakter), çünkü bize bir tane verildi. Bu nedenle ⍳Y, ile ⎕IO=1döner 1 2 ... Y. ⍳Yaslında her skaler dizideki dizinidir (bu yüzden monadik indeks üreteci olarak adlandırılır ) şeklinde bir diziyi Y( Ybir vektör olmalıdır) döndürür . Bu endeksler, skalar oldukları durumlar hariç vektörlerdir (bu bizim durumumuzdur).⍳1≡⍴Y

(⍴⊤⊣)¨Sıradaki orta işlevi çözümleyelim . ( her birinin ) ⍴⊤⊣işlenenidir ve işlev iki yönlüdür, bu nedenle işleç ilk önce uzunluk-1 argümanını diğerinin biçimine göre yeniden şekillendirir (yani, öğeyi alır ve diğer argümandaki her skalayı değiştirmek için kullanır) , ve sonra işlevi iki argümanın her çiftine uygulayın. Bu durumda, bir vektördür ve skalerdir, öyleyse, eğer öyleyse dönüştürülecektir ( şekli temsil eder (monadik) ve yeniden şekillendir (dyadic) fonksiyonlar). Olduğunu, daha basit anlamda, içeren bir diziye dönüştürülen olacaktır kez .¨¨⍳YYn≡⍴⍳YYn⍴Y⍴YYY

Şimdi, her bir çift için, sol argümanı Xve sağı çağıralım Z(böylece girdiyle çakışmamak için Y). ⍴⊤⊣ikili bir çatal olduğu için genişleyecektir:

(X⍴Z)⊤X⊣Z

Let en azaltma kolay ilk adım yapmak X⊣Ziçin X(diyadik ⊣olan sol fonksiyonu):

(X⍴Z)⊤X

⍴İçinde X⍴Zyine, bir yeniden biçimlendirme işlevi, yani X⍴Z, bizim durumumuzda, basitçe Xkere Z. ⊤olan kodlama fonksiyonu. İki sayı dizisi göz önüne alındığında, sol dizilim sonuçtaki her basamağın temelidir (tam sayı veya pozitif olması gerekmez), yani kodlama ve sağ sayı dizisidir, bunların çevrilmiş dizisini döndürür belirtilen kodlamadaki sayılar (aktarım, dizinin boyutlarına göre boyutlarının tersidir). Bir basamağın temsili, sayının bölünmesi ve daha az önemli olan bazların çarpımına dayanır. Herhangi bir baz ise 0, baz + ∞ olarak işlev görür. Argümanların skalarlarının hepsi basittir. Bu yana Xbir pozitif tamsayıdır, veX⍴Zeşit elemanların bir vektörüdür, bu gerçekten sadece Xtabana dönüştürme Zve Xrakamlara yeniden şekil verme durumudur . İçin $X,Z\in\mathbb N$ , $X_Z$ ( $X$ baz içinde $Z$ ) fazla olamaz $X$ çünkü, basamak $X_1$ olan $X$ basamak. Dolayısıyla X⍴Zamaçlarımız için yeterli.

Bunun sonucu olarak Y(⍴⊤⊣)¨⍳Y, Yher bir tabana 1'den Y, muhtemelen öncü sıfırlarla dönüştürülür. Bununla birlikte, bir sorun var: APL'de, temel 1 özel amaçlı değil, bu zorluk özel durum olsa da, bu nedenle Ykendimizi temel 1 basamağının toplamını dahil etmemiz gerekiyor . Neyse ki, bu miktar, sadece bir Yberi $Y_1=\underbrace{[1,1,...,1]}_Y$ , bu yüzden toplam basitçe $Y\times1=Y$ . YDiziye bir yere eklememiz gerekecek . Biz bunu böyle yaparız:

Y,Y(⍴⊤⊣)¨⍳Y

Bu kısmı zaten buraya dahil ettim. Diyadik ,olan catenate onların son eksenleri üzerindeki argümanları birleştirir ve hataları bu mümkün değilse, işlevi. Burada, skalar'ı Yvektör ile birleştiririz Y(⍴⊤⊣)¨⍳Y, böylece Yyukarıda açıklandığı gibi hesaplayacağımız toplamı arttırırız.

Son bölüm, tepemizdeki sol fonksiyondur +/∘∊:

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

∘olduğu oluştur operatörü. f∘g Yaynıdır f g Y. Bununla birlikte, burada kullanıyoruz ki trenimiz çatallanmasın ∊. Böylece azaltabiliriz:

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

Şimdi, toplama zamanı, ama bekle ... bir sorun var. Dizi düz değildir, bu nedenle ilk önce düzleştirmeden önce öğelerini toplayamayız. Enlist fonksiyonu ∊bir dizi düzleştirir. Şimdi dizi düzleştirildi, sonunda +/onu toplamak için kullandık. /olduğunu azaltmak operatör, doğru sola öncelikli, onun ikinci-to-son ekseninde bir dizinin elemanları arasında bir diyadik fonksiyonunu uygular. Dizinin sıralaması (boyut sayısı, yani uzunluk uzunluğu) düşmezse, bu durum burada olmasa da, dizi eklenir. Burada uygulanan fonksiyon +, artı olanİki dizinin son eksenlerine çiftleri ekleyen işlev (ve diziler böyle eklenemezse hatalar). Burada, azaltma işleminin tamamlanabilmesi için birkaç kez iki sayı ekliyor.

Lo ve işte, trenimiz:

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

Ruby , 39 37

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

Buradaki tek golf, biraz boşluk bırakıyor. Çevrimiçi deneyin

Python 2 , 57 bayt

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

Çevrimiçi deneyin!

Java 8, 76 65 bayt

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

@ OlivierGrégoire sayesinde -11 bayt .

Çevrimiçi deneyin.

Açıklama:

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 bayt

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 bayt

$f_2(n)$

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

SAS, 81 74 bayt

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

Girdi, cards;ifadeden sonra yeni satırlarda şöyle yapılır:

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

sHer giriş değeri için bir satırla birlikte , cevabı içeren bir veri kümesini (yardımcı değişkenlerle birlikte) çıkarır

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 bayt

ÆìXÄ x

Dene

õ!ìU c

Dene

J , 24 23 bayt

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

Çevrimiçi deneyin!

05AB1E (eski) , 5 bayt

LвOO+

Çevrimiçi deneyin!

Açıklama:

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'de (eski), 5 tabanının 1'i [0,01,0,0], [1,1,1,1,1] değildir. Bu nedenle, aralığı topladıktan sonra, eksik taban 1 için hesaba giriş ekleyin.

05AB1E (eski) kullanıyorum, çünkü şu andaki 05AB1E'de baz 5'in 1'i [1]. Bunu hesaba katmak için sonucu 1 ile düşürmem veya aralığın ilk elemanını kaldırmam gerekecek, ikisi de 1 bayta mal olacak.

Perl 6 , 45 41 bayt

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

Jo King sayesinde -4 bayt

Çevrimiçi deneyin!

Boşluk , 153 bayt

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

Harfler S(boşluk), T(sekme) ve N(yeni satır) yalnızca vurgulama olarak eklenmiştir.
[..._some_action]sadece açıklama olarak eklendi.

Çevrimiçi deneyin (yalnızca ham alanlar, sekmeler ve yeni satırlarla).

Port Benim Java 8 cevap , hiç Boşluk çünkü hiçbir Taban dönüşüm builtins.

Örnek çalışma: 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 bir hata ile bitiyor: Çıkış bulunamadı. (Her ne kadar NNNbu hatadan kurtulmak için sondaki üç yeni satır ekleyebilirim .)

R , 60 bayt

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

Çevrimiçi deneyin!

n>143Çünkü başarısız olan , alabileceğinden 144^144daha büyük double. Basitçe değiştirmeyi önerdiğiniz için Josh Eller'e teşekkür ederiz .log(n,i)n

Aşağıdakiler için çalışacak n>143; Hangi noktada çalışmayı durduracağından emin değilim.

R , 67 bayt

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

Çevrimiçi deneyin!

Klasik kullanır n%/%i^(0:log(n,i))%%ibaz-çıkarmak için bir yöntem iiçin basamak nher bir üs için b>1, daha sonra bunları toplar ve bir miktar birikir Fiçin başlatılır, 0daha sonra aşağıdakileri ekleyerek, n(baz 1temsil ait niçin) Fve sonucu geri gönderilmesi. İçin n=1, bu ekler sadece üsleri atlar ve nhiç F.

Python 2,61 bayt

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

Çevrimiçi deneyin!

Bu daha uzun sürmesine rağmen Dennis'in dayandığı çözüm bu yöntemi paylaşmamak için çok eğlenceli buluyorum.

Amaç, hem son haneye basmak hem n->n/bde tabanı artırmak için tekrar elde etmektir b->b+1, ancak bir veya daha fazla basamak atıldıktan sonra bazın artmasını önlemek istiyoruz. Bu, tabanı bbir şamandıra haline getirerek gerçekleştirilir , böylece güncellemeden sonra n->n//bşamandıra şamandıra ile benfekte nolur. Bu şekilde, nbir kayan nokta olup olmadığına göre ondan herhangi bir rakam çıkarmamış mıyız diye bir bayrak n.

1/n==0Koşulun b, nkat bölünmesi yapıldığı halde yüzdürme başarısız olduğu için tamsayıların tatmin edici şekilde artması için yerine getirilmesini şart koşuyoruz . ( n=1ayrıca başarısız olur, ancak yine de tekrarlanmasını istemeyiz.) Aksi halde, yüzdürmeler işlevdeki tamsayılar gibi çalışır, çünkü zemin bölünmesi yapmak için dikkatliyiz n//bve çıktı tam sayıdaki bir yüzdürmedir.

C (gcc), 67 56 bayt

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 cevabımın limanı . @ OlivierGrégoire 'in Java cevabındaki golf oyunu
sayesinde 11 bayt .

Çevrimiçi deneyin.

Açıklama:

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 bayt

Bu sürüm benim temel cevabımla neredeyse aynı, ancak özyinelemeyi durdurmak için aritmetik akışa dayanıyor. Desteklenen en yüksek değer arama yığınının boyutuna bağlıdır.

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

Çevrimiçi deneyin!

JavaScript (ES6),  51 48  44 bayt

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

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

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

Çevrimiçi deneyin!

kabuk , 6 bayt

Gerçekten böyle bir şey olduğunu ister Miçin cmap:(

Σ§ṁ`Bḣ

Çevrimiçi deneyin ya da hepsini test edin!

açıklama

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

Alternatif olarak, 6 bayt

ΣΣṠMBḣ

Çevrimiçi deneyin ya da hepsini test edin!

açıklama

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

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

Çevrimiçi deneyin!

Jöle , 4 bayt

bRFS

Çevrimiçi deneyin!

Nasıl çalışır

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.

Ataşesi , 25 bayt

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

Çevrimiçi deneyin!

açıklama

{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

Kömür , 12 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Kömür 1 tabanına dönüşemez, ancak neyse ki rakam toplamı, tabana dönüşüm ile aynıdır.$n + 1$. Açıklama:

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

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

1

Çevrimiçi deneyin! Link, test durumlarını içerir. Açıklama:

.+
$*

Birliğe dönüştür.

1
11$`;$_¶

2'den tüm numaraları listele $n + 1$ (temel 1 dönüşümden daha kolay olduğu için).

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

Orijinal sayıyı her bir tabana dönüştürmek için tekrarlı divmod kullanın.

1+;

Yalnızca temel dönüştürme basamaklarını bırakarak taban listesini silin.

1

Toplamı al ve ondalık dönüştür.

Desmos, 51 bayt

Conor O'Brien'ın cevabından ilham alan ve OEIS girişine baktığımda kendi Desmos çözümümle geldim:

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

Çevrimiçi deneyin!

APL (NARS), 29 karakter, 58 bayt

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

nasıl kullanılacağı hakkında küçük bir test:

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