İlk olarak, Beatty dizileri hakkında konuşalım . Pozitif mantık dışı sayısı göz önüne alındığında R , biz pozitif tamsayılar çarparak sonsuz bir dizi gerçekleştirebilmesi r amacıyla ve ortaya çıkan hesaplama söz alan. Örneğin,

Eğer r > 1, biz özel bir durum var. Başka bir akıl sayıda oluşturabilirler s olarak s = r / ( r - 1). Bu, daha sonra kendi Beatty dizisini oluşturabilir B _s . Düzgün bir hile yani B _r ve B _ler olan tamamlayıcı her bir pozitif tam sayı, iki dizinin arasında tam olarak biri olduğu anlamına.

Eğer r = ϕ, altın oranı ayarlarsak , s = r + 1 ve iki özel dizi elde ederiz . Düşük Wythoff sekansı için r :

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

ve üst Wythoff dizisi için s :

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

Bunlar sırasıyla OEIS üzerindeki A000201 ve A001950 dizileridir .

Meydan okuma

Pozitif bir giriş tamsayısı verildiğinde 1 <= n <= 1000, girdinin alt Wythoff sekansında mı yoksa üst sekansında mı olduğunu gösteren iki ayrı değerden birini çıktılayın . Çıkış değerleri -1ve 1, trueve false, upperve lowervb. Olabilir.

Gönderdiğiniz algoritmanın teorik olarak tüm girdiler için çalışması gerekir, ancak uygulamada yalnızca ilk 1000 giriş numarasıyla çalışması gerekir.

G / Ç ve Kurallar

• Giriş ve çıkış herhangi bir uygun yöntemle verilebilir .
• Giriş ve çıktının, dilinizin yerel sayı türüne uygun olduğu varsayılabilir.
• Tam bir program veya bir işlev kabul edilebilir. Bir işlev varsa, çıktıyı yazdırmak yerine döndürebilirsiniz.
• Standart boşluklar yasaktır.
• Bu kod golfüdür, bu nedenle her zamanki golf kuralları geçerlidir ve en kısa kod (bayt cinsinden) kazanır.

JavaScript (ES6), 50 35 bayt

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>

1Alt ve 0üst için çıkışlar . Açıklama: boolean değerleri kısmi listeleri kullanılarak inşa edilebilir Fibonacci benzeri özdeşliğe verilen iki listeleri, ile başlayarak 1ve 10, takip eden her liste ile sonuçlanan, önceki iki birleşimidir 101, 10110, 10110101biraz golfier için var Bu durumda, vs. sahte bir 0. giriş 0ve listenin ikinci elemanını oluşturmak için kullanın.

Haskell , 26 bayt

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

Çevrimiçi deneyin!

Şamandıra yok, sınırsız hassasiyet. İki baytlık H.PWiz için teşekkürler.

Python , 25 bayt

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

Çevrimiçi deneyin!

Çok basit koşulu kullanır:

ntam olarak eğer alt Wythoff sırasında -n%phi<1.

Modyt sonucunun -nPython'un modulo ile eşleştiği şekilde negatif olmasına rağmen pozitif olduğunu unutmayın .

İspat:a = -n%phi Aralıkta bulunan izin verin 0 <= a < phi. Bazı pozitif tamsayıda olduğu gibi -nmodüloyu bölebiliriz . Bunu yeniden düzenleyin .phi-n = -k*phi + akn+a = k*phi

Eğer a<1öyleyse n = floor(n+a) = floor(k*phi), vb. Alt Wythoff sırasındaysa.

Aksi takdirde, biz var 1 <= a < phibu yüzden

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

böylece ve narasındaki boşluğa düşer ve alt Wythoff dizisi tarafından kaçırılır.floor((k-1)*phi)floor(k*phi)

Bu, şu koda karşılık gelir:

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

Çevrimiçi deneyin!

İki katına çıkararak bir bayt kurtarıyoruz -(n*2)%(phi*2)<2.

05AB1E , 9 bayt

L5t>;*óså

Çevrimiçi deneyin!

0 üst, 1 alt anlamına gelir. İlk 100'ü deneyin : Çevrimiçi deneyin!

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

Ham Komut Dökümü:

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

Jöle , 5 bayt

N%ØpỊ

Çevrimiçi deneyin!

Xnor'ın Python golf sayesinde 1 bayt tasarruf etti .

Jöle , 6 bayt

×€ØpḞċ

Çevrimiçi deneyin!

Alt için 1 , üst için 0 döndürür .

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

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

Çevrimiçi deneyin!

Alt ve 0üst için hiçbir şey çıktılamaz. Daha mantıklı bir çıktı şemasına geçmek 6 bayta mal olacaktır.

Python 2 , 39 33 32 bayt

^{Bay Xcoder sayesinde -6 bayt
-1 Zacharý sayesinde -1 bayt}

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

Çevrimiçi deneyin!

FalseAlt ve Trueüst için döndürür

Julia 0.6 , 16 bayt

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

Çevrimiçi deneyin!

Sayılarla oynarken, bu özelliğe rastladım: floor (n / φ) == floor ((n + 1) / φ) n üst Wythoff sırasında ise ve floor (n / φ) <floor ( (n + 1) / φ) n, alt Wythoff sekansındaysa. Bu özellik nasıl ortaya çıktığını anlayamadım , ama en azından n = 100000 (ve muhtemelen ötesinde) kadar doğru sonuçları verir.

Eski cevap:

Julia 0.6 , 31 bayt

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

Çevrimiçi deneyin!

trueAlt ve falseüst Wythoff dizisi için döndürür .

Pyth , 8 bayt

/sM*.n3S

Burada deneyin!

Alt için 1 , üst için 0 döndürür .

Wolfram Dili (Mathematica) , 26 bayt

#~Ceiling~GoldenRatio<#+1&

Çevrimiçi deneyin!

Bir tam sayı nAlt Wythoff Sekansı iff değerindeceil(n/phi) - 1/phi < n/phi .

Kanıtla ceil(n/phi) - 1/phi < n/phi ...

Yeterli:

1. Bırakın ceil(n/phi) - 1/phi < n/phi.

2. Sonra ceil(n/phi) * phi < n + 1.

3. Not n == n/phi * phi <= ceil(n/phi) * phi.

4. Dolayısıyla n <= ceil(n/phi) * phi < n + 1,.

5. Yana nve ceil(n/phi)tamsayılardır, yerde ve devlet tanımı çağırmak floor(ceil(n/phi) * phi) == nve nalt Wythoff dizisi bulunmaktadır.

Gerekli; contrapositive tarafından kanıt:

1. Bırakın ceil(n/phi) - 1/phi >= n/phi.

2. Sonra ceil(n/phi) * phi >= n + 1.

3. Not n + phi > (n/phi + 1) * phi > ceil(n/phi) * phi

4. Dolayısıyla n > (ceil(n/phi) - 1) * phi.

5. Çünkü (ceil(n/phi) - 1) * phi < n < n + 1 <= ceil(n/phi) * phi, nalt Wythoff sırasında değil.

Japt , 10 bayt

İade gerçek alt ve için YANLıŞ üst için.

õ_*MQ fÃøU

Çevrimiçi deneyin!

Açıklama:

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

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

Bağlantı noktası @ Rod's Python 2 cevap . @ Zacharý
sayesinde -1 bayt .

Çevrimiçi deneyin.

Eski 77 76 bayt cevap:

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

Geçen hafta kendime tavsiye ettiğim bir şey için @ovs'a -1 bayt teşekkürler .. xD

İade 1alt için; 0üst için.

Çevrimiçi deneyin.

Açıklama:

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*Phialarak hesaplanır (sqrt(5)+1)/2 * ive daha sonra ondalık sayıyı kısaltmak için bir tamsayıya dökerek katlarız.

Haskell , 153 139 126 79 bayt

Sınırsız Hassasiyet!

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

Çevrimiçi deneyin!

açıklama

Sonucu hesaplamak için altın oranın yaklaşık olarak kullanılması yerine, girdinin boyutu arttıkça hatalara eğilimli oldukları anlamına gelir. Bu cevap yok. Bunun yerine, OEIS'te sağlanan abenzersiz bir dizi olan formülü kullanır.

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

bemir iltifat nerede .

Brachylog , 8 bayt

≥ℕ;φ×⌋₁?

Çevrimiçi deneyin!

Girdi, alt Wythoff sırasındaysa başarılı olur ve üst Wythoff sırasındaysa başarısız olur.

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

Sonlandırma başarısızlığı geçerli bir çıktı yöntemiyse, ilk bayt atlanabilir.

MATL , 8 bayt

t:17L*km

Çevrimiçi deneyin!

açıklama

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 bayt

Çözüm:

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

Çevrimiçi deneyin!

Açıklama:

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 bayt

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

Giriş var Ans.
Çıktı içeri Ansve otomatik olarak yazdırılıyor. Giriş alt sıradaysa veya üst sıradaysa
yazdırır .10

Tesadüfen, bu program sadece $0<N<1000$ .

Örnek:

27
             27
prgmCDGFA
              1
44
             44
prgmCDGFA
              0

Açıklama:

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

Not: TI-BASIC tokenize bir dildir. Karakter sayısı bayt sayısına eşit değil .

cQuents , 5 bayt

?F$`g

Çevrimiçi deneyin!

açıklama

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

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