Игра с добавленными номерами

Напишите функцию / программу, которая принимает 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-го воскресенья 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  

Mathematica, 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 знака

Сначала я решил это, предполагая, что все игры прекратились, и это вернулось, чтобы укусить меня за задницу во время тестирования. Левый аргумент - это количество шагов, правый аргумент - это начальная позиция, которая может быть задана в виде числа или строки.

([(-@(<.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])}

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

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

Perl 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 шагов.

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

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

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

Dart, 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]

Expanded:

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

Довольно удручающий результат ... но, эй, я все же победил Java.

Он должен быть защищен от целочисленных переполнений для практических тестовых случаев.

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

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 }

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

Следующая задача - посмотреть, смогу ли я побриться достаточно, чтобы победить некоторые языки сценариев в гольфе.

Редактировать: теперь компилируется с предупреждением, но пять символов сбриваются, удаляя объявление "void"

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

Предложения по улучшению всегда приветствуются! ;)

Редактировать: Удалено String.Empty и заменено на "", чтобы сохранить 10 байт.

Редактировать 2: Спасибо Малику за подсказку со строками!