İki pozitif tamsayı p ve q verildiğinde , göreviniz aşağıdaki algoritmayı uygulayarak yaratılan A dizisini döndürmektir :

1. A = [p, q] ve d = 2 ile başlayın
2. Toplamı d ile bölünebilen A'daki bitişik sayıların her çifti (x, y) için , x ve y arasına (x + y) / d ekleyin .
3. En az bir eşleşme çifti bulunursa, d artırın ve adım 2 ile devam edin. Aksi takdirde, durdurun ve A'ya geri dönün .

Örnek

Aşağıda p = 1 ve q = 21 için işlemin detayı verilmiştir .

  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

Dolayısıyla beklenen çıktı: [1, 1, 4, 3, 11, 8, 21]

Açıklamalar ve kurallar

• Giriş ve çıkış herhangi bir makul formatta ele alınabilir. P ve q tam sayılarının 0'dan büyük olması garanti edilir. Bu yardımcı olursa, q ≥ p olduğunu varsayabilirsiniz .
• Algoritmanın 2. adım gerektiği değil, yinelemeli sadece aynı tekrarda yerleştirilmiş olan elemanlara uygulanabilir. Örneğin, A = [1, 1] ve D = 2 gitmelidir [1, 1, 1] (1 's sonsuz bir liste).
• Bu kod golf , yani bayt cinsinden en kısa cevap kazanır!

Test durumları

  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]

Kodunuzu biraz daha büyük bir test durumuyla test etmek istiyorsanız, işte beklenen çıktı:

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

05AB1E , 28 19 18 bayt

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

Çevrimiçi deneyin!

ha, kesinlikle sert geliştirilebilir. hala refactor için çalışıyor.

Muhtemelen aldığım kadar iyi.

-1 Teşekkürler, başka kim ama Emigna! Takas işaretlemek için kayıtlardan daha iyi çalıştı.

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

Hata ayıklama dökümü [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]]

Çevrimiçi hata ayıklama ile deneyin!

Mathematica, 72 64 59 58 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

Girişi bir liste olarak alıyoruz {p,q}. Yineleme adımı şu şekilde yeniden düzenlenmiştir:

1. Her iki öğenin (a+b)/darasına yerleştirin ve : sonunda bir ile 'nin dizisini hesaplar . Bölüyoruz ve her birini ve arasına yerleştiriyoruz . Artış .ab(x+{##2,}&@@x)a+ba+NulldRiffle(a+b)/dabd
2. IntegerElde edilen listenin öğelerini seç . (Bu aynı zamanda Nulltarafından tanıtılandan da kurtulur {##2,}.)

Bu sonuç değişmedene kadar tekrarlanır (bu yalnızca hiçbiri tam sayı olmadığından tüm yeni unsurları kaldırdığımız için olabilir).

@MartinEnder //.yerine kullanmak yerine FixedPoint(ve bir liste olarak girdi almak) -8 bayt .

-6 tane daha çünkü ListConvolveaslında o kadar iyi değil

Ruby , 80 bayt

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

Çevrimiçi deneyin!

fDizi olarak giriş alarak özyinelemeli işlev [p, q].

Haskell, 85 81 bayt

(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)

Çevrimiçi deneyin!

Giriş, örneğin bir liste olarak alınır [1,2].

Düzenleme: @Laikoni sayesinde -4 bayt.

Python 2 , 112 110 108 105 103 bayt

^{-2 Jonathan Frech sayesinde bayt
-5 Erik Outgolfer sayesinde bayt}

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

Çevrimiçi deneyin!

Python 2 , 98 bayt

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)

Olarak çağır f([p,q]). Çevrimiçi deneyin!

Jonathan Allan 12 bayt kurtardı. Teşekkür ~!

açıklama

fözyinelemeli bir işlevdir: hangi durumda geri f(A, B, d)dönmediği f(next_A, A, d+1)sürece A == Bbunu değerlendirir A. (Bu, işlenir A*(A==B)or …: eğer A ≠ B, A*(A==B)yanlış-y olan boş liste ise, o zaman, …parça değerlendirilir; A = B A*(A==B)ise Aboş olan ve bu yüzden de truthy ise geri döner.)

next_A olarak hesaplanır:

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

Bu en iyi örnekle açıklanmaktadır. Ne zaman örneğin d = 5 ve 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 bayt

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

Çevrimiçi deneyin!

-8 sayesinde Rod .
-2 Lynn'e teşekkürler .

Kabuğu , 22 bayt

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

2 elemanlı bir liste alır, tamsayıların listesini ve yüzer. Çevrimiçi deneyin!

açıklama

→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 bayt

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

Çevrimiçi deneyin!

Retina , 111 bayt

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

1+@

1+
$.&
;

Çevrimiçi deneyin!

Girişi boşlukla ayrılmış sayılar olarak alır. Oldukça saf bir şekilde verilen algoritmayı takip eder, tek kayda değer teknik, aherhangi bir sayının ne zaman tutulduğunu not etmek için bir işaretleyici sembolü kullanmaktır . Bu, Retina'nın biraz sınırlı döngü yetenekleriyle çalışmak için kullanılır; bu yalnızca bir dizi evre, bu evrelerdeki girdilerde genel bir değişiklik yapmayıncaya kadar döngü yapmanıza izin verir.

Açıklama:

Bu, sorudaki ile aynı örneği kullanacaktır.

\d+
$*1;

Sayıların giriş dizisini noktalı virgülle ayrılmış unary dizisine çeviririz, böylece:

1; 111111111111111111111;

^
11@

Kodumuzu dbaşlangıçta bize verin:

11@1; 111111111111111111111;

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

Bu biraz daha karmaşık. {Sabit bir noktaya ulaşana kadar yürütülecek bir grup aşama başlatır. Ardından, +bu aşamanın kendisinin sabit bir noktaya kadar yürütülmesi gerektiğini belirtir. Bu aşama, her bir bitişik sayı çiftini ekler ancak ek bir noktalı virgül olmadan ekler. Şimdi biz olurdu:

11@1; 1111111111111111111111 111111111111111111111;

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

Diğer zor aşamada, bu bölüm birinci bölen grupta bölenimizi biriktirir ve listemizdeki herhangi bir sayıyı, bölen sayı ile izleyen bir noktalı virgül olmadan değiştirir d. Ayrıca a, bir şeylerin tutulduğunu ;belirtmek için, bu dizinin kalıcı olarak dizinin bir parçası olması gerektiğini belirtmek için bir de bu numaraları yönlendiririz . Şimdi biz olurdu:

11@1; a11111111111; 111111111111111111111;

 1+ 

Bu d, bu turdan önce ne de dizide bölünmeyen sayıların silinmesine neden olur . Bu, örneğimizde hiçbir değişiklik yapmaz.

.*a
1&$

Açgözlülükle dizenin başlangıcından agirdideki son harfe eşleşir . Bu, en fazla bir eşleşme olabileceği anlamına gelir. Herhangi bir değişiklik yaparsak, bir tane ekleriz d, aksi takdirde aynı bırakarak döngüden çıkabiliriz.

111@1; a11111111111; 111111111111111111111;

)`a

)Tarafından başlatılmış döngü kapanır {(! Sorgulama do) ve aksi takdirde bu aşamada sadece biz daha önce indirdi işaretleri kaldırır. Bu, döngünün sonu olduğu için, yukarıdaki aşamaları birçok kez tekrarlardık, ancak sadece döngüyü unutmuşum gibi devam edeceğim, çünkü örneği daha sürekli yapıyor.

111@1; 11111111111; 111111111111111111111;

1+@

Bu aşama çıktılarımızdan çıkarır:

1; 11111111111; 111111111111111111111;

1+
$.&

Bu aşama, unary sayılarını ondalık sayılarla değiştirir:

1; 11; 21;

;

Son aşama noktalı virgüllerden kurtulur:

1 11 21

Açıkça görüldüğü gibi, döngü üzerinde atlamak bize yanlış bir sonuç veriyor, ama umarım bu kafa karıştırıcı değildir.

JavaScript (ES6), 89 87 82 bayt

Teşekkürler @ -2 bayt için ve 5 bayt daha tasarruf etmenize yardımcı olduğunuz için teşekkür ederiz .

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

Diziyi girdi olarak alır: f([p,q]) .

Test Kılıfları

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 bayt

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}

Çevrimiçi deneyin!

Java 8, 180 bayt

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

Açıklama:

Burada dene.

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 bayt

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+" ")));}}

İlk program olan kod golfünde ilk girişim. Dene

Deneme 2, 159 bayt

İskeleyi kaldırmak, çünkü görev bir çift sayı alabilen (bir dizi çalışır) ve bir dizi döndüren bir işlev sağlamaktır. Gereksinimleri karşılamak için bir Func <int [], int []> F kullanılabileceği göz önüne alındığında , sadece F tanımlayın :

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

Tam Programı Burada Test Et

Genel bir Liste geçerli bir çıktı olarak kabul edilirse bu daha küçük olabilir (10 bayt'ı kaydetmek için .ToArray () 'i bırakın).

Girdi de değiştirilebilirse, bir dizi yerine <int> Listesinde yer almak çıktıyı başlatma gereksinimini ortadan kaldırır (126 baytta çıkar).

Bunu bir adım öteye taşıyarak, bu durumda bir geri dönüş değeri olması gerekmez. Bir Eylem kullanmak yerine return ifadesi tarafından kullanılan 9 baytı kaldırır.

Jöle , 19 bayt

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

Çevrimiçi deneyin!