Dados dos enteros positivos p y q , su tarea es devolver la matriz A creada mediante la aplicación del siguiente algoritmo:

1. Start con A = [p, q] y d = 2
2. Para cada par (x, y) de números contiguos en A cuya suma es divisible por d , inserte (x + y) / d entre x e y .
3. Si se encontró al menos un par coincidente, incremente d y continúe con el paso 2. De lo contrario, la parada y el retorno Una .

Ejemplo

A continuación se detalla el proceso para p = 1 y 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

De ahí el resultado esperado: [1, 1, 4, 3, 11, 8, 21]

Aclaraciones y reglas.

• La entrada y salida se pueden manejar en cualquier formato razonable. La enteros p y q se garantiza que sea mayor que 0. Si eso ayuda, se puede suponer q ≥ p .
• El segundo paso del algoritmo no debe aplicarse de forma recursiva a elementos que se acaban de insertar en la misma iteración. Por ejemplo, A = [1, 1] y d = 2 debería dar lugar a [1, 1, 1] (no una lista infinita de 1 de).
• Esto es código de golf , por lo que gana la respuesta más corta en bytes.

Casos de prueba

  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]

Si desea probar su código en un caso de prueba un poco más grande, aquí está el resultado esperado para:

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

05AB1E , 28 19 18 bytes

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

Pruébalo en línea!

eh, definitivamente se puede mejorar hardcore. Todavía trabajando para refactorizar.

Probablemente tan bueno como lo estoy obteniendo.

-1 gracias a, ¿quién más pero, Emigna! Para señalar swap funcionó mejor que los registros.

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

Volcado de depuración para [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]]

¡Pruébelo en línea con depuración!

Mathematica, 72 64 59 58 bytes

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

Pruébalo en línea!

Cómo funciona

Tomamos la entrada como una lista {p,q}. El paso de iteración se reformula como:

1. Insertar (a+b)/dentre cada dos elementos ay b: (x+{##2,}&@@x)calcula la secuencia de a+b's, con un a+Nullal final. Dividimos por de Riffleinserta cada uno (a+b)/dentre ay b. Incrementod .
2. Elija los Integerelementos de la lista resultante. (Esto también elimina el Nullintroducido por {##2,}).

Esto se repite hasta que el resultado no cambie (lo que solo puede suceder porque eliminamos todos los elementos nuevos, porque ninguno de ellos eran enteros).

-8 bytes gracias a @MartinEnder por usar en //.lugar de FixedPoint(y por tomar la entrada como una lista).

-6 más porque en ListConvolverealidad no es tan genial

Rubí , 80 bytes.

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

Pruébalo en línea!

Función recursiva que ftoma la entrada como la matriz [p, q].

Haskell, 85 81 bytes

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

Pruébalo en línea!

La entrada se toma como una lista, p. Ej. [1,2] .

Editar: -4 bytes gracias a @Laikoni.

Pitón 2 , 112 110 108 105 103 bytes

^{-2 bytes gracias a Jonathan Frech
-5 bytes gracias 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

Pruébalo en línea!

Python 2 , 98 bytes

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)

Invocar como f([p,q]).Pruébalo en línea!

Jonathan Allan ahorró 12 bytes. Gracias ~!

Explicación

fes una función recursiva: f(A, B, d)evalúa f(next_A, A, d+1), a menos que A == B, en cuyo caso regrese A. (Esto es manejado porA*(A==B)or … : si A ≠ B, A*(A==B)es la lista vacía, que es falsa-y, por lo que …se evalúa la parte; si A = B, entonces A*(A==B)es A, que no está vacío y, por lo tanto, es verdadero, y se devuelve).

next_A se calcula como:

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

Esto se explica mejor con un ejemplo. Cuando, por ejemplo, d = 5 y 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 bytes

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

Pruébalo en línea!

-8 gracias a Rod .
-2 gracias a Lynn .

Casco , 22 bytes

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

Toma una lista de 2 elementos, devuelve una lista de enteros y flotantes. Pruébalo en línea!

Explicación

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

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

Pruébalo en línea!

Retina , 111 bytes

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

1+@

1+
$.&
;

Pruébalo en línea!

Toma la entrada como números separados por espacios. De manera bastante ingenua sigue el algoritmo dado, y la única técnica notable es usar un símbolo de marcador,a , para observar cuándo se ha mantenido alguno de los números. Esto se utiliza para trabajar con las capacidades de bucle algo limitadas de Retina, que solo le permiten realizar bucles hasta que un conjunto de etapas no haga un cambio general en la entrada a esas etapas.

Explicación:

Esto usará el mismo ejemplo que en la pregunta.

\d+
$*1;

Cambiamos la matriz de entrada de números en una matriz unaria separada por punto y coma, por lo que tendríamos:

1; 111111111111111111111;

^
11@

Poner den nuestro código al principio, dándonos:

11@1; 111111111111111111111;

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

Esto es un poco más complicado. {inicia un grupo de etapas que se ejecutarán hasta que alcancen un punto fijo. Luego, +indica que esta etapa en sí misma debe ejecutarse hasta un punto fijo. Esta etapa agrega cada par de números adyacentes pero los inserta sin el punto y coma adicional. Ahora tendríamos:

11@1; 1111111111111111111111 111111111111111111111;

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

La otra etapa difícil, esta acumula nuestro divisor en el primer grupo de captura, y reemplaza cualquier número en nuestra lista sin punto y coma final con ese número dividido por d. También agregamos un encabezado aa estos números, para indicar que algo se guardó, junto con el ;para indicar que debería ser parte permanente de la matriz. Ahora tendríamos:

11@1; a11111111111; 111111111111111111111;

 1+ 

Esto elimina números que no eran divisibles por dni en la matriz antes de esta ronda. Esto no hace cambios en nuestro ejemplo.

.*a
1&$

Esto codiciosamente coincide desde el comienzo de la cadena hasta la última letra aen la entrada. Esto significa que puede haber como máximo un partido. Si realizamos algún cambio, agregamos uno a d, de lo contrario, lo dejamos igual para que podamos salir del ciclo.

111@1; a11111111111; 111111111111111111111;

)`a

Esto )cierra el ciclo iniciado por {(¡no lo cuestione!) Y de lo contrario, esta etapa simplemente elimina los marcadores que pusimos anteriormente. Como este es el final del ciclo, repetiríamos las etapas anteriores muchas veces, sin embargo, continuaré como si hubiera olvidado el ciclo, ya que hace que el ejemplo sea más continuo.

111@1; 11111111111; 111111111111111111111;

1+@

Esta etapa elimina de nuestra salida:

1; 11111111111; 111111111111111111111;

1+
$.&

Esta etapa reemplaza los números unarios con números decimales:

1; 11; 21;

;

La etapa final se deshace de los puntos y comas:

1 11 21

Obviamente, omitir el ciclo nos hace tener un resultado incorrecto aquí, pero con suerte eso no es demasiado confuso.

JavaScript (ES6), 89 87 82 bytes

Gracias @Arnauld por -2 bytes y por ayudar a ahorrar 5 bytes más.

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

Toma la entrada como una matriz: f([p,q]) .

Casos de prueba

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 bytes

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}

Pruébalo en línea!

Java 8, 180 bytes

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

Explicación:

Pruébalo aquí

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 bytes

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

Primer intento de código de golf, que es todo el programa. Pruébalo

Intento 2, 159 bytes

Quitando el andamiaje, ya que la tarea es proporcionar una función que pueda tomar un par de números (una matriz funciona) y devolver una matriz. Dado que un Func <int [], int []> F se puede utilizar para satisfacer los requisitos, solo defina 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();};

Prueba el programa completo aquí

Esto podría ser más pequeño si una lista genérica se considera una salida válida (suelte .ToArray () para guardar 10 bytes).

Si la entrada también se puede modificar, pasar una Lista <int> en lugar de una matriz elimina la necesidad de inicializar la salida (sale a 126 bytes).

Dando un paso más allá, en este caso no es necesario que haya un valor de retorno. El uso de una acción en su lugar elimina los 9 bytes utilizados por la declaración de devolución.

Jalea , 19 bytes

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

Pruébalo en línea!