您可能听说过斐波那契数。您知道，以开头的整数序列，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的斐波那契数字都会显示一次（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]

和往常一样，最短的答案以字节为单位！

Haskell，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：此技巧取自OOurous的“干净答案”。此处具有相同的加速率，替换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]只是到索引中的外汇基金债券的元素k^2+1的0。

对于需要大量时间运行的版本，请更改k*k+1为abs k+1。

果冻，11字节

A‘ŒRÆḞẹ_A_2

在线尝试！

JavaScript（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

在线尝试！

$-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].*
$*

转换为一元，除非输入为零。

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

计算绝对值的斐波那契指数，但如果该数字不是斐波那契数字，则将其删除，除非它为零。这使用@MartinEnder的Fibonacci测试正则表达式。

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

在线尝试！

Python 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}

在线尝试！

返回一组索引。

Python 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(ë¯

必须有一个更好的方法。>>>有六个（或七个，如果包括 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]

Python 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);}

在线尝试！