डिजिटल योग

Question

एक इनपुट को देखते हुए n, एक प्रोग्राम या फ़ंक्शन लिखें जो nसभी आधारों के लिए 1 के लिए डिजिटल योगों का आउटपुट / रिटर्न देता है n।

$$n + \sum_{b=2}^n \sum_{i=0}^\infty \left\lfloor \frac{n}{b^i} \right\rfloor \bmod b$$

उदाहरण:

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

bijective base- 1का 5 है[1,1,1,1,1]

आधार- 2(द्विआधारी) का 5 है[1,0,1]

आधार- 3का 5 है[1,2]

आधार- 4का 5 है[1,1]

आधार- 5का 5 है[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

स्कोरिंग:

कोड-गोल्फ : सबसे कम स्कोर के साथ सबमिशन जीतता है।

Comments

एक मजेदार एक 227 -> 9999:। और भी 1383 -> 345678:।

— अरनौलड

Answer 1

कैनवास , 3 बाइट्स

┬］∑

यहाँ कोशिश करो!

कैनवस की पिटाई जेली?

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

Answer 2

हास्केल , 46 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

फ़ंक्शन \b n -> mapM(pure[0..b])[1..n], सभी स्ट्रिंग उत्पन्न करता है lexicographic क्रम में। उदाहरण के लिए:$[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, हालांकि यह अनरी (आधार ) के लिए काम नहीं करेगा , लेकिन हम परिणामों को जोड़ रहे हैं .. हम आधार के साथ और प्रयोग करके कुछ बाइट्स भी बचा सकते हैं - बेस- लिए एक काम के इर्द-गिर्द - बाद से हम लापता हैं जो कि के समान है। जब योग।$1$a <- [1..n]$(n+1)$$1$$[\underset{n\text{ times}}{\underbrace{1,\dotsc,1}}]$$[n]$

उपयोग- doनोटेशन केवल सभी नामों को सूचीबद्ध करने के बजाय उन्हें संक्षिप्त करता है:

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

Answer 3

एपीएल (डायलॉग यूनिकोड) , 14 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

कुछ कोष्ठकों को निहित किया गया है और जोड़ा जा सकता है ("आधिकारिक" कोष्ठक की तुलना में हल्का):

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

यह एक मोनोडिक परमाणु है। एक तर्क को देखते हुए Y, यह फ़ंक्शन इस तरह व्यवहार करता है:

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

दो कार्यों को क्रम में लागू किया जाता है। हम सही से शुरू करेंगे:

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

इस ट्रेन में तीन कार्य हैं, इसलिए यह एक कांटा है। एक तर्क को देखते हुए Y, यह निम्नानुसार कार्य करता है:

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

हम इसे आसानी से कम कर सकते हैं (मोनैडिक ⊢अपना तर्क देता है, इसलिए इसे पहचान कहा जाता है ):

Y,Y(⍴⊤⊣)¨⍳Y

अब, हम जानते हैं कि Yएक पूर्णांक (साधारण स्केलर, अर्थात संख्या या वर्ण) है, क्योंकि हम एक हैं। इसलिए ⍳Y, ⎕IO=1रिटर्न के साथ 1 2 ... Y। ⍳Yवास्तव में आकार के साथ एक सरणी देता है Y( Yएक वेक्टर होना चाहिए), जहां हर स्केलर सरणी में खुद का सूचकांक है (यही कारण है कि मोनैडिक ⍳को सूचकांक जनरेटर कहा जाता है )। ये सूचकांक वैक्टर हैं, केवल मामले को छोड़कर 1≡⍴Y, जहां वे स्केलर हैं (यह हमारा मामला है)।

चलो (⍴⊤⊣)¨अगले , मध्य समारोह को पार्स करते हैं । ( प्रत्येक ) ⍴⊤⊣का ऑपरेंड है , और फ़ंक्शन डाइएडिक है, इसलिए ऑपरेटर पहले प्रत्येक लंबाई -1 तर्क को दूसरे के आकार में बदल देगा (यानी, तत्व ले लो और इसका उपयोग दूसरे तर्क में प्रत्येक स्केलर को बदलने के लिए करें) , और फिर दो तर्कों की प्रत्येक जोड़ी के लिए फ़ंक्शन लागू करें। इस मामले में, एक वेक्टर है और इसलिए, अगर एक अदिश है, है, तो में परिवर्तित हो जाएगा ( प्रतिनिधित्व करता आकार (monadic) और आकृति बदलें (dyadic) फ़ंक्शन)। अर्थात्, सरल शब्दों में, एक सरणी वाले समय में परिवर्तित हो जाएगा ।¨¨⍳YYn≡⍴⍳YYn⍴Y⍴YYY

अब, प्रत्येक जोड़ी के लिए, बाएं तर्क Xऔर दाएं को कॉल करें Z(ताकि हम इनपुट के साथ संघर्ष न करें Y)। ⍴⊤⊣एक डाईडिक कांटा है, इसलिए इसका विस्तार होगा:

(X⍴Z)⊤X⊣Z

चलो कम करने का आसान पहला कदम बनाने X⊣Zके लिए X(dyadic ⊣है बाईं समारोह):

(X⍴Z)⊤X

⍴में X⍴Zहै, फिर से, आकृति बदलें समारोह, इसलिए X⍴Z, हमारे मामले में, बस है Xबार Z। ⊤है एनकोड कार्य करते हैं। संख्याओं के दो सरणियों को देखते हुए, जहां बाएं सरणी परिणाम में प्रत्येक अंक का आधार है (पूर्णांक या सकारात्मक होने की आवश्यकता नहीं है), यानी एन्कोडिंग, और दाईं ओर संख्याओं की एक सरणी है, उन लोगों के ट्रांसपोंड सरणी को लौटाता है निर्दिष्ट एन्कोडिंग में संख्याएँ (ट्रांसपोज़न इसके तत्वों के सापेक्ष एक सरणी के आयाम का उलटा है)। एक अंक का प्रतिनिधित्व संख्या के विभाजन और कम महत्वपूर्ण आधारों के उत्पाद के भागफल पर आधारित होता है। यदि कोई आधार है 0, तो यह आधार + base के रूप में कार्य करता है। तर्कों के स्केल सभी सरल हैं। चूंकि Xएक सकारात्मक पूर्णांक है, औरX⍴Zसमान तत्वों का एक सदिश है, यह वास्तव में केवल Xआधार को रूपांतरित करने Zऔर Xअंकों में फेरबदल करने का मामला है । के लिए , ( आधार में ) की तुलना में अधिक नहीं हो सकता है , अंकों के बाद से है अंक। इसलिए, हमारे उद्देश्यों के लिए पर्याप्त है।$X,Z\in\mathbb N$$X_Z$$X$$Z$$X$$X_1$$X$X⍴Z

का परिणाम Y(⍴⊤⊣)¨⍳Yइसलिए, है Y1 से प्रत्येक आधार करने के लिए परिवर्तित Y, संभवतः अग्रणी शून्य के साथ। हालांकि, एक मुद्दा है: एपीएल में, आधार 1 को विशेष-आवरण नहीं किया गया है, जबकि यह चुनौती विशेष-मामले में है, इसलिए हमें स्वयं के आधार -1 अंकों का योग शामिल Yकरना होगा। सौभाग्य से, यह राशि सिर्फ है Y, के बाद से , इसलिए योग बस है । यह इस प्रकार है कि हमें सरणी में कहीं जोड़ना होगा। हम इसे ऐसे करते हैं:$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

अब, यह राशि के लिए समय है, लेकिन प्रतीक्षा करें ... एक समस्या है। सरणी समतल नहीं है, इसलिए हम पहले इसके तत्वों को पहले समतल करने से पहले योग नहीं कर सकते। भर्ती समारोह ∊एक सरणी सपाट। अब जब कि सरणी समतल हो गई है, तो हम अंत में इसका उपयोग +/करते हैं। /यह कम करने वाला ऑपरेटर है, यह अपनी दूसरी से आखिरी धुरी पर एक सरणी के तत्वों के बीच दाईं-बाईं प्राथमिकता के साथ एक डाइएडिक फ़ंक्शन को लागू करता है। यदि सरणी की रैंक (आयामों की संख्या, अर्थात आकार की लंबाई) कम नहीं होती है, तो सरणी को फिर से संलग्न किया जाता है, हालांकि यहां ऐसा नहीं है। यहां जो फ़ंक्शन लागू किया गया है +, वह प्लस हैफ़ंक्शन जो दो सरणियों के अंतिम अक्षों पर जोड़े को जोड़ता है (और यदि एरर्स को उस तरह नहीं जोड़ा जा सकता है)। यहां, यह बस दो बार कई नंबर जोड़ता है ताकि कमी पूरी हो जाए।

लो और निहारना, हमारी ट्रेन:

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

Comments

+1 प्रभावशाली व्याख्या। छोटा नहीं है, लेकिन कोई +/∘∊⊢,⊢⊤¨⍨⊢⍴¨⍳

— पैरेंस

@ Adám धन्यवाद! जब मैं इसे लिख रहा था तब मैं लगभग सो रहा था। :-P

— आउटगॉल्फ

@ अपने संस्करण के बारे में, ऐसा लगता है कि यह समझने में अधिक कठिन है। ;-)

— द एग्ज़ोलर

Answer 4

रूबी , ३ ९ ३ 37

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

यहां एकमात्र गोल्फिंग कुछ व्हाट्सएप को हटा रहा है। इसे ऑनलाइन आज़माएं

Comments

@Giuseppe ओपी के साथ शुरू होता है: "एक इनपुट एन को देखते हुए, (...)"। मैं लंबे समय तक यहां नहीं रहा। क्या समाधान के लिए आवश्यकताओं की कहीं सूची है?

— स्टेन्सलैग

आमतौर पर यह एक पूर्ण कार्यक्रम या एक फ़ंक्शन (नाम या अनाम) होना चाहिए, यहां अधिक जानकारी है: कमियां और आई / ओ चूक । मैं माणिक नहीं जानता, लेकिन यह सबसे कम तय लगता है।

— ।

@ बीएमओ धन्यवाद। किसी के लिए जो रूबी को नहीं जानता है, आप सबसे बड़े आराम से लंबोदर बना रहे हैं और बुला रहे हैं!

— स्टेन्सलैग

आप कोष्ठकों को निकाल सकते हैं n(37b):->n{(2..n).sum{|b|n.digits(b).sum}+n}

— Conor O'Brien

ठीक है, गूगल " रूबी लैम्ब्डा" ने चाल चली; पी लेकिन मैं सही खड़ा हूं कि आप दो बाइट्स को बचाने में सक्षम थे।

— ბიმო

Answer 5

पायथन 2 , 57 बाइट्स

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

$$a(n)=\sum_{b=2}^{n+1}\sum_{i=0}^{n-1}\left\lfloor\frac{n}{b^i}\right\rfloor\bmod b,$$ $\left\lfloor\frac{n}{(n+1)^0}\right\rfloor\bmod(n+1)=n$

इसे ऑनलाइन आज़माएं!

Answer 6

जावा 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`

Comments

कोई ज़रूरत नहीं है i, इसलिए ... 65 बाइट्स।

— ओलिवियर ग्रेगोइरे

@ ओलिविएरग्रेयर डेमन, मैं एक बेवकूफ हूं। आपका बहुत बहुत धन्यवाद! हम्म, अब मुझे भी अपने व्युत्पन्न C और

— व्हॉट्सएप के

Answer 7

डेसमोस, 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\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)

Comments

दूसरी राशि n तक चल सकती है, जिससे 3 बाइट्स की बचत होती ^n है।

— कंस्ट्रक्टर

इसके अलावा आप एक और 2 बाइट्स बचाने के \sum_{b=2}^{n+1}लिए बदल सकते हैंn+\sum_{b=2}^n

— TheConstructor

Answer 8

एसएएस, 81 74 बाइट्स

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

इनपुट cards;बयान के बाद दर्ज किया जाता है, जैसे कि नई सुर्खियों में,

data;input n;s=n;do b=2to n;do i=0to n;s+mod(int(n/b**i),b);end;end;cards;
1
2
3
4
5
6
7
8
9
10
36
37
64
65

sप्रत्येक इनपुट मान के लिए एक पंक्ति के साथ जवाब (हेल्पर चर के साथ) वाले डेटासेट को आउटपुट करता है

Ungolfed:

data; /* Implicit dataset creation */
input n; /* Read a line of input */

s=n; /* Sum = n to start with (the sum of base 1 digits of n is equal to n) */
do b=2to n; /* For base = 2 to n */
    do i=0to n; /* For each place in the output base (output base must always have less than or equal to n digits) */

        /* Decimal value of current place in the output base = b^i      */
        /* Remainder = int(b / decimal_value)                           */
        /* Current place digit = mod(remainder, base)                   */
        s+mod(int(n/b**i),b);
    end;
end;

cards;
1
2
3

Answer 9

जाप -x, 6 बाइट्स

ÆìXÄ x

कोशिश करो

õ!ìU c

कोशिश करो

Answer 10

जे , 24 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 11

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 (विरासत) में, 5 का आधार 1 [0,0,0,0,0] है, न कि [1,1,1,1,1]। इसलिए सीमा के बाद, लापता बेस 1 के लिए खाते में इनपुट जोड़ें।

मैं 05AB1E (विरासत) का उपयोग कर रहा हूं क्योंकि वर्तमान 05AB1E में, 5 का आधार 1 [1] है। इसका हिसाब देने के लिए, मुझे या तो परिणाम को 1 से घटाना होगा या श्रेणी के पहले तत्व को हटाना होगा, दोनों की लागत 1 बाइट होगी।

Answer 12

पर्ल 6 , 45 41 बाइट्स

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

-4 किंग जोए को धन्यवाद

इसे ऑनलाइन आज़माएं!

Comments

36 बाइट्स

— nwellnhof

Answer 13

व्हॉट्सएप , 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]केवल स्पष्टीकरण के रूप में जोड़ा गया।

इसे ऑनलाइन आज़माएं (केवल कच्चे स्थानों, टैब और नई-लाइनों के साथ)।

मेरे जावा 8 पोर्ट का उत्तर , क्योंकि व्हॉट्सएप के पास कोई भी आधार रूपांतरण बिल नहीं है।

उदाहरण रन: 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उस त्रुटि से छुटकारा पाने के लिए तीन अनुगामी नए समाचार जोड़ सकता हूं ।)

Answer 14

आर , 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; निश्चित नहीं है कि यह किस बिंदु पर काम करना बंद कर देगा।

आर , 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अंकों को निकालने के लिए क्लासिक विधि का उपयोग करता है , फिर उन्हें रकम देता है और योग को जमा करता है , जिसे प्रारंभ किया जाता है , फिर परिणाम को जोड़ने और वापस करने के लिए (आधार प्रतिनिधित्व ) को जोड़ा जाता है । के लिए , यह ठिकानों को छोड़ देता है और बस में जोड़ता है ।nb>1F0n1nFn=1nF

Comments

मैं किसी भी आर नहीं जानता, लेकिन उपयोग करने के बजाय 0:log(n,i), क्या आप उपयोग नहीं कर सकते 0:n? हमेशा n के किसी भी आधार निरूपण में अधिकांश n अंकों पर log(n,i)होना चाहिए , और प्रारंभिक अंकों के बाद सब कुछ 0 होना चाहिए, इसलिए यह राशि को प्रभावित नहीं करेगा।

— जोश एलर

@JoshEller मुझे लगता है कि मैं कर सकता था। यह विफल होना शुरू हो जाएगा n=144, क्योंकि 143^143आसपास है 1.6e308और इसका 144^144मूल्यांकन करता है Inf। धन्यवाद!

— Giuseppe

Answer 15

पायथन 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, और आउटपुट एक पूर्ण-संख्या फ़्लोट है।

Answer 16

सी (जीसीसी), 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;}

मेरे जावा 8 उत्तर का पोर्ट ।
-11 बाइट्स मेरे जावा उत्तर पर @ ओलिवियरग्रेयर के गोल्फ के लिए धन्यवाद ।

इसे ऑनलाइन आज़माएं।

स्पष्टीकरण:

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'

Answer 17

जावास्क्रिप्ट (ईएस 6), 42 बाइट्स

यह संस्करण मेरे मुख्य उत्तर के लगभग समान है लेकिन पुनरावृत्ति को रोकने के लिए अंकगणितीय अंतर्प्रवाह पर निर्भर करता है। उच्चतम समर्थित मूल्य कॉल स्टैक के आकार पर निर्भर करता है।

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

इसे ऑनलाइन आज़माएं!

---

जावास्क्रिप्ट (ईएस 6),  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

Answer 18

एपीएल (डायलॉग यूनिकोड) , 22 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 19

भूसी , 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

Answer 20

परी / जीपी , 30 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 21

जेली , 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.

Answer 22

अटैची , 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

Answer 23

चारकोल , 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

Answer 24

रेटिना 0.8.2 , 49 बाइट्स

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

1

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। स्पष्टीकरण:

.+
$*

यूनीरी में बदलें।

1
11$`;$_¶

$n + 1$

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

मूल संख्या को प्रत्येक आधार में बदलने के लिए बार-बार दिव्योदय का उपयोग करें।

1+;

बस आधार रूपांतरण अंकों को छोड़कर, आधारों की सूची को हटा दें।

1

राशि लें और दशमलव में परिवर्तित करें।

Answer 25

डेसमोस, 51 बाइट्स

कॉनर ओ'ब्रायन के जवाब से प्रेरित और OEIS-प्रविष्टि को देखते हुए मैं अपने खुद के डेसमोस-समाधान के साथ आया:

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

इसे ऑनलाइन आज़माएं!

Answer 26

एपीएल (एनएआरएस), 29 चार्ट, 58 बाइट्स

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

कैसे उपयोग करने पर थोड़ा परीक्षण:

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