Un n-gon construible es un polígono regular con n lados que puedes construir con solo una brújula y una regla sin marcar.

Según Gauss, el único n para el cual un n-gon es construible es un producto de cualquier número de primos Fermat distintos y una potencia de 2 (es decir, n = 2^k * p1 * p2 * ...con kun número entero y cada puno de los primos Fermat distintos).

Un primo de Fermat es un primo que se puede expresar como F (n) = 2 ^ (2 ^ n) +1 con un entero positivo. Los únicos primos Fermat conocidos son para 0, 1, 2, 3 y 4.

El reto

Dado un número entero n>2, diga si el n-gon es constructible o no.

Especificación

Su programa o función debe tomar un número entero o una cadena que represente dicho número entero (ya sea en base unaria, binaria, decimal o cualquier otra base) y devolver o imprimir un valor verdadero o falso.

Este es el código de golf, por lo que la respuesta más corta gana, se aplican las lagunas estándar .

OEIS relevantes

Ejemplos

3 -> True
9 -> False
17 -> True
1024 -> True
65537 -> True
67109888 -> True
67109889 -> False

Jalea , 7 5 bytes

Gracias a Sp3000 por guardar 2 bytes.

ÆṪBSỊ

Utiliza la siguiente clasificación:

Estos también son los números para los cuales phi (n) es una potencia de 2.

Donde phi es la función totient de Euler .

ÆṪ        # Compute φ(n).
  B       # Convert to binary.
   S      # Sum bits.
    Ị     # Check whether it's less than or equal to 1. This can only be the
          # case if the binary representation was of the form [1 0 0 ... 0], i.e. 
          e# a power of 2.

Pruébalo en línea!

Alternativamente (créditos a xnor):

ÆṪ’BP
ÆṪ        # Compute φ(n).
  ’       # Decrement.
   B      # Convert to binary.
    P     # Product. This is 1 iff all bits in the binary representation are
          # 1, which means that φ(n) is a power of 2.

Un puerto directo de mi respuesta de Mathematica es dos bytes más largo:

ÆṪ        # Compute φ(n).
  µ       # Start a new monadic chain, to apply to φ(n).
   ÆṪ     # Compute φ(φ(n)).
      H   # Compute φ(n)/2.
     =    # Check for equality.

Mathematica, 24 bytes

e=EulerPhi
e@e@#==e@#/2&

Utiliza la siguiente clasificación de OEIS:

Computable como números tales que cototient-of-totient es igual al totient-of-totient.

El totient φ(x) de un número entero xes el número de enteros positivos inferiores xque son primos entre sí a x. El cototiente es el número de enteros positivos que no lo son, es decir x-φ(x). Si el totient es igual al cototient, eso significa que el totient de φ(x) == x/2.

La clasificación más directa

Estos también son los números para los cuales phi (n) es una potencia de 2.

termina siendo un byte más largo:

IntegerQ@Log2@EulerPhi@#&

Retina, 51 50 bytes

0+$

+`^(.*)(?=(.{16}|.{8}|....|..?)$)0*\1$
$1
^1$

La entrada está en binario. Las primeras dos líneas se dividen por una potencia de dos, las siguientes dos se dividen por todos los primos Fermat conocidos (si de hecho el número es un producto de los primos Fermat). Editar: Guardado 1 byte gracias a @Martin Ender ♦.

JavaScript (ES7), 61 bytes

n=>[...Array(5)].map((_,i)=>n%(i=2**2**i+1)?0:n/=i)&&!(n&n-1)

En realidad, 6 bytes

Esta respuesta se basa en el algoritmo de xnor en la respuesta Jelly de Martin Ender . Sugerencias de golf bienvenidas. Pruébalo en línea!

▒D├♂≈π

Cómo funciona

         Implicit input n.
▒        totient(n)
 D       Decrement.
  ├      Convert to binary (as string).
   ♂≈    Convert each char into an int.
     π   Take the product of those binary digits.
         If the result is 1,
           then bin(totient(n) - 1) is a string of 1s, and totient(n) is power of two.

Lote, 97 bytes

@set/pn=
@for /l %%a in (4,-1,0)do @set/a"p=1<<(1<<%%a),n/=p*!(n%%-~p)+1"
@cmd/cset/a"!(n-1&n)"

La entrada está en stdin en decimal. Esto es en realidad 1 byte más corto que calcular las potencias de las potencias de 2 de forma iterativa. Ahorré 1 byte usando el poder de @ xnor de 2 cheques.