Додана гра чисел

Напишіть функцію / програму, яка приймає два цілих параметри цілих параметрів або цілих змінних , початкове число та макс. Кількість ітерацій. Код повинен виконувати наступний приклад гри для побудови нового числа та повторювати, поки число не залишиться одноцифровою. напр.

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 неділі о 20:00 (UTC + 8) для подань, які будуть розглянуті для прийнятої відповіді, і тоді найкоротший з будь-якої мови стане переможцем.

Редагувати:

Вітаємо Говарда, що виграв із 48 відповідями GolfScript .

Особлива згадка 2 - е місця Марини з 66 APL в відповіді .

Моя особиста улюблена (упереджена до JavaScript) була відповіддю core1024 .

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

APL (66)

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

Лівий аргумент - це максимальний кількість ітерацій, а правий - початковий номер.

Пояснення:

• ∆←⍺{... }⍕⍵: передайте лівий аргумент як число, а правий аргумент як рядок функції, яка обчислює список чисел, і зберігайте його у ∆:
  • (1<⍴⍵)∧⍺>0:: якщо кількість цифр більше 1, а кількість ітерацій залишилось більше 0:
    • ⍎¨⍵: оцінюйте кожну цифру
    • 2+/: підсумовуйте кожну пару
    • ⍕¨: форматувати кожне число у вигляді рядка
    • ∆←,/: об'єднайте рядки і зберігайте ∆
    • ∆,(⍺-1)∇⊃∆: return ∆, з подальшим результатом застосування цієї функції до ∆з меншою дозволеною ітерацією
  • ⋄⍬: якщо ні, поверніть порожній список
• ∆,⍪⍳⍴∆: з'єднайте кожен елемент ∆з його індексом у∆
• {... }/: для кожної пари:
  • (⍕⍵),': ',⍺: повертає рядок з індексом, за яким :слідує число, а потім число
• ↑¯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  

Математика, 172 символи

Це занадто довго, завдяки іменам функцій Mathematica та потворній обробці рядків (фактична "гра" - це лише 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
    ]

Рубін, 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

J - 96 92 char

Я спершу вирішив це, якщо припустити, що всі ігри закінчуються, і це повернулося, щоб вкусити мене в дупу під час тестування. Лівий аргумент - це кількість кроків, правий аргумент - вихідна позиція, яка може бути задана як число або рядок.

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

Це трохи надто гольф і перекручено, щоб дегольф задовольняв, тому я скажу так:

• (<@>:@[(' '-.~[:,@":2+/\"."0@]^:)":)Ця частина запускає гру за вказану кількість кроків. 2+/\відповідає за додавання кожної пари цифр і <@>:@[в тандемі з ^:елементами управління, що фіксують проміжні кроки гри.
• (#\(,': '&,)&":"0,)@}.@({.~,i.0:)@:".Ця частина формулює всі результати як step: result. ({.~,i.0:)переконує, що ми не робимо занадто багато кроків, чи #\є крок кроків, а (,': '&,)&":"0біт додає двокрапку та пробіл.
• (-@(<.5<.#){.])Ця частина вирізає відповідні п’ять і менше кроків із повного списку. <.означає "мінімум".

Це працює, але якщо ви почнете з достатньо великої кількості, результати гри швидко починають збільшуватися в розмірах, завдяки чому J переходить від цілих чисел до неточних подвійних. Ось кілька прикладів:

   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

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

Безумовно

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

Перл, 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]

Javascript, 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 : Перероблені рекурсивні дзвінки.

Скрипка

Bash + coreutils, 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
$ 

JavaScript (чернетка 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"

Javascript, 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])}

Перл, 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]

Безголівки:

<> =~ / /;
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 кроків.

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

JavaScript 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'))}

Безголівки:

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

Ява, 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 символів, не розбиваючи String на масив, використовуючи -96 замість "Integer.valueOf ()

Дарт, 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;
}

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

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

Кобра - 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

Python 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:])

Python 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:])

Хаскелл, 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

Groovy - 191 182 символів

На основі рішення Томаса Рюпінга , перенесеного на Groovy 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

Безголівки:

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 }

** C 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 і повторіть, щоб отримати загальну суму. Потім роздрукуйте до останніх п’яти результатів.

Наступне завдання полягає в тому, щоб побачити, чи можу я достатньо поголитися, щоб перемогти деякі мови сценаріїв у гольфі.

Редагувати: тепер компілюється з попередженням, але п’ять символів поголені, видаляючи декларацію "недійсні"

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

Використання: F (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]);
        }
    }

Пропозиції щодо вдосконалення завжди вітаються! ;)

Редагувати: Видалений рядок. Очистіть і замініть його на "", щоб зберегти 10 байт.

Редагувати 2: Дякую маліку за підказку зі струнами!