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

— Stephen
fuente

¿Podemos tomar una lista como entrada?

— Business Cat

@BusinessCat quieres decir como [1, 2, 3]? Sí. Lo que sea necesario para aceptar 3 enteros.

— Stephen

@StephenS ¿Qué hay de tomar una entrada como n,[x,y]cuando nes un número y xe yson números en una lista? Sin embargo, probablemente sea demasiado flexible;)

— Tom

1

@ CAD97 Los agregaré, me había olvidado de ellos :)

— Stephen

1

Relacionado

— xnor

15

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.

— Dennis
fuente

11

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!

— FrodCube
fuente

1

riririse puede acortar a 2 bytes. fIse puede acortar a 1 byte.

— Dennis

66

Bienvenido a PPCG!

— Martin Ender

@Dennis mejorado! ¡Gracias! Y gracias por la bienvenida.

— FrodCube

9

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

— ovs
fuente

9

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>

Expandir fragmento

— Lanudo
fuente

6

Python 2, 40 bytes

0 indexado
Pruébelo en línea

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

— Zarigüeya muerta
fuente

Jaja no está sujeto a un límite de recursión / pila a diferencia de otras respuestas. Buen truco.

— ShreevatsaR

@ShreevatsaR ¡Gracias! Pero la lambda recursiva me gana de todos modos: D

— Dead Possum

5

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.

— Laikoni
fuente

5

Mathematica, 36 bytes

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

entrada

[n, x, y]

— J42161217
fuente

1

Puedes usar en ##2lugar de #2,#3.

— alephalpha

¡muy agradable! ¡fijo!

— J42161217

5

PowerShell , 40 bytes

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

Pruébalo en línea!

— Nik Weiss
fuente

4

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

— Riley
fuente

4

Rubí, 27 bytes

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

— GB
fuente

3

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.

— fireflame241
fuente

3

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

— Tom
fuente

3

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.

— eush77
fuente

3

Octava , 24 bytes

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

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

Pruébalo en línea!

— alephalpha
fuente

2

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.

— Skidsdev
fuente

2

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!

— totalmente humano
fuente

Erp, demasiado tarde y demasiado grande.

— totalmente humano

2

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

— Luis Mendo
fuente

2

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.

— JAD
fuente

2

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.

— R. Kap
fuente

2

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

— Jörg Hülsermann
fuente

1

Aprovechando orden de evaluación extraña de PHP: $y=+$x+$x=$y. Además, puede usar solo en $n--lugar de $i++<$n.

— user63956

2

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

— Bolce Bussiere
fuente

2

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.

— Monja permeable
fuente

¿Podrías editar esta respuesta? Parece que accidentalmente lo rechacé el día que lo publicaste.

— Esolanging Fruit

@EsolangingFruit done

— Leaky Nun

2

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

— Khuldraeseth na'Barya
fuente

¿Por qué te molestas en mover x e y cuando puedes mover n? Pruébelo en línea

— Jo King

@JoKing lo consideró (pero más tiempo por mi cuenta), pero no funciona del todo, a menos que OP permita la " -1indexación".

— Khuldraeseth na'Barya

Oh, solo agregue una >al final o cambie la orden x e y

— Jo King

@JoKing Mi palma golpeó mi cara con bastante fuerza en este momento. ¡Gracias!

— Khuldraeseth na'Barya

¿Por qué te molestaste en censurar "cerebro" pero no la segunda palabra en el nombre del lenguaje de programación?

— MilkyWay90

2

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.

— PikalaxALT
fuente

Bien, y bienvenido! Aquí hay una configuración de TIO más bonita para las pruebas, en caso de que elija usarla.

— Khuldraeseth na'Barya

1

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

— Emigna
fuente

1

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!

— Felipe Nardi Batista
fuente

1

Klein , 18 + 3 bytes

Esto usa la 000topología

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

Pase de entrada en el formulario x y n.

— Asistente de trigo
fuente

1

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

— RosLuP
fuente

1

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.

— eush77
fuente

1

TI-Basic, 32 bytes

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

— pizzapants184
fuente

Golf una secuencia de Fibonacci personalizada

Entrada

Salida

Casos de prueba

Advertencias

Jalea , 3 bytes

Cómo funciona

CJam , 14 9 bytes

Python 2 , 37 bytes

JavaScript (ES6), 27 26 bytes

Intentalo

Python 2, 40 bytes

Haskell , 30 bytes

Mathematica, 36 bytes

PowerShell , 40 bytes

Brain-Flak , 38 bytes

Rubí, 27 bytes

Jalea , 6 bytes

TAESGL , 4 bytes

Prólogo (SWI) , 77 bytes

Octava , 24 bytes

Braingolf , 15 bytes

Python 2 , 112 bytes

MATL , 7 bytes

Explicación

R, 39 bytes

cc , 36 bytes

PHP> = 7.1, 55 bytes

PHP> = 7.1, 73 bytes

Lisp común, 49 bytes, indexado 0

Explicación:

Prólogo (SWI) , 85 bytes

br ** nfuck, 39 29 bytes

Explicación

C (gcc) , 29 bytes

05AB1E , 9 bytes

Lua , 44 bytes

Klein , 18 + 3 bytes

Axioma, 88 57 bytes

Retina , 37 bytes

TI-Basic, 32 bytes