附加号码游戏

16

附加号码游戏

编写一个函数/程序，该函数/程序接受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日（周日）晚上8点（UTC + 8）之前考虑是否接受已接受的答案，届时所有语言中最短的将成为获胜者。

编辑：

祝贺霍华德，以48 GolfScript的答案获胜。

特别要提到第二名的马里纳斯，答案是66 APL 。

我个人最喜欢的（偏爱JavaScript）是core1024的答案。

code-golf 
— 马特
source
我不明白，func(3541, 5)应该打印5步还是10步？
— 2014年
5个步骤。它应该在到达迭代5时停止，不再执行任何迭代并打印出最后5个步骤。我只包含了完整的步骤集，以显示该特定输入的完整计算过程。
— 马特

Answers:

4

GolfScript，48个 46个字符

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

感谢Peter Taylor对两个字符的改进。

期望两个数字都在堆栈上。在线尝试。

例子：

> 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
— 霍华德
source
通过在之后添加翻转.,,并将最终地图更改为just，可以节省一定的费用{': '*}%。
— 彼得·泰勒
10

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
— 马里纳斯
source
这样可以正确处理少于5个步骤的显示吗？例如3 {...} 3541。
— algorithmhark
@algorithmshark现在开始（它在:第一行中给出了额外的提示）
— marinus
5

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]

它期望输入变量为in n，最大迭代次数为in 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
    ]
— 马丁·恩德
source
5

Ruby，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
— 保罗·普雷斯蒂奇
source
2
有趣的观察结果是4个或更多的“ 9”产生了不同的结果
— 数字创伤2014年
4

J- 96 92个字符

我首先假设所有游戏都终止了，然后解决了这个问题，然后又在测试过程中让我深深地陷入了困境。左参数是步数，右参数是起始位置，可以指定为数字或字符串。

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

这有点打高尔夫球并且令人费解地折磨到了gogolf，所以我这样说：

  • (<@>:@[(' '-.~[:,@":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
— 算法
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])}

不打高尔夫球

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

带有换行符以提高可读性：

$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]
— 用户名
source
我学到新的东西。太棒了！
— 2014年
2

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：重做的递归调用。

小提琴

— 原产地
source
不用担心，这里什么也看不到。以为是先打印5张，但应该随便摆弄。做得好:)
— 马特2014年
2

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
$
— 数字创伤
source
2

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

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])}
— 小吃
source
1

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]

取消高尔夫：

<> =~ / /;
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个步骤，它可以打印一些额外的空行。

— 塔尔
source
更换(('')x5, @o, "$i: $s")用(@o, "$i: $s")和join"\n", @o[-5..0]用join"\n", @o[-5..-1]。然后，您将提前3个字节；）
— core1024 2014年
多余的空行我没有任何问题。
— 马特
@ core1024谢谢:)我也想给你一个提示，但是你已经摆脱了那长的“除非”部分
— Tal 2014年
1

爪哇      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);
}
}
— 用户名
source
您可以通过为变量和函数名称使用1个字符来缩小它。
— Lex Webb 2014年
完成...还更改了逻辑，以使用num <= 9而不是digits.length == 1停止递归（仅在此线程中见过……以前没有打过我）。
— user12345 2014年
您可以在您的main方法中减少参数名称的长度，这将给您另外3个
— 角色
您不需要将字符串转换为字符数组，可以使用chatAt方法访问字符串中的单个字符
— user902383 2014年
1
最后一件事，您不需要将字符转换为字符串，然后解析它，而是Integer.valueOf(digits[i] + "") + Integer.valueOf(digits[i + 1] + "");可以执行(digits[i] + digits[i+1] - 96)
— user902383 2014年
1

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'))
}
— 核心1024
source
唯一的问题是函数名称与您的变量之一相同：)但是该技术很棒。
— 马特
好点子！我将函数重命名;）
— core1024
1

Java，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，通过不使用-96而不是“ Integer.valueOf（）将字符串拆分为数组，我能够将代码减少30个字符。

— 托马斯·鲁平
source
您仍然可以减少一些字符，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 2014年
0

镖，602个 588字节

Dart可能是最糟糕的语言之一，我需要找到一种更好的方法来实现这一目标。

无论如何，这是我的条目：

通过控制台输入

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;
}
— 布拉先生
source
0

PERL 135 129/125 125/121字节

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

编辑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
— 核心1024
source
我相信您只应该打印最后5个步骤。
— 2014年
得到解决;）
— core1024
而且您仍然比我领先3个字节...爆炸吧！：p
— Tal 2014年
@Tal我们甚至现在：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);}

可读性：

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
— z
source
0

眼镜蛇-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
— 巨大
source
0

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

哈斯克尔（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
— 弗隆克
source
您只需要列出计算中的最后5个步骤。尝试putStr $ 3541#50将其与OP的示例进行比较。否则我很高兴这里有一个Haskell家伙。
— 2014年
@ core1024确实如此！尽管我确实给他们贴上了错误的标签，但您是对的。明天我会解决的。
— 弗隆克（Flonk）2014年
0

Groovy- 191182个字符

基于ThomasRüping的解决方案，移植到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 }
— 迈克尔·复活节
source
0

**Ç 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”声明删除了五个字符

— Alchymist
source
高尔夫技巧：f（int a，int z）-> f（a，z），可以使用t = 10节省2个字符。但是在相同的表达式中使用a和a / = 10是不确定的
— edc65
0

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：感谢malik提供的字符串提示！

— 萨维尼奥
source
你不需要.ToCharArray()。一个字符串=字符数组
— jzm，2014年
哦，您可以做的另一件事是，而不是.ToString()做+""
— jzm 2014年
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.