La secuencia de Fibonacci es una cosa bastante conocida por aquí. Diablos, incluso tiene su propia etiqueta. Sin embargo, por todo eso, seguro que nos gusta mantenernos en nuestras raíces 1, 1, ...(¿o no 0, 1, ...? Puede que nunca lo sepamos ...). En este desafío, las reglas son las mismas, pero en lugar de obtener el nelemento th en la secuencia de Fibonacci, comenzará con el nelemento th en la secuencia de estilo Fibonacci x, y, ....

Entrada

Tres enteros, en el orden que quieras. nes el índice (0 o 1 indexado) del término en la secuencia para su salida. xy yson los dos primeros elementos en la secuencia de Fibonacci de la ejecución de su programa actual.

Salida

El nésimo término de la sucesión de Fibonacci comenzando con x, y.

Casos de prueba

(0 indexado)

n   x     y     out
5   0     0     0
6   0     1     8
6   1     1     13
2   5     5     10
10  2     2     178
3   3     10    23
13  2308  4261  1325165
0   0     1     0
1   0     1     1

(1 indexado)

n   x     y     out
6   0     0     0
7   0     1     8
7   1     1     13
3   5     5     10
11  2     2     178
4   3     10    23
14  2308  4261  1325165
1   0     1     0
2   0     1     1

Advertencias

Asumir 0 <= x <= y.

Tenga en cuenta su orden de entrada (debe ser constante).

Jalea , 3 bytes

+¡ạ

Toma x , y , yn (indexados a 0) como argumentos separados de la línea de comandos, en ese orden.

Pruébalo en línea!

Cómo funciona

+¡ạ  Main link. Left argument: x. Right argument: y. Third argument: n

  ạ  Yield abs(x - y) = y - x, the (-1)-th value of the Lucas sequence.
+¡   Add the quicklink's left and right argument (initially x and y-x), replacing
     the right argument with the left one and the left argument with the result.
     Do this n times and return the final value of the left argument.

CJam , 14 9 bytes

l~{_@+}*;

Pruébalo en línea!

El formato de entrada es "xy n". Todavía soy un novato en esto, así que estoy 100% seguro de que hay mejores formas de hacerlo, pero por favor, en lugar de decirme "haz esto", trata de darme pistas para que pueda encontrar la respuesta yo mismo y obtener mejor. ¡Gracias!

Python 2 , 37 bytes

f=lambda x,y,n:n and f(y,x+y,n-1)or x

Pruébalo en línea!

Indexado a 0, es posible que deba ajustar el límite de recursión para n≥999

JavaScript (ES6), 27 26 bytes

No hay nada lujoso aquí, solo una función estándar de JS Fibonacci con los valores iniciales de 0 y 1 eliminados.

n=>g=(x,y)=>n--?g(y,x+y):x

Intentalo

f=
n=>g=(x,y)=>n--?g(y,x+y):x
o.value=f(i.value=13)(j.value=2308,k.value=4261)
oninput=_=>o.value=f(+i.value)(+j.value,+k.value)

*{font-family:sans-serif;}
input{margin:0 5px 0 0;width:50px;}
#o{width:75px;}

<label for=i>n: </label><input id=i type=number><label for=j>x: </label><input id=j type=number><label for=k>y: </label><input id=k type=number><label for=o>= </label><input id=o>

Python 2, 40 bytes

0 indexado
Pruébelo en línea

n,a,b=input()
exec'a,b=b,a+b;'*n
print a

Haskell , 30 bytes

x#y=(f!!)where f=x:scanl(+)y f

Pruébalo en línea! 0 indexado. Use como (x#y)n, por ejemplo, (0#1)5para el quinto elemento de la secuencia original.

La forma más corta más probable de obtener la secuencia de Fibonacci en Haskell es f=0:scanl(+)1f, que define una lista infinita que f=[0,1,1,2,3,5,8,...]contiene la secuencia. Reemplazar 0y 1con argumentos xy yproduce la secuencia personalizada. (f!!)es entonces una función que devuelve el enésimo elemento de f.

Mathematica, 36 bytes

LinearRecurrence[{1,1},{##2},{#+1}]&

entrada

[n, x, y]

PowerShell , 40 bytes

$n,$x,$y=$args;2..$n|%{$y=$x+($x=$y)};$y

Pruébalo en línea!

Brain-Flak , 38 bytes

{({}[()]<(({}<>)<>{}<(<>{}<>)>)>)}{}{}

Pruébalo en línea!

{({}[()]<                      >)}     # For n .. 0
         (({}<>)<>            )        # Copy TOS to the other stack and add it to...
                  {}                   # The second value
                    <(<>{}<>)>         # Copy what was TOS back
                                  {}{} # Pop the counter and the n+1th result

Rubí, 27 bytes

->a,b,n{n.times{b=a+a=b};a}

Jalea , 6 bytes

;SḊµ¡I

Pruébalo en línea!

Explicación

   µ¡  - repeat n times (computes the n+1th and n+2th element):
 S     -  take the sum of the elements of the previous iteration (starting at (x,y))
;      -  append to the end of the previous iteration
  Ḋ    -  remove the first element
     I - Take the difference of the n+1th and n+2th to get the n-th.

TAESGL , 4 bytes

ēB)Ė

1 indexado

Interprete

Explicación

Entrada tomada como n,[x,y]

 ēB)Ė
AēB)     get implicit input "A" Fibonacci numbers where "B" is [x,y]
    Ė    pop the last item in the array

Prólogo (SWI) , 77 bytes

f(N,Y,Z):-M is N-1,f(M,X,Y),Z is X+Y.
l(N,A,B,X):-asserta(f(0,A,B)),f(N,X,_).

Pruébalo en línea!

Comenzó jugando al golf la respuesta de Leaky Nun y llegó a algo completamente diferente.

Este tiene una regla (Nᵗʰ, (N+1)ᵗʰ)en términos de ((N-1)ᵗʰ, Nᵗʰ)y usa la administración de bases de datos para afirmar elementos 0ᵗʰ y 1ˢᵗ en tiempo de ejecución.

f(N,X,Y)significa Nᵗʰelemento es Xy (N+1)ᵗʰelemento es Y.

Octava , 24 bytes

@(n,x)(x*[0,1;1,1]^n)(1)

Formato de entrada: n,[x,y].

Pruébalo en línea!

Braingolf , 15 bytes

VR<2-M[R!+v]R_;

_; ya no es necesario en la última versión de Braingolf, sin embargo, eso fue hace unos 5 minutos, por lo que no competiría.

Python 2 , 112 bytes

1 indexado.

import itertools
def f(x,y):
 while 1:yield x;x,y=y,x+y
def g(x,y,n):return next(itertools.islice(f(x,y),n-1,n))

Pruébalo en línea!

MATL , 7 bytes

:"wy+]x

La salida está basada en 0.

¡Pruébalo en MATL Online!

Explicación

Dejar que el denotarán entradas n(índice), a, b(condiciones iniciales).

:"     % Implicitly input n. Do this n times
       %   At this point in each iteration, the stack contains the two most
       %   recently computed terms of the sequence, say s, t. In the first
       %   iteration the stack is empty, but a, b will be implicitly input
       %   by the next statement
  w    %   Swap. The stack contains t, s
  y    %   Duplicate from below. The stack contains t, s, t
  +    %   Add. The stack contains t, s+t. These are now the new two most
       %   recently comnputed terms
]      % End
x      % Delete (we have computed one term too many). Implicitly display

R, 39 bytes

f=function(x,y,n)'if'(n,f(y,x+y,n-1),x)

Una simple función recursiva. Curiosamente, esto es más corto que cualquier cosa que se me ocurra para la secuencia regular de Fibonacci (sin elementos integrados), porque esto no tiene que asignarse 1a ambos xy y= P

Calcula los n+1números de la secuencia, incluidos los valores iniciales. Cada recursión se calcula con n-1y se detiene cuando n==0. Luego se devuelve el menor de los dos números, devolviendo el nvalor -th.

cc , 36 bytes

?sdsbsa[lddlb+sdsbla1-dsa1<c]dscxldp

Pruébalo en línea!

0-indexado. La entrada debe estar en el formato n x y.

PHP> = 7.1, 55 bytes

for([,$n,$x,$y]=$argv;$n--;$x=$y,$y=$t)$t=$x+$y;echo$x;

Versión en línea

PHP> = 7.1, 73 bytes

for([,$n,$x,$y]=$argv,$r=[$x,$y];$i<$n;)$r[]=$r[+$i]+$r[++$i];echo$r[$n];

Versión en línea

Lisp común, 49 bytes, indexado 0

(defun fib(n x y)(if(= 0 n)x(fib(1- n)y(+ x y))))

Soy un novato de Lisp, por lo que cualquier consejo sería apreciado;)

Explicación:

(defun fib(n x y)                                  | Define a function taking 3 arguments
                 (if(= 0 n)x                       | If n = 0, return x
                            (fib(1- n)y(+ x y))))  | Otherwise, call fib with n-1, y, and x+y

Prólogo (SWI) , 85 bytes

l(0,X,Y,X).
l(1,X,Y,Y).
l(N,X,Y,C):-M is N-1,P is N-2,l(M,X,Y,A),l(P,X,Y,B),C is A+B.

Pruébalo en línea!

0 indexado.

br ** nfuck, 39 29 bytes

¡Gracias a @JoKing por -10!

,<,<,[>[>+>+<<-]<[>+<-]>-]>>.

TIO no funcionará particularmente bien para esto (o para cualquier solución BF a un problema que involucra números). Recomiendo encarecidamente EsotericIDE de @ Timwi (o implementar BF usted mismo).

Toma x, entonces y, entonces n. 0 indexado. Asume una cinta sin límites o envolvente.

Explicación

,<,<,            Take inputs. Tape: [n, y, x]
[                While n:
  > [->+>+<<]      Add y to x, copying it to the next cell along as well. Tape: [n, 0, x+y, y]
  < [>+<-]         Move n over. Tape: [0, n, x+y, y]
  >-               Decrement n.
] >>.            End loop. Print cell 2 to the right (x for n == 0).

C (gcc) , 29 bytes

f(n,x,y){n=n?f(n-1,y,x+y):x;}

Pruébalo en línea!

Esta implementación está basada en 0.

05AB1E , 9 bytes

`©GDŠ+}®@

Pruébalo en línea!

Explicación

`           # split inputs as separate to stack
 ©          # store n in register
  G         # n-1 times do
   D        # duplicate top of stack
    Š       # move down 2 places on stack
     +      # add top 2 values of stack
      }     # end loop
       ®@   # get the value nth value from the bottom of stack

Lua , 44 bytes

0-indexado

n,x,y=...for i=1,n do
x,y=y,x+y
end
print(x)

Pruébalo en línea!

Klein , 18 + 3 bytes

Esto usa la 000topología

:?\(:(+)$)1-+
((/@

Pase de entrada en el formulario x y n.

Axioma, 88 57 bytes

f(k,x,y)==(repeat(k<=0=>break;c:=y;y:=x+y;x:=c;k:=k-1);x)

esto pasaría la prueba propuesta (0 indexado)

(14) -> f(5,0,0)
   (14)  0
                                                 Type: NonNegativeInteger
(15) -> f(6,0,1)
   (15)  8
                                                    Type: PositiveInteger
(16) -> f(2,5,5)
   (16)  10
                                                    Type: PositiveInteger
(17) -> f(10,2,2)
   (17)  178
                                                    Type: PositiveInteger
(18) -> f(3,3,10)
   (18)  23
                                                    Type: PositiveInteger
(19) -> f(13,2308,4261)
   (19)  1325165
                                                    Type: PositiveInteger

Retina , 37 bytes

\d+
$*1
+`(1*) (1*) 1
$2 $1$2 
 .*

1

Pruébalo en línea!

Basado en 0, toma x y nseparado por espacio. Calcula en unario.

TI-Basic, 32 bytes

Prompt N,X,Y
While N
X+Y➡Z
Y➡X
Z➡Y
DS<(N,0
End
X