먼저 비티 시퀀스 에 대해 이야기 해 봅시다 . 양의 비이성적 인 수 r이 주어지면 양의 정수에 r 을 곱하고 각 결과 계산의 바닥을 취하여 무한 시퀀스를 구성 할 수 있습니다 . 예를 들어

경우 R > 1, 우리는 특별한 조건을 가지고있다. s = r / ( r -1) 과 같은 다른 비이성적 인 숫자 s 를 형성 할 수 있습니다 . 이는 자신의 비티 시퀀스를 생성 할 수 있습니다 B _들 . 깔끔한 트릭 즉 B의 _R 과 B _들 있는 상보 모든 양의 정수는 두 서열의 정확히 한 것을 의미한다.

우리가 r = ϕ, 황금비를 설정 하면 s = r + 1과 두 개의 특별한 시퀀스를 얻습니다 . 하부 Wythoff 시퀀스 에 대한 연구 :

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

그리고 s에 대한 상단 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 및 규칙

• 입력 및 출력은 편리한 방법 으로 제공 할 수 있습니다 .
• 입력 및 출력은 해당 언어의 고유 번호 유형에 맞는 것으로 가정 할 수 있습니다.
• 전체 프로그램 또는 기능이 허용됩니다. 함수 인 경우 출력하지 않고 출력을 반환 할 수 있습니다.
• 표준 허점 은 금지되어 있습니다.
• 이것은 코드 골프 이므로 모든 일반적인 골프 규칙이 적용되며 가장 짧은 코드 (바이트)가 이깁니다.

자바 스크립트 (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목록의 두 번째 요소를 구성하는 데 사용합니다.

하스켈 , 26 바이트

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

온라인으로 사용해보십시오!

수레 없음, 무제한 정밀도. 2 바이트의 H.PWiz에 감사드립니다.

파이썬 , 25 바이트

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

온라인으로 사용해보십시오!

매우 간단한 조건을 사용합니다.

n정확히 경우 낮은 Wythoff 순서입니다 -n%phi<1.

-n파이썬이 모듈로를 수행하는 방식과 일치 하여 모듈러스 결과는 음수 이지만 긍정적 입니다.

증명 :a = -n%phi 범위 내에있는 Let 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 바이트가 필요합니다.

파이썬 2 , 39 33 32 바이트

^{Mr. Xcoder 덕분에 -6 바이트 Zacharý
덕분에 -1 바이트}

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

온라인으로 사용해보십시오!

False하한 및 True상한에 대한 반환

줄리아 0.6 , 16 바이트

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

온라인으로 사용해보십시오!

숫자를 가지고 놀면서, 나는 n이 Wythoff의 상위 시퀀스에 있으면 floor (n / φ) == floor ((n + 1) / φ)와 floor (n / φ) <floor ( n이 Wythoff 시퀀스의 하위에있는 경우 (n + 1) / φ)입니다. 나는 이 속성이 어떻게 나오는지 알지 못했지만 적어도 n = 100000 (그리고 아마도 그 이상)까지 올바른 결과를 제공합니다.

오래된 답변 :

Julia 0.6 , 31 바이트

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

온라인으로 사용해보십시오!

true하위 및 false상위 Wythoff 시퀀스에 대해 리턴 합니다 .

Pyth , 8 바이트

/sM*.n3S

여기 사용해보십시오!

하한은 1 , 상한은 0 을 반환합니다 .

Wolfram Language (Mathematica) , 26 바이트

#~Ceiling~GoldenRatio<#+1&

온라인으로 사용해보십시오!

정수 n는 Wythoff Sequence iff 하단에 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하부 Wythoff 시퀀스이다.

필요한; 반대되는 증거 :

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 바이트

하한에 대해서는 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

자바 10, 77 53 52 바이트

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

@Rod의 Python 2 답변 포트 . @ Zacharý
덕분에 -1 바이트 .

온라인으로 사용해보십시오.

이전 77 76 바이트 답변 :

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

지난주에 내가 추천 한 것에 대해 @ovs 덕분에 -1 바이트 .. 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다음 정수로 캐스팅하여 소수점을 자릅니다.

하스켈 , 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