Considere una secuencia basada en las relaciones de recurrencia f(n) = f(n-1)+f(n-2), comenzando con f(1) = x1, f(2) = x2. Para x1 = 2, x2 = 1, la secuencia comienza así:

2  1  3  4  7  11  18  29  47  76  123  199  322  521  843

Concatenar esto en una cadena dará:

213471118294776123199322521843

Ahora, divida esta lista en los números más pequeños posibles que da y(n) > y(n-1). Comience con el primer número, luego el segundo, etc. El primer número de salida siempre debe ser un solo dígito. Rellene el último número con el número requerido de ceros.

2 13 47 111 829 4776 12319 93225 218430

Obtendrá dos números, (x1, x2)como entrada, en cualquier formato conveniente, y el desafío es generar la lista ordenada.

Reglas:

• La función y los programas están bien.
• La secuencia inicial tendrá exactamente 15 números (el último número es f(15)).
• x1y x2no son negativos (cero es posible).
• La salida puede estar en cualquier formato conveniente
• El vector de salida ydebe crearse de modo que y2 > y1.
  • Primero el más pequeño posible y1, luego el más pequeño posible y2, y3y así sucesivamente.
• Si x1 = x2 = 0entonces, genera 15 ceros (en el mismo formato que otra salida, es decir, no 000000000000000).

Ejemplos :

Input: 1 1
Output: 1  12  35  81  321  345  589  1442  3337 7610

Input: 3 2
Output: 3  25  71  219  315  0811 3121  23435 55898 145300
                             |
                             Optional leading zero 
Input: 0 0
Output: 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0

El código más corto en bytes gana. Incluya un enlace a un intérprete en línea si es posible.

Pyth, 56 bytes

LsgM.:sMb2?sQsM.WyHX_1Z`0u?yGX_1GHaGHjkhM.u,eNsN14QYmZ15

Banco de pruebas

Explicación:

Primero, verificamos si la entrada es precisa 0, 0. Si es así, imprime 15 ceros.

De lo contrario, producimos la secuencia, con jkhM.u,eNsN14Q. Esto es similar al algoritmo Pyth estándar para la secuencia de Fibonacci.

A continuación, reducimos sobre esta cadena. El acumulador es una lista de cadenas, que representa cada número en la secuencia dividida. En cada paso de reducción, tomamos el siguiente carácter y verificamos si el acumulador está en orden, utilizando la función auxiliar y, definida con LsgM.:sMb2, que es verdad si la entrada está fuera de servicio. Si está en orden, agregamos el siguiente carácter a la lista como su propio número. Si no, agregamos el siguiente carácter al final de la última cadena. Esto se logra con u?yGX_1GHaGH ... Y.

A continuación, realizamos un bucle while funcional. El ciclo continúa hasta que la lista en ejecución esté en orden, reutilizando la función auxiliar. En cada paso, un0 se agrega a al final de la última cadena de la lista. Esto se logra con .WyHX_1Z`0.

Finalmente, las cadenas se convierten en enteros, con sMe impresas.

Pyth, 51 bytes

LsgM.:sMb2?sQsM.WyHX_1Z`0hf!yT_./jkhM.u,eNsN14QmZ15

Creo que esto funciona, pero es demasiado lento para probarlo: es una solución de fuerza bruta para dividir la cuerda.

Haré algunas mejoras en la Xfunción, pero el código anterior funciona en la versión de Pyth que era más reciente cuando se publicó la pregunta.

JavaScript ES6, 127 135

(a,b)=>eval("for(n=r=[],v=13,o=a+n+b;v--;a=b,b=t)o+=t=b+a;for(d of o+'0'.repeat(99))(n+=d)>+v&&(r.push(v=n),n='');+v?r:[...o]")

Prueba

F=(a,b)=>eval("for(n=r=[],v=13,o=a+n+b;v--;a=b,b=t)o+=t=b+a;for(d of o+'0'.repeat(99))(n+=d)>+v&&(r.push(v=n),n='');+v?r:[...o]")

// less golfed

U=(a,b)=>{
  for(n=r=[], o=a+n+b, v=13; v--; a=b, b=t)
    o+= t= b+a;
  for(d of o+'0'.repeat(99))
    if ((n+=d) > +v)
      r.push(v=n), n='';
  return +v ? r : [...o]
}

function test(){
  var i = I.value.match(/\d+/g)
  O.textContent = i.length > 1 ? F(+i[0],+i[1]) : ''
}
test()

A,B : <input id=I value='0 1' oninput='test()'>
<pre id=O></pre>

JavaScript ES6, 187 180 187 184 182 179 175 172 165 160 155 154 bytes

(a,b)=>eval('d=""+a+b;for(i=-12,j=1;++i<99;)i<2?(c=b,d+=b=a+b,a=c,r=a?[d[0]]:"0,".repeat(15)):(f=+d.slice(j,i))>r[r.length-1]?(r.push(f),j=++i-1):d+=0;r')

Obtengo resultados similares cuando lo ejecuto 1,1y 3,2pruebo casos.0,0ha tomado un exceso de 26 bytes ...

De-golf + convertido a ES5 + demo:

function s(a, b) {
  d = "" + a + b;
  for (i = -12, j = 1; ++i < 99;)
    i < 2 ?
      (c = b, d += b = a + b, a = c, r = a ? [d[0]] : "0,".repeat(15))
    : (f = +d.slice(j, i)) > r[r.length - 1] ?
      (r.push(f), j = ++i - 1)
      : d += 0;
  return r
}
document.write(
   s(1,1)+"<br>"+
   s(3,2)+"<br>"+
   s(0,0)
)

JavaScript (ES6), 162 bytes

(a,b)=>(k=[...Array(15).keys(y="")],p=-1,z=k.map(_=>0),a|b?[...k.map(f=n=>n--?n?f(n)+f(n-1):b:a).join``,...z].map(d=>+(y+=d)>p?(p=y,y=" ",p):"").join``:z.join` `)

Explicación

(a,b)=>(
  k=[...Array(15).keys(y="")],     // k = array of numbers 0 to 14, initialise y
  p=-1,                            // initialise p to -1 so that 0 is greater than p
  z=k.map(_=>0),                   // z = array of 15 zeroes
  a|b?[                            // if a and b are not 0
      ...k.map                     // for range 0 to 14
      (f=n=>n--?n?f(n)+f(n-1):b:a) // recursive sequence function (0 indexed)
      .join``,                     // join result of f(0) to f(14) as a string
      ...z                         // append zeroes for padding
    ].map(d=>                      // for each digit of concatenated result
      +(y+=d)                      // append the digit to the current number y
      >p?(                         // if the current number is greater than the previous p
        p=y,                       // set previous to the current number
        y=" ",                     // reset y (with space as a separator)
        p                          // output the current number (with space at the start)
      ):""                         // else add nothing to the output
    )
    .join``                        // return the output as a string
  :z.join` `                       // return a bunch of zeroes if a and b are 0
)

Prueba

var solution = (a,b)=>(k=[...Array(15).keys(y="")],p=-1,z=k.map(_=>0),a|b?[...k.map(f=n=>n--?n?f(n)+f(n-1):b:a).join``,...z].map(d=>+(y+=d)>p?(p=y,y=" ",p):"").join``:z.join` `)

x1 = <input type="number" id="x1" value="3" /><br />
x2 = <input type="number" id="x2" value="2" /><br />
<button onclick="result.textContent=solution(+x1.value,+x2.value)">Go</button>
<pre id="result"></pre>

Mathematica, 192 bytes

f[{0,0}]:=0~Table~15
f@l_:=(t=0;q={};If[#>0,q~Join~{10^⌈Log10[t/#]⌉#},q]&[Last@#]&@FoldList[If[#>t,AppendTo[q,t=#];0,#]&[10#+#2]&,0,Flatten@IntegerDigits@SequenceFoldList[#+#2&,l,Range@13]])

Casos de prueba:

f[{2, 1}]
(* {2, 13, 47, 111, 829, 4776, 12319, 93225, 218430} *)
f[{3, 2}]
(* {3, 25, 71, 219, 315, 811, 3121, 23435, 55898, 145300} *)
f[{0, 0}]
(* {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} *)

Las longitudes de los nombres de las funciones me están matando.

Haskell, 165 159 152 142 141 bytes

w=take 15
x#y=x:scanl(+)y(x#y)
0%0=w[0,0..]
x%y=g(-1)(w(x#y)++0%0>>=show)(-1)
g _""_=[]
g b l@(h:t)a|b>a=b:g 0l b|1<2=g(max 0b*10+read[h])t a

Ejemplo de uso: 3 % 2-> [3,25,71,219,315,811,3121,23435,55898,145300].

Demostración en línea (con unmain contenedor).

Cómo funciona:

w=take 15
x#y=x:scanl(+)y(x#y)              -- fibonacci sequence generator for x and y

0%0=w[0,0..]                      -- special case 0%0
x%y=g(-1)(w(x#y)++0%0>>=show)(-1) -- calculate fib sequence, add some extra 0 and
                                  -- flatten all digits into a single string.
                                  -- start calculating the resulting sequence

g _""_=[]                         -- if we don't have digits left, stop.
                                  -- the final 0 in the second parameter is ignored.
g b l@(h:t)a
  |b>a=b:g 0l b                   -- if the current number is greater than the
                                  -- previous one, take it and start over.
  |1<2=g(max 0b*10+read[h])t a    -- otherwise add the next digit and retry.
                                  -- The "max" fixes the initial call with -1.

PowerShell, 167 166 bytes

param($x,$w)if($w-lt($x-eq0)){"0`n"*15;exit}[char[]]("$x"+-join(0..13|%{$w;$w=$x+($x=$w)}))|%{$z+="$_";if(+$z-gt$y){($y=$z);$z=""}};if($z){while(+$z-lt$y){$z+="0"}$z}

Guardado un byte eliminando la $svariable y simplemente alimentando el bucle de salida directamente.

Ungolfed y comentó:

param($x,$w)           # Take input parameters as x and w
if($w-lt($x-eq0)){     # If x=0, ($x-eq0)=1, so $w-lt1 implies w=0 as well
  "0`n"*15             # Print out 15 0's separated by newlines
  exit                 # And exit program
}                      # otherwise ...
[char[]](              # Construct the sequence string as a char-array
"$x"+-join(            # Starting with x and concatenated with a joined array
  0..13|%{             # Loop
    $w                 # Add on w
    $w=$x+($x=$w)      # Recalculate for next loop iteration
  }
))|%{                  # Feed our sequence as a char-array into a loop
  $z+="$_"             # z is our output number, starts with the first digit
  if(+$z-gt$y){        # If z is bigger than y (initialized to 0)
    ($y=$z)            # Set y equal to z and print it
    $z=""              # Reset z to nothing to start building the next number
  }
}
if($z){                # If there is remaining digits, we need to pad zeroes
  while(+$z-lt$y){     # Until z is bigger than y
    $z+="0"            # Tack on a zero
  }
  $z                   # Print the final number
}

Perl 6 , 107 bytes

{$_=@=(|@_,*+*...*)[^15].join.comb;.sum??[.shift,{last if !@$_;until (my$a~=.shift//0)>$^b {};$a}...*]!!$_} # 107

Uso:

# give it a lexical name for ease of use
my &code = {...}

# use ｢eager｣ because the anonymous block returns a lazy array
# and ｢say｣ doesn't ask it to generate the values
say eager code 2, 1;
# [2 13 47 111 829 4776 12319 93225 218430]
say eager code 1, 1;
# [1 12 35 81 321 345 589 1442 3337 7610]
say eager code 3, 2;
# [3 25 71 219 315 0811 3121 23435 55898 145300]
say eager code 0, 0;
# [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
say eager code 0, 1;
# [0 1 12 35 81 321 345 589 1442 3337 7000]

Explicación

crea una secuencia similar a Fibonacci, comenzando con los argumentos ( @_) deslizados ( |) en

|@_,*+*...*

toma los primeros 15 elementos de esa secuencia

(…)[^15]

combina eso en una sola cadena ( .join), lo divide en una secuencia de caracteres individuales ( .comb) y lo almacena en el escalar "predeterminado" ( $_) después de coaccionar la secuencia en una matriz mutable, almacenándola primero en una matriz anónima ( @)

$_=@=(…)[^15].join.comb;

encuentra la suma de los valores en el escalar predeterminado y, si es cero, devuelve el escalar predeterminado, que contendrá una matriz de 15 ceros

.sum?? … !!$_

Si la suma no es cero, crea una lista al cambiar primero el primer elemento en el escalar predeterminado

.shift, … 

seguido de generar el resto de los valores, comparándolo con el anterior ( $^b)
si el escalar predeterminado se queda sin valores, use 0 en su lugar ( //0)

…,{ … ;until (my$a~=.shift//0)>$^b {};$a}...*

detenerse cuando no quedan elementos en el escalar predeterminado

…,{last if !@$_; … }...*