ডিজিটাল সামিউরিয়াল

Question

একটি ইনপুট দেওয়া হয়েছে n, এমন কোনও প্রোগ্রাম বা ফাংশন লিখুন যা n1 থেকে সমস্ত ঘাঁটির জন্য ডিজিটাল সংখ্যার যোগফল / আউটপুট দেয় 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]

base- 2এর অবস্থান (বাইনারি) 5 হয়[1,0,1]

base- 3এর 5 হয়[1,2]

base- 4এর 5 হয়[1,1]

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

স্কোরিং:

কোড-গল্ফ : নিম্নতম স্কোরের সাথে জমা দেওয়া submission

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], সমস্ত স্ট্রিং উত্পন্ন করে । উদাহরণ স্বরূপ:$[0 \dotsc b]^n$

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

সঙ্গে তা ইন্ডেক্স দ্বারা (!!n)রূপান্তর করার জন্য ব্যবহার করা যেতে পারে nবেস b+1অবশ্য এই ইচ্ছা ইউনারী (base- জন্য কাজ না ), কিন্তু ফলাফল আমরা summing করছি .. আমরা এমনকি কিছু বাইট সংরক্ষণ সঙ্গে করতে পারেন এবং base- ব্যবহার জন্য একটি কাজের না করে যেহেতু আমরা যা যোগফল যখন।$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 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

কিছু বন্ধনী অন্তর্ভুক্ত এবং এটিকে যুক্ত করা যায় ("অফিসিয়াল" প্রথম বন্ধনী ব্যবহারের চেয়ে হালকা):

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

এটি একটি monadic শীর্ষে। একটি যুক্তি দেওয়া Y, এই ফাংশনটি এরকম আচরণ করে:

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

দুটি ফাংশন ক্রম প্রয়োগ করা হয়। আমরা ডান দিক থেকে শুরু করব:

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

এই ট্রেনটিতে তিনটি ফাংশন রয়েছে, সুতরাং এটি একটি কাঁটাচামচ। একটি যুক্তি দেওয়া Y, এটি নিম্নলিখিত হিসাবে কাজ করে:

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

আমরা সহজেই এটিকে হ্রাস করতে পারি (একাকী ⊢তার যুক্তি ফিরিয়ে দেয়, সুতরাং এটি পরিচয় বলা হয় ):

Y,Y(⍴⊤⊣)¨⍳Y

এখন, আমরা জানি যে Yএটি একটি পূর্ণসংখ্যা (সাধারণ স্কেলার, অর্থাত্ সংখ্যা বা চরিত্র), যেহেতু আমাদের একটি দেওয়া হয়েছে। অতএব ⍳Y, সাথে ⎕IO=1, ফিরে 1 2 ... Y। ⍳Yপ্রকৃতপক্ষে আকৃতির একটি অ্যারে প্রদান করে Y( Yঅবশ্যই ভেক্টর হতে হবে), যেখানে প্রতিটি স্কেলার অ্যারেতে নিজের সূচক হয় (এজন্য মোনাডিককে সূচক জেনারেটর⍳ বলা হয় )। এই সূচকগুলি ভেক্টর, যেখানে কেস , কোথায় তারা স্কেলার রয়েছে (কেবল আমাদের ক্ষেত্রে এটি)।1≡⍴Y

আসুন, মাঝের ফাংশনটি, পার্স করা যাক (⍴⊤⊣)¨। ⍴⊤⊣এর প্রতীক হল ¨( প্রতিটি ), এবং ফাংশন, dyadic তাই ¨অপারেটর প্রথম অন্যান্য আকৃতি প্রতিটি দৈর্ঘ্য -1 যুক্তি পুনর্নির্মাণ হবে (যে উপাদান গ্রহণ করা এবং এটি ব্যবহার অন্যান্য যুক্তি প্রতিটি স্কালে প্রতিস্থাপন) , এবং তারপরে দুটি যুক্তির প্রতিটি জুটিতে ফাংশনটি প্রয়োগ করুন। এই ক্ষেত্রে, ⍳Yএকটি ভেক্টর এবং Yতাই, যদি একটি স্কেলার হয়, n≡⍴⍳Yতারপর, Yরূপান্তরিত হবে n⍴Y( ⍴প্রতিনিধিত্ব করে আকৃতি (কীটাণুজাতীয়) এবং পুনর্নির্মাণ (dyadic) ফাংশন)। অর্থাৎ সহজ ভাষায় বলতে গেলে, Yএকটি অ্যারের ধারণকারী রূপান্তরিত হবে Yবার Y।

এখন, প্রতিটি জুটির জন্য, আসুন বাম আর্গুমেন্ট Xএবং ডানদিকে কল করুন Z(যাতে আমরা ইনপুটটির সাথে বিরোধ না করি Y)। ⍴⊤⊣একটি ডায়াডিক কাঁটাচামচ, তাই এটি প্রসারিত হবে:

(X⍴Z)⊤X⊣Z

আসুন কমানোর সহজ প্রথম পদক্ষেপ করতে X⊣Zকরতে X(dyadic ⊣হয় বাম ফাংশন):

(X⍴Z)⊤X

⍴মধ্যে X⍴Zহয়, আবার, পুনর্নির্মাণ ফাংশন, তাই X⍴Z, আমাদের ক্ষেত্রে, সহজভাবে হয় Xবার Z। ⊤হয় সঙ্কেতাক্ষরে লিখা ফাংশন। দুটি সংখ্যার অ্যারে দেওয়া, যেখানে বাম অ্যারে ফলাফলের প্রতিটি অঙ্কের ভিত্তি হয় (পূর্ণসংখ্যার বা ধনাত্মক হওয়া প্রয়োজন হয় না), অর্থাৎ এনকোডিং এবং ডান সংখ্যার একটি অ্যারে, সেইগুলির স্থানান্তরিত অ্যারে প্রদান করে নির্দিষ্ট এনকোডিংয়ের সংখ্যা (স্থানান্তর তার উপাদানগুলির সাথে সম্পর্কিত একটি অ্যারের মাত্রার বিপরীত)। একটি সংখ্যার উপস্থাপনা সংখ্যার ভাগের ভাগফল এবং কম উল্লেখযোগ্য ঘাঁটির পণ্য ভিত্তিক হয়। যদি কোনও বেস হয় তবে 0এটি বেস + as হিসাবে কাজ করে ∞ যুক্তিগুলির স্কেলারগুলি সমস্ত সহজ simple যেহেতু Xএকটি ইতিবাচক পূর্ণসংখ্যার, এবংX⍴ZXZX$X,Z\in\mathbb N$$X_Z$$X$$Z$$X$$X_1$$X$X⍴Z

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

Y,Y(⍴⊤⊣)¨⍳Y

আমি ইতিমধ্যে এই অংশ এখানে অন্তর্ভুক্ত করেছি। Dyadic ,হয় সন্নিবদ্ধ করা ফাংশন, এটা তাদের শেষ অক্ষ তার আর্গুমেন্ট concatenates, এবং ত্রুটি যদি সম্ভব নয়। এখানে, আমরা কেবল Yভেক্টরকে স্কেলারটি সংক্ষেপিত করেছিলাম Y(⍴⊤⊣)¨⍳Y, যাতে Yউপরের ব্যাখ্যা অনুসারে আমরা যে পরিমাণটি দ্বারা গণনা করতে যাচ্ছি তার বৃদ্ধি করব ।

চূড়ান্ত অংশটি আমাদের শীর্ষের বাম ফাংশন +/∘∊,:

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

∘এটি কম্পোজ অপারেটর। f∘g Yহিসাবে একই f g Y। তবে, আমরা এটি এখানে ব্যবহার করছি যাতে আমাদের ট্রেনটি কাঁটাচামচায় না যায় ∊। সুতরাং, আমরা হ্রাস করতে পারি:

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

এখন, যোগফলের সময় এসেছে তবে অপেক্ষা করুন ... একটি সমস্যা আছে। অ্যারে সমতল নয়, তাই আমরা প্রথমে এটি সমতল করার আগে এর উপাদানগুলির যোগফল দিতে পারি না। পক্ষভুক্ত ফাংশন ∊একটি অ্যারে চ্যাপ্টা। অ্যারে সমতল করা হয়েছে, আমরা শেষ পর্যন্ত +/এটি যোগফল ব্যবহার । /হয় কমাতে অপারেটর, এটা ডান-থেকে-বাম অগ্রাধিকার দিয়ে তার দ্বিতীয় টু গত অক্ষের উপর একটি অ্যারের এর উপাদান মধ্যে একটি dyadic ফাংশন প্রযোজ্য। যদি অ্যারের র‌্যাঙ্ক (মাত্রাগুলির সংখ্যা, অর্থাৎ আকৃতির দৈর্ঘ্য) হ্রাস না হয় তবে অ্যারেটি তখন আবদ্ধ থাকে, যদিও এখানে এটি হয় না। এখানে প্রয়োগ করা ফাংশনটি +হ'ল এটিই প্লাসফাংশন যা দুটি অ্যারের শেষ অক্ষে জোড়া যুক্ত করে (এবং ত্রুটিগুলি যদি অ্যারেটি যুক্ত করা যায় না)। এখানে, এটি কেবল দুটি সংখ্যাকে বহুবার যুক্ত করে যাতে হ্রাসটি সম্পন্ন হয়।

দেখুন এবং দেখুন, আমাদের ট্রেন:

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

Comments

+1 চিত্তাকর্ষক ব্যাখ্যা। খাটো নয়, তবে কোনও +/∘∊⊢,⊢⊤¨⍨⊢⍴¨⍳

— প্যারেনস

@ অ্যাডম ধন্যবাদ! আমি যখন এটি লিখেছিলাম তখন প্রায় ঘুমিয়ে ছিলাম। :

— পি

@ অ্যাডম আপনার সংস্করণ সম্পর্কিত, দেখে মনে হচ্ছে এটি একটি বাচ্চা বুঝতে আরও কঠিন। ;-)

— এরিক দি আউটগল্ফার

Answer 4

রুবি , 39 37

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

এখানে একমাত্র গল্ফিং কিছু সাদা জায়গা সরিয়ে দিচ্ছে। এটি অনলাইনে চেষ্টা করুন

Comments

@ জিউজ্পে ওপি শুরু: "একটি ইনপুট দেওয়া এন, (...)" দিয়ে শুরু করুন। আমি এখানে দীর্ঘকাল ধরে থাকি না। কোনও সমাধানের প্রয়োজনীয়তার কোনও তালিকা রয়েছে কি?

— স্টেনস্লাগ

সাধারণত এটি অবশ্যই একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন (নামযুক্ত বা নামবিহীন) হতে হবে, এখানে আরও তথ্য: লুফোলস এবং i / o ডিফল্ট । আমি রুবি জানি না, কিন্তু এই সবচেয়ে কম ফিক্স বলে মনে হয়।

— 5

@ বিএমও ধন্যবাদ রুবিকে চেনেন না এমন কারও জন্য আপনি সবচেয়ে সহজেই একটি ল্যাম্বডাকে তৈরি এবং কল করছেন!

— স্টেনস্লাগ

আপনি n(37 বি) কাছাকাছি প্রথম বন্ধনীগুলি সরাতে পারেন :->n{(2..n).sum{|b|n.digits(b).sum}+n}

— কনর ও'ব্রায়েন

ঠিক আছে, গুগল " রুবি ল্যাম্বদা" কৌশলটি করেছে; পি কিন্তু আমি সঠিকভাবে দাঁড়িয়ে আছি যে আপনি দুটি বাইট সংরক্ষণ করতে পেরেছিলেন।

— ბიმო

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;}

-১১ বাইট @ অলিভিগ্রগ্রোয়ারকে ধন্যবাদ ।

এটি অনলাইনে চেষ্টা করুন।

ব্যাখ্যা:

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 বাইট।

— অলিভিয়ার গ্রাগোয়ার

@ অলিভিয়ারগ্রোওয়ের ড্যাম, আমি একজন বোকা। অনেক ধন্যবাদ! হুম, এখন আমাকে আমার উত্পন্ন সি এবং

— হোয়াইটস্পেস

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

দ্বিতীয় সমষ্টিটি এন-এ চলে যেতে পারে, 3 টি বাইট সংরক্ষণ করা ^n উচিত পর্যাপ্ত।

— TheConstructor

এছাড়াও আপনি পরিবর্তন হতে পারে \sum_{b=2}^{n+1}থেকে n+\sum_{b=2}^nঅন্য 2 বাইট সংরক্ষণ

— 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

05 এ বি 1 ই (উত্তরাধিকার) , 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

05 এএফ 1 ই (উত্তরাধিকার) এ, 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 বাইট

— নয়েহ্নফ

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বের করার জন্য ক্লাসিক পদ্ধতি ব্যবহার করে , তারপর তাদের যোগফল যোগ করে যোগফলটি জমা করে , যা সূচনা হয় , তারপরে (এর বেস উপস্থাপনা ) যোগ করে ফলাফলটি ফেরত দেয়। কারণ এটি ঘাঁটিগুলি এড়িয়ে যায় এবং কেবলমাত্র এতে যোগ করে ।inb>1F0n1nFn=1nF

Comments

আমি কোনও আর জানি না, তবে ব্যবহারের পরিবর্তে, 0:log(n,i)আপনি কি ব্যবহার করতে পারবেন না 0:n? এন এর যে কোনও বেস উপস্থাপনায় সর্বদা n সংখ্যা হবে এবং প্রাথমিক log(n,i)অঙ্কগুলির পরে সমস্ত কিছু 0 হওয়া উচিত, সুতরাং এটি যোগফলকে প্রভাবিত করবে না।

— জোশ এলার

@ জোশেলার আমি মনে করি আমি পারতাম। এটি প্রায় ব্যর্থ হতে শুরু করবে n=144, যেহেতু 143^143কাছাকাছি রয়েছে 1.6e308এবং 144^144মূল্যায়ন করে Inf। ধন্যবাদ!

— জিউসেপ

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

এটি অনলাইন চেষ্টা করুন!

যদিও এটি ডেনিসের সমাধানের ভিত্তিতে এখন আর সমাধান নয়, আমি পদ্ধতিটি ভাগ না করার জন্য খুব মজাদার বলে মনে করি।

লক্ষ্য শেষের ডিজিটটি কেটে ফেলেছিলেন উভয়েই recurse হয় 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

জাভাস্ক্রিপ্ট (ES6), 42 বাইট

এই সংস্করণটি আমার মূল উত্তরের সাথে প্রায় একই রকম তবে পুনরাবৃত্তি বন্ধ করতে গাণিতিক আন্ডারফ্লোতে নির্ভর করে। সর্বোচ্চ সমর্থিত মান কল স্ট্যাকের আকারের উপর নির্ভর করে।

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

এটি অনলাইন চেষ্টা করুন!

---

জাভাস্ক্রিপ্ট (ES6),  51 48  44 বাইট

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

এটি অনলাইন চেষ্টা করুন!

মন্তব্য

f = (             // f = recursive function taking:
  n,              // - n = input
  b = 2,          // - b = current base, initialized to 2
  x = n           // - x = current value being converted in base b
) =>              //
  b > n ?         // if b is greater than n:
    n             //   stop recursion and return n, which is the sum of the digits of n
                  //   once converted to unary
  :               // else:
    x % b +       //   add x modulo b to the final result
    f(            //   and add the result of a recursive call:
      n,          //     pass n unchanged
      b + !x,     //     increment b if x = 0
      x ?         //     if x is not equal to 0:
        x / b | 0 //       update x to floor(x / b)
      :           //     else:
        n         //       reset x to n
    )             //   end of recursive call

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 বাইট

কনর ও'ব্রায়নের উত্তরের দ্বারা অনুপ্রাণিত হয়ে ওইআইএস-এন্ট্রির দিকে তাকিয়ে আমি নিজের ডেসমোস-সলিউশন নিয়ে এসেছি:

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