최근에 자체 시퀀스 (Piggyback 시퀀스)를 만들었으며 다음과 같이 작동합니다.

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

모든 P(n)위치 n>3에서 시퀀스는 다음과 같이 작동합니다.

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

따라서 순서를 계속하십시오.

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

주어 졌을 때 당신의 작업은,되어 n, 계산 P(n)부동 소수점 수 또는 (IM) 적절한 비율로 중.

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다.

누구나 시퀀스 이름을 찾을 수 있다면 그에 따라 게시물을 편집하십시오.

현재 리더 : MATL 및 Jelly (둘 다 15 바이트).

파이썬 2, 40 39 바이트.

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

부여 True이것은 우리가 42 바이트이있을 수 있습니다 허가되어 있지 않은 경우, 대신 1의 :

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

그것이 작동하는 방식은 매우 간단합니다. 유일한 트릭은 .0+결과를 부동 소수점으로 캐스팅하는 것입니다.

Haskel, 32 바이트

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

사용 예 : ((0#1)1!!) 7-> 2.642857142857143. 의 0 기반 인덱싱 0, 1, 1을 수정하기 위해 시퀀스를 시작 !!합니다.

편집 : @xnor는 바이트 수를 변경하지 않고 0 기반 인덱스에서 1 기반 인덱스로 전환하는 방법을 찾았습니다.

루비, 34 바이트

루비는 기본적으로 정수 나누기를 사용하기 때문에 분수를 사용하는 것이 더 짧은 것으로 판명되었습니다. 골프 제안을 환영합니다.

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

펄 6 ,  25  23 바이트

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

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

설명:

# 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
  )[ $_ ]
}

결과가 64 비트 정수에 들어갈 수있는 것보다 더 큰 분모를 갖기 시작할 때까지 3까지 시작하는 입력에 대해 Rat ( Rational )을 리턴합니다. 이 시점에서 Num (부동 소수점)을 리턴하기 시작합니다 .
마지막그것이 돌아올 쥐는P(11) == 8832072277617 / 2586200337022

부동 소수점 대신에 합리적인 숫자 를 반환 하려면 다음을 대신 하여 FatRat 을 반환합니다 .

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

테스트:

#! /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 바이트

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

이데온

MATL , 15 바이트

llli3-:"3$t/+]&

온라인으로 사용해보십시오!

설명

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

체다 , 31 바이트

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

ungolfed 버전은 너무 명확하므로 설명이 필요하지 않습니다.

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

기본적으로 함수 인수 뒤에는 함수 자체로 설정 될 변수를 지정할 수 있습니다. 왜? 이 기능은 테일 콜에 최적화되어 있거나 최소한 있어야하기 때문입니다.

자바 스크립트 (ES6), 31 바이트

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

간단한 기능.

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 바이트

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

온라인으로 사용해보십시오!

Luis Mendo 덕분에 1 바이트 절약

Pyth, 20 바이트

L?<b4h0+y-b3cy-b2ytb

온라인으로 사용해보십시오!

젤리 , 15 바이트

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

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인 .

작동 원리

ạ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 바이트

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

이 답변은 매우 깔끔한 기능을 사용했습니다 ifelse.ifelse(Condition, WhatToDoIfTrue, WhatToDoIfNot)

Mathematica, 36 바이트

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

처음 몇 가지 용어는 다음과 같습니다.

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

Dyalog APL, 25 바이트

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