Tôi có phải là số Fibonacci không?


49

Nhiệm vụ của bạn:

Viết chương trình hoặc hàm để kiểm tra xem một số được nhập có phải là số Fibonacci không . Số Fibonacci là một số có trong chuỗi Fibonacci.

Chuỗi Fibonacci được định nghĩa là: F(n) = F(n - 1) + F(n - 2)

Với những hạt giống được F(0) = 0F(1) = 1.

Đầu vào:

Một số nguyên không âm trong khoảng từ 0 đến 1.000.000.000 có thể có hoặc không phải là số Fibonacci.

Đầu ra:

Giá trị trung thực / giả mạo cho biết liệu đầu vào có phải là số Fibonacci hay không.

Ví dụ:

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

Ghi điểm:

Đây là , số byte thấp nhất sẽ thắng.


2
Ngôn ngữ lập trình tôi đang sử dụng chỉ hỗ trợ các số lên tới 9999 (Geometry Dash). Có ổn không nếu tôi cho rằng nó hỗ trợ số lên tới 1000000, theo lý thuyết?
MilkyWay90

Câu trả lời:


36

Neim , 2 byte

f𝕚

Giải trình:

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

Hoạt động tương tự như câu trả lời Hip của tôi là Square , nhưng sử dụng một danh sách vô hạn khác : f, đối với Dailymotion.

Thử nó!


1
Ồ Điểm số ấn tượng.
Gryphon - Tái lập Monica

2
Điều đó thật tuyệt, nhưng không phải là 2 byte. Trong UTF-8, nó được thể hiện là "66 F0 9D 95 9A"
sm4rk0

10
@ sm4rk0 Điều đó thật tuyệt, nhưng bạn đã nhầm. Neim sử dụng một bảng mã tùy chỉnh , do đó, biểu diễn byte của cái này là66 D5
Okx

Không phải vòng lặp này mãi mãi nếu đầu vào không có trong danh sách? Nếu vậy, điều đó có được tính là falsey không?
Enrico Borba

@EnricoBorba Neim biết rằng phần tử thứ n trong danh sách vô hạn này sẽ luôn bằng hoặc nhỏ hơn phần tử n + 1 trong danh sách. Do đó, nó có thể tự bắt và nó sẽ không chạy mãi mãi. Bạn đã thử chương trình này chưa? : P
Okx

18

JavaScript (ES6), 34 byte

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

Đệ quy tạo ra chuỗi Fibonacci cho đến khi nó tìm thấy một mục lớn hơn hoặc bằng đầu vào, sau đó trả về item == đầu vào.


NB: phép tính đệ quy ngây thơ của chuỗi Fibonacci là O (Fib (n)) - xấp xỉ O (1.6 ^ n)
Alnitak

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

@jackkav Cảm ơn, nhưng thách thức là xác định xem đầu vào có phải là số Fibonacci không.
Sản xuất ETH

12

Võng mạc , 23 byte

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

Hãy thử trực tuyến!

Đầu vào trong unary, đầu ra 0hoặc 1.

Giải trình

Chuỗi Fibonacci là một ứng cử viên tốt cho một giải pháp với các tham chiếu chuyển tiếp, tức là "phản hồi" đề cập đến một nhóm xung quanh hoặc một nhóm xuất hiện sau trong regex (trong trường hợp này, chúng tôi thực sự sử dụng cả hai tham số đó). Khi khớp các số như thế này, chúng ta cần tìm ra một biểu thức đệ quy cho sự khác biệt giữa các phần tử chuỗi. Ví dụ: để khớp các số tam giác, chúng ta thường khớp với phân đoạn trước cộng với một. Để khớp với số vuông (có sự khác biệt là số lẻ), chúng tôi khớp với phân đoạn trước cộng với hai.

Vì chúng ta có được các số Fibonacci bằng cách thêm phần tử thứ hai đến cuối cùng, nên sự khác biệt giữa chúng cũng chỉ là các số Fibonacci. Vì vậy, chúng ta cần khớp từng phân đoạn là tổng của hai phần trước. Cốt lõi của regex là thế này:

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

Bây giờ mục đích này lên thêm những con số Fibonacci bắt đầu từ 1 , tức là 1, 1, 2, 3, 5, ... . Những add lên đến 1, 2, 4, 7, 12, ... . Tức là chúng là một ít hơn các số Fibonacci, vì vậy chúng tôi thêm một 1ở cuối. Trường hợp duy nhất không bao gồm này là 0, vì vậy chúng tôi có giải ^$pháp thay thế ngay từ đầu để bao quát điều đó.


2
Rất thanh lịch! Tôi muốn chỉ ra, vì sự hoàn chỉnh, vì nó có thể rút ngắn xuống còn 20 byte trong PCRE bằng cách sử dụng bộ định lượng sở hữu:^$|^(^1|\2?+(\1))*1$
Deadcode

1
@Deadcode Tôi nhớ những thứ đó rất nhiều trong .NET;)
Martin Ender

Lưu 1 byte bằng cách loại bỏ thứ hai không cần thiết ^.
Neil

12

Regex (hương vị ECMAScript), 392 358 328 224 206 165 byte

Các kỹ thuật cần phải được sử dụng để khớp với các số Fibonacci với biểu thức chính ECMAScript (đơn nhất) khác xa so với cách nó được thực hiện tốt nhất trong hầu hết các hương vị regex khác. Việc thiếu các phản hồi ngược hoặc lồng nhau hoặc đệ quy có nghĩa là không thể trực tiếp đếm hoặc giữ tổng cộng mọi thứ đang chạy. Việc thiếu cái nhìn khiến nó thường là một thách thức thậm chí để có đủ không gian để làm việc.

Nhiều vấn đề phải được tiếp cận từ một quan điểm hoàn toàn khác, và dường như không thể giải quyết được cho đến khi có một số hiểu biết quan trọng. Nó buộc bạn phải tạo một mạng lưới rộng hơn nhiều trong việc tìm ra các thuộc tính toán học nào của các số bạn làm việc cùng có thể có thể được sử dụng để làm cho một vấn đề cụ thể có thể giải quyết được.

Vào tháng 3 năm 2014, đây là những gì đã xảy ra đối với các số Fibonacci. Nhìn vào trang Wikipedia, ban đầu tôi không thể tìm ra cách nào, mặc dù một tài sản cụ thể dường như rất gần gũi. Sau đó, nhà toán học teukon đã phác thảo một phương pháp làm cho nó khá rõ ràng có thể thực hiện được, sử dụng tính chất đó cùng với một phương pháp khác. Ông miễn cưỡng thực sự xây dựng regex. Phản ứng của anh ấy khi tôi đi trước và làm điều đó:

Bạn điên rồi! ... Tôi nghĩ bạn có thể làm điều này.

Cũng như các bài đăng regex toán học đơn nhất ECMAScript khác của tôi, tôi sẽ đưa ra một cảnh báo: Tôi khuyên bạn nên học cách giải quyết các vấn đề toán học đơn phương trong biểu thức chính thức ECMAScript. Đó là một hành trình hấp dẫn đối với tôi và tôi không muốn làm hỏng nó cho bất kỳ ai có khả năng muốn thử nó, đặc biệt là những người quan tâm đến lý thuyết số. Xem bài đăng đó để biết danh sách các vấn đề được đề xuất liên quan đến spoiler để giải quyết từng vấn đề một.

Vì vậy, đừng đọc thêm nữa nếu bạn không muốn một số phép thuật regex đơn phương hư hỏng cho bạn . Nếu bạn thực sự muốn tự mình tìm ra phép thuật này, tôi khuyên bạn nên bắt đầu bằng cách giải quyết một số vấn đề trong biểu thức ECMAScript như được nêu trong bài đăng được liên kết ở trên.

Thách thức ban đầu tôi gặp phải: Một số nguyên dương x là một số Fibonacci khi và chỉ khi 5x 2 + 4 và / hoặc 5x 2 - 4 là một hình vuông hoàn hảo. Nhưng không có chỗ để tính toán điều này trong một regex. Không gian duy nhất chúng ta phải làm việc là số chính nó. Chúng tôi thậm chí không có đủ chỗ để nhân 5 hoặc lấy hình vuông, nói gì đến cả hai.

Ý tưởng của teukon về cách giải quyết nó ( ban đầu được đăng ở đây ):

Regex được trình bày với một chuỗi có dạng ^x*$, gọi z là độ dài của nó. Kiểm tra xem z có phải là một trong số ít các số Fibonacci đầu tiên hay không (tối đa 21 nên làm). Nếu không phải vậy:

  1. Đọc một vài số, a <b, sao cho b không lớn hơn 2a.
  2. Sử dụng các hướng nhìn về phía trước để xây dựng 2 , ab và b 2 .
  3. Khẳng định rằng 5a 2 + 4 hoặc 5a 2 - 4 là một hình vuông hoàn hảo (vì vậy phải là F n - 1 cho một số n).
  4. Khẳng định rằng 5b 2 + 4 hoặc 5b 2 + 4 là một hình vuông hoàn hảo (vì vậy b phải là F n ).
  5. Kiểm tra xem z = F 2n + 3 hoặc z = F 2n + 4 bằng cách sử dụng 2 , ab và b 2 được xây dựng trước đó và các danh tính:
    • F 2n-1 = F n 2 + F n-1 2
    • F 2n = (2F n-1 + F n ) F n
Tóm lại: những bản sắc cho phép chúng ta làm giảm các vấn đề về kiểm tra rằng một số lượng nhất định là Fibonacci để kiểm tra xem một cặp nhiều số nhỏ hơn là Fibonacci. Một đại số nhỏ sẽ chỉ ra rằng với n đủ lớn (n = 3 nên làm), F 2n + 3 > F n + 5F n 2 + 4 vì vậy phải luôn có đủ không gian.

đây là một mockup của thuật toán trong C mà tôi đã viết dưới dạng thử nghiệm trước khi thực hiện nó trong regex.

Vì vậy, không có thêm ado, đây là 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})$

Hãy thử trực tuyến!

Và phiên bản đẹp, được bình luận:

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

Thuật toán nhân không được giải thích trong các bình luận đó, nhưng được giải thích ngắn gọn trong một đoạn của bài đăng regex số dồi dào của tôi .

Tôi đã duy trì sáu phiên bản khác nhau của biểu thức Fibonacci: bốn phiên bản từ độ dài ngắn nhất đến tốc độ nhanh nhất và sử dụng thuật toán được giải thích ở trên, và hai phiên bản khác sử dụng thuật toán khác, nhanh hơn nhưng dài hơn nhiều, mà tôi thấy thực sự có thể quay trở lại chỉ số Fibonacci là một kết quả khớp (giải thích rằng thuật toán ở đây nằm ngoài phạm vi của bài đăng này, nhưng nó được giải thích trong thảo luận ban đầu Gist ). Tôi không nghĩ rằng tôi sẽ duy trì nhiều phiên bản regex rất giống nhau một lần nữa, bởi vì tại thời điểm đó tôi đang thực hiện tất cả các thử nghiệm của mình trong PCRE và Perl, nhưng công cụ regex của tôi đủ nhanh để các mối quan tâm về tốc độ không còn quan trọng nữa (và nếu một cấu trúc cụ thể gây ra tắc nghẽn, tôi có thể thêm tối ưu hóa cho nó) - mặc dù tôi có thể lại duy trì một phiên bản nhanh nhất và một phiên bản ngắn nhất, nếu sự khác biệt trong tốc độ là đủ lớn.

Phiên bản "trả về chỉ số Fibonacci trừ 1 như một trận đấu" (không được đánh gôn nhiều):

Hãy thử trực tuyến!

Tất cả các phiên bản đều có trên github với lịch sử cam kết đầy đủ về tối ưu hóa golf:

regex để khớp các số Fibonacci - ngắn, tốc độ 0.txt (ngắn nhất nhưng chậm nhất, như trong bài đăng này)
regex để khớp các số Fibonacci - ngắn, tốc độ 1.txt
regex để khớp với các số Fibonacci - ngắn, tốc độ 2.txt
regex cho khớp các số Fibonacci - ngắn, tốc độ 3.txt
regex để khớp với các số Fibonacci - regex quick.txt để khớp với các số
Fibonacci - return index.txt


9

Python 3 , 48 byte

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

Hãy thử trực tuyến!


1
Là Python nên nó không hoạt động, được cung cấp đủ tài nguyên, cho các đầu vào lớn tùy ý?
Jonathan Allan

2
Tôi luôn có ấn tượng rằng chúng tôi có thể sử dụng bất kỳ thuật toán nào chúng tôi muốn miễn là nó hoạt động trong thực tế nếu các phép tính phù hợp với kiểu dữ liệu và theo lý thuyết với độ chính xác vô hạn. Chắc chắn, chỉ sử dụng intsẽ đặt thanh cao hơn (vẫn không lớn tùy ý), nhưng chúng tôi cũng không buộc các câu trả lời C sử dụng số nguyên 64 bit (hoặc 128 bit với gcc). Ở bất kỳ giá nào, việc được phép sử dụng cùng một thuật toán trong một ngôn ngữ nhưng không phải ngôn ngữ khác có vẻ vô nghĩa.
Dennis

Khung nhìn thuật toán thực sự có ý nghĩa (tôi đã luôn nghĩ rằng đó là miền đầu vào đưa ra tiêu chí "phù hợp với kiểu dữ liệu"). Điều duy nhất cần theo dõi là vùng màu xám giữa ý tưởng của thuật toán và việc thực hiện nó là gì. Ở đây người ta có thể kiểm tra xem một trong hai số nguyên có phải là hình vuông mà không cần đúc thành hình nổi không. Tôi đoán rằng một diễn viên nội bộ như một hiệu ứng phụ có thể được chấp nhận miễn là nó là một phần của thuật toán làm việc hợp pháp (... và tôi khá chắc chắn rằng một thuật toán dựa trên diễn viên sẽ không được chấp nhận).
Jonathan Allan

@Jonathan ALLan Vì giá trị tối đa cần xử lý là 1e9, tôi không nghĩ đầu vào lớn tùy ý sẽ là một vấn đề.
JAD

1
@JarkoDubbeldam vâng, chi tiết đó thực sự đã thay đổi sau khi bình luận của tôi được đưa ra.
Jonathan Allan

7

Python 2, 48 44 byte

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

Dùng thử trực tuyến

Cảm ơn Jonathan Allan vì đã tiết kiệm 4 byte


Đây có thể là 47 byte, nếu các giá trị trung thực có thể là Falsevà các giá trị giả True: TIO!
Ông Xcoder

Cũng có thể sử dụng n-athay thế n==avà có -1 và 0 làm giá trị trả về của bạn.
Bạch tuộc ma thuật Urn

@carusocomputing Tôi đã có điều đó trong lịch sử chỉnh sửa của mình, nhưng nó không hoạt động, vì đối với các giá trị thử nghiệm lớn hơn, bạn có thể có -101hoặc một số kết quả khác thay vì -1.
mbomb007

@ Mr.Xcoder bạn có thực sự nghĩ rằng tiết kiệm 1 byte là xứng đáng với sự tỉnh táo của mọi người không?
frarugi87

1
@ frarugi87 Tiết kiệm một byte luôn có giá trị
Ông Xcoder

7

05AB1E , 8 7 byte

>ÅF¹å¹m

Giải trình:

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

Hãy thử trực tuyến!

-1 cảm ơn Jonathan Allan vì cách giải quyết 0-not-a-Dailymotion-number.


Trên thực tế, sẽ không được cập nhật lên 6 byte. Không thể tin rằng KHÔNG có cách nào để thêm 0 vào danh sách dưới 3 byte.
Bạch tuộc ma thuật Urn

@Jonathan ALLan "tạo chức năng fftimeacci" trong 05AB1E không chứa 0.
Bạch tuộc ma thuật Urn

@Jonathan ALLan Bây giờ tôi hiểu rồi, ý kiến ​​hay đấy. Mất một phút để tìm hiểu chuyện gì đang thực sự xảy ra ở đó.
Bạch tuộc ma thuật Urn

Nó không đủ để tạo tối đa n(tiết kiệm một byte) như đã ÅFbao gồm và ¹åsẽ dẫn đến 0một trong hai cách cho n=0?
Emigna

0AF = []. 1AF = [1,1]. Vì vậy, rõ ràng là không.
Bạch tuộc ma thuật Urn


5

Nghiêm túc , 3 byte

,fu

Hãy thử trực tuyến!

Trả về chỉ số +1 trong danh sách các số Fibonacci nếu trung thực, nếu không thì trả về sai.

Giải trình:

,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
Nghiêm túc thô lỗ ^^
Jonathan Allan

5

Thạch ,  8 7  6 byte

-r‘ÆḞċ

Hãy thử trực tuyến!

Làm sao?

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

Ghi chú:

  • thặng dư, , là cần thiết để công trình này cho 23 , vì họ là những 3 thứ4 thứ số Fibonacci - ngoài 3 tất cả các số Fibonacci lớn hơn chỉ số của họ.
  • cái -này là cần thiết (chứ không phải chỉ ‘R) vì vậy cái này hoạt động với 00 là số Fibonacci thứ 0 ;

Umm, điều này trông quá giống câu trả lời của tôi ...
Erik the Outgolfer

Ồ, tôi đã đánh golf của tôi xuống của bạn, ngoại trừ công việc của tôi cho 3:)
Jonathan Allan

Ôi trời ơi ... Fibonacci thật kỳ lạ. (btw đã xóa câu trả lời của tôi sau đó nếu bạn nói như vậy)
Erik the Outgolfer

Bạn có chắc chắn về lưu ý cuối cùng? Khi tôi chạy nguyên tử Fibonacci trên danh sách bắt đầu từ 0, 0 được bao gồm trong đầu ra.
phân tán

1
Nó dường như không liên quan dựa trên từ ngữ của thách thức, nhưng nếu bạn sử dụng nguyên tử đếm với 1 làm đối số của bạn trong danh sách các số Fibonacci thì kết quả là 2 (không phải 1).
FryAmTheEggman

5

ZX81 BASIC 180 151 100 ~ 94 byte BASIC được mã hóa

Nhờ có Moggy trên các diễn đàn của SinclairZXWorld, đây là một giải pháp gọn gàng hơn giúp tiết kiệm nhiều byte hơn.

 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

Điều này sẽ xuất ra 1 nếu nhập số Fibonacci hoặc 0 nếu không. Mặc dù điều này giúp tiết kiệm byte, nhưng nó chậm hơn nhiều so với các giải pháp cũ bên dưới. Đối với tốc độ (nhưng nhiều byte BASIC hơn), hãy loại bỏ các VALhàm bao quanh các chuỗi ký tự chuỗi. Dưới đây là các giải pháp (er) cũ với một số giải thích:

 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

Các sửa đổi ở trên tiết kiệm thêm các byte BASIC để cô đọng các IFcâu lệnh thành một PRINTdòng duy nhất trong dòng 12; các byte khác được lưu bằng cách sử dụng VALtừ khóa và, và sử dụng GOTO CODE "£", trong bộ ký tự ZX81 là 12. Chuỗi lưu nhiều byte hơn số vì tất cả các giá trị số được lưu trữ dưới dạng float, do đó chiếm nhiều không gian hơn trên ngăn xếp VAR.

nhập mô tả hình ảnh ở đây


Trên thực tế, tôi có thể lưu thêm 6 byte BASIC được mã hóa bằng cách xóa hoàn toàn dòng 6 và thay đổi dòng 5 thành 5 IF R<F THEN NEXT I- xấu của tôi!
Shaun Bebbers

4

C #, 109 byte

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

Chắc chắn có thể được cải thiện, nhưng tôi không có thời gian.


Chào mừng đến với PPCG!
Martin Ender

1
Tôi đã viết câu trả lời của riêng tôi chỉ để nhận ra rằng nó giống như của bạn. Bạn có thể sử dụng biểu thức lambda và các biến đơn giản để có được điều này: 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;}(chỉ 80 byte). Hãy thử trực tuyến!
Charlie

1
@CarlosAlejo Lưu thêm 2 byte vào đó a+=bthay vì a=a+bb+=athay vì b=a+b.
TheLethalCoder

4

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

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

Đầu vào dự kiến ​​sẽ nằm trên ngăn xếp khi bắt đầu chương trình, vì vậy +3 byte cho -vcờ.

Hãy thử trực tuyến!

Điều này hoạt động bằng cách tạo các số Fibonacci cho đến khi chúng lớn hơn hoặc bằng số đầu vào, sau đó kiểm tra số được tạo cuối cùng để tìm sự bằng nhau với đầu vào. Đầu ra 1nếu nó là một số Fibonacci, 0nếu không.

Để đảm bảo rằng 0được xử lý chính xác, hạt giống là -1 1- số đầu tiên được tạo sẽ 0thay vì 1.

Cảm ơn @cole đã chỉ ra rằng icó thể được sử dụng để đẩy -1lên ngăn xếp khi STDIN trống. Rất thông minh!

Phiên bản trước:

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

Bây giờ tôi cảm thấy ngu ngốc vì đã lãng phí byte liên tục kiểm tra từng số được tạo trên đường đi. Làm tốt lắm!
Emigna

1
22 byte sử dụng ithay vì 01-.
cole

@cole tất nhiên, sử dụng inhư -1khi không có đầu vào cho STDIN, tôi không xem xét điều đó. Làm tốt lắm!
Sok

3

Toán học, 37 byte

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

-4 byte từ @ngenisis


Fibonacci[0]đưa ra 0, vì vậy bạn có thể lưu 4byte bằng cách đưa 0vào Tablephạm vi. Bạn có thể lưu một byte khác bằng cách sử dụng ký hiệu infix cho Table:!Fibonacci@n~Table~{n,0,#+1}~FreeQ~#&
ngenisis

3

MATL (16 byte)

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

Hãy thử trực tuyến!

Không phải là giải pháp tốt nhất, nhưng muốn sử dụng phương pháp kiểm tra trực tiếp nếu "5 * x ^ 2 +/- 4" là một hình vuông hoàn hảo .

Giải trình:

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.

Ghi chú:

Trong trường hợp "0", nó trả về "2" vì cả 4 và -4 đều là các hình vuông hoàn hảo, giống với 1 tạo ra "1 1". Xem xét bất kỳ đầu ra khác không là "trung thực" và 0 là "giả mạo".




3

Java, 72 69 68 63 59 55 50 49 byte

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

Tự kiểm tra!

Thay thế (vẫn 49 byte)

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

Không nguyên bản: đó là phiên bản lặp đơn giản và cơ bản.

Điều này hoạt động cho các số lên tới 1.836.311.903 (số thứ 47) bao gồm. Trên đó, kết quả là không xác định (bao gồm cả một vòng lặp vô hạn tiềm năng).

Cảm ơn Kevin Cruijssen và David Conrad đã giúp chơi golf :)


1
Cách tiếp cận tốt đẹp. Btw, bạn có thể chơi golf một byte bằng cách thay đổi n==0thành n<1. Trong câu hỏi có ghi " Một số nguyên không âm trong khoảng từ 0 đến 1.000.000.000 ".
Kevin Cruijssen

1
@KevinCruijssen Tôi chơi golf không phải 1, mà là 5 byte với mệnh đề đó! :-P Cảm ơn, tôi đã không nhận thấy nó.
Olivier Grégoire

2
Bạn không cần một biến tạm thời cho chuỗi Fibonacci. Bạn có thể tính toán các cặp liên tiếp vớib+=a;a=b-a;
David Conrad

1
Bạn đang làm ma thuật đen, @DavidConrad! Tôi đang nói với bạn! Ma thuật đen! :)
Olivier Grégoire

3

C # (.NET Core) , 51 byte

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

Hãy thử trực tuyến!

-6 byte nhờ @Oliver!

Giải pháp này sử dụng một hàm đệ quy khá đơn giản.

  • Biến nlà số cần kiểm tra.
  • Các biến ablà 2 số gần đây nhất trong chuỗi.
  • Kiểm tra xem số đầu tiên của 2 số gần nhất có nhỏ hơn đầu vào không. Khi gặp trường hợp này, một cuộc gọi đệ quy được thực hiện cho các số tiếp theo trong chuỗi.
  • Mặt khác, kiểm tra xem số đầu tiên có bằng đầu vào không và trả về kết quả.

Liên kết TIO cho thấy điều này hoạt động cho 1134903170 vượt quá giá trị tối đa mà thách thức yêu cầu.


Đó là tốt đẹp để xem C # giải pháp gần đây :) - Tôi nghĩ rằng bạn chỉ có thể kiểm tra nếu a<ncho 51 byte
Oliver

Cảm ơn! Và mẹo hay :)
dana

3

Nhà giả kim , 205 134 byte

Rất cảm ơn ASCII - chỉ cho việc hợp nhất các trạng thái khá thông minh, tiết kiệm 71 byte !!

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

Hãy thử trực tuyến hoặc xác minh hàng loạt!

Ung dung

# 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 . bạn có thể xóa một số 0kiểm tra cho ít byte hơn với chi phí không xác định
ASCII - chỉ


@ Chỉ ASCII: Điều đó khá hay! Thất bại 0 Mặc dù vậy, nhưng không thêm b-atom trên khởi tạo sửa chữa nó (và tiết kiệm 2 byte): D Cảm ơn
ბიმო

2

Thạch , 5 byte

ȷḶÆḞi

Hãy thử trực tuyến!

Trả về 0 cho các số không phải là Fibonacci và vị trí được lập chỉ mục 1 của số đó trong chuỗi Fibonacci cho các số Fibonacci.

Giải trình:

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

Không hoạt động cho 0.
Okx

@ComradeSparklePony Bạn có chắc không? Nó ổn với tôi.
phân tán

1
Không làm việc cho bất cứ điều gì 0 hoặc lớn hơn 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875.
Erik các Outgolfer

1
@ Mr.Xcoder Đồng thuận chung là bạn phải có khả năng xử lý những gì kiểu dữ liệu tự nhiên của bạn hỗ trợ và Jelly hỗ trợ các số nguyên chính xác tùy ý.
Erik the Outgolfer

1
Vẫn không hoạt động mọi thứ qua 26863810024485359386146727202142923967616609318986952340123175997617981700247881689338369654483356564191827856161443356312976673642210350324634850410377680367334151172899169723197082763985615764450078474174626.
Erik các Outgolfer


2

R, 43 40 byte

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

pryr::f tạo một hàm:

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

Sử dụng DescTools::Fibonacciđể tạo các số đầu tiên x+1và kiểm tra để đưa vào. x+1bởi vì u xơ thứ ba là 2 và điều đó sẽ không đủ để kiểm tra sự bao gồm của 3.

May mắn thay Desctools::Fibonacci(0)=0, đó là một freebee tốt đẹp.

-3 byte nhờ MickyT


-1:x+1sẽ tiết kiệm cho bạn một byte, nhưng 0:45sẽ tiết kiệm cho bạn ba và bao gồm phạm vi cần thiết
MickyT

@MickyT Ồ, tôi phải bỏ qua đặc tả phạm vi yêu cầu. Cảm ơn :)
JAD

Một cách tiếp cận khác, chỉ có 36 byte : pryr::f(any(!(5*n^2+c(-4,4))^.5%%1)).
rturnbull

Tôi đã nhận nó xuống còn 32 byte, xem tại đây .
rturnbull

Tôi không quá quen thuộc với các quy tắc golf mã - cho phép các gói phi cơ sở có ý nghĩa không? Tôi có thể viết mã R tùy ý vào một gói, cài đặt nó và chạy nó giống như cách bạn đã chạy hàm từ đó pryr.
mb7744

2

Haskell , 31 byte

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

Hãy thử trực tuyến! Điều này khai thác thực tế là đầu vào sẽ nằm trong phạm vi từ 0 đến 1.000.000.000, do đó chúng ta chỉ cần kiểm tra 45 số Fibonacci đầu tiên. f=0:scanl(+)1ftạo ra một danh sách vô hạn các số Fibonacci, take 45flà danh sách 45 số Fibonacci đầu tiên và elemkiểm tra xem đầu vào có nằm trong danh sách này không.


Phiên bản không giới hạn: 36 byte

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

Hãy thử trực tuyến! Đối với bất kỳ n, việc lấy các n+3số Fibonacci đầu tiên sẽ đảm bảo nsẽ nằm trong danh sách này nếu đó là số Fibonacci.

Lưu ý rằng cách tiếp cận này là không hiệu quả đáng kinh ngạc đối với các số cao không phải là số Fibonacci, bởi vì tất cả các n+3số Fibonacci cần phải được tính toán.


2

Javascript (ES6 không có toán tử **), 44 byte

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

Dựa vào tỷ lệ giữa các số Fibonacci liên tiếp tiếp cận tỷ lệ vàng. Giá trị của c là phần phân số của đầu vào chia cho tỷ lệ vàng - nếu đầu vào là Fibonacci thì giá trị này sẽ rất gần với 1 và giá trị của c-c² sẽ rất nhỏ.

Không ngắn như một số câu trả lời JS khác nhưng chạy trong thời gian O (1).


Bạn có chắc là nó chính xác?
user259412

Không hoạt động cho số Fibonacchi số 16558014
Black Owl Kai

2

Julia 0,4 , 29 byte

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

Hãy thử trực tuyến!


Nếu đây không phải là cách bạn trả lời Julia, hãy cho tôi biết. Tôi không chắc về cách thức hoạt động của đầu vào trên TIO.


1
Bạn sẽ phải biến nó thành một hàm thông thường (đếm !m=) hoặc lambda (đếm m->). Quan trọng hơn, điều này không thành công cho 0 .
Dennis

2

R, 32 31 byte

Lấy đầu vào từ stdin, trả về TRUEhoặc FALSEkhi thích hợp.

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

2

Lisp thường gặp, 61 54 byte

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

Hãy thử trực tuyến!

Việc giảm kích thước so với phiên bản trước:

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

được kích hoạt bởi ý tưởng rằng để tạo ra chuỗi các số Fibonacci chỉ cần hai biến, không phải ba biến.


1

Toán học, 33 byte

AtomQ@*InverseFunction[Fibonacci]

Bạn có thể lưu một vài byte bằng @*(và sau đó thả trận chung kết @#&)
Martin Ender

1

JS (ES6), 57 byte

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

Sử dụng phương pháp carusocomputing . Rất nhiều golfier hơn câu trả lời khác của tôi .

Ung dung

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)
}
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.