你的任务：

编写程序或函数以检查输入的数字是否为斐波那契数字。 斐波那契数是斐波那契序列中包含的数字。

斐波那契数列定义为： F(n) = F(n - 1) + F(n - 2)

有了种子F(0) = 0和F(1) = 1。

输入：

0到1,000,000,000之间的非负整数，可以是也可以不是斐波那契数。

输出：

真/假值，指示输入是否为斐波那契数。

例子：

0-->truthy
1-->truthy
2-->truthy
12-->falsy

得分：

这是代码高尔夫球，最低字节数获胜。

Neim，2 个字节

f𝕚

说明：

f       Push an infinite fibonacci list
 𝕚      Is the input in that list?

的工作原理与我的“待见即所得” 答案相同，但使用不同的无限列表：f，用于斐波那契。

试试吧！

JavaScript（ES6），34个字节

f=(n,x=0,y=1)=>x<n?f(n,y,x+y):x==n

递归生成斐波那契数列，直到找到大于或等于输入的项，然后返回item == input。

视网膜，23字节

^$|^(^1|(?>\2?)(\1))*1$

在线尝试！

一元输入，输出0或1。

说明

Fibonacci序列是具有正向引用的解决方案的良好候选者，例如，“反向引用”既可以引用周围的组，也可以引用在正则表达式中出现的组（在这种情况下，我们实际上同时使用了这两个）。当像这样匹配数字时，我们需要为序列元素之间的差异找出一个递归表达式。例如，为了匹配三角数，我们通常匹配前一个段加一个。为了匹配平方数（其差为奇数），我们匹配上一个段加两个。

由于我们通过将倒数第二个元素添加到最后一个元素来获得斐波那契数，因此它们之间的差异也只是斐波那契数。因此，我们需要将每个段匹配为前两个段的和。正则表达式的核心是：

(         # This is group 1 which is repeated 0 or more times. On each
          # iteration it matches one Fibonacci number.
  ^1      # On the first iteration, we simply match 1 as the base case.
|         # Afterwards, the ^ can no longer match so the second alternative
          # is used.
  (?>\2?) # If possible, match group 2. This ends up being the Fibonacci
          # number before the last. The reason we need to make this optional
          # is that this group isn't defined yet on the second iteration.
          # The reason we wrap it in an atomic group is to prevent backtracking:
          # if group 2 exists, we *have* to include it in the match, otherwise
          # we would allow smaller increments.
  (\1)    # Finally, match the previous Fibonacci number and store it in
          # group 2 so that it becomes the second-to-last Fibonacci number
          # in the next iteration.
)*

现在，这最终将所述斐波那契数开始于1，即1，1，2，3，5，...。那些加起来1，2，4，7，12，...。也就是说，它们比斐波那契数小1，因此我们1在末尾添加a 。唯一没有覆盖的情况是零，因此我们^$在开始时有另一种选择来覆盖它。

正则表达式（ECMAScript的香味），392个 358 328 224 206 165字节

将斐波那契数与ECMAScript正则表达式匹配（一元）所需的技术与在大多数其他正则表达式中的最佳实现方式相去甚远。缺少前向/嵌套的反向引用或递归意味着不可能直接计算或保持任何事物的连续总数。缺乏后顾之忧使得即使有足够的工作空间也常常是一个挑战。

必须从完全不同的角度解决许多问题，并且直到一些关键见解出现之前，这些问题似乎无法解决。它迫使您建立一个更广泛的网络，以发现您正在处理的数字的哪些数学属性可以用来解决特定问题。

2014年3月，斐波纳契数就是这种情况。最初查看Wikipedia页面时，我想不出办法，尽管其中一个特定的属性似乎非常接近。然后，数学家teukon概述了一种方法，该方法非常清楚地表明可以同时使用该属性和另一个属性。他不愿真正构建正则表达式。我继续前进时他的反应：

你疯了！我以为你可以这样做。

与其他ECMAScript一元数学正则表达式帖子一样，我会发出警告：我强烈建议学习如何在ECMAScript正则表达式中解决一元数学问题。对于我而言，这是一次引人入胜的旅程，对于那些可能想要自己尝试的人，尤其是对数字理论感兴趣的人，我都不想破坏它。请参阅该帖子，以获取逐个解决问题的建议问题列表，以一一解决。

因此，如果您不想破坏一元正则表达式魔术，请不要再继续阅读。如果您确实想自己弄清楚该魔术，我强烈建议您先解决ECMAScript regex中的一些问题，如上面链接的那部分所述。

我最初面临的挑战：正整数X 为Fibonacci数当且仅当5× ² + 4和/或5× ² -图4是一个完全平方。但是在正则表达式中没有空间可以计算此值。我们唯一需要处理的空间就是数字本身。我们甚至没有足够的空间乘以5 或乘平方，更不用说两者了。

teukon关于如何解决它的想法（最初在这里发布）：

正则表达式以形式为字符串的形式呈现^x*$，令z为长度。手动检查z是否是前几个斐波那契数之一（最多应做21个）。如果不是：

1. 读取两个数字，a <b，使b不大于2a。
   
2. 使用前瞻性构建a ²，ab和b ²。
   
3. 断言或者5A ² + 4或5a ² -图4是一个完全平方数（因此必须为F _n-1个对一些N）。
   
4. 断言5b ² + 4或5b ² + 4是一个完美的正方形（因此b必须为F _n）。
   
5. 通过使用较早构建的a ²，ab和b ²以及标识，检查z = F _{2n + 3}或z = F _{2n + 4}：
   
   • F _2n-1 = F _n ² + F _n-1 ²
     
   • F _2n =（2F _n-1 + F _n）F _n
     

简言之：这些身份使我们能够减少检查给定的数字是斐波那契数来检查一对的问题，很多小的数字是斐波那契数。一个小代数将表明，对于足够大的n（应该做n = 3），F _{2n + 3} > F _n + 5F _n ² + 4总是应该有足够的空间。

而这里是在C算法的样机，我在正则表达式执行它之前写了一个测试。

因此，事不宜迟，这里是正则表达式：

^((?=(x*).*(?=x{4}(x{5}(\2{5}))(?=\3*$)\4+$)(|x{4})(?=xx(x*)(\6x?))\5(x(x*))(?=(\8*)\9+$)(?=\8*$\10)\8*(?=(x\2\9+$))(x*)\12)\7\11(\6\11|\12)|x{0,3}|x{5}|x{8}|x{21})$

在线尝试！

以及印刷精美，带有注释的版本：

^(
  (?=
    (x*)                   # \2+1 = potential number for which 5*(\2+1)^2 ± 4
                           # is a perfect square; this is true iff \2+1 is a Fibonacci
                           # number. Outside the surrounding lookahead block, \2+1 is
                           # guaranteed to be the largest number for which this is true
                           # such that \2 + 5*(\2+1)^2 + 4 fits into the main number.
    .*
    (?=                    # tail = (\2+1) * (\2+1) * 5 + 4
      x{4}
      (                    # \3 = (\2+1) * 5
        x{5}
        (\2{5})            # \4 = \2 * 5
      )
      (?=\3*$)
      \4+$
    )
    (|x{4})                # \5 = parity - determined by whether the index of Fibonacci
                           #               number \2+1 is odd or even
    (?=xx (x*)(\6 x?))     # \6 = arithmetic mean of (\2+1) * (\2+1) * 5 and \8 * \8,
                           #      divided by 2
                           # \7 = the other half, including remainder
    \5
    # require that the current tail is a perfect square
    (x(x*))                # \8 = potential square root, which will be the square root
                           #      outside the surrounding lookahead; \9 = \8-1
    (?=(\8*)\9+$)          # \10 = must be zero for \8 to be a valid square root
    (?=\8*$\10)
    \8*
    (?=(x\2\9+$))          # \11 = result of multiplying \8 * (\2+1), where \8 is larger
    (x*)\12                # \12 = \11 / 2; the remainder will always be the same as it
                           #       is in \7, because \8 is odd iff \2+1 is odd
  )
  \7\11
  (
    \6\11
  |
    \12
  )
|
  x{0,3}|x{5}|x{8}|x{21}   # The Fibonacci numbers 0, 1, 2, 3, 5, 8, 21 cannot be handled
                           # by our main algorithm, so match them here; note, as it so
                           # happens the main algorithm does match 13, so that doesn't
                           # need to be handled here.
)$

这些评论中没有解释乘法算法，但是在我的大量正则表达式文章的一段中对此做了简要解释。

我维护着六个不同版本的Fibonacci正则表达式：四个从最短长度到最快速度并使用上述算法，另外两个使用不同，更快但更长的算法，正如我发现的，实际上可以返回将Fibonacci索引作为匹配项（在此处说明该算法已超出了本文的范围，但在原始讨论Gist中对此进行了解释）。我不认为我会再维护很多非常相似的正则表达式版本，因为当时我正在PCRE和Perl中进行所有测试，但正则表达式引擎 足够快，以至于对速度的关注不再那么重要了（如果某个特定的结构造成了瓶颈，我可以对其进行优化）–尽管如果两者之间存在差异，我可能会再次维护一个最快的版本和一个最短的版本速度足够大。

“将斐波纳契指数减去1作为匹配项”版本（不打高尔夫球）：

在线尝试！

所有版本都在github上，其中包含高尔夫优化的完整提交历史记录：

用于匹配斐波那契数字的正则表达式-短，速度为0.txt（如本文中最短但最慢的
正则表达式）用于匹配斐波那契数字的正则表达式-短，速度为1.txt的
正则表达式用于匹配斐波那契数字-短，速度为2.txt的
正则表达式为匹配斐波纳契数字-简短，速度为3.txt的
正则表达式，用于匹配斐波那契数字-最快.txt
正则表达式，用于匹配斐波那契数字-返回index.txt

Python 3，48个字节

lambda n:0in((5*n*n+4)**.5%1,abs(5*n*n-4)**.5%1)

在线尝试！

Python 2，48 44字节

f=lambda n,a=0,b=1:n>a and f(n,b,a+b)or n==a

在线尝试

_{感谢Jonathan Allan节省了4个字节}

05AB1E，8 7字节

>ÅF¹å¹m

说明：

>ÅF       # Generate Fibbonacci numbers up to n+1
   ¹å     # 0 if original isn't in the list, 1 if it is
     ¹m   # 0**0 = 1 if input was 0 (hotfix for 0).
          # or 0**n if not fibb / 1**n if it is a fibb.

在线尝试！

-1感谢乔纳森·艾伦（Jonathan Allan）提供的0-不是斐波那契数字的解决方法。

Perl 6、23个字节

{$_∈(0,1,*+*...*>$_)}

认真地，3个字节

,fu

在线尝试！

如果为真，则返回斐波纳契数字列表中的索引+1，否则返回为假。

说明：

,fu
,   read input
 f  0-indexed index of that number in the fibonacci sequence (-1 if not in the sequence)
  u increment. (Makes the -1 value falsy and the 0-value truthy)

果冻， 8 7  6 个字节

-r‘ÆḞċ

在线尝试！

怎么样？

-r‘ÆḞċ - Link: non negative number, n
-      - literal -1      = -1
 r     - inclusive range = [-1,0,1,2,3,4,5,...,n]
  ‘    - increment n     = [ 0,1,2,3,4,5,6,...,n+1]
   ÆḞ  - Fibonacci       = [ 0,1,1,2,3,5,8,...,fib(n+1)]
     ċ - count occurrences of n (1 if n is a Fibonacci number, 0 otherwise)

笔记：

• 增量，‘，需要所以此工程为2和3，因为它们是3 ^次和4 ^次 Fibonacci数-超越3所有斐波那契数比他们更大的索引。
• 的-需要（而不仅仅是‘R），所以这适用于0，因为0是0 ^个斐波那契数;

ZX81 BASIC 180 151 100〜94个标记化BASIC字节

感谢SinclairZXWorld论坛上的Moggy，这是一个更加整洁的解决方案，可节省更多字节。

 1 INPUT I
 2 FOR F=NOT PI TO VAL "1E9"
 3 LET R=INT (VAL ".5"+(((SQR VAL "5"+SGN PI)/VAL "2")**I)/SQR VAL "5")
 4 IF R>=I THEN PRINT F=R
 5 IF R<I THEN NEXT F

如果输入斐波那契数，则将输出1；否则，将输出零。尽管这样可以节省字节，但比下面的旧解决方案要慢得多。为了提高速度（但需要更多的BASIC字节），请删除VAL字符串文字数字周围的包装。这是旧的（较旧的）解决方案，并带有一些解释：

 1 INPUT A$
 2 LET A=SGN PI
 3 LET B=A
 4 LET F=VAL A$
 5 IF F>SGN PI THEN FOR I=NOT PI TO VAL "1E9"
 6 LET C=A+B
 7 LET A=B
 8 LET B=C
 9 IF B>=F THEN GOTO CODE "£"
10 IF F THEN NEXT I
12 PRINT STR$(SGN PI*(B=F OR F<=SGN PI)) AND F>=NOT PI;"0" AND F<NOT PI

上面的修改节省了更多的BASIC字节，以将IF语句压缩为PRINT第12行中的单个语句；VAL使用GOTO CODE "£"Z 和ZX81字符集中的关键字和来保存其他字节，在所有数字值都以浮点数形式存储的情况下，字符串比数字保存更多的字节，因此在VAR堆栈上占用更多的空间。

C＃，109个字节

bool f(int n){int[]i=new[]{0,1,0};while(i[0]<n||i[1]<n){i[i[2]%2]=i[0]+i[1];i[2]++;}return n==i[0]||n==i[1];}

绝对可以改善，但是我没有时间。

> <>，21 19 + 3 = 24 22字节

i1\{=n;
?!\:@+:{:}(

预计输入将在程序启动时进入堆栈，因此该-v标志的+3字节。

在线尝试！

这是通过生成斐波那契数直到它们大于或等于输入数，然后检查最后生成的数与输入是否相等来起作用的。1如果是斐波那契数，0则输出，否则。

为确保0正确处理，种子为-1 1-生成的第一个数字为0而不是1。

感谢@cole指出，当STDIN为空时，i可用于将其压入-1堆栈。非常聪明！

先前版本：

01-1\{=n;
}(?!\:@+:{:

Mathematica，37个字节

!Fibonacci@n~Table~{n,0,#+1}~FreeQ~#&

@ngenisis中的-4个字节

MATL（16字节）

2^5*4-t8+hX^tk=s

在线尝试！

不是最复杂的解决方案，而是想使用直接方法来检查“ 5 * x ^ 2 +/- 4”是否为理想的正方形。

说明：

2^5*    % 5 times the input squared
4-      % push the above minus 4
t8+     % push the above plus 8 (+4 overall)
hX^     % concatenate them into an array and then take the sqrt().
tk      % push a copy of the array that is rounded using floor().
=       % test if the sqrt's were already integers
s       % sum the results, returns 0 if neither was a perfect square.

注意：

在“ 0”的情况下，它会返回“ 2”，因为4和-4都是完美的正方形，与1相同会产生“ 1 1”。将任何非零输出视为“真实”，将0输出视为“虚假”。

Pari / GP，32字节

n->!prod(x=0,n+1,fibonacci(x)-n)

在线尝试！

PHP，44字节

for(;0>$s=$x-$argn;)$x=+$y+$y=$x?:1;echo!$s;

在线尝试！

PHP，58字节

for($x=0,$y=1;$x<$argn;$x=$y,$y=$t)$t=$x+$y;echo$x==$argn;

在线尝试！

Java，72 69 68 63 59 55 50 49字节

n->{int a=0,b=1;for(;a<n;a=b-a)b+=a;return a==n;}

自己测试！

备用（仍为49个字节）

n->{int a=0,b=1;for(;a<n;b=a+(a=b));return a==n;}

不是很原始：这是简单的基本迭代版本。

这适用于包括1,836,311,903（第47个斐波纳契数）的数字。在此之上，结果是不确定的（包括潜在的无限循环）。

感谢Kevin Cruijssen和David Conrad帮助打高尔夫球:)

C＃（.NET Core），51字节

bool f(int n,int a=0,int b=1)=>a<n?f(n,b,a+b):a==n;

在线尝试！

-6个字节，感谢@Oliver！

该解决方案使用了非常简单的递归函数。

• 变量n是要测试的数字。
• 变量a和b是序列中的2个最新数字。
• 检查最近2个数字中的第一个是否小于输入。在这种情况下，将对系列中的下一个数字进行递归调用。
• 否则，请检查第一个数字是否等于输入并返回结果。

TIO链接演示了1134903170的工作，该工作超过了质询所要求的最大值。

炼金术士，205个 134字节

^{非常感谢仅ASCII的状态合并，节省了71个字节！}

_->In_x+c+u
u+b->u+a+d
u+0b->v
v+c->v+b+d
v+0c->w
w+a+x->w+y
w+0a+0x->Out_"1"
w+a+0x->Out_"0"
w+0a+x+y->w+2x
w+0a+0y+d->w+c
w+0d+0a->u

在线尝试或批量验证！

不打高尔夫球

# read input, initialize (c = 1)
_ -> In_x + c + s0

# a,d <- b
s0 +  b -> s0 + a + d
s0 + 0b -> s1

# b,d <- c
s1 +  c -> s1 + b + d
s1 + 0c -> s2

s2 +  a +  x -> s2 + y            # y <- min(a,x)
s2 + 0a + 0x -> Out_"1"           # if (a == x): was Fibonacci
s2 +  a + 0x -> Out_"0"           # if (a >  x): stop (we exceeded target)
s2 + 0a +  x +  y -> s2 + 2x      # if (a <  x): x += a (since y = a) / restore x
s2 + 0a      + 0y +  d -> s2 + c  # once that's done; c <- d
s2 + 0a           + 0d->s0        # and finally loop

果冻，5个字节

ȷḶÆḞi

在线尝试！

对于非斐波那契数字，返回0；对于斐波那契数字，该数字在斐波那契序列中的1索引位置。

说明：

ȷḶÆḞi
ȷ        The literal number 1000
 Ḷ       Range [0,1,...,999]
  ÆḞ     Get the ith Fib number; vectorizes [1,1,2,3,5,...,<1000th Fib number>]
    i    Get the first index of element in list, or 0 if not found

Dyalog APL，17个字节

0∊1|.5*⍨4 ¯4+5××⍨

在线尝试！

R，43 40字节

pryr::f(x%in%DescTools::Fibonacci(0:45))  

pryr::f 创建一个函数：

function (x) 
x %in% DescTools::Fibonacci(0:45)

用于DescTools::Fibonacci创建第一个x+1斐波那契数并检查是否包含。x+1因为第三个fibnum是2，而这不足以检查是否包含3。

幸运的是Desctools::Fibonacci(0)=0，这是一个不错的自由蜂。

-3个字节感谢MickyT

Haskell，31个字节

f=0:scanl(+)1f
(`elem`take 45f)

在线尝试！这利用了输入将在0到1,000,000,000之间的事实，因此我们只需要检查前45个斐波那契数。f=0:scanl(+)1f生成无限的斐波那契数字take 45f列表，是前45个斐波那契数字的列表，并elem检查输入是否在此列表中。

非限制版本：36字节

f=0:scanl(+)1f
g n=n`elem`take(n+3)f

在线尝试！对于任何n，如果是n+3斐波那契数字，则采用第一个斐波那契数字将保证它n会出现在此列表中。

请注意，这种方法对于非斐波那契数的高数而言效率极低，因为n+3需要计算所有斐波那契数。

Javascript（不含**运算子的ES6），44个位元组

f=(x,c=x*(Math.sqrt(5)-1)/2%1)=>x*(c-c*c)<.5

依靠连续的斐波那契数之间的比率接近黄金比率。c的值是输入的小数部分除以黄金分割率-如果输入是斐波那契，则该值将非常接近1，并且c-c²的值将非常小。

不像其他一些JS回答那样短，但是可以在O（1）时间内运行。

朱莉娅0.4，29字节

!m=in(0,sqrt(5*m*m+[4,-4])%1)

在线尝试！

如果这不是您要做的茱莉亚答案，请告诉我。我不确定输入如何在TIO上工作。

R，32 31字节

从标准输入，返回TRUE或FALSE根据需要获取输入。

any(!(5*scan()^2+-1:1*4)^.5%%1)

Common Lisp，61 54字节

(defun f(x)(do((a 0 b)(b 1(+ a b)))((>= a x)(= a x))))

在线尝试！

与先前版本相比尺寸减小：

(defun f(x)(do((a 0 b)(b 1 c)(c 1(+ b c)))((>= a x)(= a x))))

这是由以下想法触发的：要生成斐波那契数字的序列，仅需要两个变量，而不是三个。

Mathematica，33个字节

AtomQ@*InverseFunction[Fibonacci]

JS（ES6），57个字节

n=>(y=y=>((5*(n**2)+y)**0.5),~~y(4)==y(4)|~~y(-4)==y(-4))

使用carusocomputing的方法。比我的其他答案还多。

不打高尔夫球

n=>{
    y=y=>((5*(n**2)+y)**0.5);//carusocomputing's method in a function
    return ~~y(4) === y(4) || ~~y(-4) === y(-4);//~~x === Math.floor(x)
}