Her ikisi de asal ise ve n'nin pozitif bir tamsayı olduğu 2 ^n- 1 biçiminde yazılabilirse , bir sayı bir Mersenne Prime'dır .

Göreviniz, pozitif bir tamsayı verildiğinde, bunun bir Mersenne üssü olup olmadığını belirlemektir. Ya bir truthy / falsy değeri döndüren bir işlev ya da IO gerçekleştiren tam bir program gönderebilirsiniz.

Kurallar:

• Bu kod-golf olduğundan , bunu mümkün olan en kısa bayt sayısında yapmayı hedeflemelisiniz . Yerleşiklere izin verilir.
• Standart golf boşlukları geçerlidir - Mersenne primelarını harici dosyalardan okuyamaz veya programınıza kodlayamazsınız.
• Programınız, dilinizin standart tamsayı boyutundaki değerler için çalışmalıdır.

Test Kılıfları

Başvuru için, (bilinen) Mersenne Primes listesi burada bulunabilir . Bazı kullanışlı test durumları:

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

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

_{Herkese mutlu noeller! Ne kutlarsanız kutlayın, iyi tatiller :)}

Jöle , 5 bayt

&‘<ÆP

Çevrimiçi deneyin!

Nasıl çalışır

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

Şekilde bir pozitif sayı 2 ^{, n} 1 - ikili sadece oluşur 1 's .

Kod:

b`¹pP

Açıklama:

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 kodlamasını kullanır . Çevrimiçi deneyin! veya Tüm test durumlarını doğrulayın .

Python , 45 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

Zincirleme karşılaştırmanın üç terimi

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

aşağıdakileri yapın:

• -~n&nn + 1 ve n'in bit cinsinden AND değerini hesaplar . Yana n sadece oluşur 1 bir Mersenne sayısı, bitler halinde VE dönecektir eğer bit 0 ise (ve ancak) bu böyledir.

• all(n%i for i in range(2,n))döner doğru ancak ve ancak i n mod tüm değerleri için, sıfır olmayan bir i içinde [2, ..., n - 1] , yani ancak ve ancak , n dışında pozitif bölenler sahip 1 ve n .

  Bir başka deyişle, tüm döner Gerçek ancak ve ancak n bir bileşik sayı, yani, n ya olan 1 ya da asal.

• n açıklayıcıdır.

Zincirleme karşılaştırma, eğer münferit karşılaştırmalar aynı yaparsa True döndürür .

• İtibaren tüm geri dönüş ya Doğru / 1 ya da yanlış / 0 , -~n&n<all(n%i for i in range(2,n))sadece dönebilir doğru ise -~n&nverimler 0 (yani, eğer , n , bir Mersenne sayıdır) ve bütün döner doğru (diğer bir deyişle, eğer , n , ya 1 ya da birincil).

• Karşılaştırma n> 1all(n%i for i in range(2,n))<n olduğunda geçerlidir , fakat n = 1 ise hepsi True döndürdüğü için bu durumda geçerli değildir.

Brachylog , 7 bayt

#p+~^h2

Çevrimiçi deneyin!

Bir Brachylog programı temel olarak bir zincir oluşturan bir dizi kısıtlamadır: ilk kısıtlama, giriş ve bilinmeyen bir isimsiz arasındadır (hadi bu tartışmanın amacı için A diyelim ), ikinci kısıtlama bu isimsiz bilinmeyen ile ikinci isimsiz arasındadır. bilinmeyen ( B dediğimiz ) vb. Gibi, program böyle yıkılır:

#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

Tüm bu kısıtlamaları aynı anda yerine getirmenin tek yolu, B'nin 2'nin gücü olması, yani girişin 2 eksi 1'in gücü olması ve girişin de asıl olmasıdır. (Brachylog dahili olarak bir kısıtlayıcı çözücü kullanır, bu nedenle program değerlendirme sırasının göründüğü kadar verimsiz olmayacaktır; iki sayının üstelleşmesi olarak ifade etmeye çalışmadan önce Cformda olduğunun farkında olacaktır .)[2, Y]B

İlginç bir şekilde, #p+~^ hemen hemen Mersenne gibi asal sadece dejenere olmayan durumlarda (baz olarak 2 kullanabilir, çünkü çalışır geçirmez ), ancak a) başarısız olmayan Mersenne asal B -1 bunlar olarak ifade edilebilir B ¹, ve b ) mevcut Brachylog tercümanının, kısıtlı olmayan bir program tarafından karıştırılması (sonsuz veya en azından uzun süreli bir döngü içine girme) gibi görünüyor. Yani, 7 byte Brachylog'da yenilmiş gibi görünmüyor.

Mathematica 26 Bayt

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

Bu kanıtı görün

Tek mükemmel rakamlar olmadığı ve hiçbirinin var olduğu bilinmediği sürece çalışır.

Mathematica, 29 26 bayt

Düzenleme: Martin Ender sayesinde 3 bayt kaydedildi

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

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

İlk 42 üst kodun kodlanmasından bu yana daha hızlı olacağını düşünüyorum:

MersennePrimeExponentQ@Log2[#+1]&

Perl 6 , 29 bayt

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

Dene

Expanded:

{             # 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 keyfi büyük Int'lere sahip olduğundan, önünü s .base(2)ile doldurmaz 0.

Python, 83 82 79 76 73 bayt

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 bayt

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

Bu işlev Lucas-Lehmer ilkellik testini uygular , bu nedenle diğer Python tekliflerinden bazıları kadar kısa olmasa da , büyük girdilerin işlenmesinde çok daha hızlıdır.

İşte Python 2 veya Python 3 üzerinde çalışan bazı test kodları.

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)

çıktı

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, işte bu , her döngüde fyeniden test etmeyen , biraz daha verimli bir sürümü 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 bayt

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

Garip R yerleşik mersennealır n, argüman olarak değil 2^n-1.

Bu x, STDIN'den alır , matlabpaketi kullanarak asal olup olmadığını kontrol eder ve x+1mod 1'i alıp 'sıfır değil' olup olmadığını kontrol ederek 2 log'unun bir tam sayı olup olmadığını kontrol eder.

Ayrıca, mersenneyerleşik yapıyı kullanırsanız, biraz daha kısa kalır, ancak aldatma gibi hissettirir:

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

@Billywob sayesinde 1 bayt kaydedildi

Pyke, 10 bayt

_PQb2+}\1q

Burada dene!

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

Aslında 9 bayt

;├╔'1=@p*

Çevrimiçi deneyin!

Açıklama:

Form 2 ^n- 1'in her sayısı , ikili temsilinde 1'lerin hepsine sahip olduğundan, bir Mersenne primi bu kalitede bir asal sayı olarak tanımlanabilir.

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

Jöle, 5 bayt

@Dennis'in mevcut 5-byte Jelly cevabına alternatif bir yaklaşım:

B;ÆPP

Çevrimiçi deneyin!

Nasıl çalışır:

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

Bir Mersenne Prime 2 güçten daha az olduğu için, ikili gösterimi münhasır 1'dir. Buradaki çıktı Mersenne primerleri için 1, diğer tüm durumlarda 0'dır.

Seylan, 66 bayt

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

Biçimlendirildi (ve yorumlandı):

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

Hile yaparak (sonuçları Ceylon's Integer aralığında kodlayarak), baytı kısaltır (65):

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

(Sözdizimi vurgulayıcısına benziyor, Ceylon'un onaltılık sayılarını yorum başlangıcı olarak yanlış anlıyor.)

Anonim bir işlev tamamsa, bu işlev 49 bayttır:

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

Wolfram Dili (Mathematica) , 23 bayt

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

Çevrimiçi deneyin!

1 doğru işlenir çünkü PrimeQ[BitAnd[1,1+2]*1] == PrimeQ@1 == False. Aksi halde, BitAnd[#,#+2]#asal olmak için bunun #bir asal olması ve bir Mersenne sayısı BitAnd[#,#+2] == 1olduğunda #olması gerekir.

ECMAScript regex, 42 31 bayt

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

Çevrimiçi deneyin!

Düzenleme: Neil sayesinde 31 bayta kadar.

Temel "2 eksi 1 gücüdür" testidir ^(x(x*)(?=\2$))*$. Bu, "çıkarma 1" işleminin daha sonra yapılması mümkün olmayana kadar eşit olarak bölünerek "2'ye bölünerek çalışır, sonra sonucun sıfır olduğunu iddia eder. Bu son değiştirerek ≥1 yalnızca sayıları eşleşecek şekilde modifiye edilebilir *bir karşı +bir kez en az yineleme için döngü zorlayarak,. xEn sondan önce bir $ek eklemek, en az bir kez döngülendikten sonra nihai sonucun 1 olduğunu iddia ederek sadece numbers3 sayıları ile eşleşmesini sağlar.

İlgili "2 bir güçtür" testidir ^((x+)(?=\2$))*x$. Tarafından keşfedilen 2 eksi 2 eşleşen güçler için bir kestirme bulunmaktadır Güvenlik çok kötü : ^((x+)(?=\2$)x)*$. Bu regexlerin üçü de aynı uzunluktadır.

Grimy tarafından alternatif 31 bayt versiyonu :

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

Grimy'den sohbette ilham aldı

Düzenli ifade, girişin 3'ten büyük olduğunu ve hiçbir şekilde: (xx+)\1+ya da olmadığını belirtir ((xx)+)(\1x)+.

İlk bileşik sayıları eşleştirir.
İkincisi, 2'den büyük olan bazı tek sayıların bir katından 1'den küçük bir sayı ile eşleşir.

01
$2^n-1$

2, tek bir asaldan 1 daha az olan tek asal olduğundan, negatif görünüm, girişin 3'ten büyük olduğu iddiasıyla birlikte, yalnızca mersenne primleriyle eşleşir.

Ruby, 47 bayt

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

Julia, 26 bayt

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

Python, 65 bayt

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

Çıkış Kodu ile çıkış yapar. Yanlış için Özyineleme Hatası. True için hata yok.

Nasıl çalışır

Yana 2^n-1ikili olarak 1 den tamamen yapılmış, bir sonraki 2^n-1numara ile üretilebilir number|number+1.

Bu işlev 2^n-1bunu asal bir sayı olup olmadığını görmek için her sayı kontrolünden tekrar tekrar geçerek bunu kullanır . Sayı bir mersenne üssü değilse, python, en fazla özyineleme derinliği aşılmış olacağı için nihayetinde bir hata atar.

Pushy , 7 bayt

oBoIpP#

Çevrimiçi deneyin!

Bu, mersenne sayılarının sadece ikili gösterimlerinde bulunanlara sahip olmasından yararlanır:

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

Yığın ürün, yalnızca 1sayının ikili gösteriminde sıfır değeri yoksa ve olacaktır True.

Pyth , 8 bayt

&.AjQ2P_

Tüm test durumlarını doğrulayın.

Pyth , 8 bayt

<.&QhQP_

Tüm test durumlarını doğrulayın.

Nasıl?

Kod Dağılımı # 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.

Bu nasıl çalışıyor?

2 ⁿ - 1 formunun bir numarası her zaman sadece ikili olarak yazıldığında 1 içerir . Bu nedenle, tüm ikili basamaklarının 1 olup olmadığını ve asal olup olmadığını test ediyoruz .

Kod Dağılımı # 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.

Bu nasıl çalışıyor?

Bu, + 1 girişinin iki gücünün olup olmadığını test eder (yani, bir Mersenne numarası ise) ve ardından birincillik testini gerçekleştirir. Python'da, boolbir alt intsınıftır, yani truthy 1 olarak kabul edilir ve sahte, 0 olarak değerlendirilir . Açıkça birinin 0 , diğeri 1 olduğunu kontrol etmekten kaçınmak için , değerlerini kullanarak karşılaştırırız <(çünkü bu durumda sadece 1 vakamız vardır).

Java 8, 53 52 49 bayt

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

Hata düzeltildi ve @Nevay sayesinde 4 byte golf oynadı .

Açıklama:

Burada dene.

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 bayt

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

Burada dene

Python 2,63 bayt

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

Burada dene

Öneri Jonathan için teşekkürler

Bayt sayısını azaltmak için her türlü öneriye açın.

Japt, 6 bayt

¢¬×&Uj

Çalıştır ya da tüm test vakalarını çalıştır

Python, 93 Bayt

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

Bu kod hem Python 2 hem de Python 3'te çalışır, bu yüzden bir sürüm belirtmedim.

Raket 76 bayt

(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 yapmak:

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

Çıktı:

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

PHP, 53 bayt

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

komut satırı argümanı alır; 1Mersenne asal, boş dize için yazdırır . İle koş -r.

Yıkmak

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 bayt

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

Sayı bir Mersenne Prime ise 1, aksi takdirde 0 döndürür.

Scala, 59 Bayt

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

Bu fonksiyon girişin a olmasını gerektirir BigInt. Kolayca içine bir dize "162259276829213363391578010288127" (2 ** 107-1 bir Mersenne asal) dönüştürebilirsiniz BigIntyaparak BigInt("162259276829213363391578010288127"). isProbablePrime()Yöntemin adından da anlaşılacağı gibi yanlış gidebilir . Fakat olasılık, fazla değil 0.5^(t.bigLength)*9.

Bağımsız komut dosyası sürümü 72 bayt uzunluğundadır.

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

Bunu "t.scala" olarak kaydettiğimizi varsayalım, ardından program olarak çalıştırılabilir.

>scala t.scala 162259276829213363391578010288127
>true

Perl 5 , 53 bayt

İçin 52 baytlık kod + 1 -p

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

Çevrimiçi deneyin!