A sequência de Fibonacci é uma coisa bastante conhecida por aqui. Heck, ele ainda tem sua própria etiqueta. No entanto, por tudo isso, com certeza gostamos de manter nossas raízes 1, 1, ...(ou é 0, 1, ...? Talvez nunca saibamos ...). Neste desafio, as regras são as mesmas, mas, em vez de obter o nth item na sequência Fibonacci, você receberá o nth item na sequência Fibonacci-esque, começando com x, y, ....

Entrada

Três números inteiros, na ordem que você desejar. né o índice (0 ou 1 indexado) do termo na sequência para sua saída. xe ysão os dois primeiros itens na sequência Fibonacci da execução do programa atual.

Saída

O nth prazo na sequência de Fibonacci começando com x, y.

Casos de teste

(Indexado 0)

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

(Indexado 1)

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

Ressalvas

Suponha 0 <= x <= y.

Observe sua ordem de entrada (deve ser constante).

Gelatina , 3 bytes

+¡ạ

Toma x , y , e n (0-indexada) como argumentos de linha de comando separadas, em que ordem.

Experimente online!

Como 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~{_@+}*;

Experimente online!

O formato de entrada é "xy n". Eu ainda sou um novato nisso, então tenho 100% de certeza de que existem maneiras melhores de fazer isso, mas, por favor, em vez de me dizer "faça isso", tente apenas me dar dicas para que eu possa encontrar a resposta e obter Melhor. Obrigado!

Python 2 , 37 bytes

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

Experimente online!

Indexado a 0, pode ser necessário ajustar o limite de recursão para n≥999

JavaScript (ES6), 27 26 bytes

Nada sofisticado aqui, apenas uma função JS Fibonacci padrão com os valores iniciais de 0 e 1 removidos.

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

Tente

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
Experimente online

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

Experimente online! Indexado a 0. Use como (x#y)n, por exemplo, (0#1)5para o quinto elemento da sequência original.

A maneira mais provável de obter a sequência de Fibonacci em Haskell é a f=0:scanl(+)1fque define uma lista infinita que f=[0,1,1,2,3,5,8,...]contém a sequência. Substituindo 0e 1por argumentos xe yproduz a sequência customizada. (f!!)é então uma função retornando o 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

Experimente online!

Flak cerebral , 38 bytes

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

Experimente online!

{({}[()]<                      >)}     # 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

Ruby, 27 bytes

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

Gelatina , 6 bytes

;SḊµ¡I

Experimente online!

Explicação

   µ¡  - 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)Ė

Indexado 1

Intérprete

Explicação

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

Prolog (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,_).

Experimente online!

Começou a jogar a resposta de Leaky Nun e chegou a algo completamente diferente.

Este tem uma regra (Nᵗʰ, (N+1)ᵗʰ)em termos de ((N-1)ᵗʰ, Nᵗʰ)e usa gerenciamento de banco de dados para declarar elementos 0ˢᵗ e 1ˢᵗ em tempo de execução.

f(N,X,Y)significa Nᵗʰelemento é Xe (N+1)ᵗʰelemento é Y.

Oitava , 24 bytes

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

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

Experimente online!

Braingolf , 15 bytes

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

_; não é mais necessário na versão mais recente do Braingolf, no entanto, a partir de ~ 5 minutos atrás, seria incompatível.

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

Experimente online!

MATL , 7 bytes

:"wy+]x

A saída é baseada em 0.

Experimente no MATL Online!

Explicação

Deixe a entradas ser denotado n(índice), a, b(condições iniciais).

:"     % 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)

Uma função recursiva simples. Curiosamente, isso é mais curto do que qualquer coisa que eu possa criar para a sequência regular de Fibonacci (sem embutidos), porque isso não precisa ser atribuído 1a ambos xe y= P

Calcula os n+1números da sequência, incluindo os valores iniciais. Cada recursão é calculada com n-1e interrompida quando n==0. O menor dos dois números é retornado, retornando o n-ésimo valor.

dc , 36 bytes

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

Experimente online!

0-indexed. A entrada deve estar no formato n x y.

PHP> = 7.1, 55 bytes

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

Versão Online

PHP> = 7.1, 73 bytes

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

Versão Online

Lisp comum, 49 bytes, indexado 0

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

Eu sou um Lisp noob, então qualquer dica seria apreciada;)

Explicação:

(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

Prolog (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.

Experimente online!

Indexado a 0.

br ** nfuck, 39 29 bytes

Obrigado a @JoKing por -10!

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

O TIO não funcionará particularmente bem para isso (ou para qualquer solução BF para um problema que envolva números). Eu sugiro fortemente o EsotericIDE de Timwi (ou a implementação do BF você mesmo).

Leva x, então y, então n. Indexado a 0. Pressupõe uma fita sem limites ou envolvente.

Explicação

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

Experimente online!

Esta implementação é baseada em 0.

05AB1E , 9 bytes

`©GDŠ+}®@

Experimente online!

Explicação

`           # 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-Indexed

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

Try it online!

Klein, 18 + 3 bytes

This uses the 000 topology

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

Pass input in the form x y n.

Axiom, 88 57 bytes

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

this would pass the test proposed (0 indexed)

(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

Try it online!

0-based, takes x y n separated by space. Calculates in unary.

TI-Basic, 32 bytes

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