Hice mi propia secuencia recientemente (llamada secuencia Piggyback), y funciona así:

P(1), P(2)Y P(3)= 1.

Para todos los P(n)lugares n>3, la secuencia funciona así:

P(n) = P(n-3) + P(n-2)/P(n-1)

Entonces, continuando la secuencia:

P(4)= 1 + 1/1=2

P(5)= 1 + 1/2= 3/2 =1.5

P(6)= 1 + 2/(3/2)= 7/3 =2.33333...

P(7)= 2 + (3/2)/(7/3)= 37/14=2.6428571428...

P(8)= 3/2 + (7/3)/(37/14)= 529/222 =2.3828828828...

Su tarea es, cuando se le da n, calcular P(n)como un número de coma flotante o como una fracción (im) adecuada.

Este es el código de golf , por lo que gana el código más corto en bytes.

Si alguien puede encontrar el nombre de la secuencia, edite la publicación en consecuencia.

Líderes actuales: MATL y Jelly (ambos a 15 bytes).

Python 2, 40 39 bytes.

f=lambda x:x<4or.0+f(x-3)+f(x-2)/f(x-1)

Da en Truelugar de 1, si esto no está permitido, podemos tener esto para 42 bytes:

f=lambda x:.0+(x<4or f(x-3)+f(x-2)/f(x-1))

La forma en que funciona es bastante sencilla, el único truco es usar .0+para lanzar el resultado a un flotador.

Haskel, 32 bytes

(a#b)c=a:(b#c)(a+b/c)
((0#1)1!!)

Ejemplo de uso: ((0#1)1!!) 7-> 2.642857142857143. Comienzo la secuencia con 0, 1, 1para arreglar !!la indexación basada en 0.

Editar: @xnor encontró una manera de cambiar del índice basado en 0 a 1, sin cambiar el recuento de bytes.

Ruby, 34 bytes

Como Ruby usa la división entera por defecto, resulta que es más corto usar fracciones en su lugar. Sugerencias de golf bienvenidas.

f=->n{n<4?1r:f[n-3]+f[n-2]/f[n-1]}

Perl 6 ,  25  23 bytes

{(0,1,1,1,*+*/*...*)[$_]}

{(0,1,1,*+*/*...*)[$_]}

Explicación:

# bare block lambda with implicit parameter ｢$_｣
{
  (
    # initial set-up
    # the ｢0｣ is for P(0) which isn't defined
    0, 1, 1, 1,

    # Whatever lambda implementing the algorithm
    * + * / *
    # { $^a + $^b / $^c }

    # keep using the lambda to generate new values until
    ...

    # Whatever (Forever)
    *

   # get the value indexed by the argument
  )[ $_ ]
}

Esto devuelve una Rata ( Racional ) para las entradas que comienzan con 3 hasta que el resultado comience a tener un denominador más grande que el que puede caber en un entero de 64 bits, en cuyo punto comienza a devolver Num s (punto flotante).
La última rata que devolverá esP(11) == 8832072277617 / 2586200337022

Si desea que devuelva números racionales en lugar de flotantes, puede cambiarlo por el siguiente, que en su lugar devolverá un FatRat .

{(0.FatRat,1,1,*+*/*...*)[$_]}

Prueba:

#! /usr/bin/env perl6
use v6.c;
use Test;

my &piggyback = {(0,1,1,*+*/*...*)[$_]}
# */ # stupid highlighter no Perl will ever have C/C++ comments

my @test = (
  1, 1, 1, 2,
  3/2, 7/3, 37/14,
  529 / 222,
  38242 / 11109,
  66065507 / 19809356,
  8832072277617 / 2586200337022,
);

plan +@test;

for 1..* Z @test -> ($input,$expected) {
  cmp-ok piggyback($input), &[==], $expected, $expected.perl;
}

C, 46 bytes

float P(n){return n<4?1:P(n-3)+P(n-2)/P(n-1);}

Ideona

MATL , 15 bytes

llli3-:"3$t/+]&

Pruébalo en línea!

Explicación

lll       % Push 1, 1, 1
i         % Take input n
3-:       % Pop n and push range [1 2 ... n-3] (empty if n<4)
"         % For each
  3$t     %    Duplicate the top three numbers in the stack
  /       %    Pop the top two numbers and push their division
  +       %    Pop the top two numbers and push their addition
]         % End
&         % Specify that the next function, which is implicit display, will take
          % only one input. So the top of the stack is displayed

Cheddar , 31 bytes

n P->n<4?1:P(n-3)+P(n-2)/P(n-1)

La versión sin golf es tan clara que no necesitas explicación:

n P->
  n < 4 ? 1 : P(n-3) + P(n-2) / P(n-1)

básicamente, después de los argumentos de la función, puede especificar la variable a utilizar que se establecerá en la función misma. ¿Por qué? porque esta función será optimizada para cola, o al menos debería serlo.

Javascript (ES6), 31 bytes

P=n=>n<4?1:P(n-3)+P(n-2)/P(n-1)

Una función simple

P=n=>n<4?1:P(n-3)+P(n-2)/P(n-1)

var out = '';

for (var i=1;i <= 20;i++) {
out +='<strong>'+i+':</strong> '+P(i)+'<br/>';
}

document.getElementById('text').innerHTML = out;

div {
font-family: Arial
}

<div id="text"></div>

05AB1E , 18 17 bytes

3Ld                # push list [1,1,1]
   ¹ÍG         }   # input-3 times do
      D3£          # duplicate list and take first 3 elements of the copy
         R`        # reverse and flatten
           /+      # divide then add
             ¸ì    # wrap in list and prepend to full list
                ¬  # get first element and implicitly print

Pruébalo en línea!

Guardado 1 byte gracias a Luis Mendo

Pyth, 20 bytes

L?<b4h0+y-b3cy-b2ytb

Pruébalo en línea!

Jalea , 15 bytes

ạ2,1,3߀÷2/SµḊ¡

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

ạ2,1,3߀÷2/SµḊ¡  Main link. Argument: n (integer)

             Ḋ   Dequeue; yield [2, ..., n].
            µ ¡  If the range is non-empty (i.e., if n > 1), execute the chain to
                 the left. If n is 0 or 1, return n.
                 Note that P(3) = P(0) + P(2)/P(1) if we define P(0) := 0.
ạ2,1,3           Take the absolute difference of n and 2, 1, and 3.
                 This gives [0, 1, 1] if n = 2, and P(0) + P(1)/P(1) = 0 + 1/1 = 1.
      ߀         Recursively apply the main each to each difference.
        ÷2/      Perform pairwise division.
                 This maps [P(n-2), P(n-1), P(n-3)] to [P(n-2)/P(n-1), P(n-3)].
           S     Sum, yielding P(n-2)/P(n-1) + P(n-3).

R, 53 47 bytes

f=function(N)ifelse(N>3,f(N-3)+f(N-2)/f(N-1),1)

Esta respuesta hizo uso de la bonita función ifelse:ifelse(Condition, WhatToDoIfTrue, WhatToDoIfNot)

Mathematica, 36 bytes

P@n_:=If[n<4,1,P[n-3]+P[n-2]/P[n-1]]

Aquí están los primeros términos:

P /@ Range[10]
{1, 1, 1, 2, 3/2, 7/3, 37/14, 529/222, 38242/11109, 66065507/19809356}

Dyalog APL, 25 bytes

⊃{1↓⍵,⍎⍕' +÷',¨⍵}⍣⎕⊢0 1 1