รับจำนวนเต็มบวกสองตัวpและqงานของคุณคือส่งคืนอาร์เรย์A ที่สร้างโดยใช้อัลกอริทึมต่อไปนี้:

1. เริ่มต้นด้วยA = [p, q]และd = 2
2. สำหรับแต่ละคู่(x, y)ของตัวเลขที่ต่อเนื่องกันในที่มีผลรวมหารด้วย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 ≥พี
• ขั้นตอนที่สองของอัลกอริทึมไม่ควรนำไปใช้ซ้ำกับองค์ประกอบที่เพิ่งถูกแทรกเข้าไปในการวนซ้ำเดียวกัน ตัวอย่างเช่น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#

ลองออนไลน์!

ใช่สามารถปรับปรุงได้ไม่ยอมใครง่ายๆแน่นอน ยังคงทำงานเพื่อ refactor

อาจจะดีเท่าที่ฉันได้รับ

-1 ต้องขอบคุณใครมาก แต่ Emigna! เพื่อชี้ให้เห็นการแลกเปลี่ยนทำงานได้ดีกว่าการลงทะเบียน

[                   // 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]]

ลองออนไลน์ด้วย debug!

Mathematica, 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 การเพิ่มขึ้นbd
2. เลือกIntegerองค์ประกอบของรายการผลลัพธ์ (สิ่งนี้จะกำจัดสิ่งที่Nullแนะนำโดย{##2,}เช่นกัน)

สิ่งนี้ทำซ้ำจนกว่าผลลัพธ์จะไม่เปลี่ยนแปลง (ซึ่งสามารถเกิดขึ้นได้เพราะเราลบองค์ประกอบใหม่ทั้งหมดออกไปเพราะไม่มีองค์ประกอบใดเป็นจำนวนเต็ม)

-8 ไบต์ขอบคุณ @MartinEnder จากการใช้//.แทนFixedPoint(และจากการรับอินพุตเป็นรายการ)

-6 มากขึ้นเพราะListConvolveจริงๆแล้วมันไม่ได้ยอดเยี่ยม

Ruby , 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 ไบต์ขอบคุณ Jonathan Frech
-5 ไบต์ขอบคุณ Erik the Outgolfer}

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])เรียกว่าเป็น ลองออนไลน์!

Jonathan Allan บันทึก 12 ไบต์ ขอบคุณ ~!

คำอธิบาย

fเป็นฟังก์ชัน recursive: f(A, B, d)evalutes ไป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เช่นนั้นซึ่งไม่ว่างเปล่าและเป็นความจริงดังนั้นจึงได้รับผลตอบแทน)

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]

Python 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 ขอบคุณที่ลินน์

Husk , 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>

Röda , 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 ไบต์

การถอดนั่งร้านออกเนื่องจากภารกิจคือจัดเตรียมฟังก์ชันที่สามารถใช้ตัวเลขคู่หนึ่ง (อาร์เรย์ทำงาน) และส่งคืนอาร์เรย์ เนื่องจาก Func <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

ลองออนไลน์!