Додана гра чисел


16

Додана гра чисел

Напишіть функцію / програму, яка приймає два цілих параметри цілих параметрів або цілих змінних , початкове число та макс. Кількість ітерацій. Код повинен виконувати наступний приклад гри для побудови нового числа та повторювати, поки число не залишиться одноцифровою. напр.

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 неділі о 20:00 (UTC + 8) для подань, які будуть розглянуті для прийнятої відповіді, і тоді найкоротший з будь-якої мови стане переможцем.

Редагувати:

Вітаємо Говарда, що виграв із 48 відповідями GolfScript .

Особлива згадка 2 - е місця Марини з 66 APL в відповіді .

Моя особиста улюблена (упереджена до JavaScript) була відповіддю core1024 .


Я не розумію, чи func(3541, 5)слід надрукувати 5 кроків чи 10?
Тал

5 кроків. Він повинен зупинятися, коли він потрапляє до ітерації 5, виконувати не більше ітерацій та роздруковувати останні 5 кроків. Я щойно включив повний набір кроків, щоб показати повний процес обчислення для цього конкретного вводу.
Метт

Відповіді:


4

GolfScript, 48 46 символів

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

Дякую Пітеру Тейлору за двозначне вдосконалення.

Очікує обидва числа на стеку. Спробуйте в Інтернеті .

Приклади:

> 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

Існує помірне заощадження, додавши фліп після .,,і перетворивши остаточну карту в справедливу {': '*}%.
Пітер Тейлор

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  

Чи правильно ця ручка відображає менш ніж 5 кроків? Напр 3 {...} 3541.
Алгоритм

@algorithmshark Це зараз (він дав додаткові рядки з :першим)
marinus

5

Математика, 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
    ]

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

2
Цікаве спостереження, що 4 або більше "9" с дає різний результат
Digital Trauma

4

J - 96 92 char

Я спершу вирішив це, якщо припустити, що всі ігри закінчуються, і це повернулося, щоб вкусити мене в дупу під час тестування. Лівий аргумент - це кількість кроків, правий аргумент - вихідна позиція, яка може бути задана як число або рядок.

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

Це трохи надто гольф і перекручено, щоб дегольф задовольняв, тому я скажу так:

  • (<@>:@[(' '-.~[:,@":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

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

3

Перл, 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]

Я дізнався нові тони. Дивовижно!
core1024

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 : Перероблені рекурсивні дзвінки.

Скрипка


Не хвилюйтеся, тут нічого не бачити. Думав, що друкує перші 5, але це має бути з вашою загадкою. Приємна робота :)
Метт

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
$ 

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"

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

1

Перл, 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 кроків.


Замініть (('')x5, @o, "$i: $s")на (@o, "$i: $s")і join"\n", @o[-5..0]з join"\n", @o[-5..-1]. Тоді ви будете на 3 байти вперед;)
core1024

У мене немає проблем із зайвими порожніми рядками.
Метт

@ core1024 Дякую :) Я також збирався дати вам підказку, але ви вже позбулися тієї довгої "хіба що" частини
Тал

1

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

Ви можете зменшити це за допомогою 1 знака для імен змінних та функцій.
Lex Webb

Виконано ... також змінено логіку, щоб зупинити рекурсію, використовуючи num <= 9 замість digits.length == 1 (Видно лише в цій темі ... раніше мене не вдарило).
користувач12345

ви можете зменшити довжину імені аргументу у вашому головному методі, що дасть вам додаткові 3 символи
user902383

вам не потрібно перетворювати рядок в масив символів, ви можете отримати доступ до одного символу з рядка за допомогою chatAtметоду
user902383

1
і останнє, що вам не потрібно перетворювати свого персонажа в рядок, а потім розбирати його, замість цього Integer.valueOf(digits[i] + "") + Integer.valueOf(digits[i + 1] + "");ви можете це зробити(digits[i] + digits[i+1] - 96)
user902383

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

Проблема лише в тому, що назва функції те саме, що одна з ваших змінних :) Але методика є приголомшливою.
Метт

Гарна думка! Я перейменував функцію;)
core1024

1

Ява, 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 я зміг зменшити код на 30 символів, не розбиваючи String на масив, використовуючи -96 замість "Integer.valueOf ()


ви все ще можете скоротити деякі символи,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

Дарт, 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;}

І незворушена, трохи не змінена версія:

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

0

PERL 135 129/125 125/121 байт

Він має таку ж помилку, що і відповідь Тала

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

Я вважаю, що ви повинні лише надрукувати останні 5 кроків.
Тал


А ти ще на 3 байти попереду мене ... вибух! : p
Тал

@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

0

Кобра - 363

Досить пригнічуючий результат ... але ей, я все одно переміг Яву.

Він повинен бути захищений від цілих переливів для практичних тестових випадків.

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

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

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

Ви повинні перерахувати лише останні 5 кроків з обчислення. Спробуйте putStr $ 3541#50і порівняйте це з прикладом ОП. Інакше я радий, що тут є хлопець Haskell
core1024

@ core1024 Це так! Хоча я неправильно позначив їх, ти маєш рацію. Я це виправлю завтра.
Флонк

0

Groovy - 191 182 символів

На основі рішення Томаса Рюпінга , перенесеного на 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 }

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

Трохи менше гольфу (міні-гольф?)

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 і повторіть, щоб отримати загальну суму. Потім роздрукуйте до останніх п’яти результатів.

Наступне завдання полягає в тому, щоб побачити, чи можу я достатньо поголитися, щоб перемогти деякі мови сценаріїв у гольфі.

Редагувати: тепер компілюється з попередженням, але п’ять символів поголені, видаляючи декларацію "недійсні"


Підказки для гольфу: 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]);
        }
    }

Пропозиції щодо вдосконалення завжди вітаються! ;)

Редагувати: Видалений рядок. Очистіть і замініть його на "", щоб зберегти 10 байт.

Редагувати 2: Дякую маліку за підказку зі струнами!


Вам не потрібно .ToCharArray(). A string = char масив
jzm

О, і ще одна річ, яку ви можете зробити, це замість цього .ToString()зробити+""
jzm
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.