Sono un numero di Fibonacci?


49

Il tuo compito:

Scrivi un programma o una funzione per verificare se un numero inserito è un numero di Fibonacci . Un numero di Fibonacci è un numero contenuto nella sequenza di Fibonacci.

La sequenza di Fibonacci è definita come: F(n) = F(n - 1) + F(n - 2)

Con i semi F(0) = 0e F(1) = 1.

Ingresso:

Un numero intero non negativo compreso tra 0 e 1.000.000.000 che può essere o meno un numero di Fibonacci.

Produzione:

Un valore di verità / falsità che indica se l'ingresso è o meno un numero di Fibonacci.

Esempi:

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

punteggio:

Questo è , vince il conteggio di byte più basso.


2
Il linguaggio di programmazione che sto usando supporta solo numeri fino a 9999 (Geometry Dash). Va bene se suppongo che supporti numeri fino a 1000000, in teoria?
MilkyWay90,

Risposte:


36

Neim , 2 byte

f𝕚

Spiegazione:

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

Funziona come il mio È Hip per essere la risposta quadrata , ma utilizza un elenco infinito diverso f:, per fibonacci.

Provalo!


1
Wow! Punteggio impressionante.
Gryphon - Ripristina Monica il

2
È fantastico, ma non 2 byte. In UTF-8 è rappresentato come "66 F0 9D 95 9A"
sm4rk0

10
@ sm4rk0 È fantastico, ma ti sbagli. Neim usa una tabella codici personalizzata , quindi la rappresentazione in byte di questo è66 D5
Okx,

Questo ciclo non è per sempre se l'ingresso non è nell'elenco? In tal caso, conta come falso?
Enrico Borba,

@EnricoBorba Neim sa che l'ennesimo elemento in questo elenco infinito sarà sempre uguale o minore dell'n + 1 ° elemento nell'elenco. Pertanto, può catturare se stesso e non funzionerà per sempre. Hai provato il programma vero? : P
Okx,

18

JavaScript (ES6), 34 byte

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

Genera in modo ricorsivo la sequenza di Fibonacci fino a quando non trova un elemento maggiore o uguale all'input, quindi restituisce input == input.


NB: l'ingenuo calcolo ricorsivo della sequenza di Fibonacci è O (Fib (n)) - circa O (1.6 ^ n)
Alnitak

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

@jackkav Grazie, ma la sfida è determinare se l'input è un numero di Fibonacci.
ETHproductions

12

Retina , 23 byte

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

Provalo online!

Input in unario, output 0o 1.

Spiegazione

La sequenza di Fibonacci è un buon candidato per una soluzione con riferimenti in avanti, ovvero un "backreference" che si riferisce a un gruppo circostante o a uno che appare più avanti nella regex (in questo caso, stiamo effettivamente usando entrambi). Quando si corrispondono numeri come questo, dobbiamo capire un'espressione ricorsiva per la differenza tra gli elementi della sequenza. Ad esempio per abbinare i numeri triangolari, di solito abbiniamo il segmento precedente più uno. Per abbinare i numeri quadrati (le cui differenze sono i numeri dispari), abbiniamo il segmento precedente più due.

Poiché otteniamo i numeri di Fibonacci aggiungendo il penultimo elemento all'ultimo, le differenze tra loro sono anche solo i numeri di Fibonacci. Quindi dobbiamo abbinare ogni segmento come la somma dei due precedenti. Il nucleo del regex è questo:

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

Ora questo finisce per aggiungere i numeri di Fibonacci a partire da 1 , cioè 1, 1, 2, 3, 5, ... . Coloro aggiungere fino a 1, 2, 4, 7, 12, ... . Cioè sono uno in meno dei numeri di Fibonacci, quindi aggiungiamo un 1alla fine. L'unico caso che non copre è zero, quindi all'inizio abbiamo l' ^$alternativa per coprirlo.


2
Molto elegante! Vorrei solo sottolineare, per completezza, che può essere abbreviato in 20 byte in PCRE usando un quantificatore possessivo:^$|^(^1|\2?+(\1))*1$
Deadcode

1
@Deadcode Mi mancano molto quelli in .NET;)
Martin Ender il

Salva 1 byte rimuovendo il secondo non necessario ^.
Neil

12

Regex (sapore ECMAScript), 392 358 328 224 206 165 byte

Le tecniche che devono entrare in gioco per abbinare i numeri di Fibonacci con una regex ECMAScript (in unario) sono molto lontane da come è meglio farlo nella maggior parte degli altri sapori regex. La mancanza di backreferenze o ricorsioni in avanti / nidificate significa che è impossibile contare direttamente o mantenere un totale parziale di qualsiasi cosa. La mancanza di lookbehind rende spesso una sfida anche avere abbastanza spazio per lavorare.

Molti problemi devono essere affrontati da una prospettiva completamente diversa e sembrano irrisolvibili fino all'arrivo di alcune intuizioni chiave. Ti costringe a lanciare una rete molto più ampia per scoprire quali proprietà matematiche dei numeri con cui stai lavorando potrebbero essere utilizzate per rendere risolvibile un particolare problema.

Nel marzo 2014, questo è ciò che è accaduto per i numeri di Fibonacci. Guardando la pagina di Wikipedia, inizialmente non riuscivo a trovare un modo, sebbene una particolare proprietà sembrasse allettante. Quindi il matematico Teukon ha delineato un metodo che ha chiarito che sarebbe possibile farlo, usando quella proprietà insieme a un'altra. Era riluttante a costruire effettivamente la regex. La sua reazione quando sono andato avanti e l'ho fatto:

Sei pazzo! ... Pensavo che potresti farlo.

Come con gli altri miei post di regex matematici unari ECMAScript, darò un avvertimento: consiglio vivamente di imparare a risolvere i problemi matematici unari in regex ECMAScript. È stato un viaggio affascinante per me e non voglio rovinarlo per nessuno che potrebbe potenzialmente provarlo da solo, in particolare quelli con un interesse per la teoria dei numeri. Vedi quel post per un elenco di problemi raccomandati consecutivamente con tag spoiler da risolvere uno per uno.

Quindi non leggere oltre se non vuoi che qualche magia regex unaria sia viziata per te . Se vuoi fare un tentativo per capire da solo questa magia, ti consiglio vivamente di iniziare risolvendo alcuni problemi nella regex di ECMAScript come indicato in quel post collegato sopra.

La sfida che ho affrontato inizialmente: un numero intero positivo x è un numero di Fibonacci se e solo se 5x 2 + 4 e / o 5x 2 - 4 è un quadrato perfetto. Ma non c'è spazio per calcolare questo in una regex. L'unico spazio in cui dobbiamo lavorare è il numero stesso. Non abbiamo nemmeno abbastanza spazio per moltiplicare per 5 o prendere il quadrato, figuriamoci entrambi.

L'idea di teukon su come risolverlo ( originariamente pubblicato qui ):

Il regex è presentato con una stringa del modulo ^x*$, sia z la sua lunghezza. Controlla se z è uno dei primi numeri di Fibonacci a mano (dovrebbero fare fino a 21). Se non è:

  1. Leggi un paio di numeri, a <b, in modo tale che b non sia maggiore di 2a.
  2. Usa le previsioni per costruire a 2 , ab e b 2 .
  3. Asserire che 5a 2 + 4 o 5a 2 - 4 è un quadrato perfetto (quindi a deve essere F n-1 per qualche n).
  4. Asserire che 5b 2 + 4 o 5b 2 + 4 è un quadrato perfetto (quindi b deve essere F n ).
  5. Verifica che z = F 2n + 3 o z = F 2n + 4 utilizzando il precedente a a 2 , ab e b 2 e le identità:
    • F 2n-1 = F n 2 + F n-1 2
    • F 2n = (2F n-1 + F n ) F n
In breve: queste identità ci consentono di ridurre il problema di verificare che un dato numero sia Fibonacci, controllando che una coppia di numeri molto più piccoli sia Fibonacci. Una piccola algebra mostrerà che per n abbastanza grande (n = 3 dovrebbe fare), F 2n + 3 > F n + 5F n 2 + 4, quindi dovrebbe esserci sempre spazio sufficiente.

Ed ecco un mockup dell'algoritmo in C che ho scritto come test prima di implementarlo in regex.

Quindi, senza ulteriori indugi, ecco la 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})$

Provalo online!

E la versione stampata e commentata:

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

L'algoritmo di moltiplicazione non è spiegato in quei commenti, ma è brevemente spiegato in un paragrafo dei miei post postgex di numeri abbondanti .

Stavo mantenendo sei diverse versioni del regex di Fibonacci: quattro che cricchettano dalla lunghezza più breve alla velocità più veloce e usano l'algoritmo spiegato sopra, e altri due che usano un algoritmo diverso, molto più veloce ma molto più lungo, che come ho trovato può effettivamente tornare l'indice di Fibonacci come una corrispondenza (spiegando che l'algoritmo qui va oltre lo scopo di questo post, ma è spiegato nella discussione originale Gist ). Non credo che manterrei di nuovo molte versioni molto simili di un regex, perché al momento stavo facendo tutti i miei test su PCRE e Perl, ma il mio motore regex è abbastanza veloce che i problemi di velocità non sono più così importanti (e se un particolare costrutto sta causando un collo di bottiglia, posso aggiungere un'ottimizzazione per esso) - anche se probabilmente manterrei di nuovo una versione più veloce e una versione più corta, se la differenza in velocità erano abbastanza grandi.

La versione "restituisce l'indice di Fibonacci meno 1 come una partita" (non fortemente giocata a golf):

Provalo online!

Tutte le versioni sono su github con la cronologia completa delle ottimizzazioni del golf:

regex per l'abbinamento dei numeri di Fibonacci - short, speed 0.txt (il più breve ma più lento, come in questo post)
regex per l'abbinamento dei numeri di Fibonacci - short, speed 1.txt
regex per l'abbinamento dei numeri di Fibonacci - short, speed 2.txt
regex per numeri di Fibonacci corrispondenti - breve,
regex 3.txt di velocità per i numeri di Fibonacci corrispondenti - regex fast.txt
per numeri di Fibonacci corrispondenti - return index.txt


9

Python 3 , 48 byte

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

Provalo online!


1
Essere Python non dovrebbe funzionare, date risorse sufficienti, per input arbitrariamente grandi?
Jonathan Allan,

2
Ho sempre avuto l'impressione di poter usare l'algoritmo desiderato per tutto il tempo, poiché funziona in pratica se i calcoli si adattano al tipo di dati e in teoria con una precisione infinita. Certo, usando solo intsi imposta la barra più in alto (ancora non arbitrariamente grande), ma non forziamo nemmeno le risposte C per usare numeri interi a 64 bit (o 128 bit con gcc). Ad ogni modo, essere autorizzati a usare lo stesso algoritmo in una lingua ma non in un'altra sembra assurdo.
Dennis,

La visione algoritmica ha un senso (avevo sempre pensato che fosse il dominio di input a dettare i criteri di "adattamento nel tipo di dati"). L'unica cosa da tenere d'occhio è l'area grigia tra l' idea dell'algoritmo e la sua implementazione. Qui si potrebbe verificare se uno dei numeri interi è quadrato senza lanciare float. Immagino che un cast interno come effetto collaterale sia accettabile purché faccia parte di un algoritmo legittimo e funzionante (... e sono abbastanza sicuro che un algoritmo che si basava sul cast non sarebbe accettabile).
Jonathan Allan,

@JonathanAllan Poiché il valore massimo da gestire è 1e9, non penso che input arbitrariamente grandi potrebbero costituire un problema.
JAD,

1
@JarkoDubbeldam sì, quel dettaglio è stato effettivamente modificato dopo che il mio commento è stato fatto.
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

Provalo online

Grazie a Jonathan Allan per aver salvato 4 byte


Questo può essere 47 byte, se possono essere Falsevalori di verità e falsi valori True: TIO!
Mr. Xcoder,

Potrebbe anche utilizzare n-aal posto di n==ae avere -1 e 0 come valori di ritorno.
Magic Octopus Urn

@carusocomputing L'ho avuto nella mia cronologia delle modifiche, ma non funziona, perché per valori di test più grandi potresti avere -101o qualche altro risultato invece di -1.
mbomb007,

@ Mr.Xcoder pensi davvero che salvare 1 byte valga la sanità mentale di tutti?
frarugi87,

1
@ frarugi87 Vale sempre la pena salvare un byte
Mr. Xcoder il

7

05AB1E , 8 7 byte

>ÅF¹å¹m

Spiegazione:

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

Provalo online!

-1 grazie a Jonathan Allan per la soluzione alternativa al numero 0-non-a-fibonacci.


In realtà, non verrà aggiornato a 6 byte. Non riesco a credere che NON c'è modo di aggiungere uno 0 a un elenco in meno di 3 byte.
Magic Octopus Urn

@JonathanAllan la "generazione della funzione fibbonacci" in 05AB1E non contiene 0.
Magic Octopus Urn

@JonathanAllan Adesso capisco, bella idea. Mi ci è voluto un minuto per capire cosa stesse realmente accadendo lì.
Magic Octopus Urn

Non è sufficiente generare fino a n(salvare un byte) come ÅFè inclusivo e ¹åsi tradurrebbe in 0entrambi i modi n=0?
Emigna,

0AF = []. 1AF = [1,1]. Quindi apparentemente no.
Magic Octopus Urn,


5

Scherzi a parte , 3 byte

,fu

Provalo online!

Restituisce l'indice +1 nell'elenco dei numeri di Fibonacci, se vero, altrimenti restituisce falso.

Spiegazione:

,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
Seriamente maleducato ^^
Jonathan Allan il

5

Gelatina ,  8 7  6 byte

-r‘ÆḞċ

Provalo online!

Come?

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

Appunti:

  • l'incremento, è necessaria in modo che questo funziona per 2 e 3 , dal momento che sono il 3 ° e 4 ° numeri di Fibonacci - al di là di 3 tutti i numeri di Fibonacci sono superiori loro indice.
  • il -è necessario (e non solo ‘R) in modo che questo funziona per 0 dal 0 è il 0 ° numero di Fibonacci;

Umm, sembra troppo la mia risposta ...
Erik the Outgolfer,

Oh, ho giocato a golf il mio fino al tuo, tranne che il mio funziona per 3:)
Jonathan Allan il

Oh whoops ... Fibonacci è strano. (tra l'altro ho eliminato la mia risposta, se lo dici tu)
Erik the Outgolfer,

Sei sicuro dell'ultima nota? Quando eseguo l'atomo di Fibonacci su un elenco che inizia da 0, 0 viene incluso nell'output.
disperde il

1
Non sembra essere rilevante in base alla formulazione della sfida, ma se si utilizza l'atomo di conteggio con 1 come argomento nell'elenco dei numeri di Fibonacci il risultato è 2 (non 1).
FryAmTheEggman,

5

ZX81 BASIC 180 151 100 ~ 94 byte BASIC tokenizzati

Grazie a Moggy nei forum SinclairZXWorld, ecco una soluzione molto più ordinata che consente di risparmiare più byte.

 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

Questo produrrà 1 se viene inserito un numero di Fibonacci o zero in caso contrario. Anche se questo fa risparmiare byte, è molto più lento delle vecchie soluzioni di seguito. Per la velocità (ma più byte BASIC) rimuovere i VALwrapper attorno ai numeri letterali di stringa. Ecco le vecchie (er) soluzioni con alcune spiegazioni:

 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

Le modifiche sopra salvano ulteriori byte BASIC nel condensare le IFistruzioni in un singolo PRINTin linea 12; altri byte sono stati salvati usando la VALparola chiave e, e usando GOTO CODE "£", che nel set di caratteri ZX81 è 12. Le stringhe salvano più byte sui numeri poiché tutti i valori numerici sono memorizzati come float, quindi occupano più spazio nello stack VAR.

inserisci qui la descrizione dell'immagine


In realtà, potrei salvare altri 6 byte BASIC tokenizzati rimuovendo del tutto la linea 6 e cambiando la linea 5 in 5 IF R<F THEN NEXT I- il mio male!
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];}

Sicuramente potrebbe essere migliorato, ma non ho avuto tempo.


Benvenuti in PPCG!
Martin Ender,

1
Ho scritto la mia risposta solo per rendermi conto che era la stessa della tua. È possibile utilizzare espressioni lambda e variabili semplici per ottenere questo: 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;}(solo 80 byte). Provalo online!
Charlie,

1
@CarlosAlejo Salva altri 2 byte su quello con a+=binvece di a=a+be b+=ainvece di b=a+b.
TheLethalCoder il

4

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

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

Si prevede che l'input sia nello stack all'avvio del programma, quindi +3 byte per il -vflag.

Provalo online!

Funziona generando numeri di Fibonacci fino a quando non sono maggiori o uguali al numero di input, quindi controllando l'uguaglianza dell'ultimo numero generato con l'input. Emette 1se fosse un numero di Fibonacci, 0altrimenti.

Per garantire che 0sia gestito correttamente, il seme è -1 1: il primo numero generato sarà 0invece che 1.

Grazie a @cole per aver sottolineato che ipuò essere utilizzato per spingere -1nello stack quando STDIN è vuoto. Molto intelligente!

Versione precedente:

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

Ora mi sento stupido per sprecare byte controllando continuamente ogni numero generato lungo la strada. Ben fatto!
Emigna,

1
22 byte usando iinvece di 01-.
Cole

@cole ovviamente, usando icome -1quando non c'è input per STDIN, non lo avevo considerato. Ben fatto!
Chiamato il

3

Mathematica, 37 byte

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

-4 byte da @ngenisis


Fibonacci[0]0, in modo da poter salvare i 4byte includendo 0nella Tablegamma. È possibile salvare un altro byte utilizzando la notazione Table!Fibonacci@n~Table~{n,0,#+1}~FreeQ~#&
infissa

3

MATL (16 byte)

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

Provalo online!

Non è la soluzione più golfistica, ma ha voluto utilizzare il metodo diretto per verificare se "5 * x ^ 2 +/- 4" è un quadrato perfetto .

Spiegazione:

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.

Nota:

Nel caso "0" restituisce "2" perché sia ​​4 che -4 sono quadrati perfetti, lo stesso con 1 che produce "1 1". Considera qualsiasi output diverso da zero come "verità" e 0 come "falsa".




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

Provalo tu stesso!

Alternativa (ancora 49 byte)

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

Non molto originale: è la versione iterativa semplice e di base.

Funziona con numeri fino a 1.836.311.903 (47 ° numero di fibonacci) inclusi. Inoltre, il risultato non è definito (incluso un potenziale ciclo infinito).

Grazie a Kevin Cruijssen e David Conrad per l'aiuto nel golf :)


1
Bel approccio. A proposito, puoi giocare a golf un byte cambiando n==0in n<1. Nella domanda indica " Un numero intero non negativo compreso tra 0 e 1.000.000.000 ".
Kevin Cruijssen,

1
@KevinCruijssen Ho giocato a golf non 1, ma 5 byte con quella clausola! :-P Grazie, non me ne ero accorto.
Olivier Grégoire,

2
Non è necessaria una variabile temp per la sequenza di Fibonacci. Puoi calcolare le coppie successive conb+=a;a=b-a;
David Conrad il

1
Stai facendo magia nera, @DavidConrad! Ti sto dicendo! Magia nera! :)
Olivier Grégoire il

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;

Provalo online!

-6 byte grazie a @Oliver!

Questa soluzione utilizza una funzione ricorsiva piuttosto semplice.

  • La variabile nè il numero da testare.
  • Le variabili ae bsono i 2 numeri più recenti nella sequenza.
  • Verifica se il primo dei 2 numeri più recenti è inferiore all'input. In questo caso, viene effettuata una chiamata ricorsiva ai numeri successivi della serie.
  • Altrimenti, controlla se il primo numero è uguale all'input e restituisce il risultato.

Il collegamento TIO dimostra che funziona per 1134903170 che supera il valore massimo richiesto dalla sfida.


È bello vedere le soluzioni C # ultimamente :) - Penso che puoi semplicemente verificare se a<nper 51 byte
Oliver

Grazie! E bel consiglio :)
dana,

3

Alchimista , 205 134 byte

Un grande grazie a ASCII-only per la fusione piuttosto intelligente degli stati, risparmiando 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

Provalo online o verifica in batch!

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 . puoi rimuovere alcuni 0controlli per un minor numero di byte a scapito del non determinismo
solo ASCII il


@ Solo ASCII: è carino! Non riesce però a 0, ma non aggiungendo b-atom all'inizializzazione lo risolve (e salva 2 byte): D Grazie
ბიმო

2

Gelatina , 5 byte

ȷḶÆḞi

Provalo online!

Restituisce 0 per i numeri non di Fibonacci e la posizione 1 indicizzata del numero nella sequenza di Fibonacci per i numeri di Fibonacci.

Spiegazione:

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

Non funziona per 0.
Okx,

@ComradeSparklePony Sei sicuro? Per me va bene.
disperde il

1
Non funziona per 0 o qualcosa di più grande di 43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875.
Erik l'Outgolfer

1
@ Mr.Xcoder Il consenso generale è che devi essere in grado di gestire ciò che il tuo tipo di dati naturale supporta e Jelly supporta numeri interi di precisione arbitraria.
Erik the Outgolfer,

1
Ancora non funziona per nulla oltre 26863810024485359386146727202142923967616609318986952340123175997617981700247881689338369654483356564191827856161443356312976673642210350324634850410377680367334151172899169723197082763985615764450078474174626.
Erik l'Outgolfer


2

R, 43 40 byte

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

pryr::f crea una funzione:

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

Utilizza DescTools::Fibonacciper creare i primi x+1numeri di fibonacci e verifica l'inclusione. x+1perché il terzo fibnum è 2 e non sarebbe sufficiente per verificare l'inclusione di 3.

Fortunatamente Desctools::Fibonacci(0)=0, quindi è un bel freebee.

-3 byte grazie a MickyT


-1:x+1ti farà risparmiare un byte, ma 0:45ti farà risparmiare tre e coprirà l'intervallo richiesto
MickyT

@MickyT Oh, devo aver trascurato le specifiche di portata richieste. Grazie :)
JAD,

Un approccio alternativo, solo 36 byte: pryr::f(any(!(5*n^2+c(-4,4))^.5%%1)).
rturnbull,

Sono arrivato a 32 byte, vedi qui .
rturnbull,

Non ho molta familiarità con le regole del code golf - ha senso consentire pacchetti non di base? Potrei scrivere codice R arbitrario in un pacchetto, installarlo ed eseguirlo nello stesso modo in cui hai eseguito la funzione pryr.
mb7744,

2

Haskell , 31 byte

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

Provalo online! Questo sfrutta il fatto che l'input sarà compreso tra 0 e 1.000.000.000, quindi dobbiamo controllare solo i primi 45 numeri di Fibonacci. f=0:scanl(+)1fgenera un elenco infinito di numeri di Fibonacci, take 45fè l'elenco dei primi 45 numeri di Fibonacci e elemcontrolla se l'input è in questo elenco.


Versione senza restrizioni: 36 byte

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

Provalo online! Per chiunque n, prendere i primi n+3numeri di Fibonacci garantirà che nsarà in questa lista se si tratta di un numero di Fibonacci.

Si noti che questo approccio è incredibilmente inefficiente per numeri elevati che non sono numeri di Fibonacci, poiché è n+3necessario calcolare tutti i numeri di Fibonacci.


2

Javascript (ES6 senza l'operatore **), 44 byte

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

Si basa sul rapporto tra i numeri successivi di Fibonacci che si avvicinano al rapporto aureo. Il valore di c è la parte frazionaria dell'input divisa per il rapporto aureo - se l'input è Fibonacci, questo sarà molto vicino a 1 e il valore di c-c² sarà molto piccolo.

Non è breve come alcune delle altre risposte di JS ma viene eseguito in O (1) tempo.


Sei sicuro che sia esatto?
user259412

Non funziona con il numero di fibonacchi 16558014
Black Owl Kai del

2

Julia 0.4 , 29 byte

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

Provalo online!


Se non è così che rispondi a Julia, fammi sapere. Non sono sicuro di come funzioni l'input su TIO.


1
Dovresti renderlo una funzione regolare (conteggio !m=) o un lambda (conteggio m->). Ancora più importante, questo non riesce per 0 così com'è.
Dennis,

2

R, 32 31 byte

Riceve input da stdin, restituisce TRUEo FALSEcome appropriato.

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

2

Lisp comune, 61 54 byte

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

Provalo online!

La riduzione delle dimensioni rispetto alla versione precedente:

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

è stato innescato dall'idea che per generare la sequenza dei numeri di Fibonacci siano necessarie solo due variabili, non tre.


1

Mathematica, 33 byte

AtomQ@*InverseFunction[Fibonacci]

Puoi salvare un paio di byte con @*(e poi rilasciare la finale @#&)
Martin Ender il

1

JS (ES6), 57 byte

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

Utilizza il metodo di carusocomputing . Molto più golfista della mia altra risposta .

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)
}
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.