如果数字既是素数又可以以2 ⁿ -1的形式书写，则该数字就是梅森素数，其中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编码。在线尝试！或验证所有测试用例。

Python，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&n计算n +1和n的按位与。由于如果n是一个梅森数，则n仅由1个位组成，因此，当（且仅当）这种情况下，按位与将返回0。

• all(n%i for i in range(2,n))返回真当且仅当N模我是非零对的所有值我在[2，...，N - 1] ，即，如果且仅当Ñ无正除数除了1和Ñ。

  换句话说，当且仅当n是一个复数，即n为1或质数时，all都返回True。

• n 是不言自明的。

当且仅当单个比较执行相同时，链接比较才返回True。

• 因为所有返回任一真 / 1或假 / 0，-~n&n<all(n%i for i in range(2,n))只能返回真，如果-~n&n产率0（即，如果Ñ是梅森数）和所有返回真（即，如果Ñ或者1或素数）。

• 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

有趣的是，#p+~^ 几乎可以工作，因为梅森状素数只能使用2作为在非简并情况下（基证明），但a）其发生故障的非梅森素数乙 -1，因为它们可以表示为乙 ¹，和b ）现有的Brachylog解释器似乎受到约束不严格的程序的迷惑（进入无限循环，或至少是长时间循环）。因此，在Brachylog中似乎不太可能击败7个字节。

Mathematica 26字节

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

看到这个证明

只要没有奇数完美的数字，并且不存在已知的完美数字，就可以工作。

Mathematica，29 26字节

编辑：感谢马丁·恩德节省了3个字节

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

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

我怀疑这会更快，因为前42个指数是硬编码的：

MersennePrimeExponentQ@Log2[#+1]&

Perl 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

}

由于Perl 6具有任意大的Ints，因此不会.base(2)用0s 填充其前面。

Python，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

Python 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素数测试，因此虽然它不像其他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。

这x取自STDIN，使用matlab软件包检查它是否为质x+1数，并通过取mod 1并检查“非零”来检查2的对数是否为整数。

另外，如果您使用mersenne内置函数，则最终会略短一些，但感觉就像作弊：

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

@Billywob节省了1个字节

Pyke，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

由于Mersenne Prime比2的幂小1，因此其二进制表示形式恰好是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;

通过作弊（将结果硬编码在Ceylon的Integer范围内），我们可以获得一个较短的字节（65）：

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

（似乎语法突出显示功能误解了锡兰的十六进制数字作为注释的开始。）

如果可以使用匿名函数，则该字节为49个字节：

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

Wolfram语言（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.

在线尝试！

编辑：感谢尼尔，减少到31个字节。

基本的“是2的幂减去1”的测试是^(x(x*)(?=\2$))*$。这是通过循环操作“减去1，然后平均除以2”直到无法进行进一步处理，然后断言结果为零来进行的。通过将最后*一个更改为a +，可以强制循环至少迭代一次，可以将其修改为仅匹配≥1的数字。通过在循环中至少循环一次后得出的最终结果为1.，在最后一个值x之前插入一个$进一步修改它以使其仅匹配数字≥3。

相关的“是2的幂”检验是^((x+)(?=\2$))*x$。格里米（Grimy）发现了一个匹配2减2的幂的简写：^((x+)(?=\2$)x)*$。这三个正则表达式的长度均相同。

替代的31字节版本，由Grimy撰写：

^(?!(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)+。

第一个匹配复合数字。
第二个匹配的数字小于1，大于一个大于2的奇数的倍数。

01
$2^n-1$

由于2是唯一的比奇数素数小1的素数，因此负前瞻以及输入大于3的断言将仅匹配mersenne素数。

Ruby，47个字节

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

朱莉娅，26个字节

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

Python，65个字节

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

通过退出代码输出。递归错误为False。对于True，没有错误。

怎么运行的

由于2^n-1二进制完全由1组成，因此下一个2^n-1数字可以由生成number|number+1。

此函数通过递归地2^n-1检查每个数字以查看其是否为质数和输入等式来使用此功能。如果该数字不是mersenne质数，则python最终将引发错误，因为将超过最大递归深度。

Pushy，7个字节

oBoIpP#

在线尝试！

充分利用了mersenne数字在其二进制表示形式中只有一个的事实：

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当数字的二进制表示形式中没有零且其素数为时，堆栈乘积才会为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 ⁿ -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，因此将true视为1并将falsy视为0。为了避免显式检查一个为0且另一个为1，我们使用<（因为我们只有1个这样的情况）比较它们的值。

Java 8，53 52 49字节

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

错误修正，并通过由于4个字节golfed @Nevay。

说明：

在这里尝试。

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个字节

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

在这里尝试

Python 2，63个字节

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

在这里尝试

感谢您的建议乔纳森

公开有关减少字节数的任何建议。

Japt，6个字节

¢¬×&Uj

运行它或运行所有测试用例

Python，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);

接受命令行参数；打印1Mersenne素数，其他为空字符串。用运行-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。

Scala，59字节

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

此函数要求输入为BigInt。您可以轻松地将字符串“ 162259276829213363391578010288127”（2 ** 107-1是Mersenne质数）转换为BigIntby 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

Perl 5，53个字节

52个字节的代码+ 1个 -p

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

在线尝试！