एक संख्या एक Mersenne प्राइम है यदि यह दोनों अभाज्य है और इसे फॉर्म 2 ⁿ -1 में लिखा जा सकता है , जहाँ n एक धनात्मक पूर्णांक है।

आपका कार्य है, किसी भी सकारात्मक पूर्णांक को देखते हुए, यह निर्धारित करना कि वह मेरसेन प्राइम है या नहीं। आप या तो एक फ़ंक्शन सबमिट कर सकते हैं जो एक सत्य / मिथ्या मान लौटाता है, या एक पूर्ण कार्यक्रम जो आईओ करता है।

नियम:

जैसा कि यह कोड-गोल्फ है , आपको इसे कम से कम बाइट काउंट संभव करने के लिए करना चाहिए । बिल बनाने की अनुमति है।
स्टैंडर्ड गोल्फिंग लूपहोल्स लागू होते हैं - आप बाहरी फाइलों से मेरसेन प्राइम नहीं पढ़ सकते हैं, या उन्हें अपने प्रोग्राम में हार्डकोड कर सकते हैं।
आपका कार्यक्रम आपकी भाषा के मानक पूर्णांक आकार के भीतर मूल्यों के लिए काम करना चाहिए।

परीक्षण के मामलों

संदर्भ के लिए, (ज्ञात) Mersenne Primes की एक सूची यहां पाई जा सकती है । कुछ आसान परीक्षण मामले हैं:

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

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

_{क्रिसमस की शुभकामनायें! एक महान छुट्टी है, जो भी आप मनाते हैं :)}

— FlipTack
स्रोत

2

अगर मैं इसे isprime चुनौती के एक ठिकाने के रूप में वोट कर सकता था , क्योंकि यह वास्तव में कुछ नया नहीं जोड़ता है।

— दोष

9

@flawr वे बहुत समान हैं - लेकिन इस चुनौती के लिए, एक बिल्डिन होने की संभावना कम है और यह निर्धारित करने के लिए बहुत सारे दिलचस्प दृष्टिकोण हैं कि क्या संख्या एक के रूप में प्रतिनिधित्व करने योग्य है2^n-1

— FlipTack

1

मेरा मानना है कि मेरसेन संख्या की परिभाषा यह भी है कि n अभाज्य हो (एक शर्त जो आवश्यक भी सिद्ध हुई हो, लेकिन पर्याप्त नहीं है, (2 ^ n) -1 अभाज्य होने के लिए।)

— SuperJedi224

4

@ SuperJedi224 nहमेशा प्रमुख होता है, लेकिन यह जानते हुए कि कुछ भी नहीं बदलता है, परिभाषा अभी भी सही है।

— फ्लिपकैक

2

@ TheBitByte हाँ - यदि आप कुछ संभावना-आधारित एल्गोरिथ्म को लागू कर रहे हैं जो 100% समय तक काम नहीं करता है, तो आप इसे अभी भी पोस्ट कर सकते हैं, लेकिन यह प्रतिस्पर्धा में नहीं होगा :)

— FlipTack

19

जेली , 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.

— डेनिस
स्रोत

अदनान के जवाब के रूप में एक ही मुद्दा। देखें mothereff.in/byte-counter

— केली Lowder

8

@ केलीलॉडर उस बाइट काउंटर का उपयोग यूटीएफ -8 करता है। जेली और 05AB1E दोनों सिंगल बाइट कैरेक्टर सेट का उपयोग करते हैं।

— डेनिस

24

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 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

— अदनान
स्रोत

5

मुझे आश्चर्य हुआ कि जब तक किसी ने उस चाल का उपयोग नहीं किया था :)

— फ्लिपकार्ट

— K

5

@KellyLowder UTF-8 में, हाँ। हालाँकि, 05AB1E UTF-8 एन्कोडिंग के बजाय CP-1252 एन्कोडिंग का उपयोग करता है।

— अदनान

10

पायथन , 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 में केवल 1 बिट्स होते हैं यदि यह एक Mersenne संख्या है, तो बिटवाइंड और 0 वापस आ जाएगा यदि (और केवल यदि) तो यह मामला है।
all(n%i for i in range(2,n))रिटर्न यह सच है यदि और केवल यदि एन मॉड मैं के सभी मानों के लिए गैर-शून्य है मैं में [2, ..., n - 1] , यानी, यदि और केवल यदि n अलग से कोई सकारात्मक divisors है 1 और एन ।

दूसरे शब्दों में, सभी रिटर्न यह सच है यदि और केवल यदि n एक समग्र संख्या, यानी है, n या तो है 1 या एक प्रमुख।
n आत्म-व्याख्यात्मक है।

जंजीर तुलना सही है और यदि केवल व्यक्तिगत तुलना समान है, तो यह सच है ।

चूंकि सभी रिटर्न ट्रू / 1 या गलत / 0-~n&n<all(n%i for i in range(2,n)) रिटर्न करते हैं , केवल ट्रू रिटर्न कर सकते हैं यदि -~n&nपैदावार 0 (यानी, यदि n एक Mersenne नंबर है) और सभी रिटर्न ट्रू (यानी, यदि n या तो 1 या एक प्राइम)।
तुलना all(n%i for i in range(2,n))<nरखती है जब भी n> 1 , लेकिन जब से सभी रिटर्न यह सच है , तो n = 1 , यह इस मामले में नहीं रखता है।

— डेनिस
स्रोत

1

वाह, यह आश्चर्यजनक है :)

— एबसीडेक्टर 17

8

ब्रेकीलॉग , 7 बाइट्स

#p+~^h2

इसे ऑनलाइन आज़माएं!

एक ब्रैकीलॉग कार्यक्रम मूल रूप से बाधाओं का एक क्रम है जो एक श्रृंखला बनाते हैं: पहला बाधा इनपुट और एक अज्ञात अज्ञात के बीच है (आइए इसे इस चर्चा के उद्देश्य के लिए ए कहते हैं ), दूसरा बाधा उस अनाम अज्ञात और एक दूसरे अनाम के बीच है अज्ञात (जिसे हम बी कहेंगे ), और इसी तरह। जैसे, कार्यक्रम इस तरह टूट गया:

#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

जिस तरह से इन सभी बाधाओं को एक साथ संतुष्ट किया जा सकता है, अगर बी 2 की शक्ति है, यानी इनपुट 2 शून्य से 1 की शक्ति है, और इनपुट भी प्रमुख है। (Brachylog आंतरिक रूप से एक अवरोधक सॉल्वर का उपयोग करता है, इसलिए यह कार्यक्रम उतना अकुशल नहीं होगा जितना कि मूल्यांकन क्रम दिखता है; यह दो Cरूपों की व्याख्या के रूप में [2, Y]व्यक्त करने की कोशिश करने से पहले उस रूप से अवगत होगा B।)

दिलचस्प बात यह है कि #p+~^ लगभग काम करता है, क्योंकि मेर्सेन-जैसे प्राइम केवल गैर-अध: पतन मामलों ( प्रमाण ) में आधार के रूप में 2 का उपयोग कर सकते हैं , लेकिन ए) गैर-मेर्सेंइ प्राइम बी -1 के लिए विफल रहता है क्योंकि उन्हें बी ¹ और बी के रूप में व्यक्त किया जा सकता है। ) मौजूदा Brachylog दुभाषिया एक कार्यक्रम है कि खराब विवश है द्वारा भ्रमित किया जा रहा है (अनंत, या कम से कम लंबी अवधि, पाश) में जा रहा है। इसलिए ब्राइटलॉग में 7 बाइट्स पिटने की संभावना नहीं है।

मैं प्रसन्न हूँ! अनंत लूप की समस्या के लिए, यह विधेय के अधिभार के कारण है। पीछे देखते हुए मुझे लगता है कि मुझे विधेयकों के लिए किसी भी तरह के ओवरलोडिंग को लागू नहीं करना चाहिए था। इससे फाइंडॉल जैसी चीजों में भी समस्या आती है।

— घातक

7

गणितज्ञ 26 बाइट्स

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

इस प्रमाण को देखें

इतने लंबे समय तक काम करता है कि कोई विषम संख्या नहीं है, और कोई भी मौजूद नहीं है।

— केली लोडर
स्रोत

तो क्या आपका उत्तर मान्य नहीं है?

— जोनाथन फ्रीच

मुझे नहीं लगता कि अंतरिक्ष जरूरी है।

— जोनाथन फ्रीच

n(n+1)/2जब भी nMersenne प्राइम (यूक्लिड) होता है, तब @JonathanFrech फॉर्मूला (सम) पूर्ण संख्याओं का उत्पादन करता है। यह अज्ञात प्रतीत होता है कि क्या एक विषम पूर्ण संख्या का रूप n(n+1)/2हो सकता है, अर्थात त्रिकोणीय संख्या हो सकती है। यहां तक कि सभी सही संख्याएं त्रिकोणीय हैं जहां यह nएक मेर्सेन प्राइम (ईयूलर) है।

— जेपी स्टिग नील्सन

1

@JeppeStigNielsen सवाल यह है कि अगर किसी के समाधान को आधार बनाने के लिए किसी अज्ञात तथ्य का उपयोग करना वैध है।

— जोनाथन फ्रीच

7

गणितज्ञ, २ ९ २६ बाइट्स

संपादित करें: मार्टिन एंडर के लिए धन्यवाद 3 बाइट्स सहेजे गए

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

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

मुझे संदेह है कि यह तेजी से होगा क्योंकि पहले 42 एक्सपोर्टर हार्ड-कोडेड हैं:

MersennePrimeExponentQ@Log2[#+1]&

— ngenisis
स्रोत

6

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

— मार्टिन एंडर

5

पर्ल 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

}

चूंकि पर्ल 6 में मनमाने ढंग से बड़े इनट्स हैं, यह एस के .base(2)साथ सामने नहीं रखता है 0।

— ब्रैड गिल्बर्ट b2gills
स्रोत

5

पायथन, 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

पायथन 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

यह समारोह लुकास-लेहमेर प्राइमलिटी टेस्ट को लागू करता है , इसलिए जब तक यह बहुत से अन्य इनपुट्स की तुलना में छोटा नहीं होता है, यह विशाल आदानों को संभालने में बहुत तेज है।

यहाँ कुछ परीक्षण कोड हैं जो पायथन 2 या पायथन 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

एफडब्ल्यूआईडब्ल्यू, यहां इसका थोड़ा अधिक कुशल संस्करण है 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

— दोपहर 2 बजे
स्रोत

आप सभी लूप को एक लाइन पर लिख सकते हैं (नई लाइन और इंडेंट की कोई आवश्यकता नहीं)

— फ्लिपकार्ट

@ फीलटैक डी’ओह! धन्यवाद! मैं वास्तव में नहीं जानता कि मैं क्यों चूक गया ... और मैंने अभी देखा कि मैं कुछ और बाइट्स निकाल सकता हूं जो पायथन 2 पर वापस

— आकर होगा

4

आर, 41 40 बाइट्स

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

विचित्र रूप से आर में निर्मित बिलियन तर्क के रूप में mersenneलेता nहै, नहीं 2^n-1।

यह xएसटीडीआईएन से लेता है, यह जांचता है कि क्या यह matlabपैकेज का उपयोग करते हुए प्राइम है और यह जांचता है कि क्या x+1मॉड 1 को लेने से 2-लॉग एक पूरी संख्या है और 'शून्य-नेस नहीं' के लिए जांच करता है।

इसके अलावा, यदि आप mersenneबिलिन का उपयोग करते हैं , तो यह थोड़ा छोटा होने पर समाप्त हो जाता है, लेकिन धोखा देने जैसा लगता है:

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

@ बेलीवॉब के लिए 1 बाइट धन्यवाद

— JAD
स्रोत

एक समान उत्तर पोस्ट किया, लेकिन मैंने इसे अभी हटा दिया है। मैं matlab::isprimeएक बाइट को बचाने के लिए सुझाव दे सकता हूं । इसके अलावा, आपको <-इन-फंक्शन असाइनमेंट के लिए उपयोग करना होगा।

— बिलीवोब

@billywob ने सिर्फ अस्वस्थ देखा कि matlab :: isprime 1 बाइट छोटा था। (आपके समाधान पर 1 सेकंड का शिखर मिला)।

— JAD

आप log2(x+1)इसके बजाय भी उपयोग कर सकते हैं log(x+1,2)।

— बिलीवोब 15

2

पाइके, 10 बाइट्स

_PQb2+}\1q

यहाँ यह कोशिश करो!

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

— नीला
स्रोत

2

दरअसल , 9 बाइट्स

;├╔'1=@p*

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

चूंकि फॉर्म 2 ^एन -1 की प्रत्येक संख्या में बाइनरी प्रतिनिधित्व में सभी 1 है, इसलिए एक मेर्सेन प्राइम को उस गुणवत्ता के लिए एक प्रमुख संख्या के रूप में पहचाना जा सकता है।

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

— मेगो
स्रोत

2

जेली, 5 बाइट्स

वैकल्पिक दृष्टिकोण @ डेनिस मौजूदा 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

चूंकि मेर्सन प्राइम 2 की शक्ति से कम है, इसलिए इसका बाइनरी प्रतिनिधित्व 1 है। इसके बाद उत्पादन Mersenne primes के लिए 1 है, और अन्य सभी मामलों में 0 है।

— steenbergh
स्रोत

2

सीलोन, 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;

धोखा देने (सीलोन के इंटेगर की श्रेणी में परिणाम को हार्डकोड करने) के साथ, हम बाइट को छोटा कर सकते हैं (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

— पाओलो एबरमन
स्रोत

2

वोल्फ्राम भाषा (गणितज्ञ) , 23 बाइट्स

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

इसे ऑनलाइन आज़माएं!

1 सही ढंग से नियंत्रित किया जाता है क्योंकि PrimeQ[BitAnd[1,1+2]*1] == PrimeQ@1 == False। अन्यथा, BitAnd[#,#+2]#प्रधान होने के लिए , हमें प्रधान की आवश्यकता है #और BitAnd[#,#+2] == 1, जो तब होता है जब #एक मेरसेन संख्या होती है।

— lirtosiast
स्रोत

अच्छी तरह से किया! किसी के रूप में, जिसने कभी गणितज्ञ का उपयोग नहीं किया है, हालांकि, आपका TIO कोड पहले भ्रमित था। तब मुझे एहसास हुआ कि आप अपने कार्य की तुलना ngenisis के पिछले बंधे रिकॉर्ड धारक से कर रहे हैं। मुझे लगता है कि यह सिर्फ फ़ंक्शन के आउटपुट को दिखाने के लिए बेहतर होगा और शायद दूसरे लिंक की तुलना दूसरे समाधान (ओं) से कर सकता है।

— डेडकोड

2

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 से विभाजित करता है" तब तक काम करता है जब तक कि इसे आगे नहीं किया जा सकता है, फिर परिणाम शून्य है। यह कम से कम एक बार लूप को चलने के *लिए +मजबूर करके, अंतिम को बदलकर केवल ≥1 से मिलान करने के लिए संशोधित किया जा सकता है । xअंतिम से पहले डालने से $यह केवल संख्या the3 से मेल खाने के लिए संशोधित करता है यह मानकर कि अंतिम परिणाम कम से कम एक बार लूप करने के बाद 1 है।

संबंधित "2 की शक्ति है" परीक्षण है ^((x+)(?=\2$))*x$। यहां 2 शून्य से 2 के मिलान शक्तियों, द्वारा की खोज के लिए एक आशुलिपि है मटमैला : ^((x+)(?=\2$)x)*$। इन तीनों रेगीक्स एक ही लंबाई के हैं।

वैकल्पिक 31 बाइट संस्करण, ग्रिम द्वारा :

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

— Deadcode
स्रोत

1

11 बाइट्स को 2 की शक्ति से कम नंबर 1 के लिए सीधे जाँच करके बचाएं: इसे ऑनलाइन आज़माएं!

— नील

@ नील आपको बहुत बहुत धन्यवाद! काश मैं उस के बारे में सोचा होता, लेकिन फिर, यह ठीक उसी तरह का है जो मैं चाहता था!

— डेडकोड

1

वास्तव में इसके बारे में सोचना x(x+)(?=\3$)थोड़ा अधिक कुशल होगा?

— नील

हां, आप बिल्कुल सही कह रहे हैं।

— डेडकोड

2

रेगेक्स (ECMAScript), 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

चैट में ग्रिम से प्रेरित

रेगेक्स का दावा है कि इनपुट 3 से अधिक है, और यह न तो फॉर्म का है: (xx+)\1+या ((xx)+)(\1x)+।

पहली संख्या मिश्रित संख्याओं से मेल खाती है।
दूसरी संख्या एक ऐसी संख्या से मेल खाती है जो 2 से अधिक संख्या में किसी विषम संख्या से 1 कम है।

01
$2^n-1$

चूँकि 2 एकमात्र ऐसा अभाज्य है जो विषम प्राइम से 1 कम है, नकारात्मक लुकहेड, साथ में यह दावा कि इनपुट 3 से अधिक है, केवल mersenne primes से मेल खाएगा।

— H.PWiz
स्रोत

1

रूबी, 47 बाइट्स

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

— जीबी
स्रोत

1

जूलिया, 26 बाइट्स

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

— alephalpha
स्रोत

1

पायथन, 65 बाइट्स

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

निर्गम कोड के माध्यम से आउटपुट। गलत के लिए पुनरावृत्ति त्रुटि। ट्रू के लिए कोई त्रुटि नहीं।

यह काम किस प्रकार करता है

चूंकि 2^n-1बाइनरी पूरी तरह से 1 से बना है, इसलिए अगली 2^n-1संख्या को उत्पन्न किया जा सकता है number|number+1।

यह फ़ंक्शन पुनरावर्ती रूप से प्रत्येक 2^n-1नंबर की जाँच के माध्यम से यह देखने के लिए उपयोग करता है कि क्या यह एक प्रमुख संख्या है और इनपुट के लिए eqaul है। यदि संख्या एक mersenne प्राइम नहीं है, तो अजगर अंततः एक त्रुटि फेंक देगा क्योंकि अधिकतम पुनरावृत्ति की गहराई पार हो गई होगी।

— Cormac
स्रोत

1

अगर मैं गलत नहीं हूँ, <0~> 0>।

— जोनाथन फ्रेच

1

पुष्य , 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।

— FlipTack
स्रोत

1

पायथ , 8 बाइट्स

&.AjQ2P_

सभी परीक्षण मामलों की जाँच करें।

पायथ , 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 दो की शक्ति है (यानी यदि यह एक मेरसेन संख्या है), और फिर प्रायोगिक परीक्षण करता है। पायथन में, boolएक उपवर्ग है int, इसलिए सत्य को 1 माना जाता है और मिथ्या को 0 माना जाता है । स्पष्ट रूप से जाँचने से बचने के लिए कि एक 0 है और दूसरा 1 है , हम उनके मूल्यों की तुलना करते हैं <(क्योंकि हमारे पास केवल 1 ऐसा मामला है)।

— मिस्टर एक्सकोडर
स्रोत

1

जावा 8, 53 52 49 बाइट्स

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

बग-फिक्स्ड और 4 बाइट्स के लिए गोल्फ @ नोवेय को धन्यवाद ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

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

— केविन क्रूज़सेन
स्रोत

वर्तमान समाधान trueहर प्राइम> 2 के लिए वापस आता है , न कि केवल n->{for(int i=2;i<n;n&=-n%i++>>-1);return(n&n+1)<1&n>2;}

— मेर्सेन

1

52 बाइट्स:n->{int i=1;for(;++i<n&n%i>0;);return(n&n+1|i^n)<1;}

— नेवले

@ नोवे थैंक्स .. और यकीन नहीं होता कि टेस्ट केसों में किसी भी तरह के प्राइम शामिल नहीं हैं जो मेरसेन प्राइम नहीं हैं .. उन्हें खुद जोड़ा, और आप वास्तव में सही थे।

— केविन क्रूज़सेन

1

49 बाइट्स:n->{int i=1;for(;n%++i>0;);return(n&n+1|i^n)==0;}

— नेवई

1

पायथन 3, 68 बाइट्स

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

इसे यहाँ आज़माएँ

पायथन 2, 63 बाइट्स

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

इसे यहाँ आज़माएँ

सुझाव के लिए धन्यवाद जोनाथन

बायटेकाउंट को कम करने के लिए किसी भी सुझाव के लिए खोलें।

— ABcDexter
स्रोत

1

1 and~> 1and।

— जोनाथन फ्रीच

1

जाप, 6 बाइट्स

¢¬×&Uj

इसे चलाएं या सभी परीक्षण मामलों को चलाएं

— ओलिवर
स्रोत

1

— झबरा

0

पायथन, 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 दोनों में काम करेगा इसलिए मैंने कोई संस्करण निर्दिष्ट नहीं किया है।

— sonrad10
स्रोत

0

रैकेट 76 बाइट्स

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

परिक्षण:

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

आउटपुट:

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

— rnso
स्रोत

0

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.

— टाइटस
स्रोत

0

सी, 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 प्राइम है, तो रिटर्न 1, अन्यथा।

— Steadybox
स्रोत

~x+g(2,n)इसके बजाय सुझाव देंx^g(2,n)-1

— छत

0

स्काला, 59 बाइट्स

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

इस फ़ंक्शन के लिए इनपुट की आवश्यकता है a BigInt। आप आसानी से एक स्ट्रिंग "162259276829213363391578010288127" (2 ** 107-1 एक Mersenne प्रधानमंत्री है) में परिवर्तित BigIntकर सकते हैं 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

— आरिया ऐक्स
स्रोत

आप निकाल सकते हैं Probableसे isProbablePrimeअगर स्काला एक है isPrimeसमारोह।

— मिल्कीवेय

0

पर्ल 5 , 53 बाइट्स

कोड + 1 के लिए 52 बाइट्स -p

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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

मेटा सर्वसम्मति के अनुसार, -pएक अन्य प्रोग्रामिंग भाषा के रूप में वर्गीकृत किया गया है, और इसलिए आपके बायटेकाउंट में गणना नहीं की जाती है।

— मिल्कीवेयय

यह एक Mersenne प्रधानमंत्री है?

नियम:

परीक्षण के मामलों

जेली , 5 बाइट्स

यह काम किस प्रकार करता है

05AB1E , 5 बाइट्स

पायथन , 45 बाइट्स

यह काम किस प्रकार करता है

ब्रेकीलॉग , 7 बाइट्स

गणितज्ञ 26 बाइट्स

गणितज्ञ, २ ९ २६ बाइट्स

पर्ल 6 , 29 बाइट्स

विस्तारित:

पायथन, 83 82 79 76 73 बाइट्स

पायथन 2, 71 बाइट्स

आर, 41 40 बाइट्स

पाइके, 10 बाइट्स

दरअसल , 9 बाइट्स

जेली, 5 बाइट्स

सीलोन, 66 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 23 बाइट्स

ECMAScript रेगेक्स, 42 31 बाइट्स

रेगेक्स (ECMAScript), 29 बाइट्स

रूबी, 47 बाइट्स

जूलिया, 26 बाइट्स

पायथन, 65 बाइट्स

पुष्य , 7 बाइट्स

पायथ , 8 बाइट्स

पायथ , 8 बाइट्स

कैसे?

कोड ब्रेकडाउन # 1

वह कैसे काम करता है?

कोड ब्रेकडाउन # 2

वह कैसे काम करता है?

जावा 8, 53 52 49 बाइट्स

पायथन 3, 68 बाइट्स

पायथन 2, 63 बाइट्स

जाप, 6 बाइट्स

पायथन, 93 बाइट्स

रैकेट 76 बाइट्स

PHP, 53 बाइट्स

सी, 94 बाइट्स

स्काला, 59 बाइट्स

पर्ल 5 , 53 बाइट्स