La séquence de Fibonacci est une chose assez bien connue ici. Heck, il a même sa propre étiquette. Cependant, pour autant, nous aimons bien nous en tenir à nos racines 1, 1, ...(ou est-ce 0, 1, ...? Nous ne le saurons peut-être jamais ...). Dans ce défi, les règles sont les mêmes, mais au lieu d'obtenir le ne élément de la séquence de Fibonacci, vous obtiendrez le ne élément de la séquence de Fibonacci en commençant par x, y, ....

Contribution

Trois entiers, dans l'ordre que vous souhaitez. nest l'index (0 ou 1 indexé) du terme dans la séquence de votre sortie. xet ysont les deux premiers éléments de la séquence Fibonacci de votre exécution de programme actuelle.

Sortie

Le nème terme de la suite de Fibonacci à partir de x, y.

Cas de test

(Indexé 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

(1 index)

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

Avertissements

Supposons 0 <= x <= y.

Veuillez noter votre commande d'entrée (doit être constante).

Gelée , 3 octets

+¡ạ

Prend x , y et n (indexés 0) comme arguments de ligne de commande distincts, dans cet ordre.

Essayez-le en ligne!

Comment ça marche

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

l~{_@+}*;

Essayez-le en ligne!

Le format d'entrée est "xy n". Je suis toujours un noob à ce sujet, donc je suis sûr à 100% qu'il y a de meilleures façons de le faire, mais s'il vous plaît au lieu de me dire "faites ceci" essayez de ne me donner que des indices afin que je puisse trouver la réponse moi-même et obtenir mieux. Merci!

Python 2 , 37 octets

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

Essayez-le en ligne!

0 indexé, vous devrez peut-être ajuster la limite de récursivité pour n≥999

JavaScript (ES6), 27 26 octets

Rien d'extraordinaire ici, juste une fonction JS Fibonacci standard avec les valeurs initiales de 0 et 1 supprimées.

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

Essayez-le

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 octets

0 indexé
Essayez-le en ligne

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

Haskell , 30 octets

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

Essayez-le en ligne! 0 indexé. Utilisez as (x#y)n, par exemple (0#1)5pour le cinquième élément de la séquence d'origine.

Le moyen le plus court probablement d'obtenir la séquence de Fibonacci dans Haskell est de f=0:scanl(+)1fdéfinir une liste infinie f=[0,1,1,2,3,5,8,...]contenant la séquence. Remplacer 0et 1par des arguments xet ydonne la séquence personnalisée. (f!!)est alors une fonction renvoyant le nième élément de f.

Mathematica, 36 octets

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

contribution

[n, x, y]

PowerShell , 40 octets

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

Essayez-le en ligne!

Brain-Flak , 38 octets

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

Essayez-le en ligne!

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

Rubis, 27 octets

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

Gelée , 6 octets

;SḊµ¡I

Essayez-le en ligne!

Explication

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

ēB)Ė

1 indexé

Interprète

Explication

Entrée prise comme 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 octets

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

Essayez-le en ligne!

Commencé à jouer au golf avec la réponse de Leaky Nun et est arrivé à quelque chose de complètement différent.

Celui-ci a une règle pour (Nᵗʰ, (N+1)ᵗʰ) en termes de ((N-1)ᵗʰ, Nᵗʰ)et utilise la gestion de base de données pour AFFIRMER 0ᵗʰ et 1ˢᵗ éléments lors de l' exécution.

f(N,X,Y)signifie que l' Nᵗʰélément est Xet que l' (N+1)ᵗʰélément est Y.

Octave , 24 octets

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

Format d'entrée: n,[x,y] .

Essayez-le en ligne!

Braingolf , 15 octets

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

_; n'est plus nécessaire sur la dernière version de Braingolf, mais il y a environ 5 minutes, il n'y aurait donc pas de concurrence.

Python 2 , 112 octets

1 indexé.

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

Essayez-le en ligne!

MATL , 7 octets

:"wy+]x

La sortie est basée sur 0.

Essayez-le à MATL Online!

Explication

Laissez les entrées Désignons n(index), a, b(conditions initiales).

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

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

Une fonction récursive simple. Curieusement, c'est plus court que tout ce que je peux trouver pour la séquence Fibonacci régulière (sans intégré), car cela n'a pas à être assigné 1aux deux xet y= P

Calcule les n+1nombres de la séquence, y compris les valeurs initiales. Chaque récursivité est calculée avec n-1et arrêtée quand n==0. Le plus petit des deux nombres est ensuite renvoyé, donnant la nvaleur -th.

dc , 36 octets

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

Essayez-le en ligne!

0-indexé. L'entrée doit être au format n x y.

PHP> = 7.1, 55 octets

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

Version en ligne

PHP> = 7.1, 73 octets

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

Version en ligne

Lisp commun, 49 octets, indexé 0

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

Je suis un Noob Lisp donc tous les conseils seraient appréciés;)

Explication:

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

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.

Essayez-le en ligne!

0 indexé.

br ** nfuck, 39 29 octets

Merci à @JoKing pour -10!

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

TIO ne fonctionnera pas particulièrement bien pour cela (ou pour toute solution BF à un problème impliquant des nombres). Je suggère fortement @ Timwi EsotericIDE (ou l'implémentation de BF vous-même).

Prend x, puisy , alors n. 0 indexé. Suppose une bande sans limite ou enveloppante.

Explication

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

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

Essayez-le en ligne!

Cette implémentation est basée sur 0.

05AB1E , 9 octets

`©GDŠ+}®@

Essayez-le en ligne!

Explication

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

0 indexé

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

Essayez-le en ligne!

Klein , 18 + 3 octets

Cela utilise la 000topologie

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

Passez la saisie dans le formulaire x y n.

Axiome, 88 57 octets

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

cela passerait le test proposé (0 indexé)

(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

Rétine , 37 octets

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

1

Essayez-le en ligne!

Basé sur 0, prend x y nséparé par l'espace. Calcule en unaire.

TI-Basic, 32 octets

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