पृष्ठभूमि:

मानक संचालन गणित जैसे मूल जोड़ और वास्तविक दुनिया में गुणा इन जैसे काम करते हैं:

12 + 123 = 135

तथा

12 * 123 = 1476

यह दिलचस्प और उबाऊ नहीं है! कई स्कूल पहले से ही औपचारिक एल्गोरिदम के अभ्यास, अभ्यास, अभ्यास के रूप में इसकी व्याख्या कर रहे हैं। यह एक बहुत ही कठोर और उबाऊ गणितीय आहार का अर्थ है और इस चुनौती में ऐसा नहीं है। हमारी प्यारी साइट पर कुछ मजेदार खेलने के लिए तैयार हो जाओ।

दो सकारात्मक पूर्णांक संख्याओं को जोड़ने की प्रक्रिया पर विचार करें, फिर इसके परिणाम के सभी अंकों को फिर से जोड़ दें। केवल एक अंक प्राप्त होने तक जोड़ के साथ दोहराते हुए। उदाहरण के लिए:

का परिणाम 12 + 123135 है।
135 के सभी अंकों को जोड़कर हम प्राप्त करते हैं 1 + 3 + 5 = 9।

इस बार-बार जोड़ में एकल अंक 9 प्राप्त करने के लिए आवश्यक चरणों की संख्या 2 है।

जोड़ की पिछली प्रक्रिया के समान, दो सकारात्मक पूर्णांक संख्याओं का गुणन एक ही प्रक्रिया का अनुसरण करता है। इसके परिणाम के सभी अंकों को गुणा करें और तब तक इस प्रक्रिया को दोहराएं जब तक कि केवल एक अंक न रह जाए। उपरोक्त उदाहरण लें:

12 * 1231476 का परिणाम है।
1476 के सभी अंकों को हम प्राप्त करते हैं 1 * 4 * 7 * 6 = 168।
168 के सभी अंकों को फिर से गुणा करें 1 * 6 * 8 = 48।
48 के सभी अंकों को फिर से गुणा करें 4 * 8 = 32।
32 के सभी अंकों को एक बार फिर से गुणा करें 3 * 2 = 6।

एकल अंक 6 प्राप्त करने के लिए आवश्यक चरणों की संख्या यह दोहराया गुणन 5 है।

इस चुनौती के लिए और गणित के किसी भी दुरुपयोग से बचने के लिए, मैं इन दो डमी नोटेशनों को पेश करता हूं: (+)और (*), लेकिन आप अपनी पसंद के किसी भी नोटेशन का उपयोग कर सकते हैं , जो अनुसरण की तरह काम करते हैं:

एकल मान प्राप्त करने के लिए बार-बार जोड़ प्रक्रिया का संचालन है 12 (+) 123 = 9।
एकल मान प्राप्त करने के लिए बार-बार गुणा प्रक्रिया का संचालन है 12 (*) 123 = 6।

चुनौती:

चुनौती यह है कि या तो एक कार्यक्रम या एक फ़ंक्शन लिखा जाए जो पृष्ठभूमि अनुभाग में समझाया गया दोनों संचालन कर सकता है : (+)और (*)।

इनपुट:

कार्यक्रम या फ़ंक्शन के इनपुट दो सकारात्मक पूर्णांक हैं और एक ऑपरेशन (+)और (*)। इनपुट का प्रारूप प्रोग्रामर की एक मनमानी पसंद है । आप इनपुट, उदाहरण के लिए, फ़ॉर्मेट कर सकते हैं a (+) bया F(a, (+), b)या किसी भी प्रारूप आप चाहते हैं।

आउटपुट:

कार्यक्रम या फ़ंक्शन के आउटपुट में ऑपरेशन का परिणाम और वांछित चरणों के साथ फ्रीस्टाइल प्रारूप के साथ आवश्यक संख्या शामिल होनी चाहिए।

परीक्षण मामले (इनपुट और आउटपुट प्रारूप को अनदेखा करें):

    81 (+) 31       -->   (4 ; 2)
    351 (+) 14568   -->   (6 ; 3)
    21 (*) 111      -->   (8 ; 3)
    136 (*) 2356    -->   (0 ; 2)

सामान्य नियम:

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

खेल शुरू करते हैं!!

code-golf math repeated-transformation

— अनास्तासिया-रोमानोवा ova
स्रोत

बार-बार जोड़ा जाने वाला हिस्सा ( डिजिटल रूट ) अनिवार्य रूप से codegolf.stackexchange.com/q/1128/194

— पीटर टेलर

4

पहला पहला सवाल! और मैं अपने स्वयं के प्रश्नों से सामान्य नियम प्रारूप और वाक्यों को पहचानता हूं। ;)

— केविन क्रूज़सेन

4

@ केविनक्रूजसेन युप। ये सही है। चूंकि इसका कोई कॉपीराइट नहीं है इसलिए मैं आपकी अनुमति के बिना इसे डुप्लिकेट करता हूं। हेहेहे: डी

— अनास्तासिया-रोमानोवा '

4

@ अनास्तासिया-रोमानोवा no "कोई कॉपीराइट नहीं"? XXI सदी में? नहीं; यहाँ सब कुछ CC-BY-SA 3.0 है। सामग्री सबमिट करने पर अनुमति मिल जाती है। साइट पाद की जाँच करें।

— माइंडविन

1

@ ब्रैडगिल्बर्ब २ जी हां, बिल्कुल। यह इस तरह से पोस्ट में कहा गया है। उद्धरण: "इनपुट का प्रारूप प्रोग्रामर का एक मनमाना विकल्प है"।

— अनास्तासिया-रोमनोवा

11

Dyalog APL , 33 32 30 29 बाइट्स

यह उपसर्ग संकेतन को शामिल करने के लिए APL का विस्तार करता है +/A n₁ n₂और ×/A n₁ n₂। (वास्तव में, आप बाईं ओर किसी भी ऑपरेशन का उपयोग कर सकते हैं /A।) {परिणाम, पुनरावृत्ति गणना} की सूची लौटाता है।

A←{(⊃,≢)⍺⍺{∪⍵,⍨⍺⍺⍎¨⍕⊃⍵}⍣≡⍺⍺⍵}

A←{बाएँ हाथ के कार्य और दाएँ हाथ के तर्क के संदर्भ में एक उच्च-क्रम फ़ंक्शन को परिभाषित करें⍺⍺⍵

(⊃,≢) की गणना के बाद का पहला तत्व है

⍺⍺{आपूर्ति की गई फ़ंक्शन ( +/योग के लिए या ×/उत्पाद के लिए) उच्च-क्रम फ़ंक्शन को खिलाया गया

∪ के अद्वितीय तत्व

⍵,⍨ तर्क से जोड़ा गया

⍺⍺ को खिलाया समारोह

⍎¨ के प्रत्येक चरित्र का मूल्यांकन

⍕ के चरित्र का प्रतिनिधित्व

⊃⍵ तर्क का पहला तत्व

}⍣≡ जब तक परिणाम तर्क के समान होता है, तब तक बार-बार लागू किया जाता है

⍺⍺⍵मूल रूप से खिलाया गया फ़ंक्शन ( +/या ×/) मूल तर्क पर लागू होता है

} [उच्च-क्रम फ़ंक्शन परिभाषा का अंत]

TryAPL ऑनलाइन! ( सुरक्षा कारणों से ⍎इसका अनुकरण किया गया eहै।)

एक बाइट को बचाने के लिए @ngn को धन्यवाद।

0 बाइट्स (जेस्ट में)

Dyalog APL वास्तव में पहले से ही Anastasiyan गणित के लिए पूर्ण समर्थन है; इसके बजाय (+)और (×), यह उपयोग करता है +{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}और ×{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}।

कोशिश करो 81 +{(⊃,≢)⍺⍺{∪⍵,⍨⍺⍺e¨⍕⊃⍵}⍣≡⍺⍺/⍺⍵} 31और 21 ×{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/e¨⍕⍵}⍣=⍵⍺⍺⍨⍺} 111।

— एडम
स्रोत

उत्तर के लिए धन्यवाद, (+1)। क्या यह बड़ी संख्या में इनपुट को संभाल सकता है?

— अनास्तासिया-रोमानोवा

1

यदि आप सेट करते हैं ⎕FR←1287(यानी IEEE 754-2008 128-बिट दशमलव F loating-point R epretation का ⎕PP←34उपयोग करते हैं ) और (यानी 34 वर्णों का उपयोग करें ' P rint P recision), तो आप 10³⁴ से नीचे के पूर्णांक का उपयोग कर सकते हैं।

— अड्म

हम्म, भले ही यह पूर्ण समर्थन है, +{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}और ×{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}अभी भी कुछ बाइट्स नहीं हैं? मैं उलझन में हूँ कि यह कैसे 0 बाइट्स है:: S

— केविन क्रूज़सेन

3

@KevinCruijssen ओपी किसी भी इनपुट संकेतन की अनुमति देता है। इसलिए, यदि कोई भाषा डिफॉल्ट-नोटेशन अनास्तासियायन गणित को आउट-ऑफ-द-बॉक्स का समर्थन करने के लिए हुई, तो मल्टी-चार्ज़ ग्लिफ़ (+), एनास्टासियन + होगा। Dyalog APL, अनास्तासियन गणित का समर्थन करता है, लेकिन यह एक अलग मल्टी-चार ग्लिफ़ का उपयोग करता है, जैसे *कि शक्ति का मतलब है और आपको ×गुणन की आवश्यकता है, जबकि /प्रतिकृति का मतलब है और आपको ÷विभाजन की आवश्यकता है।

— एडम

1

@ Adám आह ठीक है, यह समझ में आता है। यह ओपा के नियमों को तोड़ने वाला है, लेकिन उन्हें तोड़ना नहीं। यह अभी भी बहुत अजीब है कि (+)आपके पास +{n←0⋄n,⍺⍺{n+←1⋄⍺⍺/⍎¨⍕⍵}⍣=⍵⍺⍺⍨⍺}इनपुट के रूप में है, लेकिन चूंकि ओपी ने वास्तव में कहा है कि कोई भी इनपुट प्रारूप करेगा, आप फ़ंक्शन को पैरामीटर के रूप में उपयोग कर सकते हैं। हम्म, मुझे आश्चर्य है कि यह अन्य प्रोग्रामिंग भाषाओं में भी संभव है जो इनपुट के रूप में फ़ंक्शन का समर्थन करते हैं।

— केविन क्रूज़सेन

8

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

f=map(read.pure).show
g h=(\x->(h.f$last x,length x+1)).takeWhile(>10).iterate(h.f)
(a#b)o=g(foldr1 o)$o a b

समारोह को परिभाषित करता है #जो पहले लेता है aऔर bऑपरेटर और उसके बाद o। मजेदार तथ्य: यह किसी भी ऑपरेटर (वास्तव में, किसी भी फ़ंक्शन) के साथ काम करता है जो आप चाहते हैं!

— ThreeFx
स्रोत

उत्तर के लिए धन्यवाद, (+1)। क्या यह बड़ी संख्या में इनपुट को संभाल सकता है?

— अनास्तासिया-रोमानोवा

4

@ अनास्तासिया-रोमानोवा, हाँ, यह आपकी रैम जितनी बड़ी संख्या में संभाल सकती है क्योंकि हास्केल का Integerप्रकार बिना रुके है।

— तीनFx

8

पाइके, 16 बाइट्स

RE`DltImbRoKr)oh

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

RE               - evaluate the input as Pyke code
                 -  (`B` is product and `s` is sum, the second line is a tuple)
  `              - i = str(^)
    ltI      )   - if len(i) != 1:
       mb        -   map(i, int)
         R       -   get the `B` or `s` from input
          oK     -   o++
            r    -   goto_start()
              oh - o++ + 1

के रूप में गुणा Bऔर के रूप में लेता है s। दो संख्यात्मक आदानों को अल्पविराम द्वारा अलग किया जाता है।

— नीला
स्रोत

1

अच्छा! क्या हमें स्पष्टीकरण मिल सकता है?

— एमिगा

उत्तर के लिए धन्यवाद, (+1)। क्या यह बड़ी संख्या में इनपुट को संभाल सकता है?

— अनास्तासिया-रोमानोवा

@ अनास्टेशिया Romanova,秀यह चाहिए मनमाना संख्या संभालने में सक्षम हो

— ब्लू

मैं आपके कोड का परीक्षण नहीं कर सकता क्योंकि वेब मेरे माता-पिता की इंटरनेट उपयोग नीति के उल्लंघन के कारण अवरुद्ध है। T_T

— अनास्तासिया-

कुछ इस तरह से: वेब पेज अवरुद्ध! आपने एक वेब पेज तक पहुंचने का प्रयास किया है जो आपकी इंटरनेट उपयोग नीति का उल्लंघन करता है। URL: pyke.catbus.co.uk/?code=RE%60DltImbRoKr%29oh&input=B%0A21%2C+111&warnings=0 श्रेणी: अपडेट किया गया

— अनास्तासिया-

8

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

पुनरावर्ती कार्य, इनपुट प्रारूप को पुनरावर्ती कॉल को सरल बनाने के लिए सिलवाया गया है:

ऑपरेटर: '+' या '*'
ऑपरेंड: दो मानों की सरणी

f=(o,v,s=1,t=eval(v.join(o)))=>t>9?f(o,[...t+''],s+1):[t,s]

परीक्षा

f=(o,v,s=1,t=eval(v.join(o)))=>t>9?f(o,[...t+''],s+1):[t,s]

;[
  [81,'+',31,     /* -> */ 4, 2]
, [351,'+',14568, /* -> */ 6, 3]
, [21,'*',111,    /* -> */ 8, 3]
, [136,'*',2356,  /* -> */ 0, 2]
].forEach(t=>{
  var [a,o,b,k1,k2] = t,
      [r,s]=f(o,[a,b]);
  console.log(k1==r && k2==s ? 'OK':'KO',a,o,b,'->',r,s)
})

स्निपेट का विस्तार करें

— edc65
स्रोत

उत्तर के लिए धन्यवाद, (+1)। क्या यह बड़ी संख्या में इनपुट को संभाल सकता है?

— अनास्तासिया-रोमानोवा

1

@ अनास्तासिया-

— रोमानोवा cript

8

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

f=lambda s,c=0:s[1:]and f(min(s).join(`eval(s)`),c+1)or(s,c)

इनपुट एक स्ट्रिंग की तरह है 81+31, आउटपुट एक सिंगलटन स्ट्रिंग और एक काउंटर (जैसे, कैप) का एक टपल है ('4', 2)।

Ideone पर इसका परीक्षण करें ।

— डेनिस
स्रोत

यदि इनपुट को स्ट्रिंग्स की एक सरणी के रूप में लिया जाता है और एकल स्ट्रिंग की अनुमति दी जाती है, जैसे, f(['81', '31'],'+')एक और बाइट को बचाया जा सकता है, लेकिन ऐसा लगता है कि नियमों को बहुत दूर खींचना ...

— डेनिस

"इनपुट का प्रारूप प्रोग्रामर की एक मनमानी पसंद है"

— टोबियास किन्ज़लर

... जो मामले में मैं भी जहाँ तक जाना चाहते हैं और गुजर पर विचार operator.addया operator.mul); क्रमशः

— टोबियास Kienzler

7

अजगर, १६

eJ.uvjhQ`N.vQ)lJ

"+ 123 12"इसके अलावा और "* 123 12"गुणन के लिए इनपुट पसंद करता है। जैसे आउटपुट result<linefeed>steps।

इसे यहां आज़माएं , या एक टेस्ट सूट चलाएं , लेकिन ध्यान दें कि यह eval पर निर्भर करता है, इसलिए ऑनलाइन इंटरप्रेटर में केवल अतिरिक्त संस्करण ही काम करेगा। गुणन ऑफ़लाइन दुभाषिया के साथ सही ढंग से काम करता है।

यह मध्यवर्ती परिणामों की एक सूची बनाने के लिए संचयी कमी फ़ंक्शन का उपयोग करता है, इसलिए "+ 351 14568"हम प्राप्त करते हैं [14919, 24, 6]। यह काम करता है क्योंकि एकल अंक संख्या अनास्तासिया जोड़ और गुणा का एक निश्चित बिंदु है। तब हमें केवल एरे का अंतिम तत्व और साथ ही एरे की लंबाई मिलती है।

यह मनमाने ढंग से बड़ी संख्या के लिए काम करेगा, कम से कम जब तक आप स्मृति से बाहर नहीं भागते।

— FryAmTheEggman
स्रोत

7

आर, 175 167 164 140 134 134 127 126 119 बाइट्स

function(G,S,D){i=1;O=switch(S,"+"=sum,prod);x=O(G,D);while(x>9){i=i+1;x=O(strtoi(strsplit(paste(x),"")[[1]]))};c(x,i)}

अघोषित:

f=function(G,S,D) #The function takes : the left operand, the operation symbol (between quote marks)
                  #and then the right operand
i=1               #That's the counter

O=switch(S,"+"=sum,prod)     #`O` takes the value `sum` if `S` matches `+`, `prod` 
                             #(which is the next agument) if not. 

x=O(G,D)                     #Does the first operation

while(nchar(x)>1)                 #While the number of character of the result 
                                  #of the operation is not of length 1, i.e., an integer :

    i=i+1                                    #Increase the counter
    x=O(strtoi(strsplit(paste(x),"")[[1]]))  #Apply the operation `O` to the first operation and 
                                             #the eventual subsequent ones

c(x,i)                                 #Outputs the result and the counter

ifelseवापस आ गया है ! हाँ!
nop

उपयोग:

Special addition
> f(31,"+",81)
[1] 4 2

Special multiplication
> f(136,"*",2356)
[1] 0 2

24 बाइट्स से बाहर निकलने के लिए @plannapus को बहुत-बहुत धन्यवाद ! -7 बाइट्स @Vlo से एक अच्छे विचार के लिए धन्यवाद !

— फ़्रेडरिक
स्रोत

हाँ, कृपया स्पष्टीकरण जोड़ दें क्योंकि मैं आर को प्यार करता हूँ! VBA के बाद यह मेरी दूसरी भाषा है। (+1)

— अनास्तासिया-रोमानोवा '

1

@ अनास्तासिया-रोमानोवा Roman: हो गया!

— Frédéric

@plannapus: बहुत अच्छा! आपका बहुत बहुत धन्यवाद !

— फ्रैडरिक

1

@ Frédéric का अच्छा उपयोग strtoi! 4 और बाइट्स हैं तुमने मुझे पीटा है।

— प्लेनैपस

1

ऐसा लगता है कि आप पहले ऑपरेशन में एक्स के असाइनमेंट के भीतर ओ की परिभाषा को शामिल करके एक बाइट को आगे बढ़ा सकते हैं: एक्स = (ओ = स्विच (एस, सम, `*`)) (जी, डी);)

— rturnbull

6

05AB1E , 20 15 बाइट्स

[¼¹iOëP}Dg#S]¾‚

व्याख्या

[       Dg# ]    # loop until number is single digit
 ¼               # increase counter
  ¹iO            # if operation is addition, sum list
     ëP}         # else take product of list
           S     # split into a list of digits
             ¾‚  # pair final number with counter and output

गुणा के लिए ऑपरेटर 1 है, 0 है।

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

— Emigna
स्रोत

उत्तर के लिए धन्यवाद, (+1)। क्या यह बड़ी संख्या में इनपुट को संभाल सकता है?

— अनास्तासिया-रोमानोवा

@ अनास्तासिया-रोमानोवा Roman मुझे एक कारण नहीं दिखता कि क्यों नहीं। आपके पास कोई उदाहरण है?

— एमिगा

आपके प्रोग्राम को उस तरह के इनपुट्स के लिए टेस्ट किया गया है, इसलिए यह परफेक्ट है :)

— अनास्तासिया-रोमानोवा

6

जेली , 11 10 बाइट्स

Dj⁹VµÐĿḊĖṪ

इनपुट संख्या और या तो की एक जोड़ी है +या ×।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

Dj⁹VµÐĿḊĖṪ  Main link. Left argument: [x, y] (integers). Right argument: + or ×

    µÐĿ     Repeatedly execute the chain to the left, initially with argument
            [x, y], then with the previous return value. Stop when the results are
            no longer unique, and return the array of all intermediate results.
D           Decimal; convert the integers [x, y] or the return value z to base 10.
 j⁹         Join, separating by the link's right argument, i.e., '+' or '×'.
   V        Evaluate the result. This casts the previous return value to string,
            so, e.g., [8, 1, '+', 3, 1] becomes "81+31" before evaluation.
       Ḋ    Dequeue; discard the first intermediate result, i.e., [x, y].
        Ė   Enumerate; prefix each integer in the array with its 1-based index.
         Ṫ  Tail; extract the last index-value pair.

— डेनिस
स्रोत

6

एआरएम मशीन कोड, 48 बाइट्स

हेक्स डंप:

b570 2a00 bf0c 1840 4348 2101 230a e00c 3101 0015 fbb0 f6f3 fb06 0413 2a00 bf0c 192d 4365 0030 d1f5 0028 280a d2f0 bd70

यह फ़ंक्शन किसी भी सिस्टम कॉल या लाइब्रेरी फ़ंक्शन पर निर्भर नहीं करता है। यह थम्ब -2 कोड है, जो 32-बिट एआरएम के लिए एक चर-लंबाई अनुदेश एन्कोडिंग (2 या 4 बाइट्स) है। इस प्रकार, यह प्रक्रिया कर सकता अधिकतम मूल्य 2 ^ 32-1 है। 2 बाइट्स को गिराया जा सकता है यदि यह AAPCS ( 46 बाइट्स ) के अनुरूप नहीं है , क्योंकि शुरुआत में हमें रजिस्टर को ढेर नहीं करना पड़ेगा।

असंगठित विधानसभा (GNU वाक्यविन्यास):

.syntax unified
.text
.global anastasiya
.thumb_func
anastasiya:
    @Input:
    @r0 - First number
    @r1 - Second number
    @r2 - 0 for add, 1 for multiply
    @Output:
    @r0 - Resultant value
    @r1 - Number of steps
    push {r4,r5,r6,lr}
    cmp r2,#0
    ite eq @if r2==0
    addeq r0,r0,r1 @r0+=r1
    mulne r0,r0,r1 @else r0*=r1
    movs r1,#1 @r1 is the number of steps
    movs r3,#10
    b endloop
    loop:
        adds r1,r1,#1 @Increment number of steps
        movs r5,r2 @r5=1 if multiply, 0 if add
        parseDigits:
            udiv r6,r0,r3 @r6=r0/r3
            mls r4,r6,r3,r0 @r4=r0 - r6*r3
            @Last two operations were r4=r0%r3 (r3==10)
            cmp r2,#0
            ite eq @if r2==0
            addeq r5,r5,r4 @r5+=r4
            mulne r5,r5,r4 @else r5*=r4
            movs r0,r6 @r0=r6 (Set r0 to r0/10)
            bne parseDigits @while (r0!=0)
        @Now our new total is in r5
        movs r0,r5 @Put it in r0
    endloop:
        cmp r0,#10
        bhs loop @while (r0 >=10)
    pop {r4,r5,r6,pc} @Return

सी में परीक्षण स्क्रिप्ट:

#include <stdio.h>
unsigned long long anastasiya(unsigned,unsigned,unsigned);

int main(void) {
    unsigned x,y,op;
    printf("Enter first operand, second operand, and 0 for addition or 1 for multiplication.\n");
    scanf("%u%u%u",&x,&y,&op);
    unsigned long long res = anastasiya(x,y,op);
    printf("Result = %u, steps = %u\n",(unsigned)res ,(unsigned)(res >> 32));
}

— इयान च्यू
स्रोत

4

आर, 130 124 चर

@ Frédéric के कुछ अलग दृष्टिकोण :

f=function(a,f,b){b=c(a,b);n=1;while((m<-nchar(d<-switch(f,'(+)'=sum,prod)(b)))>1){b=d%%10^(1:m)%/%10^(1:m-1);n=n+1};c(d,n)}

नई कहानियों के साथ प्रस्तुत:

f=function(a,f,b){
    b=c(a,b) # Take both numbers
    n=1 #Counter
    while((m<-nchar(d<-switch(f,'(+)'=sum,prod)(b)))>1){
#My own special digit splitter! (d is the result and m is the nb of char of d)
        b=d%%10^(1:m)%/%10^(1:m-1)
        n=n+1
    }
    c(d,n) #Print results
    }

लाइन 4 को शायद अधिक स्पष्टीकरण की आवश्यकता है:

switch(f,'(+)'=sum,prod) #pick which operator to use
switch(f,'(+)'=sum,prod)(b) # apply it to b
d<-switch(f,'(+)'=sum,prod)(b) #Saves the result in d
nchar(d<-switch(f,'(+)'=sum,prod)(b))#Measures the number of character of d
m<-nchar(d<-switch(f,'(+)'=sum,prod)(b)) #Saves it in m
(m<-nchar(d<-switch(f,'(+)'=sum,prod)(b)))>1 #Checks if it is more than 1

परीक्षण के मामलों:

> f(12,"(+)",123)
[1] 9 2
> f(12,"(*)",123)
[1] 6 5
> f(351,"(+)",14568)
[1] 6 3

— plannapus
स्रोत

काफी दुर्भाग्यपूर्ण है कि आप इस उत्तर के साथ देर से आए, लेकिन आपने मेरा उत्थान किया है। आर। में यह बनाने के लिए धन्यवाद

— अनास्तासिया-रोमानोवा '

दुर्भाग्यपूर्ण क्यों?

— प्लेनैपस

क्योंकि अगर आप पहली बार आए थे, तो आपको और अधिक वृद्धि मिली होगी

— अनास्तासिया-रोमानोवा

@ अनास्तासिया-

— रोमानोवा enough

बोनस अंक fदोनों फ़ंक्शन नाम और इसके तर्कों में से एक होने के लिए :)

— JDL

4

ऑक्टेव, 85 बाइट्स MATLAB, 123, 114, 105, 94 बाइट्स

प्रत्यक्ष अनुक्रमण, और वृद्धिशीलता का लाभ उठाने के लिए, ऑक्टेस में इसका अनुवाद करने का निर्णय लिया गया। प्रपत्र पर इनपुट लेता है:, f(a,operator)जहां a = [number1, number2], और operator==1उत्पाद देता है, और operator==2योग देता है।

function[x,i]=f(a,o)
g={@prod,@sum}{o};x=g(a);i=1;while(x=g(num2str(x)-48))>9;i++;end

स्पष्टीकरण:

g={@prod,@sum}{o} : उपयुक्त फ़ंक्शन, उत्पाद या योग का चयन करता है और इसे असाइन करता है g

x=g(a) इनपुट का योग या उत्पाद

i=1; ... i++ : इन्क्रीमेंटर चरणों की संख्या की गणना करने के लिए

while(x=g(num2str(x)-48))>9;
          num2str(x)-48)     % turns a number 123 into an array [1 2 3].
        g(num2str(x)-48))    % Takes the sum or product of the array
      x=g(num2str(x)-48))    % Assign that value to the variable x
      x=g(num2str(x)-48))>9  % Checks if x > 9, continue looping if yes

दो न्यूलाइन्स, एक स्पेस, और अलग-अलग तर्कों के बजाय वेक्टर में दोनों इनपुट नंबर को हटा दिया। यह 9 बाइट्स को बचाया, पाजोंक के लिए धन्यवाद! k=@(x)...बीकर =) के लिए एक और 11 बाइट्स धन्यवाद को बचाने के लिए हटा दिया गया है।

— स्टीवी ग्रिफिन
स्रोत

4

जावा, 164 159 146 बाइट्स

int[]p(int t,int m,String[]d){int r=m;for(String i:d){int x=Integer.decode(i);r=m<1?r+x:r*x;}return r>9?p(++t,m,(r+"").split("")):new int[]{r,t};}

पहला तर्क सिर्फ काउंटर है, हमेशा 0

दूसरा तर्क विधि है, 0 ADD के लिए और 1 MULTIPLY के लिए।

तीसरा तर्क स्ट्रिंग्स की एक सरणी है, जिसमें जोड़ने / गुणा करने के लिए मान शामिल हैं।

Ungolfed

public static int[] p(int t, int m, String[] d) {
    int r = m;
    for (String i : d) {
        int x = Integer.decode(i);
        r = m < 1 ? r + x : r * x;
    }
    return (r + "").length() > 1 ? p(++t, m, (r + "").split("")) : new int[]{r, t};
}

कुछ बाइट्स काटने के लिए @ केविन क्रूज़सेन को धन्यवाद।

5 बाइट शेविंग करने के लिए @milk को धन्यवाद।

परीक्षण कार्यक्रम

public static final int ADD = 0;
public static final int MULTIPLY = 1;

public static void main(String[] args) {
    System.out.println(Arrays.toString(p(0, ADD, new String[]{"12", "123"}))); //9
    System.out.println(Arrays.toString(p(0, MULTIPLY, new String[]{"12", "123"}))); //6
}

public static int[] p(int t, int m, String[] d) {
    int r = m;
    for (String i : d) {
        int x = Integer.decode(i);
        r = m < 1 ? r + x : r * x;
    }
    return (r + "").length() > 1 ? p(++t, m, (r + "").split("")) : new int[]{r, t};
}

— शॉन वाइल्ड
स्रोत

मेरे जावा उत्तर से छोटा, अच्छा । हालाँकि, आप उन चरणों के साथ-साथ उस उत्तर को भी छापने वाले हैं जो वर्तमान में आपके उत्तर से गायब है ..

— केविन क्रूज़सेन

@ केविनक्रूजसेन आह। यह उबाऊ है .. मैं अब ठीक करने की कोशिश करूँगा।

— शॉन वाइल्ड

Btw, आप अपने वर्तमान जवाब को थोड़ा गोल्फ कर सकते हैं। m==0हो सकता है m<1, और Integer.parseIntहो सकता है Integer.decode।

— केविन क्रूज़सेन

मैं जावा का अधिक उपयोग नहीं करता, लेकिन क्या आपको jअंत में उस संस्करण की आवश्यकता है ? (r+"")दो बार इनलिंक करने से ऐसा लगता है कि यह कुछ बाइट्स को शेव कर देगा।

— दूध

1

क्या हम भविष्य में अपने पद नहीं बदल सकते हैं? यदि आप टिप्पणियों में ऐसा करने का सुझाव देना चाहते हैं।

— शॉन वाइल्ड

3

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

+×⁵?µDSP⁵?$ÐĿµL;Ṫ

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

तर्कों को देखते हुए x y 1, यह अनास्तासिया राशि की गणना करता है x (+) y।

तर्कों को देखते हुए x y 0, यह अनास्तासिया उत्पाद की गणना करता है x (*) y।

आउटपुट के रूप में दिया जाता है [number of steps, result]।

— लिन
स्रोत

उत्तर के लिए धन्यवाद, लेकिन आपके प्रोग्राम आउटपुट में आवश्यक भाग की संख्या नहीं है? क्या मुझसे कोई चूक हो रही है?

— अनास्तासिया-रोमानोवा

3

पायथन, 160 146 129 बाइट्स

def r(s):
 n=str(eval(s));c=0
 while n[1:]:exec("n=str(reduce(lambda a,b:a%sb,map(int,list(n))))"%"*+"["+"in s]);c+=1
 return n,c

जल्द ही स्पष्टीकरण पोस्ट करेंगे।

इनपुट फॉर्म में 12+12या 5*35(सामान्य +और *संकेतों के साथ) है, और यह मानता है कि वे केवल दो ऑपरेटर हैं।

यह आपके कंप्यूटर की मेमोरी की अनुमति के रूप में नंबर इनपुट को संभाल सकता है।

मैं लगभग निश्चित रूप से आश्वस्त हूं कि यह आगे हो सकता है।

संपादित करें: 16 31 बाइट्स @ कोपर को धन्यवाद दिया।

— clismique
स्रोत

उत्तर के लिए धन्यवाद, (+1)। क्या यह बड़ी संख्या में इनपुट को संभाल सकता है?

— अनस्तासिया-रोमानोवा

@ अनास्तासिया-रोमानोवा h उम्म्म ... मुझे पूरा यकीन है कि वे कर सकते हैं। क्या आप मुझे बड़े इनपुट्स का उदाहरण दे सकते हैं? मैं कोशिश करूँगा और उन लोगों से गणना करूँगा।

— clismique

हो सकता है: 3218753647208435810122106 * 29349566754?

— अनास्तासिया-रोमानोवा

1

@ अनास्तासिया-रोमानोवा, हाँ, इसने ~ 0.5 सेकंड में काम किया, ठीक से समय नहीं दिया।

— clismique

आप बदल सकते हैं "+" if "+" in s else "*"करने के लिए "*+"["+"in s], और उसके बाद के बजाय करने के लिए इसे देने की t, बस इसे इनलाइन जोड़ने में execकॉल।

— कॉपर

3

आर, 110 बाइट्स

@Plannapus 'फाड़नेवाला का उपयोग करना।

function(A,F,B){r=Reduce;x=r(F,A,B);y=1;while(x>9){m=nchar(x);x=r(F,x%%10^(1:m)%/%10^(1:m-1));y=y+1};cat(x,y)}

f=function(A,F,B){
  r=Reduce                                  # Shortcut for Reduce
  x=r(F,A,B)                                # A operator B
  y=1                                       # Initiate counter
  while(x>9)                                # If number of digits > 2, or number > 9
  {m=nchar(x)                               # Count number of digits
    x=r(F,x%%10^(1:m)%/%10^(1:m-1))         # @plannapus's splitter, then feed into the A operator B operator C, etc while condition true
    y=y+1}                                  # Increment counter
  cat(x,y)}                                 # Print

उत्पादन

> f(136,"*",2356)
0 2
> f(31,"+",81)
4 2
> f(2,"+",3)
5 1
> (function(A,F,B){r=Reduce;x=r(F,A,B);y=1;while(x>9){m=nchar(x);x=r(F,x%%10^(1:m)%/%10^(1:m-1));y=y+1};cat(x,y)})(21,"*",111)
8 3

संपादित करें: मैं गिन नहीं सकता।

— VLO
स्रोत

आर शानदार है क्योंकि हमें इसके कार्य को छोटा करने की अनुमति है, जो कि गोल्फ में मूल्यवान है। (+1)

— अनास्तासिया-रोमानोवा '

3

क्लोजर 126 बाइट्स

(defn f [o a b] (loop [n (o a b) c 1] (if (< n 10) [n c] (recur (reduce #(o %1 %2) (map #(- (int %) 48) (str n))) (inc c)))))

समारोह को इस तरह कहा जाता है:

(f + 81 31)

यहाँ कोड ungolfed है:

(defn f [o a b]
  (loop [n (o a b) c 1]
    (if (< n 10)
      [n c]
      (recur (reduce #(o %1 %2)
                     (map #(- (int %) 48) (str n)))
             (inc c)))))

(def test-cases [[+ 81 31]
                 [+ 351 14568]
                 [* 21 111]
                 [* 136 2356]])

(map #(apply f %) test-cases)
;;=> ([4 2] [6 3] [8 3] [0 2])

इस बात को ध्यान में रखें कि क्लोजर मेरे लिए अभी भी नया है, इसलिए यह संभवतः सबसे अच्छा समाधान नहीं है। चुनौती सभी एक समान थी। इसके अतिरिक्त, कोड बिना किसी कठिनाई के बहुत बड़ी संख्या के साथ चला।

— जेम्स बी।
स्रोत

यह बहुत देर हो चुकी है, लेकिन आप वहां के अधिकांश रिक्त स्थान को कम कर सकते हैं।

— ३६:१६

2

पर्ल 6 53 बाइट्स

{$/=(&^b($^a,$^c),{[[&b]] .comb}...10>*);$/[*-1],+$/}

चूंकि ( 12, &[+], 123 )इनपुट के लिए स्वीकार्य है, मैं इसे 53 बाइट्स तक ले जा सकता हूं।
( &[+]छोटा है के लिए &infix:<+>जो संख्यात्मक इन्फ़िक्स अलावा ऑपरेटर के लिए एक "श्रद्धा" है)

यदि दूसरे तर्क में एक स्ट्रिंग होना था तो (+)यह 87 बाइट्स होगा

{my&b=::("&infix:<$^b.substr(1,1)>");$/=(b($^a,$^c),{[[&b]] .comb}...10>*);$/[*-1],+$/}

स्पष्टीकरण:

# bare block lambda with 3 parameters declared using placeholder syntax
{
  # store list into ｢$/｣
  # ( used ｢$/｣ so that I don't have to declare a variable )
  $/ = (

    # declare second placeholder parameter, and call it
    &^b(
      # with the first and third placeholder parameters
      $^a, $^c
    ),

    # bare block lambda with implicit parameter ｢$_｣
    {
      # list reduce using the second parameter from outer block
      [[&b]]

      # a list of the digits of ｢$_｣ (implicit method call)
      .comb
    }

    # keep doing that until
    ...

    # it produces something smaller than 10
    # ( Whatever lambda )
    10 > *
  );

  # returns

  # final result ( last value from list )
  $/[ * - 1 ],
  # and count of values in list
  +$/
}

परीक्षा:

#! /usr/bin/env perl6
use v6.c;
use Test;

my &anastasiya-math = {$/=(&^b($^a,$^c),{[[&b]] .comb}...10>*);$/[*-1],+$/}

my @test = (
  (  81, &[+], 31    ) => (4, 2),
  ( 351, &[+], 14568 ) => (6, 3),
  (  21, &[*], 111   ) => (8, 3),
  ( 136, &[*], 2356  ) => (0, 2),
);

plan +@test;

for @test -> $_ ( :key(@input), :value(@expected) ) {
  cmp-ok anastasiya-math(|@input), &[»==«], @expected;
}

सामान्य उपयोग:

# override built-in Bag operator ｢(+)｣ in current lexical scope
my &infix:<(+)> = &anastasiya-math.assuming: *, &[+], *;

# add a new operator
my &infix:<(*)> = &anastasiya-math.assuming: *, &[*], *;

say 12 (+) 123; # (9 2)
say 12 (*) 123; # (6 5)

— ब्रैड गिल्बर्ट b2gills
स्रोत

2

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

g=lambda x,o,i=1:x<10and[x,i]or g(eval(o.join(`x`)),o,i+1)
lambda a,o,b:g(eval('%s'*3%(a,o,b)),o)

एक अनाम फ़ंक्शन जो पहले ऑपरेंड a, एक ऑपरेटर o( '+'या '*') और दूसरे ऑपरेंड के तर्क के माध्यम से इनपुट लेता है b, और फॉर्म की एक सूची देता है [result, steps]।

यह काम किस प्रकार करता है

अनाम फ़ंक्शन उन दोनों के बीच ऑपरेटर के साथ संचालन को व्यवस्थित करके एक स्ट्रिंग बनाता है, और फिर इसका मूल्यांकन करता है; यह प्रश्न में वर्णित पहला कदम है। फिर, इस मान और ऑपरेटर को पुनरावर्ती फ़ंक्शन में पास किया जाता है g। यहां, एक काउंटर i, जिसे हर पुनरावर्ती कॉल के लिए बढ़ाया जाता है, का उपयोग किया जाता है। यदि इनपुट से कम है 10, तो एक एकल अंक तक पहुंच गया होगा, इसलिए यह iवापस आ गया है। यदि नहीं, तो इनपुट को एक स्ट्रिंग में बदल दिया जाता है और इस स्ट्रिंग में प्रत्येक वर्ण ऑपरेटर के साथ जुड़ जाता है, जिससे वांछित गणना होती है, जिसे फिर मूल्यांकन किया जाता है और फ़ंक्शन को पुनरावर्ती रूप से पास किया जाता है।

Ideone पर इसे आज़माएं

— TheBikingViking
स्रोत

(+1) स्पष्टीकरण की प्रतीक्षा करते हुए :)

— अनास्तासिया-रोमानोवा '

2

ग्रूवी, 102 बाइट्स

def p,e,r;p={t,m,d->e=d*.toInteger();r=m<1?e.sum():e.inject{a,b->a*b};r>9?p(++t,m,""+r as List):[r,t]}

Degolfed

def p,e,r
p = { t, m, d ->
    e = d*.toInteger()
    r = (
            m<1
                ? e.sum()
                : e.inject { a, b -> a * b }
        )
    r > 9
        ? p(++t, m, "" + r as List)
        : [r,t]
}

व्याख्या

जावा के लिए @ सीन बीन के उत्कृष्ट समाधान पर आधारित है।

p: क्लोजर (फ़ंक्शन, लैम्ब्डा, जो भी हो) जो समाधान को लागू करता है
t: वर्तमान कॉल डेप्थ (पुनरावृत्तियों की संख्या), pहमेशा साथ होना चाहिएt=1
m: 0"जोड़ने" के लिए, 1"गुणा" के लिए प्रदर्शन करने के लिए ऑपरेशन
d: ऑपरेंड की सूची, प्रत्येक ऑपरेंड एक स्ट्रिंग ऑब्जेक्ट है
e: प्रत्येक के तत्व d, एक पूर्णांक में परिवर्तित हो गए
r: eऑपरेशन पर निर्भर करता है, का योग या उत्पादm
परिणाम कथन, के साथ शुरू r > 9:
- यदि बहु-अंक ( r > 9), पुनर्निवेश, गहराई बढ़ाना tऔर rअंकों की सूची (और वापसी परिणाम) की सूची में परिवर्तित करना।
- यदि एकल-अंक, वापसी rऔर tएक सूची के रूप में।

परीक्षण कार्यक्रम

final ADD = 0
final MULTIPLY = 1
println p(1, ADD, ["12", "123"]) //9, 2
println p(1, MULTIPLY, ["12", "123"]) //6, 5
println p(1, ADD, ["2", "3"]) //5, 1

परिणाम

[9, 2]
[6, 5]
[5, 1]

— रोजर ग्लोवर
स्रोत

2

हास्केल, 76 70 बाइट्स

 (x#y)f=until(<[10])(\[s,i]->[foldr(f.read.pure)0$show s,i+1])[f x y,1]

परिणाम और चरणों की संख्या के साथ एक दो तत्व सूची देता है। बड़ी संख्या में मनमानी के लिए काम करता है। प्रयोग उदाहरण: (351#14568)(+)-> [6,3]।

संपादित करें: 6 बाइट्स के लिए @BlackCap का धन्यवाद।

— nimi
स्रोत

आप बदल सकते हैं (-48+).fromEnumके साथread.pure

— BlackCap

2

आर, 91 बाइट्स

@ व्लो के कोड का उपयोग करना, जो @ प्लेनैपस के स्प्लिटर का उपयोग करता है, और कुछ आइडिया जो मैंने @ फ्रेडेरिक के उत्तर को गोल्फ करते समय उत्पन्न किया, यह अभी तक का सबसे छोटा आर उत्तर है। (आज यहां असामान्य रूप से बड़ी संख्या में आर उत्तर ...)

function(A,F,B){x=F(A,B);while(x>9){m=nchar(x);x=F(x%%10^(1:m)%/%10^(1:m-1));T=T+1};c(x,T)}

महत्वपूर्ण रूप से, इसके लिए आवश्यक है कि ऑपरेटर के लिए इनपुट sum(+) या prod(*) के लिए होना चाहिए। चुनौती के नियमों के तहत, यह ठीक लगता है।

इंडेंटेशन के साथ:

function(A,F,B){
  x=F(A,B);
  while(x>9){
    m=nchar(x);
    x=F(x%%10^(1:m)%/%10^(1:m-1));
    T=T+1
  };
  c(x,T)
}

@ वलो के उत्तर से मुख्य अंतर हैं:

उपयोग करने के बजाय Reduce, हम एक फ़ंक्शन होने वाले इनपुट तर्क पर भरोसा करते हैं, और बस इसे स्पष्ट रूप से कहते हैं। (फ़र्स्ट-क्लास ऑब्जेक्ट होने वाले फ़ंक्शंस के लिए Yay!)
अपने काउंटर के रूप में एक नए चर को इनिशियलाइज़ करने के बजाय, हम आर के बिल्डिंस और उपयोग का दुरुपयोग करते हैं T, जो TRUE(उर्फ 1) का मूल्यांकन करता है , लेकिन चूंकि यह आरक्षित चर नहीं है, इसलिए हम इसे संशोधित कर सकते हैं। इस प्रकार T+Tहै 2। इसलिए हम इसका उपयोग अपने काउंटर के रूप में करते हैं।
catआउटपुट के आईएनजी के बजाय , हम इसे एक वेक्टर के रूप में वापस करते हैं c। दो बाइट्स को बचाने के साथ-साथ, यह तथ्य कि आउटपुट को एक वेक्टर में मजबूर किया जाता है, यह सुनिश्चित करता है कि Tवर्ग का है numeric। यदि हम उपयोग करते हैं cat, और Tवृद्धि नहीं की गई है, तो हमें गलत आउटपुट मिलता है 1 TRUE।

— rturnbull
स्रोत

आप whileलूप का पुनर्गठन इस प्रकार कर सकते हैं, Fनाम संघर्ष से बचने के लिए कुछ और बनना function(A,O,B){x=O(A,B);while({F=F+1;x>9})x=O(x%/%10^(1:nchar(x)-1)%%10;c(x,F)}}। यह आश्चर्यजनक है कि पिछले कुछ वर्षों में हम कितने R गोल्फिंग ट्रिक्स लेकर आए हैं :)

— Giuseppe

@Giuseppe अच्छा पुनर्गठन! मुझे इस समय मेटा सर्वसम्मति नहीं मिल रही है, लेकिन मुझे पूरा विश्वास है कि किसी फ़ंक्शन के भीतर Tऔर Fकाउंटर ट्रिक का उपयोग करना वास्तव में अमान्य है, क्योंकि इसका मतलब है कि फ़ंक्शन को केवल एक बार बुलाया जा सकता है। तो यह जवाब (और मेरे कई अन्य!) अमान्य हैं, जब तक rm(T)कि अंत में एक स्पष्ट नहीं है । मैं उस मेटा पोस्ट की तलाश में रहता हूं ताकि मुझे यकीन हो जाए कि मैंने इसे सपने में नहीं सोचा था।

— rturnbull

मेरा मानना है कि जब तक आप संशोधित या वैश्विक वातावरण में नहीं आते हैं, चाल Tऔर Fचाल पूरी तरह से मान्य है। उदाहरण के लिए, लगातार रिटर्न । मुझे लगता है कि यह मेटा पोस्ट है, जिसका आप उल्लेख करते हैं। TFf=function(){T=T+1;T}2

— ग्यूसेप

@Giuseppe आह हाँ, तुम दोनों मायने में सही हो। धन्यवाद!

— rturnbull

1

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

पुनरावर्ती कॉल। @ Edc65 के जावास्क्रिप्ट उत्तर से बहुत भिन्न हुआ करता था, लेकिन जैसा कि मैंने इसे अनुकूलित किया, अंततः उनके जवाब से लगभग एक स्वतंत्र रूप से विकसित एक सीधा बंदरगाह बन गया, एक अंतिम अनुकूलन जिसमें ऑपरेंड की सूची की लंबाई के बजाय eval'ed परिणाम की जांच शामिल है। , जिसने मुझे उनकी बाइट की गिनती को पार करने की अनुमति दी।

इनपुट एक स्ट्रिंग है जो ऑपरेटर का प्रतिनिधित्व करता है, और एक सरणी जिसमें ऑपरेंड होते हैं।

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

f=->o,x,i=1{y=eval x*o;y>9?f[o,y.to_s.chars,i+1]:[y,i]}

— मूल्य स्याही
स्रोत

परिणाम सही है, लेकिन एकल अंकों का मूल्य प्राप्त करने के लिए आवश्यक चरणों की संख्या गलत है। क्या आप अपना कोड सुधार सकते हैं?

— अनस्तासिया-रोमानोवा

@ अनास्तासिया-रोमानोवा, आह, आप सही कह रहे हैं। मेरे पुराने तर्क के लिए इसे शुरू करने की आवश्यकता थी i=0और रिफ्लेक्टिंग करते समय मैं भूल गया था।

— वैल्यू इंक

1

पर्ल, 38 बाइट्स

के लिए +2 शामिल है -ap

STDIN पर इनपुट के साथ चलाएं और ऑपरेटर के चारों ओर रिक्त स्थान:

amath.pl <<< "12 + 123"
amath.pl <<< "12 * 123"

आउटपुट अंकों और द्वारा अलग किए गए चरण हैं +A

amath.pl:

#!/usr/bin/perl -ap
1while++$\,$_=eval."+A",s/\B/$F[1]/g

यदि चरणों को एकात्मक में आउटपुट करना ठीक है तो यह 35 बाइट संस्करण बेहतर काम करता है:

#!/usr/bin/perl -lap
1while$\.=1,$_=eval,s/\B/$F[1]/g

— टन हास्पेल
स्रोत

1

मैथेमेटिका, 105 94 बाइट्स

कोड।

{x,y}=(c=0;f//.a_:>(c++;t=o@@IntegerDigits@a);{t,c})&/.{{f->#1+#2,o->Plus},{f->#1#2,o->Times}}

उपयोग।

x[81, 31]
(* {4, 2} *)

x[351, 14568]
(* {6, 3} *)

y[21, 111]
(* {8, 3} *)

y[136, 2356]
(* {0, 2} *)

स्पष्टीकरण।

दो कार्यों x((+)) और y(के लिए (*)) एक ही समय में पैरामीटर की जगह fऔर oमें बनाए जाते हैं

(c = 0;
 f //. a_ :> (c++; t = o@@ IntegerDigits@a);
 {t, c}
)&

उनके उचित मूल्यों के साथ। के लिए x, fबन जाता है #1 + #2और oबन जाता है Plus; के लिए y, वे क्रमशः बन जाते हैं #1 #2और Times। xस्पष्टीकरण के अंतिम भाग के लिए फ़ंक्शन को फिर से लिखना :

x = (
  c = 0;
  #1 + #2 //. a_ :> (c++; t = Plus@@IntegerDigits@a); 
  {t, c}
) &;

(* The symbol //. stands for ReplaceRepeated. 
   The rule a_ :> (c++; t = Plus@@IntegerDigits@a) is applied until the result no longer 
changed. Specifically, the rule increments the counter of 1 at each step (this is c++), 
then takes the sum of the digits of the previous result (this is Plus@@IntegerDigits@a). 
The rule stops to apply when the variable t is less than 10. We return the final result and 
the number of steps with {t, c}. *)

1

जावा 7, 203 195 192 बाइट्स

int c=1;String c(long a,long b,int o){return p(((o<1?a+b:a*b)+"",o)+","+c;}long p(String n,int o){long x=o,q;for(String s:n.split("")){q=new Long(s);x=o<1?x+q:x*q}c++;return x<10?x:p(x+"",o);}

यह long(2 ⁶³ -1 का अधिकतम मूल्य) का उपयोग करता है । यदि इसके intबजाय इसका उपयोग किया जाएगा (अधिकतम मूल्य 2 ³¹ -1) तो यह केवल 1 बाइट कम ( 191 बाइट ) होगा।

int c=1;String c(int a,int b,int o){return p(((o<1?a+b:a*b)+"",o)+","+c;}int p(String n,int o){int x=o,q;for(String s:n.split("")){q=new Integer(s);x=o<1?x+q:x*q}c++;return x<10?x:p(x+"",o);}

यह सबसे अधिक संभावना थोड़ा और गोल्फ हो सकता है। चरणों को प्रिंट करने के साथ-साथ दोनों ऑपरेटरों के लिए उत्तर कुछ बाइट्स लेता है, हालांकि ..
उपयोग 0 (के लिए (+)) और 1 (के लिए (*))।

Ungolfed और परीक्षण कोड:

इसे यहाँ आज़माएँ।

class Main{
  static int c = 1;
  static String c(long a, long b, int o){
    return p((o < 1 ? a+b : a*b) + "", o) + "," + c;
  }

  static long p(String n, int o){
    long x = o,
         q;
    for(String s : n.split("")){
      q = new Long(s);
      x = o < 1
           ? x + q
           : x * q;
    }
    c++;
    return x < 10
            ? x
            : p(x+"", o);
  }

  public static void main(String[] a){
    System.out.println(c(81, 31, true));
    c = 1;
    System.out.println(c(351, 14568, true));
    c = 1;
    System.out.println(c(21, 111, false));
    c = 1;
    System.out.println(c(136, 2356, false));
  }
}

आउटपुट:

4,2
6,3
8,3
0,2

— केविन क्रूज़सेन
स्रोत

अनास्तासिया की दुनिया में गणित कैसे काम करता है?

पृष्ठभूमि:

चुनौती:

इनपुट:

आउटपुट:

सामान्य नियम:

Dyalog APL , 33 32 30 29 बाइट्स

0 बाइट्स (जेस्ट में)

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

पाइके, 16 बाइट्स

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

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

अजगर, १६

आर, 175 167 164 140 134 134 127 126 119 बाइट्स

05AB1E , 20 15 बाइट्स

जेली , 11 10 बाइट्स

यह काम किस प्रकार करता है

एआरएम मशीन कोड, 48 बाइट्स

आर, 130 124 चर

ऑक्टेव, 85 बाइट्स MATLAB, 123, 114, 105, 94 बाइट्स

जावा, 164 159 146 बाइट्स

Ungolfed

परीक्षण कार्यक्रम

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

पायथन, 160 146 129 बाइट्स

आर, 110 बाइट्स

क्लोजर 126 बाइट्स

पर्ल 6 53 बाइट्स

स्पष्टीकरण:

परीक्षा:

सामान्य उपयोग:

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

ग्रूवी, 102 बाइट्स

Degolfed

व्याख्या

परीक्षण कार्यक्रम

परिणाम

हास्केल, 76 70 बाइट्स

आर, 91 बाइट्स

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

पर्ल, 38 बाइट्स

मैथेमेटिका, 105 94 बाइट्स

जावा 7, 203 195 192 बाइट्स