Primero, hablemos de las secuencias de Beatty . Dado un número irracional positivo r , podemos construir una secuencia infinita multiplicando los enteros positivos a r en orden y tomando el piso de cada cálculo resultante. Por ejemplo,

Si r > 1, tenemos una condición especial. Podemos formar otro número irracional s como s = r / ( r - 1). Esto puede generar su propia secuencia Beatty, B _s . El truco es que B _r y B _s son complementarios , lo que significa que cada entero positivo está exactamente en una de las dos secuencias.

Si establecemos r = ϕ, la proporción áurea, obtenemos s = r + 1 y dos secuencias especiales. La secuencia inferior de Wythoff para r :

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

y la secuencia superior de Wythoff para s :

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

Estas son las secuencias A000201 y A001950 en OEIS, respectivamente.

El reto

Dado un entero de entrada positivo 1 <= n <= 1000, genera uno de dos valores distintos que indican si la entrada está en la secuencia de Wythoff inferior o en la secuencia superior . Los valores de salida pueden ser -1y 1, truey false, uppery lower, etc.

Aunque su algoritmo enviado debe funcionar teóricamente para todas las entradas, en la práctica solo tiene que funcionar con los primeros 1000 números de entrada.

E / S y reglas

• La entrada y salida se pueden dar por cualquier método conveniente .
• Se puede suponer que la entrada y la salida encajan en el tipo de número nativo de su idioma.
• Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
• Las lagunas estándar están prohibidas.
• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

JavaScript (ES6), 50 35 bytes

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>

Salidas 1para inferior y 0para superior. Explicación: listas parciales de valores booleanos se puede construir usando un Fibonacci-como identidad: dado dos listas, comenzando con 1y 10, cada lista posterior es la concatenación de las dos anteriores, lo que resulta en 101, 10110, 10110101etc. En este caso es ligeramente Golfier tener una entrada 0 falsa y úsela 0para construir el segundo elemento de la lista.

Haskell , 26 bytes

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

Pruébalo en línea!

Sin flotadores, precisión ilimitada. Gracias por H.PWiz por dos bytes.

Python , 25 bytes

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

Pruébalo en línea!

Utiliza la condición muy simple:

nestá en la secuencia inferior de Wythoff exactamente si -n%phi<1.

Tenga en cuenta que el resultado del módulo es positivo aunque -nsea ​​negativo, y coincide con la forma en que Python hace el módulo.

Prueba: Let a = -n%phi, que se encuentra en el rango 0 <= a < phi. Podemos dividir el -nmódulo phicomo -n = -k*phi + apara un número entero positivo k. Reorganizar eso a n+a = k*phi.

Si a<1, entonces n = floor(n+a) = floor(k*phi), y así está en la secuencia inferior de Wythoff.

De lo contrario, tenemos 1 <= a < phitan

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

entonces ncae en la brecha entre floor((k-1)*phi)y floor(k*phi) y se pierde por la secuencia inferior de Wythoff.

Esto corresponde a este código:

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

Pruébalo en línea!

Ahorramos un byte al duplicarlo -(n*2)%(phi*2)<2.

05AB1E , 9 bytes

L5t>;*óså

Pruébalo en línea!

0 significa superior, 1 significa inferior. Pruebe los primeros 100: ¡ Pruébelo en línea!

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

Volcado de comando sin procesar:

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

Jalea , 5 bytes

N%ØpỊ

Pruébalo en línea!

Guardado 1 byte gracias al golf Python de xnor .

Jalea , 6 bytes

×€ØpḞċ

Pruébalo en línea!

Devuelve 1 para inferior y 0 para superior.

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

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

Pruébalo en línea!

No produce nada para inferior y 0superior. Cambiar a un esquema de salida más sensato costaría 6 bytes.

Python 2 , 39 33 32 bytes

^{-6 bytes gracias al Sr. Xcoder
-1 byte gracias a Zacharý}

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

Pruébalo en línea!

Retornos Falsepara inferior y Truesuperior

Julia 0.6 , 16 bytes

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

Pruébalo en línea!

Mientras jugaba con los números, me encontré con esta propiedad: floor (n / φ) == floor ((n + 1) / φ) si n está en la secuencia superior de Wythoff, y floor (n / φ) <floor ( (n + 1) / φ) si n está en la secuencia inferior de Wythoff. No he descubierto cómo se produce esta propiedad, pero da los resultados correctos al menos hasta n = 100000 (y probablemente más allá).

Vieja respuesta:

Julia 0.6 , 31 bytes

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

Pruébalo en línea!

Devuelve truepara la falsesecuencia de Wythoff inferior y superior.

Pyth , 8 bytes

/sM*.n3S

Pruébalo aquí!

Devuelve 1 para inferior y 0 para superior.

Wolfram Language (Mathematica) , 26 bytes

#~Ceiling~GoldenRatio<#+1&

Pruébalo en línea!

Un entero nestá en la secuencia de Wythoff inferior iff ceil(n/phi) - 1/phi < n/phi.

Prueba de que ceil(n/phi) - 1/phi < n/phies ...

Suficiente:

1. Dejar ceil(n/phi) - 1/phi < n/phi.

2. A continuación, ceil(n/phi) * phi < n + 1.

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

4. Por lo tanto, n <= ceil(n/phi) * phi < n + 1.

5. Como ny ceil(n/phi)son enteros, invocamos la definición de piso y estado floor(ceil(n/phi) * phi) == n, y nestá en la secuencia inferior de Wythoff.

Necesario; prueba por contrapositivo:

1. Dejar ceil(n/phi) - 1/phi >= n/phi.

2. A continuación, ceil(n/phi) * phi >= n + 1.

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

4. Por lo tanto n > (ceil(n/phi) - 1) * phi.

5. Como (ceil(n/phi) - 1) * phi < n < n + 1 <= ceil(n/phi) * phi, nno está en la secuencia inferior de Wythoff.

Japt , 10 bytes

Devuelve verdadero para inferior y falso para superior.

õ_*MQ fÃøU

Pruébalo en línea!

Explicación:

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

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

Puerto de la respuesta de @ Rod's Python 2 .
-1 byte gracias a @ Zacharý .

Pruébalo en línea.

Antigua respuesta de 77 76 bytes:

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

-1 byte gracias a @ovs 'por algo que me recomendé la semana pasada ... xD

Devoluciones 1por menor; 0para superior.

Pruébalo en línea.

Explicación:

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*Phise calcula tomando (sqrt(5)+1)/2 * i, y luego lo piso al convertirlo en un número entero para truncar el decimal.

Haskell , 153 139 126 79 bytes

Precisión ilimitada!

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

Pruébalo en línea!

Explicación

En lugar de usar una aproximación de la proporción áurea para calcular el resultado, significa que son propensos a errores a medida que aumenta el tamaño de la entrada. Esta respuesta no. En su lugar, utiliza la fórmula provista en el OEIS que aes la secuencia única tal que

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

¿Dónde bestá el cumplido ordenado?

Brachylog , 8 bytes

≥ℕ;φ×⌋₁?

Pruébalo en línea!

El predicado tiene éxito si la entrada está en la secuencia de Wythoff inferior y falla si está en la secuencia de Wythoff superior.

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

Si el hecho de no terminar es un método de salida válido, se puede omitir el primer byte.

MATL , 8 bytes

t:17L*km

Pruébalo en línea!

Explicación

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

Solución:

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

Pruébalo en línea!

Explicación:

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

La entrada está adentro Ans.
La salida está en Ansy se imprime automáticamente.
Imprime 1si la entrada está en la secuencia inferior o 0si está en la secuencia superior.

$0<N<1000$ .

Ejemplo:

27
             27
prgmCDGFA
              1
44
             44
prgmCDGFA
              0

Explicación:

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

Nota: TI-BASIC es un lenguaje tokenizado. El recuento de caracteres no es igual al recuento de bytes.

cQuents , 5 bytes

?F$`g

Pruébalo en línea!

Explicación

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

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