La secuencia de lengüeta

14

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

clismique
fuente
¿Podemos comenzar en el índice 0? P(0)=1...
nimi
3
¿Puedo preguntar la razón detrás del nombre que le dio a esta secuencia?
John Dvorak
@ JanDvorak Parece que los números están "superpuestos" entre sí.
clismique
@nimi Sí, estás permitido.
clismique

Respuestas:

6

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.

Loovjo
fuente
Puede guardar un byte eliminando el espacio entre x<4yor
acrolith
En Python 2, puedes usar f(x-1.)para lanzar para flotar. En Python 3, no necesitas lanzar nada.
Dennis
5

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.

nimi
fuente
1
Buen método para superar la definición recursiva directa. Creo que puede cambiar a 1 indexado inicializando (0,1,1).
xnor
4

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]}
Sherlock9
fuente
4

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;
}
Brad Gilbert b2gills
fuente
3

C, 46 bytes

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

Ideona

Betseg
fuente
3

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
Luis Mendo
fuente
2

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.

Downgoat
fuente
2

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>

Decaimiento Beta
fuente
¿Por qué no ES6? Ahorra una tonelada métrica de bytes.
Ismael Miguel
Así:P=n=>n<4?1:P(n-3)+P(n-2)/P(n-1)
Ismael Miguel
@IsmaelMiguel Gracias. Francamente, no tengo idea de la diferencia entre los diferentes Javascripts: D
Beta Decay
Para su ventaja, en la mayoría de los desafíos, solo necesita conocer la "notación Big Arrow", que le permite crear funciones sin usar la palabra clave function. El bit P=n=>[...]está creando una función anónima que toma 1 parámetro (n). Además, en ES6, los retornos son implícitos. Entonces, P=n=>5es una función que siempre regresa 5. Solo necesita encerrar el cuerpo {}si tiene más de una declaración (Ej P=n=>{alert(1);console.log(1)}. :) . Como solo tiene 1 instrucción (grande) (el operador ternario), puede olvidar la {}.
Ismael Miguel
@IsmaelMiguel Gracias, eso será útil: D
Beta Decay
2

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

Emigna
fuente
1

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).
Dennis
fuente
1

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)

Frédéric
fuente
1
Debería poder deshacerse de él return()en su código. Pero también debe nombrar la función para que su recursión funcione
usuario5957401
0

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}
fosgeno
fuente
0

Dyalog APL, 25 bytes

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

ngn
fuente