Dołączona gra liczb

Napisz funkcję / program, który pobiera 2 parametry całkowite parametry całkowite lub zmienne całkowite , numer początkowy i maksymalną liczbę iteracji. Kod powinien wykonać następujący przykład gry, aby skonstruować nowy numer i powtarzać, aż liczba pozostanie pojedynczą cyfrą. na przykład.

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

Zasadniczo, biorąc każdą indywidualną cyfrę i dodając ją do sąsiada, a następnie dołączając wynik następnego dodawania.

Maksymalna liczba iteracji ma na celu ochronę nieskończonych pętli, a gdy maksimum zostanie osiągnięte, kod powinien zrzucić ostatnie 5 kroków liczbowych. Ten sam wynik powinien wystąpić po zakończeniu osiągania jednej cyfry. Jeśli wystąpiło mniej niż 5 kroków, wypisz tylko prawidłowe liczby.

Dane wyjściowe powinny wyglądać jak ( Step: Number), w tym ostatnie 5 kroków zakończonych lub zakończonych kroków:

func(3541, 50) utworzy ten dokładny format wyjściowy:

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

func(3541, 5) wyprodukowałby:

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

Całe obliczenie to:

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

Jeśli jest mniej niż 5 kroków, po prostu wydrukuj te kroki.

Używaj tylko wbudowanych bibliotek, parametry mogą pochodzić z dowolnego miejsca (co jest najłatwiejsze dla wybranego języka). Brak limitu maksymalnego rozmiaru liczby całkowitej, a jeśli występują przepełnienia, pozwól mu się zawiesić.

Biorąc pod uwagę, że nie jest to zbyt trudne z logicznego punktu widzenia, dam do niedzieli 25-tej, 20:00 (UTC + 8), aby wnioski zostały rozpatrzone pod kątem przyjętej odpowiedzi, w którym to momencie zwycięzcą będzie którykolwiek z najkrótszych języków.

EDYTOWAĆ:

Gratulacje dla Howarda, wygrywając z 48 GolfScript odpowiedź .

Wyróżnienie 2 miejsce marinus z 66 APL odpowiedź .

Moim osobistym ulubionym (nastawionym na JavaScript) była odpowiedź core1024 .

GolfScript, 48 46 znaków

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

Dziękuje Peterowi Taylorowi za ulepszenie dwóch postaci.

Oczekuje obu liczb na stosie. Wypróbuj online .

Przykłady:

> 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+/⍎¨⍵⋄⍬}⍕⍵}

Lewy argument to maksymalna liczba iteracji, a prawy argument to liczba początkowa.

Wyjaśnienie:

• ∆←⍺{... }⍕⍵: przekaż lewy argument jako liczbę, a prawy argument jako ciąg do funkcji obliczającej listę liczb i zapisz ją w ∆:
  • (1<⍴⍵)∧⍺>0:: jeśli liczba cyfr jest większa niż 1, a liczba pozostałych iteracji jest większa niż 0:
    • ⍎¨⍵: oceń każdą cyfrę
    • 2+/: zsumuj każdą parę
    • ⍕¨: sformatuj każdą liczbę jako ciąg
    • ∆←,/: konkatenuj ciągi i przechowuj w ∆
    • ∆,(⍺-1)∇⊃∆: return ∆, a następnie wynik zastosowania tej funkcji ∆z dozwoloną jedną iteracją mniej
  • ⋄⍬: jeśli nie, zwróć pustą listę
• ∆,⍪⍳⍴∆: sparuj każdy element ∆z jego indeksem w∆
• {... }/: dla każdej pary:
  • (⍕⍵),': ',⍺: zwraca ciąg z indeksem, po którym :następuje, a następnie liczba
• ↑¯5↑: zamień listę ciągów w macierz, aby wyświetlały się w osobnych wierszach, i weź 5 ostatnich elementów

Test:

      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 znaki

Jest to o wiele za długo, dzięki nazwom funkcji Mathematica i brzydkiej obsłudze napisów (rzeczywista „gra” to tylko 76 takich znaków), ale i tak:

""<>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]

Oczekuje liczby wejściowej w zmiennej ni maksymalnej liczby iteracji wm .

Mniej golfa:

"" <> 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
    ]

Ruby, 106 znaków

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}

Nie mam 100% jasności co do reguł wprowadzania, ale jeśli dam radę n jako ciąg, mogę zapisać 5 znaków, a jeśli mogę użyć predefiniowanych zmiennych i napisać program zamiast funkcji, mogę zapisać kolejne 9.

Tworzy funkcję, fktórą można wywołać w następujący sposób:

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

Najpierw rozwiązałem to, zakładając, że wszystkie gry się zakończyły, a to wróciło, by ugryźć mnie w tyłek podczas testów. Lewy argument to liczba kroków, prawy argument to pozycja początkowa, którą można podać jako liczbę lub ciąg znaków.

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

To jest trochę zbyt golfowe i zwojowe, by można było go z powodzeniem degolfować, więc powiem tak:

• (<@>:@[(' '-.~[:,@":2+/\"."0@]^:)":)Ta część uruchamia grę przez określoną liczbę kroków. 2+/\odpowiada za dodanie każdej pary cyfr oraz <@>:@[w połączeniu z ^:kontrolkami przechwytującymi pośrednie etapy gry.
• (#\(,': '&,)&":"0,)@}.@({.~,i.0:)@:".Ta część formatuje wszystkie wyniki jako step: result. ({.~,i.0:)upewnia się, że nie wykonujemy zbyt wielu kroków, #\to liczby kroków, a (,': '&,)&":"0bit dodaje dwukropek i spację.
• (-@(<.5<.#){.])Ta część wycina odpowiednie pięć lub mniej kroków z pełnej listy. <.oznacza „minimum”.

Działa, ale jeśli zaczniesz od wystarczająco dużej liczby, wyniki gry szybko zaczną rosnąć, co powoduje, że J zmienia się z liczb całkowitych na nieprecyzyjne podwajanie. Oto kilka przykładów:

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

Nie golfił

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

Z nowymi liniami dla czytelności:

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

+ Edycja: Nie ma wymówki, aby nie używać -nprzełącznika linii poleceń, a następnie wynik wynosi 82 = 81 + 1 :

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

Możliwe, że przepełnienie liczb całkowitych jest w porządku, wynosi 81 = 80 + 1

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

JavaScript, 247 278 288 307 znaków

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

Sformatowany

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

Edycja 1 : Usunięto trójkę

Edycja 2 : Odwrócona logika „pomijania” indeksu 0

Edycja 3 : Przerobiono wywołanie rekurencyjne.

Skrzypce

Bash + coreutils, 115 bajtów

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

Wynik:

$ ./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 (wersja robocza ECMAScript 6) - 134 znaków

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

Przykłady:

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 bajty

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 129 bajtów

<>=~/ /;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]

Nie golfowany:

<> =~ / /;
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]

Mam nadzieję, że to w porządku, że drukuje kilka dodatkowych pustych linii, jeśli całość zajmuje mniej niż 5 kroków.

Java      524   405 365 znaków [414 bajtów]

Wersja golfowa: 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);}}

Wersja do odczytu:

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 bajty

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

Nie golfowany:

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

Java, 341 znaków 371 znaków

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

Sformatowany:

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

Dzięki user902383 mogłem zredukować kod o 30 znaków, nie dzieląc łańcucha na tablicę przy użyciu -96 zamiast „Integer.valueOf ()

Dart, 602 588 bajtów

Dart jest prawdopodobnie jednym z najgorszych języków, w którym można to zrobić ... Muszę znaleźć lepszy sposób, aby to zrobić.

Tak czy inaczej, oto mój wpis:

Wejście przez konsolę

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

I nieprzygotowana, nieco nieupoważniona wersja:

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 bajtów

Ma ten sam błąd co odpowiedź Tal

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

Edytuj 129 bajtów jako funkcję:

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 bajtów jako funkcja:

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 bajtów jako skrypt konsoli (bez skrótu):

($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 bajtów jako skrypt konsoli (bez skrótu):

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

Rozszerzony:

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

Testuj z c(372,4);:

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

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

Czytelny:

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

Stosowanie:

F(3541, 50)

Wynik:

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

Kobra - 363

Dość przygnębiający wynik ... ale hej, wciąż pokonuję Javę.

W praktycznych przypadkach testowych powinien być odporny na przepełnienia liczb całkowitych.

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 znaków

Używanie wielu ciągów do wykonania zadania.

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 znaków

Wersja definiująca funkcję

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

Wersja lekko nie golfowa:

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

Haskell, 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

przykładowe użycie:

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

Aby uczynić go bardziej czytelnym, użyj putStr:

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

Groovy - 191 182 znaków

Na podstawie rozwiązania Thomasa Rüpinga przeniesionego do 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}

Wykonanie i wyjście:

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

Nie golfowany:

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

Nieco mniej golfa (mini-golfa?)

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

}

Wystarczy przydzielić wystarczającą ilość pamięci, aby cyklicznie przechowywać pięć wyników. Pętla zewnętrzna trwa, dopóki nie osiągniemy limitu lub nie osiągniemy jednej cyfry. Pętla wewnętrzna dodaje ostatnią cyfrę liczby do ostatniej cyfry 1/10 liczby i dodaje ją, pomnożoną przez odpowiednią moc 10 do wyniku. Podziel pierwszą liczbę przez 10 i powtórz, aby uzyskać sumę. Następnie wydrukuj do pięciu ostatnich wyników.

Kolejnym wyzwaniem jest sprawdzenie, czy uda mi się wygolić na tyle, by pokonać golfa w językach skryptowych.

Edycja: Teraz kompiluje się z ostrzeżeniem, ale pięć znaków zostało zgolonych przez usunięcie deklaracji „void”

C # - 309 330 320 306 bajtów

Wersja do gry w golfa:

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

Zastosowanie: F (3541,50);

Wersja bez golfa dla czytelności:

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

Sugestie dotyczące ulepszeń są zawsze mile widziane! ;)

Edycja: Usunięto String.Empty i zastąpiono go „”, aby zapisać 10 bajtów.

Edycja 2: Dzięki Malik za napiwek ze sznurkami!