목표는 주어진 숫자 n가 가장 적은 바이트에서 소수 인지 결정하는 것입니다 . 그러나 코드는 숫자로만 구성된 단일 Python 2 표현식 이어야합니다.

• 연산자
• 입력 변수 n
• 정수 상수
• 괄호

루프 없음, 할당 없음, 내장 함수 없음, 위에 나열된 것만. 네 가능합니다.

연산자

다음 은 산술, 비트 및 논리 연산자를 포함 하여 Python 2 의 모든 연산자 목록입니다 .

+    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

모든 중간 값은 정수 (또는 암시 적으로 0과 1 인 False / True)입니다. 부수를 생성 할 수 있으므로 음수 지수와 함께 지수를 사용할 수 없습니다. 참고 /파이썬 3는 달리, 바닥 부문 않기 때문에 //필요하지 않습니다.

파이썬에 익숙하지 않더라도 연산자는 매우 직관적이어야합니다. 참조 연산자 우선 순위에 대한이 테이블 과 이 섹션 아래를 문법에 대한 자세한 사양에 대해. TIO에서 Python 2를 실행할 수 있습니다 .

I / O

입력 :n 2 이상의 양의 정수

출력 :n 소수 이면 1 , 그렇지 않으면 0 True과False 또한 사용될 수있다. 가장 적은 바이트가 이깁니다.

코드는 표현식이므로 입력 값이으로 저장되어 n원하는 출력을 평가 하는 스 니펫이됩니다 .

코드는 n임의로 큰 시스템 제한을 위해 작동해야합니다 . 파이썬의 정수 유형은 제한이 없으므로 연산자에는 제한이 없습니다. 그러나 코드를 실행하는 데 시간이 오래 걸릴 수 있습니다.

43 바이트

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

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

이 방법은 Dennis의 두 번째 (삭제 된) 답변과 비슷하지만이 답변은 더 쉽게 증명할 수 있습니다.

증명

짧은 형식

가장 중요한 자리 (4**n+1)**n%4**n**2베이스에 로 나누어 아닌 N 의 다음 (덜 중요한) 자리 할 것이다 후 (즉, "다음의 숫자는"소수 부분에 있지 않은 경우)를 제로하는 비트 마스크와$2^n$$n$(4**n+1)**n%4**n**2/n&2**(2*n*n+n)/-~2**n 확인하기 위해 실행된다 홀수 위치의 숫자가 0이 아닌 경우

긴 형태

하자 이베이스 갖는 숫자 B의 표현, 즉, N의 B , N + ⋯ + 1 B 1 + 0 B 0 및 난 에 숫자 일 " 베이스 b 표현 에서의 위치 " i .$[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$

2 n × 4 n 2 − 1 이므로(n2n-1s 포함)은 정수이며,⌊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}$

다음으로

$$\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}$$

그렇게까지의 숫자를 잘라야한다 2 N 마지막 자리 - 것을 제외합니다 ($4^{n^2}=(2^n)^{2n}$%4**n**2$2n$ (1)이지만 다른 모든 이항 계수를 포함합니다.$\binom nn$

소개 /n:

• 경우 소수이고, 결과가 될 것입니다 [ ($n$. 홀수 위치의 모든 숫자는 0입니다.$\left[\binom n{n-1}/n,0,\dots,0,\binom n1/n,0,0\right]_{2^n}$

• 이 소수가 아닌 경우 :$n$

  하자 그 가장 큰 정수 등의 수 N ∤ ($a$ (n>a>0). 배당을 다음과 같이 다시 작성하십시오.$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}$

  첫 번째 소환수는 모든 자릿수를 있으며 위치 2 a - 1 의 숫자는0입니다.$n$$2a-1$

  제 피가수는 (위치에서 가장 중요한 자리 갖는 로 나누어 생략) N 및 (베이스) (2) N > N 의한 나눈 때문에 지수를 해당 위치에 자리 할 것이다 2 - 1 제로한다.$2a$$n$$2^n>n$$n$$2a-1$

  따라서 최종 결과 ( (4**n+1)**n%4**n**2/n)는 위치 2 a + 1 이 아닌 0 (숫자 )이어야합니다 .$2^n$$2a+1$

마지막으로, 비트 단위 AND은 ( &) 자료 벡터화 비트 AND 숫자에 행하는 (염기는 2의 제곱이기 때문에) 때문 & 0 = 0 , 및 ( 2 N - 1 ) = 을 모든 0 ≤ a < 2 n 이면 0입니다. iff 첫 번째 n 홀수 위치의 모든 자릿수 0을 갖습니다. 이는 n 이 소수입니다.$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$

파이썬 2 , 56 바이트

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

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

이 개념 증명이 도전은 비트없이 특히, 단지 산술 연산자와 행할 수 있다는 것입니다 |, &또는를 ^. 이 코드는 골프 용으로 비트 단위 및 비교 연산자를 사용하며 산술 등가로 쉽게 대체 할 수 있습니다.

However, the solution is extremely slow, and I haven't been able to run $n=6$`, thanks to two-level exponents like $2^{n^n}$.

The main idea is to make an expression for the factorial $n!$, which lets us do a Wilson's Theorem primality test $(n-1)! \mathbin{\%} n > n-2$ where $\mathbin{\%}$ is the modulo operator.

We can make an expression for the binomial coefficient, which is made of factorials

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

But it's not clear how to extract just one of these factorials. The trick is to hammer apart $n!$ by making $m$ really huge.

$$\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)$$

So, if we let $c$ be the product $\left(1-\frac{1}{m}\right)\left(1-\frac{2}{m}\right)\cdots \left(1-\frac{n-1}{m}\right)$, we have

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

If we could just ignore $c$, we'd be done. The rest of this post is looking how large we need to make $m$ to be able to do this.

Note that $c$ approaches $1$ from below as $m \to \infty$. We just need to make $m$ huge enough that omitting $c$ gives us a value with integer part $n!$ so that we may compute

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

For this, it suffices to have $1 - c < 1/n!$ to avoid the ratio passing the next integer $n!+1$.

Observe that $c$ is a product of $n$ terms of which the smallest is $\left(1-\frac{n-1}{m}\right)$. So, we have

$$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.