Um número é um Mersenne Prime se for primo e puder ser escrito no formato 2 ⁿ -1 , onde n é um número inteiro positivo.

Sua tarefa é determinar, dado qualquer número inteiro positivo, se é ou não um primo de Mersenne. Você pode enviar uma função que retorne um valor de verdade / falsidade ou um programa completo que execute E / S.

Regras:

• Como esse é o código-golfe , você deve fazer isso na menor contagem de bytes possível. Builtins são permitidos.
• Aplicam-se brechas de golfe padrão - você não pode ler os números primos de Mersenne de arquivos externos ou codificá-los em seu programa.
• Seu programa deve funcionar para valores dentro do tamanho inteiro padrão do seu idioma.

Casos de teste

Para referência, uma lista dos (conhecidos) Mersenne Primes pode ser encontrada aqui . Alguns casos de teste úteis são:

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

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

_{Feliz Natal pra todo mundo! Tenha um ótimo feriado, o que você comemora :)}

Gelatina , 5 bytes

&‘<ÆP

Experimente online!

Como funciona

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

Um número positivo na forma 2 ⁿ - 1 em binário consiste apenas de 1's .

Código:

b`¹pP

Explicação:

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

Usa a codificação CP-1252 . Experimente online! ou Verifique todos os casos de teste .

Python , 45 bytes

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

Experimente online!

Como funciona

Os três termos da comparação encadeada

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

faça o seguinte:

• -~n&ncalcula o bit a bit E de n + 1 e n . Como n consiste apenas de 1 bits, se for um número de Mersenne, o AND bit a bit retornará 0 se (e somente se) for esse o caso.

• all(n%i for i in range(2,n))retorna True se e somente se n mod i for diferente de zero para todos os valores de i em [2,…, n - 1] , ou seja, se e somente se n não tiver divisores positivos além de 1 e n .

  Em outras palavras, all retorna True se e somente se n for um número composto, ou seja, n for 1 ou um primo.

• n é auto-explicativo.

A comparação encadeada retorna True se e somente se as comparações individuais fizerem o mesmo.

• Desde todos os retornos tanto verdadeiro / 1 ou Falso / 0 , -~n&n<all(n%i for i in range(2,n))só pode retornar verdadeiro se -~n&nos rendimentos 0 (isto é, se n é um número Mersenne) e todos os retornos verdadeira (ou seja, se n seja 1 ou prime).

• A comparação all(n%i for i in range(2,n))<né válida sempre que n> 1 , mas como tudo retorna True se n = 1 , não é válido nesse caso.

Braquilog , 7 bytes

#p+~^h2

Experimente online!

Um programa Brachylog é basicamente uma sequência de restrições que formam uma cadeia: a primeira restrição é entre a entrada e um desconhecido anônimo (vamos chamá-lo de A para os fins desta discussão), a segunda restrição é entre esse desconhecido anônimo e uma segunda anônima. desconhecido (que chamaremos de B ) e assim por diante. Como tal, o programa se divide assim:

#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

A única maneira de satisfazer todas essas restrições simultaneamente é se B for uma potência de 2, ou seja, a entrada for uma potência de 2 menos 1, e a entrada também for primária. (Brachylog usa um solucionador de restrições internamente, para que o programa não seja tão ineficiente quanto a ordem da avaliação parece; ele estará ciente de que esse Cé o formato [2, Y]antes de tentar expressar Bcomo a exponenciação de dois números.)

Curiosamente, #p+~^ quase funciona, porque os primos do tipo Mersenne só podem usar 2 como base em casos não degenerados ( prova ), mas a) ele falha nos primos não-Mersenne B -1, pois podem ser expressos como B and eb ), o intérprete Brachylog existente parece estar confuso (entrando em um loop infinito ou pelo menos de longa duração) por um programa que é tão pouco restrito. Portanto, é improvável que 7 bytes sejam vencidos no Brachylog.

Mathematica 26 Bytes

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

Veja esta prova

Funciona desde que não haja números perfeitos ímpares e nenhum seja conhecido por existir.

Mathematica, 29 26 bytes

Editar: salvou 3 bytes graças a Martin Ender

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

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

Eu suspeito que isso seria mais rápido, pois os primeiros 42 expoentes são codificados:

MersennePrimeExponentQ@Log2[#+1]&

Perl 6 , 29 bytes

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

Tente

Expandido:

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

}

desde que o Perl 6 tenha Ints arbitrariamente grandes, ele não preenche a frente .base(2)com 0s.

Python, 83 82 79 76 73 bytes

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 bytes

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

Essa função implementa o teste de primalidade Lucas – Lehmer , portanto, embora não seja tão curto quanto algumas das outras ofertas em Python, é muito mais rápido no manuseio de entradas imensas.

Aqui está um código de teste que é executado no Python 2 ou 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)

saída

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, aqui está uma versão um pouco mais eficiente fque não é testada ma cada loop:

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 bytes

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

Curiosamente, o R embutido mersennetoma ncomo argumento, não 2^n-1.

Isso é feito xpelo STDIN, verifica se é primo usando o matlabpacote e verifica se o log de 2 x+1é um número inteiro, usando o mod 1 e verificando 'not zero-ness'.

Além disso, se você usar o mersennebuilt-in, ele será um pouco mais curto, mas parecerá trapaça:

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

Guardado 1 byte graças a @Billywob

Pyke, 10 bytes

_PQb2+}\1q

Experimente aqui!

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

Na verdade , 9 bytes

;├╔'1=@p*

Experimente online!

Explicação:

Como todo número da forma 2 ⁿ -1 possui todos os 1s em sua representação binária, um primo de Mersenne pode ser identificado como um número primo com essa qualidade.

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

Geléia, 5 bytes

Abordagem alternativa à resposta Jelly existente de 5 bytes do @Dennis:

B;ÆPP

Experimente online!

Como funciona:

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

Como um Mersenne Prime é um a menos que uma potência de 2, sua representação binária é excusivamente 1's. A saída é 1 para primos de Mersenne e 0 em todos os outros casos.

Ceilão, 66 bytes

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

Formatado (e comentado):

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

Com a trapaça (codificação dos resultados no intervalo do número inteiro do Ceilão), podemos obter um byte mais curto (65):

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

(Parece que o marcador de sintaxe entende os números hexadecimais do Ceilão como início de comentário.)

Se uma função anônima estiver correta, essa é 49 bytes:

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

Wolfram Language (Mathematica) , 23 bytes

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

Experimente online!

1 é tratado corretamente porque PrimeQ[BitAnd[1,1+2]*1] == PrimeQ@1 == False. Caso contrário, para BitAnd[#,#+2]#ser primo, precisamos que #seja primo e BitAnd[#,#+2] == 1, o que acontece quando #é um número de Mersenne.

Regex ECMAScript, 42 31 bytes

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

Experimente online!

Edit: Até 31 bytes, graças a Neil.

O teste básico "é uma potência de 2 menos 1" é ^(x(x*)(?=\2$))*$. Isso funciona fazendo um loop na operação "subtraia 1, depois divida uniformemente por 2" até que isso não possa mais ser feito, afirmando que o resultado é zero. Isso pode ser modificado para corresponder apenas aos números ≥1, alterando o último *para a +, forçando o loop a repetir pelo menos uma vez. Inserir um xantes do último $modifica- o ainda mais para corresponder apenas aos números ≥3, afirmando que o resultado final após o loop pelo menos uma vez é 1.

O teste "é uma potência de 2" relacionada é ^((x+)(?=\2$))*x$. Há também uma abreviação de poderes correspondentes de 2 menos 2, descobertos por Grimy :^((x+)(?=\2$)x)*$ . Todas essas três expressões regulares têm o mesmo comprimento.

Versão alternativa de 31 bytes, do Grimy :

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

Experimente online!

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

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

Experimente online!

Inspirado por Grimy no chat

A regex afirma que a entrada é maior que 3 e que não é da forma: (xx+)\1+ou ((xx)+)(\1x)+.

O primeiro corresponde a números compostos.
O segundo corresponde a um número 1 menor que um múltiplo de algum número ímpar maior que 2.

01
$2^n-1$ ou números 1 a menos que um primo ímpar.

Como 2 é o único primo que é 1 menor que um ímpar ímpar, a cabeça negativa, juntamente com a afirmação de que a entrada é maior que 3, corresponderá apenas aos primos mersenne.

Ruby, 47 bytes

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

Julia, 26 bytes

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

Python, 65 bytes

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

Saídas via código de saída. Erro de recursão para falso. Nenhum erro para True.

Como funciona

Como 2^n-1no binário é feito inteiramente de 1, o próximo 2^n-1número pode ser gerado por number|number+1.

Essa função usa isso percorrendo recursivamente cada 2^n-1número, verificando se é um número primo e eqaul para a entrada. Se o número não for um primo de Mersenne, o python acabará gerando um erro, pois a profundidade máxima da recursão teria sido excedida.

Pushy , 7 bytes

oBoIpP#

Experimente online!

Isso tira vantagem do fato de que os números de Mersenne têm apenas um em sua representação binária:

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

O produto da pilha será apenas 1se o número não tiver zeros em sua representação binária e sua primalidade for True.

Pitão , 8 bytes

&.AjQ2P_

Verifique todos os casos de teste.

Pitão , 8 bytes

<.&QhQP_

Verifique todos os casos de teste.

Quão?

Divisão de código # 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.

Como isso funciona?

Um número do formato 2 ⁿ - 1 sempre contém 1 somente quando escrito em binário. Portanto, testamos se todos os seus dígitos binários são 1 e se são primos.

Divisão de código # 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.

Como isso funciona?

Isso testa se a entrada + 1 é uma potência de dois (ou seja, se é um número de Mersenne) e, em seguida, executa o teste de primalidade. Em Python, boolé uma subclasse de int, então a verdade é tratada como 1 e a falsidade é tratada como 0 . Para evitar verificar explicitamente se um é 0 e o outro é 1 , comparamos seus valores usando <(já que temos apenas 1 caso).

Java 8, 53 52 49 bytes

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

Correção de bugs e golfed por 4 bytes graças ao @Nevay .

Explicação:

Experimente aqui.

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 bytes

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

Experimente aqui

Python 2, 63 bytes

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

Experimente aqui

Obrigado pela sugestão Jonathan

Abra todas as sugestões para reduzir o número de bytes.

Japonês, 6 bytes

¢¬×&Uj

Executar ou executar todos os casos de teste

Python, 93 bytes

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

Esse código funcionaria no Python 2 e no Python 3, portanto não especifiquei uma versão.

Raquete 76 bytes

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

Ungolfed:

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

Teste:

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

Saída:

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

PHP, 53 bytes

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

aceita argumento de linha de comando; imprime 1para Mersenne prime, string vazio. Corra com -r.

demolir

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 bytes

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

Retorna 1 se o número for um Mersenne Prime, 0 caso contrário.

Scala, 59 Bytes

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

Esta função requer que a entrada seja a BigInt. Você pode converter facilmente uma sequência "162259276829213363391578010288127" (2 ** 107-1 é um primer de Mersenne) BigIntfazendo isso BigInt("162259276829213363391578010288127"). Pode dar errado, como o nome do isProbablePrime()método sugere. Mas a probabilidade não é maior que 0.5^(t.bigLength)*9.

A versão do script independente tem 72 bytes.

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

Suponha que o salvemos como "t.scala" e, em seguida, o programa pode ser executado como

>scala t.scala 162259276829213363391578010288127
>true

Perl 5 , 53 bytes

52 bytes de código + 1 para -p

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

Experimente online!