숫자는 모두 소수이고 2 ⁿ -1 형식으로 쓸 수있는 경우 Mersenne Prime 입니다. 여기서 n 은 양의 정수입니다.

당신의 임무는 양의 정수가 주어지면 그것이 메르 센 소수인지 여부를 결정하는 것입니다. 진실 / 거짓 값을 반환하는 함수 또는 IO를 수행하는 전체 프로그램을 제출할 수 있습니다.

규칙 :

• 이것이 code-golf 이므로 가능한 한 짧은 바이트 수로이 작업을 수행해야 합니다. 내장이 허용됩니다.
• 표준 골프 허점이 적용됩니다-외부 파일에서 Mersenne 프라임을 읽거나 프로그램에 하드 코딩 할 수 없습니다.
• 프로그램은 언어의 표준 정수 크기 내의 값에 대해 작동해야합니다.

테스트 사례

참고로 (알려진) 메르 센 프라임 목록은 여기 에서 찾을 수 있습니다 . 편리한 테스트 사례는 다음과 같습니다.

2  -> False
1  -> False 
20 -> False
51 -> False
63 -> False

3    -> True
31   -> True
8191 -> True

_{메리 크리스마스, 여러분! 축하 할 때마다 즐거운 휴가 보내세요 :)}

젤리 , 5 바이트

&‘<ÆP

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

작동 원리

&‘<ÆP  Main link. Argument: x

 ‘     Yield x+1.
&      Take the bitwise AND of x and x+1.
       This yields 0 iff x is a Mersenne number, i.e., iff x+1 is a power of 2.
   ÆP  Yield 1 if x is a prime, 0 if not.
  <    Compare the results to both sides,
       This yields 1 iff x is both a Mersenne number and a prime.

05AB1E , 5 바이트

이진수 로 2 ⁿ -1 형식의 양수 는 1 로만 구성됩니다 .

암호:

b`¹pP

설명:

b`      # Push each digit of the binary representation of the number onto the stack
  ¹p    # Check if the input is prime
    P   # Take the product of all these digits

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

파이썬 , 45 바이트

lambda n:-~n&n<all(n%i for i in range(2,n))<n

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

작동 원리

연쇄 비교의 세 가지 용어

-~n&n<all(n%i for i in range(2,n))<n

다음을 수행하십시오.

• -~n&nn + 1 및 n 의 비트 단위 AND를 계산합니다 . 메르 센 수인 경우 n 은 1 비트로 만 구성 되므로 비트 AND는 0 인 경우에만 0 을 반환 합니다.

• all(n%i for i in range(2,n))n mod i 가 [2,…, n-1] 에서 i의 모든 값에 대해 0이 아닌 경우에만, 즉 n에 1 과 n 이외의 양의 제수가없는 경우 에만 True를 반환합니다 .

  즉, 모든 반환 진정한 경우에만 경우 n이 합성 수, 즉이며, n은 하나이고 하나 또는 소수.

• n 자명하다.

체인 비교는 개별 비교가 동일 할 경우에만 True를 반환합니다 .

• 이후 모든 반환하거나 참 / 1 또는 거짓 / 0 , -~n&n<all(n%i for i in range(2,n))만 반환 할 수 있습니다 진정한 경우 -~n&n수익률 0 (즉, 만약 N 메르 센 수입니다) 및 모든 반환 사실 (즉, 만약 N 중 하나 또는 소수).

• 비교 all(n%i for i in range(2,n))<n는 n> 1 일 때마다 유지 되지만 n = 1 인 경우 모두 True를 반환 하므로이 경우 에는 유지되지 않습니다.

Brachylog , 7 바이트

#p+~^h2

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

Brachylog 프로그램은 기본적으로 체인을 형성하는 일련의 제약 조건입니다. 첫 번째 제약 조건은 입력과 익명의 알 수 없음 ( 이 토론의 목적으로 A 라고 함 )이며 두 번째 제약 조건은 익명의 알 수 없음과 두 번째 익명입니다. 알 수 없음 ( B라고 함 ) 등. 따라서 프로그램은 다음과 같이 분류됩니다.

#p      Input = A, and is prime
+       B = A + 1
~^      B = X to the power Y, C = the list [X, Y]
h       D = the head of list C (= X)
2       D = 2

B가 2의 거듭 제곱, 즉 입력이 2-1의 거듭 제곱이고 입력도 프라임 인 경우, 이러한 모든 제약 조건을 동시에 만족시킬 수있는 유일한 방법입니다. (Brachylog는 내부적으로 제약 조건 솔버를 사용하므로 프로그램은 평가 순서보다 비효율적이지 않습니다 . 두 숫자의 지수 로 표현하기 전에 C형식이 있음을 알 수 있습니다.)[2, Y]B

흥미롭게도 Mersenne과 같은 소수는 비 퇴행성 사례에서 증거 로 2를 사용할 수 있기 때문에 #p+~^ 거의 효과가 있지만 a) B는 ¹ 로 표현 될 수 있기 때문에 비 Merenne은 B -1에 실패합니다. ) 기존의 Brachylog 인터프리터는 잘 제한되지 않은 프로그램에 의해 혼동되는 것 같습니다 (무한한 또는 최소한 긴 기간의 루프로 이동). 따라서 Brachylog에서는 7 바이트를 이길 가능성이 거의 없습니다.

매스 매 티카 26 바이트

PerfectNumberQ[# (#+1)/2]&

이 증거를보십시오

홀수의 완벽한 숫자가없고 존재하지 않는 한 작동합니다.

매스 매 티카, 29 26 바이트

편집 : Martin Ender 덕분에 3 바이트를 절약했습니다.

PrimeQ@#&&IntegerQ@Log2[#+1]&

PrimeQ@#&&1>BitAnd[#,#+1]&

첫 42 개의 지수가 하드 코딩되어 있기 때문에 이것이 더 빠를 것이라고 생각합니다.

MersennePrimeExponentQ@Log2[#+1]&

펄 6 , 29 바이트

{.base(2)~~/^1*$/&&.is-prime}

시도 해봐

넓히는:

{             # bare block lambda with implicit parameter ｢$_｣

  .base(2)    # is its binary representation ( implicit method call on ｢$_｣ )
   ~~
  /^ 1* $/    # made entirely of ｢1｣s

  &&          # and

  .is-prime   # is it prime

}

펄 6 임의로 큰 INTS을 가지고 있기 때문에, 패드의하지 않는 전면 .base(2)으로 0들.

파이썬, 83 82 79 76 73 바이트

def f(m):
 s,n=(m!=3)*4,m>>2
 while-~m&m<n:s,n=(s*s-2)%m,n>>1
 return s<1

파이썬 2, 71 바이트

def f(m):
 s,n=(m!=3)*4,m/4
 while-~m&m<n:s,n=(s*s-2)%m,n/2
 return s<1

이 함수는 Lucas–Lehmer primality test를 구현 하므로 다른 Python 오퍼링만큼 짧지는 않지만 큰 입력을 처리 하는 데 훨씬 빠릅니다.

다음은 Python 2 또는 Python 3에서 실행되는 테스트 코드입니다.

from __future__ import print_function

def primes(n):
    """ Return a list of primes < n """
    # From http://stackoverflow.com/a/3035188/4014959
    sieve = [True] * (n//2)
    for i in range(3, int(n**0.5) + 1, 2):
        if sieve[i//2]:
            sieve[i*i//2::i] = [False] * ((n - i*i - 1) // (2*i) + 1)
    return [2] + [2*i + 1 for i in range(1, n//2) if sieve[i]]

def lucas_lehmer_old(p):
    m = (1 << p) - 1
    s = 4
    for i in range(p - 2):
        s = (s * s - 2) % m
    return s == 0 and m or 0

# much faster
def lucas_lehmer(p):
    m = (1 << p) - 1
    s = 4
    for i in range(p - 2):
        s = s * s - 2
        while s > m:
            s = (s & m) + (s >> p)
    return s == 0 or s == m and m or 0

def f(m):
 s,n=(m!=3)*4,m>>2
 while-~m&m<n:s,n=(s*s-2)%m,n>>1
 return s<1

# Make a list of some Mersenne primes
a = [3]
for p in primes(608):
    m = lucas_lehmer(p)
    if m:
        print(p, m)
        a.append(m)
print()

# Test that `f` works on all the numbers in `a`
print(all(map(f, a))) 

# Test `f` on numbers that may not be Mersenne primes
for i in range(1, 525000):
    u = f(i)
    v = i in a
    if u or v:
        print(i, u, v)
    if u != v:
        print('Error:', i, u, v)

산출

3 7
5 31
7 127
13 8191
17 131071
19 524287
31 2147483647
61 2305843009213693951
89 618970019642690137449562111
107 162259276829213363391578010288127
127 170141183460469231731687303715884105727
521 6864797660130609714981900799081393217269435300143305409394463459185543183397656052122559640661454554977296311391480858037121987999716643812574028291115057151
607 531137992816767098689588206552468627329593117727031923199444138200403559860852242739162502265229285668889329486246501015346579337652707239409519978766587351943831270835393219031728127

True
3 True True
7 True True
31 True True
127 True True
8191 True True
131071 True True
524287 True True

FWIW, 다음은 약간 더 효율적인 버전 으로 모든 루프에서 f다시 테스트하지는 않습니다 m.

def f(m):
 s,n=m!=3and 4,m>>2
 if-~m&m<1:
  while n:
   s=(s*s-2)%m
   n>>=1
 return s<1

R, 41 40 바이트

matlab::isprime(x<-scan())&!log2(x+1)%%1

이상하게도 R의 내장은 인수 mersenne가 n아니라 인수로 사용됩니다 2^n-1.

이것은 xSTDIN에서 가져 matlab오고 패키지를 사용하여 소수 인지 x+1확인하고 mod 1을 취하고 '0이 아님'을 확인 하여 2-log of 가 정수인지 확인합니다.

또한 mersenne내장 을 사용하면 약간 짧아 지지만 속임수처럼 느껴집니다.

numbers::mersenne(log2(scan()+1))

@Billywob 덕분에 1 바이트 절약

파이크, 10 바이트

_PQb2+}\1q

여기 사용해보십시오!

_P         -    is_prime(input)
     +     -   ^ + V
  Qb2      -    base_2(input)
      }    -  uniquify(^)
       \1q - ^ == "1"

실제로 9 바이트

;├╔'1=@p*

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

설명:

2 ⁿ -1 형식의 모든 숫자는 이진 표현에서 모두 1을 갖기 때문에 메르 센 소수는 해당 품질의 소수로 식별 될 수 있습니다.

;├╔'1=@p*
 ├╔'1=     only unique binary digit is 1
        *  and
;     @p   is prime

젤리, 5 바이트

@Dennis의 기존 5 바이트 젤리 답변에 대한 대체 방법 :

B;ÆPP

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

작동 방식 :

B      Returns the binary representation of the input as a list [1, 0, 1, 1, ...]
 ;     And attach to this list 
  ÆP   a 1 if the input is a prime, 0 otherwise
    P  Calculates the product of this list of 1's and 0's

메르 센 프라임은 2의 거듭 제곱보다 하나가 작으므로 이진 표현은 예외적으로 1입니다. 그 결과는 Mersenne 소수의 경우 1이고 다른 모든 경우에는 0입니다.

실론, 66 바이트

Boolean m(Integer c)=>c>2&&c.and(c+1)<1&&!(2:c-2).any((d)=>c%d<1);

형식화 및 주석 처리 :

// Check whether a (positive integer) number is a mersenne prime number.
//
// Question:  http://codegolf.stackexchange.com/q/104508/2338
// My Answer: http://codegolf.stackexchange.com/a/104805/2338

Boolean m(Integer c) =>
        // check whether c+1 is a power of two
        c.and(c+1)<1 &&
        // the standard primality check by trial division
         !(2 : c-2).any((d) => c%d < 1) &&
        // we need to exclude 1, which is unfortunately
        // matched by both criteria above, but is no prime.
        c>1;

부정 행위 (실론 정수 범위의 결과를 하드 코딩)하면 바이트가 짧아 질 수 있습니다 (65).

Boolean h(Integer c) =>
        c.and(c+1)<1 && #20000000800a20ac.and(c+1)>0;

(구문 하이 라이터는 Ceylon의 16 진 숫자를 주석 시작으로 이해하지 못하는 것 같습니다.)

익명 함수가 괜찮 으면 49 바이트입니다.

[2,3,5,7,13,17,19,31,61].map((p)=>2^p-1).contains

Wolfram Language (Mathematica) , 23 바이트

PrimeQ[BitAnd[#,#+2]#]&

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

1 때문에 올바르게 처리됩니다 PrimeQ[BitAnd[1,1+2]*1] == PrimeQ@1 == False. 그렇지 않으면 BitAnd[#,#+2]#소수가 되려면 #소수이고 메르 센 숫자 BitAnd[#,#+2] == 1일 때 발생합니다 #.

ECMAScript 정규식, 42 31 바이트

^(?!(xx+)\1+$)(x(x*)(?=\3$))+x$

^
(?!(xx+)\1+$)      # Assert that N is prime or 0 or 1.
(x(x*)(?=\3$))+x$  # Assert that N is a power of 2 minus 1 and is >= 3.
                   # The >=3 part of this prevents the match of 0 and 1.

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

편집 : Neil 덕분에 31 바이트까지 감소했습니다.

기본 "2의 거듭 제곱 1입니다"테스트는 ^(x(x*)(?=\2$))*$입니다. 이것은 더 이상 수행 할 수 없을 때까지 "1을 빼고 2로 균등하게 나누기"작업을 반복 한 다음 결과가 0이라고 주장함으로써 작동합니다. 마지막 *을 a 로 변경 +하여 루프를 한 번 이상 반복하도록하여 숫자 ≥1 만 일치하도록 수정할 수 있습니다 . 삽입 x마지막 전에 $한 번 적어도 반복 한 후 최종 결과가 1임을 주장에 의해 더 수정에만 일치하는 번호를 ≥3.

관련 "2의 거듭 제곱"테스트는 ^((x+)(?=\2$))*x$입니다. 발견이 마이너스 2의 일치 능력을위한 속기도있다 검댕으로 더럽혀진은 : ^((x+)(?=\2$)x)*$. 이 3 개의 정규식은 모두 같은 길이입니다.

Grimy의 대체 31 바이트 버전 :

^(?!(xx+)\1+$|((xx)+)(\2x)*$)xx

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

# Match Mersenne primes in the domain ^x*$
^                   # N = input number
(?!                 # "(?!p|q)" is equivalent to "(?!p)(?!q)"; evaluate the
                    # logical AND of the following negative lookaheads:
    (xx+)\1+$       # Assert that N is prime or 0 or 1
|
    ((xx)+)(\2x)*$  # Assert that N is a power of 2 minus 1; this is based
                    # on "(?!(x(xx)+)\1*$)" which matches powers of 2.
)
xx                  # Assert that N >= 2, to prevent the unwanted match of
                    # 0 and 1 by both of the negative lookahead statements.

정규식 (ECMAScript), 29 바이트

^(?!(xx+|(x(x))+)(\1\3)+$)xxx

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

채팅 에서 Grimy에 의해 영감을 받음

정규식은 입력 (3)보다 큰 것으로 주장하고,이 둘의 형상 없다고 : (xx+)\1+또는 ((xx)+)(\1x)+.

첫 번째는 복합 숫자와 일치합니다.
두 번째는 2보다 큰 홀수의 배수보다 1이 작은 숫자와 일치합니다.

01
$2^n-1$

2는 홀수 소수보다 1이 적은 유일한 소수이므로, 입력이 3보다 크다는 주장과 함께 부정적인 전망은 메르 센 소수에만 일치합니다.

루비, 47 바이트

->b{!("%b"%(b/2)=~/0/||(2...b).find{|a|b%a<1})}

줄리아, 26 바이트

n->isprime(n)&&ispow2(n+1)

파이썬, 65 바이트

f=lambda n,i=3:(n^i)-all(n%i for i in range(2,n))<0 or f(n,-~i|i)

종료 코드를 통한 출력. 거짓 재귀 오류. True에 오류가 없습니다.

작동 원리

2^n-1이진수는 전적으로 1로 만들어 지기 때문에 다음 2^n-1숫자는로 생성 할 수 있습니다 number|number+1.

이 함수는 각 2^n-1숫자 검사를 재귀 적으로 수행하여 소수인지 입력에 대해 eqaul인지 확인합니다. 숫자가 메르 센 소수가 아닌 경우 파이썬은 최대 재귀 깊이를 초과했을 때 결국 오류를 발생시킵니다.

Pushy , 7 바이트

oBoIpP#

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

이것은 메르 센 숫자가 이진 표현에 하나만 있다는 사실을 이용합니다.

oB      \ Pop input, push its binary digits.
  oI    \ Re-push the input
    p   \ Test its primality (0/1)
     P# \ Print the product of the stack

스택 곱은 1이진 표현에서 숫자가 0이 아니고 소수가 인 경우 에만 해당됩니다 True.

Pyth , 8 바이트

&.AjQ2P_

모든 테스트 사례를 확인하십시오.

Pyth , 8 바이트

<.&QhQP_

모든 테스트 사례를 확인하십시오.

어떻게?

코드 분석 # 1

&.AjQ2P_    Full program with implicit input.

      P_    Is Prime?
   jQ2      Convert the input to binary as a list of digits.
 .A         All the elements are truthy (i.e. all are 1).
&           Logical AND.
            Output implicitly.

어떻게 작동합니까?

형태의 숫자 2 ^{, n은} - 1은 항상 포함 1 진에 기록 된 경우에만 사용할 수 있습니다. 따라서 모든 이진수가 1 인지 소수인지 테스트합니다 .

코드 분석 # 2

<.&QhQP_    Full program with implicit input.

      P_    Is Prime?
    hQ      Input + 1.
 .&Q        Bitwise AND between the input and ^.
<           Is smaller than? I.e. The bitwise AND results in 0 and the primality test results in 1.
            Output implicitly.

어떻게 작동합니까?

이 경우를 테스트 입력 + 1이 2의 거듭 제곱 인 (예는 메르 센 번호 인 경우), 다음 솟수 테스트를 수행한다. Python에서 bool의 하위 클래스 int이므로 truthy는 1 로 처리되고 falsy는 0 으로 처리됩니다 . 사람이 있음을 명시 적으로 확인 피하기 위해 0 과 다른 하나는 1 , 우리는 사용하여 값을 비교 <(우리는 하나 이러한 경우이 있기 때문에).

자바 8, 53 52 49 바이트

n->{int i=1;for(;n%++i>0;);return(n&n+1|i^n)==0;}

@Nevay 덕분에 버그가 수정되어 4 바이트가 되었습니다 .

설명:

여기에서 시도하십시오.

n->{                // Method with integer parameter and boolean return-type
  int i=1;          //  Temp integer `i`, starting at 1
  for(;n%++i>0;);   //  Loop and increase `i` as long as `n` is divisible by `i`
  return(n&n+1|i^n) //  Then return if `n` bitwise-AND `n+1` bitwise-OR `i` bitwise-XOR `n`
          ==0;      //  is exactly 0
}                   // End of method

파이썬 3, 68 바이트

a=int(input());print(a&-~a<1and a>1and all(a%b for b in range(2,a)))

여기 사용해보십시오

파이썬 2, 63 바이트

a=input();print(a&-~a<1)and a>1and all(a%b for b in range(2,a))

여기 사용해보십시오

제안 해 주셔서 감사합니다 Jonathan

바이트 수를 줄이기위한 제안을 엽니 다.

apt, 6 바이트

¢¬×&Uj

실행 또는 모든 테스트 케이스 실행

파이썬, 93 바이트

def f(a):
 for b in range(a):
  if(a+1==2**b and not[i for i in range(2,a)if a%i<1]):return 1

이 코드는 Python 2와 Python 3 모두에서 작동하므로 버전을 지정하지 않았습니다.

라켓 76 바이트

(define(g m)(for/or((i m))(= m(-(expt 2 i)1))))(if(and(prime? n)(g n))#t #f)

언 골프 드 :

(require math)
(define(f n)
  (define (ispowerminus1 m)
    (for/or ((i m))
      (= m (-(expt 2 i)1))))
  (if (and (prime? n)
           (ispowerminus1 n))
      #t #f))

테스트 :

(f 1)
(f 2)
(f 20)
(f 51)
(f 63)
(f 3)
(f 31)
(f 8191)

산출:

#f
#f
#f
#f
#f
#t
#t
#t

PHP, 53 바이트

for($i=$n=$argv[1];--$i&&$n%$i;);echo!($i-1|$n+1&$n);

명령 행 인수를 취합니다. 1메르 센 소수, 빈 문자열을 인쇄 합니다. 로 실행하십시오 -r.

고장

for($i=$n=$argv[1];--$i&&$n%$i;);   // loop $i down from $n-1 until $i divides $n
                        // If $n is prime, loop ends with $i=1. ($n=1 -> $i=0)
echo!($i-1|$n+1&$n);    // If $i!=1, $n is not prime. If ($n+1&$n)>0, $n is not Mersenne.
                        // If either $i-1 or $n+1&$n is truthy, the negation will be false.

C, 94 바이트

g(n,i){return--i?g(2*n,i):n;}n,r;f(x){for(n=r=1;++n<x;)r=x%n?x^g(2,n)-1?r:r|2:r&2;return r>2;}

숫자가 Mersenne Prime이면 1을, 그렇지 않으면 0을 반환합니다.

스칼라, 59 바이트

def f(t:BigInt)=t.isProbablePrime(t.bitLength*9)&(1+t)%2==0

이 함수는 입력이이어야합니다 BigInt. 당신은 쉽게로 문자열 "162259276829213363391578010288127을"(이 ** (107-1)는 메르 센 소수)로 변환 할 수 있습니다 BigInt수행하여 BigInt("162259276829213363391578010288127"). isProbablePrime()방법 의 이름에서 알 수 있듯이 잘못 될 수 있습니다 . 그러나 확률은 그 이상 0.5^(t.bigLength)*9입니다.

독립형 스크립트 버전은 72 바이트입니다.

val t=BigInt(args(0));print(t.isProbablePrime(t.bitLength*9)&(1+t)%2==0)

"t.scala"로 저장하면 프로그램을 다음과 같이 실행할 수 있습니다.

>scala t.scala 162259276829213363391578010288127
>true

펄 5 , 53 바이트

코드 52 바이트 + 1 -p

$f=0|sqrt;1while$_%$f--;$_=!$f*(sprintf'%b',$_)!~/0/

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