추가 숫자 게임

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 단계 미만인 경우 수행 한 단계를 인쇄하십시오.

내장 라이브러리 만 사용하면 어디에서나 매개 변수를 선택할 수 있습니다 (원하는 언어에 가장 쉬운 방법). 최대 정수 크기에 제한이 없으며 오버플로가 있으면 충돌합니다.

이것이 퍼즐 관점에서 그리 어렵지 않다는 것을 감안할 때, 나는 8PM (UTC + 8) 8시 (UTC + 8)까지 수락 된 답변에 대한 제출물을 제출할 것입니다.이 시점에서 가장 짧은 언어가 승자가 될 것입니다.

편집하다:

48 GolfScript 답변 으로 하워드에게 축하를 전합니다 .

66 APL 답변 2 위의 마리 누스에 대한 특별 언급 .

내가 개인적으로 좋아하는 (JavaScript에 편향되어 있음)은 core1024의 답변 이었습니다.

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

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@]^:)":))

이것은 약간 골프를 치고 만족스럽게 degolf하기에 복잡하기 때문에 다음과 같이 말할 것입니다.

• (<@>:@[(' '-.~[:,@":2+/\"."0@]^:)":)이 부분은 지정된 단계 수만큼 게임을 실행합니다. 2+/\각 숫자 쌍을 추가해야합니다.<@>:@[^: 하고 게임의 중간 단계를 캡처하는 컨트롤 과 함께 .
• (#\(,': '&,)&":"0,)@}.@({.~,i.0:)@:".이 부분은 모든 결과를로 형식화합니다 step: result. ({.~,i.0:)너무 많은 조치를 취하지 않도록하고 있습니다.#\ 거치지 않고 단계 번호이며 (,': '&,)&":"0비트는 콜론과 공백을 추가합니다.
• (-@(<.5<.#){.]) 이 부분은 전체 목록에서 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

자바 스크립트 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])
}

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

자바 스크립트, 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 : "skipping"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 초안)-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"

자바 스크립트, 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])}

펄 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 단계 미만이면 여분의 빈 줄을 인쇄하는 것이 좋습니다.

자바      (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);
}
}

자바 스크립트 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'))
}

자바, 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 덕분에 "Integer.valueOf () 대신 -96을 사용하여 문자열을 배열로 분할하지 않음으로써 코드를 30 자 줄일 수있었습니다.

다트, 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;}

그리고 ungolfed, 약간 unminified 버전 :

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 바이트

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

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

파이썬 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:])

약간 ungolfed 버전 :

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

그루비- 191 개 182 문자

Thomas Rü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 }

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

}

주기적으로 5 개의 결과를 저장하기에 충분한 메모리를 할당하십시오. 외부 루프는 한계에 도달하거나 한 자리 수에 도달 할 때까지 계속 진행됩니다. 내부 루프는 숫자의 마지막 자릿수를 숫자의 1/10의 마지막 자릿수에 더하고이를 10의 관련 거듭 제곱에 곱하여 결과에 더합니다. 먼저 10으로 숫자를 나누고 반복하여 합계를 얻으십시오. 그런 다음 마지막 5 개 결과까지 인쇄하십시오.

다음 도전은 골프에서 일부 스크립팅 언어를 이길만큼 면도 할 수 있는지 보는 것입니다.

편집 : 이제 경고로 컴파일되지만 "void"선언을 제거하여 5자를 깎았습니다.

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 덕분에!