Một số là một Mersenne Prime nếu cả hai đều là số nguyên tố và có thể được viết dưới dạng 2 ⁿ -1 , trong đó n là số nguyên dương.

Nhiệm vụ của bạn là, đưa ra bất kỳ số nguyên dương nào, xác định xem đó có phải là số nguyên tố Mersenne hay không. Bạn có thể gửi một hàm trả về giá trị trung thực / sai lệch hoặc chương trình đầy đủ thực hiện IO.

Quy tắc:

• Vì đây là môn đánh gôn , bạn nên cố gắng làm điều này với số byte ngắn nhất có thể. Nội tích được cho phép.
• Áp dụng sơ hở golf tiêu chuẩn - bạn không thể đọc các số nguyên tố Mersenne từ các tệp bên ngoài hoặc mã hóa chúng vào chương trình của bạn.
• Chương trình của bạn sẽ hoạt động cho các giá trị trong kích thước số nguyên tiêu chuẩn của ngôn ngữ của bạn.

Các trường hợp thử nghiệm

Để tham khảo, một danh sách (được biết) Mersenne Primes có thể được tìm thấy ở đây . Một số trường hợp kiểm tra tiện dụng là:

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

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

_{Chúc mừng giáng sinh, mọi người! Có một kỳ nghỉ tuyệt vời, bất cứ điều gì bạn ăn mừng :)}

Thạch , 5 byte

&‘<ÆP

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

&‘<Æ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 byte

Một số dương ở dạng 2 ⁿ - 1 ở dạng nhị phân chỉ bao gồm 1's .

Mã số:

b`¹pP

Giải trình:

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

Sử dụng mã hóa CP-1252 . Hãy thử trực tuyến! hoặc Xác minh tất cả các trường hợp thử nghiệm .

Con trăn , 45 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ba thuật ngữ so sánh xích

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

làm như sau:

• -~n&ntính toán bitwise AND của n + 1 và n . Vì n chỉ bao gồm 1 bit nếu là số Mersenne, bitwise AND sẽ trả về 0 nếu (và chỉ khi) đây là trường hợp.

• all(n%i for i in range(2,n))trả về True khi và chỉ khi n mod i khác không cho tất cả các giá trị của i trong [2, Vượt, n - 1] , nghĩa là, nếu và chỉ khi n không có ước số dương ngoài 1 và n .

  Nói cách khác, tất cả trả về True khi và chỉ khi n là số tổng hợp, nghĩa là n là 1 hoặc số nguyên tố.

• n là tự giải thích.

So sánh chuỗi trả về Đúng khi và chỉ khi các so sánh riêng lẻ làm như vậy.

• Vì tất cả trả về True / 1 hoặc Sai / 0 , -~n&n<all(n%i for i in range(2,n))chỉ có thể trả về True nếu -~n&nmang lại 0 (nghĩa là, nếu n là số Mersenne) và tất cả trả về True (nghĩa là nếu n hoặc 1 hoặc một số nguyên tố).

• So sánh all(n%i for i in range(2,n))<ngiữ bất cứ khi nào n> 1 , nhưng vì tất cả trả về True nếu n = 1 , nên nó không giữ trong trường hợp này.

Brachylog , 7 byte

#p+~^h2

Hãy thử trực tuyến!

Một chương trình Brachylog về cơ bản là một chuỗi các ràng buộc tạo thành một chuỗi: ràng buộc đầu tiên là giữa đầu vào và ẩn danh (gọi nó là A cho mục đích của cuộc thảo luận này), ràng buộc thứ hai là giữa ẩn danh ẩn danh đó và ẩn danh thứ hai không biết (mà chúng ta sẽ gọi là B ), v.v. Như vậy, chương trình bị hỏng như thế này:

#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

Cách duy nhất tất cả các ràng buộc này có thể được thỏa mãn đồng thời là nếu B là lũy thừa 2, tức là đầu vào là lũy thừa 2 trừ 1, và đầu vào cũng là số nguyên tố. (Brachylog sử dụng một bộ giải ràng buộc trong nội bộ, vì vậy chương trình sẽ không hiệu quả như thứ tự đánh giá; sẽ nhận ra rằng đó Clà dạng [2, Y]trước khi nó cố gắng biểu thị Bdưới dạng lũy ​​thừa của hai số.)

Thật thú vị, #p+~^ gần như hoạt động, bởi vì các số nguyên tố giống Mersenne chỉ có thể sử dụng 2 làm cơ sở trong các trường hợp không suy biến ( bằng chứng ), nhưng a) nó không thành công cho các số nguyên tố không Mersenne B -1 vì chúng có thể được biểu thị là B và b ) trình thông dịch Brachylog hiện tại dường như bị nhầm lẫn (đi vào một vòng lặp vô hạn hoặc ít nhất là thời gian dài) bởi một chương trình bị hạn chế kém. Vì vậy, 7 byte dường như không thể bị đánh bại trong Brachylog.

Toán học 26 byte

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

Xem bằng chứng này

Hoạt động miễn là không có số hoàn hảo kỳ lạ, và không có số nào tồn tại.

Toán học, 29 26 byte

Chỉnh sửa: Đã lưu 3 byte nhờ Martin Ender

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

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

Tôi nghi ngờ điều này sẽ nhanh hơn vì 42 số mũ đầu tiên được mã hóa cứng:

MersennePrimeExponentQ@Log2[#+1]&

Perl 6 , 29 byte

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

Thử nó

Mở rộng:

{             # 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

}

vì Perl 6 có Ints lớn tùy ý, nó không đệm phía trước .base(2)với 0s.

Python, 83 82 79 76 73 byte

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

Python 2, 71 byte

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

Hàm này thực hiện kiểm tra tính nguyên thủy của Lucas Gian Lehmer , vì vậy trong khi nó không ngắn như một số dịch vụ Python khác, nó nhanh hơn nhiều trong việc xử lý các đầu vào lớn.

Đây là một số mã kiểm tra chạy trên Python 2 hoặc 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)

đầu ra

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, đây là phiên bản hiệu quả hơn một chút fmà không kiểm tra lại mtrên mỗi vòng lặp:

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 byte

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

Điều kỳ lạ là phần dựng sẵn trong R mersennemấtn làm đối số, không 2^n-1.

Cái này lấy xtừ STDIN, kiểm tra xem nó có phải là số nguyên tố khôngmatlab hay không và kiểm tra xem 2 log của x+1có phải là số nguyên hay không bằng cách lấy mod 1 và kiểm tra 'không phải là số không'.

Ngoài ra, nếu bạn sử dụng mersennenội dung, nó sẽ ngắn hơn một chút, nhưng cảm giác như gian lận:

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

Đã lưu 1 byte nhờ @Billywob

Pyke, 10 byte

_PQb2+}\1q

Hãy thử nó ở đây!

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

Trên thực tế , 9 byte

;├╔'1=@p*

Hãy thử trực tuyến!

Giải trình:

Vì mọi số của mẫu 2 ⁿ -1 có tất cả 1 trong biểu diễn nhị phân của nó, một số nguyên tố Mersenne có thể được xác định là số nguyên tố có chất lượng đó.

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

Thạch, 5 byte

Cách tiếp cận thay thế cho câu trả lời Jelly 5 byte hiện có của @Dennis:

B;ÆPP

Hãy thử trực tuyến!

Làm thế nào nó hoạt động:

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

Vì Mersenne Prime nhỏ hơn một lũy thừa 2, nên đại diện nhị phân của nó chỉ là 1 giây. Đầu ra của nó là 1 cho các số nguyên tố Mersenne và 0 trong tất cả các trường hợp khác.

Ceylon, 66 byte

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

Được định dạng (và nhận xét):

// 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;

Với gian lận (mã hóa kết quả trong phạm vi Số nguyên của Ceylon), chúng ta có thể rút ngắn một byte (65):

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

(Có vẻ như cú pháp tô sáng hiểu nhầm các chữ số hex của Ceylon là bắt đầu nhận xét.)

Nếu một hàm ẩn danh là ổn, thì hàm này là 49 byte:

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

Ngôn ngữ Wolfram (Mathicala) , 23 byte

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

Hãy thử trực tuyến!

1 được xử lý chính xác bởi vì PrimeQ[BitAnd[1,1+2]*1] == PrimeQ@1 == False. Mặt khác, BitAnd[#,#+2]#để trở thành số nguyên tố, chúng ta cần đó #là số nguyên tố và BitAnd[#,#+2] == 1, điều này xảy ra khi #là số Mersenne.

Regex ECMAScript, 42 31 byte

^(?!(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.

Hãy thử trực tuyến!

Chỉnh sửa: Xuống tới 31 byte nhờ Neil.

Bài kiểm tra "cơ bản là 2 trừ 1" cơ bản là ^(x(x*)(?=\2$))*$. Điều này hoạt động bằng cách lặp lại thao tác "trừ 1, sau đó chia đều cho 2" cho đến khi không thể thực hiện được nữa, sau đó khẳng định rằng kết quả bằng không. Điều này có thể được sửa đổi để chỉ khớp các số by1 bằng cách thay đổi số cuối cùng *thành a +, buộc vòng lặp phải lặp lại ít nhất một lần. Chèn một xtrước cuối cùng $sửa đổi nó để chỉ khớp với các số ≥3 bằng cách khẳng định rằng kết quả cuối cùng sau khi lặp ít nhất một lần là 1.

Bài kiểm tra "là sức mạnh của 2" là ^((x+)(?=\2$))*x$. Ngoài ra còn có một tốc ký cho sức mạnh phù hợp của 2 trừ 2, được phát hiện bởi Grimy : ^((x+)(?=\2$)x)*$. Cả ba regexes này đều có cùng độ dài.

Phiên bản 31 byte thay thế, bởi Grimy :

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

Hãy thử trực tuyến!

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

Regex (ECMAScript), 29 byte

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

Hãy thử trực tuyến!

Lấy cảm hứng từ Grimy trong trò chuyện

Regex khẳng định rằng đầu vào lớn hơn 3 và nó không phải là dạng: (xx+)\1+hoặc ((xx)+)(\1x)+.

Các đầu tiên phù hợp với số tổng hợp.
Số thứ hai khớp với một số nhỏ hơn 1 so với bội số của một số lẻ lớn hơn 2.

Đầu tiên sẽ không khớp với số nguyên tố, 0hoặc 1.
Thứ hai sẽ không khớp với số của mẫu$2^n-1$hoặc các số nhỏ hơn 1 số nguyên tố lẻ.

Vì 2 là số nguyên tố duy nhất nhỏ hơn 1 số nguyên tố lẻ, nên giao diện phủ định, cùng với xác nhận rằng đầu vào lớn hơn 3, sẽ chỉ khớp với các số nguyên tố mersenne.

Ruby, 47 byte

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

Julia, 26 byte

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

Python, 65 byte

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

Đầu ra thông qua Mã thoát. Lỗi đệ quy cho Sai. Không có lỗi cho True.

Làm thế nào nó hoạt động

Vì 2^n-1trong nhị phân được tạo hoàn toàn từ 1, nên 2^n-1số tiếp theo có thể được tạo bởi number|number+1.

Hàm này sử dụng điều này bằng cách đệ quy qua từng 2^n-1lần kiểm tra số để xem đó có phải là số nguyên tố và eqaul cho đầu vào không. Nếu số lượng không phải là số nguyên tố mersenne, python cuối cùng sẽ đưa ra một lỗi vì độ sâu đệ quy tối đa sẽ bị vượt quá.

Đẩy , 7 byte

oBoIpP#

Hãy thử trực tuyến!

Điều này lợi dụng thực tế là số mersenne chỉ có số trong biểu diễn nhị phân của chúng:

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

Sản phẩm ngăn xếp sẽ chỉ là 1nếu số không có số 0 trong biểu diễn nhị phân của nó và tính nguyên thủy của nó là True.

Bình thường , 8 byte

&.AjQ2P_

Xác nhận tất cả các trường hợp thử nghiệm.

Bình thường , 8 byte

<.&QhQP_

Xác nhận tất cả các trường hợp thử nghiệm.

Làm sao?

Sự cố mã số 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.

Làm thế nào mà làm việc?

Một số dạng 2 ⁿ - 1 luôn chỉ chứa 1 khi được viết ở dạng nhị phân. Do đó, chúng tôi kiểm tra nếu tất cả các chữ số nhị phân của nó là 1 và nếu nó là số nguyên tố.

Sự cố mã số 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.

Làm thế nào mà làm việc?

Điều này kiểm tra nếu đầu vào + 1 là lũy thừa của hai (tức là nếu đó là số Mersenne), sau đó thực hiện kiểm tra tính nguyên thủy. Trong Python, boollà một lớp con của int, vì vậy tính trung thực được coi là 1 và sai được coi là 0 . Để tránh kiểm tra rõ ràng rằng một là 0 và khác là 1 , chúng tôi so sánh các giá trị của chúng bằng cách sử dụng <(vì chúng tôi chỉ có 1 trường hợp như vậy).

Java 8, 53 52 49 byte

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

Đã sửa lỗi và đánh gôn bằng 4 byte nhờ @Nevay .

Giải trình:

Hãy thử nó ở đây.

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

Python 3, 68 byte

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

Hãy thử nó ở đây

Python 2, 63 byte

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

Hãy thử nó ở đây

Cảm ơn vì lời đề nghị Jonathan

Mở cho bất kỳ đề xuất để giảm bytecount.

Japt, 6 byte

¢¬×&Uj

Chạy nó hoặc chạy tất cả các trường hợp thử nghiệm

Python, 93 byte

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

Mã này sẽ hoạt động trong cả Python 2 và Python 3 vì vậy tôi chưa chỉ định phiên bản.

Vợt 76 byte

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

Ung dung:

(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))

Kiểm tra:

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

Đầu ra:

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

PHP, 53 byte

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

lấy đối số dòng lệnh; in 1cho Mersenne Prime, chuỗi trống khác. Chạy với -r.

phá vỡ

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 byte

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;}

Trả về 1 nếu số đó là Mersenne Prime, 0 nếu không.

Scala, 59 byte

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

Hàm này yêu cầu đầu vào là a BigInt. Bạn có thể dễ dàng chuyển đổi một chuỗi "162259276829213363391578010288127" (2 ** 107-1 là một số nguyên tố Mersenne) BigIntbằng cách thực hiện BigInt("162259276829213363391578010288127"). Nó có thể đi sai như tên của isProbablePrime()phương pháp cho thấy. Nhưng xác suất không hơn 0.5^(t.bigLength)*9.

Phiên bản tập lệnh độc lập dài 72 byte.

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

Giả sử chúng ta lưu nó dưới dạng "t.scala", sau đó chương trình có thể được chạy dưới dạng

>scala t.scala 162259276829213363391578010288127
>true

Perl 5 , 53 byte

52 byte mã + 1 cho -p

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

Hãy thử trực tuyến!