교류 피보나치 시퀀스를 먼저 시작 1하고 1평소와 같이.

그러나 다음 두 숫자를 얻기 위해 항상 마지막 두 값을 더하는 대신 더하기로 시작하고 다른 때마다 뺄 수 있습니다.

순서는 다음과 같이 시작됩니다.

1
1
2    # 1 + 1
-1   # 1 - 2
1    # 2 + -1
-2   # -1 - 1
-1   # 1 + -2
-1   # -2 - -1
-2   # -1 + -1
1    # -1 - -2
-1   # -2 + 1
2    # 1 - -1
1    # -1 + 2
1    # 2 - 1

기타

^{이 시작됩니다 후가 도착하면 통지 1하고 1다시.}

숫자 N이 주어지면 교번 피보나치 시퀀스 의 N 번째 항을 인쇄하십시오 .

이것은 code-golf 이므로 바이트 수가 가장 적은 코드가 이깁니다.

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

n=>"334130110314"[n%12]-2

인덱스가 0입니다. 약간 재귀 버전으로 문자열을 줄일 수 있지만 6 바이트가 추가됩니다.

f=n=>"3341301"[n]-2||f(13-n%12)

이것은 여전히 ​​결정적인 재귀 공식보다 짧습니다.

f=n=>n<2||f(n-2)+f(n-1)*(-n%2|1)

파이썬, 31 바이트

lambda n:2-33107256/5**(n%12)%5

값을 계산하려고하지 않습니다. 그냥 peroidic length-12리스트에서 찾아보세요[1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]기본 5에서 압축 된 .

1의 재귀 솔루션 (37 바이트)과 비교하십시오 True.

f=lambda n:n<2or(-1)**n*f(n-1)+f(n-2)

또는 문자열 저장

lambda n:int('334130110314'[n%12])-2

또는 산술 표현 시도.

lambda n:4**n%7%3*(-1)**((n+n%2*4)/6)

오아시스 , 10 바이트

더 많은 내장 기능을 구현하도록 상기시켜줍니다. : p. 입력은 0 인덱스 입니다.

암호:

n>2%x<*c+V

번역 된 버전 :

a(n) = (2*((n+1)%2)-1) * a(n-1) + a(n-2)
a(1) = 1
a(0) = 1

그리고 n 번째 항을 계산합니다 .

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

05AB1E , 10 바이트

•É&†º•sèÍ

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

Pyth-13 바이트

기본 인코딩 된 한 번주기 시리즈, 모듈 식 인덱스.

@-R2jC"
ûx"5

여기에서 온라인으로 사용해보십시오 .

젤리, 12 바이트

“½Ġ⁻S’b5_2⁸ị

TryItOnline!

첫 번째와 두 번째 값이 주어지면 1 기준 1 합니다.

이것이 더 짧은 지 확실하지 않지만이 시리즈의 기간은 12입니다.
[1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]

그래서, 나는 그것을 가져다가 추가 2제공하기 위해
[3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
다음베이스로하는 것이 변환 된 5베이스 번호 250,주고 :
[11, 197, 140, 84]
(인 184222584).

“½Ġ⁻S’b5_2⁸ị - Main link: n
“½Ġ⁻S’       - base 250 number      184222584
      b5     - convert to base 5   [3, 3, 4, 1, 3, 0, 1, 1, 0, 3, 1, 4]
        _2   - subtract 2          [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]
          ⁸  - left argument, n
           ị - index into (1-based and modular)

하스켈, 33 26 바이트

a!b=a:b:(a+b)!(-a)
(1!1!!)

재귀 적 접근. 인덱스가 0입니다. Ideone에서 사용해보십시오. xnor
덕분에 7 바이트가 절약되었습니다 .

용법:

Prelude> (1!1!!)11
2

Mathematica, 40 바이트

ETHproductions의 답변 에서처럼 룩업 테이블을 만들고 주기적으로 액세스하십시오. 이름이없는 함수, 1- 색인.

Join[s={2,1,1,2,-1,1},-s][[#~Mod~12+1]]&

MATL , 17 16 15 바이트

'"Bl)e'F5Za2-i)

입력은 1 기반입니다.

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

설명

순서는 period [1 1 2 -1 1 -2 -1 -1 -2 1 -1 2]입니다.

'"Bl)e     % Compressed array [1 1 2 -1 1 -2 -1 -1 -2 1 -1 2] with source 
           % alphabet [-2 -1 0 1 2]
F5Za       % Decompress with target alphabet [0 1 2 3 4]
2-         % Subtract 2 to transform alphabet into [-2 -1 0 1 2]
i)         % Input N and use as (modular, 1-based) index into the sequence

WinDbg, 26 바이트

?(85824331b>>@$t0%c*3&7)-2

입력은 의사 레지스터를 통해 전달됩니다 $t0. 인덱스가 0입니다. 시퀀스에서 각 항의 +2는 3 비트 작성에 저장됩니다 85824331b.

작동 방식 :

? (85824331b >> @$t0 % c * 3 & 7) - 2 ;*? Evalutes the expression. Shifts 85824331b to get
                                       *the 3 bits for the @$t0'th term (mod c (12) when
                                       *the sequence repeats). Bitwise AND by 7 to get the
                                       *desired 3 bits, finally subtract 2 since the terms
                                       *where stored as +2.

샘플 출력, 시퀀스의 처음 14 개 값을 인쇄하는 루프 :

0:000> .for(r$t0=0;@$t0<e;r$t0=@$t0+1){?(85824331b>>@$t0%c*3&7)-2}
Evaluate expression: 1 = 00000001
Evaluate expression: 1 = 00000001
Evaluate expression: 2 = 00000002
Evaluate expression: -1 = ffffffff
Evaluate expression: 1 = 00000001
Evaluate expression: -2 = fffffffe
Evaluate expression: -1 = ffffffff
Evaluate expression: -1 = ffffffff
Evaluate expression: -2 = fffffffe
Evaluate expression: 1 = 00000001
Evaluate expression: -1 = ffffffff
Evaluate expression: 2 = 00000002
Evaluate expression: 1 = 00000001
Evaluate expression: 1 = 00000001

자바, 32 바이트

n->"334130110314".charAt(n%12)-50

이것이 Java이기 때문에 답은 0으로 색인됩니다.

테스트 및 ungolfed :

class Ideone {
  public static void main (String[] args) throws Exception {
    java.util.function.IntFunction f = n->"334130110314".charAt(n%12)-50;
    for (int i = 0; i < 12; i++) {
      System.out.printf("%d -> %d%n", i, f.apply(i));
    }
  }
}

Ideone에서 테스트

매스 매 티카, 45 41 38 바이트

3 바이트 동안 @MartinEnder에게 감사드립니다.

±0=±1=1;±n_:=±(n-2)+±(n-1)(1-2n~Mod~2)

인덱스가 0입니다.

용법

±5

-2

펄 6 ,  39 35  32 바이트

{(1,1,{|(($/=$^a+$^b),$b-$/)}...*)[$_]}

{(|(334130110314.comb X-2)xx*)[$_]}

{(|334130110314.comb xx*)[$_]-2}

{334130110314.substr($_%12,1)-2}

C #, 117 바이트

골프 :

int A(int n){var f=new List<int>{0,1,1};for(int i=3;i<=n;i++){f.Add(i%2>0?f[i-1]+f[i-2]:f[i-2]-f[i-1]);}return f[n];}

언 골프 드 :

public int A(int n)
{
  var f = new List<int> { 0, 1, 1 };

  for (int i = 3; i <= n; i++)
  {
    f.Add(i % 2 > 0 ? f[i - 1] + f[i - 2] : f[i - 2] - f[i - 1]);
  }

  return f[n];
}

테스트 :

var alternatingFibonacci = new AlternatingFibonacci();
Console.WriteLine(alternatingFibonacci.B(10));
1

R, 38 바이트

@ETHproductions JS 응답에서 영감을 얻은 룩업 테이블 솔루션을 사용합니다.

c(s<-c(2,1,1,2,-1,1),-s)[scan()%%12+1]

편집 : 이것은 1 인덱싱이라는 것을 언급하지 않았습니다.

실제로 , 22 바이트

34*@%"334130110314"E≈¬

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

설명:

34*@%"334130110314"E≈¬
34*@%                   input % 12
     "334130110314"E    get that character in the string
                    ≈¬  convert to int, subtract 2

자바 7, 88 82 79 바이트

골프 :

int f(int n){int c,i=0,a=1,b=1;for(;i<n;){c=i++%2>0?a-b:a+b;a=b;b=c;}return b;}

언 골프 :

int f(int n)
{
    int c, i = 0, a = 1, b = 1;
    for (; i < n;)
    {
        c = i++ % 2 > 0 ? a - b : a + b;
        a = b;
        b = c;
    }
    return b;
}

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

DC, 55 바이트

?sd[ln1+snly[[+2Q]sEln2%1=E-]xlyrsylnld>r]sr1sy0sn1lrxp

인덱스가 0입니다.

?sd                                                     takes input and stores
                                                        it in register d

                                            1sy0sn1     stores 1 in register y
                                                        and 0 in register n and
                                                        appends 1 to the stack

   [ln1+snly                                            adds 1 to register n and
                                                        appends the value of
                                                        register y to the stack

            [[+2Q]sEln2%1=E-]                           adds or subtracts the
                                                        the two values on the
                                                        stack depending on
                                                        parity of n

                             xlyrsylnld>r]              does the rest of the
                                                        stuff required to store
                                                        the new values properly
                                                        and quits if it has
                                                        done enough iterations

                                          sr            stores the main macro
                                                        in register r

                                                   lrxp executes the macro and
                                                        prints the stack

레지스터 d는 값의 인덱스를 저장합니다. 레지스터 n은 완료된 반복 횟수를 계산합니다. 레지스터 r은 메인 매크로를 저장합니다. 레지스터 y는 이후 값을 시퀀스에 저장하고 스택은 시퀀스의 초기 값을 포함합니다.

큰 고리에서 일어나는 일에 대한 시각적 설명 (추가 가정) :

register: y=1     y=1   y=1    y=1   y=1    y=2
stack:     1      1 1    2     2 1   1 2     1
               ly     +     ly     r     sy

더하기 또는 빼기 여부를 확인하는 검사는 카운터 모듈로 2를 사용하여 트릭 을 사용하여 if then else 구성을 만듭니다.

마지막에 스택에는 단일 숫자, 원하는 값이 포함되어 있습니다 p.

(나는 처음 dc이므로 여기에서 약간의 개선이있을 것으로 예상됩니다.)

ForceLang , 153 바이트

def s set
s a 1
s b 1
s p 1
s k io.readnum()
if k=0
goto b
label a
s c b.mult p
s c a+c
s a b
s b c
s p p.mult -1
s k k+-1
if k
goto a
label b
io.write a

Turtlèd , 35 바이트

#112-1_--_1-2#?:[*l+].(-r'1)(_"-2")

0 인덱스

설명:

#112-1_--_1-2#                      the 12 values of sequence. - is -1, _ is -2
              ?:                    input a number and move right that many
                [*l+]               move back to the asterisk on start cell, 
                                    increment sting pointer by amount moved
                     .              write pointed char
                      (-r'1)        if it was -, move right, write 1
                            (_"-2") if it was _, write "-2"
      [print grid]

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

ABCR, 43 바이트

)AAB)ABB..A))A..A)AA(ABB.)A+A)))AiB5aAb(Bxo

설명 : 첫 번째 부분 ( )AAB)ABB..A))A..A)AA(ABB.)A+A)))A)은 대기열 A를 [1, 1, 2, -1, 1, -2, -1, -1, -2, 1, -1, 2]를 포함하도록 설정하고 다른 모든 대기열은 비워 둡니다. . iB원하는 용어를 저장하고 루프 5aAb(Bx는 큐를 여러 번 순환합니다. o대기열의 앞면을 숫자로 인쇄하면 원하는 답이됩니다.

배치, 49 바이트

@cmd/cset/a"n=%1%%12,~!(n%%3)*(1|-!(n%%5*(n/4)))"

명령 행 매개 변수로 입력을받습니다. 설명 : 닫힌 양식은 다음 관찰을 사용합니다.

• 시퀀스는주기 12와 주기적입니다
• 세 번째 항은 모두 ± 2이고 다른 항은 ± 1입니다.
• 세 번째 이후의 항은 5의 배수를 제외하고 음수입니다 (모듈로 12 감소 후)

따라서 모듈로 12를 줄임으로써 시작합니다 (2 바이트 절약). 그런 다음 모듈로 3을 줄이고 결과를 반전시킵니다. 그렇지 않으면 3 또는 0의 배수에 대해 1입니다. 그런 다음 그 값을 비트 단위로 사용하지 않고 3의 배수에 대해 -2를, 그렇지 않으면 -1을 제공합니다. 그런 다음 모듈로 5를 줄이고 별도로 4로 나눕니다. 항 1, 2, 3, 5, 10 및 12 (0)에 대해 0을 제공합니다. 반전 및 부정은 해당 값에 대해 -1을, 다른 값에 대해서는 0을 제공합니다. 그런 다음 비트 단위 또는 1을 비트 단위로 계산하고 이전 계산과 곱합니다.

TI 기본, 26 바이트

불행히도 매우 흥미롭지 않은 접근법. 더 짧은 것을 찾을 수 없었습니다. 이 목록은 1- 색인입니다.

Input :{1,1,2,-1,1,-2:augment(Ans,-Ans:Ans(X

C #, 73 71 바이트

0으로 인덱스 된 n 값을 사용합니다.

n=>{int a=1,b=1,i=0,r;for(;++i<n;){r=i%2>0?a+b:a-b;a=b;b=r;}return b;};

형식화 된 버전 :

Func<int, int> f = n =>
{
    int a = 1, b = 1, i = 0, r;

    for(; ++i < n;)
    {
        r = i % 2 > 0 ? a + b : a - b;
        a = b;
        b = r;
    }

    return b;
};