피보나치 수에 대해 들어봤을 것입니다. 나중에 시작하는 정수 시퀀스 1, 1, 그리고 각각의 새로운 숫자는 마지막 두 숫자의 합입니까?

1 1 2 3 5 8 13...

등등. 피보나치 수에 대한 도전은 여기에서 꽤 인기가 있습니다 . 그러나 피보나치 수로 시작해야한다고 누가 말 1, 1합니까? 왜 그들은 시작할 수 없었 0, 1습니까? 자, 0부터 시작하도록 재정의합시다.

0 1 1 2 3 5 8 13...

하지만 ... 우리도 거기서 멈출 필요는 없습니다! 다음 두 숫자를 얻기 위해 마지막 두 숫자를 더할 수 있다면 두 번째 숫자에서 첫 번째 숫자를 빼서 새 숫자를 붙일 수도 있습니다. 따라서 다음과 1, 0같이 시작할 수 있습니다 .

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

우리는 심지어 부정적인 것으로 끝날 수 있습니다.

-1 1 0 1 1 2 3 5 8 13...

그리고이 시리즈는 영원히 계속됩니다. 나는 그것이 피보나치 수를 반영하는 방법이 흥미 롭다고 생각합니다.

13 -8 5 -3 2 -1 1 0 1 1 2 3 5 8 13...

이 시리즈를 "확장 피보나치 수"또는 EFN이라고 합니다. 에이 시리즈를 시작하는 명백한 부정 번호가 실제로 존재하지 않기 때문에, 우리는 말할 것이다 0 쇼에서 최대 0 , 일반 피보나치 수는 긍정적 인 지표에, 확장, 부정적인 (반 음?) 피보나치 수 연장 음수 지수에 다음과 같이 입력하십시오.

Indices: ...-7  -6 -5  -4 -3  -2 -1  0  1  2  3  4  5  6  7 ...
Values:  ...13  -8  5  -3  2  -1  1  0  1  1  2  3  5  8  13...

이것은 오늘날의 도전으로 이어집니다.

정수 N이 주어지면 EFN 시리즈 에서 N이 나타나는 모든 인덱스를 반환 합니다 .

이 작업에 대한 몇 가지 무작위 관찰 :

• 1 은 다른 숫자보다 EFN에 더 많이 나타납니다 [-1, 1, 2]. 3 개 이상의 장소에는 숫자가 표시되지 않습니다.

• 1보다 큰 피보나치 수는 1 번 (3, 8, 21 등) 또는 두 번 (2, 5, 13 등) 나타납니다.

규칙 설명 :

• abs(N)피보나치 숫자가 아닌 경우 EFN 시리즈에 표시 되지 않으므로 가능한 경우 아무것도 출력하지 않거나 빈 모음을 출력해야하거나 언어에서 가능하지 않은 경우 숫자가 아닌 상수 값을 출력 할 수 있습니다.
• 경우 N이 의 여러 위치에 나타납니다 EFN , 당신의 출력을 정렬 할 필요가 없습니다. 각 인덱스는 정확히 한 번만 나타나야합니다.
• 대부분의 시퀀스 챌린지에서 1 기반 또는 0 기반 인덱싱을 사용할지 여부를 선택할 수 있지만 이 챌린지 는 설명 된 인덱싱을 사용해야합니다 (여기서 0은 0에 나타남).
• 모든 표준 형식을 통해 I / O를 수행 할 수 있습니다.

테스트 사례

-13: []
-12: []
-11: []
-10: []
-9: []
-8: [-6]
-7: []
-6: []
-5: []
-4: []
-3: [-4]
-2: []
-1: [-2]
0: 0
1: [-1, 1, 2]
2: [-3, 3]
3: [4]
4: []
5: [-5, 5]
6: []
7: []
8: [6]
9: []
10: []
11: []
12: []
13: [-7, 7]

그리고 더 큰 테스트 사례 :

89: [-11, 11]
1836311903: [46]
10000: []
-39088169: [-38]

평소와 같이 바이트 단위의 최단 답변이 이깁니다!

하스켈 , 78 바이트

nimi 덕분에 4 바이트 절약

a#b=a:b#(a-b)
f 0=[0]
f a=do{(i,x)<-zip[0..a*a+1]$0#1;[-i|x==a]++[i|abs x==a]}

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

먼저 우리는 설정 (#) , (#)두 개의 매개 변수, a그리고 b, 그리고로 시작하는 목록을 반환 a하고 다음에 b#(a-b). 이것은 무한한 목록을 만들지 만 Haskell이 게으 르기 때문에 영원히 반복되는 것에 대해 걱정할 필요가 없습니다. 이것은 본질적으로 특정 쌍 이전에 피보나치 시퀀스를 만드는 역순으로 작동합니다. 예를 들어 (0#1)음수 인덱스가있는 모든 피보나치 수의 목록이됩니다.

여기에서 우리는 만든다 f. 시퀀스에서 찾으려고하는 숫자 인 f인수 a를 사용합니다. 여기서 우리는 do표기법을 사용 하여 목록 이해를 수행합니다. 우리 a*a+1는 목록 0#1¹ 의 첫 번째 요소를 취하는 것으로 시작합니다 . 함수 a*a+1가 피보나치 시퀀스의 역수보다 빠르게 증가하기 때문에이 범위 내에서 검사하면 모든 결과를 찾을 수 있습니다. 이것은 우리가 무한 목록을 검색하지 못하게합니다. 그런 다음 각 값 x과 색인에 대해i , 만약 x==a우리가 발견 a우리가 반환되도록 시퀀스의 음 반 -i, 그리고 만약 abs x==a우리가 반환 i물론 우리가 그것을 발견하도록 음의 절반의 절대 값이 양의 절반이기 때문이다.

이것은 목록 [0,0]을 만들어 그에 0대한 올바른 출력을 하드 코딩합니다.

^{1 :이 속임수는 ururous 'Clean answer 에서 가져 왔습니다 . 등이 여기에 같은 속도 향상의 aplies은 대체 a*a+1와 함께 abs a+1많은 시간을 절약 할 수 있습니다.}

면도 , 132 (120) 109 바이트

import StdEnv
g n|n<2=n=g(n-1)+g(n-2)
?k=[e\\p<-[0..k*k+1],e<-if(isOdd p)([~p,p]%(0,k))[p*sign k]|g p==abs k]

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

g :: Int -> Int피보나치 함수입니다.
? :: Int -> [Int]EFN의 요소를 색인으로k^2+1 의 0.

제정신 시간에 실행되는 버전의 경우로 변경 k*k+1하십시오 abs k+1.

젤리 , 11 바이트

A‘ŒRÆḞẹ_A_2

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

자바 스크립트 (ES6),  94  93 바이트

n=>(g=a=>a*a<n*n?g(b,b+=a,i++):a%n)(i=0,b=1)?[]:i&1?n<0?~n?[]:-2:i-1?[-i,i]:[-i,i,2]:n<0?-i:i

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

또는 반환 할 수 있으면 92 바이트$-0$ ...에 대한 $n=0$.

APL (Dyalog Classic) , 52 50 바이트

필요 ⎕IO←0

{X-⍨⍸⍵=F,⍨⌽0,F×1 ¯1⍴⍨≢F←{⍵≤1:1⋄+/∇¨⍵-1 2}¨⍳X←1+|⍵}

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

망막 0.8.2 , 104 102 바이트

[1-9].*
$*
(-)?(\b1|(?>\3?)(\2))*(1)$|(0)?.*
$5$1$4$4$#2$*
-1(11)+$

^1(11)+$
-$&,$&
1+
$.&
^2$
-1,1,2

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

[1-9].*
$*

입력이 0이 아닌 경우 단항으로 변환하십시오.

(-)?(\b1|(?>\3?)(\2))*(1)$|(0)?.*
$5$1$4$4$#2$*

절대 값의 피보나치 지수를 계산하지만 숫자가 피보나치 수가 아닌 경우 0이 아닌 경우 삭제하십시오. 이것은 @MartinEnder의 피보나치 테스트 정규식을 사용합니다.

-1(11)+$

절대 값이 홀수 피보나치 수인 음수를 삭제합니다.

^1(11)+$
-$&,$&

홀수 양의 피보나치 수에 대해 음수 지수를 추가합니다.

1+
$.&

십진수로 변환합니다.

^2$
-1,1,2

에 대한 추가 지수를 추가하십시오 1.

실제로 34 바이트

;╗3*;±kSix⌠;;AF@;1&@0>*YτD(s**╜=⌡░

무차별 대입으로 날을 구하다

설명:

;╗3*;±kSix⌠;;AF@;1&@0>*YτD(s**╜=⌡░
;╗                                  save a copy of the input (let's call it N) to register 0 (the main way to get additional values into functions)
  3*;±                              -3*N, 3*N
      kSi                           push to list, sort, flatten (sort the two values on the stack so that they are in the right order for x)
         x                          range(min(-3*N, 3*N), max(-3*N, 3*N))
          ⌠;;AF@;1&@0>*YτD(s**╜=⌡░  filter (remove values where function leaves a non-truthy value on top of the stack):
           ;;                         make two copies of parameter (let's call it n)
             AF                       absolute value, Fib(|n|)
               @;                     bring a copy of n to the top of the stack and make another copy
                 1&                   0 if n is divisible by 2 else 1
                   @0>                1 if n is negative else 0 (using another copy of n)
                      *               multiply those two values (acts as logical AND: is n negative and not divisible by 2)
                       YτD            logical negate, double, decrement (maps [0, 1] to [1, -1])
                          (s          sign of n (using the last copy)
                            **        multiply Fib(|n|), sign of n, and result of complicated logic (deciding whether or not to flip the sign of the value for the extended sequence)
                              ╜=      push value from register 0, equality comparison (1 if value equals N else 0)

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

파이썬 3 , 92 바이트

f=lambda x,l=[],i=0,a=0,b=1:i<x*x+2and f(x,l+[i][:a==x]+[-i][:i%2*2*a-a==x],i+1,b,a+b)or{*l}

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

인덱스 집합을 반환합니다.

파이썬 2 , 87 85 바이트

f=lambda v,a=0,b=1,i=1:v*v>=a*a and[i]*(v==b)+[1-i]*((-1)**i*a==v)+f(v,b,a+b,i+1)or[]

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

05AB1E , 36 바이트

x*ÝʒÅfIÄQ}Ii®šë1KIdiÐ`ÉiD(ì}ëD`Èi(ë¯

더 나은 접근 방식이 있어야합니다 ..>.> 6 개 (또는 포함하면 7 개) 0 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오. .

설명:

x*Ý            # Create a list in the range [0, (implicit) input * input * 2]
   ʒ     }     # Filter this list by:
    Åf         #  Where the Fibonacci value at that index
      IÄQ      #  Is equal to the absolute value of the input
Ii             # If the input is exactly 1:
  ®š           #  Prepend -1 to the list
ë              # Else:
 1K            #  Remove all 1s (only applies to input -1)
 Idi           #  If the input is non-negative:
    Ð`Éi   }   #   If the found index in the list is odd:
        D(ì    #    Prepend its negative index to the list
   ë           #  Else (the input is negative):
    D`Èi       #   If the found index in the list is even:
        (      #    Negate the found index
       ë       #   Else (found index is odd):
        ¯      #    Push an empty array
               # (Output the top of the stack implicitly as result)

몇 가지 단계별 예 :

Input:  Filtered indices:  Path it follows (with actions) and result:

-8      [6]                NOT 1 → neg → even index → negate index: [-6]
-5      [5]                NOT 1 → neg → odd index → push empty array: []
-1      [1,2]              NOT 1 → (remove 1) neg → even remaining index: negate index: [-2]
0       [0]                NOT 1 → even index → negate index: [0]    
1       [1,2]              1 → prepend -1: [-1,1,2]
5       [5]                NOT 1 → non-neg → odd index → Prepend neg index: [-5,5]
8       [6]                NOT 1 → non-neg → even index → (nothing): [6]

파이썬 2 , 95 92 94 바이트

x=input()
i=a=0;b=1
while x*x>=a:
 if 0<a==x:print i
 if[-a,a][i%2]==x:print-i
 a,b=b,a+b;i+=1

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

C # (Visual C # 대화식 컴파일러) 144 바이트

o=>{int c=0,n=1,i=0,k=Math.Abs(o);for(;c<k;i++,n+=c,c=n-c);return new[]{c>k|o<0?0.1:i,(i>0|o<0)&i%2>0&c==k?-i:0.1,o==1?2:0.1}.Where(p=>p!=0.1);}

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