Ordenar una secuencia concatenada


17

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.


¿Qué quiere decir exactamente con "números más pequeños posibles"? ¿El promedio más pequeño? ¿El máximo más pequeño? ¿Algo más?
isaacg

@isaacg Entonces, como el enésimo número es mayor que (n-1) th.
nicael

1
Para aclarar mi pregunta, ¿cuál sería la división adecuada de 5467ser? 54 67? 5 46 70?
isaacg


3
Lo 0 parece una excepción bastante molesta e innecesaria.
Martin Ender

Respuestas:


1

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.


5

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>


Hay un error para x1 = 0, x2> 0, por ejemplo, entrada "0 1".
flornquake

@flornquake arreglado. El recuento de bytes sigue siendo el mismo, habiendo reducido un poco el código de llenado cero
edc65

2

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


¿Por qué produce más números? ¿Y no debería ser fácil de arreglar? El requisito es n <= 15.
Stewie Griffin

@Stewie Pero bueno, el primero produce 12 y el segundo 11. Eso es menor que 15.
nicael

La secuencia inicial f(n) = f(n-1)+f(n-2)tiene un valor máximo de exactamente 15. El número de valores de salida se determina en función del algoritmo, nada más.
Stewie Griffin

@Stewie ok, entonces debe ser exactamente 15, ¿verdad? Entonces, por n <= 15 quiere decir que los números de entrada son menores que 15?
nicael

El número de valores en la secuencia inicial es 15. Los valores iniciales f(1)=x1y f(2)=x2pueden ser superiores a 15. El número de valores de salida se determina en función de los valores de entrada. Porque 3 2serán las 10.
Stewie Griffin

1

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


1

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.


1

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.

0

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
}

0

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 !@$_;  }...*

¿Por qué debe haber un espacio en until (my$a...? ¿ (No es un delimitador especial?
gato

@cat que sería una llamada a la subrutina llamada until, que no existe.
Brad Gilbert b2gills
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.