Dati due interi positivi p e q , il vostro compito è quello di restituire la matrice A ha creato applicando il seguente algoritmo:

1. Inizia con A = [p, q] e d = 2
2. Per ogni coppia (x, y) di numeri contigui in ALLA cui somma è divisibile per d , inserto (x + y) / d tra x ed y .
3. Se è stata trovata almeno una coppia corrispondente, incrementare d e proseguire con il passaggio 2. In caso contrario, stop e ritorno A .

Esempio

Di seguito è riportato il dettaglio del processo per p = 1 e 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

Da qui l'uscita prevista: [1, 1, 4, 3, 11, 8, 21]

Chiarimenti e regole

• L'input e l'output possono essere gestiti in qualsiasi formato ragionevole. Gli interi p e q sono garantiti essere maggiori di 0. Se questo aiuta, puoi assumere q ≥ p .
• Il secondo passaggio dell'algoritmo non deve essere applicato in modo ricorsivo agli elementi che sono stati appena inseriti nella stessa iterazione. Ad esempio, A = [1, 1] e d = 2 dovrebbe portare a [1, 1, 1] (non un elenco infinito di 1).
• Questo è code-golf , quindi vince la risposta più breve in byte!

Casi test

  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]

Se desideri testare il tuo codice su un caso di test leggermente più grande, ecco l'output previsto per:

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

05AB1E , 28 19 18 byte

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

Provalo online!

eh, può sicuramente essere migliorato hardcore. ancora lavorando per refactoring.

Probabilmente buono come lo sto capendo.

-1 grazie a chi altro, ma Emigna! Per sottolineare lo swap ha funzionato meglio dei registri.

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

Dump del debug per [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]]

Provalo online con il debug!

Mathematica, 72 64 59 58 byte

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

Provalo online!

Come funziona

Prendiamo l'input come un elenco {p,q}. La fase di iterazione viene riformulata come:

1. Inserisci (a+b)/dtra ogni due elementi ae b: (x+{##2,}&@@x)calcola la sequenza di a+b's, con un a+Nullalla fine. Dividiamo per de Riffleinseriamo ciascuno (a+b)/dtra ae b. Incremento d.
2. Seleziona gli Integerelementi dell'elenco risultante. (Questo elimina anche quello Nullintrodotto da {##2,}.)

Questo si ripete fino a quando il risultato non cambia (cosa che può succedere solo perché abbiamo rimosso tutti i nuovi elementi, perché nessuno di loro era un numero intero).

-8 byte grazie a @MartinEnder dall'uso //.invece di FixedPoint(e dall'assunzione di input come elenco).

-6 in più perché in ListConvolverealtà non è eccezionale

Rubino , 80 byte

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

Provalo online!

Funzione ricorsiva fche accetta input come array [p, q].

Haskell, 85 81 byte

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

Provalo online!

L'input viene preso come un elenco, ad es [1,2].

Modifica: -4 byte grazie a @Laikoni.

Python 2 , 112 110 108 105 103 103 byte

^{-2 byte grazie a Jonathan Frech
-5 byte grazie a 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

Provalo online!

Python 2 , 98 byte

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)

Invoke as f([p,q]). Provalo online!

Jonathan Allan ha salvato 12 byte. Grazie ~!

Spiegazione

fè una funzione ricorsiva: si f(A, B, d)valuta f(next_A, A, d+1), a meno che A == B, nel qual caso non ritorni A. (Questo è gestito da A*(A==B)or …: se A ≠ B, A*(A==B)è l'elenco vuoto, che è falso-y, quindi la …parte viene valutata; se A = B allora A*(A==B)è A, che è non vuoto e quindi veritiero, e viene restituito.)

next_A è calcolato come:

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

Questo è meglio spiegato con l'esempio. Quando ad es. d = 5 E 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 byte

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

Provalo online!

-8 grazie a Rod .
-2 grazie a Lynn .

Buccia , 22 byte

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

Accetta un elenco di 2 elementi, restituisce un elenco di numeri interi e float. Provalo online!

Spiegazione

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

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

Provalo online!

Retina , 111 byte

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

1+@

1+
$.&
;

Provalo online!

Accetta l'input come numeri separati da spazio. Segue in modo abbastanza ingenuo l'algoritmo dato, con l'unica tecnica notevole che consiste nell'utilizzare un simbolo marcatore a, per notare quando uno qualsiasi dei numeri è stato mantenuto. Questo è usato per lavorare con le capacità di looping in qualche modo limitate di Retina, che consente di eseguire il loop solo fino a quando una serie di stage non apporta modifiche globali all'input di tali stage.

Spiegazione:

Questo utilizzerà lo stesso esempio della domanda.

\d+
$*1;

Modifichiamo la matrice di input di numeri in una matrice unaria separata di punto e virgola, quindi avremmo:

1; 111111111111111111111;

^
11@

Inserisci dnel nostro codice all'inizio, dandoci:

11@1; 111111111111111111111;

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

Questo è leggermente più complicato. {avvia un gruppo di fasi che verranno eseguite fino a raggiungere un punto fisso. Quindi, +indica che questo stadio stesso dovrebbe essere eseguito fino a un punto fisso. Questa fase aggiunge ogni coppia di numeri adiacenti ma li inserisce senza il punto e virgola aggiuntivo. Ora avremmo:

11@1; 1111111111111111111111 111111111111111111111;

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

L'altra fase difficile, questa accumula il nostro divisore nel primo gruppo di acquisizione e sostituisce qualsiasi numero nella nostra lista senza un punto e virgola finale con quel numero diviso per d. Aggiungiamo anche un lead aa questi numeri, per indicare che qualcosa è stato mantenuto, insieme a ;per indicare che dovrebbe essere permanentemente parte dell'array. Ora avremmo:

11@1; a11111111111; 111111111111111111111;

 1+ 

Questo elimina i numeri che non erano divisibili dné nella matrice prima di questo round. Questo non fa cambiamenti nel nostro esempio.

.*a
1&$

Ciò corrisponde avidamente dall'inizio della stringa all'ultima lettera anell'input. Ciò significa che può esserci al massimo una partita. Se abbiamo apportato delle modifiche, ne aggiungiamo una d, altrimenti la stessa in modo da poter uscire dal ciclo.

111@1; a11111111111; 111111111111111111111;

)`a

La )chiusura del ciclo inizia da {(non metterlo in discussione!) E altrimenti questa fase rimuove solo i marcatori che abbiamo messo in precedenza. Poiché questa è la fine del ciclo, ripetiamo molte volte le fasi precedenti, tuttavia continuerò come se avessi dimenticato il ciclo, poiché rende l'esempio più continuo.

111@1; 11111111111; 111111111111111111111;

1+@

Questa fase rimuove dal nostro output:

1; 11111111111; 111111111111111111111;

1+
$.&

Questa fase sostituisce i numeri unari con numeri decimali:

1; 11; 21;

;

La fase finale si sbarazza dei punti e virgola:

1 11 21

Ovviamente, saltare sul loop ci fa avere un risultato errato qui, ma speriamo che non sia troppo confuso.

JavaScript (ES6), 89 87 82 byte

Grazie @Arnauld per -2 byte e per aver contribuito a salvare altri 5 byte.

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

Prende ingresso come un array: f([p,q]).

Casi test

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 byte

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}

Provalo online!

Java 8, 180 byte

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

Spiegazione:

Provalo qui.

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 byte

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

Primo tentativo di code golf, che è l'intero programma. Provalo

Tentativo 2, 159 byte

Togliere il ponteggio, poiché il compito è fornire una funzione che può prendere una coppia di numeri (un array funziona) e restituire un array. Dato che Func <int [], int []> F può essere utilizzato per soddisfare i requisiti, basta definire 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();};

Prova il programma completo qui

Questo potrebbe essere più piccolo se un elenco generico è considerato un output valido (rilasciare .ToArray () per salvare 10 byte).

Se è possibile modificare anche l'input, passare un Elenco <int> anziché un array rimuove la necessità di inizializzare l'output (esce a 126 byte).

Facendo un ulteriore passo avanti, in questo caso non è necessario un valore di ritorno. L'uso di un'azione rimuove invece i 9 byte utilizzati dall'istruzione return.

Gelatina , 19 byte

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

Provalo online!