Спочатку поговоримо про послідовності Бітті . Давши позитивне ірраціональне число r , ми можемо побудувати нескінченну послідовність, помноживши додатні цілі числа на r у порядку і взявши підсумок кожного результуючого обчислення. Наприклад,

Якщо r > 1, ми маємо особливу умову. Ми можемо утворити інше ірраціональне число s як s = r / ( r - 1). Потім це може створити власну послідовність Beatty, B _s . Акуратний трюк полягає в тому, що B _r і B _s є взаємодоповнюючими , це означає, що кожне додатне ціле число знаходиться в точно одній з двох послідовностей.

Якщо встановити r = ϕ, золоте співвідношення, то отримаємо s = r + 1 і дві спеціальні послідовності. Нижче послідовність Wythoff для г :

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

і верхню послідовність Вітофа для 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, виведіть одне з двох різних значень, що вказують, чи є вхід у нижній послідовності Вайтофа чи у верхній послідовності. Вихідні значення можуть бути -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т.д. підроблений 0-й запис 0та використовувати його для побудови другого елемента списку.

Haskell , 26 байт

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

Спробуйте в Інтернеті!

Без поплавків, необмежена точність. Дякую H.PWiz за два байти.

Пітон , 25 байт

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

Спробуйте в Інтернеті!

Використовується дуже проста умова:

nточно в нижній послідовності Уайтофа, якщо -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), так і є в нижній послідовності Вайтофа.

Інакше у нас 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) пропускається нижньою послідовністю Вітофа.

Це відповідає цьому коду:

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 байт завдяки гольфу Python від 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$

Мозок-Флак , 78 байт

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

Спробуйте в Інтернеті!

Виводить нічого для нижнього та 0верхнього. Перехід на більш розумну схему виводу коштуватиме 6 байт.

Python 2 , 39 33 32 байт

^{-6 байтів завдяки містеру Xcoder
-1 байт завдяки Zacharý}

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

Спробуйте в Інтернеті!

Повернення Falseдля нижнього та Trueверхнього

Джулія 0,6 , 16 байт

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

Спробуйте в Інтернеті!

Граючи з цифрами, я натрапив на цю властивість: floor (n / φ) == floor ((n + 1) / φ), якщо n у верхній послідовності Wythoff, і floor (n / φ) <floor ( (n + 1) / φ), якщо n знаходиться в нижній послідовності Вітофа. Я не зрозумів, як виникає ця властивість, але вона дає правильні результати принаймні до n = 100000 (і, можливо, далі).

Стара відповідь:

Джулія 0,6 , 31 байт

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

Спробуйте в Інтернеті!

Повернення trueдля нижньої та falseдля верхньої послідовності Вітофа.

Pyth , 8 байт

/sM*.n3S

Спробуйте тут!

Повертає 1 для нижнього та 0 для верхнього.

Мова Вольфрама (Mathematica) , 26 байт

#~Ceiling~GoldenRatio<#+1&

Спробуйте в Інтернеті!

Ціле число nзнаходиться в нижній iff послідовності Wythoff ceil(n/phi) - 1/phi < n/phi.

Це підтвердження 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знаходиться у нижній послідовності Вайтофа.

Необхідні; докази контрастності:

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це не в нижній послідовності Вайтофа.

Japt , 10 байт

Повертає значення true для нижнього та false для верхнього.

õ_*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;}

Порт @ Rod's відповідь Python 2 .
-1 байт завдяки @ Zacharý .

Спробуйте в Інтернеті.

Старі 77 76 байт відповідають:

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замовлений комплімент.

Брахілог , 8 байт

≥ℕ;φ×⌋₁?

Спробуйте в Інтернеті!

Присудок досягає успіху, якщо вхід знаходиться в нижній послідовності Уайтофа, і невдалий, якщо він знаходиться у верхній послідовності Вітофа.

 ℕ          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