Tôi đã thực hiện trình tự của riêng mình gần đây (được gọi là trình tự Piggyback) và nó hoạt động như thế này:

P(1), P(2)Và P(3)= 1.

Đối với tất cả mọi P(n)nơi n>3, trình tự hoạt động như thế này:

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

Vì vậy, tiếp tục trình tự:

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

Nhiệm vụ của bạn là, khi được đưa ra n, tính toán P(n)dưới dạng số dấu phẩy động hoặc một phần (im) thích hợp.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte thắng.

Nếu bất cứ ai có thể tìm thấy tên của trình tự, xin vui lòng chỉnh sửa bài cho phù hợp.

Các nhà lãnh đạo hiện tại: MATL và Jelly (cả hai ở mức 15 byte).

Python 2, 40 39 byte.

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

Cung cấp Truethay vì 1, nếu điều này không được phép, chúng tôi có thể có giá trị này cho 42 byte:

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

Cách thức hoạt động của nó khá đơn giản, mẹo duy nhất là sử dụng .0+để chuyển kết quả thành float.

Haskel, 32 byte

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

Ví dụ sử dụng: ((0#1)1!!) 7-> 2.642857142857143. Tôi bắt đầu trình tự 0, 1, 1để sửa !!chỉ mục dựa trên 0.

Chỉnh sửa: @xnor tìm thấy cách chuyển từ chỉ mục dựa trên 0 sang chỉ số 1, mà không thay đổi số byte.

Ruby, 34 byte

Vì Ruby sử dụng phân chia số nguyên theo mặc định, nên hóa ra nó ngắn hơn để sử dụng phân số thay thế. Gợi ý chơi golf chào mừng.

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

Perl 6 ,  25  23 byte

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

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

Giải trình:

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

Điều này trả về một Rat ( Rational ) cho các đầu vào bắt đầu bằng 3 lên cho đến khi kết quả bắt đầu có mẫu số lớn hơn có thể vừa với số nguyên 64 bit, tại đó nó bắt đầu trả về Num s (dấu phẩy động).
Con chuột cuối cùng nó sẽ trở lại làP(11) == 8832072277617 / 2586200337022

Nếu bạn muốn nó trả về các số Rational chứ không phải là số float, bạn có thể đổi nó lấy số sau để trả về FatRat .

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

Kiểm tra:

#! /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 byte

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

Ý tưởng

MATL , 15 byte

llli3-:"3$t/+]&

Hãy thử trực tuyến!

Giải trình

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 byte

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

Phiên bản không rõ ràng rất rõ ràng, bạn không cần giải thích:

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

về cơ bản sau các đối số hàm, bạn có thể chỉ định biến sẽ sử dụng sẽ được đặt thành chính hàm đó. Tại sao? bởi vì chức năng này sẽ được tối ưu hóa cuộc gọi đuôi, hoặc ít nhất nên được.

Javascript (ES6), 31 byte

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

Một chức năng đơn giản.

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 byte

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

Hãy thử trực tuyến!

Đã lưu 1 byte nhờ Luis Mendo

Bình thường, 20 byte

L?<b4h0+y-b3cy-b2ytb

Hãy thử trực tuyến!

Thạch , 15 byte

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

Hãy thử trực tuyến! hoặc xác minh tất cả các trường hợp thử nghiệm .

Làm thế nào nó hoạt động

ạ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 byte

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

Câu trả lời này đã sử dụng chức năng khá gọn gàng ifelse:ifelse(Condition, WhatToDoIfTrue, WhatToDoIfNot)

Toán học, 36 byte

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

Dưới đây là một vài điều khoản đầu tiên:

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

APL Dyalog, 25 byte

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