Spiel mit angehängten Zahlen

Schreiben Sie eine Funktion / ein Programm, das 2 ganzzahlige Parameter, ganzzahlige Parameter oder ganzzahlige Variablen , eine Startnummer und eine maximale Anzahl von Iterationen akzeptiert. Der Code sollte das folgende Spielbeispiel ausführen, um eine neue Nummer zu konstruieren, und wiederholen, bis die Nummer eine einzelne Ziffer übrig hat. z.B.

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

Im Grunde genommen wird jede einzelne Ziffer genommen und dem Nachbarn hinzugefügt, und dann wird auch das Ergebnis der nächsten Addition angehängt.

Die maximale Iterationszahl dient zum Schutz vor Endlosschleifen. Wenn die maximale Anzahl erreicht ist, sollte der Code die letzten 5 Ziffernschritte ausgeben. Die gleiche Ausgabe sollte beim Beenden durch Erreichen einer einzelnen Ziffer erfolgen. Wenn weniger als 5 Schritte aufgetreten sind, geben Sie nur die gültigen Zahlen aus.

Die Ausgabe sollte wie folgt aussehen ( Step: Number) und die letzten 5 Schritte der abgeschlossenen oder beendeten Schritte enthalten:

func(3541, 50) würde genau dieses Ausgabeformat erzeugen:

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

func(3541, 5) würde produzieren:

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

Die gesamte Berechnung ist:

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

Wenn weniger als 5 Schritte vorhanden sind, drucken Sie einfach die ausgeführten Schritte aus.

Verwenden Sie nur eingebaute Bibliotheken. Die Parameter können von jedem Ort aus eingegeben werden (was für Ihre Sprache am einfachsten ist). Keine Begrenzung für die maximale Ganzzahlgröße, und wenn es Überläufe gibt, lassen Sie es abstürzen.

Da dies aus Puzzle-Sicht nicht allzu schwierig ist, gebe ich bis Sonntag, den 25., 20.00 Uhr (UTC + 8) Zeit, um Einsendungen für die akzeptierte Antwort zu berücksichtigen. An diesem Punkt wird die kürzeste Sprache der Gewinner sein.

BEARBEITEN:

Herzlichen Glückwunsch an Howard, der mit einer Antwort von 48 GolfScript gewonnen hat .

Besonders zu erwähnen ist der 2. Platz Marinus mit einer 66 APL Antwort .

Mein persönlicher Favorit (voreingenommen gegenüber JavaScript) war die Antwort von core1024 .

GolfScript, 48 46 Zeichen

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

Vielen Dank an Peter Taylor für eine Verbesserung um zwei Charaktere.

Erwartet beide Zahlen auf dem Stapel. Versuchen Sie es online .

Beispiele:

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

Das linke Argument ist die maximale Iterationszahl und das rechte Argument ist die Startnummer.

Erläuterung:

• ∆←⍺{... }⍕⍵: Übergebe das linke Argument als Zahl und das rechte Argument als Zeichenfolge an die Funktion, die die Liste der Zahlen berechnet, und speichere sie in ∆:
  • (1<⍴⍵)∧⍺>0:: Wenn die Anzahl der Stellen mehr als 1 beträgt und die Anzahl der verbleibenden Iterationen mehr als 0:
    • ⍎¨⍵: bewerte jede Ziffer
    • 2+/: summiere jedes Paar
    • ⍕¨: formatiere jede Zahl als String
    • ∆←,/: verketten die Zeichenfolgen und speichern in ∆
    • ∆,(⍺-1)∇⊃∆: return ∆, gefolgt vom Ergebnis der Anwendung dieser Funktion ∆mit einer Iteration weniger
  • ⋄⍬: Wenn nicht, geben Sie die leere Liste zurück
• ∆,⍪⍳⍴∆: Paar jedes Element von ∆mit seinem Index in∆
• {... }/: für jedes Paar:
  • (⍕⍵),': ',⍺: gibt einen String mit dem Index :gefolgt von der Nummer zurück
• ↑¯5↑: Verwandle die Liste der Zeichenfolgen in eine Matrix, damit sie in separaten Zeilen angezeigt werden, und nimm die letzten 5 Elemente

Prüfung:

      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 Zeichen

Das ist viel zu lang, dank der Funktionsnamen von Mathematica und der hässlichen Handhabung von Zeichenfolgen (das eigentliche "Spiel" besteht nur aus 76 dieser Zeichen), aber hier ist es trotzdem:

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

Es erwartet die Eingangsnummer in Variable nund die maximale Anzahl von Iterationen in m.

Mit weniger Golf:

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

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}

Ich bin nicht 100% klar in den Eingaberegeln, aber wenn ich neinen String nehmen kann, kann ich 5 Zeichen speichern, und wenn ich vordefinierte Variablen verwenden und ein Programm anstelle einer Funktion schreiben kann, kann ich weitere 9 speichern.

Erzeugt eine Funktion, fdie wie folgt aufgerufen werden kann:

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

Ich hatte dies zunächst gelöst, vorausgesetzt, dass alle Spiele beendet waren, und dies kam zurück, um mich während des Testens in den Arsch zu beißen. Das linke Argument ist die Anzahl der Schritte, das rechte Argument ist die Startposition, die als Zahl oder als Zeichenfolge angegeben werden kann.

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

Dies ist ein bisschen zu golfen und gewunden, um zufriedenstellend zu entgolfen, also sage ich Folgendes:

• (<@>:@[(' '-.~[:,@":2+/\"."0@]^:)":)Dieser Teil führt das Spiel für die angegebene Anzahl von Schritten aus. 2+/\ist verantwortlich für das Hinzufügen jedes Ziffernpaares und <@>:@[zusammen mit den ^:Steuerelementen, die die Zwischenschritte des Spiels erfassen.
• (#\(,': '&,)&":"0,)@}.@({.~,i.0:)@:".Dieser Teil formatiert alle Ergebnisse als step: result. ({.~,i.0:)stellt sicher, dass wir nicht zu viele Schritte machen, #\gibt die Schrittnummern an und das (,': '&,)&":"0Bit fügt den Doppelpunkt und das Leerzeichen hinzu.
• (-@(<.5<.#){.])Dieser Teil schneidet die relevanten fünf oder weniger Schritte aus der vollständigen Liste aus. <.bedeutet "Minimum von".

Es funktioniert, aber wenn Sie mit einer ausreichend großen Zahl beginnen, werden die Ergebnisse des Spiels schnell größer, was dazu führt, dass J von Ganzzahlen zu ungenauen Doppelwerten wechselt. Hier sind einige Beispiele:

   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

Mit Zeilenumbrüchen zur besseren Lesbarkeit:

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

+ Bearbeiten: Keine Entschuldigung dafür, dass die -nBefehlszeilenoption nicht verwendet wurde , und dann lautet die Punktzahl 82 = 81 + 1 :

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

Und wenn ein möglicher Integer-Überlauf in Ordnung ist, ist dies 81 = 80 + 1

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

Javascript, 247 278 288 307 Zeichen

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

Formatiert

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

Bearbeiten 1 : Ternär entfernt

Edit 2 : Umgedrehte Logik zum "Überspringen" des Index 0

Edit 3 : Rekursiver Aufruf überarbeitet.

Geige

Bash + Coreutils, 115 Bytes

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

Ausgabe:

$ ./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 Zeichen

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

Beispiele:

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 Bytes

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 Bytes

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

Ich hoffe, es ist in Ordnung, dass es einige zusätzliche leere Zeilen druckt, wenn das Ganze weniger als 5 Schritte dauert.

Java      524   405 365 Zeichen [414 Byte]

Golf Version: 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);}}

Lesbare Version:

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 Bytes

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

Java, 341 Zeichen 371 Zeichen

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

Formatiert:

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

Dank user902383 konnte ich den Code um 30 Zeichen reduzieren, indem ich den String nicht in ein Array aufteilte und -96 anstelle von "Integer.valueOf ()" verwendete.

Dart, 602 588 Bytes

Dart ist wahrscheinlich eine der schlechtesten Sprachen, um dies zu tun ... Ich muss einen besseren Weg finden, um dies zu tun.

Sowieso ist hier mein Eintrag:

Eingabe über Konsole

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

Und die ungolfed, leicht unminimierte Version:

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 Bytes

Es hat den gleichen Fehler wie Tals Antwort

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

Bearbeiten Sie 129 Bytes als Funktion:

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 Bytes als Funktion:

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 Bytes als Konsolenskript (ohne den Hashbang):

($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 Bytes als Konsolenskript (ohne den Hashbang):

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

Erweitert:

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

Testen Sie mit c(372,4);:

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

Testen Sie mit 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);}

Lesbar:

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

Verwendung:

F(3541, 50)

Ausgabe:

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

Cobra - 363

Ein ziemlich deprimierendes Ergebnis ... aber hey, ich habe immer noch Java besiegt.

Es sollte immun gegen Integerüberläufe für die praktischen Testfälle sein.

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 Zeichen

Verwenden Sie viele Zeichenfolgen, um die Aufgabe zu erledigen.

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 Zeichen

Version, die eine Funktion definiert

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

Leicht ungolfierte Version:

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

Beispielverwendung:

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

Um es lesbarer zu machen, benutze putStr:

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

Groovy - 191 182 Zeichen

Basierend auf der auf Groovy 2.2.1 portierten Lösung von Thomas Rüping :

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}

Ausführung und Ausgabe:

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

Etwas weniger Golf (Minigolf?)

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

}

Weisen Sie einfach genügend Speicherplatz zu, um fünf Ergebnisse zyklisch zu speichern. Die äußere Schleife läuft weiter, bis wir das Limit erreichen oder eine einzelne Ziffer erreichen. Die innere Schleife addiert die letzte Ziffer der Zahl zur letzten Ziffer von 1/10 der Zahl und addiert diese, multipliziert mit der entsprechenden Potenz von 10, zum Ergebnis. Teilen Sie die erste Zahl durch 10 und wiederholen Sie den Vorgang, um die Gesamtsumme zu erhalten. Dann drucken Sie bis zu den letzten fünf Ergebnissen aus.

Die nächste Herausforderung besteht darin, zu sehen, ob ich mich genug rasieren kann, um einige Skriptsprachen beim Golfspielen zu übertreffen.

Bearbeiten: Kompiliert jetzt mit Warnung, aber fünf Zeichen werden durch Entfernen der "Void" -Deklaration entfernt

C # - 309 330 320 306 Bytes

Golf Version:

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

Verbrauch: F (3541,50);

Ungolfed-Version zur besseren Lesbarkeit:

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

Verbesserungsvorschläge sind immer willkommen! ;)

Bearbeiten: String.Empty wurde entfernt und durch "" ersetzt, um 10 Bytes zu sparen.

Edit 2: Danke an malik für den Tipp mit den Strings!