首先，让我们谈谈Beatty序列。给定一个无理数正数r，我们可以通过将正整数乘以r并乘以每个结果计算的底数来构造无限序列。例如，

如果r > 1，则有特殊条件。我们可以形成另一个无理数s，即s = r /（r -1）。然后，这可以生成自己的Beatty序列B _s。巧妙的技巧是B _r和B _s是互补的，这意味着每个正整数都恰好在两个序列之一中。

如果我们将黄金比例设置为r = then，则得到s = r + 1和两个特殊序列。该低Wythoff序列为[R ：

1, 3, 4, 6, 8, 9, 11, 12, 14, 16, 17, 19, 21, 22, 24, 25, 27, 29, ... 

和上部Wythoff序列为小号：

2, 5, 7, 10, 13, 15, 18, 20, 23, 26, 28, 31, 34, 36, 39, 41, 44, 47, ... 

这些分别是OEIS 上的序列A000201和A001950。

挑战

给定正输入整数1 <= n <= 1000，输出两个不同值之一，指示输入是处于较低的Wythoff序列还是较高的序列。输出值可以是-1和1，true和false，upper和lower，等等。

尽管理论上您提交的算法必须适用于所有输入，但实际上，它只必须使用前1000个输入数字。

I / O和规则

• 输入和输出可以通过任何方便的方法给出。
• 可以假定输入和输出适合您语言的本机数字类型。
• 完整的程序或功能都是可以接受的。如果是函数，则可以返回输出而不是打印输出。
• 禁止出现标准漏洞。
• 这是代码高尔夫球，因此所有常用的高尔夫规则都适用，并且最短的代码（以字节为单位）获胜。

JavaScript（ES6），50 35字节

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>

1较低和0较高的输出。说明：布尔值的部分列表可以使用来构建一个斐波那契状的身份：给定两个列表，开始1和10，每个后续名单是前两者的串联，导致101，10110，10110101等等。在这种情况下，它稍微golfier有伪造的第0个条目，0并使用该条目构造列表的第二个元素。

Haskell，26个字节

(l!!)
l=0:do x<-l;[1-x..1]

在线尝试！

无浮球，无限精度。感谢H.PWiz提供两个字节。

Python，25个字节

lambda n:-n*2%(5**.5+1)<2

在线尝试！

使用非常简单的条件：

n恰好在时处于较低的Wythoff序列中-n%phi<1。

请注意，取模结果即使-n为负也为正，与Python的取模方式相匹配。

证明：让它a = -n%phi在范围内0 <= a < phi。我们可以分割 -n模phi为-n = -k*phi + a一些正整数k。将其重新排列为n+a = k*phi。

如果是a<1，则n = floor(n+a) = floor(k*phi)，等等在较低的Wythoff序列中。

否则，我们有1 <= a < phi这样

n+1 = floor(n+a) = floor(k*phi)
n > n+a-phi = k*phi - phi = (k-1)*phi

因此n落在 和之间的间隙中，floor((k-1)*phi)而floor(k*phi)较低的Wythoff序列则错过了。

这对应于以下代码：

lambda n:-n%(5**.5/2+.5)<1

在线尝试！

我们通过加倍到来节省一个字节-(n*2)%(phi*2)<2。

05AB1E，9个字节

L5t>;*óså

在线尝试！

0表示较高，1表示较低。尝试前100个：在线尝试！

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

原始命令转储：

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

果冻，5个字节

N%ØpỊ

在线尝试！

多亏了xnor的Python golf，节省了1个字节。

果冻，6个字节

×€ØpḞċ

在线尝试！

对于低位返回1，对于高位返回0。

×€Ø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.

检查 $(0,\:N]\cap \mathbb{Z}$ 绝对足够，因为 $\varphi > 1$ 和 $N > 0$ 因此 $0 < N < N\varphi$。

Brain-Flak，78个字节

([{}]()){<>{}((([()]))){{<>({}())}{}(([({})]({}{})))}<>([{}]{}<>)}<>({}()){{}}

在线尝试！

下限和0上限不输出任何内容。更改为更合理的输出方案将花费6个字节。

Python 2中，39个 33 32字节

^{得益于Xcoder先生，-6个字节得益于Zacharý得
-1个字节}

lambda n,r=.5+5**.5/2:-~n//r<n/r

在线尝试！

False较低和True较高的回报

Julia 0.6, 16 bytes

n->n÷φ<-~n÷φ

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, 31 bytes

n->n∈[floor(i*φ)for i∈1:n]

Try it online!

Returns true for lower and false for upper Wythoff sequence.

Pyth, 8 bytes

/sM*.n3S

Try it here!

Returns 1 for lower and 0 for upper.

Wolfram Language (Mathematica), 26 bytes

#~Ceiling~GoldenRatio<#+1&

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.

Japt, 10 bytes

Returns true for lower and false for upper.

õ_*MQ fÃøU

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

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.
-1 byte thanks to @Zacharý.

Try it online.

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

Returns 1 for lower; 0 for upper.

Try it online.

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.

Haskell, 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!

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.

Brachylog, 8 bytes

≥ℕ;φ×⌋₁?

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.

MATL, 8 bytes

t:17L*km

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

K (oK), 20 bytes

Solution:

x in_(.5*1+%5)*1+!x:

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?

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.

cQuents, 5 bytes

?F$`g

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