อันดับแรกให้พูดคุยเกี่ยวกับลำดับเบ็ตตี้ ด้วยจำนวนอตรรกยะบวกrเราสามารถสร้างลำดับอนันต์โดยการคูณจำนวนเต็มบวกกับrตามลำดับและนำพื้นของการคำนวณผลลัพธ์แต่ละอัน ตัวอย่างเช่น,

ถ้าr > 1 เรามีเงื่อนไขพิเศษ เราสามารถสร้างจำนวนอตรรกยะจำนวนsเป็นs = r / ( r - 1) แล้วนี้สามารถสร้างลำดับเบ็ตตี้ของตัวเองB s เคล็ดลับคือการที่เรียบร้อยB _RและB _sเป็นที่เกื้อกูลซึ่งหมายความว่าทุกจำนวนเต็มบวกที่อยู่ในว่าหนึ่งในสองลำดับ

ถ้าเราตั้งค่าr = ϕ อัตราส่วนทองคำเราจะได้s = r + 1 และสองลำดับพิเศษ ต่ำลำดับ WythoffสำหรับR :

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

และลำดับ Wythoffสำหรับs :

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

นี่คือลำดับA000201และA001950บน OEIS ตามลำดับ

ความท้าทาย

รับค่าอินพุตจำนวนเต็มบวก1 <= n <= 1000เอาต์พุตหนึ่งในสองค่าที่แตกต่างระบุว่าอินพุตอยู่ในลำดับ Wythoff ที่ต่ำกว่าหรือลำดับบน ค่าเอาต์พุตอาจเป็น-1และ1, trueและfalse, upperและlower, เป็นต้น

แม้ว่าอัลกอริทึมที่คุณส่งจะต้องทำงานในทางทฤษฎีสำหรับอินพุตทั้งหมด แต่ในทางปฏิบัติมันจะต้องทำงานกับอินพุต 1,000 หมายเลขแรกเท่านั้น

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บน คำอธิบาย: รายชื่อบางส่วนของค่าบูลีนจะถูกสร้างขึ้นโดยใช้ Fibonacci เหมือนตัวตน: รับสองรายการเริ่มต้นด้วย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เป็นลบก็ตาม

พิสูจน์: Let ซึ่งอยู่ในช่วงa = -n%phi 0 <= a < phiเราสามารถแบ่ง -nโมดูโลphiเป็นสำหรับบางจำนวนเต็มบวก-n = -k*phi + a จัดเรียงที่kn+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Ị

ลองออนไลน์!

ที่บันทึกไว้ 1 ขอบคุณไบต์XNOR กอล์ฟหลาม

เยลลี่ 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 ไบต์

^{-6 ไบต์ขอบคุณ Mr. Xcoder
-1 ไบต์ขอบคุณZacharý}

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

ลองออนไลน์!

ผลตอบแทนFalseสำหรับต่ำและTrueสำหรับบน

Julia 0.6 , 16 ไบต์

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

ลองออนไลน์!

ขณะที่กำลังเล่นกับตัวเลขฉันพบคุณสมบัตินี้: floor (n / φ) == floor ((n + 1) / φ) ถ้า n อยู่ในลำดับ Wythoff ตอนบนและ floor (n / φ) <floor ( (n + 1) / φ) ถ้า n อยู่ในลำดับ Wythoff ที่ต่ำกว่า ฉันไม่ได้หาวิธีการที่คุณสมบัตินี้มาถึง แต่มันให้ผลลัพธ์ที่ถูกต้องอย่างน้อย n = 100000 (และอาจเกิน)

คำตอบเก่า:

Julia 0.6 , 31 bytes

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

ลองออนไลน์!

ผลตอบแทนที่trueต่ำกว่าและfalseสำหรับลำดับ Wythoff ส่วนบน

Pyth , 8 ไบต์

/sM*.n3S

ลองที่นี่!

ส่งคืน1สำหรับค่าต่ำและ0สำหรับส่วนบน

ภาษา Wolfram (Mathematica)ขนาด 26 ไบต์

#~Ceiling~GoldenRatio<#+1&

ลองออนไลน์!

จำนวนเต็มnอยู่ในลำดับที่ต่ำกว่าของ Wythoff iffceil(n/phi) - 1/phi < n/phiIFF

พิสูจน์ว่าceil(n/phi) - 1/phi < n/phi...

พอเพียง:

1. ceil(n/phi) - 1/phi < n/phiให้

2. จากนั้นceil(n/phi) * phi < n + 1.

3. n == n/phi * phi <= ceil(n/phi) * phiหมายเหตุ

4. ดังนั้น, n <= ceil(n/phi) * phi < n + 1.

5. ตั้งแต่nและceil(n/phi)เป็นจำนวนเต็มเราเรียกคำจำกัดความของพื้นและรัฐfloor(ceil(n/phi) * phi) == nและnอยู่ในลำดับ Wythoff ที่ต่ำกว่า

จำเป็น พิสูจน์โดย contrapositive:

1. ceil(n/phi) - 1/phi >= n/phiให้

2. จากนั้นceil(n/phi) * phi >= n + 1.

3. บันทึก n + phi > (n/phi + 1) * phi > ceil(n/phi) * phi

4. n > (ceil(n/phi) - 1) * phiด้วยเหตุนี้

5. ตั้งแต่(ceil(n/phi) - 1) * phi < n < n + 1 <= ceil(n/phi) * phi, nไม่ได้อยู่ในลำดับที่ต่ำกว่า Wythoff

Japt , 10 ไบต์

ผลตอบแทนจริงสำหรับต่ำและเท็จสำหรับบน

õ_*MQ fÃøU

ลองออนไลน์!

คำอธิบาย:

õ_*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 ไบต์

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

ท่าเรือ@ ก้านของงูหลาม 2 คำตอบ
ขอบคุณ -1 ไบต์@ Zachary

ลองออนไลน์

77 77ไบต์เก่าตอบ:

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

-1 ไบต์ขอบคุณ@ovs 'สำหรับสิ่งที่ฉันแนะนำตัวเองเมื่อสัปดาห์ที่แล้ว .. xD

ผลตอบแทนที่1ต่ำกว่า; 0สำหรับบน

ลองออนไลน์

คำอธิบาย:

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คำนวณได้จากการรับ(sqrt(5)+1)/2 * iและจากนั้นเรานำมันมาหารด้วยการชี้ไปที่จำนวนเต็มเพื่อตัดทศนิยม

Haskell , 153 139 126 79 ไบต์

ความแม่นยำไม่ จำกัด !

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

ลองออนไลน์!

คำอธิบาย

แทนที่จะใช้การประมาณอัตราส่วนทองคำในการคำนวณผลลัพธ์หมายถึงพวกเขามีแนวโน้มที่จะเกิดข้อผิดพลาดเมื่อขนาดของอินพุตเพิ่มขึ้น คำตอบนี้ไม่ได้ แต่จะใช้สูตรที่มีให้ใน OEIS ซึ่งaเป็นลำดับเฉพาะเช่นนั้น

∀n . b(n) = a(a(n))+1

ที่bเป็นคำชมเชยที่ได้รับคำสั่ง

Brachylogขนาด 8 ไบต์

≥ℕ;φ×⌋₁?

ลองออนไลน์!

เพรดิเคตสำเร็จหากอินพุตอยู่ในลำดับ Wythoff ที่ต่ำกว่าและล้มเหลวหากอยู่ในลำดับ Wythoff ตอนบน

 ℕ          There exists a whole number
≥           less than or equal to
            the input such that
  ;φ×       multiplied by phi
     ⌋₁     and rounded down
       ?    it is the input.

หากความล้มเหลวในการยกเลิกเป็นวิธีการส่งออกที่ถูกต้องไบต์แรกสามารถละเว้น

MATL , 8 ไบต์

t:17L*km

ลองออนไลน์!

คำอธิบาย

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 ไบต์

วิธีการแก้:

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

ลองออนไลน์!

คำอธิบาย:

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 ไบต์

max(Ans=iPart((√(5)+1)/2randIntNoRep(1,Ans

Ansการป้อนข้อมูลที่อยู่ใน
เอาต์พุตอยู่ในAnsและพิมพ์โดยอัตโนมัติ
พิมพ์1ถ้าอินพุตอยู่ในลำดับที่ต่ำกว่าหรือ0หากอยู่ในลำดับบน

โปรแกรมนี้จะทำงานโดยบังเอิญเท่านั้น $0<N<1000$ .

ตัวอย่าง:

27
             27
prgmCDGFA
              1
44
             44
prgmCDGFA
              0

คำอธิบาย:

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

หมายเหตุ: TI-BASIC เป็นภาษาโทเค็น จำนวนตัวอักษรไม่เท่ากับจำนวนไบต์

cQuents , 5 ไบต์

?F$`g

ลองออนไลน์!

คำอธิบาย

?         output true if in sequence, false if not in sequence
          each term in the sequence equals:

 F        floor (
  $               index * 
   `g                     golden ratio
     )                                 ) implicit