Đầu tiên, hãy nói về chuỗi Beatty . Cho một số vô tỷ r dương , chúng ta có thể xây dựng một chuỗi vô hạn bằng cách nhân các số nguyên dương với r theo thứ tự và lấy sàn của mỗi phép tính kết quả. Ví dụ,

Nếu r > 1, chúng ta có một điều kiện đặc biệt. Chúng ta có thể tạo thành một số vô tỷ khác s là s = r / ( r - 1). Điều này sau đó có thể tạo ra chuỗi Beatty của riêng nó, B _s . Thủ thuật gọn gàng là B _r và B _s là bổ sung cho nhau , nghĩa là mọi số nguyên dương nằm trong chính xác một trong hai chuỗi.

Nếu chúng ta đặt r = ϕ, tỷ lệ vàng, thì chúng ta sẽ có s = r + 1 và hai chuỗi đặc biệt. Các hạ chuỗi Wythoff cho r :

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

và chuỗi Wythoff trên cho s :

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

Đây là các chuỗi A000201 và A001950 trên OEIS, tương ứng.

Các thách thức

Cho một số nguyên đầu vào dương 1 <= n <= 1000, xuất một trong hai giá trị riêng biệt cho biết liệu đầu vào nằm trong chuỗi Wythoff thấp hơn hay chuỗi trên . Các giá trị đầu ra có thể là -1và 1, truevà false, uppervà lowervv

Mặc dù thuật toán đã gửi của bạn về mặt lý thuyết phải hoạt động cho tất cả các đầu vào, nhưng trên thực tế, nó chỉ phải hoạt động với 1000 số đầu vào đầu tiên.

I / O và Nội quy

• Đầu vào và đầu ra có thể được cung cấp bởi bất kỳ phương pháp thuận tiện .
• Đầu vào và đầu ra có thể được coi là phù hợp với loại số gốc của ngôn ngữ của bạn.
• Một chương trình đầy đủ hoặc một chức năng được chấp nhận. Nếu một chức năng, bạn có thể trả lại đầu ra thay vì in nó.
• Sơ hở tiêu chuẩn bị cấm.
• Đây là môn đánh gôn để áp dụng tất cả các quy tắc chơi golf thông thường và mã ngắn nhất (tính bằng byte) sẽ thắng.

JavaScript (ES6), 50 35 byte

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>

Đầu ra 1cho thấp hơn và 0cho trên. Giải thích: Có thể xây dựng danh sách một phần các giá trị boolean bằng cách sử dụng danh tính giống như Fibonacci: đưa ra hai danh sách, bắt đầu bằng1 và 10, mỗi danh sách tiếp theo là nối của hai trước, kết quả là 101, 10110, 10110101vv Trong trường hợp này nó hơi golfier có một mục nhập giả thứ 0 của 0và sử dụng mục đó để xây dựng phần tử thứ hai của danh sách.

Haskell , 26 byte

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

Hãy thử trực tuyến!

Không phao, độ chính xác không giới hạn. Cảm ơn H.PWiz cho hai byte.

Python , 25 byte

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

Hãy thử trực tuyến!

Sử dụng điều kiện rất đơn giản:

nlà trong chuỗi Wythoff thấp hơn chính xác nếu -n%phi<1.

Lưu ý rằng kết quả modulo là dương mặc dù -nlà âm, phù hợp với cách Python thực hiện modulo.

Chứng minh: Hãy a = -n%phi, nằm trong phạm vi 0 <= a < phi. Chúng ta có thể chia -nmodulo phinhư -n = -k*phi + ađối với một số nguyên dương k. Sắp xếp lại đển+a = k*phi .

Nếu a<1, sau đón = floor(n+a) = floor(k*phi) , và như vậy là trong chuỗi Wythoff thấp hơn.

Nếu không, chúng ta có 1 <= a < phinhư vậy

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

do đó nrơi vào khoảng cách giữa floor((k-1)*phi)và floor(k*phi) và bị bỏ lỡ bởi chuỗi Wythoff thấp hơn.

Điều này tương ứng với mã này:

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

Hãy thử trực tuyến!

Chúng tôi lưu một byte bằng cách nhân đôi lên -(n*2)%(phi*2)<2.

05AB1E , 9 byte

L5t>;*óså

Hãy thử trực tuyến!

0 có nghĩa là trên, 1 có nghĩa là thấp hơn. Hãy thử 100 đầu tiên: Hãy thử trực tuyến!

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

Dump lệnh thô:

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

Thạch , 5 byte

N%ØpỊ

Hãy thử trực tuyến!

Đã lưu 1 byte nhờ vào gôn Python của xnor .

Thạch , 6 byte

×€ØpḞċ

Hãy thử trực tuyến!

Trả về 1 cho thấp hơn và 0 cho trên.

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

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

Hãy thử trực tuyến!

Đầu ra không có gì cho thấp hơn và 0cho trên. Thay đổi thành sơ đồ đầu ra hợp lý hơn sẽ tốn 6 byte.

Python 2 , 39 33 32 byte

^{-6 byte nhờ ông Xcoder
-1 byte nhờ vào Zacharý}

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

Hãy thử trực tuyến!

Trả về Falsecho thấp hơn và Truecho trên

Julia 0,6 , 16 byte

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

Hãy thử trực tuyến!

Trong khi chơi xung quanh với các con số, tôi đã bắt gặp thuộc tính này: floor (n /) == floor ((n + 1) / φ) nếu n nằm trong dãy Wythoff trên và sàn (n / φ) <floor ( (n + 1) / φ) nếu n nằm trong chuỗi Wythoff thấp hơn. Tôi chưa tìm ra cách thức tài sản này xuất hiện, nhưng nó cho kết quả chính xác ít nhất lên tới n = 100000 (và có thể hơn thế nữa).

Câu trả lời cũ:

Julia 0,6 , 31 byte

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

Hãy thử trực tuyến!

Trả về truecho falsechuỗi thấp hơn và cho chuỗi Wythoff trên.

Bình thường , 8 byte

/sM*.n3S

Hãy thử nó ở đây!

Trả về 1 cho thấp hơn và 0 cho trên.

Ngôn ngữ Wolfram (Mathicala) , 26 byte

#~Ceiling~GoldenRatio<#+1&

Hãy thử trực tuyến!

Một số nguyên nnằm trong chuỗi thứ tự Wythoff thấp hơn ceil(n/phi) - 1/phi < n/phi.

Bằng chứng ceil(n/phi) - 1/phi < n/philà ...

Đủ:

1. Hãy để ceil(n/phi) - 1/phi < n/phi.

2. Sau đó , ceil(n/phi) * phi < n + 1.

3. Lưu ý n == n/phi * phi <= ceil(n/phi) * phi.

4. Do đó , n <= ceil(n/phi) * phi < n + 1.

5. Vì nvà ceil(n/phi)là số nguyên, chúng tôi gọi định nghĩa về sàn và trạng thái floor(ceil(n/phi) * phi) == n, và nnằm trong chuỗi Wythoff thấp hơn.

Cần thiết; bằng chứng bởi contrapositive:

1. Hãy để ceil(n/phi) - 1/phi >= n/phi.

2. Sau đó , ceil(n/phi) * phi >= n + 1.

3. chú thích n + phi > (n/phi + 1) * phi > ceil(n/phi) * phi

4. Do đó n > (ceil(n/phi) - 1) * phi.

5. Vì (ceil(n/phi) - 1) * phi < n < n + 1 <= ceil(n/phi) * phi, nkhông nằm trong chuỗi Wythoff thấp hơn.

Japt , 10 byte

Trả về true cho dưới và false cho trên.

õ_*MQ fÃøU

Hãy thử trực tuyến!

Giải trình:

õ_*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 byte

n->{var r=Math.sqrt(5)/2+.5;return(int)(-~n/r)<n/r;}

Cổng câu trả lời Python 2 của @ Rod .
-1 byte nhờ @ Zacharý .

Hãy thử trực tuyến.

Câu trả lời cũ 77 76 byte:

n->{for(int i=0;i++<n;)if(n==(int)((Math.sqrt(5)+1)/2*i))return 1;return 0;}

-1 byte cảm ơn @ovs 'vì điều gì đó tôi đã tự đề xuất vào tuần trước .. xD

Trả về 1cho thấp hơn; 0cho thượng.

Hãy thử trực tuyến.

Giải trình:

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được tính bằng cách lấy (sqrt(5)+1)/2 * i, và sau đó chúng tôi xếp nó bằng cách chuyển nó thành một số nguyên để cắt bớt số thập phân.

Haskell , 153 139 126 79 byte

Chính xác không giới hạn!

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

Hãy thử trực tuyến!

Giải trình

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