Jeu de nombres ajoutés

16

Jeu de nombres ajoutés

Écrivez une fonction / programme qui prend 2 paramètres entiers paramètres entiers ou variables entières , un nombre de départ et un nombre d'itérations max. Le code doit exécuter l'exemple de jeu suivant pour construire un nouveau numéro et répéter jusqu'à ce que le numéro ne contienne qu'un seul chiffre. par exemple.

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

Fondamentalement, en prenant chaque chiffre individuel et en l'ajoutant à son voisin, puis en ajoutant le résultat de l'ajout suivant également.

Le nombre d'itérations max est de protéger les boucles infinies, et lorsque le max est atteint, le code devrait vider les 5 dernières étapes numériques. La même sortie devrait se produire à la fin en atteignant un seul chiffre. Si moins de 5 étapes se sont produites, ne sortez que les nombres valides.

La sortie doit apparaître comme ( Step: Number), y compris les 5 dernières étapes des étapes terminées ou terminées:

func(3541, 50) produirait ce format de sortie exact:

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

func(3541, 5) produirait:

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

L'ensemble du calcul étant:

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

S'il y a moins de 5 étapes, imprimez simplement ces étapes.

N'utilisez que des bibliothèques intégrées, les paramètres peuvent provenir de n'importe où (ce qui est le plus simple pour la langue de votre choix). Aucune limite sur la taille entière maximale, et s'il y a des débordements, laissez-le planter.

Étant donné que ce n'est pas trop difficile d'un point de vue de puzzle, je donnerai jusqu'au dimanche 25, 20h (UTC + 8) pour que les soumissions soient prises en compte pour la réponse acceptée, auquel cas la plus courte de toutes les langues sera gagnante.

ÉDITER:

Félicitations à Howard, gagnant avec une réponse 48 GolfScript .

Mention spéciale à la 2e place marinus avec une réponse 66 APL .

Mon préféré (étant biaisé vers JavaScript) était la réponse de core1024 .

code-golf 
— Mat
source
Je ne comprends pas, est func(3541, 5)censé imprimer 5 étapes ou 10?
— Tal
5 étapes. Il doit s'arrêter lorsqu'il atteint l'itération 5, ne plus effectuer d'itérations et imprimer les 5 dernières étapes. Je viens d'inclure l'ensemble complet des étapes pour montrer le processus de calcul complet pour cette entrée particulière.
— Matt

Réponses:

4

GolfScript, 48 46 caractères

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

Merci à Peter Taylor pour une amélioration à deux caractères.

Attend les deux nombres sur la pile. Essayez en ligne .

Exemples:

> 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
— Howard
source
Il y a une économie modérée en ajoutant un flip après .,,et en transformant la carte finale en juste {': '*}%.
— Peter Taylor
10

APL (66)

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

L'argument de gauche est le nombre d'itérations maximal et l'argument de droite est le numéro de début.

Explication:

  • ∆←⍺{... }⍕⍵: passez l'argument gauche sous forme de nombre et l'argument droit sous forme de chaîne à la fonction qui calcule la liste des nombres, et stockez-la dans ∆:
    • (1<⍴⍵)∧⍺>0:: si le nombre de chiffres est supérieur à 1 et le nombre d'itérations restant est supérieur à 0:
      • ⍎¨⍵: évaluer chaque chiffre
      • 2+/: additionner chaque paire
      • ⍕¨: formate chaque nombre sous forme de chaîne
      • ∆←,/: concaténer les chaînes et stocker dans ∆
      • ∆,(⍺-1)∇⊃∆: return ∆, suivi du résultat de l'application de cette fonction ∆avec une itération de moins autorisée
    • ⋄⍬: sinon, retourne la liste vide
  • ∆,⍪⍳⍴∆: associer chaque élément de ∆avec son index dans∆
  • {... }/: pour chaque paire:
    • (⍕⍵),': ',⍺: retourne une chaîne avec l'index, suivi de :, suivi du nombre
  • ↑¯5↑: transformez la liste des chaînes en une matrice afin qu'elles s'affichent sur des lignes distinctes, et prenez les 5 derniers éléments

Tester:

      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
— marinus
source
Cette poignée affiche-t-elle correctement moins de 5 étapes? Par exemple 3 {...} 3541.
— algorithmshark
@algorithmshark Il le fait maintenant (il a donné des lignes supplémentaires avec le :premier)
— marinus
5

Mathematica, 172 caractères

C'est beaucoup trop long, grâce aux noms de fonctions de Mathematica et à la gestion des chaînes laides (le "jeu" réel n'est que de 76 de ces caractères), mais le voici quand même:

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

Il attend le numéro d'entrée en variable n et le nombre maximum d'itérations en m.

Avec moins de 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
    ]
— Martin Ender
source
5

Ruby, 106 caractères

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}

Je ne suis pas sûr à 100% des règles d'entrée, mais si je peux prendre ncomme chaîne, je peux enregistrer 5 caractères, et si je peux utiliser des variables prédéfinies et écrire un programme au lieu d'une fonction, je peux enregistrer 9 autres.

Crée une fonction fqui peut être appelée comme suit:

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
— Paul Prestidge
source
2
Observation intéressante que 4 ou plusieurs "9" produisent un résultat divergent
— Digital Trauma
4

J - 96 92 car

J'avais d'abord résolu cela en supposant que tous les jeux se terminaient, et cela est revenu me mordre dans le cul pendant les tests. L'argument de gauche est le nombre d'étapes, l'argument de droite est la position de départ, qui peut être donnée sous la forme d'un nombre ou d'une chaîne.

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

C'est un peu trop golfé et alambiqué pour dégouliner de manière satisfaisante, alors je dirai ceci:

  • (<@>:@[(' '-.~[:,@":2+/\"."0@]^:)":)Cette partie exécute le jeu pour le nombre d'étapes spécifié. 2+/\est responsable de l'ajout de chaque paire de chiffres, et <@>:@[en tandem avec des ^:commandes capturant les étapes intermédiaires du jeu.
  • (#\(,': '&,)&":"0,)@}.@({.~,i.0:)@:".Cette partie formate tous les résultats en step: result. ({.~,i.0:)s'assure que nous ne prenons pas trop de pas, ce #\sont les numéros de pas, et le (,': '&,)&":"0bit ajoute les deux points et l'espace.
  • (-@(<.5<.#){.])Cette partie supprime les cinq étapes pertinentes ou moins de la liste complète. <.signifie «minimum de».

Cela fonctionne, mais si vous commencez avec un nombre suffisamment important, les résultats du jeu commencent rapidement à augmenter en taille, ce qui fait que J passe des entiers aux doubles imprécis. Voici quelques exemples:

   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
— algorithmshark
source
3

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

Non golfé

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])
}
— edc65
source
3

Perl, 86 84

Avec de nouvelles lignes pour la lisibilité:

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

+ Modifier: aucune excuse pour ne pas utiliser le -ncommutateur de ligne de commande, puis le score est de 82 = 81 + 1 :

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

Et, le débordement d'entier possible étant OK, c'est 81 = 80 + 1

$.=$_;
print+(map$.=~s/.(?=(.|))/~$1?$&+$1:''/eg>1?"$_: $.$/":(),/ /..$')[-5..-1]
— user2846289
source
J'ai appris de nouvelles choses. Impressionnant!
— core1024
2

Javascript, 247 278 288 307 Caractères

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

Formaté

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

Edit 1 : Suppression du ternaire

Edit 2 : Logique inversée pour "sauter" 0 index

Edit 3 : Appels récursifs retravaillés.

Violon

— Origineil
source
Ne vous inquiétez pas, rien à voir ici. Je pensais qu'il imprimait les 5 premiers, mais il devrait avec votre violon. Beau travail :)
— Matt
2

Bash + coreutils, 115 octets

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

Production:

$ ./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
$
— Traumatisme numérique
source
2

JavaScript (ECMAScript 6 Draft) - 134 caractères

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

Exemples:

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"
— MT0
source
1

Javascript, 182 octets

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])}
— Casse-croûte
source
1

Perl, 166 147 138 129 129 octets

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

Non golfé:

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

J'espère que ça va bien qu'il imprime des lignes vides supplémentaires si le tout prend moins de 5 étapes.

— Tal
source
Remplacez (('')x5, @o, "$i: $s")par (@o, "$i: $s")et join"\n", @o[-5..0]par join"\n", @o[-5..-1]. Ensuite, vous aurez 3 octets d'avance;)
— core1024
Je n'ai aucun problème avec des lignes vides supplémentaires.
— Matt
@ core1024 Merci :) J'allais aussi vous donner un pourboire, mais vous vous êtes déjà débarrassé de cette longue partie "à moins"
— Tal
1

Java      524   405 365 caractères [414 octets]

Version golfée: 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);}}

Version lisible:

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);
}
}
— user12345
source
Vous pouvez réduire cela en utilisant 1 caractère pour les noms de variable et de fonction.
— Lex Webb
Terminé ... a également changé la logique pour arrêter la récursivité en utilisant num <= 9 au lieu de digits.length == 1 (vu dans ce fil uniquement ... ne m'a pas frappé auparavant).
— user12345
vous pouvez réduire la longueur du nom de l'argument dans votre méthode principale, ce qui vous donnera 3 personnages de chat supplémentaires
— user902383
vous n'avez pas besoin de convertir une chaîne en tableau de caractères, vous pouvez accéder à un seul caractère de la chaîne en utilisant la chatAtméthode
— user902383
1
et enfin, vous n'avez pas besoin de convertir votre caractère en chaîne, puis de l'analyser, à la place, Integer.valueOf(digits[i] + "") + Integer.valueOf(digits[i + 1] + "");vous pouvez le faire(digits[i] + digits[i+1] - 96)
— user902383
1

JavaScript 133 octets

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

Non golfé:

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'))
}
— core1024
source
Le seul problème est que le nom de la fonction est le même que celui de l'une de vos variables :) Mais la technique est géniale.
— Matt
Bon point! J'ai renommé la fonction;)
— core1024
1

Java, 341 caractères 371 caractères

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

Formaté:

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

Grâce à user902383, j'ai pu réduire le code de 30 caractères, en ne divisant pas la chaîne en tableau et en utilisant -96 au lieu de "Integer.valueOf ()

— Thomas Rüping
source
vous pouvez toujours réduire certains caractères,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
0

Fléchette, 602 588 octets

Dart est probablement l'une des pires langues pour ce faire ... Je vais devoir trouver une meilleure façon de le faire.

Quoi qu'il en soit, voici mon entrée:

Entrée via la console

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

Et la version non golfée, légèrement non minimisée:

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;
}
— MisterBla
source
0

PERL 135129/125 125/121 octets

Il a le même bug que la réponse de 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]}

Modifiez 129 octets en fonction:

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 octets en fonction:

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 octets comme script de console (sans le 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 octets comme script de console (sans le 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]

Étendu:

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

Testez avec c(372,4);:

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

Testez avec c(3541,50);:

6: 1411
7: 552
8: 107
9: 17
10: 8
— core1024
source
Je pense que vous n'êtes censé imprimer que les 5 dernières étapes.
— Tal
— Je l'ai
Et vous avez encore 3 octets devant moi ... faites-le exploser! : p
— Tal
@Tal Nous sommes encore maintenant: D
— core1024
0

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

Lisible:

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

Usage:

F(3541, 50)

Production:

6: 1411
7: 552
8: 107
9: 17
10: 8
— jzm
source
0

Cobra - 363

Un résultat plutôt déprimant ... mais bon, j'ai quand même battu Java.

Il devrait être à l'abri des débordements d'entier pour les cas de test pratiques.

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
— Οurous
source
0

Python 2.7, 174 173 158 caractères

Utiliser beaucoup de chaînes pour effectuer la tâche.

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 caractères

Version définissant une fonction

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

Version légèrement non golfée:

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:])
— avall
source
0

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

exemple d'utilisation:

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

Pour le rendre plus lisible, utilisez putStr:

λ> putStr $ 3541#5
1: 1411
2: 552
3: 107
4: 17
5: 8
— Flonk
source
Vous devez répertorier uniquement les 5 dernières étapes du calcul. Essayez de le putStr $ 3541#50comparer avec l'exemple de l'OP. Sinon, je suis content qu'il y ait un gars Haskell ici.
— core1024
@ core1024 C'est le cas! Même si je les ai mal étiquetés, vous avez raison. Je vais arranger ça demain.
— Flonk
0

Groovy - 191 182 caractères

Basé sur la solution de Thomas Rüping , portée sur 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}

Exécution et sortie:

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

Non golfé:

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 }
— Michael Easter
source
0

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

Un peu moins de golf (mini-golf?)

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

}

Allouez juste assez de mémoire pour stocker cinq résultats de façon cyclique. La boucle externe continue jusqu'à ce que nous atteignions la limite ou atteignions un seul chiffre. La boucle intérieure ajoute le dernier chiffre du nombre au dernier chiffre de 1/10 du nombre et l'ajoute, multiplié par la puissance pertinente de 10 au résultat. Divisez le nombre que vous avez d'abord par 10 et répétez pour obtenir le total. Imprimez ensuite les cinq derniers résultats.

Le prochain défi est de voir si je peux me raser suffisamment pour battre certains langages de script au golf.

Edit: compile maintenant avec avertissement mais cinq caractères rasés en supprimant la déclaration "void"

— Alchymiste
source
Conseils de golf: f (int a, int z) -> f (a, z) et pourrait utiliser t = 10 en économisant 2 caractères supplémentaires. Mais utiliser a et a / = 10 dans la même expression n'est pas défini
— edc65
0

C # - 309 330 320 306 octets

Version golfée:

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

Utilisation: F (3541,50);

Version non golfée pour la lisibilité:

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

Les suggestions d'amélioration sont toujours les bienvenues! ;)

Éditer: Supprimé String.Empty et l'a remplacé par "" pour économiser 10 octets.

Edit 2: Merci à malik pour l'astuce avec les cordes!

— tsavinho
source
Vous n'en avez pas besoin .ToCharArray(). A string = char array
— jzm
Oh, et une autre chose que vous pouvez faire est, au lieu de .ToString(), faire+""
— jzm
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.