Défi

Vous devez écrire un programme qui prend un entier positif nen entrée et ngénère le numéro de Fibonacci (abrégé en Fib # partout) qui contient le nth Fib # en tant que sous-chaîne. Aux fins de ce défi, la séquence de Fibonacci commence par a 1.

Voici quelques exemples que vous pouvez utiliser comme cas de test ou comme exemples pour clarifier le défi (pour ce dernier, veuillez laisser un commentaire ci-dessous expliquant ce que vous trouvez peu clair).

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

Comme toujours, il s'agit de code-golf , alors optez pour le nombre d'octets le plus bas possible.

Si quelque chose prête à confusion / n'est pas clair, veuillez laisser un commentaire.

(Ce défi est basé sur un autre défi que j'ai publié: Imprimer le nième nombre premier qui contient n )

Haskell , 85 84 octets

MODIFIER:

• -1 octet: Laikoni raccourci l.
• Typo ( x>=sfor x<=s) dans l'explication.

fprend un Intet retourne un 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

Essayez-le en ligne!

Comment ça marche

• lest la liste infinie des nombres de Fibonacci, définie récursivement comme les sommes partielles de 0:1:l. Il commence par 0parce que les listes sont indexées 0. mest la même liste convertie en chaînes.
• Dans f:
  • nest le numéro d'entrée, et xest la (chaîne du) nème numéro de Fibonacci.
  • Dans la compréhension de la liste externe, yun nombre de Fibonacci est testé pour savoir s'il contient xcomme sous-chaîne. Les ys qui passent sont collectés dans la liste et indexés avec la finale !!npour donner la sortie. Un supplément xest ajouté aux tests pour économiser deux octets de plus !!(n-1)à la fin.
  • Pour éviter de compter ys plusieurs fois, les tests de chacun ysont encapsulés oret une autre liste de compréhension.
  • Dans la compréhension de la liste intérieure, sitère à travers les suffixes de y.
  • Pour tester si xc'est un préfixe de s, nous vérifions si x<=set x++":">s. ( ":"est quelque peu arbitraire mais doit être plus grand que n'importe quel chiffre.)

Gelée , 15 14 octets

1 octet merci à Jonathan Allan.

0µ³,ÆḞẇ/µ³#ÆḞṪ

Essayez-le en ligne!

Python 2 , 99 86 octets

• Ørjan Johansen Sauvegardé 7 octets: commencer b=i=x=-1 a=1et supprimer lex and
• Ørjan Johansen réenregistré 3 octets: f and n==2àf*(n>2)
• Felipe Nardi Batista a économisé 9 octets: a,b=a+b,araccourci de swap économique f-=str(x)in str(a), pressé(n<2)*f
• ovs a économisé 13 octets: transition de python 3 à python 2.

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

Essayez-le en ligne!

Explication:

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 octets

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)

Essayez-le en ligne!

Java, 118 111 octets

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

Je continue de penser qu'il devrait être possible de ne pas dupliquer le bit Fibonacci, mais tous mes efforts se traduisent en quelque sorte par plus d'octets.

Merci à Kevin pour les améliorations ... je suppose que cela montre que c'était ma première tentative de golf :)

Perl 6 , 45 octets

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

$_est l'argument de la fonction; @fest la séquence de Fibonacci, générée paresseusement.

JavaScript (ES6), 96 93 92 90 86 octets

Indexé en 0, le 0ème numéro de la séquence étant 1. Craps out 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)))

• 2 6 octets économisés grâce à Arnauld

Essayez-le

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>

Explication

Version mise à jour à suivre, quand j'aurai une minute.

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

Fusain , 65 octets

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

Essayez-le en ligne!Lien vers le code détaillé pour explication.

PHP , 96 octets

for($f=[0,1];$s<$a=$argn;$s+=$f[$a]&&strstr($f[$i],"$f[$a]")?:0)$f[]=$f[$i]+$f[++$i];echo$f[$i];

Essayez-le en ligne!

Mathematica, 85 octets

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

contribution

[dix]

-4 octets de @JungHwan Min

sortie

4660046610375530309

R, 77 72 octets

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

Cela utilise la gmpbibliothèque pour le numéro de Fibonacci. Mise en œuvre assez directe de la question.

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

Quelques tests

> 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

Clojure, 99 octets

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

Une solution de base, utilise une séquence infinie de nombres de Fibonacci s.

C #, 35 octets

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

Essayez-le

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";}

NewStack , 14 octets

N∞ ḟᵢfi 'fif Ṗf⁻

La ventilation:

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

En anglais: (avec exemple d'une entrée de 3)

N∞: Faites une liste des nombres naturels [1,2,3,4,5,6...]

ḟᵢ: Stocker l'entrée dans la variable f [1,2,3,4,5,6...]

fi: Convertir la liste en nombres de Fibonacci [1,1,2,3,5,8...]

'fif: Conserver tous les éléments qui contiennent le fnuméro de Fibonacci[2,21,233...]

Ṗf⁻: Affiche le f-1e élément (-1 en raison de l'indexation basée sur 0)233

Japt , 16 15 octets

_søNg)«´U}a@MgX

Essayez-le