打印包含第n个斐波那契数的第n个斐波那契数！

22

挑战

您必须编写一个程序，以正整数n作为输入，并输出n包含n第Fib＃号作为子字符串的第Fibonacci号（在整个过程中简称为Fib＃）。出于此挑战的目的，斐波那契序列以开头1。

以下是一些示例，您可以将它们用作测试用例，或者用作阐明挑战的示例（对于后者，请在下面留下注释，说明您不清楚的地方）。

n=1
Fib#s: 1
       ^1 1st Fib# that contains a 1 (1st Fib#)
Output: 1

n=2
Fib#s: 1, 1
       ^1 ^2 2nd Fib# that contains a 1 (2nd Fib#)
Output: 1

n=3
Fib#s: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233
             ^1              ^2                   ^3 3rd Fib# that contains a 2 (3rd Fib#)
Output: 233

n=4
Output: 233

n=5
Output: 6765

n=6
Output: 28657

n=7
Output: 1304969544928657

n=8
Output: 14472334024676221

n=9
Output: 23416728348467685

n=10
Fib#s: 1, ..., 34, 55, 89, ..., 63245986, 102334155, 165580141, ..., 2880067194370816120, 4660046610375530309
                   ^1                     ^2         ^3                                   ^10 10th Fib# that contains a 55 (10th Fib#)
Output: 4660046610375530309

与往常一样，这是code-golf，因此请尽可能减少字节数。

如果有什么令人困惑/不清楚的地方，请发表评论。

（此挑战基于我发布的另一个挑战：打印包含n的第n个素数）

code-golf  math  number  fibonacci 
— ericw31415
source
3
我建议包括n=5测试用例，因为我只是犯了一个愚蠢的错误，我在其中写了一张支票，如果子字符串不止一次，则该支票要数多次。n=5会因为...而赶上它55。
— 与Orjan约翰森
2
@officialaimm我认为期望很高的数字是不合理的。我的解决方案最多可在TIO上工作n=25（输出有1186位数字），然后被杀死n=26（在我自己的笔记本电脑上编译为3085位数字）。每当再fib(n)获得一位数字时，难度似乎都会增加（正如人们期望的那样）。下一跳31在最终输出中具有12990位数。
— 与Orjan约翰森
1
是。大声笑！我的python解决方案在n> 6时卡住了，因为有一个递归函数在循环中被多次调用。：D
— Officialaimm
1
@officialaimm哦，对了，直接用递归定义斐波那契时，指数爆炸是个问题。即使没有，您也可能很快达到Python的递归限制。
— 与Orjan约翰森
1
@Shaggy：这就是我的意思是一致的：当0是第0个斐波那契数字时，则1是第一个（“第1个”斐波那契数字）。
— ShreevatsaR

Answers:

12

哈斯克尔，85 84字节

编辑：

  • -1个字节：Laikoni缩短了l。
  • 错字（x>=s用于x<=s在解释）。

f取Int并返回String。

l=0:scanl(+)1l
m=show<$>l
f n|x<-m!!n=[y|y<-x:m,or[x<=s|s<-scanr(:)""y,x++":">s]]!!n

在线尝试！

怎么运行的

  • l是斐波纳契数的无限列表，递归定义为的部分和0:1:l。它开始于0因为列表是0索引的。m是转换为字符串的相同列表。
  • 在 f：
    • n 是输入数字，并且 x是第（一个）n斐波那契数字（的字符串）。
    • 在外部列表理解中，y是测试斐波那契数字是否包含x为子字符串的数字。传递的ys收集在列表中，并与最终索引建立索引!!n以提供输出。一个额外的x在测试之前的命令，以节省最后两个字节!!(n-1)。
    • 为避免y数次计数，将每个测试y包入or并进行另一个列表理解。
    • 在内部列表理解中，s迭代以下的后缀y。
    • 要测试是否x是的前缀s，我们检查x<=s和 x++":">s。（":"在某种程度上是任意的，但必须大于任何数字。）
— ØrjanJohansen
source
1
l=0:scanl(+)1l保存一个字节。
— Laikoni
4

Python 2中，99 86个字节

f=n=input()
b=i=x=-1
a=1
while(n>2)*f:i+=1;a,b=a+b,a;x=[x,a][i==n];f-=`x`in`a`
print a

在线尝试！

说明：

f=n=int(input())                 # f is number of required numbers

b=i=x=-1                         # i is index(counter) set at -1
                                 # In Two-sided fibonacci, fib(-1) is 1 
                                 # and b(fib before it) i.e. fib(-2) is -1
                                 # Taking advantage of all -1 values, x is 
                                 # also set to -1 so that the `if str(...`
                                 # portion does not execute until x is set a 
                                 # value(i.e. the nth fibonacci) since there 
                                 # is no way -1 will be found in the number 
                                 # (ALL HAIL to Orjan's Genius Idea of using 
                                 # two-sided fibonacci)      

a=1                              # fib(-1) is 1


while(n>2)*f:                    # no need to perform this loop for n=1 and 
                                 # n=2 and must stop when f is 0

 i+=1                            # increment counter

 b,a=a,a+b                       # this might be very familiar (fibonacci 
                                 # thing ;))                         

 x=[x,a][i==n]                   # If we have found (`i==n`) the nth 
                                 # fibonacci set x to it

 f-=`x`in`a`                     # the number with required substring is 
                                 # found, decrease value of f

print a                          # print required value

Python 3中，126个 120 113 112 110 101 99字节

f=n=int(input())
b=i=x=-1
a=1
while(n>2)*f:i+=1;a,b=a+b,a;x=[x,a][i==n];f-=str(x)in str(a)
print(a)

在线尝试！

— 官方网站
source
1
您可以通过删除b=i=x=-1 a=1和删除7个字节x and 。（基本上从双面斐波那契序列
— -1，1，0，1，1，2
1
您在-1：P
— ØrjanJohansen
1
额腮红。另外，我想摆脱`和n> 2`，但似乎n==2确实需要特殊对待。但是可以缩短为*(n>2)。
— 与Orjan约翰森
1
将其压缩到88个字节，某些更改是python 2独有的，但其他更改也将在python 3中起作用
— Felipe Nardi Batista
1
对于python 3，您仍然可以高尔夫9个字节：此处
— Felipe Nardi Batista
4

Java，118 111字节

i->{long n=i,p=0,q,c=1;for(;--n>0;p=c,c+=q)q=p;for(n=c;i>0;q=p,p=c,c+=q)if((""+c).contains(""+n))--i;return p;}

我一直认为不应该复制斐波那契位，但我的所有努力都会导致更多字节。

多亏了凯文（Kevin）的改进...猜测它表明这是我第一次打高尔夫球:)

— 拉斯洛克
source
2
不允许使用摘要。您应该像这样将其变成lambda：i->{long n=i,p=0,q,c=1;while(--n>0){q=p;p=c;c+=q;}n=c;while(i>0){if((""+c).contains(""+n))--i;q=p;p=c;c+=q;}return p;}（118个字节）
— Okx
1
欢迎来到PPCG！@Okx指出，将其更改为lambda后，我必须说这是一个令人印象深刻的答案。大约一个小时前，我正准备在午餐前做这个挑战，然后放弃了。所以我+1。打高尔夫球的一些小事情：while(--n>0){q=p;p=c;c+=q;}可以for(;--n>0;p=c,c+=q)q=p;而且n=c;while(i>0){if((""+c).contains(""+n))--i;q=p;p=c;c+=q;}可以for(n=c;i>0;q=p,p=c,c+=q)if((""+c).contains(""+n))--i;。（总共：i->{long n=i,p=0,q,c=1;for(;--n>0;p=c,c+=q)q=p;for(n=c;i>0;q=p,p=c,c+=q)if((""+c).contains(""+n))--i;return p;}（111字节）
— 凯文Cruijssen
2

Perl 6、45字节

{my@f=0,1,*+*...*;@f.grep(/$(@f[$_])/)[$_-1]}

$_是该函数的参数；@f是斐波那契序列，是延迟生成的。

— 肖恩
source
2

JavaScript（ES6），96 93 92 90 86字节

0索引，序列中的第0个数字是 1。爬到14。

f=(n,x=1,y=1)=>n?f(n-1,y,x+y):x+""
g=(n,x=y=0)=>x>n?f(y-1):g(n,x+!!f(y++).match(f(n)))

试试吧

f=(n,x=1,y=1)=>n?f(n-1,y,x+y):x+""
g=(n,x=y=0)=>x>n?f(y-1):g(n,x+!!f(y++).match(f(n)))
oninput=_=>o.innerText=(v=+i.value)<14?`f(${v}) = ${f(v)}\ng(${v}) = `+g(v):"Does not compute!"
o.innerText=`f(0) = ${f(i.value=0)}\ng(0) = `+g(0)
<input id=i min=0 type=number><pre id=o>
展开摘要

说明

一分钟后更新的版本。

f=...                   :Just the standard, recursive JS function for generating the nth Fibonacci number
g=(...)=>               :Recursive function with the following parameters.
n                       :  The input integer.
x=0                     :  Used to count the number of matches we've found.
y=0                     :  Incremented on each pass and used to generate the yth Fibonacci number.
x>n?                    :If the count of matches is greater than the input then
f(y-1)                  :    Output the y-1th Fibonacci number.
:                       :Else
g(...)                  :    Call the function again, with the following arguments.
n                       :      The input integer.
x+                      :      The total number of matches so far incremented by the result of...
RegExp(f(n)).test(f(y)) :        A RegEx test checking if the yth Fibonacci number, cast to a string, contains the nth Fibonacci number.
                        :        (returns true or false which are cast to 1 and 0 by the addition operator)
y+1                     :      The loop counter incremented by 1
— 毛茸茸
source
您的答案似乎提供了与示例不同的输出。
— ericw31415
@ ericw31415，这是因为它的索引为0。
— 毛茸茸的
我写的特别是这样写的：“就本挑战而言，斐波那契数列以1开头。”
— ericw31415
@ ericw31415：我的序列确实以1开头，只是从0开始索引；序列中的第0个和第1个数字是1，第2个是2，第3个是3，第4个是5，第5个是8，依此类推。
— 毛茸茸的
2

木炭，65字节

ＡＩθνＡνφＡ±¹βＡβιＡβξＡ¹αＷ∧›ν²φ«Ａ⁺ι¹ιＡ⁺αβχＡαβＡχαＡ⎇⁼ιναξξＡ⁻φ›№ＩαＩξ⁰φ»Ｉα

在线尝试！链接到详细代码进行解释。

— 仅ASCII
source
1

Mathematica，85个字节

(i=ToString;f=Fibonacci;For[n=t=0,t<#,If[i@f@n++~StringContainsQ~i@f@#,t++]];f[n-1])&

输入

[10]

@JungHwan Min的-4个字节

输出

4660046610375530309

— J42161217
source
2
看起来很奇怪，但f@i@n++完全有效，减少了1个字节。使用For代替While减少3个字节。85个字节：(i=ToString;f=Fibonacci;For[n=t=0,t<#,If[i@f@n++~StringContainsQ~i@f@#,t++]];f[n-1])&
— JungHwan Min
提醒一下，分别声明全局变量是完全可以的。我的错。
— JungHwan Min
1

R，77 72字节

F=gmp::fibnum;i=0;d=n=scan();while(n)if(grepl(F(d),F(i<-i+1)))n=n-1;F(i)

这利用gmp了斐波那契数的库。完全直截了当执行该问题。

F=gmp::fibnum;          # Alias Fibonacci function to F
i=0;                    # intitalise counter
d=n=scan();             # get n assign to d as well
while(n)               # loop while n
  if(grepl(F(d),F(i<-i+1)))  # use grepl to determine if Fib of input is in Fib# and increment i
     n=n-1;             # decrement n
F(i)                  # output result

一些测试

> F=gmp::fibnum;i=0;d=n=scan();while(n)if(grepl(F(d),F(i<-i+1)))n=n-1;F(i)
1: 2
2: 
Read 1 item
Big Integer ('bigz') :
[1] 1
> F=gmp::fibnum;i=0;d=n=scan();while(n)if(grepl(F(d),F(i<-i+1)))n=n-1;F(i)
1: 3
2: 
Read 1 item
Big Integer ('bigz') :
[1] 233
> F=gmp::fibnum;i=0;d=n=scan();while(n)if(grepl(F(d),F(i<-i+1)))n=n-1;F(i)
1: 10
2: 
Read 1 item
Big Integer ('bigz') :
[1] 4660046610375530309
> F=gmp::fibnum;i=0;d=n=scan();while(n)if(grepl(F(d),F(i<-i+1)))n=n-1;F(i)
1: 15
2: 
Read 1 item
Big Integer ('bigz') :
[1] 1387277127804783827114186103186246392258450358171783690079918032136025225954602593712568353
— 米奇
source
0

Clojure，99个字节

(def s(lazy-cat[0 1](map +(rest s)s)))#(nth(filter(fn[i](.contains(str i)(str(nth s %))))s)(dec %))

一个基本的解决方案是使用无限的斐波那契数列s。

— 尼古妮
source
0

C＃，35个字节

int u=1,b=1;for(;b<n;){b+=u;u=b-u;}

试试吧

int n=int.Parse(t2.Text);int u=1,b=1;for(;b<n;){b+=u;u=b-u;t.Text+=b.ToString()+" ";}if(b==n){t.Text+="true";}
— 埃兰兹·卡尔沃
source
1
欢迎参加“编程难题”和“代码高尔夫球”。答案既可以是完整程序，也可以是函数，而您仅提供了一个片段。特别是，您假设输入在其中，n而您只是将输出放入b（我认为）。您可以编写以n参数作为参数并返回b...。此外，我很确定您没有计算挑战所要求的内容。实际上，我不知道您在计算什么。您能否提供一些我们可以用来验证您的解决方案的代码？（您的“尝试它”不能原样运行。）
— 达达
0

NewStack，14个字节

N∞ ḟᵢfi 'fif Ṗf⁻

细目：

N∞              Add all natural numbers to the stack
   ḟᵢ           Define new function will value of input
     fi          Get the n'th Fibonacci number for ever element n
       'fif      Remove all elements that don't contain the (input)'th Fibonacci number 
           Ṗf⁻  Print the (input-1)'th element

用英语： 以输入3为例）

N∞：列出自然数 [1,2,3,4,5,6...]

ḟᵢ：将输入存储在变量中 f [1,2,3,4,5,6...]

fi：将列表转换为斐波那契数字 [1,1,2,3,5,8...]

'fif：保留所有包含f第斐波那契数的元素[2,21,233...]

Ṗf⁻：打印 f-1 th个元素（由于从0开始的索引而为-1）233

— 引力子
source
GitHub似乎只包含一个自述文件和一个教程。引用了一个实现，但未链接。尽管PPCG现在允许使用比挑战性更新的语言，但我相信我们仍然需要公开可用的实现。
— 与Orjan约翰森
@ØrjanJohansen，啊，谢谢您提醒我。我忘了上传！一会儿就可以了。
— 重力1998年
您的实现似乎使用了UTF-8，在这种情况下，实际上是28个字节（不要介意Haskell设置，我仅使用TIO来计数字节）。因此，像Jelly等语言具有自己的代码页。
— 与Orjan约翰森
@ØrjanJohansenTouché，正如我们所说的，我正在为它自己的编码分配表。
— Graviton
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.