एप्लाइड नंबर गेम

Question

एप्लाइड नंबर गेम

एक फ़ंक्शन / प्रोग्राम लिखें जिसमें 2 पूर्णांक पैरामीटर पूर्णांक पैरामीटर या पूर्णांक चर , एक प्रारंभ संख्या और अधिकतम पुनरावृत्तियों की गणना होती है। कोड को एक नया नंबर बनाने के लिए निम्नलिखित गेम का उदाहरण देना चाहिए, और तब तक दोहराना चाहिए जब तक कि अंक एक एकल अंक न रह जाए। जैसे।

3 7 2 = (3 + 7) & (7 + 2) = 10 9
1 0 9 = (1 + 0) & (0 + 9) = 1 9
1 9 = (1 + 9) = 10
1 0 = (1 + 0) = 1

मूल रूप से, प्रत्येक व्यक्तिगत अंक को लेने और इसे अपने पड़ोसी से जोड़ना, फिर अगले परिणाम के साथ-साथ परिणाम को जोड़ना।

अधिकतम पुनरावृत्ति गणना अनंत छोरों को सुरक्षित करने के लिए है, और जब अधिकतम हिट होता है, तो कोड को अंतिम 5 नंबर चरणों को डंप करना चाहिए। एक ही अंक तक पहुँचने पर एक ही आउटपुट होना चाहिए। यदि 5 से कम चरण होते हैं, तो केवल मान्य संख्याओं का उत्पादन होता है।

आउटपुट Step: Numberपूर्ण या समाप्त चरणों के अंतिम चरण सहित ( ) दिखाई देना चाहिए :

func(3541, 50) इस सटीक आउटपुट स्वरूप का उत्पादन करेगा:

6: 1411
7: 552
8: 107
9: 17
10: 8

func(3541, 5) उत्पादन होगा:

1: 895
2: 1714
3: 885
4: 1613
5: 774

संपूर्ण गणना की जा रही है:

1: 895
2: 1714
3: 885
4: 1613
5: 774
6: 1411
7: 552
8: 107
9: 17
10: 8

यदि 5 से कम चरण हैं, तो बस उन चरणों को प्रिंट करें।

केवल बिल्ट-इन लिबास का उपयोग करें, पैरामीटर कहीं से भी हो सकते हैं (आपकी पसंद की भाषा के लिए सबसे आसान)। अधिकतम पूर्णांक आकार पर कोई सीमा नहीं है, और यदि वहाँ बहुत अधिक हैं, तो इसे क्रैश होने दें।

यह देखते हुए कि यह एक पहेली की दृष्टि से बहुत कठिन नहीं है, मैं स्वीकृत उत्तर के लिए विचार करने के लिए प्रस्तुतियाँ के लिए रविवार २५, (बजे (यूटीसी + from) तक का समय दूंगा, जिस बिंदु पर किसी भी भाषा का सबसे छोटा विजेता होगा।

संपादित करें:

हॉवर्ड को बधाई, 48 गोल्फस्क्रिप्ट उत्तर के साथ जीत ।

66 एपीएल उत्तर के साथ 2 स्थान मेरिनस का विशेष उल्लेख ।

मेरा व्यक्तिगत पसंदीदा (जावास्क्रिप्ट के पक्षपाती होना) Core1024 का जवाब था ।

Comments

मुझे समझ नहीं आ रहा है, func(3541, 5)5 चरणों को मुद्रित करना है या 10 को?

— ताल

5 कदम। यह चलना बंद कर देना चाहिए क्योंकि यह पुनरावृत्ति 5 को हिट करता है, अधिक पुनरावृत्तियों का प्रदर्शन नहीं करता है और अंतिम 5 चरणों का प्रिंट आउट करता है। मैंने अभी उस विशेष इनपुट के लिए पूर्ण गणना प्रक्रिया दिखाने के लिए चरणों का पूरा सेट शामिल किया है।

— मैट

Answer 1

GolfScript, 48 46 वर्ण

{.`n*[~]n\{:s++s}*;~}*].,,\]zip{': '*}%1>-5>n*

दो-चरित्र सुधार के लिए पीटर टेलर को धन्यवाद ।

स्टैक पर दोनों संख्याओं की अपेक्षा करता है। ऑनलाइन कोशिश करें ।

उदाहरण:

> 4 50

> 141 50
1: 55
2: 10
3: 1

> 3541 50
6: 1411
7: 552
8: 107
9: 17
10: 8

> 3541 5
1: 895
2: 1714
3: 885
4: 1613
5: 774

Comments

एक फ्लिप जोड़ने के बाद .,,और अंतिम नक्शे को बस में बदलकर एक मध्यम बचत होती है {': '*}%।

— पीटर टेलर

Answer 2

एपीएल (66)

{↑¯5↑{(⍕⍵),': ',⍺}/∆,⍪⍳⍴∆←⍺{(1<⍴⍵)∧⍺>0:∆,(⍺-1)∇⊃∆←,/⍕¨2+/⍎¨⍵⋄⍬}⍕⍵}

बाएं तर्क अधिकतम पुनरावृत्ति गणना है और सही तर्क प्रारंभ संख्या है।

स्पष्टीकरण:

• ∆←⍺{... }⍕⍵: एक संख्या के रूप में बाएं तर्क और सही तर्क को फ़ंक्शन के लिए स्ट्रिंग के रूप में पास करें जो संख्याओं की सूची की गणना करता है, और इसे इसमें संग्रहीत करता है ∆:
  • (1<⍴⍵)∧⍺>0:: यदि अंकों की मात्रा 1 से अधिक है और बचे हुए पुनरावृत्तियों की मात्रा इससे अधिक है 0:
    • ⍎¨⍵: प्रत्येक अंक का मूल्यांकन करें
    • 2+/: प्रत्येक जोड़ी का योग
    • ⍕¨: प्रत्येक संख्या को एक स्ट्रिंग के रूप में प्रारूपित करें
    • ∆←,/: स्ट्रिंग्स को समेटें और स्टोर करें ∆
    • ∆,(⍺-1)∇⊃∆: वापसी ∆, इस फ़ंक्शन को लागू करने के परिणाम के ∆साथ एक कम पुनरावृत्ति की अनुमति है
  • ⋄⍬: यदि नहीं, तो खाली सूची वापस करें
• ∆,⍪⍳⍴∆: ∆इसके सूचकांक के साथ प्रत्येक तत्व को जोड़ी∆
• {... }/: प्रत्येक जोड़ी के लिए:
  • (⍕⍵),': ',⍺: इंडेक्स के साथ एक स्ट्रिंग लौटाएं, उसके :बाद नंबर के साथ
• ↑¯5↑: स्ट्रिंग्स की सूची को एक मैट्रिक्स में बदल दें ताकि वे अलग-अलग लाइनों पर प्रदर्शित हों, और अंतिम 5 आइटम लें

परीक्षा:

      5{↑¯5↑{(⍕⍵),': ',⍺}/∆,⍪⍳⍴∆←⍺{(1<⍴⍵)∧⍺>0:∆,(⍺-1)∇⊃∆←,/⍕¨2+/⍎¨⍵⋄⍬}⍕⍵}3541
1: 895 
2: 1714
3: 885 
4: 1613
5: 774 
      50{↑¯5↑{(⍕⍵),': ',⍺}/∆,⍪⍳⍴∆←⍺{(1<⍴⍵)∧⍺>0:∆,(⍺-1)∇⊃∆←,/⍕¨2+/⍎¨⍵⋄⍬}⍕⍵}3541
6: 1411
7: 552 
8: 107 
9: 17  
10: 8  

Comments

क्या यह हैंडल 5 चरणों से कम के डिस्प्ले को ठीक से प्रदर्शित करता है? जैसे 3 {...} 3541।

— एल्गोरिथमशार्क

@ अल्गोरिद्मशर्क अब यह करता है (इसने :पहले के साथ अतिरिक्त लाइनें दीं )

— marinus

Answer 3

गणितज्ञ, 172 वर्ण

यह बहुत लंबा रास्ता है, मैथेमेटिका के फ़ंक्शन नाम और बदसूरत स्ट्रिंग हैंडलिंग (वास्तविक "गेम" उन पात्रों में से केवल 76 के लिए धन्यवाद), लेकिन यहां यह वैसे भी है:

""<>ToString/@(f=Flatten)@Take[Thread@{r=Range@Length[s=Rest@Cases[NestList[FromDigits[f@(d=IntegerDigits)[Tr/@Partition[d@#,2,1]]]&,n,m],i_/;i>0]],": "&/@r,s,"\n"&/@r},-5]

यह चर में इनपुट संख्या nऔर पुनरावृत्तियों की अधिकतम संख्या की अपेक्षा करता है m।

कम गोल्फ के साथ:

"" <> ToString /@
  (f = Flatten)@
   Take[
    Thread@{
      r = Range@Length[
         s = Rest@Cases[
            NestList[                 
             FromDigits[
               f@(d = IntegerDigits)[Tr /@ Partition[d@#, 2, 1]]] &,
             n,
             m
             ],
            i_ /; i > 0
            ]
         ],
      ": " & /@ r,
      s,
      "\n" & /@ r
      },
    -5
    ]

Answer 4

रूबी, 106 वर्ण

f=->n,m{s=0
$*<<"#{s}: #{n=n.to_s.gsub(/.\B/){eval$&+?++$'[0]}.chop}"until n.to_i<10||m<s+=1
puts$*.pop 5}

मैं इनपुट नियमों पर 100% स्पष्ट नहीं हूं, लेकिन अगर मैं nएक स्ट्रिंग के रूप में ले सकता हूं तो मैं 5 वर्णों को बचा सकता हूं, और अगर मैं पूर्वनिर्धारित चर का उपयोग कर सकता हूं और एक फ़ंक्शन के बजाय एक प्रोग्राम लिख सकता हूं, तो मैं एक और 9 बचा सकता हूं।

एक फ़ंक्शन बनाता fहै जिसे निम्नानुसार कहा जा सकता है:

f[3541, 6]

2: 1714
3: 885
4: 1613
5: 774
6: 1411

f[372, 50]

1: 109
2: 19
3: 10
4: 1

f[9999, 10]

6: 99999999999
7: 18181818181818181818
8: 9999999999999999999
9: 181818181818181818181818181818181818
10: 99999999999999999999999999999999999

Comments

दिलचस्प है कि 4 या अधिक "9" का एक विचलन परिणाम पैदा करता है

— डिजिटल ट्रामा

Answer 5

जे - 96 92 चार

मैंने पहली बार यह मानते हुए हल किया कि सभी खेल समाप्त हो गए, और यह मुझे परीक्षण के दौरान गधे में काटने के लिए वापस आया। बाएं तर्क चरणों की संख्या है, सही तर्क प्रारंभिक स्थिति है, जिसे संख्या या स्ट्रिंग के रूप में दिया जा सकता है।

([(-@(<.5<.#){.])(#\(,': '&,)&":"0,)@}.@({.~,i.0:)@:".@(<@>:@[(' '-.~[:,@":2+/\"."0@]^:)":))

यह थोड़ा बहुत गोल्फ और संतुष्ट करने के लिए अपमानित करने के लिए दृढ़ है, इसलिए मैं यह कहूंगा:

• (<@>:@[(' '-.~[:,@":2+/\"."0@]^:)":)यह भाग निर्दिष्ट चरणों की संख्या के लिए गेम चलाता है। 2+/\प्रत्येक जोड़ी अंकों को जोड़ने के लिए जिम्मेदार है, और खेल के मध्यवर्ती चरणों पर कब्जा करने वाले नियंत्रण के <@>:@[साथ मिलकर ^:।
• (#\(,': '&,)&":"0,)@}.@({.~,i.0:)@:".यह भाग सभी परिणामों को इस रूप में प्रारूपित करता है step: result। ({.~,i.0:)यह सुनिश्चित कर रहा है कि हम बहुत अधिक कदम नहीं उठा रहे हैं, #\कदम संख्या है, और (,': '&,)&":"0कोलन और स्पेस को थोड़ा जोड़ता है।
• (-@(<.5<.#){.])यह भाग पूरी सूची से प्रासंगिक पाँच-या-कम चरणों को काट देता है। <.का अर्थ है 'न्यूनतम'।

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

   f =: ([(-@(<.5<.#){.])(#\(,': '&,)&":"0,)@}.@({.~,i.0:)@:".@(<@>:@[(' '-.~[:,@":2+/\"."0@]^:)":))
   5 f 3541
1: 895
2: 1714
3: 885
4: 1613
5: 774
   50 f 3541
6: 1411
7: 552
8: 107
9: 17
10: 8
   100 f 372
1: 109
2: 19
3: 10
4: 1

Answer 6

जावास्क्रिप्ट 139 144 150

function f(a,n){for(r=[a+=''];n--&&a[1];r.push(a=t))for(t='',i=0;a[++i];)t+=a[i-1]- -a[i];for(i=0;r[++i];)r[i+5]||console.log(i+': '+r[i])}

Ungolfed

function f(a,n)
{
  for (r=[a+='']; n-- && a[1]; r.push(a=t))
  {
    for (t = '', i = 0; a[++i]; )
    {
      t += a[i-1]- -a[i]; /* -char force conversion to number */
    }
  }   
  for (i = 0; r[++i];) r[i+5]||console.log(i+': '+r[i])
}

Answer 7

पर्ल, 86 84

पठनीयता के लिए नई सुर्खियों के साथ:

$s+=$_=<>;
print+(map$s=~s/.(?=(.|))/~$1?$&+$1:''/eg>1?"$_: $s$/":(),/ /..$')[-5..-1]

+ संपादित करें:-n कमांड लाइन स्विच का उपयोग नहीं करने के लिए कोई बहाना नहीं है , और फिर स्कोर 82 = 81 + 1 है :

$s+=$_;
print+(map$s=~s/.(?=(.|))/~$1?$&+$1:''/eg>1?"$_: $s$/":(),/ /..$')[-5..-1]

और, संभव पूर्णांक अतिप्रवाह ठीक हो रहा है, यह 81 = 80 + 1 है

$.=$_;
print+(map$.=~s/.(?=(.|))/~$1?$&+$1:''/eg>1?"$_: $.$/":(),/ /..$')[-5..-1]

Comments

मैंने नए टिंग्स सीखे। बहुत बढ़िया!

— core1024

Answer 8

जावास्क्रिप्ट, 247 278 288 307 वर्ण

 var t=[],q=1;function f(a,c){var x=a.toString().split(''),r='',p=parseInt;for(y in x){var i=p(y);if(i){r+=(p(x[i])+p(x[i-1])).toString();}}if(c!=0&&a>10){t.push(q+++':'+r+'\n');if(q>6){t.shift()}f(r,c-1);}console.log(t.join(',').replace(/,/g,''))}

प्रारूपित

var t = [],
q = 1;

function f(a, c) {
 var x = a.toString().split(''),
    r = '',
    p = parseInt;
 for (y in x) {
    var i = p(y);
    if (i) {
        r += (p(x[i]) + p(x[i - 1])).toString();
    }
 }
 if (c != 0 && a > 10) {
    t.push(q+++':' + r + '\n');
    if (q > 6) {
        t.shift()
    }
    f(r, c - 1);
 }
 console.log(t.join(',').replace(/,/g, ''))
}

संपादित करें 1 : हटाए गए टर्नरी

संपादन 2 : "स्किपिंग" 0 इंडेक्स के लिए फ़्लिप किए गए तर्क

संपादित 3 : पुनरावर्ती पुनरावर्ती कॉलिंग।

बेला

Comments

चिंता मत करो, यहाँ देखने के लिए कुछ भी नहीं है। सोचा कि यह पहले 5 मुद्रण कर रहा था, लेकिन यह आपके फिडेल के साथ होना चाहिए। अच्छा काम :)

— मैट

Answer 9

बैश + कोरुटिल्स, 115 बाइट्स

for((a=$1;++i<=$2&a>9;)){
a=`paste -d+ <(fold -1<<<${a%?}) <(fold -1<<<${a#?})|bc|tr -d '
'`
echo $i: $a
}|tail -n5

आउटपुट:

$ ./appended-number.sh 3541 50
6: 1411
7: 552
8: 107
9: 17
10: 8
$ ./appended-number.sh 3541 5
1: 895
2: 1714
3: 885
4: 1613
5: 774
$ 

Answer 10

जावास्क्रिप्ट (ECMAScript 6 ड्राफ्ट) - 134 वर्ण

f=(x,y,i=0,j=[])=>([m=''].map.call(m+x,(z,p,n)=>m+=p?+z+1*n[p-1]:m),j[i++]=i+': '+m,m.length>1&&i<y?f(m,y,i,j):j.slice(-5).join('\n'))

उदाहरण:

f(372,5)
"1: 109
2: 19
3: 10
4: 1"

f(3541,50)
"6: 1411
7: 552
8: 107
9: 17
10: 8"

f(3541,5)
"1: 895
2: 1714
3: 885
4: 1613
5: 774"

Answer 11

जावास्क्रिप्ट, 182 बाइट्स

function f(I,T){s=[],x=1;for(;;){d=(""+I).split("");l=d.length;if(l==1||x>T)break;for(I="",i=1;i<l;)I+=+d[i-1]+ +d[i++];s.push(x+++": "+I)}s=s.slice(-5);for(i in s)console.log(s[i])}

Answer 12

पर्ल, 166 147 138 129 बाइट्स

<>=~/ /;for$i(1..$'){@n=split'',$s||$`;$s=join'',map{$n[$_]+$n[$_+1]}0..@n-2;@o=(@o,"$i: $s");$s<10&&last}print join$/,@o[-5..-1]

Ungolfed:

<> =~ / /;
for $i (1..$') {
    @n = split'', $s||$`;
    $s = join'',map {$n[$_]+$n[$_+1]} 0..@n-2;
    @o = (@o, "$i: $s");
    $s<10 && last
}
print join$/,@o[-5..-1]

मुझे आशा है कि यह ठीक है कि यह कुछ अतिरिक्त खाली लाइनों को प्रिंट करता है अगर पूरी चीज 5 से कम कदम लेती है।

Comments

बदलें (('')x5, @o, "$i: $s")के साथ (@o, "$i: $s")और join"\n", @o[-5..0]साथ join"\n", @o[-5..-1]। फिर आप 3 बाइट्स आगे होंगे;)

— कोर 1024

मुझे अतिरिक्त खाली लाइनों के साथ कोई समस्या नहीं है।

— मैट

@ core1024 धन्यवाद :) मैं आपको एक टिप देने जा रहा था, लेकिन आपने पहले ही उस लंबे "" से छुटकारा पा लिया जब तक "भाग"

— ताल

Answer 13

जावा      524   405 365 वर्ण [414 बाइट्स]

गोल्फ संस्करण: class A{static int n=0;List<String> s=new ArrayList<>();void c(int b,int r){String d=b+"";if(r==0||b <= 9){int m=s.size();for(int i= m>=5?m-5:0;i<m;i++)System.out.println(s.get(i));return;}String l="";for(int i=0;i<d.length()-1;i++)l+=d.charAt(i)+d.charAt(i+1)-96;s.add(++n+":"+l);c(Integer.valueOf(l),--r);}public static void main(String[] a){new A().c(3541,50);}}

पठनीय संस्करण:

class AddDigits {
static int n = 0;
List<String> steps = new ArrayList<>();

void count(int num, int count) {
    String digits = num + "";
    if (count == 0 || num <= 9) {
        int stepsSize = steps.size();
        for (int i = stepsSize >= 5 ? stepsSize - 5 : 0; i < stepsSize; i++) {
            System.out.println(steps.get(i));
        }
        return;
    }
    String line = "";
    for (int i = 0; i < digits.length() - 1; i++) {
        line += digits.charAt(i) + digits.charAt(i + 1) - 96;
    }
    steps.add(++n + ":" + line);
    count(Integer.valueOf(line), --count);
}

public static void main(String[] args) {
    new AddDigits().count(3541, 50);
}
}

Comments

आप चर और फ़ंक्शन नामों के लिए 1 वर्ण का उपयोग करके इसे छोटा कर सकते हैं।

— लेक्स वेब

हो गया ... अंकों को फिर से बदलने के लिए लॉजिक को भी बदल दिया </ 9 इसके बजाय digits.length == 1 (केवल इस धागे में देखा ... मुझे पहले नहीं मारा)।

— user12345

Yout मुख्य विधि में आप तर्क नाम की लंबाई कम कर सकते हैं, जो आपको अतिरिक्त 3 चैटर देगा

— user902383

आपको वर्णों के सरणी में स्ट्रिंग को परिवर्तित करने की आवश्यकता नहीं है, आप chatAtविधि का उपयोग करके स्ट्रिंग से एकल वर्ण तक पहुंच सकते हैं

— user902383

और आखिरी बात, आपको अपने चरित्र को स्ट्रिंग में बदलने की आवश्यकता नहीं है और फिर इसे पार्स करें, इसके बजाय Integer.valueOf(digits[i] + "") + Integer.valueOf(digits[i + 1] + "");आप कर सकते हैं(digits[i] + digits[i+1] - 96)

— user902383

Answer 14

जावास्क्रिप्ट 133 बाइट्स

function f(n,g){for(c=r=[];g--;(n=s)&&(r[c++]=c+': '+s))for(i=s='',n+=s;n[++i];s+=n[i]-+-n[i-1]);console.log(r.slice(-5).join('\n'))}

Ungolfed:

function sums(num, guard) {
    for(count = res = [];guard--;(num = sum) && (res[count++] = count + ': ' + sum))
        for(i = sum = '',num += sum;num[++i];sum += num[i] -+- num[i-1]);
    console.log(res.slice(-5).join('\n'))
}

Comments

केवल समस्या है फ़ंक्शन का नाम आपके चर में से एक के समान है :) लेकिन तकनीक बहुत बढ़िया है।

— मैट

अच्छी बात! मैंने समारोह का नाम बदल दिया;)

— कोर 1024

Answer 15

जावा, 341 वर्ण 371 चार

 class a{public static void main(String[] a){p(3541,50);}static void p(int n,int k){Queue<String>q=new LinkedList();int c=0;while(n>9&&c<k){c++;String r="";String p=""+n;for(int i=0;i<p.length()-1;i++)r+=((p.charAt(i)+p.charAt(i+1)-96));n=Integer.parseInt(r);q.add(c+": "+n);if(q.size()>5)q.remove();}for(String s:q){System.out.println(s);}}}

प्रारूपित:

class a {
public static void main(String[] a) {
    p(3541, 50);
}

static void p(int n, int k) {
    Queue<String> q = new LinkedList();
    int c = 0;
    while (n > 9 && c < k) {
        c++;
        String r = "";
        String p = "" + n;
        for (int i = 0; i < p.length() - 1; i++)
            r += ((p.charAt(i) + p.charAt(i + 1) - 96));
        n = Integer.parseInt(r);
        q.add(c + ": " + n);
        if (q.size() > 5)
            q.remove();
    }
    for (String s : q) {
        System.out.println(s);
    }
}}

User902383 के लिए धन्यवाद मैं 30 अक्षरों द्वारा कोड को कम करने में सक्षम था, स्ट्रिंग को एक सरणी में विभाजित न करके "Integer.valueOf () के बजाय -96 का उपयोग कर

Comments

आप अभी भी कुछ पात्रों को कम कर सकते हैं,class a{public static void main(String[] a) {p(3541, 50);}static void p(int n,int k){Queue<String> q=new LinkedList();int c=0;while(n>9&&c<k){c++;String r="";String p=""+n;for(int i=0;i<p.length()-1;i++)r+=((p.charAt(i)+p.charAt(i+1)-96));n=Integer.parseInt(r);q.add(c+": "+n);if(q.size()>5)q.remove();}for(String s:q){System.out.println(s);}}}

— user902383

Answer 16

डार्ट, 602 588 बाइट्स

डार्ट शायद ऐसा करने वाली सबसे खराब भाषाओं में से एक है ... मुझे ऐसा करने के लिए एक बेहतर तरीका खोजने की आवश्यकता होगी।

वैसे भी, यहाँ मेरा प्रवेश है:

कंसोल के माध्यम से इनपुट

var steps={};void main(a){c(a[0],int.parse(a[1]));}void c(inp,m){int i=0;int n=int.parse(inp);while(++i<=m){n=addUp(n.toString());steps[i]=n;if(n<10)break;}printSteps();}int addUp(n){var ns=[];for(int i=0;i<n.length;i++){try{ns.add(n[i]+n[i+1]);}catch(e){}}return addNumbers(ns);}int addNumbers(ns){var it=ns.iterator;var s="";while(it.moveNext()){int i=0;for(var t in it.current.split('')){i+=int.parse(t);}s=s+i.toString();}return int.parse(s);}void printSteps(){int l=steps.length;for(int i=getStart(l);i<=l;i++){print("${i}:\t${steps[i]}");}}int getStart(l){int m=l-4;return m>0?m:1;}

और अनगुल्ड, थोड़ा अनइंस्टाल्ड वर्जन:

var steps = {};

void main(a)
{
    c(a[0], int.parse(a[1]));
}

void c(String input, int max)
{
    int i = 0;
    int n = int.parse(input);

    while(++i <= max)
    {
        n = addUp(n.toString());

        steps[i] = n;

        if(n < 10)
            break;
    }

    printSteps();
}

int addUp(String n)
{
    List numbers = [];

    for(int i = 0; i < n.length; i++)
    {
        try
        {
            numbers.add(n[i] + n[i + 1]);
        }
        catch(e){}
    }

    return addNumbers(numbers);
}

int addNumbers(List numbers)
{
    Iterator it = numbers.iterator;

    String s = "";

    while(it.moveNext())
    {
        int i = 0;
        for(String s in it.current.split(''))
        {
            i += int.parse(s);
        }

        s = s + i.toString();
    }

    return int.parse(s);
}

void printSteps()
{
    int l = steps.length;

    for(int i = getStart(l); i <= l; i++)
    {        
        print("${i}:\t${steps[i]}");
    } 
}

int getStart(int l)
{
    int m = l - 4;
    return m > 0 ? m : 1;
}

Answer 17

PERL 135 129/125 125/121 बाइट्स

इसमें ताल के जवाब के समान बग है

sub c{($e,$l)=@_;print join"\n",(grep/\d$/,map{$s="";{$e=~/(.)(.)/;redo if""ne($e=$2.$')and$s.=$1+$2};++$c.": ".($e=$s)}1..$l)[-5..-1]}

फ़ंक्शन के रूप में 129 बाइट संपादित करें:

sub c{($e,$l)=@_;print join$/,(grep/\d$/,map{$s="";{$e=~/(.)(.)/;redo if""ne($e=$2.$')and$s.=$1+$2}"$_: ".($e=$s)}1..$l)[-5..-1]}

एक समारोह के रूप में 125 बाइट्स:

sub c{($e,$l)=@_;print+(grep/\d$/,map{$s="";{$e=~/(.)(.)/;redo if""ne($e=$2.$')and$s.=$1+$2}"$_: ".($e=$s).$/}1..$l)[-5..-1]}

कंसोल बाइट के रूप में 125 बाइट्स (हैशबैंग के बिना):

($e,$l)=@ARGV;print join$/,(grep/\d$/,map{$s="";{$e=~/(.)(.)/;redo if""ne($e=$2.$')and$s.=$1+$2}"$_: ".($e=$s)}1..$l)[-5..-1]

कंसोल बाइट के रूप में 121 बाइट (हैशबैंग के बिना):

($e,$l)=@ARGV;print+(grep/\d$/,map{$s="";{$e=~/(.)(.)/;redo if""ne($e=$2.$')and$s.=$1+$2}"$_: ".($e=$s).$/}1..$l)[-5..-1]

विस्तारित:

sub c
{
    ($e, $l) = @_;
    print +(grep /\d$/, map {
        $s="";
        {
            $e =~ /(.)(.)/;
            redo if "" ne ($e = $2.$') and $s .= $1 + $2
        }
        "$_: ".($e = $s).$/
    } 1 .. $l)[-5 .. -1]
}

इसके साथ टेस्ट करें c(372,4);:

[blank line]
1: 109
2: 19
3: 10
4: 1

इसके साथ टेस्ट करें c(3541,50);:

6: 1411
7: 552
8: 107
9: 17
10: 8

Comments

मेरा मानना ​​है कि आप केवल अंतिम 5 चरणों को प्रिंट करने वाले हैं।

— ताल

मिल गया;)

— कोर 1024

और तुम अभी भी 3 बाइट्स मेरे आगे हो ... इसे ब्लास्ट करो! : पी

— ताल

@ ताल हम अभी भी कर रहे हैं: D

— core1024

Answer 18

C # - 269

void F(int x,int y){var o=new List<string>();var i=x+"";for(int n=1;n<y&&i.Length>1;n++){var s="";for(int z=0;z<i.Length;z++){int a=i[z]-'0';var t=a+(z+1!=i.Length?i[z+1]-'0':-a);if(t!=0)s+=t;}i=s;o.Add(n+": "+i);}foreach(var p in o.Skip(o.Count-5))Debug.WriteLine(p);}

पठनीय:

void F(int x,int y){
    var o=new List<string>();
    var i=x+"";
    for(int n=1;n<y&&i.Length>1;n++)
    {
        var s="";
        for(int z=0;z<i.Length;z++){
            int a=i[z]-'0';
            var t=a+(z+1!=i.Length?i[z+1]-'0':-a);
            if(t!=0)
                s+=t;
        }
        i=s;
        o.Add(n+": "+i);
    }
    //Output
    foreach(var p in o.Skip(o.Count-5))
        Debug.WriteLine(p);
}

उपयोग:

F(3541, 50)

आउटपुट:

6: 1411
7: 552
8: 107
9: 17
10: 8

Answer 19

कोबरा - 363

बल्कि निराशाजनक परिणाम ... लेकिन हे, मैंने अभी भी जावा को हराया।

यह व्यावहारिक परीक्षण मामलों के लिए पूर्णांक ओवरफ्लो के लिए प्रतिरक्षा होना चाहिए ।

class P
    cue init(a,b)
        base.init
        l=[]
        c=.p(a.toString)
        for x in b
            l.add("")
            y=l.count
            for i in c.count-1,l[y-1]+=(c[i]+c[i+1]).toString
            if l.last.length<2,break
            c=.p(l.last)
        z=if(y>5,y-5,0)
        for x in l[z:y],print"[z+=1]:",x
    def p(n) as List<of int>
        c=List<of int>()
        for i in n,c.add(int.parse(i.toString))
        return c

Answer 20

पायथन 2.7, 174 173 158 अक्षर

कार्य करने के लिए बहुत सारे स्ट्रिंग्स का उपयोग करना।

x,n=raw_input().split()
o,i=[],0
while int(n)>i<o>9<x:x="".join(`sum(map(int,x[j:j+2]))`for j in range(len(x)-1));i+=1;o+=[`i`+": "+x]
print"\n".join(o[-5:])

पायथन 2.7, 155 वर्ण

एक फ़ंक्शन को परिभाषित करने वाला संस्करण

def a(x,n):
 o,i,x=[],0,`x`
 while n>i<o>9<int(x):x="".join(`sum(map(int,x[j:j+2]))`for j in range(len(x)-1));i+=1;o+=[`i`+": "+x]
 print"\n".join(o[-5:])

थोड़ा ungolfed संस्करण:

x,n=map(int,raw_input().split())
o,i=[],1
while i<=n and x>9:
  x=int("".join(`sum(map(int,`x`[j:j+2]))` for j in range(len(`x`)-1)))
  o.append("%d: %d"%(i,x))
  i+=1
print "\n".join(o[-5:])

Answer 21

हास्केल, 154

s=show
z=zipWith
m#n=concat.z(\a b->s a++": "++b++"\n")[1..].(\x->drop(length x-n)x).takeWhile(/="").iterate((\x->z(+)x(tail x)>>=s).map(\x->read[x]))$s m

उदाहरण का उपयोग:

λ> 3541#5
"1: 1411\n2: 552\n3: 107\n4: 17\n5: 8\n"

इसे और अधिक पठनीय बनाने के लिए, उपयोग करें putStr:

λ> putStr $ 3541#5
1: 1411
2: 552
3: 107
4: 17
5: 8

Comments

आपको गणना से केवल अंतिम 5 चरणों को सूचीबद्ध करना होगा। कोशिश करें putStr $ 3541#50और इसकी तुलना ओपी के उदाहरण से करें। वरना मुझे खुशी है कि यहां एक हास्केल लड़का है।

— Core1024

@ core1024 यह करता है! हालांकि मैंने उन्हें गलत लेबल दिया था, आप सही हैं। मैं कल उसे ठीक कर दूंगा।

— फ्लोक्स

Answer 22

ग्रूवी - 191 182 वर्ण

थॉमस रॉपिंग के समाधान के आधार पर , ग्रूवी को 2.2.1 पर पोर्ट किया गया:

f={it as int};n=args[0];s=f args[1];q=[];x=0;while(f(n)>9&&x<s){x++;d=n.split("");n="";for(i in 1..d.length-2)n+=f(d[i])+f(d[i+1]);q << "$x: $n"};q[-1..5].reverse().each{println it}

निष्पादन और उत्पादन:

bash$ groovy Numbers.groovy 3541 50 
6: 1411
7: 552
8: 107
9: 17
10: 8

Ungolfed:

f = {it as int}
n = args[0]
s = f args[1]

queue = []
stepCounter = 0

while (f(n) > 9 && stepCounter < s) {
    stepCounter++
    digits=n.split("")
    n=""
    for(i in 1..digits.length-2) {
        n += f(digits[i]) + f(digits[i+1])
    }
    queue << "$stepCounter: $n"
}

queue[-1..5].reverse().each{ println it }

Answer 23

** सी 186 179 174 **

f(int a,int z){for(int c,d,i,j=0,m[5];m[j++%5]=a,j<=z&&a/10;a=c)for(c=0,i=1;a/10;d=a%10+(a/=10)%10,c+=d*i,i*=d<10?10:100);for(i=j<5?0:j-5;i<j;printf("%d: %d\n",i,m[i++%5]));}

थोड़ा कम गोल्फ (मिनी गोल्फ)?

f(int a, int z)
{


for(int c,d,i,j=0,m[5];m[j++%5]=a,j<=z&&a/10;a=c)
    for(c=0,i=1;a/10;d=a%10+(a/=10)%10,c+=d*i,i*=d<10?10:100);

    for(i=j<5?0:j-5;i<j;printf("%d: %d\n",i,m[i++%5]));

}

बस पर्याप्त रूप से पाँच परिणामों को संग्रहीत करने के लिए पर्याप्त मेमोरी आवंटित करें। बाहरी लूप तब तक चलता रहता है जब तक हम सीमा से नहीं टकराते या एक अंक तक नहीं पहुंच जाते। आंतरिक लूप संख्या के अंतिम अंक को संख्या के 1/10 के अंतिम अंक में जोड़ता है और इसे जोड़ता है, परिणाम की 10 की प्रासंगिक शक्ति से गुणा करता है। संख्या को आप पहले 10 से विभाजित करें और कुल प्राप्त करने के लिए दोहराएं। फिर अंतिम पांच परिणामों का प्रिंट आउट लें।

अगली चुनौती यह देखना है कि क्या मैं गोल्फ में कुछ स्क्रिप्टिंग भाषाओं को हरा सकता हूं।

संपादित करें: अब चेतावनी के साथ संकलित करता है, लेकिन "शून्य" घोषणा को हटाकर पांच पात्रों का मुंडन किया जाता है

Comments

गोल्फ युक्तियाँ: f (int a, int z) -> f (a, z) और t = 10 बचत 2 अधिक वर्णों का उपयोग कर सकते हैं। लेकिन एक ही अभिव्यक्ति में a / a = 10 का उपयोग अपरिभाषित है

— edc65

Answer 24

सी # - 309 330 320 306 बाइट्स

गोल्फ संस्करण:

private static void F(int aN,int aM){var s=new List<string>();var n=aN.ToString();for(int i=1;i<=aM;i++){int z=n.Length;if(z==1){break;}var a=n;n="";for(int j=0;j<z-1;j++){int r=a[j]-'0'+a[j + 1]-'0';n=n+r;}s.Add(i+": "+n);}int l=s.Count;int p=5;if(l<5){p=l;}for(int k=l-p;k<l;k++){Debug.WriteLine(s[k]);}}

उपयोग: एफ (3541,50);

पठनीयता के लिए अनगुल्ड संस्करण:

private static void AppendNumbers(int aNum, int aMaxSteps)
    {
        var results = new List<string>();
        var numString = aNum.ToString();
        for (int i = 1; i <= aMaxSteps; i++)
        {
            int stringLength = numString.Length;
            if (stringLength == 1)
            {
                break;
            }
            var a = numString;
            numString = "";
            for (int j = 0; j < stringLength-1; j++)
            {
                int additionResult = a[j]-'0' + (a[j + 1]-'0');
                numString = numString + additionResult;
            }
            results.Add(i+": "+ numString);
        }
        int numberOfResults = results.Count;
        int p = 5;
        if (numberOfResults < 5)
        {
            p = numberOfResults;
        }
        for (int k = numberOfResults - p; k < numberOfResults; k++)
        {
            Debug.WriteLine(results[k]);
        }
    }

सुधार के सुझावों का हमेशा स्वागत है! ;)

संपादित करें: String.Empty को निकाला गया और 10 बाइट्स को बचाने के लिए इसे "" से बदल दिया गया।

संपादित 2: तार के साथ टिप के लिए मलिक के लिए धन्यवाद!

Comments

आप की जरूरत नहीं है .ToCharArray()। एक तार = चार सरणी

— jzm

ओह, और एक और चीज जो आप कर सकते हैं, वह है .ToString(), करना+""

— jzm