Я число Фібоначчі?


49

Ваше завдання:

Напишіть програму або функцію, щоб перевірити, чи є число, яке вводиться, число Фібоначчі . Число Фібоначчі - це число, що міститься в послідовності Фібоначчі.

Послідовність Фібоначчі визначається як: 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

Оцінка:

Це , виграє найменший байт.


2
Мова програмування, яку я використовую, підтримує лише номери до 9999 (Geometry Dash). Чи добре, якщо припустити, що він теоретично підтримує номери до 1000000?
MilkyWay90

Відповіді:


36

Нейм , 2 байти

f𝕚

Пояснення:

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

Працює так само, як і моя відповідь It Hip to be Square , але використовує інший нескінченний список:, fдля vred.

Спробуй це!


1
Оце Так! Вражаючий бал.
Грифон - Відновіть Моніку

2
Це чудово, але не 2 байти. У UTF-8 він представлений як "66 F0 9D 95 9A"
sm4rk0

10
@ sm4rk0 Це чудово, але ви помиляєтесь. Neim використовує користувацьку кодову сторінку , тому байтове представлення цього66 D5
Okx

Чи не є ця петля назавжди, якщо введення немає у списку? Якщо так, чи вважається це фальси?
Енріко Борба

@EnricoBorba Neim знає, що n-й елемент у цьому нескінченному списку завжди буде рівним або меншому, ніж n + 1-й елемент у списку. Тому він може наздогнати себе, і він не запуститься вічно. Ви спробували програму це? : P
Okx

18

JavaScript (ES6), 34 байти

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

Рекурсивно генерує послідовність Фібоначчі до тих пір, поки не знайде елемент, більший або рівний вводу, а потім поверне item == input.


Примітка: наївно-рекурсивний розрахунок послідовності Фібоначчі становить O (Fib (n)) - приблизно O (1.6 ^ n)
Альнітак

f = n => n? n> 2? f (n-1) + f (n-2): 1: 0 28 байт
джеккав

@jackkav Спасибі, але завдання полягає в тому, щоб визначити , якщо вхід є числом Фібоначчі.
ETHproductions

12

Сітківка , 23 байти

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

Спробуйте в Інтернеті!

Введення в одинарних, вихідних 0або 1.

Пояснення

Послідовність Фібоначчі є хорошим кандидатом на рішення з прямими посиланнями, тобто на "зворотній зв'язок", який посилається або на оточуючу групу, або на ту, що з'являється пізніше в регулярному вираженні (у цьому випадку ми фактично використовуємо обидва з них). Зіставляючи такі числа, нам потрібно розробити рекурсивне вираження різниці між елементами послідовності. Наприклад, щоб відповідати трикутним числам, ми зазвичай співпадаємо з попереднім сегментом плюс один. Для відповідності квадратних чисел (відмінності яких непарні числа) ми співставляємо попередній сегмент плюс два.

Оскільки ми отримуємо числа Фібоначчі, додаючи елемент останній до останнього до останнього, різниці між ними також є лише числами Фібоначчі. Тому нам потрібно відповідати кожному сегменту як сума попередніх двох. Основою регулярного вираження є:

(         # 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в кінці. Єдиний випадок, який це не стосується, дорівнює нулю, тому у нас є ^$альтернатива на початку для цього.


2
Дуже елегантно! Я просто хотів би зазначити, для повноти, що його можна скоротити до 20 байт в PCRE, використовуючи присвійний кількісний показник:^$|^(^1|\2?+(\1))*1$
Deadcode

1
@Deadcode Я дуже сумую за ними в .NET;)
Мартін Ендер

Збережіть 1 байт, видаливши непотрібну секунду ^.
Ніл

12

Регекс (аромат ECMAScript), 392 358 328 224 206 165 байт

Методи, які повинні вступити в гру, щоб співставити числа Фібоначчі з регулярним виразом ECMAScript (унарним), далеко не те, як найкраще це робити в більшості інших ароматів регулярного виразів. Відсутність прямолінійних / вкладених зворотних посилань або рекурсії означає, що неможливо безпосередньо підрахувати або зберегти загальну кількість нічого. Відсутність вигляду позаду часто стає проблемою навіть мати достатньо місця для роботи.

До багатьох проблем слід підходити з зовсім іншого погляду, і здаються нерозв'язними до появи якогось ключового розуміння. Це змушує вас запустити набагато ширшу мережу, визначивши, які математичні властивості чисел, з якими ви працюєте, можуть бути використані для вирішення певної проблеми.

У березні 2014 року це сталося для чисел Фібоначчі. Переглядаючи сторінку Вікіпедії, я спочатку не міг розібратися із способом, хоча одне певне властивість здавалося відчутно близьким. Тоді математик Текон виклав метод, який дав зрозуміти, що це можна зробити, використовуючи цю властивість разом з іншою. Він неохоче насправді побудував регекс. Його реакція, коли я пішов і зробив це:

Ти божевільний! ... Я думав, ти можеш це зробити.

Як і в інших моїх неорічних публікаціях з математики з регулярних виразів ECMAScript, я надам попередження: я настійно рекомендую навчитися вирішувати одинарні математичні задачі в регулярному виразі ECMAScript. Це була захоплююча подорож для мене, і я не хочу її зіпсувати нікому, хто, можливо, захоче спробувати його сам, особливо тим, хто цікавиться теорією чисел. Перегляньте цю публікацію для списку рекомендованих послідовно позначених спойлерами проблем, які потрібно вирішити по черзі.

Тому не читайте більше, якщо ви не хочете, щоб певна манія одинарного виразка була зіпсована для вас . Якщо ви хочете самостійно спробувати вирішити цю магію, я настійно рекомендую почати з вирішення деяких проблем у регулярному вираженні ECMAScript, описаних у цій публікації, зв'язаній вище.

Завдання, з яким я зіткнувся спочатку: Позитивне ціле число x - це число Фібоначчі тоді і лише тоді, коли 5x 2 + 4 та / або 5x 2 - 4 є ідеальним квадратом. Але немає можливості обчислити це в регулярному виразі. Єдиний простір, над яким ми маємо працювати, - це саме число. У нас навіть не вистачає місця, щоб помножити на 5 або взяти квадрат, не кажучи вже про обидва.

ідея Teukon про те, як її вирішити ( спочатку розміщено тут ):

Регекс подається рядком форми ^x*$, нехай z - його довжина. Перевірте, чи є z одне з перших кількох чисел Фібоначчі вручну (до 21 слід зробити). Якщо це не так:

  1. Прочитайте пару чисел, a <b, таких, що b не більше 2a.
  2. Використовуйте передні очі, щоб побудувати 2 , ab та b 2 .
  3. Зверніть увагу, що або 5a 2 + 4, або 5a 2 - 4 є ідеальним квадратом (тому для деяких n повинен бути F n-1 ).
  4. Стверджуємо, що або 5b 2 + 4, або 5b 2 + 4 є ідеальним квадратом (тому b має бути F n ).
  5. Перевірте, що z = F 2n + 3 або z = F 2n + 4 , використовуючи попередньо побудовані 2 , ab і b 2 , і тотожності:
    • F 2n-1 = F n 2 + F n-1 2
    • F 2n = (2F n-1 + F n ) F n
Якщо коротко: ці тотожності дозволяють нам зменшити проблему перевірки того, що задане число є Фібоначчиною, щоб перевірити, чи є пара набагато менших чисел Фібоначчі. Маленька алгебра покаже, що для досить великих n (n = 3 слід зробити), F 2n + 3 > F n + 5F n 2 + 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.
)$

Алгоритм множення не пояснюється в цих коментарях, але коротко пояснюється в абзаці мого рядового регекс-поста .

Я підтримував шість різних версій регулярного виразка Фібоначчі: чотири, що тривогуть від найменшої довжини до найшвидшої швидкості, і використовую алгоритм, пояснений вище, і два інших, які використовують інший, набагато швидший, але набагато більш тривалий алгоритм, який, як я знайшов, може насправді повернути індекс Фібоначчі як збіг (пояснюючи, що алгоритм тут виходить за рамки цієї публікації, але це пояснено в оригінальній дискусії Gist ). Я не думаю, що я б підтримував багато подібних версій регулярного виразів, тому що в той час я робив усі свої тести на PCRE та Perl, але мій регекс-движок досить швидкий, що занепокоєння швидкістю вже не є таким важливим (і якщо певна конструкція спричиняє вузьке місце, я можу додати оптимізацію за це) - хоча, мабуть, я б знову підтримував одну найшвидшу версію та одну найкоротшу версію, якщо різниця у швидкості були досить великими

Версія "повернути індекс Фібоначчі мінус 1 як відповідність" (не сильно гольфується):

Спробуйте в Інтернеті!

Усі версії розміщені на github із повною історією оптимізацій гольфу:

Регекс для відповідності чисел Фібоначчі - короткий, швидкість 0.txt (найкоротший, але найповільніший, як у цій публікації).
Регекс для відповідності чисел Фібоначчі - короткий, швидкий 1.txt регекс
для відповідності чисел Фібоначчі - короткий, швидкість 2.txt регекс
для відповідність чисел Фібоначчі - короткий, швидкий 3.txt
регулярний вираз для відповідності чисел Фібоначчі - найшвидший.txt регекс
для відповідності чисел Фібоначчі - повернення index.txt


9

Python 3 , 48 байт

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

Спробуйте в Інтернеті!


1
Будучи Python, чи не повинен він працювати, даючи достатньо ресурсів, для довільно великих входів?
Джонатан Аллан

2
У мене завжди було враження, що ми можемо використовувати будь-який алгоритм, який ми хотіли, оскільки він працює на практиці, якщо обчислення відповідають типу даних і теоретично даються безмежною точністю. Звичайно, використання лише intвстановило б планку вище (все ще не довільно велика), але ми також не змушуємо відповіді C використовувати 64-бітні цілі числа (або 128-бітні з gcc). У будь-якому випадку, дозволяти використовувати один і той же алгоритм на одній мові, але не на іншій, здається безглуздим.
Денніс

Алгоритмічний вигляд має сенс (я завжди вважав, що саме вхідний домен диктує критерії "відповідності типу даних"). Єдине, на що слід звернути увагу, - це сіра область між ідеєю алгоритму та його реалізацією. Тут можна було б перевірити, чи будь-яке ціле число є квадратним без викидання плавців. Я здогадуюсь, що внутрішній склад як побічний ефект є прийнятним, якщо він є частиною законного, працюючого алгоритму (... і я впевнений, що алгоритм, який покладався на роль, не був би прийнятним).
Джонатан Аллан

@JonathanAllan Оскільки максимальне значення для обробки - 1e9, я не думаю, що довільно великі входи будуть проблемою.
JAD

1
@JarkoDubbeldam так, ця деталь була фактично змінена після мого коментаря.
Джонатан Аллан

7

Python 2, 48 44 байт

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

Спробуйте в Інтернеті

Дякую Джонатану Аллану за збереження 4 байтів


Це може бути 47 байт, якщо значення truthy можуть бути Falseі хибними значеннями True: TIO!
Містер Xcoder

Може також використовуватись n-aзамість n==aта мати значення -1 та 0 у якості повернених значень.
Magic Octopus Urn

@carusocomputing У мене це було в моїй історії редагування, але це не працює, тому що для більших значень тесту ви можете мати -101чи якийсь інший результат замість -1.
mbomb007

@ Mr.Xcoder, чи справді ви вважаєте, що збереження 1 байта вартий розуму?
frarugi87

1
@ frarugi87 Зберегти байт завжди варто
пан Xcoder

7

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 спасибі Джонатану Аллану за вирішення 0-не-полезного числа.


Насправді не буде оновлено до 6 байт. Не можу повірити, що немає жодного способу додати 0 до списку в межах 3 байтів.
Чарівний восьминога Урна

@JonathanAllan "функція генерування фібоначчі" у 05AB1E не містить 0.
Чарівний восьминіг Урна

@JonathanAllan Я розумію зараз, приємна ідея. Мені потрібна хвилина, щоб зрозуміти, що там насправді відбувається.
Чарівний восьминога Урна

Чи не достатньо для генерації upto n(збереження байта) як ÅFвсеохоплюючого і ¹åце призведе в 0будь-якому випадку n=0?
Емінья

0AF = []. 1AF = [1,1]. Так, мабуть, ні.
Чарівний восьминога Урна


5

Серйозно , 3 байти

,fu

Спробуйте в Інтернеті!

Повертає індекс +1 у списку чисел Фібоначчі, якщо truthy, інакше повертає помилкове значення.

Пояснення:

,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
Серйозно грубий ^^
Джонатан Аллан

5

Желе ,  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 - й числа Фібоначчі - за 3 всі числа Фібоначчі більше , ніж їх індекс.
  • -потрібен (а не тільки ‘R) , так що це працює для 0 , оскільки 0 є 0 - го числа Фібоначчі;

Гм, це занадто схоже на мою відповідь ...
Ерік Аутгольфер

О, я заграв шахту до твоїх, крім моїх робіт для 3:)
Джонатан Алан

Ой, ой ... Фібоначчі дивний. (Btw видалила мою відповідь, якщо ви скажете так)
Ерік Аутгольфер

Ви впевнені в останній записці? Коли я запускаю атом Фібоначчі за списком, починаючи з 0, 0 виводиться 0.
розкидання

1
Це, мабуть, не є актуальним на основі формулювання виклику, але якщо ви використовуєте атом count з 1 в якості аргументу у списку чисел Фібоначчі, результат 2 (а не 1).
FryAmTheEggman

5

ZX81 BASIC 180 151 100 ~ 94 токенізованих байків BASIC

Завдяки Moggy на форумах SinclairZXWorld, тут виходить набагато акуратніше рішення, яке економить більше байтів.

 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, якщо введено число Фібоначчі, або нуль, якщо ні. Хоча це економить байти, це набагато повільніше, ніж старі рішення нижче. Для швидкості (але більше базових байтів) зніміть 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 "£", що в наборі символів ZX81 дорівнює 12. Рядки зберігають більше байтів над числами, оскільки всі числові значення зберігаються у вигляді поплавків, тому забирають більше місця на стеку VAR.

введіть тут опис зображення


Насправді я міг би зберегти ще 6 бакетів, що базуються на базіках BASIC, видаливши рядок 6 і змінивши рядок 5 на 5 IF R<F THEN NEXT I- мій поганий!
Shaun Bebbers

4

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

Однозначно можна було б покращити, але я не встиг.


Ласкаво просимо до PPCG!
Мартін Ендер

1
Я написав власну відповідь лише для того, щоб зрозуміти, що це те саме, що і ваше. Ви можете використовувати лямбда-вирази та прості змінні, щоб отримати це: 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;}(всього 80 байт). Спробуйте в Інтернеті!
Чарлі

1
@CarlosAlejo Збережіть ще 2 байти на цьому, a+=bа не a=a+bта b+=aзамість b=a+b.
TheLethalCoder

4

> <> , 21 19 + 3 = 24 22 байти

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

Очікується, що введення буде на стеці при запуску програми, тому +3 байти для -vпрапора.

Спробуйте в Інтернеті!

Це працює, генеруючи числа Фібоначчі до тих пір, поки вони не будуть більшими або рівними вхідному числу, а потім перевірити останнє створене число на рівність із вхідним. Виходить, 1якщо це число Фібоначчі, в 0іншому випадку.

Щоб переконатися, що 0обробляється правильно, насінням є -1 1- генерується перше число, 0а не 1.

Завдяки @cole за вказівку, що iможна використовувати для натискання -1на стек, коли STDIN порожній. Дуже розумний!

Попередня версія:

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

Тепер я почуваюся дурним, що витрачаю байти постійно перевіряючи кожне згенероване число по дорозі. Чудово зроблено!
Емінья

1
22 байти, використовуючи iзамість 01-.
cole

@cole звичайно, використовуючи, iяк -1коли немає STDIN, я б не вважав це. Чудово зроблено!
Сік

3

Математика, 37 байт

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

-4 байти від @ngenisis


Fibonacci[0]дає 0, тому ви можете зберегти 4байти, включивши 0в Tableдіапазон. Ви можете зберегти ще один байт, використовуючи позначення інфіксації для Table:!Fibonacci@n~Table~{n,0,#+1}~FreeQ~#&
ngenisis

3

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 - як "хибний".



3

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;

Спробуйте в Інтернеті!


2
Golfed більше: for(;0>$s=$x-$argn;)$x=+$y+$y=$x?:1;echo!$s;.
user63956

@ user63956 Дякую за навчальні зусилля із завданням ланцюгових змінних
Jörg Hülsermann

3

Ява, 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-го поля). Над цим результат не визначений (включаючи потенційну нескінченну петлю).

Дякуємо Кевіну Крейсейну та Девіду Конраду за допомогу в гольфі :)


1
Гарний підхід. До речі, можна перейти n==0на байт, перейшовши на n<1. У запитанні зазначено " Невід'ємне ціле число від 0 до 1 000 000 000 ".
Кевін Круїйсен

1
@KevinCruijssen Я гольфував не 1, а 5 байт із цим пунктом! :-P Спасибі, я цього не помічав.
Олів’є Грегоар

2
Вам не потрібна змінна temp для послідовності Фібоначчі. Ви можете порахувати послідовні пари зb+=a;a=b-a;
Девід Конрад

1
Ти робиш чорну магію, @DavidConrad! Я тобі кажу! Чорна магія! :)
Олів'є Грегоар

3

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є двома останніми числами в послідовності.
  • Перевіряє, чи є перше з двох останніх номерів менше введення. У такому випадку здійснюється рекурсивний дзвінок на наступні номери в серії.
  • В іншому випадку перевірте, чи є перше число рівним вводу, і поверніть результат.

Посилання TIO демонструє, що це працює для 1134903170, що перевищує максимальне значення, необхідне для виклику.


Приємно бачити , C # рішення в останній час :) - Я думаю , ви можете просто перевірити , якщо в a<nпротягом 51 байт
Oliver

Дякую! І приємна порада :)
дата

3

Алхімік , 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


139 . ви можете зняти кілька 0чеків на меншу кількість байтів за ціну недетермінізму
лише для ASCII


@ ASCII-тільки: Це дуже приємно! Збій при 0 , хоча, але не додаючи b-атом ініціалізації фіксує його (і зберігає 2 байта): D Дякую
ბიმო

2

Желе , 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

Не працює за 0.
Okx

@ComradeSparklePony Ви впевнені? Це працює для мене.
розкидання

1
Не працює на 0 або що - щось більше , ніж 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875.
Ерік Outgolfer

1
@ Mr.Xcoder Загальний консенсус полягає в тому, що ви повинні вміти обробляти те, що підтримує ваш природний тип даних, а Jelly підтримує цілі числа довільної точності.
Ерік Аутгольфер

1
Тим НЕ менше не працює ні на що над 26863810024485359386146727202142923967616609318986952340123175997617981700247881689338369654483356564191827856161443356312976673642210350324634850410377680367334151172899169723197082763985615764450078474174626.
Ерік Outgolfer


2

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тому що третій фібнум дорівнює 2, і цього було б недостатньо для перевірки на включення 3.

На щастя Desctools::Fibonacci(0)=0, так що це приємна халява.

-3 байти завдяки MickyT


-1:x+1заощадить вам байт, але 0:45збереже вас три та покриє необхідний діапазон
MickyT

@MickyT О, я, мабуть, не звернув уваги на необхідну специфікацію діапазону. Дякую :)
JAD

Альтернативний підхід, тільки 36 байт: pryr::f(any(!(5*n^2+c(-4,4))^.5%%1)).
rturnbull

Я звів її до 32 байт, дивіться тут .
rturnbull

Я не настільки знайомий з правилами кодового гольфу - чи має сенс дозволити пакети, що не стосуються базових даних? Я міг би записати довільний код R в пакет, встановити його і запустити його так само, як ви запустили функцію pryr.
mb7744

2

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числа Фібоначчі потрібно обчислити.


2

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) час.


Ви впевнені, що це точно?
користувач259412

Не працює для номера фібоначчі 16558014
Чорна сова Кай

2

Юлія 0,4 , 29 байт

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

Спробуйте в Інтернеті!


Якщо ви так не робите відповіді Джулії, дайте мені знати. Я не впевнений, як працює вхід на TIO.


1
Вам доведеться зробити це звичайною функцією (підрахунок !m=) або лямбда (підрахунок m->). Що ще важливіше, це не вдасться до 0, як є.
Денніс

2

R, 32 31 байт

Здійснює введення з stdin, повертає TRUEабо, FALSEякщо це доречно.

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

2

Лист звичайний, 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))))

була спровокована ідеєю, що для генерації послідовності чисел Фібоначчі потрібні лише дві змінні, а не три.


1

Математика, 33 байти

AtomQ@*InverseFunction[Fibonacci]

Ви можете зберегти пару байтів за допомогою @*(а потім відкинути фінал @#&)
Мартін Ендер

1

JS (ES6), 57 байт

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

Використовується метод карусокомп'ютерів . Багато гольфіста, ніж моя інша відповідь .

Безумовно

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)
}
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.