Un numero è un Mersenne Prime se è sia primo che può essere scritto nella forma 2 ⁿ -1 , dove n è un numero intero positivo.

Il tuo compito è, dato qualsiasi numero intero positivo, determinare se si tratta o meno di un numero primo di Mersenne. È possibile inviare una funzione che restituisce un valore di verità / falsa o un programma completo che esegue IO.

Regole:

• Dato che si tratta di code-golf , dovresti mirare a farlo nel minor numero di byte possibile. Sono ammessi i builtin.
• Si applicano scappatoie da golf standard: non è possibile leggere i numeri primi di Mersenne da file esterni o codificarli nel programma.
• Il tuo programma dovrebbe funzionare per valori all'interno della dimensione intera standard della tua lingua.

Casi test

Per riferimento, un elenco di (noti) Primi di Mersenne può essere trovato qui . Alcuni pratici casi di test sono:

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

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

_{Buon Natale a tutti! Buone vacanze, qualunque cosa tu festeggi :)}

Gelatina , 5 byte

&‘<ÆP

Provalo online!

Come funziona

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

Un numero positivo nella forma 2 ⁿ - 1 in binario è costituito solo da 1 .

Codice:

b`¹pP

Spiegazione:

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

Utilizza la codifica CP-1252 . Provalo online! oppure Verifica tutti i casi di test .

Python , 45 byte

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

Provalo online!

Come funziona

I tre termini del confronto incatenato

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

eseguire le seguenti operazioni:

• -~n&ncalcola l'AND bit a bit di n + 1 e n . Poiché n è costituito esclusivamente da 1 bit se è un numero di Mersenne, AND bit a bit restituirà 0 se (e solo se) questo è il caso.

• all(n%i for i in range(2,n))restituisce True se e solo se n mod i è diverso da zero per tutti i valori di i in [2,…, n - 1] , ovvero se e solo se n non ha divisori positivi a parte 1 e n .

  In altre parole, tutto restituisce True se e solo se n è un numero composto, ovvero n è 1 o un numero primo.

• n è autoesplicativo.

Il confronto concatenato restituisce True se e solo se i singoli confronti fanno lo stesso.

• Dal momento che tutti i rendimenti sia Vero / 1 o False / 0 , -~n&n<all(n%i for i in range(2,n))possono restituire solo vero se -~n&ni rendimenti 0 (vale a dire, se n è un numero di Mersenne) e di tutti i rendimenti vero (vale a dire, se n o 1 o un numero primo).

• Il confronto all(n%i for i in range(2,n))<nvale ogni volta che n> 1 , ma poiché tutto restituisce True se n = 1 , in questo caso non vale.

Brachylog , 7 byte

#p+~^h2

Provalo online!

Un programma Brachylog è fondamentalmente una sequenza di vincoli che formano una catena: il primo vincolo è tra l'input e uno sconosciuto anonimo (chiamiamolo A ai fini di questa discussione), il secondo vincolo è tra quell'ignoto anonimo e un secondo anonimo sconosciuto (che chiameremo B ) e così via. Pertanto, il programma si interrompe in questo modo:

#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

L'unico modo in cui tutti questi vincoli possono essere soddisfatti simultaneamente è se B è una potenza di 2, ovvero l'ingresso è una potenza di 2 meno 1 e anche l'ingresso è primo. (Brachylog usa internamente un risolutore di vincoli, quindi il programma non sarà inefficiente come sembra l'ordine di valutazione; sarà consapevole che Cè del modulo [2, Y]prima di provare ad esprimere Bcome l'esponenziazione di due numeri.)

È interessante notare che #p+~^ quasi funziona, perché i numeri primi simili a Mersenne possono usare solo 2 come base in casi non degeneri ( prova ), ma a) falliscono per i numeri primi non Mersenne B -1 in quanto possono essere espressi come B ¹ eb ) l'interprete Brachylog esistente sembra essere confuso (andando in un ciclo infinito, o almeno di lunga durata) da un programma che è così poco vincolato. Quindi è improbabile che 7 byte vengano battuti in Brachylog.

Mathematica 26 byte

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

Vedi questa prova

Funziona fino a quando non ci sono numeri perfetti dispari e nessuno è noto per esistere.

Mathematica, 29 26 byte

Modifica: salvato 3 byte grazie a Martin Ender

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

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

Sospetto che questo sarebbe più veloce poiché i primi 42 esponenti sono codificati:

MersennePrimeExponentQ@Log2[#+1]&

Perl 6 , 29 byte

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

Provalo

Allargato:

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

}

poiché Perl 6 ha Ints arbitrariamente grandi, non riempie la parte anteriore di .base(2)con 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

Questa funzione implementa il test di primalità di Lucas – Lehmer , quindi sebbene non sia così breve come alcune delle altre offerte di Python, è molto più veloce nella gestione di immensi input.

Ecco un po 'di codice di test che funziona su Python 2 o 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)

produzione

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, ecco una versione leggermente più efficiente fche non riprova msu ogni 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 byte

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

Stranamente l'integrato in R mersenneprende ncome argomento, non 2^n-1.

Questo prende xda STDIN, controlla se è primo usando il matlabpacchetto e controlla se il 2-log di x+1è un numero intero prendendo mod 1 e controllando "non zero-ness".

Inoltre, se si utilizza il mersennebuilt-in, finisce per essere leggermente più corto, ma sembra imbrogliare:

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

Salvato 1 byte grazie a @Billywob

Pyke, 10 byte

_PQb2+}\1q

Provalo qui!

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

In realtà , 9 byte

;├╔'1=@p*

Provalo online!

Spiegazione:

Poiché ogni numero della forma 2 ⁿ -1 ha tutti 1 nella sua rappresentazione binaria, un numero primo di Mersenne può essere identificato come un numero primo con quella qualità.

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

Gelatina, 5 byte

Approccio alternativo alla risposta Jelly a 5 byte esistente di @Dennis:

B;ÆPP

Provalo online!

Come funziona:

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

Poiché un Mersenne Prime è uno in meno di una potenza di 2, la sua rappresentazione binaria è eccezionalmente di 1. Il risultato è 1 per i primi di Mersenne e 0 in tutti gli altri casi.

Ceylon, 66 byte

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

Formattato (e commentato):

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

Con i trucchi (hardcoding dei risultati nell'intervallo di Ceylon's Integer), possiamo ottenere un byte più breve (65):

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

(Sembra che l'evidenziatore della sintassi fraintenda i numeri esadecimali di Ceylon come inizio del commento.)

Se una funzione anonima va bene, questa è di 49 byte:

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

Wolfram Language (Mathematica) , 23 byte

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

Provalo online!

1 è gestito correttamente perché PrimeQ[BitAnd[1,1+2]*1] == PrimeQ@1 == False. Altrimenti, per BitAnd[#,#+2]#essere primi, abbiamo bisogno che #sia primo e BitAnd[#,#+2] == 1, che accade quando #è un numero di Mersenne.

ECMAScript regex, 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.

Provalo online!

Modifica: fino a 31 byte grazie a Neil.

Il test di base "è una potenza di 2 meno 1" è ^(x(x*)(?=\2$))*$. Funziona eseguendo il ciclo "sottrai 1, quindi dividi uniformemente per 2" fino a quando non può essere eseguito ulteriormente, quindi affermando che il risultato è zero. Questo può essere modificato per far corrispondere solo i numeri ≥1 cambiando l'ultimo *in a +, forzando l'iterazione del loop almeno una volta. L'inserimento di un xprecedente all'ultimo $lo modifica ulteriormente in modo che corrisponda solo ai numeri ≥3 affermando che il risultato finale dopo il loop almeno una volta è 1.

Il relativo test "è una potenza di 2" è ^((x+)(?=\2$))*x$. C'è anche una scorciatoia per corrispondenti potenze di 2 meno 2, scoperti da Grimy : ^((x+)(?=\2$)x)*$. Tutti e tre questi regex sono della stessa lunghezza.

Versione alternativa a 31 byte, di Grimy :

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

Provalo 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 byte

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

Provalo online!

Ispirato da Grimy in chat

Il regex afferma che l'input è maggiore di 3 e che non è né della forma: (xx+)\1+o ((xx)+)(\1x)+.

Il primo corrisponde a numeri composti.
Il secondo corrisponde a un numero che è 1 in meno di un multiplo di un numero dispari maggiore di 2.

01
$2^n-1$

Poiché 2 è l'unico numero primo che è 1 in meno di un numero dispari, il punto di vista negativo, insieme all'asserzione che l'input è maggiore di 3, corrisponderà solo ai numeri primi di mersenne.

Rubino, 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)

Uscite tramite il codice di uscita. Errore di ricorsione per falso. Nessun errore per True.

Come funziona

Poiché 2^n-1in binario è composto interamente da 1, il 2^n-1numero successivo può essere generato da number|number+1.

Questa funzione lo utilizza 2^n-1esaminando ricorsivamente ciascun numero per verificare se si tratta di un numero primo ed eqaul nell'input. Se il numero non è un numero primo di mersenne, Python alla fine genererà un errore poiché la profondità massima di ricorsione sarebbe stata superata.

Pushy , 7 byte

oBoIpP#

Provalo online!

Questo sfrutta il fatto che i numeri di mersenne ne hanno solo uno nella loro rappresentazione binaria:

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

Il prodotto stack sarà solo 1se il numero non ha zeri nella sua rappresentazione binaria e la sua primalità è True.

Pyth , 8 byte

&.AjQ2P_

Verifica tutti i casi di test.

Pyth , 8 byte

<.&QhQP_

Verifica tutti i casi di test.

Come?

Codice n. 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.

Come funziona?

Un numero del modulo 2 ⁿ - 1 contiene sempre 1 solo se scritto in binario. Quindi, testiamo se tutte le sue cifre binarie sono 1 e se è primo.

Codice n. 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.

Come funziona?

Questo verifica se l' ingresso + 1 è una potenza di due (cioè se è un numero di Mersenne), quindi esegue il test di primalità. In Python, boolè una sottoclasse di int, quindi la verità è trattata come 1 e la falsa è trattata come 0 . Per evitare di verificare esplicitamente che uno sia 0 e l'altro sia 1 , confrontiamo i loro valori usando <(poiché abbiamo solo 1 caso del genere).

Java 8, 53 52 49 byte

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

Bug risolto e golfato da 4 byte grazie a @Nevay .

Spiegazione:

Provalo qui.

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

Provalo qui

Python 2, 63 byte

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

Provalo qui

Grazie per il suggerimento Jonathan

Aperto a qualsiasi suggerimento per ridurre il numero di dipendenti.

Japt, 6 byte

¢¬×&Uj

Eseguilo o esegui tutti i casi di test

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

Questo codice funzionerebbe sia in Python 2 che in Python 3, quindi non ho specificato una versione.

Racchetta 76 byte

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

test:

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

Produzione:

#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);

accetta l'argomento della riga di comando; stampe 1per Mersenne prime, stringa vuota altro. Corri con-r .

abbattersi

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

Restituisce 1 se il numero è un Mersenne Prime, 0 altrimenti.

Scala, 59 byte

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

Questa funzione richiede che l'ingresso sia a BigInt. Puoi facilmente convertire una stringa "162259276829213363391578010288127" (2 ** 107-1 è un numero primo di Mersenne) BigIntfacendo BigInt("162259276829213363391578010288127"). Potrebbe andare storto come il nome diisProbablePrime() suggerisce metodo. Ma la probabilità non è maggiore di0.5^(t.bigLength)*9 .

La versione dello script autonomo è lunga 72 byte.

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

Supponiamo di salvarlo come "t.scala", quindi il programma può essere eseguito come

>scala t.scala 162259276829213363391578010288127
>true

Perl 5 , 53 byte

52 byte di codice + 1 per -p

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

Provalo online!