La sequenza di Fibonacci è abbastanza conosciuta qui. Diamine, ha anche il suo tag. Tuttavia, nonostante tutto, ci piace sicuramente attenerci alle nostre radici di 1, 1, ...(o è 0, 1, ...? Potremmo non saperlo mai ...). In questa sfida, le regole sono le stesse, ma invece di ottenere l' noggetto th nella sequenza di Fibonacci, otterrai l' noggetto th nella sequenza di Fibonacci a partire da x, y, ....

Ingresso

Tre numeri interi, nell'ordine che desideri. nè l'indice (0 o 1 indicizzato) del termine nella sequenza per l'output. xe ysono i primi due elementi nella sequenza Fibonacci del tuo programma attuale.

Produzione

La nesimo termine della sequenza di Fibonacci iniziano x, y.

Casi test

(0-indicizzati)

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

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

Avvertenze

Assumere 0 <= x <= y.

Si prega di notare l'ordine di input (deve essere costante).

Gelatina , 3 byte

+¡ạ

Accetta x , y e n (indicizzati 0) come argomenti della riga di comando separati, in questo ordine.

Provalo online!

Come funziona

+¡ạ  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 byte

l~{_@+}*;

Provalo online!

Il formato di input è "xy n". Sono ancora un noob in questo, quindi sono sicuro al 100% che ci sono modi migliori per farlo, ma per favore invece di dirmi "fai questo" prova solo a darmi suggerimenti in modo che io possa trovare la risposta da solo e ottenere meglio. Grazie!

Python 2 , 37 byte

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

Provalo online!

0 indicizzato, potrebbe essere necessario regolare il limite di ricorsione per n≥999

JavaScript (ES6), 27 26 byte

Niente di speciale qui, solo una funzione JS Fibonacci standard con i valori iniziali di 0 e 1 rimossi.

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

Provalo

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 byte

0 indicizzato
Provalo online

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

Haskell , 30 byte

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

Provalo online! 0-indicizzati. Utilizzare come (x#y)n, ad es. (0#1)5Per il quinto elemento della sequenza originale.

Il modo più probabile per ottenere la sequenza di Fibonacci in Haskell è f=0:scanl(+)1f, che definisce un elenco infinito f=[0,1,1,2,3,5,8,...]contenente la sequenza. Sostituendo 0e 1con argomenti xe yrestituisce la sequenza personalizzata. (f!!)è quindi una funzione che restituisce l'ennesimo elemento di f.

Mathematica, 36 byte

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

ingresso

[N, x, y]

PowerShell , 40 byte

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

Provalo online!

Brain-Flak , 38 byte

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

Provalo 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

Rubino, 27 byte

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

Gelatina , 6 byte

;SḊµ¡I

Provalo online!

Spiegazione

   µ¡  - 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 byte

ēB)Ė

1 indicizzati

Interprete

Spiegazione

Ingresso preso come 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 byte

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

Provalo online!

Ha iniziato a giocare a golf la risposta di Leaky Nun ed è arrivato a qualcosa di completamente diverso.

Questo ha una regola (Nᵗʰ, (N+1)ᵗʰ)in termini di ((N-1)ᵗʰ, Nᵗʰ)e utilizza la gestione del database per affermare elementi 0ᵗʰ e 1ˢᵗ in fase di esecuzione.

f(N,X,Y)significa che l' Nᵗʰelemento è Xe l' (N+1)ᵗʰelemento è Y.

Ottava , 24 byte

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

Formato di input: n,[x,y].

Provalo online!

Braingolf , 15 byte

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

_; non è più necessario sull'ultima versione di Braingolf, tuttavia è di circa 5 minuti fa, quindi non competere.

Python 2 , 112 byte

1-indicizzati.

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

Provalo online!

MATL , 7 byte

:"wy+]x

L'output è basato su 0.

Provalo su MATL Online!

Spiegazione

Lasciare gli ingressi sono denominate n(index), a, b(condizioni iniziali).

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

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

Una semplice funzione ricorsiva. Stranamente, questo è più breve di qualsiasi cosa mi venga in mente per la normale sequenza di Fibonacci (senza built-in), perché questo non deve assegnare1 a entrambix ey = P

Calcola i n+1numeri della sequenza, inclusi i valori iniziali. Ogni ricorsione viene calcolata con n-1e interrotta quando n==0. Viene quindi restituito il più basso dei due numeri, restituendo il nvalore -th.

dc , 36 byte

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

Provalo online!

0-indexed. L'input deve essere nel formato n x y.

PHP> = 7,1, 55 byte

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

Versione online

PHP> = 7.1, 73 byte

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

Versione online

Lisp comune, 49 byte, indicizzato 0

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

Sono un nipote di Lisp quindi qualsiasi consiglio sarebbe apprezzato;)

Spiegazione:

(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 byte

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.

Provalo online!

0-indicizzati.

br ** nfuck, 39 29 byte

Grazie a @JoKing per -10!

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

TIO non funzionerà particolarmente bene per questo (o per qualsiasi soluzione BF a un problema che coinvolge numeri). Consiglio vivamente EsotericIDE di @Timwi (o implementando BF da soli).

Prende x, quindi y, quindin . 0-indicizzati. Presuppone un nastro illimitato o avvolgente.

Spiegazione

,<,<,            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 byte

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

Provalo online!

Questa implementazione è basata su 0.

05AB1E , 9 byte

`©GDŠ+}®@

Provalo online!

Spiegazione

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

0-indicizzato

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

Provalo online!

Klein , 18 + 3 byte

Questo utilizza la 000topologia

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

Passa l'input nel modulo x y n.

Axiom, 88 57 byte

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

questo supererebbe il test proposto (0 indicizzato)

(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 byte

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

1

Provalo online!

Basato su 0, prende x y nseparato dallo spazio. Calcola in unario.

TI-Basic, 32 byte

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