배경

대부분의 사람들은 피보나치 수에 익숙 합니다F(n) .

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

이러한 재귀 함수에 의해 형성되고 F(n) = F(n-1) + F(n-2)함께 F(0)=0와 F(1)=1. A000045

밀접하게 관련된 순서는 Lucas 번호입니다 L(m) .

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

이러한 재귀 함수에 의해 형성되고 L(m) = L(m-1) + L(m-2)함께 L(0)=2와 L(1)=1. A000032

우리는 짝수 / 홀수 인덱스를 기반으로 두 시퀀스를 번갈아 가며
A(x) = F(x)if x mod 2 = 0와 A(x) = L(x)그렇지 않으면 구성을 사용할 수 있습니다. 예를 들어 since와 A(4)같습니다 . 우리는이 순서를 부를 것이다 루카스 - nacci 숫자 , :F(4)4 mod 2 = 0A(x)

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

이것은 재귀 함수에 의해 형성 될 수 A(x) = 3*A(x-2) - A(x-4)와 A(0)=0, A(1)=1, A(2)=1, 및 A(3)=4. A005013

도전

입력이 주어지면 위에서 설명한대로 숫자 n시퀀스를 출력하십시오 . 가장 적은 바이트 (또는 메타에서 개별적으로 결정된 LabVIEW 와 같은 바이트 등가 )가 이깁니다.n+1A(n)

입력

하나의 음이 아닌 정수입니다 n.

산출

번호 목록과는 루카스 - nacci 수의 서브 순서에 해당 A(0)하는 A(n). 목록은 위에서 설명한 순서대로 정렬되어야합니다.

규칙

• 표준 코드 골프 규칙 및 허점 제한이 적용됩니다.
• 표준 입 / 출력 규칙이 적용됩니다.
• 입력 번호는 단항 또는 10 진수, STDIN에서 읽은 함수, 명령 줄 인수 등 원하는 형식으로 지정할 수 있습니다.
• 함수 호출의 결과로 출력을 STDOUT으로 인쇄하거나 리턴 할 수 있습니다. 인쇄 된 경우 숫자를 구분하기위한 적절한 구분 기호가 포함되어야합니다 (공백 구분, 쉼표 구분 등).
• 또한 STDOUT으로 출력하는 경우 주변 공백, 후행 줄 바꿈 등은 모두 선택 사항입니다.
• 입력이 정수가 아니거나 음의 정수인 경우 동작이 정의되지 않았으므로 프로그램은 무엇이든 할 수 있습니다.

예

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

젤리, 12 바이트

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

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

배경

F (-1) = 1 및 L (-1) = -1을 정의하여 F와 L을 -1로 확장 할 수 있습니다. 이것은 재귀 함수와 일치합니다.

우리의 프로그램은

-1  1
 0  2

각 단계에서 다음 쌍을 형성하기 위해 마지막 쌍을 뒤집어 두 번째 쌍에 추가합니다. 예를 들면 다음과 같습니다.

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

이 단계를 몇 단계 더 진행하면

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

Lucas-nacci 시퀀스는 단순히 왼쪽 열입니다.

작동 원리

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

^‡ С 왼쪽에있는 두 개의 링크에서 엿보기 : 2와 U+¥. 가장 왼쪽은 나 일드이기 때문에 루프의 몸체가 될 수 없습니다. 따라서 U+¥본문으로 사용되며 입력에서 숫자를 읽습니다. 명령 행 인수가 없으므로 해당 숫자는 STDIN에서 읽습니다.

CJam, 21 20 바이트

1 바이트를 절약 한 Sp3000에 감사합니다.

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

여기에서 테스트하십시오.

설명

챌린지 사양에 지정된 반복을 사용하기 만하면됩니다.

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.

펄 6, 42 바이트

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

용법

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

하스켈, 59 , 57 , 56 , 52 , 51 바이트

l a=2*mod a 2:scanl(+)1(l a)
f n=[l i!!i|i<-[0..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다음과 같이 정의 된 무한 목록을 제공합니다 f(0)=start, f(1)=1, f(n)=f(n-1) + f(n-2). whichStart i홀수 입력 (Lucas 시리즈)의 경우 2를, 짝수 (피보나치 시리즈)의 경우 0을 반환합니다. lucasNacci ii 번째 Lucas-nacci 번호를 제공합니다. firstN n목록 위에 매핑합니다.

부메랑이 1 바이트를 절약했습니다.

ES6, 65 바이트

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

질문에 주어진 되풀이 관계를 사용합니다.

망막 , 70 62 59 바이트

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

f
1

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

• 입력은 단항베이스, n 1입니다.
• 1? $`¶-0에서 n 까지 각 숫자에 대한 줄을 만듭니다 . , 1, 11, 111, 1111, ...
• m`^(11)*1$ $&ff- ff홀수 줄에 추가하십시오 . L (0) = 2로 함수를 시드합니다.
• m`$  f-  f모든 줄에 추가 하십시오 (공백 참조). 피보나치 수는 0과 1, 루카스 수는 2와 1로 함수를 시드합니다.
• +`1(f*) (f*) $2 $2$1 -루프 : 여전히 1이있는 동안 F (n + 1) = F (n) + F (n-1)을 계산합니다.
•  f*   -각 줄 끝에서 F (n + 1)를 제거합니다.
• fs를 다시 1로 교체하십시오 . 이것이 필요하지 않고 fs를 유지할 수 있다면 길이는 55 바이트입니다.

Oracle SQL 11.2, 218 216 201 바이트

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;

언 골프

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;

SIGN 함수를 사용하여 시퀀스의 처음 3 요소를 생성하여 몇 바이트를 얻었습니다.

apt, 25 22 21 바이트

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

온라인으로 테스트하십시오!

배경

Japt에서 피보나치 시퀀스를 생성하는 것은 다소 어렵지만, Mg이를 위해 내장되어 있습니다. 그러나 이것은 우리에게 Lucas 시퀀스가 ​​아닌 Fibonacci 시퀀스만을 제공합니다. 이 트릭을 사용하여 Lucas 시퀀스를 상당히 쉽게 수행 할 수 있습니다.

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

보시다시피, 모두 F(N-1) + F(N+1)동일 L(N)합니다 N. 그러나 홀수 인덱스에는 Lucas 숫자 만 필요하므로 두 수식을 하나로 결합 할 수 있습니다.

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

작동 원리

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

매스 매 티카, 52 51 바이트

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

위의 Martin과 매우 비슷한 생각으로 함수의 "기본 사례"를 정의하는 더 짧은 방법을 찾으려고 시간을 보냈습니다. 다항식 보간은 흉상이었고, 나는 이것을 음수로 확장하여 상당히 짧은 정의를 얻었습니다.

매스 매 티카, 56 바이트

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

매우 간단한 구현. 도우미 f함수를 정의한 다음 f모든 결과를 얻기 위해 범위에 적용되는 명명되지 않은 함수로 평가 합니다. 불필요하게 번거 롭습니다.

명명되지 않은 단일 함수는 1 바이트 더 길어 보입니다.

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

MATL , 17 18 바이트

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

Martin의 CJam 답변을 거의 직접 번역했습니다 .

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

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

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

이것은 숫자를 입력으로 취하여 각 숫자를 구분하는 공백과 함께 목록을 STDOUT에 인쇄합니다.

설명

§ 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

!하위 술어 1의 첫 번째 규칙의 컷 은 역 추적 ( \) 할 때 인터프리터가 4보다 작은 입력에 대해 두 번째 규칙을 시도하는 무한 루프로 끝나지 않도록하기 위해 필요합니다.

수학, 41 바이트

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

그루비, 50 바이트

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

이것은 함수 x를 정의하는데,이 함수는 n을 첫 번째 인수로 취하고 Fibocas 시퀀스에서 처음 네 개의 숫자의 기본 사례를 나머지 함수의 기본 인수로 갖습니다.

여기에 n이 있습니다. b, c, d 및 e는 시퀀스에서 다음 네 가지 요소입니다.

n이 0보다 작을 때까지 n을 감소시키고 재귀합니다. 재귀가 발생하면 현재 시퀀스의 첫 번째 요소를 최종 반환 값에 더합니다. 시퀀스에서 다음 4 개의 요소에 대한 새로운 값은 재귀 호출에 주어집니다. 마지막 3 개의 요소는 처음 3 개로 옮겨지고 3 번째 db를 사용하여 이전 요소 중 2 개에서 새로운 네 번째 요소가 생성됩니다.

groovy는 여러 값을 목록에 채워서 여러 값을 반환 할 수 있으므로 목록 중첩으로 새 값을 구분합니다. 따라서 각 호출은 현재 첫 번째 요소와 재귀의 결과를 반환합니다.

R , 55 바이트

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

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

• JayCe 덕분에 -24 바이트

철탑 , 19

이것은 Martin의 접근 방식을 직접적으로 번역 한 것입니다.

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

작동 방식 :

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

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

Try it here!

스택에 일련의 숫자를 남기는 익명의 람다. 용법:

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

설명

[                              {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}

파이썬 2, 71 바이트

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)

이것은 너무 길어 보인다. 그러나 비트 not연산자를 두 번 사용하게되어 기뻤습니다 . 한 번은 일종의 패리티로 앞뒤로 뒤집고 한 번 n도달하면 재귀를 종료합니다 -1.

변수 p는 항상 0또는 -1이므로 항목 0또는 -1목록 사이를 번갈아 표시합니다. ( -1Python 목록의 항목 을 선택 한다는 것은 마지막 요소를 선택하는 것을 의미합니다.)

C ++ 템플릿 메타 프로그래밍, 130 바이트

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)

재귀 적 정의는 어떻게 든 C ++ TMP, 사용법에 대해 울고 있습니다.

L<x>::v

와 x인 A(x)당신은 좋아한다.