Ben bir Fibonacci Numarası mıyım?


49

Senin görevin:

Girilen bir sayının Fibonacci numarası olup olmadığını kontrol etmek için bir program veya işlev yazın . Bir Fibonacci sayısı, Fibonacci dizisinde bulunan bir sayıdır.

Fibonacci Dizisi şöyle tanımlanır: F(n) = F(n - 1) + F(n - 2)

Tohumları ile F(0) = 0ve F(1) = 1.

Giriş:

Bir Fibonacci numarası olan veya olmayan 0 ila 1,000,000,000 arasında negatif olmayan bir tam sayı.

Çıktı:

Girişin bir Fibonacci numarası olup olmadığını belirten bir truthy / falsy değeri.

Örnekler:

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

Puanlama:

Bu , en düşük bayt sayısı kazanıyor.


2
Kullandığım programlama dili yalnızca 9999'a kadar olan rakamları (Geometry Dash) destekler. Teorik olarak 1000000'e kadar sayıları desteklediğini varsayarsam sorun olmaz mı?
MilkyWay90

Yanıtlar:


36

Neim , 2 bayt

f𝕚

Açıklama:

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

Benim Kalça ile aynı Kare cevabı gibi çalışır, ancak farklı bir sonsuz liste kullanır:, ffibonacci için.

Dene!


1
Vaov! Etkileyici puan.
Gryphon - Monica

2
Bu harika, ama 2 bayt değil. UTF-8'de "66 F0 9D 95 9A" olarak temsil edilir
sm4rk0

10
@ sm4rk0 Bu harika, ama yanılıyorsun. Neim özel bir kod sayfası kullanıyor , bu yüzden bunun bayt temsili66 D5
Okx

Giriş listede değilse, bu sonsuza kadar döngü yok mu? Eğer öyleyse, bu yanlış sayılıyor mu?
Enrico Borba

@EnricoBorba Neim, bu sonsuz listedeki n elementinin daima listedeki n + 1 elemente eşit veya ondan daha az olacağını biliyor. Bu nedenle, kendisini yakalayabilir ve sonsuza dek çalışmayacak. Programı denedin mi? : P
Okx,

18

JavaScript (ES6), 34 bayt

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

Girdiden büyük veya eşit bir öğe bulana kadar tekrarlı bir şekilde Fibonacci dizisini oluşturur, ardından item == input değerini döndürür.


Not: Fibonacci sekansının saf özyinelemeli hesaplaması O (Fib (n)) - yaklaşık O (1.6 ^ n)
Alnitak

f = n => n? n> 2? f (n-1) + f (n-2): 1: 0 28bayt
jackkav

@jackkav Teşekkürler ama meydan girişi olmadığını belirlemektir olan bir Fibonacci sayı.
ETHproductions

12

Retina , 23 bayt

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

Çevrimiçi deneyin!

Tekli giriş, çıkış 0veya 1.

açıklama

Fibonacci dizisi ileriye referansları olan bir çözüm için iyi bir adaydır, yani çevreleyen bir gruba veya daha sonra regex'te görünen bir gruba atıfta bulunan bir "geri referans" (bu durumda, ikisini de kullanıyoruz). Bunun gibi sayıları eşleştirirken, dizi öğeleri arasındaki fark için özyinelemeli bir ifade bulmamız gerekir . Örneğin, üçgen sayıları eşleştirmek için, genellikle önceki bölüm artı bir sayı ile eşleşiriz. Kare sayıları (farklılıkları tek sayılar olan) eşleştirmek için önceki segment artı iki eşleşiriz.

Fibonacci sayılarını sonuncuya ikinci-son elemanı ekleyerek elde ettiğimizden, aralarındaki farklar da sadece Fibonacci sayılarıdır. Bu yüzden, her bir segmenti önceki ikisinin toplamı olarak eşleştirmemiz gerekiyor. Regex'in özü şudur:

(         # 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.
)*

Şimdi bu, 1'den başlayan Fibonacci sayılarını , yani 1, 1, 2, 3, 5, ... ekleyerek sona erer . Bunlar kadar ekleyin , 1, 2, 4, 7, 12 ... . Yani, Fibonacci sayılarından bir taneden küçükler, bu yüzden 1sonuna bir ekleyelim . Bunun kapsamadığı tek durum sıfırdır, bu yüzden ^$başlangıçta bunu örtecek alternatifimiz vardır.


2
Çok zarif! ^$|^(^1|\2?+(\1))*1$
Bütünlüğün iyiliği için, PCRE'de

1
@Deadcode .NET'de çok özlüyorum;)
Martin Ender

Gereksiz saniye kaldırarak 1 bayt kaydedin ^.
Neil

12

Regex (ECMAScript lezzet), 392 358 328 224 206 165 bayt

Fibonacci sayılarını ECMAScript regex (unary) ile eşleştirmek için uygulanması gereken teknikler, çoğu regex tatında en iyi şekilde yapılmasından çok uzaktır. Ileri / iç içe geçmiş referansların veya özyinelemelerin olmaması, toplam bir şeyi doğrudan saymanın veya sürdürmenin imkansız olduğu anlamına gelir. Bakış açısının eksikliği, çalışmak için yeterli alana sahip olmanın bile sıkıntı yaratmasını güçleştiriyor.

Pek çok soruna tamamen farklı bir bakış açısıyla yaklaşılmalı ve bazı önemli içgörüler gelinceye kadar çözülemez görünmektedir. Çalıştığınız sayıların hangi matematiksel özelliklerinin, belirli bir problemi çözülebilir hale getirmek için kullanılabileceğini bulmakta çok daha geniş bir ağ oluşturmaya zorlar.

Mart 2014'te Fibonacci sayıları için olan bu oldu. Vikipedi sayfasına bakarken, başlangıçta bir yöntem bulamamıştım, ancak belirli bir özellik titizlikle yakın görünüyordu. Sonra matematikçi teukon , bu özelliği bir başkasıyla birlikte kullanmanın mümkün olabileceğini açıkça belirten bir yöntem belirledi . Rejimi inşa etmek konusunda isteksizdi. Devam edip yaptığım tepkisi:

Çılgınsın! ... bunu yapabileceğini düşündüm.

Diğer ECMAScript unary matematik regex gönderilerimde olduğu gibi, bir uyarı vereceğim : ECMAScript regex'te unary matematiksel problemlerin nasıl çözüleceğini öğrenmenizi şiddetle tavsiye ediyorum. Benim için büyüleyici bir yolculuk oldu ve bunu denemek isteyebilecek herhangi biri için, özellikle de sayı teorisine ilgi duyanlar için onu mahvetmek istemiyorum. Birbiri ardına çözmek için art arda spoiler etiketli önerilen sorunların bir listesi için bu yazı bakın .

Öyleyse , eğer sizin için şımarık bazı regex sihrini istemiyorsanız, daha fazla okumayın . Bu sihri kendiniz bulmaya bir göz atmak istiyorsanız, yukarıda belirtilen bağlantıda belirtildiği gibi ECMAScript regex'teki bazı sorunları çözerek başlamanızı şiddetle tavsiye ederim.

Başlangıçta karşılaştığım zorluk: Pozitif x tamsayı bir Fibonacci sayısı, eğer sadece 5x 2 + 4 ve / veya 5x 2 - 4 mükemmel bir kare ise. Ancak bunu bir regex'te hesaplamak için yer yoktur. Çalışmamız gereken tek yer sayının kendisi. Her ikisini de tek başımıza bırakarak 5 ile çarpmak veya kareyi almak için bile yeterli odamız yok .

teukon'un bunu nasıl çözeceğine dair fikri ( aslen burada yayınlanmıştır ):

Düzenli ifade, formun bir dizesiyle sunulur ^x*$, z uzunluğu olsun. Z'nin elle yapılan ilk birkaç Fibonacci sayısından biri olup olmadığını kontrol edin (21'e kadar yapmalı). Ya değilse:

  1. Birkaç rakamı oku, b <a'dan büyük olmayacak şekilde.
  2. 2 , ab ve b 2 oluşturmak için ileriye dönük bakışlar kullanın .
  3. 5a 2 + 4 veya 5a 2 - 4'ün mükemmel bir kare olduğunu varsayalım (bu nedenle , bazı n'ler için Fn-1 olmalıdır ).
  4. 5b 2 + 4 veya 5b 2 + 4'ün mükemmel bir kare olduğunu varsayalım (bu nedenle bn Fn olmalıdır ).
  5. Bu z kontrol = F 2n + 3 veya Z = F olduğu 2n + 4 önceki kullanarak inşa 2 , ab, ve b 2 ve kimlikleri
    • F 2-n-1 = F , n 2 + F , n-1 2
    • F 2n = (2F , n-1 + K , n ) F , n
Kısacası: Bu kimlikler, verilen bir sayının Fibonacci olduğunu kontrol etme sorununu azaltmamıza izin veriyor, bir çift daha küçük sayının Fibonacci olduğunu kontrol etmek için . Küçük bir cebir, yeterince büyük n (n = 3'ün yapması gereken), F 2n + 3 > F n + 5F n 2 + 4 için her zaman yeterince yer olması gerektiğini gösterecektir.

Ve işte, Regex'te uygulamadan önce bir test olarak yazdığım C'deki algoritma listesi .

Yani daha fazla ado olmadan, işte regex:

^((?=(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})$

Çevrimiçi deneyin!

Ve güzel basılmış, yorumladı sürümü:

^(
  (?=
    (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.
)$

Çarpma algoritması bu yorumlarda açıklanmıyor, ancak regex posta mesajımın bol olduğu bir paragrafta kısaca açıklanıyor .

Fibonacci regex'in altı farklı versiyonunu koruyordum: en kısa uzunluktan en yüksek hıza kadar cırcırlanan ve yukarıda açıklanan algoritmayı kullanan dört kişi ve farklı, çok daha hızlı fakat çok daha uzun bir algoritma kullanan iki kişi Maç olarak Fibonacci endeksi (buradaki algoritmanın bu yazının kapsamı dışında olduğunu açıklamak, ancak Gist'in orijinal tartışmasında açıklanmıştır ). Bir regex'in pek çok benzer versiyonunu tekrar koruyacağımı sanmıyorum, çünkü o sırada PCRE ve Perl'deki tüm testlerimi, ancak regex motorumu yapıyordum. hız endişelerinin artık o kadar önemli olmadığı kadar hızlıdır (ve belirli bir yapı tıkanıklığa neden oluyorsa, bunun için bir optimizasyon ekleyebilirim) - muhtemelen yine en hızlı ve en kısa bir sürümü yine de koruyabilirim hızda yeterince büyüktü.

"Fibonacci endeksi eksi 1'i bir eşleşme olarak döndür" versiyonu (ağır golf oynamamaktadır):

Çevrimiçi deneyin!

Tüm sürümler, golf optimizasyonlarının tam bir tarihçesiyle github'da:

Fibonacci sayıları eşleştirmek için regex - kısa, hızlı 0.txt (bu yazıdaki gibi en kısa ama en kısa olanı)
Fibonacci sayıları eşleştirmek için regex - kısa, hız 1. fxt
için
regex Fibonacci sayılarını eşleştirmek - kısa, hızlı 3.txt
regex Fibonacci sayılarını eşleştirmek için - fastest.txt
regex Fibonacci sayılarını eşleştirmek için - return index.txt


9

Python 3 , 48 bayt

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

Çevrimiçi deneyin!


1
Python olmak, isteğe bağlı olarak büyük girdiler için yeterli kaynak sağlanmamalı mı?
Jonathan Allan,

2
Hesaplamalar veri tipine uyuyorsa ve sınırsız hassasiyet verilen teoride pratikte çalıştığı sürece istediğimiz algoritmayı ne kadar kullanabileceğimizi her zaman izledim. Elbette, yalnızca intçubuğu daha yüksek (hala isteğe bağlı olarak büyük değil) ayarlayacaktır, fakat C cevaplarını 64-bit tamsayılar (veya gcc ile 128-bit) kullanmaya zorlamayız. Her halükarda, aynı algoritmayı bir dilde kullanabilmek ancak bir başkasını kullanmamak saçma sapan görünüyor.
Dennis,

Algoritmik görünüm anlamlıdır (“veri türüne sığdır” kriterlerini belirleyen girdi alanı olduğunu hep düşünmüştüm). İzlenecek tek şey , algoritma fikri ile uygulaması arasındaki gri alandır . İşte bir olabilir tamsayılar birini yüzen olmadan döküm kare olup olmadığını kontrol edin. Yan etki olarak içsel bir aldatmanın meşru, çalışma algoritmasının bir parçası olduğu sürece kabul edilebilir olduğunu tahmin ediyorum (... ve alçıya dayanan bir algoritmanın kabul edilemeyeceğinden eminim).
Jonathan Allan,

@JonathanAllan İşlenecek maksimum değer 1e9 olduğundan, keyfi olarak büyük girdilerin bir sorun olacağını düşünmüyorum.
JAD

1
@JarkoDubbeldam evet, yorumum yapıldıktan sonra bu ayrıntı gerçekten değiştirildi.
Jonathan Allan,

7

Python 2, 48 44 bayt

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

Çevrimiçi deneyin

Jonathan Allan'a 4 byte kaydettiği için teşekkürler


Eğer truthy değerleri olabilir Falseve sahte değerler ise bu 47 byte olabilir True: TIO!
Bay Xcoder

n-aYerinde de kullanabilirler n==ave -1 ve 0 değerlerine sahip olabilirsiniz.
Magic Octopus Urn

@carusocomputing Düzenleme geçmişimde vardı, ancak işe yaramıyor, çünkü daha büyük test değerleri için -101bunun yerine başka bir sonuç olabilir -1.
mbomb007

@ Mr.Xcoder gerçekten 1 byte tasarrufunun herkesin aklına değer olduğunu düşünüyor musunuz?
frarugi87

1
@ frarugi87 Bir bayt kaydetmek her zaman buna değer
Bay Xcoder

7

05AB1E , 8 7 bayt

>ÅF¹å¹m

Açıklama:

>Å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.

Çevrimiçi deneyin!

-1, fibonacci-numarası olmayan geçici çözüm için Jonathan Allan'a teşekkürler.


Aslında, 6 bayta güncellenmeyecek. 3 baytın altındaki bir listeye 0 eklemenin bir yolu olmadığına inanamıyorum.
Magic Octopus Urn,

@JonathanAllan, 05AB1E’deki "üretme fibbonacci işlevi" 0 içermez.
Magic Octopus Urn

@JonathanAllan Şimdi anlıyorum, iyi fikir. Orada neler olup bittiğini anlamak için bana bir dakika sürdü.
Magic Octopus Urn,

Kapsayıcı nolduğu gibi ÅFher iki şekilde ¹åde sonuçlanacak kadar (bir bayt tasarrufu) üretmek yeterli olmaz mı? 0n=0
Emigna

0AF = []. 1AF = [1,1]. Öyle görünüşte değil.
Magic Octopus Urn


5

Cidden , 3 bayt

,fu

Çevrimiçi deneyin!

Truthy ise Fibonacci sayıları listesinde +1 dizinini döndürür, aksi takdirde falsy döndürür.

Açıklama:

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

9
Cidden kaba ^^
Jonathan Allan

5

Jöle ,  8 7  6 bayt

-r‘ÆḞċ

Çevrimiçi deneyin!

Nasıl?

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

Notlar:

  • artım, yani bunun için çalışır gereklidir 2 ve 3 onlar olduğundan, 3 rd ve 4 th ötesinde - Fibonacci sayıları 3 tüm Fibonacci sayıları kendi indeksi daha büyüktür.
  • -gerekli (yalnızca daha edilir ‘R) bu yüzden bunun için çalışır 0 beri 0 olduğu 0 inci Fibonacci sayı;

Bu benim
cevabımdaki

Benimki senin için golf oynadım, benim için işler dışında 3:)
Jonathan Allan

Oh fahişe ... Fibonacci garip. (btw cevabımı sildim sonra söylersen)
Outgolfer Erik

Son notundan emin misin? Fibonacci atomunu 0'dan başlayan bir listede çalıştırdığımda, çıktıya dahil edilir.
dağınık

1
Mücadelenin ifadesine dayanarak alakalı görünmüyor, ancak Fibonacci sayıları listesindeki argümanınız olarak count atomunu 1 ile kullanırsanız sonuç 2'dir (1 değil).
FryAmTheEggman

5

ZX81 BASIC 180 151 100 ~ 94 belirtilmiş BASIC bayt

SinclairZXWorld forumlarındaki Moggy sayesinde, daha fazla bayt tasarrufu sağlayan daha düzenli bir çözüm.

 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

Bir Fibonacci numarası girilirse 1, yoksa girilmezse sıfır verilir. Bu, bayt tasarrufu sağlamasına rağmen, aşağıdaki eski çözümlerden çok daha yavaştır. Hız için (ancak daha fazla BASIC baytı) VAL, dize değişmez sayılarının etrafındaki sarmalayıcıları çıkarın . İşte bazı açıklamalar ile eski (ler) çözümleri:

 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

Yukarıdaki değişiklikler, IFifadeleri PRINTsatır 12'de tek bir satırda yoğunlaştırmak için daha fazla BASIC baytı kaydetmektedir ; diğer baytlar VALanahtar sözcük kullanılarak ve, ve GOTO CODE "£"ZX81 karakter kümesinde 12 olan karakterlerin kullanılmasıyla kaydedilmiştir. Dizeler, tüm sayısal değerler kayan nokta olarak kaydedildiğinden sayılar üzerinde daha fazla bayt tasarrufu sağlar, bu nedenle VAR yığınında daha fazla yer kaplar.

görüntü tanımını buraya girin


Aslında, 6 numaralı satırı, tamamen 6 numaralı satırı kaldırarak ve 5 numaralı satırı değiştirerek 5 IF R<F THEN NEXT Ifena hale getirerek kurtarabilirim .
Shaun Bebbers

4

C #, 109 bayt

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

Kesinlikle daha iyi olabilirdi ama zamanım olmadı.


PPCG'ye Hoşgeldiniz!
Martin Ender

1
Kendi cevabımı sadece seninkiyle aynı olduğunun farkına varmak için yazdım. Bunu elde etmek için lamda ifadelerini ve basit değişkenleri kullanabilirsiniz: n=>{int a=0,b=1,c=0;while(a<n&b<n)if(++c%2>0)a=a+b;else b=a+b;return a==n|b==n;}(sadece 80 bayt). Çevrimiçi deneyin!
Charlie,

1
@CarlosAlejo a+=bBunun yerine a=a+bve b+=abunun yerine 2 bayt daha kaydedin b=a+b.
TheLethalCoder

4

> <> , 21 19 + 3 = 24 22 bayt

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

Program başlangıcında girişin yığında olması bekleniyor, bu nedenle -vbayrak için +3 bayt .

Çevrimiçi deneyin!

Bu, Fibonacci sayılarını giriş numarasına eşit veya onlardan daha büyük olana kadar üreterek ve daha sonra giriş ile eşitlik için son üretilen numarayı kontrol ederek çalışır. Çıkışlar 1bu bir Fibonacci sayı ise 0aksi.

Bunun 0doğru kullanıldığından emin olmak için, tohum -1 1- üretilen ilk sayı 0yerine olacaktır 1.

STDIN boş olduğunda yığının üzerine iitmek için kullanılabilecek işaretleme için @cole sayesinde -1. Çok zeki!

Önceki versiyon:

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

Şimdi yol boyunca oluşturulan her sayıyı sürekli olarak kontrol ederek baytları boşa harcadığım için kendimi aptal hissediyorum. Güzel bitti!
Emigna

1
22 bayti yerine kullanarak 01-.
cole,

kullanarak tabii @cole, iolarak -1STDIN için hiçbir giriş olduğunda, bunu kabul ederim. Güzel bitti!
Sok

3

Mathematica, 37 bayt

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

@Ngenisis takımından -4 byte


Fibonacci[0]verir 0kaydedebilir, böylece 4dahil ederek bayt 0içinde Tablearalığında. Aşağıdakiler için infix notasyonunu kullanarak başka bir bayttan tasarruf edebilirsiniz Table:!Fibonacci@n~Table~{n,0,#+1}~FreeQ~#&
ngenisis

3

MATL (16 bayt)

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

Çevrimiçi deneyin!

En hızlı çözüm değil, ancak "5 * x ^ 2 +/- 4" ün mükemmel bir kare olup olmadığını doğrudan denetleme yöntemini kullanmak istedi .

Açıklama:

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.

Not:

"0" durumunda "2" yi döndürür çünkü hem 4 hem de -4 mükemmel karelerdir, "1" i üreten 1 ile aynıdır. Sıfır olmayan çıktıları "truthy" ve 0 "falsy" olarak kabul edin.




3

Java, 72 69 68 63 59 55 50 49 bayt

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

Kendin test et!

Alternatif (hala 49 bayt)

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

Çok orijinal değil: sade ve basit yinelemeli versiyon.

Bu, 1.836.311.903 (47. fibonacci sayısı) 'ya kadar olan numaralar için işe yarar. Bunun üstünde, sonuç tanımsızdır (potansiyel bir sonsuz döngü dahil).

Golfe yardım ettiği için Kevin Cruijssen ve David Conrad'a teşekkürler :)


1
Güzel yaklaşım. Btw, golf değiştirerek bir bayt can n==0için n<1. Sorusuna yılında "devletler 0 ile 1.000.000.000 arasında bir negatif olmayan tamsayı ".
Kevin Cruijssen

1
@KevinCruijssen Ben 1, ama bu maddeye göre 5 byte golf oynadım! :-P Teşekkürler, fark etmedim.
Olivier Grégoire

2
Fibonacci dizisi için geçici değişkene ihtiyacınız yoktur. Ardışık çiftleri şu değerlerle hesaplayabilirsinizb+=a;a=b-a;
David Conrad

1
Kara büyü yapıyorsun, DavidConrad! Sana söylüyorum! Kara büyü! :)
Olivier Grégoire

3

C # (.NET Core) , 51 bayt

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

Çevrimiçi deneyin!

@Oliver sayesinde -6 bayt!

Bu çözüm oldukça basit bir özyinelemeli işlev kullanır.

  • Değişken ntest edilecek sayıdır.
  • Değişkenler ave bdizideki en son 2 sayıdır.
  • En son 2 numaranın ilki girişin altında mı diye bakar. Bu durumda, serinin sonraki numaralarına özyinelemeli bir çağrı yapılır.
  • Aksi halde, ilk sayının girişe eşit olup olmadığını kontrol edin ve sonucu geri getirin.

TIO bağlantısı, bu çalışmanın, meydan okuma için gereken maksimum değeri aşan 1134903170 için olduğunu göstermektedir.


Bu :) son zamanlarda C # çözümleri görmek güzel - Ben sadece kontrol düşünüyorum a<niçin 51 bayt
Oliver

Teşekkürler! Ve güzel ipucu :)
dana

3

Alchemist , 205 134 bayt

ASCII'ye büyük teşekkürler - sadece devletlerin zekice birleşmesi için 71 byte tasarruf !!

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

Çevrimiçi deneyin veya toplu olarak doğrulayın!

Ungolfed

# 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


139 . 0nondeterminizm pahasına daha az bayt için bazı çekleri kaldırabilirsiniz
yalnızca ASCII


@ ASCII-only: Bu oldukça hoş! Yine de 0 için başarısız olur, ancak bbaşlatma
-atom eklenmemesi sorunu

2

Jöle , 5 bayt

ȷḶÆḞi

Çevrimiçi deneyin!

Fibonacci olmayan sayılar için 0 değerini ve Fibonacci sayıları için Fibonacci dizisindeki sayının 1 dizeli konumunu döndürür.

Açıklama:

ȷḶÆḞ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

0 için çalışmıyor.
Okx

@ComradeSparklePony Emin misiniz? Bu benim için çalışıyor.
dağınık

1
0 veya 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875. daha büyük bir şey için çalışmaz
Outgolfer Erik

1
@ Mr.Xcoder Genel fikir birliği, doğal veri türünüzün desteklediği şeyleri kullanabilmeniz gerektiği ve Jelly isteğe bağlı tamsayıları desteklediği anlamına gelir.
Outgolfer Erik,

1
Yine 26863810024485359386146727202142923967616609318986952340123175997617981700247881689338369654483356564191827856161443356312976673642210350324634850410377680367334151172899169723197082763985615764450078474174626. üzerinde herhangi bir şey için çalışmaz
Outgolfer Erik


2

R, 43 40 bayt

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

pryr::f bir fonksiyon yaratır:

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

DescTools::Fibonacciİlk x+1fibonacci sayılarını oluşturmak için kullanır ve dahil edilmesini kontrol eder. x+1ünkü üçüncü fibnum 2'dir ve bu, 3'ün dahil edilmesini kontrol etmek için yeterli olmaz.

Neyse ki Desctools::Fibonacci(0)=0, bu güzel bir freebee.

MickyT sayesinde -3 bayt


-1:x+1size bir bayt kazandırır, ancak 0:45üç
kişiyi kurtarır

@MickyT Oh, istenen aralık şartnamesini gözden kaçırmış olmalıyım. Thanks :)
JAD

Alternatif bir yaklaşım, sadece 36 byte: pryr::f(any(!(5*n^2+c(-4,4))^.5%%1)).
rturnbull

32 bayta indirdim, buraya bakın .
rturnbull

Kod golf kurallarına aşina değilim - temel olmayan paketlere izin vermek mantıklı mı? Rasgele bir R kodu bir pakete yazabilir, kurabilir ve işlevi çalıştırdığınız şekilde çalıştırabilirim pryr.
mb7744

2

Haskell , 31 bayt

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

Çevrimiçi deneyin! Bu, girişin 0 ila 1,000,000,000 aralığında olacağı gerçeğinden istifade eder, bu nedenle sadece ilk 45 Fibonacci sayısını kontrol etmemiz gerekir. f=0:scanl(+)1fFibonacci sayılarının sonsuz bir listesini oluşturur take 45f, ilk 45 Fibonacci sayılarının elemlistesidir ve girişin bu listede olup olmadığını kontrol eder.


Sınırsız sürüm: 36 bayt

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

Çevrimiçi deneyin! Herhangi biri için n, ilk n+3Fibonacci numaralarını almak, neğer bir Fibonacci numarasıysa, bu listede olacağını garanti edecektir.

Bu yaklaşımın, Fibonacci sayıları olmayan yüksek sayılar için inanılmaz derecede verimsiz olduğuna dikkat edin, çünkü tüm n+3Fibonacci sayıları hesaplanmalıdır.


2

Javascript (** operatörü olmayan ES6), 44 bayt

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

Altın orana yaklaşan art arda Fibonacci sayıları arasındaki orana güvenir. C değeri, girişin fraksiyonel kısmıdır ve altın orana bölünür - eğer giriş Fibonacci ise, o zaman bu 1'e çok yakın olacak ve c-c² değeri çok küçük olacaktır.

Diğer JS cevaplarından bazıları kısa değil, ancak O (1) sürede çalışıyor.


Kesin olduğundan emin misin?
user259412

Fibonacchi numarası 16558014 için işe yaramazsa
Black Owl Kai

2

Julia 0.4 , 29 bayt

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

Çevrimiçi deneyin!


Julia'nın cevabı böyle yapmıyorsa, bana haber ver. Girişin TIO'da nasıl çalıştığından emin değilim.


1
Düzenli bir işlev (sayma !m=) veya bir lambda (sayma m->) yapmalısınız . Daha da önemlisi, bu olduğu gibi 0 için başarısız olur .
Dennis

2

R, 32 31 bayt

Stdin'den girdi alır, döner TRUEveya FALSEuygun şekilde.

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

2

Ortak Lisp, 61 54 bayt

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

Çevrimiçi deneyin!

Önceki sürüme göre boyutta azalma:

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

Fibonacci sayıları dizisini oluşturmak için üç değil, sadece iki değişken gerekli olduğu fikri ile tetiklendi.


1

Mathematica, 33 bayt

AtomQ@*InverseFunction[Fibonacci]

Birkaç bayttan tasarruf edebilirsiniz @*(ve sonuncuyu bırakın @#&)
Martin Ender

1

JS (ES6), 57 bayt

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

Carusocomputing'in metodunu kullanır . Diğer cevabımdan çok golfçüler .

Ungolfed

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)
}
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.