সংযুক্ত নম্বর গেম

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সমাপ্ত বা সমাপ্ত পদক্ষেপের শেষ 5 টি ধাপ সহ আউটপুট ( ) এর মতো উপস্থিত হওয়া উচিত :

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 টিরও কম পদক্ষেপ থাকে তবে কেবল নেওয়া পদক্ষেপগুলি মুদ্রণ করুন।

কেবল অন্তর্নির্মিত লিবস ব্যবহার করুন, প্যারামিটারগুলি যে কোনও জায়গা থেকে হতে পারে (আপনার পছন্দের ভাষার পক্ষে যা সহজ)। সর্বাধিক পূর্ণসংখ্যার আকারের সীমা নেই এবং যদি অতিরিক্ত প্রবাহ থাকে তবে এটি ক্রাশ হতে দিন।

ধাঁধা দৃষ্টিকোণ থেকে এটি খুব কঠিন নয়, আমি গ্রহণের উত্তরের জন্য বিবেচনার জন্য সাবমিশনের জন্য রবিবার 25, 8 পিএম (ইউটিসি + 8) পর্যন্ত দেব, যে মুহুর্তে কোনও ভাষার সংক্ষিপ্ততম বিজয়ী হবে।

সম্পাদনা করুন:

হাওয়ার্ডকে অভিনন্দন, একটি 48 গল্ফস্ক্রিপ্ট উত্তরের সাথে জিতেছে ।

AP 66 এপিএল উত্তরের সাথে ২ য় স্থানের মেরিনাসের বিষয়ে বিশেষ উল্লেখ ।

আমার ব্যক্তিগত প্রিয় (জাভাস্ক্রিপ্টের প্রতি পক্ষপাতদুষ্ট হওয়া) কোর 1024 এর উত্তর ছিল ।

Comments

আমি বুঝতে পারি না, func(3541, 5)5 টি ধাপ বা 10 প্রিন্ট করার কথা?

— তাল

5 পদক্ষেপ। এটি 5 টি পুনরাবৃত্তিকে আঘাত করার সাথে সাথে থামতে হবে, আর পুনরাবৃত্তি করবে না এবং শেষ 5 টি পদক্ষেপ মুদ্রণ করবে। সেই নির্দিষ্ট ইনপুটটির জন্য সম্পূর্ণ গণনা প্রক্রিয়াটি দেখানোর জন্য আমি কেবলমাত্র পদক্ষেপের পুরো সেটটি অন্তর্ভুক্ত করেছি।

— ম্যাট

Answer 1

গল্ফস্ক্রিপ্ট, 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।

— অ্যালগরিদমশর্ক

@ অ্যালগরিদমশর্ক এটি এখন করে (এটি :প্রথমটির সাথে অতিরিক্ত লাইন দিয়েছে )

— মেরিনাস

Answer 3

গণিত, 172 টি অক্ষর

এটি ম্যাথমেটিকার ফাংশন নাম এবং কুরুচিপূর্ণ স্ট্রিং হ্যান্ডলিং (প্রকৃত "গেম" those চরিত্রগুলির মধ্যে কেবল 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

আমি নতুন টিংস শিখেছি। অসাধারণ!

— কোর 1024

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 : পুনরাবৃত্তি পুনরাবৃত্তি কলিং calling

বেহালা

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 ধন্যবাদ :) আমি আপনাকে একটি টিপও দিতে যাচ্ছিলাম, তবে আপনি ইতিমধ্যে "দীর্ঘ" অংশ ছাড়াই দীর্ঘ থেকে মুক্তি পেয়েছেন

— তাল

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 ব্যবহার করে পুনরাবৃত্তি বন্ধ করতে যুক্তিও পরিবর্তন করেছে। দৈর্ঘ্য == 1 (কেবল এই থ্রেডে দেখা গেছে ... আমাকে আগে আঘাত করেনি)।

— ব্যবহারকারী 12345

আপনি আপনার প্রধান পদ্ধতিতে যুক্তির নামটির দৈর্ঘ্য হ্রাস করতে পারবেন, এটি আপনাকে অতিরিক্ত 3 টি চ্যাটার দেবে

— ব্যবহারকারী 902383

আপনার স্ট্রিংকে অক্ষরের অ্যারে রূপান্তর করতে হবে না, আপনি 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);
    }
}}

ব্যবহারকারী 902383 এর জন্য ধন্যবাদ আমি "পূর্ণসংখ্যা.ভালিউঅফ () এর পরিবর্তে স্ট্রিংকে একটি অ্যারে -96 ব্যবহার করে আরে বিভক্ত না করে 30 অক্ষরে কোডটি কমিয়ে আনতে সক্ষম হয়েছি

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

— ব্যবহারকারী 902383

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

এবং অবহেলিত, সামান্য unminified সংস্করণ:

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

পার্ল 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 বাইট এগিয়ে ... এটি ব্লাস্ট! : P

— তাল

@ টাল আমরা এখনও

— রয়েছি

Answer 18

সি # - 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

পাইথন ২.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:])

কিছুটা অবারিত সংস্করণ:

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এবং এটি অপির উদাহরণের সাথে তুলনা করুন । অন্যথায় আমি খুশী এখানে হাস্কেল লোক আছে।

— কোর 1024

@ কোর 1024 এটি করে! যদিও আমি এগুলি ভুল হিসাবে চিহ্নিত করেছি, আপনি ঠিক বলেছেন। আমি আগামীকাল ঠিক করব।

— ফ্লোন্ক

Answer 22

গ্রোভি - 191 182 অক্ষর

গ্রোভির ২.২.১ এ পোর্ট করা থমাস রপিংয়ের সমাধানের ভিত্তিতে :

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 ব্যবহার

— অপরিজ্ঞাত

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

উন্নতির জন্য পরামর্শ সর্বদা স্বাগত! ;)

সম্পাদনা করুন: স্ট্রিং সরানো হয়েছে mpএফটি এবং এটি 10 ​​"বাইট সংরক্ষণ করতে" "দিয়ে প্রতিস্থাপিত হয়েছে।

সম্পাদনা 2: স্ট্রিং সহ টিপ্পের জন্য মালিককে ধন্যবাদ!

Comments

আপনার যা দরকার তা আত .ToCharArray()। একটি স্ট্রিং = চর অ্যারে

— jzm

ওহ, এবং অন্য জিনিস আপনি কি করতে পারেন হয়, পরিবর্তে .ToString(), কি+""

— jzm