[Question]
  [
First, let's talk about [Beatty sequences](https://en.wikipedia.org/wiki/Beatty_sequence). Given a positive irrational number ***r***, we can construct an infinite sequence by multiplying the positive integers to ***r*** in order and taking the floor of each resulting calculation. For example,  
[![Beatty sequence of r](https://i.stack.imgur.com/skq6L.png)](https://i.stack.imgur.com/skq6L.png)
If ***r*** > 1, we have a special condition. We can form another irrational number ***s*** as ***s*** = ***r*** / (***r*** - 1). This can then generate its own Beatty sequence, ***B***s. The neat trick is that ***B***r and ***B***s are *complementary*, meaning that every positive integer is in exactly one of the two sequences.
If we set ***r*** = ϕ, the golden ratio, then we get ***s*** = ***r*** + 1, and two special sequences. The *lower Wythoff sequence* for ***r***:
```
1, 3, 4, 6, 8, 9, 11, 12, 14, 16, 17, 19, 21, 22, 24, 25, 27, 29, ... 
```
and the *upper Wythoff sequence* for ***s***:
```
2, 5, 7, 10, 13, 15, 18, 20, 23, 26, 28, 31, 34, 36, 39, 41, 44, 47, ... 
```
These are sequences [A000201](https://oeis.org/A000201) and [A001950](https://oeis.org/A001950) on OEIS, respectively.
### The Challenge
Given a positive input integer `1 <= n <= 1000`, output one of two distinct values indicating whether the input is in the *lower Wythoff sequence* or the *upper* sequence. The output values could be `-1` and `1`, `true` and `false`, `upper` and `lower`, etc.
Although your submitted algorithm must theoretically work for all inputs, in practice it only has to work with the first 1000 input numbers.
## I/O and Rules
* The input and output can be given by [any convenient method](http://meta.codegolf.stackexchange.com/q/2447/42963).
* The input and output can be assumed to fit in your language's native number type.
* Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
* [Standard loopholes](http://meta.codegolf.stackexchange.com/q/1061/42963) are forbidden.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so all usual golfing rules apply, and the shortest code (in bytes) wins.
  
[Answer]
## JavaScript (ES6), ~~50~~ 35 bytes
```
f=(n,s="1",t=0)=>s[n-1]||f(n,s+t,s)
```
```
<input type=number min=1 oninput=o.textContent=this.value&amp;&amp;f(this.value)><pre id=o>
```
Outputs `1` for lower and `0` for upper. Explanation: Partial lists of boolean values can be constructed using a Fibonacci-like identity: given two lists, starting with `1` and `10`, each subsequent list is the concatenation of the previous two, resulting in `101`, `10110`, `10110101` etc. In this case it's slightly golfier to have a fake 0th entry of `0` and use that to construct the second element of the list.
[Answer]
# [Python](https://docs.python.org/2/), 25 bytes
```
lambda n:-n*2%(5**.5+1)<2
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPSjdPy0hVw1RLS89U21DTxuh/QVFmXolCWmZOSWqRRppOUWJeeqqGoY6hgaGm5v//AA "Python 2 – Try It Online")
Uses the very simple condition:
> 
> `n` is in the lower Wythoff sequence exactly if `-n%phi<1`.
> 
> 
> 
Note that the modulo result is positive even though `-n` is negative, matching how Python does modulo. 
> 
> **Proof:** Let `a = -n%phi`, which lies in the range `0 <= a < phi`. We can split
>  `-n` modulo `phi` as `-n = -k*phi + a` for some positive integer `k`.
>  Rearrange that to `n+a = k*phi`. 
> 
> 
> If `a<1`, then `n = floor(n+a) = floor(k*phi)`, and so is in the lower
>  Wythoff sequence. 
> 
> 
> Otherwise, we have `1 <= a < phi` so 
> 
> 
> 
> ```
> n+1 = floor(n+a) = floor(k*phi)
> n > n+a-phi = k*phi - phi = (k-1)*phi
> 
> ```
> 
> so `n` falls in the gap between `floor((k-1)*phi)` and `floor(k*phi)`
>  and is missed by the lower Wythoff sequence.
> 
> 
> 
This corresponds to this code:
```
lambda n:-n%(5**.5/2+.5)<1
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSHPSjdPVcNUS0vPVN9IW89U08bwf0FRZl6JQlpmTklqkUaaTlFiXnqqhqGOoYGhpub//wA "Python 2 – Try It Online")
We save a byte by doubling to `-(n*2)%(phi*2)<2`.
[Answer]
# [Haskell](https://www.haskell.org/), 26 bytes
```
(l!!)
l=0:do x<-l;[1-x..1]
```
[Try it online!](https://tio.run/##y0gszk7NyfmfZhvzXyNHUVGTK8fWwColX6HCRjfHOtpQt0JPzzD2f5FttCGQYWAQy5WbmJlnm5tY4KtQUJSZV6KiEB1dUQNUXaSTplBha5scW5NsoxttqGMQG/v/X3JaTmJ68X/d5IICAA "Haskell – Try It Online")
No floats, unlimited precision. Thanks for H.PWiz for two bytes.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 9 bytes
```
L5t>;*óså
```
[Try it online!](https://tio.run/##MzBNTDJM/f/fx7TEzlrr8Obiw0v//zc0NQcA "05AB1E – Try It Online")
---
0 means upper, 1 means lower. **Try the first 100: [Try it online!](https://tio.run/##MzBNTDJM/W9oYODup3R4v62Svd9/H9MSO2utw5v9Di/9b1v7HwA "05AB1E – Try It Online")**
---
```
    CODE   |      COMMAND      # Stack (Input = 4)
===========+===================#=======================
L          | [1..a]            # [1,2,3,4]
 5t>;      | (sqrt(5) + 1)/2   # [phi, [1,2,3,4]]
     *     | [1..a]*phi        # [[1.6,3.2,4.8,6.4]]
      ó    | floor([1..a]*phi) # [[1,3,4,6]]
       så  | n in list?        # [[1]]
```
---
**Raw Command Dump:**
```
----------------------------------
Depth: 0
Stack: []
Current command: L
----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4]]
Current command: 5
----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], '5']
Current command: t
----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 2.23606797749979]
Current command: >
----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 3.23606797749979]
Current command: ;
----------------------------------
Depth: 0
Stack: [[1, 2, 3, 4], 1.618033988749895]
Current command: *
----------------------------------
Depth: 0
Stack: [[1.618033988749895, 3.23606797749979, 4.854101966249685, 6.47213595499958]]
Current command: ó
----------------------------------
Depth: 0
Stack: [[1, 3, 4, 6]]
Current command: s
----------------------------------
Depth: 0
Stack: [[1, 3, 4, 6], '4']
Current command: å
1
stack > [1]
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
N%ØpỊ
```
[Try it online!](https://tio.run/##y0rNyan8/99P9fCMgoe7u/4bGhgEHW5/1LTmPwA "Jelly – Try It Online")
Saved 1 byte thanks to [xnor's Python golf](https://codegolf.stackexchange.com/a/166893/59487).
---
### [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
×€ØpḞċ
```
[Try it online!](https://tio.run/##ARkA5v9qZWxsef//w5figqzDmHDhuJ7Ei////zM2 "Jelly – Try It Online")
Returns **1** for lower and **0** for upper.
```
×€ØpḞċ – Full Program / Monadic Link. Argument: N.
×€     – Multiply each integer in (0, N] by...
  Øp   – Phi.
    Ḟ  – Floor each of them.
     ċ – And count the occurrences of N in that list.
```
Checking \$(0,\:N]\cap \mathbb{Z}\$ is most definitely enough because \$\varphi > 1\$ and \$N > 0\$ and therefore \$0 < N < N\varphi\$.
[Answer]
# [Brain-Flak](https://github.com/DJMcMayhem/Brain-Flak), 78 bytes
```
([{}]()){<>{}((([()]))){{<>({}())}{}(([({})]({}{})))}<>([{}]{}<>)}<>({}()){{}}
```
[Try it online!](https://tio.run/##HYsxDoBACAS/s1tYWBgb40cIxVmYGI2FLeHtuHcN7Azs8bXrnc6n3VWwSAcZ2x4JwECnUAwJMrs2ZbqGlpRuvRYKA8ZjRGbVvKw/ "Brain-Flak – Try It Online")
Outputs nothing for lower and `0` for upper. Changing to a more sensible output scheme would cost 6 bytes.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~39~~ ~~33~~ 32 bytes
-6 bytes thanks to Mr. Xcoder  
-1 byte thanks to Zacharý  
```
lambda n,r=.5+5**.5/2:-~n//r<n/r
```
[Try it online!](https://tio.run/##TY7BDoIwEETvfsXeEFypXVoRIl@iHDBKNIHSNBjjxV@vQ@LBwxzey3am/j3fJyexb85x6MbLtSPHocntxmZZbpXU249TKhydCtGHh5spGabXLdQJj51f93zSTAWTYdozHZgqJg2lBYHUsLpE4AVe4AVeLAIvVZuufsVP7/@LcYmj5e0OwYYGakwIWMCCbgEXyxfQWYAL7BiwAZuyTSl@AQ "Python 2 – Try It Online")
Returns `False` for lower and `True` for upper
[Answer]
# [Julia 0.6](http://julialang.org/), 16 bytes
```
n->n÷φ<-~n÷φ
```
[Try it online!](https://tio.run/##yyrNyUw0@19u@z9P1y7v8PbzbTa6dWD6f25igQZQsKAoM68kJ09DSSXPSkFFo1wjT1NTSVNHwdDKyEDz/39jMwA "Julia 0.6 – Try It Online")
While playing around with the numbers, I came across this property: floor(n/φ) == floor((n+1)/φ) if n is in the upper Wythoff sequence, and floor(n/φ) < floor((n+1)/φ) if n is in the lower Wythoff sequence. I haven't figured out *how* this property comes about, but it gives the correct results at least upto n = 100000 (and probably beyond).
---
Old answer: 
# [Julia 0.6](http://julialang.org/), 31 bytes
```
n->n∈[floor(i*φ)for i∈1:n]
```
[Try it online!](https://tio.run/##yyrNyUw0@19u@z9P1y7vUUdHdFpOfn6RRqbW@TbNtPwihUygmKFVXuz/3MQCDaCagqLMvJKcPA0llTwrBRWNco08TU0lTR0FQysjA83//43NAA "Julia 0.6 – Try It Online")
Returns `true` for lower and `false` for upper Wythoff sequence. 
[Answer]
# [Arn](https://github.com/ZippyMagician/Arn), [9 bytes](https://github.com/ZippyMagician/Arn/wiki/Carn)
```
2>6Yx!¦ü#
```
[Try it!](https://zippymagician.github.io/Arn?code=cGhpLTE8JXBoaQ==&input=Mjk=)
# Explained
Unpacked: `phi-1<%phi`
I found another way of calculating this:
> 
> ![n % phi > phi + 1](https://latex.codecogs.com/png.latex?%5Clarge&space;n%5Cmod&space;%5CPhi&space;%3E&space;%5CPhi&space;-&space;1)
>   
> is true if `n` is in the Lower Wythoff Sequence
> 
> 
> 
This example merely uses this formula (it was shorter than `1>((n_)%phi`). And here is how it works:
```
    phi  Builtin for the Golden Ratio
  -      Minus
    1    Literal one
<        Is less than
    _    Variable initialized to STDIN, implied
  %      Modulo
    phi
```
Returns true if lower, false if upper
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 26 bytes
```
#~Ceiling~GoldenRatio<#+1&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2ar8V@5zjk1MyczL73OPT8nJTUvCCiVb6Osbaj2X9OaK6AoM6/Ewb0ov7TAqTI6KDEvPTXa0MAgVkchLfY/AA "Wolfram Language (Mathematica) – Try It Online")
An integer `n` is in the lower Wythoff Sequence iff `ceil(n/phi) - 1/phi < n/phi`.
## Proof that `ceil(n/phi) - 1/phi < n/phi` is...
Sufficient:
1. Let `ceil(n/phi) - 1/phi < n/phi`.
2. Then, `ceil(n/phi) * phi < n + 1`.
3. Note `n == n/phi * phi <= ceil(n/phi) * phi`.
4. Hence, `n <= ceil(n/phi) * phi < n + 1`.
5. Since `n` and `ceil(n/phi)` are integers, we invoke the definition
of floor and state `floor(ceil(n/phi) * phi) == n`, and `n` is in the lower
Wythoff sequence.
Necessary; proof by contrapositive:
1. Let `ceil(n/phi) - 1/phi >= n/phi`.
2. Then, `ceil(n/phi) * phi >= n + 1`.
3. Note `n + phi > (n/phi + 1) * phi > ceil(n/phi) * phi`
4. Hence `n > (ceil(n/phi) - 1) * phi`.
5. Since `(ceil(n/phi) - 1) * phi < n < n + 1 <= ceil(n/phi) * phi`, `n` is not in the lower Wythoff sequence.
[Answer]
## [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), ~~21~~ ~~19~~ 13 bytes
```
⊢∊∘⌊⍳×1+∘÷⍣=≢
```
-6 bytes from Adám after conversion to tacit function.
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn//1HXokcdXY86Zjzq6XrUu/nwdENtIOfw9ke9i20fdS76n/aobcKj3r5HXc2Petc86t1yaL3xo7aJj/qmBgc5A8kQD8/g/2kKhlxpCkZAbAzEJiC2JQA "APL (Dyalog Extended) – Try It Online")
### Old answer:
```
{⍵∊⌊((1+∘÷⍣=1)×⍳⍵)}
```
Uses the same approach as [Magic Octopus Urn's answer.](https://codegolf.stackexchange.com/a/166883/80214)
-2 bytes from ZippyMagician.
Prints 1 for upper and 0 for lower sequence.
## Explanation
```
{⍵∊⌊((2÷¯1+5*÷2)×⍳⍵)}
                 ⍳⍵   Generate list of 1 to n
     (2÷¯1+5*÷2)×     Multiply it by the golden ratio
   ⌊                  Floor the entire list
 ⍵∊                   is n in the list?
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/v/pR79ZHHV2Pero0NAy1H3XMOLz9Ue9iW0PNw9Mf9W4GSmrW/k971DbhUW/fo67mR71rHvVuObTe@FHbxEd9U4ODnIFkiIdn8P80BUOuNAUjIDYGYhMQ2xIA "APL (Dyalog Extended) – Try It Online")
[Answer]
# [Pyth](https://pyth.readthedocs.io), 8 bytes
```
/sM*.n3S
```
[Try it here!](https://pyth.herokuapp.com/?code=%2FsM%2a.n3S&test_suite=1&test_suite_input=1%0A3%0A4%0A6%0A8%0A9%0A11%0A2%0A5%0A7%0A10%0A13%0A15&debug=0)
Returns **1** for lower and **0** for upper.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 10 bytes
Returns **true** for lower and **false** for upper.
```
õ_*MQ fÃøU
```
[Try it online!](https://tio.run/##HY0xCkIxEAX7nGJrWfnuJvr9h7BQsBIRCy1EMXwUD@CZBPscLE4MvGImZHI55ket5XOYrNZyLu/y3dY6vW1C2AVTiSpJZaGyVBlUDGXOkIa1nuEd73jH@5zhfZB2uk6u99dpDFxz0x7MGGEDja7DDjtBh2P7l1CEI/EEJzj1/9ozZ2r7Hw "Japt – Try It Online")
## Explanation:
```
õ_*MQ fÃøU
             // Implicit U = Input
õ            // Range [1...U]
 _           // Loop through the range, at each element:
  *MQ        //   Multiply by the Golden ratio
      f      //   Floor
       Ã     // End Loop
        øU   // Return true if U is found in the collection
```
[Answer]
# Java 10, ~~77~~ ~~53~~ 52 bytes
```
n->{var r=Math.sqrt(5)/2+.5;return(int)(-~n/r)<n/r;}
```
Port of [@Rod's Python 2 answer](https://codegolf.stackexchange.com/a/166887/52210).  
-1 byte thanks to *@Zacharý*.
[Try it online.](https://tio.run/##LY7BbsJADETvfIXFKatVFqjEpUv6B3DhWDiYsLRLg5d6nUgVSn89OMBlLHs043fGDsvz8WeoG8wZ1hjpNgGIJIFPWAfYjCvAIaUmIEFdqAVkvF77iUoWlFjDBggqGKj8uHXIwNUa5dvlX5ZiaWZv1i09B2mZxrwpyn@asVmp@H7wY8@1PTTa86rrUjzCRWGKrXCkr889oHmSnBI/GGK18BBX1WI@12mtebgA278s4eJSK@6qUWn0pZ2@72RqySm@ebH3wx0)
---
**Old ~~77~~ 76 bytes answer:**
```
n->{for(int i=0;i++<n;)if(n==(int)((Math.sqrt(5)+1)/2*i))return 1;return 0;}
```
-1 byte thanks to *@ovs*' for something [I recommended myself last week.. xD](https://codegolf.stackexchange.com/questions/166415/find-the-10-adic-cube-root-of-3/166422#comment402310_166422)
Returns `1` for lower; `0` for upper.
[Try it online.](https://tio.run/##RU/LjsIwDLzzFRanmIhui8SFkP0DuHAEDqG0u2aLyyYuEkL99pKWSlz8GNsz44u7u/nl/NfllQsBNo74OQEglsKXLi9g27cDALnqI6OJSDuJIYgTymELDBY6nn8/y9oPS2RTQ1qv2SCViq3tUVRq4@Q3Cf9e1BJ1hl@LGSH6QhrPkJmxSE3bmZ7/1pyqyD/K3Gs6wzUaVDvxxD/7Izh8u/vIZgZobbM0jVlrHKYAu0eQ4prUjSS3eCoVK9LT1UGmmpP4Fo4/td0L)
**Explanation:**
```
n->{                    // Method with integer as both parameter and return-type
  for(int i=0;++i<=n;)  //  Loop `i` in the range [1, `n`]
    if(n==(int)((Math.sqrt(5)+1)/2*i))
                        //   If `n` is equal to `floor(Phi * i)`:
      return 1;         //    Return 1
  return 0;}            //  Return 0 if we haven't returned inside the loop already
```
`i*Phi` is calculated by taking `(sqrt(5)+1)/2 * i`, and we then floor it by casting it to an integer to truncate the decimal.
[Answer]
# [Haskell](https://www.haskell.org/), ~~153~~ ~~139~~ ~~126~~ 79 bytes
*Unlimited Precision!*
```
l=length
f a c|n<-2*l a-c,n<0||l a<a!!n=c:a|1>0=a
g x=x==(foldl f[][1..x+1])!!0
```
[Try it online!](https://tio.run/##Fcm9DsIgEADgvU9xJA7@tQHjZDhfpGG4IFDi9TSVgYF3R92@5Fvo8wzMvTNykFSWIQKBb2LHy5GBRn8Wq1v70ZJSgv5Gzdw10pCgYkXcxxc/GOLsZjNN9WTcQSndV8qC7y1L2cXMJWyQ/n/Vrn8B "Haskell – Try It Online")
## Explanation
Instead of using an approximation of the golden ratio to calculate the result meaning they are prone to errors as the size of the input rises. This answer does not. Instead it uses the formula provided on the OEIS that `a` is the unique sequence such that
```
∀n . b(n) = a(a(n))+1
```
where `b` is the ordered compliment.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 8 bytes
```
≥ℕ;φ×⌋₁?
```
[Try it online!](https://tio.run/##Dcq9CoJgFMbxWzm880E89k2Dl9EQDSWvKYiaH4iIQxai1NASXUHU2NLS2gV0Db43Ymd44A/PbxOtLSf3gq3RF5kANwbXh8SRIDKzUPVLVQfVPIQXZDISmmqeIg1DzpLxIk@cwLYhlrtU@pbURPdpy@596VV7V8fr/Fd/b@p8UtXe7PslIRgIA4QhwghhjDBBmCLMEEjn8U8MiAUxITbEiFgRM2Jn6Ks/ "Brachylog – Try It Online")
The predicate succeeds if the input is in the lower Wythoff sequence and fails if it is in the upper Wythoff sequence.
```
 ℕ          There exists a whole number
≥           less than or equal to
            the input such that
  ;φ×       multiplied by phi
     ⌋₁     and rounded down
       ?    it is the input.
```
If failure to terminate is a valid output method, the first byte can be omitted.
[Answer]
# [cQuents](https://github.com/stestoltz/cQuents), 5 bytes
```
?F$`g
```
[Try it online!](https://tio.run/##Sy4sTc0rKf7/395NJSH9/38jAA "cQuents – Try It Online")
## Explanation
```
?         output true if in sequence, false if not in sequence
          each term in the sequence equals:
 F        floor (
  $               index * 
   `g                     golden ratio
     )                                 ) implicit
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 8 bytes
```
t:17L*km
```
[**Try it online!**](https://tio.run/##y00syfn/v8TK0NxHKzv3/38jSwA "MATL – Try It Online")
### Explanation
```
t      % Implicit input. Duplicate
:      % Range
17L    % Push golden ratio (as a float)
*      % Multiply, element-wise
k      % Round down, element-wise
m      % Ismember. Implicit output
```
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 20 bytes
**Solution:**
```
x in_(.5*1+%5)*1+!x:
```
[Try it online!](https://tio.run/##y9bNz/7/v0IhMy9eQ89Uy1Bb1VQTSCpWWBlZ/v8PAA "K (oK) – Try It Online")
**Explanation:**
```
x in_(.5*1+%5)*1+!x: / the solution
                  x: / save input as x
                 !   / generate range 0..x
               1+    / add 1
              *      / multiply by
     (       )       / do this together
           %5        / square-root of 5
         1+          / add 1
      .5*            / multiply by .5
    _                / floor
x in                 / is input in this list?
```
[Answer]
# TI-BASIC (TI-84), 18 bytes
```
max(Ans=iPart((√(5)+1)/2randIntNoRep(1,Ans
```
Input is in `Ans`.  
Output is in `Ans` and is automatically printed.  
Prints `1` if input is in the lower sequence or `0` if it's in the upper sequence.
Coincidentally, this program will only run for \$0<N<1000\$ .
**Example:**
```
27
             27
prgmCDGFA
              1
44
             44
prgmCDGFA
              0
```
**Explanation:**
```
max(Ans=iPart((√(5)+1)/2randIntNoRep(1,Ans    ;full program, example input: 5
                        randIntNoRep(1,Ans    ;generate a list of random integers in [1,Ans]
                                               ; {1, 3, 2, 5, 4}
              (√(5)+1)/2                      ;calculate phi and then multiply the resulting
                                              ;list by phi
                                               ; {1.618 4.8541 3.2361 8.0902 6.4721}
        iPart(                                ;truncate
                                               ; {1 4 3 8 6}
    Ans=                                      ;compare the input to each element in the list
                                              ;and generate a list based off of the results
                                               ; {0 0 0 0 0}
max(                                          ;get the maximum element in the list and
                                              ;implicitly print it
```
---
**Note:** TI-BASIC is a tokenized language. Character count does *not* equal byte count.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 5 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
╒φ*i╧
```
[Try it online.](https://tio.run/##y00syUjPz0n7///R1Enn27QyH01d/v@/IZcxlwmXGZcFlyWXoSGXoRGXoQmXoYEBlxGXKZc5kMVlaMxlaAqUMAYA)
**Explanation:**
```
╒      # Push a list in the range [1, (implicit) input-integer]
 φ*    # Multiply each value by the golden ratio 1.618033988749895
   i   # Floor each by casting it to an integer
    ╧  # Check if the (implicit) input-integer is in this list
       # (after which the entire stack joined together is output implicitly as result)
```
]