Su objetivo es determinar si un número dado nes primo en la menor cantidad de bytes. Pero, su código debe ser una sola expresión de Python 2 en números que consisten solo en

• operadores
• la variable de entrada n
• constantes enteras
• paréntesis

Sin bucles, sin asignaciones, sin funciones integradas, solo lo que se menciona anteriormente. Si es posible.

Operadores

Aquí hay una lista de todos los operadores en Python 2 , que incluye operadores aritméticos, bit a bit y lógicos:

+    adddition
-    minus or unary negation
*    multiplication
**   exponentiation, only with non-negative exponent
/    floor division
%    modulo
<<   bit shift left
>>   bit shift right
&    bitwise and
|    bitwise or
^    bitwise xor
~    bitwise not
<    less than
>    greater than
<=   less than or equals
>=   greater than or equals
==   equals
!=   does not equal

Todos los valores intermedios son enteros (o Falso / Verdadero, que implícitamente es igual a 0 y 1). La exponenciación no puede usarse con exponentes negativos, ya que esto puede producir flotadores. Tenga en cuenta que /hace la división del piso, a diferencia de Python 3, por //lo que no es necesario.

Incluso si no está familiarizado con Python, los operadores deberían ser bastante intuitivos. Vea esta tabla para la precedencia del operador y esta sección y más abajo para una especificación detallada de la gramática. Puede ejecutar Python 2 en TIO .

I / O

Entrada: Un entero positivo nque es al menos 2.

Salida: 1 si nes primo y 0 en caso contrario. Truey Falsetambién se puede usar. Pocos bytes ganan.

Como su código es una expresión, será un fragmento, esperando el valor de entrada almacenado como ny evaluando el resultado deseado.

Su código debe funcionar para narbitrariamente grandes, dejando a un lado los límites del sistema. Como el tipo de número entero de Python no tiene límites, no hay límites para los operadores. Su código puede tardar mucho tiempo en ejecutarse.

43 bytes

(4**n+1)**n%4**n**2/n&2**(2*n*n+n)/-~2**n<1

Pruébalo en línea!

El método es similar a la segunda respuesta (eliminada) de Dennis, pero es más fácil demostrar que esta respuesta es correcta.

Prueba

Forma corta

El dígito más significativo de (4**n+1)**n%4**n**2en base que no es divisible entre n hará que el siguiente dígito (menos significativo) sea distinto de cero (si ese "siguiente dígito" no está en la parte fraccionaria), se ejecuta a con la máscara de bits para verificar si algún dígito en la posición impar no es cero.$2^n$$n$(4**n+1)**n%4**n**2/n&2**(2*n*n+n)/-~2**n

Forma larga

Sea el número que tiene esa representación base b , es decir, a n b n + ⋯ + a 1 b 1 + a 0 b 0 , y a i es el dígito en " posición " i en representación de base b .$[a_n,\dots,a_1,a_0]_b$$b$$a_nb^n+\dots+a_1b^1+a_0b^0$$a_i$$i$$b$

• .$\texttt{2**(2*n*n+n)/-~2**n} =\lfloor{2^{(2n+1)n}\over1+2^n}\rfloor =\lfloor{4^{n^2}\times 2^n\over1+2^n}\rfloor =\lfloor{{(4^{n^2}-1)\times 2^n\over1+2^n} +{2^n\over1+2^n}}\rfloor$

Porque (conn2n-1s) es un número entero, y⌊2$2^n\times{4^{n^2}-1\over1+2^n} =2^n(2^n-1)\times{(4^n)^n-1\over4^n-1} =[2^n-1,0,2^n-1,0,2^n-1,0]_{2^n}$$n$ $2^n-1$, =[2n-1,0,2n-1,0,2n-1,0]2n.$\lfloor{2^n\over1+2^n}\rfloor=0$2**(2*n*n+n)/-~2**n$[2^n-1,0,2^n-1,0,2^n-1,0]_{2^n}$

A continuación, considere

$$\begin{align} \texttt{(4**n+1)**n} &=(4^n+1)^n \\ &=\binom n04^{0n}+\binom n14^{1n}+\dots+\binom nn4^{n^2} \\ &=\left[\binom nn,0,\dots,0,\binom n1,0,\binom n0\right]_{2^n} \end{align}$$

, porlo que truncará el número a 2 n últimos dígitos, lo que excluye el ($4^{n^2}=(2^n)^{2n}$%4**n**2$2n$ (que es 1) pero incluye todos los demás coeficientes binomiales.$\binom nn$

Acerca de /n:

• Si es primo, el resultado será [ ($n$. Todos los dígitos en la posición impar son cero.$\left[\binom n{n-1}/n,0,\dots,0,\binom n1/n,0,0\right]_{2^n}$

• Si no es primo:$n$

  Sea el mayor número entero tal que n ∤ ($a$ (n>a>0). Reescribe el dividendo como$n\nmid\binom na$$n>a>0$

  $\left[\binom n{n-1},0,\binom n{n-2},0,\dots,\binom n{a+1}, 0,0,0,\dots,0,0,0\right]_{2^n} + \left[\binom na,0,\binom n{a-1},0,\dots,\binom n0\right]_{2^n}$

  El primer sumando tiene todos los dígitos divisibles por , y el dígito en la posición 2 a - 1 cero.$n$$2a-1$

  El segundo sumando tiene su dígito más significativo (en la posición ) no divisible por ny (la base) 2 n > n , por lo que el cociente al dividir eso entre n tendría el dígito en la posición 2 a - 1 distinto de cero.$2a$$n$$2^n>n$$n$$2a-1$

  Por lo tanto, el resultado final ( (4**n+1)**n%4**n**2/n) debe tener el dígito (base , por supuesto) en la posición 2 a + 1 diferente de cero.$2^n$$2a+1$

Finalmente, el AND a nivel de bits ( &) realiza un AND a nivel de bits vectorizado en los dígitos en la base (porque la base es una potencia de 2), y porque a & 0 = 0 , a & ( 2 n - 1 ) = a para todos 0 ≤ a < 2 n , es cero si f tiene todos los dígitos en las primeras n posiciones impares cero, lo que equivale a n siendo primo.$2^n$$a\texttt &0=0,a\texttt&(2^n-1)=a$$0\le a<2^n$(4**n+1)**n%4**n**2/n&2**(2*n*n+n)/-~2**n(4**n+1)**n%4**n**2/n$n$$n$

Python 2 , 56 bytes

n**(n*n-n)/(((2**n**n+1)**n**n>>n**n*~-n)%2**n**n)%n>n-2

Pruébalo en línea!

Esta es una prueba de concepto que este desafío es factible con sólo los operadores aritméticos, en particular, sin bit a bit |, &o ^. El código usa operadores bit a bit y de comparación solo para jugar al golf, y pueden reemplazarse fácilmente con equivalentes aritméticos.

Sin embargo, la solución es extremadamente lenta, y no he podido ejecutar ', gracias a exponentes de dos niveles como 2 n n .$n=6$$2^{n^n}$

La idea principal es hacer una expresión para el factorial , Lo que nos permite hacer un teorema de Wilson test de primalidad ( n - 1 ) ! % n > n - 2 donde % es el operador del módulo.$n!$$(n-1)! \mathbin{\%} n > n-2$$\mathbin{\%}$

Podemos hacer una expresión para el coeficiente binomial , que está hecho de factoriales

$$\binom{m}{n} \ = \frac{m!}{n!(m-n)!}$$

Pero no está claro cómo extraer solo uno de estos factoriales. El truco es martillar aparte haciendo m realmente grande.$n!$$m$

$$\binom{m}{n} \ = \frac{m(m-1)\cdots(m-n+1)}{n!}= \frac{m^n}{n!}\cdot \left(1-\frac{1}{m}\right)\left(1-\frac{2}{m}\right)\cdots \left(1-\frac{n-1}{m}\right)$$

Entonces, si dejamos que sea ​​el producto ( 1 - $c$, tenemos$\left(1-\frac{1}{m}\right)\left(1-\frac{2}{m}\right)\cdots \left(1-\frac{n-1}{m}\right)$

$$n! = \frac{m^n}{\binom{m}{n}} \cdot c$$

Si pudiéramos ignorar , estaríamos listos. El resto de esta publicación analiza qué tan grande debemos hacer m para poder hacer esto.$c$$m$

Tenga en cuenta que aproxima a 1 desde abajo como m → ∞ . ¡Solo necesitamos hacer m lo suficientemente grande como para que omitir c nos dé un valor con la parte entera n ! para que podamos calcular$c$$1$$m \to \infty$$m$$c$$n!$

$$n! = \left\lfloor \frac{m^n}{\binom{m}{n}} \right\rfloor$$

Para esto, es suficiente tener para evitar que la relación pase el siguiente entero $1 - c < 1/n!$$n!+1$

Observe que es un producto de n términos de los cuales el más pequeño es ( 1 $c$$n$$\left(1-\frac{n-1}{m}\right)$

$$c > \left(1-\frac{n-1}{m}\right)^n > 1 - \frac{n-1}{m} n > 1-\frac{n^2}{m},$$

which means $1 - c < \frac{n^2}{m}$. Since we're looking to have $1 - c < 1/n!$, it suffices to take $m \geq n! \cdot n^2$.

In the code, we use $m=n^n$. Since Wilson's Theorem uses $(n-1)!$, we actually only need $m \geq (n-1)! \cdot (n-1)^2$. It's easy to see that $m=n^n$ satisfies the bound for the small values and quickly outgrows the right hand side asymptotically, say with Stirling's approximation.

This answer doesn't use any number-theoretic cleverness. It spams Python's bitwise operators to create a manual "for loop", checking all pairs $1 \leq i,j < n$ to see whether $i \times j = n$.

Python 2, way too many bytes (278 thanks to Jo King in the comments!)

((((((2**(n*n)/(2**n-1)**2)*(2**((n**2)*n)/(2**(n**2)-1)**2))^((n*((2**(n*n-n)/(2**n-1))*(2**((n**2)*(n-1))/(2**n**2-1))))))-((2**(n*n-n)/(2**n-1))*(2**((n**2)*(n-1))/(2**(n**2)-1))))&(((2**(n*(n-1))/(2**n-1))*(2**((n**2)*(n-1))/(2**(n**2)-1)))*(2**(n-1)))==0))|((1<n<6)&(n!=4))

Try it online!

This is a lot more bytes than the other answers, so I'm leaving it ungolfed for now. The code snippet below contains functions and variable assignment for clarity, but substitution turns isPrime(n) into a single Python expression.

def count(k, spacing):
    return 2**(spacing*(k+1))/(2**spacing - 1)**2
def ones(k, spacing):
    return 2**(spacing*k)/(2**spacing - 1)

def isPrime(n):
    x = count(n-1, n)
    y = count(n-1, n**2)
    onebits = ones(n-1, n) * ones(n-1, n**2)
    comparison = n*onebits
    difference = (x*y) ^ (comparison)
    differenceMinusOne = difference - onebits
    checkbits = onebits*(2**(n-1))
    return (differenceMinusOne & checkbits == 0 and n>1)or 1<n<6 and n!=4

Why does it work?

I'll do the same algorithm here in base 10 instead of binary. Look at this neat fraction:

$$\frac{1.0}{999^2} = 1.002003004005\dots$$

If we put a large power of 10 in the numerator and use Python's floor division, this gives an enumeration of numbers. For example, $10^{15}/(999^2) = 1002003004$ with floor division, enumerating the numbers $1,2,3,4$.

Let's say we multiply two numbers like this, with different spacings of zeroes. I'll place commas suggestively in the product.

$$1002003004 \times 1000000000002000000000003000000000004 =$$ $$1002003004,002004006008,003006009012,004008012016$$

The product enumerates, in three-digit sequences, the multiplication table up to 4 times 4. If we want to check whether the number 5 is prime, we just have to check whether $005$ appears anywhere in that product.

To do that, we XOR the above product by the number $005005005\dots005$, and then subtract the number $001001001\dots001$. Call the result $d$. If $005$ appeared in the multiplication table enumeration, it will cause the subtraction to carry over and put $999$ in the corresponding place in $d$.

To test for this overflow, we compute an AND of $d$ and the number $900900900\dots900$. The result is zero if and only if 5 is prime.