Lý lịch

Hầu hết mọi người đều quen thuộc với các số Fibonacci F(n) :

0, 1, 1, 2, 3, 5, 8, 13, 21 ...

Chúng được hình thành bởi hàm đệ quy F(n) = F(n-1) + F(n-2)với F(0)=0và F(1)=1. A000045

Một chuỗi liên quan chặt chẽ là các số Lucas L(m) :

2, 1, 3, 4, 7, 11, 18, 29 ...

Chúng được hình thành bởi hàm đệ quy L(m) = L(m-1) + L(m-2)với L(0)=2và L(1)=1. A000032

Chúng ta có thể xen kẽ giữa hai chuỗi dựa trên các chỉ số chẵn / lẻ, với việc xây dựng
A(x) = F(x)nếu x mod 2 = 0và A(x) = L(x)nếu không. Ví dụ, A(4)bằng F(4)từ 4 mod 2 = 0. Chúng tôi sẽ gọi chuỗi này là Số Lucas-nacci , A(x):

0, 1, 1, 4, 3, 11, 8, 29, 21, 76 ...

Điều này có thể được hình thành bởi các chức năng đệ quy A(x) = 3*A(x-2) - A(x-4)với A(0)=0, A(1)=1, A(2)=1, và A(3)=4. A005013

Thử thách

Cho đầu vào n, đầu ra chuỗi n+1số lên đến và bao gồm A(n)như mô tả ở trên. Ít byte nhất (hoặc tương đương byte, chẳng hạn như LabVIEW , như được xác định riêng lẻ trên Meta) sẽ thắng.

Đầu vào

Một số nguyên không âm n.

Đầu ra

Một danh sách các số tương ứng với các số Lucas-nacci từ A(0)đến A(n). Danh sách phải theo thứ tự tuần tự như mô tả ở trên.

Quy tắc

• Quy tắc tiêu chuẩn golf-golf và hạn chế kẽ hở áp dụng.
• Quy tắc đầu vào / đầu ra tiêu chuẩn được áp dụng.
• Số đầu vào có thể ở bất kỳ định dạng phù hợp nào: đơn nguyên hoặc thập phân, đọc từ STDIN, đối số hàm hoặc dòng lệnh, v.v. - lựa chọn của bạn.
• Đầu ra có thể được in thành STDOUT hoặc trả về do kết quả của chức năng gọi. Nếu được in, các dấu phân cách phù hợp để phân biệt các số phải được đưa vào (được phân tách bằng dấu cách, được phân tách bằng dấu phẩy, v.v.).
• Ngoài ra, nếu đầu ra cho STDOUT, khoảng trắng xung quanh, dòng mới, v.v ... đều là tùy chọn.
• Nếu đầu vào là một số nguyên không hoặc số nguyên âm, chương trình có thể làm bất cứ điều gì hoặc không có gì, vì hành vi không được xác định.

Ví dụ

Input -> Output
0 -> 0
5 -> 0, 1, 1, 4, 3, 11
18 -> 0, 1, 1, 4, 3, 11, 8, 29, 21, 76, 55, 199, 144, 521, 377, 1364, 987, 3571, 2584

Thạch, 12 byte

;2U+¥Ð¡-,1ZḢ

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

Lý lịch

Chúng ta có thể mở rộng F và L đến -1 bằng cách xác định F (-1) = 1 và L (-1) = -1. Điều này phù hợp với chức năng đệ quy.

Chương trình của chúng tôi bắt đầu với

-1  1
 0  2

Trong mỗi bước, để tạo thành cặp tiếp theo, chúng tôi đảo ngược cặp cuối cùng và thêm nó vào cặp áp chót. Ví dụ:

[0, 2] U+¥ [-1, 1] -> [2, 0] + [-1, 1] -> [1, 1]

Nếu chúng tôi tiếp tục quá trình này thêm một vài bước nữa, chúng tôi sẽ nhận được

-1  1
 0  2
 1  1
 1  3
 4  2
 3  7
11  5

Trình tự Lucas-nacci chỉ đơn giản là cột bên trái.

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

;2U+¥Ð¡-,1ZḢ  Niladic link. No implicit input.
              Since the link doesn't start with a nilad, the argument 0 is used.

;2            Concatenate the argument with 2, yielding [0, 2].
       -,1    Yield [-1, 1]. This is [L(-1), F(-1)].
    ¥         Create a dyadic chain of the two atoms to the left:
  U             Reverse the left argument.
   +            Add the reversed left argument and the right one, element-wise.
     С       For reasons‡, read a number n from STDIN.
              Repeatedly call the dyadic link U+¥, updating the right argument with
              the value of the left one, and the left one with the return value.
              Collect all intermediate results.
          Z   Zip the list of results, grouping the first and seconds coordinates.
           Ḣ  Head; select the list of first coordinates.

^‡ С peeks tại hai liên kết bên trái: 2và U+¥. Vì cái ngoài cùng bên trái là một con số không, nó không thể là phần thân của vòng lặp. Do đó, U+¥được sử dụng như cơ thể và một số được đọc từ đầu vào. Vì không có đối số dòng lệnh, số đó được đọc từ STDIN.

CJam, 21 20 byte

Cảm ơn Sp3000 vì đã tiết kiệm 1 byte.

TXX4ri{1$3*4$-}*?;]p

Kiểm tra nó ở đây.

Giải trình

Đơn giản chỉ cần sử dụng sự tái phát được đưa ra trong thông số thử thách.

TXX4 e# Push 0 1 1 4 as base cases.
ri   e# Read input and convert to integer N.
{    e# Run this N times...
  1$ e#   Copy a(n-2).
  3* e#   Multiply by 3.
  4$ e#   Copy a(n-4).
  -  e#   Subtract.
}*
?;   e# Discard the last three values, using a ternary operation and popping the result.
]p   e# Wrap the rest in an array and pretty-print it.

Perl 6, 42 byte

{(0,1,1,4,{$^b;$^d;3*$^c-$^a}...*)[0..$_]}

sử dụng

> my &f = {(0,1,1,4,{$^b;$^d;3*$^c-$^a}...*)[0..$_]}
-> ;; $_? is raw { #`(Block|184122176) ... }
> f(0)
(0)
> f(5)
(0 1 1 4 3 11)
> f(18)
(0 1 1 4 3 11 8 29 21 76 55 199 144 521 377 1364 987 3571 2584)

Haskell, 59 , 57 , 56 , 52 , 51 byte

l a=2*mod a 2:scanl(+)1(l a)
f n=[l i!!i|i<-[0..n]]

Định nghĩa loạt thích nghi từ câu trả lời này .

Ít chơi gôn hơn:

fibLike start = start : scanl (+) 1 (fibLike start)
whichStart i = (2*mod i 2)
lucasNacci i = fibLike (whichStart i) !! i
firstN n = [ lucasNacci i | i <- [0..n]]

fibLike startđưa ra một danh sách vô hạn, được định nghĩa : f(0)=start, f(1)=1, f(n)=f(n-1) + f(n-2). whichStart itrả về 2 cho đầu vào lẻ ​​(chuỗi Lucas) hoặc 0 cho chẵn (chuỗi Fibonacci). lucasNacci icho số Lucas-nacci thứ ih. firstN nbản đồ qua danh sách.

Một byte được lưu bởi Boomerang.

ES6, 65 byte

n=>[...Array(n)].map(_=>a.shift(a.push(a[2]*3-a[0])),a=[0,1,1,4])

Sử dụng các mối quan hệ tái phát được đưa ra trong câu hỏi.

Võng mạc , 70 62 59 byte

1
¶$`1
m`^(11)*1$
$&ff
m`$
 f
+`1(f*) (f*)
$2 $2$1
 f*

f
1

Dùng thử trực tuyến

• Đầu vào là trong cơ sở đơn nguyên, n 1s.
• 1? $`¶- Tạo một dòng cho mỗi số từ 0 đến n : , 1, 11, 111, 1111, ...
• m`^(11)*1$ $&ff- Nối ffvào các dòng lẻ. Điều này sẽ gieo hàm với L (0) = 2.
• m`$  f- Nối  fvào tất cả các dòng (lưu ý khoảng trắng). Điều này tạo ra hàm với 0 và 1 cho các số Fibonacci và 2 và 1 cho các số Lucas.
• +`1(f*) (f*) $2 $2$1 - Vòng lặp: tính F (n + 1) = F (n) + F (n-1) trong khi vẫn còn 1s.
•  f*   - Loại bỏ F (n + 1) khỏi cuối mỗi dòng.
• Thay fs trở lại 1s. Nếu điều này là không cần thiết và chúng ta có thể ở lại với fs, thì độ dài chỉ là 55 byte.

Oracle SQL 11.2, 218 216 201 byte

WITH v(a,b,c,d,i)AS(SELECT 0,1,1,4,3 FROM DUAL UNION ALL SELECT b,c,d,3*c-a,i+1 FROM v WHERE i<:1)SELECT SIGN(LEVEL-1) FROM DUAL WHERE LEVEL-1<=:1 CONNECT BY LEVEL<4UNION ALL SELECT d FROM v WHERE:1>2;

Không chơi gôn

WITH v(a,b,c,d,i) AS 
(
  SELECT 0,1,1,4,3 FROM DUAL 
  UNION ALL 
  SELECT b,c,d,3*c-a,i+1 FROM v WHERE i<:1
)
SELECT SIGN(LEVEL-1) FROM DUAL WHERE LEVEL-1<=:1 CONNECT BY LEVEL<4
UNION ALL SELECT d FROM v WHERE:1>2;

Tôi đã quản lý để đạt được một vài byte bằng cách sử dụng (lạm dụng?) Hàm SIGN để tạo 3 phần tử đầu tiên của chuỗi.

Japt, 25 22 21 byte

Uò £MgXf2)+X%2*Mg°X)r

Kiểm tra nó trực tuyến!

Lý lịch

Thật khó để tạo ra một chuỗi Fibonacci trong Japt, nhưng chúng tôi đã tích hợp sẵn Mgđể làm điều đó cho chúng tôi. Tuy nhiên, điều này chỉ cung cấp cho chúng ta chuỗi Fibonacci chứ không phải chuỗi Lucas. Chúng ta có thể thực hiện chuỗi Lucas khá dễ dàng bằng thủ thuật này:

N    F(N-1)  F(N+1)  F(N-1)+F(N+1)
0    1       1       2
1    0       1       1
2    1       2       3
3    1       3       4
4    2       5       7
5    3       8       11
6    5       13      18
7    8       21      29

Như bạn có thể thấy, F(N-1) + F(N+1)là bằng L(N)với tất cả N. Tuy nhiên, vì chúng ta chỉ cần số Lucas trên các chỉ số lẻ, nên chúng ta có thể kết hợp hai công thức thành một:

N    N-N%2  N+N%2    F(N-N%2)  F(N+N%2)*(N%2)  F(N-N%2)+F(N+N%2)*(N%2)
0    0      0        0         0               0
1    0      2        0         1               1
2    2      2        1         0               1
3    2      4        1         3               4
4    4      4        3         0               3
5    4      6        3         8               11
6    6      6        8         0               8
7    6      8        8         21              29

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

Uò £  MgX-1 +X%2*Mg° X)r
Uò mX{MgX-1 +X%2*Mg++X)r

             // Implicit: U = input integer
Uò mX{       // Create the inclusive range [0..U], and map each item X to:
MgXf2)+      //  Floor X to a multiple of 2, calculate this Fibonacci number, and add:
+X%2*Mg++X)  //  Calculate the (X+1)th Fibonacci number and multiply by X%2.
)r           //  Round the result. (The built-in Fibonacci function returns
             //  a decimal number on higher inputs.)

Toán học, 52 51 byte

If[#>2,3#0[#-2]-#0[#-4],#-If[#>1,1,0]]&/@0~Range~#&

Ý tưởng rất giống với Martin ở trên, tôi đã dành thời gian cố gắng tìm một cách ngắn hơn để xác định "trường hợp cơ sở" cho hàm. Nội suy đa thức là một bức tượng bán thân, vì vậy tôi đã thực hiện điều này, sử dụng phần mở rộng thành các phủ định để đưa ra một định nghĩa khá ngắn.

Toán học, 56 byte

f@0=0
f@1=f@2=1
f@3=4
f@n_:=3f[n-2]-f[n-4];
f/@0~Range~#&

Thực hiện rất đơn giản. Xác định hàm trợ giúpf và sau đó đánh giá một hàm không tên được áp dụng fcho một phạm vi để có được tất cả các kết quả. Điều này cảm thấy cồng kềnh không cần thiết.

Một hàm không tên duy nhất dường như dài hơn một byte:

Switch[#,0,0,1,1,2,1,3,4,_,3#0[#-2]-#0[#-4]]&/@0~Range~#&

MATL , 17 18 byte

0ll4i:"y3*5$y-](x

Hầu như bản dịch trực tiếp câu trả lời CJam của Martin .

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

0ll4       % push first four numbers: 0,1,1,4
i:         % input n and generate array [1,2,...,n]
"          % for loop. Repeat n times
  y        % copy second-top element from stack
  3*       % multiply by 3
  5$y      % copy fifth-top element from stack
  -        % subtract. This is the next number in the sequence
]          % end loop
(x         % indexing operation and delete. This gets rid of top three numbers

Brachylog , 51 byte

:0re{:4<:[0:1:1:4]rm!.|-4=:1&I,?-2=:1&*3-I=.}w,@Sw\

Cái này lấy một số làm đầu vào và in ra STDOUT danh sách, với các khoảng trắng ngăn cách mỗi số.

Giải trình

§ Main predicate

:0re{...}               § Enumerate integers between 0 and the Input, pass the integer 
                        § as input to sub-predicate 1      
         w,@Sw          § Write sub-predicate 1's output, then write a space
              \         § Backtrack (i.e. take the next integer in the enumeration)


§ Sub-predicate 1

:4<                     § If the input is less than 4
   :[0:1:1:4]rm!.       § Then return the integer in the list [0,1,1,4] at index Input

|                       § Else

-4=:1&I,                § I = sub_predicate_1(Input - 4)
        ?-2=:1&*3-I=.   § Output = sub_predicate_1(Input - 2) * 3 - I

Việc cắt giảm !quy tắc đầu tiên của vị từ phụ 1 là cần thiết để khi chúng ta quay lại ( \), chúng ta không kết thúc trong một vòng lặp vô hạn nơi trình thông dịch sẽ thử quy tắc thứ hai cho đầu vào nhỏ hơn 4.

Toán học, 41 byte

LinearRecurrence[{0,3,0,-1},{0,1,1,4},#]&

Groovy, 50 byte

x={a,b=0,c=1,d=1,e=4->a<0?:[b,x(a-1,c,d,e,3*d-b)]}

Điều này xác định hàm x, lấy n là đối số đầu tiên và có trường hợp cơ sở của bốn số đầu tiên trong chuỗi Fibocas làm đối số mặc định cho phần còn lại của hàm.

đây là n. b, c, d và e là bốn phần tử tiếp theo trong chuỗi.

Nó giảm n và đệ quy cho đến khi n nhỏ hơn 0 - khi nó đệ quy, nó thêm vào giá trị trả về cuối cùng của phần tử đầu tiên trong chuỗi hiện tại của nó. Các giá trị mới cho bốn phần tử tiếp theo trong chuỗi được đưa ra cho lệnh gọi đệ quy-- ba phần tử cuối cùng được chuyển sang ba phần tử đầu tiên và phần tử thứ tư mới được tạo từ hai trong số các phần tử trước đó bằng cách sử dụng 3 * db.

Nó phân định các giá trị mới với các danh sách lồng nhau, vì Groovy có thể trả về nhiều giá trị bằng cách nhồi chúng vào một danh sách - vì vậy mỗi cuộc gọi trả về phần tử đầu tiên hiện tại và kết quả của đệ quy, sẽ là danh sách riêng của nó.

R , 55 byte

A=c(0,1,1,4);for(x in 4:scan()+1)A[x]=3*A[x-2]-A[x-4];A

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

• -24 byte nhờ JayCe

Giá treo , 19

Đây là một bản dịch khá trực tiếp về cách tiếp cận của Martin.

0114{@-4@-33*-,i}=4

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

0114    # Push 0, 1, 1, 4 to the stack.
{       # Start a for loop.
 @-4    # Get the stack element at index -4
 @-3    # Get the stack element at index -3
 3      # Push 3 to the stack.
 *      # Multiply the top two elements of the stack.
 -      # Subtract the top two elements of the stack.
  ,     # Switch to loop iterations.
 i      # Get command line args.
}       # End for loop.
=4      # Discard the top 4 elements of the stack.

DUP , 32 byte

[a:0 1$4[a;1-$a:][1ø3*4ø-]#%%]

Try it here!

Một lambda ẩn danh để lại một chuỗi các số trên ngăn xếp. Sử dụng:

8[a:0 1$4[a;1-$a:][1ø3*4ø-]#%%]!

Giải trình

[                              {start lambda}
 a:                            {save input number to a}
   0 1$4                       {base cases to get us started}
        [       ][       ]#    {while loop}
         a;1-$a:               {a--, check if a>0}
                  1ø3*4ø-      {3*stack[n-2]-stack[n-4]}

                           %%  {discard top 2 stack items}
                             ] {end lambda}

Python 2, 71 byte

def a(n,x=0,y=1,z=2,w=1,p=0):
 if~n:print[x,z][p];a(n-1,y,x+y,w,z+w,~p)

Điều này chắc chắn có vẻ quá dài. Tuy nhiên, tôi hài lòng rằng tôi đã sử dụng toán nottử bitwise ... hai lần. Một lần như một sự tương đương lật qua lại và một lần để chấm dứt đệ quy khin đạt-1 .

Biến psẽ luôn luôn là 0hoặc -1, vì vậy nó sẽ xen kẽ giữa các mục 0hoặc -1của danh sách. (Chọn mục nhập -1của danh sách Python có nghĩa là chọn phần tử cuối cùng.)

Lập trình meta mẫu C ++, 130 byte

template<int X>struct L{enum{v=3*L<X-2>::v-L<X-4>::v};};
#define D(X,A) template<>struct L<X>{enum{v=A};};
D(0,0)D(1,1)D(2,1)D(3,4)

Định nghĩa đệ quy bằng cách nào đó khóc cho C ++ TMP, cách sử dụng:

L<x>::v

với xviệc A(x)bạn thích