З огляду на два натуральних числа p і q , ваше завдання - повернути масив A, створений за допомогою наступного алгоритму:

1. Почніть з A = [p, q] і d = 2
2. Для кожної пари (x, y) суміжних чисел у A , сума яких ділиться на d , вставіть (x + y) / d між x і y .
3. Якщо знайдена хоча б одна пара, збільшить d і продовжуємо діяти з кроком №2. В іншому випадку, зупинка і повернення .

Приклад

Нижче наведено деталі процесу для p = 1 і q = 21 .

  1  21             | Iteration #1: we start with d = 2 and A = [1, 21]
   \/               |               1 + 21  is divisible by 2 -> we insert 11
 22/2=11            |
                    |
  1  11 21          | Iteration #2: d = 3, A = [1, 11, 21]
   \/               |               1 + 11  is divisible by 3 -> we insert 4
 12/3=4             |
                    |
  1 4 11  21        | Iteration #3: d = 4, A = [1, 4, 11, 21]
        \/          |               11 + 21 is divisible by 4 -> we insert 8
      32/4=8        |
                    |
  1    4    11 8 21 | Iteration #4: d = 5, A = [1, 4, 11, 8, 21]
    \/   \/         |               1 + 4   is divisible by 5 -> we insert 1
  5/5=1 15/5=3      |               4 + 11  is divisible by 5 -> we insert 3
                    |
  1 1 4 3 11 8 21   | Iteration #5: d = 6, A = [1, 1, 4, 3, 11, 8, 21]
                    |               no sum of two contiguous numbers is divisible by 6
                    |               -> we stop here

Звідси очікуваний вихід: [1, 1, 4, 3, 11, 8, 21]

Роз'яснення та правила

• Введення та вихід можна обробляти у будь-якому розумному форматі. Гарантовано, що цілі p і q будуть більшими ніж 0. Якщо це допомагає, ви можете припустити, що q ≥ p .
• Другий крок алгоритму не повинен застосовуватись рекурсивно до елементів, які щойно були вставлені з однаковою ітерацією. Наприклад, A = [1, 1] і d = 2 повинні привести до [1, 1, 1] (а не нескінченного списку 1-х).
• Це код-гольф , тому найкоротша відповідь у байтах виграє!

Тестові кейси

  p |   q | Output
----+-----+-------------------------------------------------------------------------------
  1 |   1 | [1,1,1]
  1 |   2 | [1,2]
  1 |   3 | [1,1,2,3]
  2 |   6 | [2,1,2,1,4,1,2,6]
  3 |  13 | [3,1,8,1,3,1,7,1,2,1,5,1,3,2,13]
  9 |   9 | [9,6,9,6,9]
 60 |  68 | [60,13,1,4,31,2,3,5,2,19,64,7,13,1,2,5,2,27,44,3,4,8,2,1,12,1,5,3,28,2,4,16,1,
    |     |  2,12,1,2,1,10,1,6,68]
144 | 336 | [144,68,3,4,8,1,12,1,4,2,28,13,128,44,17,92,240,58,108,5,17,1,2,5,3,28,3,1,11,
    |     |  60,3,6,2,42,2,4,26,192,54,132,7,1,15,1,3,1,18,1,4,2,30,3,1,12,1,9,78,46,336]

Якщо ви хочете перевірити свій код на трохи більшому тестовому випадку, ось очікуваний вихід для:

• p = 12096 (2 ⁶ * 3 ³ * 7)
• q = 24192 (2 ⁷ * 3 ³ * 7)

05AB1E , 28 19 18 байт

[Ðü+NÌ/‚ζ˜ʒ.ï}DŠQ#

Спробуйте в Інтернеті!

е, напевно, можна покращити хардкор. все ще працює на рефактор.

Напевно, так добре, як я це отримую.

-1 дякую, хто ще, але Емінья! Для вказівки своп працював краще, ніж регістри.

[                   // Infinite loop.
 Ð                  // Triplicate [p, ..., q]
  U                 // Pop 1 of 3 copies into register X.
   ü+               // Pairwise addition.
     NÌ/            // Divide by current iteration + 2 (which is d).
        ‚           // Group original [p, ..., q] with pairwise additives.
         ζ˜         // Transpose together and flatten.
           ʒ.ï}     // Filter out non-integer entities (includes the space added by zip).
               DXQ  // Dupe result, see if equal to original.
                  # // If new array is original array, nothing happened, quit & return.

Дамп налагодження для [p,q] = [1,3]:

Full program: [ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> [  ||  stack: []
ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: []
current >> U  ||  stack: [[1, 3], [1, 3], [1, 3]]
current >> ü  ||  stack: [[1, 3], [1, 3]]
Full program: +
current >> +  ||  stack: [1, 3]
stack > [4]
current >> N  ||  stack: [[1, 3], [4]]
current >> Ì  ||  stack: [[1, 3], [4], 0]
current >> /  ||  stack: [[1, 3], [4], 2]
current >> ‚  ||  stack: [[1, 3], [2.0]]
current >> ζ  ||  stack: [[[1, 3], [2.0]]]
current >> ˜  ||  stack: [[[1, 2.0], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 2.0, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 2.0, 3]]
current >> X  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
current >> Q  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 3]]
current >> #  ||  stack: [[1, 2.0, 3], 0]
stack > [[1, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 2.0, 3]]
current >> U  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 2.0, 3]]
current >> ü  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 2.0]
stack > [3.0]
Full program: +
current >> +  ||  stack: [3.0, 2.0, 3]
stack > [3.0, 5.0]
current >> N  ||  stack: [[1, 2.0, 3], [3.0, 5.0]]
current >> Ì  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 1]
current >> /  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 3]
current >> ‚  ||  stack: [[1, 2.0, 3], [1.0, 1.6666666666666667]]
current >> ζ  ||  stack: [[[1, 2.0, 3], [1.0, 1.6666666666666667]]]
current >> ˜  ||  stack: [[[1, 1.0], [2.0, 1.6666666666666667], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 1.0, 2.0, 1.6666666666666667, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.6666666666666667]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 0]
stack > [[1, 1.0, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 1.0, 2.0, 3]]
current >> U  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> ü  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 1.0]
stack > [2.0]
Full program: +
current >> +  ||  stack: [2.0, 1.0, 2.0]
stack > [2.0, 3.0]
Full program: +
current >> +  ||  stack: [2.0, 3.0, 2.0, 3]
stack > [2.0, 3.0, 5.0]
current >> N  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0]]
current >> Ì  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 2]
current >> /  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 4]
current >> ‚  ||  stack: [[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]
current >> ζ  ||  stack: [[[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]]
current >> ˜  ||  stack: [[[1, 0.5], [1.0, 0.75], [2.0, 1.25], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 0.5, 1.0, 0.75, 2.0, 1.25, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.5]
stack > [0]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.75]
stack > [0]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.25]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 1]
[1, 1.0, 2.0, 3]
stack > [[1, 1.0, 2.0, 3]]

Спробуйте в Інтернеті за допомогою налагодження!

Математика, 72 64 59 58 байт

(d=2;#//.x_:>Riffle[x,(x+{##2,}&@@x)/d++]~Cases~_Integer)&

Спробуйте в Інтернеті!

Як це працює

Ми приймаємо дані як список {p,q}. Крок ітерації формулюється так:

1. Вставте (a+b)/dміж кожними двома елементами aі b: (x+{##2,}&@@x)обчислюйте послідовність a+b's, з а a+Nullв кінці. Ми ділимо поd і Riffleвставляємо кожен (a+b)/dміж aі b. Приріст d.
2. Виберіть Integer елементи отриманого списку. (Це також позбавляється від Nullвведеного {##2,}також.)

Це повторюється, поки результат не зміниться (що може статися лише тому, що ми видалили всі нові елементи, оскільки жоден з них не був цілим числом).

-8 байт завдяки використанню @MartinEnder //. замість FixedPoint(та прийняття даних як списку).

-6 більше, тому що ListConvolveнасправді це не так здорово

Рубін , 80 байт

->a,d=2{*b=a[0];a.each_cons 2{|x,y|z=x+y;b+=z%d>0?[y]:[z/d,y]};b==a ?a:f[b,d+1]}

Спробуйте в Інтернеті!

Рекурсивна функція, що fприймає вхід як масив [p, q].

Haskell, 85 81 байт

(a:b:c)#d=a:[div(a+b)d|mod(a+b)d<1]++(b:c)#d
l#d=l
l%d|l==l#d=l|e<-d+1=l#d%e
(%2)

Спробуйте в Інтернеті!

Вхід приймається як список, наприклад [1,2] .

Редагувати: -4 байти завдяки @Laikoni

Python 2 , 112 110 108 105 103 байт

^{-2 байти завдяки Джонатану Фреху
-5 байт завдяки Еріку Переверху}

y=input()
x=d=1
while x!=y:
 d+=1;x=y;y=x[:1]
 for a,b in zip(x,x[1:]):c=a+b;y+=[c/d,b][c%d>0:]
print x

Спробуйте в Інтернеті!

Python 2 , 98 байт

f=lambda A,B=0,d=2:A*(A==B)or f(sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1]),A,d+1)

Викликати як f([p,q]). Спробуйте в Інтернеті!

Джонатан Аллан врятував 12 байт. Спасибі ~!

Пояснення

fє рекурсивною функцією: f(A, B, d)оцінює f(next_A, A, d+1), якщо A == B, у разі, якщо вона повертається A. (Це обробляється A*(A==B)or …: якщо A ≠ B A*(A==B)- це порожній список, який є хибним-y, тому …частина оцінюється; якщо A = B, то A*(A==B)є A, яка не порожня і, таким чином, truthy, і вона повертається.)

next_A обчислюється як:

sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])

Це найкраще пояснити на прикладі. Коли, наприклад, d = 5 і A = [1, 4, 11, 8, 21]:

  sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])
= sum([[(1+4)/d, 4], [(4+11)/d, 11], [8], [21]], [1])
= [1] + [1, 4] + [3, 11] + [8] + [21]
= [1, 1, 4, 3, 11, 8, 21]

Пітон 2 , 111 байт

A=input()
m=d=1
while m:
 m=o=0;d+=1
 while A[o+1:]:
	o+=1;s=A[o-1]+A[o]
	if s%d<1:A[o:o]=s/d,;m=1;o+=1
print A

Спробуйте в Інтернеті!

-8 завдяки Роду .
-2 завдяки Лінні .

Лушпиння , 22 байти

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN

Бере 2-елементний список, повертає список цілих чисел і плаває. Спробуйте в Інтернеті!

Пояснення

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN  Input is a list L.
  G                 tN  Cumulative reduce over the list [2,3,4..
                   ⁰    with initial value L
   `λ             )     using flipped version of this function:
     f£NΣẊṠeo/⁰+:.       Arguments are a list, say K=[1,3,3], and a number, say d=4.
                :.       Prepend 0.5: [0.5,1,2,3]
         Ẋ               For each adjacent pair,
               +         take their sum,
            o/⁰          divide by d,
          Ṡe             and pair it with the right number in the pair: [[0.375,1],[1.0,3],[1.5,3]]
        Σ                Concatenate: [0.375,1,1.0,3,1.5,3]
     f£N                 Remove non-integers: [1,1.0,3,3]
                        Now we have an infinite list of L threaded through 2,3,4.. using the expansion operation.
 U                      Take longest prefix of unique elements,
→                       then last element of that.

Perl 5 , 92 + 1 ( -a) = 93 байти

do{$c=0;@n=shift@F;$.++;push@n,($t=$_+$n[-1])%$.?$_:($c=$t/$.,$_)for@F;@F=@n}while$c;say"@F"

Спробуйте в Інтернеті!

Сітківка , 111 байт

\d+
$*1;
^
11@
{+`(1+); (1+);
$1; $1$2 $2;
(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1; 
 1+ 
 
.*a
1$&
)`a

1+@

1+
$.&
;

Спробуйте в Інтернеті!

Приймає дані як пробіли, розділені числами Досить наївно слідує заданому алгоритму, єдиний помітний прийом - використання символу маркера,a , щоб відмітити, коли зберігалося будь-яке число. Це використовується для роботи з дещо обмеженими можливостями циклічного циклу Retina, що дозволяє циклічно лише до тих пір, поки набір етапів не внесе загальних змін у вхід до цих етапів.

Пояснення:

Для цього буде використаний той же приклад, що і в питанні.

\d+
$*1;

Ми змінюємо вхідний масив чисел на одинарний масив, розділений крапкою з комою, так що у нас буде:

1; 111111111111111111111;

^
11@

Введіть dнаш код на початку, даючи нам:

11@1; 111111111111111111111;

{+`(1+); (1+);
$1; $1$2 $2;

Це трохи складніше. {запускає групу етапів, які будуть виконуватися до тих пір, поки вони не досягнуть фіксованої точки. Потім +вказує, що сам цей етап повинен виконуватися до фіксованої точки. Цей етап додає кожну пару сусідніх чисел, але вставляє їх без додаткової крапки з комою. Тепер у нас буде:

11@1; 1111111111111111111111 111111111111111111111;

(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1;

Інший складний етап, цей накопичує наш дільник у першій групі зйомки і замінює будь-яке число у нашому списку без проміжного крапки з комою на це число, поділене на d. aДо цих цифр ми також додаємо провідне , щоб вказати, що щось зберігалось, а також ;вказати, що воно повинно бути постійно частиною масиву. Тепер у нас буде:

11@1; a11111111111; 111111111111111111111;

 1+ 

Це видаляє числа, які не були розділені dні в масиві до цього раунду. Це не робить змін у нашому прикладі.

.*a
1&$

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

111@1; a11111111111; 111111111111111111111;

)`a

)Закриває цикл , розпочатий {(не ставлять під сумнів його!) , І в іншому випадку цей етап просто видаляє маркери ми кладемо вниз раніше. Оскільки це кінець циклу, ми б повторювали вищезазначені етапи багато разів, однак я просто продовжую так, ніби я забув цикл, оскільки це робить приклад більш безперервним.

111@1; 11111111111; 111111111111111111111;

1+@

Цей етап видаляє з нашого результату:

1; 11111111111; 111111111111111111111;

1+
$.&

Цей етап замінює одинарні числа десятковими числами:

1; 11; 21;

;

Заключний етап позбавляється від крапки з комою:

1 11 21

Очевидно, що пропуск на циклі змушує нас отримати неправильний результат, але, сподіваємось, це не надто заплутано.

JavaScript (ES6), 89 87 82 байт

Дякуємо @Arnauld за -2 байти та допомогли зберегти ще 5 байт.

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

Вводить дані як масив: f([p,q]) .

Випробування

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

;[[1,1],[1,2],[1,3],[2,6],[3,13],[9,9],[60,68],[144,336],[12096,24192]]
.forEach(test=>O.innerText+=JSON.stringify(test)+" -> "+JSON.stringify(f(test))+"\n")

<pre id=O></pre>

Рода , 90 байт

f a,d=2{A=[a()|slide 2|[_,(_1+_)/d]if[(_1+_2)%d=0]else[_1]]+a[-1]f A,d=d+1 if[a!=A]else A}

Спробуйте в Інтернеті!

Java 8, 180 байт

import java.util.*;p->q->{List<Integer>r=new Stack();r.add(p);r.add(q);for(int d=1,f=d,i;f==d++;)for(i=1;i<r.size();i++)if((q=r.get(i)+r.get(i-1))%d<1)r.add(i++,q/(f=d));return r;}

Пояснення:

Спробуйте тут.

import java.util.*;           // Required import for List and Stack

p->q->{                       // Method with two integer parameters and List return-type
  List<Integer>r=new Stack(); //  Result-list
  r.add(p);r.add(q);          //  Add the two input-integers to the List
  for(int d=1,                //  Divisible integer (starting at 1)
          f=d,                //  Temp integer (starting at `d` / also 1)
          i;                  //  Index-integer
      f==d++;)                //  Loop (1) as long as `f` and `d` are equal
                              //  (and raise `d` by 1 so it starts at 2 inside the loop)
    for(i=1;                  //   Reset index-integer to 1
        i<r.size();i++)       //   Inner loop (2) over the List
      if((q=r.get(i)+r.get(i-1)) 
                              //    If the current + previous items (stored in `q`)
         %d<1)                //    are divisible by `d`:
        r.add(i++,q/(f=d));   //     Insert `q` divided by `d` to the List at index `i`
                              //     (and raise `i` by 1 and set `f` to `d` in the process)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
  return r;                   //  Return the result-List
}                             // End of method

C #, 280 байт

using System.Linq;class A{static void Main(string[] p){var l=new System.Collections.Generic.List<int>(p.Select(int.Parse));int r,d=2,c;do{c=0;for(int i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);l.ForEach(v=>System.Console.Write((v+" ")));}}

Перша спроба кодового гольфу, яка є цілою програмою. Перевірте це

Спроба 2, 159 байт

Забираючи ешафот, тому що завдання полягає в наданні функції, яка може приймати пару чисел (масив працює) і повертає масив. Враховуючи, що функцію <int [], int []> F можна використовувати для задоволення вимог, просто визначте F :

F=v=>{var l=new List<int>(v);int i,r,d=2,c;do{c=0;for(i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);return l.ToArray();};

Повна програма тут

Це може бути меншим, якщо загальний список вважатиметься дійсним виведенням (скиньте .ToArray (), щоб зберегти 10 байт).

Якщо також можна змінити вхід, то передача у Список <int> замість масиву усуває необхідність ініціалізації виводу (виходить у 126 байт).

Зробивши цей крок далі, в цьому випадку насправді не повинно бути значення повернення. Використання дії замість цього видаляє 9 байтів, які використовуються в операторі return.

Желе , 19 байт

®‘©‘÷@+2\⁸żFfṀR$µÐL

Спробуйте в Інтернеті!