Secuencias Contra Fibonacci

13

Dadas tres números m , n y p , su tarea es para imprimir una lista / matriz de longitud p comenzando con m y n y cada elemento después de p representa la diferencia de los 2 números antes de que, mn (Contrarreforma secuencia de Fibonacci )

Para este desafío, puede usar una función para devolver o imprimir el resultado o un programa completo.

Entrada

Tres enteros, m , n y p , separados por nuevas líneas / espacios / comas, cualquiera que sea su idioma, pero debe especificar su formato de entrada. La inserción del código no está permitida.

Salida

Los números contenidos en la secuencia Counter-Fibonacci, en cualquiera de los siguientes formatos (este ejemplo:) m = 50, n = 40, p = 6:

  • 50,40,10,30,-20,50 (o con espacios después de las comas)
  • [50,40,10,30,-20,50] (o con espacios después de las comas)
  • 50 40 10 30 -20 50(o con \n(líneas nuevas) en lugar de espacios)
  • {50,40,10,30,-20,50} (o con espacios en lugar de comas)

Ejemplos

Input => Output

50,40,10 => 50,40,10,30,-20,50,-70,120,-190,310
-100,-90,7 => -100,-90,-10,-80,70,-150,220
250,10,8 => 250,10,240,-230,470,-700,1170,-1870

Reglas

  • Le garantizamos que p es mayor que 1
  • Debe proporcionar una forma de probar su programa, si es posible
  • Tenga en cuenta que estas lagunas están prohibidas y la inserción de código está prohibida, como se mencionó anteriormente

Puntuación y tabla de clasificación

Su código debe ser lo más corto posible, ya que este es el código de golf . No se aceptará ninguna respuesta , porque este desafío está destinado a encontrar la respuesta más corta por idioma, evitando una ventaja injusta para los idiomas de golf.

Mostrar fragmento de código

Pregunta relacionada por ETHproductions: Monday Mini-Golf # 1: Reverse Fibonacci Solver

code-golf  math  number  sequence  fibonacci 
— Sr. Xcoder
fuente
Relacionados, posible duplicado. Básicamente es el mismo desafío que este, pero salir en orden inverso desde un punto específico en la secuencia.
— ETHproductions
@ETHproductions puede considerarse un engaño, pero esto es un poco diferente, tratando de ver la solución más corta en cada idioma
— Sr. Xcoder
Sí, no había tanta preocupación por la desigualdad del idioma en ese entonces ;-) Sin embargo, no creo que haga una gran diferencia. La principal diferencia aquí es que puedes omitir el primer paso del algoritmo que hubieras utilizado para resolver ese desafío (trabajando hacia atrás para encontrar el punto de partida)
— ETHproductions
@ETHproductions, de hecho, hay pequeñas diferencias. Si desea que se elimine este desafío, lo haré totalmente.
— Sr. Xcoder
Personalmente creo que está bien. Aparte, ¿se nos permite tener un separador final?
— ETHproductions

Respuestas:

9

Haskell, 29 bytes

a#b=a:b#(a-b)
(.(#)).(.).take

La longitud pes el primer parámetro. Ejemplo de uso: ( (.(#)).(.).take ) 10 50 40-> [50,40,10,30,-20,50,-70,120,-190,310]. Pruébalo en línea! .

Acortar la lista a pelementos toma más bytes que producirla.

— nimi
fuente
6

Jalea , 6 bytes

_@С+Ṗ

Pruébalo en línea!

Cómo funciona

_@С+Ṗ  Main link. Left argument: m. Right argument: n. Third argument: p

    +   Yield (m + n), the term that comes before m.
  С    Execute the link to the left p times, starting with left argument m and
        right argument (m + n). After each execution, replace the right argument
        with the left one and the left argument with the previous return value.
        Yield all intermediate values of the left argument, starting with m.
_@          Subtract the left argument from the right one.
        This yields the first (p + 1) terms of the sequence, starting with m.
    Ṗ   Pop; discard the last term.
— Dennis
fuente
5

JavaScript (ES6), 33 bytes

f=(m,n,p)=>p?m+[,f(n,m-n,p-1)]:[]

Devuelve una cadena del formato 1,2,3,, ¡sin usar cadenas!

Fragmento de prueba

Mostrar fragmento de código

— ETHproductions
fuente
5

Perl 6 , 25 bytes

{($^m,$^n,*-*...*)[^$^p]}

Intentalo

Expandido:

{  # bare block lambda with placeholder parameters ｢$m｣ ｢$n｣ ｢$p｣
  (
    $^m, $^n,  # declare first two params, and use them

    * - *      # WhateverCode lambda which subtracts two values

    ...        # keep using that to generate values

    *          # never stop (instance of type Whatever)

  )[ ^ $^p ]   # declare last param, and use it to grab the wanted values
               # ｢^ $^p｣ is short form of range op
               # ｢0 ..^ $^p｣ which excludes the ｢$p｣
}
— Brad Gilbert b2gills
fuente
5

CJam , 15 bytes

q~2-{1$1$-}*]S*

1 byte adicional porque CJam no usa naturalmente uno de los formatos de salida permitidos> _ <

Pruébalo en línea!

Explicación

q~               e# Read and eval the input
  2-             e# Subtract 2 from p (to account for m and n being in the list)
    {            e# Run this block p-2 times:
     1$1$-       e#   Copy the top values and subtract
          }*     e# (end of block)
            ]    e# Wrap the stack in an array
             S*  e# Join with spaces
— Gato de negocios
fuente
4

05AB1E , 9 7 bytes

ÍFÂ2£¥«

Pruébalo en línea!

Explicación

ÍF          # p-2 times do
  Â         # create a reversed copy of the current list
   2£       # take the first 2 elements of the list
     ¥      # calculate delta
      «     # append to the list
— Emigna
fuente
3

Röda , 38 bytes

f i,a,b{seq 1,i|{|_|[a];b=a-b;a=a-b}_}

Pruébalo en línea!

Explicado:

f i,a,b{seq 1,i|{|_|[a];b=a-b;a=a-b}_}
f i,a,b{                             } /* Function declaration */
        seq 1,i                        /* Push numbers 1..i to the stream */
               |{|_|               }_  /* For each number in the stream: */
                    [a];               /*   Push the current value of a */
                        b=a-b;         /*   Set b = the next number */
                              a=a-b    /*   Set a = the previous value of b */
— fergusq
fuente
3

Haskell , 33 bytes

(m!n)0=[]
(m!n)p=m:(n!(m-n))(p-1)

Llamar usando (m!n)p. Obras de definir !como una función infija que lleva en my ny devuelve una función que toma py devuelve el resultado deseado.

— Julian Wolf
fuente
¡Agradable! No pensé en hacer la función infijo, así que mi mejor intento con Haskell fue 34. Por cierto, puede reemplazar la nueva línea ;para que sea de una sola línea, por lo que se ve un poco más codegolfy.
— AlexJ136
2

Ruby, 31 bytes

->m,n,p{p.times{m,n=n,(p m)-n}}

La solución directa

— GB
fuente
2

PHP, 76 bytes

[,$a,$b,$c]=$argv;for($r=[$a,$b];$c---2;)$r[]=-end($r)+prev($r);print_r($r);

PHP, 84 bytes

[,$a,$b,$c]=$argv;for($r=[$a,$b];$c>$d=count($r);)$r[]=$r[$d-2]-end($r);print_r($r);
— Jörg Hülsermann
fuente
2

Pyth, 18 bytes

JEKEVEJ=N-JK=JK=KN

Pruébalo en línea!

La entrada y la salida están delimitadas por líneas nuevas.

Cómo funciona:

JEKE                Read two lines of input to J and K
    VE              Read another line and loop that many times:
      J               Print J
       =N-JK          Set N to J - K (Pyth uses prefix notation)
            =JK       Set J to K
               =KN    Set K to N
— draziwfozo
fuente
1

Mathematica, 26 bytes

{-1,1}~LinearRecurrence~##

Me encanta el edificio. Toma entrada en el formulario {{m, n}, p}. LinearRecurrencequiere saber los coeficientes de la combinación lineal de elementos anteriores para generar nuevos elementos, que en este caso es {-1,1}.

— Greg Martin
fuente
1

QBIC , 35 33 bytes

:::?'a;b;`[c-2|e=a-b?e';`┘a=b┘b=e

Se guardaron 2 bytes colocando el primero PRINT en un código literal.

Explicación (versión de 35 bytes):

:::         Get parameters a, b, c from the cmd-line
  ';`       This suppresses a newline when printing
?a   b';`   PRINT a and b
[c-2|       FOR x=1; x<=(c-2); x++
  e=a-b       calculate the next term of the sequence
  ?e';`       Print it, suppressing newline
  ┘a=b        ┘ denotes a syntactic linebreak; shove the numbers one over
  ┘b=e        dito
            FOR-loop is auto-closed
— Steenbergh
fuente
¿Tienes alguna idea de un intérprete en línea para probar esto?
— Sr. Xcoder
@ Mr.Xcoder todavía no hay intérprete en línea, lo siento. He agregado un enlace al intérprete, que es un proyecto de DOSBOX que ejecuta QBasic, que ejecuta QBIC.
— steenbergh
1
La explicación vale más que el intérprete @steenbergh, ¡gracias por responder!
— Sr. Xcoder
1

C, 128 bytes

m,n,p,z;main(c,v)char**v;{m=atoi(v[1]);n=atoi(v[2]);p=atoi(v[3])-2;printf("%d,%d",m,n);while(p--)z=m,m=n,n=z-m,printf(",%d",n);}

Este programa analiza los tres argumentos m, ny pdesde la línea de comandos, e imprime la salida como se especifica.

Los compiladores modernos de C le permiten omitir las importaciones básicas, y así podemos usar printfy atoisin el #includes.

Las variables globales son intpor defecto cuando se declaran sin tipo, esto ahorra mucho espacio.

— AlexJ136
fuente
1

Java, 66 bytes

Por una vez, lambdas son el enfoque ineficiente para jugar al golf debido a la muy manera indirecta de la aplicación de la recursividad para ellas que requiere una gran cantidad de bytes adicionales.

Golfizado:

String f(int m,int n,int p){return""+m+(p>1?","+f(n,m-n,p-1):"");}

Sin golf:

public class CounterFibonacciSequences {

  private static final int[][] INPUTS = new int[][] { //
      { 50, 40, 10 }, //
      { -100, -90, 7 }, //
      { 250, 10, 8 } };

  private static final String[] OUTPUTS = new String[] { //
      "50,40,10,30,-20,50,-70,120,-190,310", //
      "-100,-90,-10,-80,70,-150,220", //
      "250,10,240,-230,470,-700,1170,-1870" };

  public static void main(String[] args) {
    for (int i = 0; i < INPUTS.length; ++i) {
      final int m = INPUTS[i][0];
      final int n = INPUTS[i][1];
      final int p = INPUTS[i][2];
      System.out.println("M: " + m);
      System.out.println("N: " + n);
      System.out.println("P: " + p);
      System.out.println("Expected: " + OUTPUTS[i]);
      System.out.println("Actual:   " + new CounterFibonacciSequences().f(m, n, p));
      System.out.println();
    }
  }

  String f(int m, int n, int p) {
    return "" + m + (p > 1 ? "," + f(n, m - n, p - 1) : "");
  }
}
— Comunidad
fuente
1

AHK, 68 bytes

m=%1%
n=%2%
3-=2
Send %m%`n%n%`n
Loop,%3%
{
n:=m-n
m-=n
Send %n%`n
}

Conseguir' muy cansado de no saber / poder utilizar argumentos pasados ( %1%, %2%, ...) directamente en cualquiera de las funciones matemáticas

— Tostadas de ingeniero
fuente
1

Python 2 , 93 90 bytes

u,t=int,input;m,n,p=u(t()),u(t()),u(t());l=[m,n]
for i in range(p-2):l.append(l[-2]-l[-1])

Pruébalo en línea!

Guardado 3 bytes gracias a @ Mr.Xcoder

Funciona tomando los números como entrada y formateándolos correctamente, luego usando un bucle for para generar una lista basada en los números ingresados.

— Camarada SparklePony
fuente
Puede eliminar el espacio después de la coma en ese rango para ahorrar 1 byte
— Mr. Xcoder
Y puede ser más corto si asigna su entrada con ints y input.split
— Sr. Xcoder
@ Mr.Xcoder Probé la división, pero terminó siendo más larga.
— Camarada SparklePony
Ok, no pude probarlo. Está bien de todos modos.
— Sr. Xcoder
Y el rango no necesita el primer argumento
— Sr. Xcoder
0

Swift - 85 bytes

func y(x:Int,y:Int,z:Int){var m=x,n=y,p=z,c=0;for _ in 1...p{print(m);c=m;m=n;n=c-n}}

Uso: y(x:50,y:40,x:6)

Swift - 84 bytes

func z(l:[Int]){var m=l[0],n=l[1],p=l[2],c=0;for _ in 1...p{print(m);c=m;m=n;n=c-n}}

Uso: z(l: [50,40,6])

Salida:

50
40
10
30
-20
50
— Sr. Xcoder
fuente
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.