Ta tâche:

Ecrivez un programme ou une fonction pour vérifier si un numéro entré est un numéro de Fibonacci . Un numéro de Fibonacci est un nombre contenu dans la séquence de Fibonacci.

La séquence de Fibonacci est définie comme suit: F(n) = F(n - 1) + F(n - 2)

Avec les graines étant F(0) = 0et F(1) = 1.

Contribution:

Un entier non négatif compris entre 0 et 1 000 000 000 pouvant être un nombre de Fibonacci ou non.

Sortie:

Une valeur vérité / fausseté indiquant si l'entrée est un nombre de Fibonacci ou non.

Exemples:

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

Notation:

C'est le code-golf , le plus petit nombre d'octets gagne.

Neim , 2 octets

f𝕚

Explication:

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

Fonctionne de la même façon que ma réponse de réponse C'est carré , mais utilise une liste infinie différente f:, pour fibonacci.

Essayez le!

JavaScript (ES6), 34 octets

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

Génère récursivement la séquence de Fibonacci jusqu’à ce qu’il trouve un élément supérieur ou égal à l’entrée, puis renvoie l’élément item == input.

Retina , 23 octets

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

Essayez-le en ligne!

Entrée en unaire, sorties 0ou 1.

Explication

La séquence de Fibonacci est un bon candidat pour une solution avec des références en aval, c’est-à-dire un "backreference" qui fait référence à un groupe environnant ou à un groupe qui apparaît plus tard dans la regex (dans ce cas, nous utilisons en fait les deux). Lorsque des nombres tels que ceux-ci correspondent, nous devons trouver une expression récursive pour la différence entre les éléments de séquence. Par exemple, pour faire correspondre des nombres triangulaires, nous associons généralement le segment précédent plus un. Pour faire correspondre les nombres carrés (dont les différences sont les nombres impairs), nous comparons le segment précédent plus deux.

Puisque nous obtenons les nombres de Fibonacci en ajoutant l’avant-dernier élément au dernier, les différences entre eux ne sont également que les nombres de Fibonacci. Nous devons donc faire correspondre chaque segment à la somme des deux précédents. Le coeur de la regex est la suivante:

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

Maintenant , cela finit par ajouter les nombres de Fibonacci à partir de 1 , soit 1, 1, 2, 3, 5, ... . Les ajouter jusqu'à 1, 2, 4, 7, 12, ... . C'est-à-dire qu'ils sont un de moins que les nombres de Fibonacci, nous ajoutons donc un 1à la fin. Le seul cas que cela ne couvre pas est zéro, nous avons donc la ^$possibilité au début de couvrir cela.

Regex (saveur ECMAScript), 392 358 328 224 206 165 octets

Les techniques qui doivent être utilisées pour faire correspondre les nombres de Fibonacci avec une expression rationnelle ECMAScript (unaire) sont bien loin de la meilleure façon de la faire dans la plupart des autres saveurs d’expression rationnelle. L'absence de références arrière ou de récursion imbriquées / imbriquées signifie qu'il est impossible de compter directement ou de conserver un total cumulé. Le manque de repères rend souvent difficile le fait de disposer de suffisamment d’espace pour travailler.

De nombreux problèmes doivent être abordés sous un angle totalement différent et ne semblent pas résolus avant l’arrivée de certaines informations essentielles. Cela vous oblige à utiliser un réseau beaucoup plus large pour déterminer quelles propriétés mathématiques des nombres avec lesquels vous travaillez pourraient être utilisées pour résoudre un problème particulier.

En mars 2014, c'est ce qui s'est passé pour les chiffres de Fibonacci. En regardant la page Wikipedia, je ne pouvais pas au départ trouver un moyen, même si une propriété en particulier semblait extrêmement proche. Ensuite, le mathématicien Teukon a présenté une méthode indiquant clairement qu'il serait possible de le faire, en utilisant cette propriété avec une autre. Il était réticent à réellement construire la regex. Sa réaction quand je suis allé de l'avant et l'a fait:

Vous êtes fou! ... Je pensais que tu pourrais faire ça.

Comme pour mes autres publications ECMAScript sur les expressions mathématiques unaires, je tiens à vous avertir: je vous recommande vivement d'apprendre à résoudre des problèmes mathématiques unaires dans ECMAScript regex. Ce voyage a été fascinant pour moi et je ne veux pas le gâter pour ceux qui voudraient éventuellement l'essayer eux-mêmes, en particulier ceux qui s'intéressent à la théorie des nombres. Voir ce post pour une liste de problèmes recommandés consécutivement étiquetés spoiler à résoudre un par un.

Donc , ne lisez pas plus loin si vous ne voulez pas que la magie des expressions rationnelles unaires vous soit gâtée . Si vous voulez vraiment essayer de découvrir cette magie vous-même, je vous recommande vivement de commencer par résoudre certains problèmes de la regex ECMAScript, comme indiqué dans l'article ci-dessus.

Le défi que j’avais initialement relevé: un entier positif x est un nombre de Fibonacci si et seulement si 5x ² + 4 et / ou 5x ² - 4 est un carré parfait. Mais il n'y a pas de place pour calculer cela dans une regex. Le seul espace dans lequel nous devons travailler est le numéro lui-même. Nous n'avons même pas assez de place pour multiplier par 5 ou prendre la place, sans parler des deux.

L'idée de teukon sur la façon de le résoudre ( posté à l'origine ici ):

Le regex est présenté avec une chaîne de la forme ^x*$, soit z sa longueur. Vérifiez si z est ou non l’un des premiers nombres de Fibonacci à la main (jusqu’à 21 devrait suffire). Si ce n'est pas le cas:

1. Lire quelques nombres, a <b, tels que b n’est pas plus grand que 2a.
   
2. Utilisez des prévisions pour construire un ² , un ab et un b ² .
   
3. Affirmer que 5a ² + 4 ou 5a ² - 4 est un carré parfait (il faut donc être F _n-1 pour certains n).
   
4. Affirmez que 5b ² + 4 ou 5b ² + 4 est un carré parfait (donc b doit être F _n ).
   
5. Vérifiez que z = F _{2n + 3} ou z = F _{2n + 4} en utilisant les versions antérieures a ² , ab et b ² et les identités:
   
   • F _2n-1 = F _n ² + F _n-1 ²
     
   • F _2n = (2F _n-1 + F _n ) F _n
     

En bref: ces identités nous permettent de réduire le problème de vérification d’un nombre donné de Fibonacci, mais également de vérifier qu’une paire de nombres beaucoup plus petits est bien de Fibonacci. Un peu d'algèbre montrera que pour n assez grand (n = 3 devrait faire), F _{2n + 3} > F _n + 5F _n ² + 4 donc il devrait toujours y avoir assez d'espace.

Et voici une maquette de l'algorithme en C que j'ai écrit comme test avant de l'implémenter dans une regex.

Donc, sans plus tarder, voici 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})$

Essayez-le en ligne!

Et la jolie version commentée et commentée:

^(
  (?=
    (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'algorithme de multiplication n'est pas expliqué dans ces commentaires, mais est brièvement expliqué dans un paragraphe de mon article sur les regex en nombres abondants .

Je maintenais six versions différentes de la regex de Fibonacci: quatre qui vont du plus court au plus rapide et qui utilisent l'algorithme expliqué ci-dessus, et deux autres qui utilisent un algorithme différent, beaucoup plus rapide mais beaucoup plus long, qui peut effectivement renvoyer l'index de Fibonacci en tant que correspondance (expliquer cet algorithme dépasse le cadre de cet article, mais il est expliqué dans la discussion d'origine Gist ). Je ne pense pas que je maintiendrais autant de versions très similaires d’une regex, car à l’époque, je faisais tous mes tests sous PCRE et Perl, mais mon moteur de regex est assez rapide pour que les soucis de vitesse ne soient plus aussi importants (et si une construction en particulier est à l'origine d'un goulot d'étranglement, je peux lui ajouter une optimisation) - bien que je conserverais probablement encore une version la plus rapide et une version la plus courte, à la différence en vitesse étaient assez gros.

La version "retourne l'indice de Fibonacci moins 1 en match" (peu joué au golf):

Essayez-le en ligne!

Toutes les versions sont sur github avec l'historique complet des optimisations de golf:

regex pour faire correspondre les nombres de Fibonacci - court, vitesse 0.txt (le plus court mais le plus lent, comme dans cet article)
regex pour faire correspondre les nombres de Fibonacci - court, vitesse 1.txt
regex pour faire correspondre les nombres de Fibonacci - court, vitesse 2.txt
regex pour numéros
correspondants de Fibonacci - expression rationnelle courte et rapide 3.txt pour les numéros correspondants de Fibonacci - regex plus rapide.txt
pour les numéros correspondants de Fibonacci - retour index.txt

Python 3 , 48 octets

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

Essayez-le en ligne!

Python 2, 48 44 octets

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

Essayez-le en ligne

_{Merci à Jonathan Allan pour avoir économisé 4 octets}

05AB1E , 8 7 octets

>ÅF¹å¹m

Explication:

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

Essayez-le en ligne!

-1 merci à Jonathan Allan pour la solution de contournement 0-not-a-fibonacci-number.

Perl 6 , 23 octets

{$_∈(0,1,*+*...*>$_)}

Sérieusement , 3 octets

,fu

Essayez-le en ligne!

Retourne l'index +1 dans la liste des nombres de Fibonacci si truey, sinon renvoie fausseté.

Explication:

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

Gelée ,  8 7  6 octets

-r‘ÆḞċ

Essayez-le en ligne!

Comment?

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

Remarques:

• l'incrément, ‘, est nécessaire pour que cela fonctionne pour 2 et 3 , car ils sont les 3 ^ème et 4 ^ème nombres de Fibonacci - au - delà de 3 tous les nombres de Fibonacci sont supérieurs à leur indice.
• le -est nécessaire (plutôt que simplement ‘R) donc cela fonctionne pour 0 puisque 0 est le 0 ^ème nombre de Fibonacci;

ZX81 BASIC 180 151 100 ~ 94 octets BASIC sous forme de jetons

Grâce à Moggy sur les forums SinclairZXWorld, voici une solution beaucoup plus élégante qui permet d’économiser plus d’octets.

 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

Cela affichera 1 si un numéro de Fibonacci est entré, ou zéro sinon. Bien que cela économise des octets, il est beaucoup plus lent que les anciennes solutions ci-dessous. Pour la vitesse (mais plus d'octets BASIC), supprimez les VALenveloppeurs autour des nombres littéraux de chaîne. Voici les anciennes solutions avec quelques explications:

 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

Les modifications ci-dessus permettent d’économiser davantage d’octets BASIC en condensant les IFinstructions en une seule PRINTligne 12; Les autres octets ont été sauvegardés à l'aide du VALmot clé and, et de l'utilisation de GOTO CODE "£"ce qui est 12 dans le jeu de caractères ZX81. Les chaînes enregistrent davantage d'octets que de chiffres car toutes les valeurs numériques sont stockées sous forme de flottants. Par conséquent , utilisez davantage d'espace sur la pile VAR.

C #, 109 octets

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

Cela pourrait certainement être amélioré, mais je n’avais pas le temps.

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

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

L'entrée devrait être sur la pile au début du programme, donc +3 octets pour le -vdrapeau.

Essayez-le en ligne!

Cela fonctionne en générant des nombres de Fibonacci jusqu'à ce qu'ils soient supérieurs ou égaux au nombre entré, puis en vérifiant que le dernier numéro généré est bien égal à celui de l'entrée. Affiche 1s'il s'agit d'un nombre de Fibonacci, 0sinon.

Pour s'assurer que le 0traitement est effectué correctement, la graine est -1 1- le premier numéro généré sera 0plutôt que 1.

Merci à @cole, qui ipeut être utilisé pour -1empiler lorsque STDIN est vide. Très intelligent!

La version précédente:

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

Mathematica, 37 octets

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

-4 octets de @ngenisis

MATL (16 octets)

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

Essayez-le en ligne!

Pas la solution la plus risquée, mais je voulais utiliser la méthode directe pour vérifier si "5 * x ^ 2 +/- 4" est un carré parfait .

Explication:

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.

Remarque:

Dans le cas "0", il retourne "2" car 4 et -4 sont des carrés parfaits, idem avec 1 qui produit "1 1". Considérez toute sortie non nulle comme "vérité" et 0 comme "fausseté".

Pari / GP , 32 octets

n->!prod(x=0,n+1,fibonacci(x)-n)

Essayez-le en ligne!

PHP , 44 octets

for(;0>$s=$x-$argn;)$x=+$y+$y=$x?:1;echo!$s;

Essayez-le en ligne!

PHP , 58 octets

for($x=0,$y=1;$x<$argn;$x=$y,$y=$t)$t=$x+$y;echo$x==$argn;

Essayez-le en ligne!

Java, 72 69 68 63 59 55 50 49 octets

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

Testez-le vous-même!

Alternative (encore 49 octets)

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

Pas très original: c'est la version itérative simple et basique.

Cela fonctionne pour des nombres allant jusqu'à 1 836 311 903 (47ème numéro de fibonacci) inclus. Au-dessus, le résultat est indéfini (y compris une boucle potentielle infinie).

Merci à Kevin Cruijssen et David Conrad pour leur aide au golf :)

C # (.NET Core) , 51 octets

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

Essayez-le en ligne!

-6 octets grâce à @Oliver!

Cette solution utilise une fonction récursive assez simple.

• La variable nest le nombre à tester.
• Les variables aet bsont les 2 nombres les plus récents de la séquence.
• Vérifie si le premier des 2 numéros les plus récents est inférieur à l'entrée. Lorsque tel est le cas, un appel récursif est effectué aux numéros suivants de la série.
• Sinon, vérifiez si le premier nombre est égal à l'entrée et renvoyez le résultat.

Le lien TIO illustre ce fonctionnement pour 1134903170 qui dépasse la valeur maximale requise par le défi.

Alchimiste , 205 134 octets

^{Un grand merci à ASCII uniquement pour la fusion plutôt intelligente des états, économisant 71 octets !!}

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

Essayez-le en ligne ou vérifiez par lot!

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

Gelée , 5 octets

ȷḶÆḞi

Essayez-le en ligne!

Renvoie 0 pour les nombres autres que Fibonacci et la position indexée 1 du nombre dans la séquence de Fibonacci pour les nombres de Fibonacci.

Explication:

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

Dyalog APL, 17 octets

0∊1|.5*⍨4 ¯4+5××⍨

Essayez-le en ligne!

R, 43 40 octets

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

pryr::f crée une fonction:

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

Utilise DescTools::Fibonaccipour créer les premiers x+1nombres de fibonacci et vérifie l’inclusion. x+1parce que le troisième fibnum est 2, et cela ne suffirait pas pour vérifier l'inclusion de 3.

Heureusement Desctools::Fibonacci(0)=0, c'est un joli freebee.

-3 octets grâce à MickyT

Haskell , 31 octets

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

Essayez-le en ligne! Ceci exploite le fait que l'entrée sera dans la plage de 0 à 1 000 000 000. Il est donc nécessaire de vérifier uniquement les 45 premiers nombres de Fibonacci. f=0:scanl(+)1fgénère une liste infinie de nombres de Fibonacci, take 45fest la liste des 45 premiers nombres de Fibonacci et elemvérifie si l'entrée est dans cette liste.

Version illimitée: 36 octets

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

Essayez-le en ligne! Pour tous n, prendre les premiers n+3numéros de Fibonacci garantira qu’il nfigurera dans cette liste s’il s’agit d’un numéro de Fibonacci.

Notez que cette approche est incroyablement inefficace pour les nombres élevés qui ne sont pas des nombres de Fibonacci, car tous n+3les nombres de Fibonacci doivent être calculés.

Javascript (ES6 sans l'opérateur **), 44 octets

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

S'appuie sur le rapport entre les nombres successifs de Fibonacci approchant le nombre d'or. La valeur de c est la partie fractionnaire de l'entrée divisée par le nombre d'or - si l'entrée est Fibonacci, il sera très proche de 1 et la valeur de c-c² sera très petite.

Pas aussi court que d'autres réponses de JS mais qui s'exécute dans le temps O (1).

Julia 0.4 , 29 bytes

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

Essayez-le en ligne!

Si ce n'est pas ainsi que vous répondez Julia, faites-le-moi savoir. Je ne sais pas comment fonctionne l'entrée sur TIO.

R, 32 31 octets

Prend les entrées de stdin, retourne TRUEou FALSEselon le cas.

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

Common Lisp, 61 54 octets

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

Essayez-le en ligne!

La réduction de taille par rapport à la version précédente:

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

a été déclenchée par l’idée que pour générer la séquence des nombres de Fibonacci, seules deux variables sont nécessaires, et non trois.

Mathematica, 33 octets

AtomQ@*InverseFunction[Fibonacci]

JS (ES6), 57 octets

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

Utilise la méthode de carusocomputing . Beaucoup plus golfeur que mon autre réponse .

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