ऐड-गुणा-ऐड सीक्वेंस

Question

( संबंधित )

एक पूर्णांक को देखते हुए n > 1,
1) संख्याओं की सीमा का निर्माण करें n, n-1, n-2, ... 3, 2, 1और योग की गणना करें
2) उस संख्या के व्यक्तिगत अंकों को लें और उत्पाद की गणना करें
3) उस संख्या के व्यक्तिगत अंकों को लें और योग की गणना करें
4) चरण 2 और 3 को दोहराएं जब तक आप एक अंक पर पहुँचें। वह अंक परिणाम है।

अनुक्रम के पहले बीस शब्द नीचे हैं:

3, 6, 0, 5, 2, 7, 9, 2, 7, 9, 1, 9, 0, 0, 9, 6, 7, 0, 0, 6

नोट: यह अनुक्रम OEIS में नहीं है।

I / O और नियम

• नंबर बहुत जल्दी मिल जाएंगे, इसलिए समाधान बिना असफलता के 100,000 तक इनपुट संख्याओं को संभालने में सक्षम होना चाहिए (यह ठीक है अगर आपका कोड इसे संभाल सकता है)।
• इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा दिया जा सकता है ।
• या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
• मानक खामियों को मना किया जाता है।
• यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

उदाहरण

n     output
1234   9
3005   3
5007   5
9854   8
75849  8
100000 0

Comments

+1 एक अनुक्रम चुनौती के लिए जो OEIS में नहीं है

— JAD

जब भी n ever 100000 , चरण 2 और 3 के केवल दो पुनरावृत्तियों परिणाम प्राप्त करने के लिए पर्याप्त हैं। क्या हम इसका लाभ उठा सकते हैं या एल्गोरिथ्म में हमें n के बड़े मूल्यों के लिए काम चुनना चाहिए ?

— डेनिस

@ डेनिस एल्गोरिथ्म के किसी भी मूल्य के लिए काम करना चाहिए n। केवल पोस्ट किए गए समाधान के लिए काम करना है n = 100000।

— AdmBorkBork 14

Numbers will get very large quicklyनहीं, यह नहीं

— l4m2

@ l4m2 आउटपुट नहीं। लेकिन 100000 + 99999 + ... + 1 = 5000050000 एक 33-बिट संख्या है, जिसे आपकी पसंद की भाषा का प्रतिनिधित्व करने में परेशानी हो सकती है या नहीं।

— डेनिस

Answer 1

पायथन 2 , 77 72 71 62 60 बाइट्स

lambda n:reduce(lambda x,c:eval(c.join(`x`)),'*+'*n,-n*~n/2)

2 बाइट बंद करने के लिए @xnor को धन्यवाद!

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

Comments

मैंने अभी-अभी लूप के लिए स्विच किया है, लेकिन मुझे भविष्य के लिए उस ट्रिक को याद रखना होगा।

— डेनिस

कहाँ हैं repeat until you reach a single digit?

— टाइटस

@ टिट्स I केवल n चरण 2 और 3 का पुनरावृत्तियों करता है, जो हमेशा पर्याप्त होता है। वास्तव में, n since 100000 के बाद से , तीन पुनरावृत्तियां पर्याप्त होंगी।

— डेनिस

अब जब आप इसका उल्लेख करते हैं: वास्तव में, सबसे छोटे इनपुट के लिए तीन पुनरावृत्तियों की आवश्यकता होगी 236172; और वह केवल 1 मिलियन से नीचे का है।

— टाइटस

आप कम कर सकते हैं

— xnor

Answer 2

05AB1E , 7 बाइट्स

LOΔSPSO

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

Exlpanation

L         # push range [1 ... input]
 O        # sum range
  Δ       # loop until top of stack stops changing
   SP     # product of digits
     SO   # sum of digits

Comments

लगभग ASCII- ही! : D

— AdmBorkBork

@AdmBorkBork: हाँ, बहुत सामान्य नहीं: P

— Emigna

Answer 3

जेली , 8 बाइट्स

RSDPDƲÐL

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

पूर्ण कार्यक्रम (यह परिणाम सहित एक एकल सरणी देता है, लेकिन ब्रैकेट STDOUT में दिखाई नहीं देते हैं)।

Comments

यह सबसे "प्राकृतिक दिखने वाला" जेली उत्तर है जिसे मैंने अभी तक देखा है। केवल 2 गैर-ASCII वर्ण हैं

— RedClover

@Soaku codegolf.stackexchange.com/questions/69424/…

— बजे फल तोड़ना

उह, क्या हम कृपया यहाँ पर चर्चा नहीं कर सकते, धन्यवाद। : पी टीएनबी इस पर चर्चा करने के लिए एक वैकल्पिक स्थान हो सकता है, अगर कोई शोर नहीं किया जाता है। ;)

— एरिक आउटोलॉफ़र

Answer 4

MATL , 15 13 बाइट्स

महीने की भाषा में श्रद्धांजलि :

:`sV!UpV!Utnq

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

मुझे नहीं लगता कि संख्या को स्ट्रिंग में बदलने के लिए किसी संख्या के अंकों को प्राप्त करने का एक सरल तरीका है V, फिर इसे स्थानांतरित करना !, और इस ऊर्ध्वाधर वेक्टर को एक संख्यात्मक एक में बदलना U।

2 बाइट्स को निर्माता ¹ को धन्यवाद देता है! मैं निहित अंत को भूल गया, जिसका अर्थ है कि मैं हटा सकता हूं ], और तत्वों की संख्या की तुलना करने के बजाय 1, मैं बस उस मूल्य को घटा सकता हूं और इसे सीधे बूलियन के रूप में उपयोग कर सकता हूं।

तो, स्पष्टीकरण इस प्रकार है:

                 % Grab input n implicitly
:                % Range from 1 ... n inclusive
 `               % Do ... while
  s               % sum the vector
   V!U            % Convert the number to digits
      p           % Take the product of these digits
       V!U        % Convert the product into digits
          t       % Duplicate the result
           n      % Count the number of elements
            q     % Decrement the number of elements
                  % Loop until the number of elements is 1
                 % Implicit end

¹ ... MATL, लुइस मेंडो की।

Answer 5

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

f=(n,k=n*++n/2)=>k>9?f(!n,eval([...k+''].join('*+'[+!n]))):k

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

टिप्पणी की गई

f = (                     // f = recursive function taking:
  n,                      //   n = original input
  k = n * ++n / 2         //   k = current value, initialized to sum(i=1..n)(i)
) =>                      //
  k > 9 ?                 // if k has more than 1 digit:
    f(                    //   recursive call to f() with:
      !n,                 //     a logical NOT applied to n
      eval(               //     the result of the expression built by:
        [...k + '']       //       turning k into a list of digits
        .join('*+'[+!n])  //       joining with '*' on even iterations or '+' on odd ones
      )                   //     end of eval()
    )                     //   end of recursive call
  :                       // else:
    k                     //   stop recursion and return the last value

---

वैकल्पिक संस्करण, 59 बाइट्स (गैर-प्रतिस्पर्धात्मक)

एक गैर-पुनरावर्ती संस्करण जो केवल n <236172 के लिए काम करता है । (यह अनुरोधित सीमा को शामिल करता है लेकिन एक मान्य जेनेरिक एल्गोरिथ्म के रूप में योग्य नहीं है।)

n=>[...'*+*+'].map(o=>n=eval([...n+''].join(o)),n*=++n/2)|n

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

Comments

आपका मुख्य संस्करण तब टूटता है जब N> = 77534568790। यह तब काम करता है जब N = 7753456879; निश्चित रूप से नहीं जहां ब्रेकपॉइंट है। बेशक, यह कोई फर्क नहीं पड़ता क्योंकि requirment केवल N = 100,000 तक संभालना है, इसलिए मुझे यकीन नहीं है कि मैंने यह क्यों लिखा है ....

— रॉस प्रेसर

@RossPresser एक मोटे अनुमान के रूप में, मैं कहूंगा कि यह काम करता है Number.MAX_SAFE_INTEGER ** 0.5 ~= 94906265।

— अरनौलड

Answer 6

हास्केल , 72 71 63 बाइट्स

g=map(read.pure).show
f n=until(<10)(sum.g.product.g)$sum[1..n]

8 बाइट्स के लिए एक बाइट और @ मिमी के लिए @ बीएमओ को धन्यवाद!

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

Answer 7

स्टैक्स , 14 13 10 बाइट्स

ñu┌↕a√äJ²┐

इसे चलाएं और डीबग करें

बनाने में काफी मजेदार था। मुझे आश्चर्य है कि अगर अंत में तुलना करने के लिए अधिक संक्षिप्त तरीका है।

व्याख्या

|+wE:*E|+c9>                 # Full Program Unpacked
|+                           # Create range and sum it
   wE:*                      # Start loop, digitize number, product of digits
       E|+                   # Digitize number, sum digits
          c9>                # Duplicate, check length is = 1
                             # Otherwise loop back to the 'w' character

-1 बाइट्स ओव्स के लिए धन्यवाद

-3 बाइट्स स्क्रूबल के लिए धन्यवाद

Answer 8

आर , 152 130 109 बाइट्स

function(w,x=w*(w+1)/2,y=prod(d(x)),z=sum(d(y)))"if"(z>9,f(,z),z)
d=function(x)x%/%10^(0:max(0,log10(x)))%%10

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

@Giuseppe ने 21 42 बाइट्स को विभिन्न आर चीजों के साथ पाया, जिनका मैं अभी तक उपयोग नहीं कर रहा हूं, साथ ही साथ एक संख्या के अंकों को स्ट्रिंग और बैक के लिए, और कम बाइट्स के साथ बिना किसी झटके के प्राप्त करने के लिए!

# Old
d=function(x)strtoi(el(strsplit(paste(x),"")))
# New
d=function(x)x%/%10^(0:max(0,log10(x)))%%10

options(scipen=9) है , वर्ष समारोह के लिए 9854 के मामले के लिए आवश्यक हो गया क्योंकि पहला उत्पाद मंच 80000, 8e +05 के रूप में जो आर प्रिंट के रूप में समाप्त होता है।

Comments

ओह समझा। वैज्ञानिक संकेतन उत्पादन। अच्छी पकड़!

— AdmBorkBork

अंत में चारों ओर मिल गया scipen: इसे ऑनलाइन आज़माएं ! ध्यान दें max(0,log10(x))क्योंकि यदि है x=0, तो log10(0)=-Infएक त्रुटि का कारण बनता है।

— ग्यूसेप

Answer 9

अजगर , 11 बाइट्स

usj*FjGTTsS

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

usj * FjGTTsS - पूर्ण कार्यक्रम। एन = इनपुट।
          एस - रेंज। उपज [1, एन] N N।
         s - सम।
यू - जबकि कोई दो लगातार पुनरावृत्तियाँ एक ही परिणाम प्राप्त नहीं करते हैं, (var: G):
   * एफजीजीटी - डिजिटल उत्पाद।
 sj T - डिजिटल योग।

Answer 10

चारकोल , 18 बाइट्स

≔Σ…·¹ＮθＷ›θ⁹≔ΣΠθθＩθ

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

≔Σ…·¹Ｎθ

पूर्णांकों को इनपुट तक जोड़ते हैं।

 Ｗ›θ⁹≔ΣΠθθ

जबकि परिणाम 9 से अधिक है, अंकों के उत्पाद के अंकों का योग लें।

Ｉθ

परिणाम को स्ट्रिंग और अंतर्निहित रूप से मुद्रित करें।

Answer 11

गैया , 8 बाइट्स

┅⟨Σ₸∨Π⟩°

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

पुरानी व्याख्या (बग को ठीक करने से पहले जो गैया की गलती है IMO: P):

┅⟨ΣΠ⟩ ° - पूर्ण कार्यक्रम। एन = इनपुट।
┅ - रेंज। स्टैक में पुश [1, एन]]]।
 Yield yield ° - जबकि कोई दो लगातार पुनरावृत्तियों एक ही परिणाम नहीं है, करते हैं:
  Or - सम (या डिजिटल योग, जब एक पूर्णांक पर लागू होता है)।
   Product - डिजिटल उत्पाद।

डेनिस की बदौलत 1 बाइट बचा ।

Comments

┅⟨ΣΠ⟩°एक बाइट बचाता है।

— डेनिस

यह मानों के लिए काम नहीं करता है डिजिटल योग 0 था, जैसे4

— जो किंग

@JoKing फिक्स्ड, कि जगह के लिए धन्यवाद। दुर्भाग्य से, Gaia में, किसी कारण के लिए 0परिणामों के अंक ले रहा है []:(

— श्री Xcoder

Answer 12

एफ #, 175 बाइट्स

let d n=seq{for i in(string n).ToCharArray() do yield string i|>uint64}
let c n=
 let mutable r=Seq.sum{1UL..n}
 while r>9UL do r<-d r|>Seq.reduce(fun a x->x*a)|>d|>Seq.sum
 r

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

फ़ंक्शन के लिए केवल चेतावनी यह है कि इनपुट मान प्रकार का होना चाहिए uint64।

Ungolfed यह थोड़ा इस तरह है:

let d n=seq{for i in(string n).ToCharArray() do yield string i|>uint64}

let c n =
 let mutable r = Seq.sum {1UL..n}
 while r > 9UL do
  r<-d r
  |> Seq.reduce(fun a x->x*a)
  |> d
  |> Seq.sum
 r

फ़ंक्शन d nसंख्या nको उसके घटक अंकों में परिवर्तित करता है । यह पहले एक स्ट्रिंग में परिवर्तित होता है, फिर स्ट्रिंग में प्रत्येक वर्ण प्राप्त करता है। प्रत्येक वर्ण को फिर से एक स्ट्रिंग में परिवर्तित किया जाना चाहिए, अन्यथा पात्रों को उनके "वास्तविक" मूल्यों के बजाय उनके ASCII मूल्यों में परिवर्तित किया जाएगा।

c nसमारोह के साथ, मुख्य कार्य है nप्रारंभिक मूल्य के रूप में। इस फंक्शन rमें हमारा रनिंग वैल्यू है। whileपाश निम्नलिखित है:

• rइसके घटक अंकों ( d r) में परिवर्तित करें ।
• उन सभी अंकों का उत्पाद प्राप्त करें। यह उपयोग करता है Seq.reduceजो संचित मूल्य ( a) और अनुक्रम में अगले मान के साथ एक फ़ंक्शन लेता है ( x) और इस मामले में उत्पाद वापस करता है। प्रारंभिक मूल्य अनुक्रम में पहला तत्व है।
• इस उत्पाद के मूल्य को इसके घटक अंकों ( d) में परिवर्तित करें ।
• पहले से अंकों को योग करें, और इसे असाइन करें r।

Answer 13

Befunge, 136 बाइट्स

101p&::*+2/>:82+%01g*01p82+/:#v_$01gv
X      v_v# #:/+82p10+g10%+82: <p100<
v:g10$ >#<#^                 #<^
>82+/#v_.@
      >101p^

आप इसे यहाँ आज़मा सकते हैं ।

जबकि सभी दुभाषियों के पास एक बड़ा पर्याप्त सेल आकार नहीं है, यह छोटे संख्याओं के साथ काम करता है जो कि बहुत अधिक लोगों के लिए है। बड़ी संख्या में nआप के लिए BefunExec जैसे दुभाषिया की आवश्यकता हो सकती है ।

Answer 14

गोल> <> , ₃₅ 33 बाइट्स

1AY:P*2,TYMR*YR+:a(?Bt
:a(qlBaSD$

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

जो किंग द्वारा -2 बाइट्स।

फ़ंक्शंस का व्यापक उपयोग और अंतर्निहित लूप्स।

उदाहरण पूर्ण कार्यक्रम और यह कैसे काम करता है

1AGIE;GN
2AY:P*2,YlMR*YlR+:a(?B8R!
:a(?BaSD$

<main program>
1AG       Register row 1 as function G
   IE;    Take number input; halt on EOF
      GN  Call G and print the result as number
          Repeat indefinitely

<function G>
2AY            Register row 2 as function Y
   :P*2,       Sum of 1 to n
        Y      Call Y (break into digits)
         lMR*  Product
Y              Call Y
 lR+           Sum (an implicit zero is used)
    :a(?B      Return if the result is less than 10
         8R!   Skip initial 8 commands
               Repeat indefinitely

<function Y>
:a(?B      Return if the top is less than 10
     aSD   Divmod by 10; [... n] => [... n/10 n%10]
        $  Swap top two, so the "div" goes to the top

Comments

33 बाइट्स

— जो किंग

Answer 15

जाप, 16 14 13 बाइट्स

_ì ×ìx}gN®õ x

कोशिश करो

---

व्याख्या

                  :Implicit input of integer U
         ®        :Map
        N         :The array of inputs (which just contains U)
          õ       :  Range [1,U]
            x     :  Reduce by addition
_     }g          :Take the last element of N, run it through the following function and push the result to N
                  : Repeat U times and then return the last element of N
 ì                :  Split to an array of digits
   ×              :  Reduce by multiplication
    ìx            :  Split to an array of digits and reduce by addition

Comments

नीट, मैंने इसे स्वयं हल करने की कोशिश की लेकिन एक अच्छा समाधान नहीं मिला इसलिए यह तुम्हारा देखना दिलचस्प है।

— नित

धन्यवाद, @ नीत। हालांकि एक छोटा रास्ता होना चाहिए।

— झबरा

@ नहीं, समझ गया! अभी भी आश्वस्त है कि एक छोटा रास्ता होना चाहिए, हालांकि।

— झबरा

Answer 16

भूसी , 7 बाइट्स

ωöΣdΠdΣ

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

Answer 17

PHP 7, 89 बाइट्स

for($a=$argn*-~+$argn/2;$a>9;)$a=array_sum(($s=str_split)(array_product($s($a))));echo$a;

ऑनलाइन के साथ पाइप के रूप में चलाएं -rया इसे आज़माएं ।

• PHP हमेशा इनपुट को स्ट्रिंग के रूप में लेती है, इसलिए मुझे वांछित के रूप में काम करने के +लिए इंट कास्ट करने के लिए उपयोग ~करना होगा।
• प्री-इन्क्रीमेंट से काम नहीं चलेगा: कोई फर्क नहीं पड़ता कि मैंने इसे कहां रखा है, यह दोनों ऑपरेंड को प्रभावित करेगा।
• लेकिन: अगर यह एकल अंक से पहले या इसके बाद होता है तो कोई फर्क नहीं पड़ता (अतिरिक्त पुनरावृत्तियों एक बात नहीं बदल जाएगा); इसलिए मैं for()इसके बजाय का उपयोग कर सकते हैं do ... while()।
• फ़ंक्शन नाम के इनलाइन असाइनमेंट के लिए PHP 7 या बाद के संस्करण की आवश्यकता होती है।
  पुराने PHP के लिए एक और बाइट की आवश्यकता होती है: for($s=str_split,$a=...;$a>9;)$a=array_sum($s(...));
  ( str_splitएक वैरिएबल को असाइन नहीं करना एक और बाइट को बर्बाद करेगा।)

Answer 18

पर्ल 6 , 49 बाइट्स

{($_*.succ/2,{[+] ([*] .comb).comb}...9>=*).tail}

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

Comments

आप [*](.comb).combइसके बजाय का उपयोग कर सकते हैं([*] .comb).comb

— ब्रैड गिल्बर्ट b2gills

Answer 19

टीईसी , 118 बाइट्स

proc S n {set r [expr $n*($n+1)/2]
while \$r>9 {set r [expr [join [split [expr [join [split $r ""] *]] ""] +]]}
set r}

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

Comments

फेल आउटगॉल्फ, 119

— सेर्गिओल

Answer 20

पावरशेल कोर , 91 101 93 बाइट्स

Function F($a){$o=$a*($a+1)/2;1,2|%{$o=[char[]]"$([char[]]"$o"-join'*'|iex)"-join'+'|iex};$o}

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

थोड़े अनगढ़ ...

Function F ($a)
{
    $o=$a*($a+1)/2;
    1..2 | % {
        $o = [char[]]"$o"-join '*' | iex;
        $o = [char[]]"$o"-join '+' | iex;
    }
    $o | Write-Output
}

पहले चरण में पूर्णांकों को अंकों में विभाजित करना था - इसने पूर्णांक को तार वर्णों की एक सरणी में विभाजित करके किया । बाद में, ऑपरेंड डालें, और फिर कमांड के रूप में स्ट्रिंग का मूल्यांकन करें। फिर, जब तक इनपुट एक अंक का नहीं हो जाता, तब तक कई-जोड़ चक्र करने की बात है।

iexएक उपनाम है Invoke-Commandजिसके लिए पहले पैराम स्थान में पारित एक स्ट्रिंग का मूल्यांकन किया जाता है।

संपादित करें: @AdmBorkBork द्वारा अनुरोध के अनुसार , मैंने एक फ़ंक्शन हैडर को बाइट काउंट में जोड़ा है। इसके अलावा, मैंने थोड़ा गणित किया और महसूस किया कि पुनरावृत्तियों की संख्या पर एक ऊपरी सीमा है < log log 10^6 < log 6 < 2, जिससे एक और छह बाइट्स बच गए।

X2 संपादित करें: @AdmBorkBork ने पूर्णांक को गणित की अभिव्यक्ति में परिवर्तित करने का एक अधिक जटिल तरीका पाया, और फिर इसे पाइप करने का सुझाव दिया iex। इससे 8 बाइट बच गईं। धन्यवाद!

Comments

आसपास एक और PowerSheller देखकर अच्छा लगा! हालाँकि, मुझे लगता है कि आपको Function F($a){ }अपनी बाइट गिनती में फ़ंक्शन की परिभाषा को शामिल करना होगा । हालाँकि, आपको [char[]]इसके बजाय कुछ का उपयोग करने में सक्षम होना चाहिए -split''-ne'', मुझे लगता है।

— AdmBorkBork

[char[]]1234=Ӓ, जो अमान्य है; मैं इसे काम करने में सक्षम हो सकता हूं, लेकिन यह अभी स्पष्ट नहीं हो सकता है। सलाह के लिये धन्यवाद!

— जेफ फ्रीमैन

क्षमा करें, मैं स्पष्ट नहीं था - [char[]]"$o"और |iexइसके बजाय iex( )।

— AdmBorkBork

इस टिप ने मेरे कोड का 8% हिस्सा काट दिया। बहुत बढ़िया। धन्यवाद!

— जेफ फ्रीमैन

Answer 21

पर्ल 5 -p , 61 बाइट्स

$_*=$_/2+.5;$_=eval((eval s/./$&*/gr.1)=~s/./+$&/gr)while$_>9

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

Answer 22

रूबी , 57 बाइट्स

->n{("*+"*n).chars.reduce(-~n*n/2){|x,y|eval x.digits*y}}

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

Answer 23

जावा 8, 129 बाइट्स

n->{long r=1,i=n;for(;i>1;r+=i--);for(;r>9;r=(i+"").chars().map(p->p-48).sum(),i=1)for(int s:(r+"").getBytes())i*=s-48;return r;}

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

स्पष्टीकरण:

n->{            // Method with integer parameter and long return-type
  long r=1,     //  Result-long, starting at 1
       i=n;     //  Temp integer, starting at the input `n`
  for(;i>1;     //  Loop as long as `i` is not 1 yet
      r+=i--);  //   And increase `r` by `i`
  for(;r>9      //  Loop as long as `r` is not a single digit yet
      ;         //    After every iteration:
       r=(i+"").chars().map(p->p-48).sum(),
                //     Set `r` to the sum of digits of `i`
       i=1)     //     And reset `i` to 1
    for(int s:(r+"").getBytes())i*=s-48;
                //    Set `i` to the product of the digits of `r`
  return r;}    //  Return `r` as result

Answer 24

जूलिया 0.6 , 56 बाइट्स

f(n,k=(n+1)n÷2)=k>9?f(0,sum(digits(prod(digits(k))))):k

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

बहुत सीधा: (n+1)n÷21..n से राशि के लिए गणना करें, यह जांचें कि क्या यह एक एकल अंक संख्या ( >9) है, यदि यह नहीं है, तो कश्मीर के अंकों के उत्पाद के अंकों के योग पर k सेट के साथ फिर से प्रयास करें, बाकी k।