Число - це Mersenne Prime, якщо воно є простим і може бути записане у формі 2 ⁿ -1 , де n - натуральне число.

Ваше завдання полягає в тому, щоб, враховуючи будь-яке додатне ціле число, визначити, чи є це простим рівнем Мерсенна чи ні. Ви можете подати або функцію, яка повертає значення truthy / falesy, або повну програму, яка виконує IO.

Правила:

• Оскільки це код-гольф , вам слід поставити за мету зробити це якомога коротшим числом байтів. Вбудовані дозволені.
• Застосовуються стандартні лазівки для гольфу - ви не можете прочитати праймери 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 . Спробуйте в Інтернеті! або Перевірте всі тестові випадки .

Пітон , 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обчислює порозрядне AND з n + 1 і n . Оскільки n складається виключно з 1 біта, якщо це число Мерсена, порозрядне значення AND поверне 0, якщо (і лише тоді) це так.

• all(n%i for i in range(2,n))повертає True, якщо і тільки тоді, коли n mod i не дорівнює нулю для всіх значень i в [2,…, n - 1] , тобто, якщо і тільки тоді, якщо n не має позитивних дільників, крім 1 і n .

  Іншими словами, все повертає True, якщо і лише тоді, коли n - складене число, тобто n є 1 або простим.

• n є само собою зрозумілим.

Ланцюговий порівняння повертає істину, якщо і лише тоді, коли окремі порівняння роблять те саме.

• Оскільки все повертається або Правда / 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 , але оскільки все повертає True, якщо n = 1 , воно не виконується в цьому випадку.

Брахілог , 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, а вхід також є простим. (Брахілог використовує вирішувач обмежень внутрішньо, тому програма не буде такою неефективною, як виглядає порядок оцінювання; він повинен знати, що Cмає форму, [2, Y]перш ніж спробує виразити Bяк показник двох чисел.)

Цікаво, що це #p+~^ майже працює, тому що Мерсен-подібні праймери можуть використовувати 2 як основу лише у випадках, що не вироджуються ( доказ ), але а) він не вдається для не мерзеннових прайменів B -1, оскільки вони можуть бути виражені як B ¹, і b ) начебто перекладач Брахілог переплутаний (переходить у нескінченний або хоча б тривалий цикл) програмою, яка погано обмежена. Тож 7 байтів здається малоймовірними для побиття в Брахілозі.

Математика 26 байт

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

Дивіться цей доказ

Працює до тих пір, поки не існує непарних досконалих чисел, і жодне, як відомо, не існує.

Математика, 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)з 0с.

Пітон, 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

Ця функція реалізує тест первинності Лукаса-Лемера , тому, хоча він не такий короткий, як деякі інші пропозиції 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пакету, і перевіряє, чи є 2-логічний журнал x+1цілим числом, взявши mod 1 і перевіривши на 'not zero-ness'.

Крім того, якщо ви використовуєте mersenneвбудований, він закінчується трохи коротше, але відчуває себе як обман:

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

Збережено 1 байт завдяки @Billywob

Пайк, 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 байт

Альтернативний підхід до існуючої 5-байтової відповіді Jelly:

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. Вихід для цього становить 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;

За допомогою обману (жорстке кодування результатів у діапазоні цілочистих Цейлонів) ми можемо отримати байт коротший (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

Мова Вольфрама (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", поки це не можна зробити далі, запевняючи, що результат дорівнює нулю. Це можна змінити так, щоб відповідати лише числам ≥1, змінивши останнє *на a +, примушуючи цикл повторювати хоча б один раз. Вставлення xдо останнього $додатково модифікує його, щоб воно відповідало лише числам ≥3, стверджуючи, що кінцевий результат після циклу принаймні один раз дорівнює 1.

Пов'язаний тест "сила 2" є ^((x+)(?=\2$))*x$. Існує також стенограма відповідності потужностей 2 мінус 2, виявлена Grimy : ^((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.

Regex (ECMAScript), 29 байт

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

Спробуйте в Інтернеті!

Натхненний Гримі в чаті

Регекс запевняє, що вхід більший за 3, і що він не має жодної форми: (xx+)\1+або ((xx)+)(\1x)+.

Перший відповідає складеним числам.
Другий відповідає числу, яке на 1 менше, ніж кратне деякому непарному числу, більше 2.

Перший не збігається з простими числами 0або 1.
Другий не буде відповідати номерам форми$2^n-1$

Оскільки 2 є єдиним простим рівнем, що на 1 менше, ніж непарний простір, негативний показник разом із твердженням, що вхід більший за 3, буде відповідати лише мерзенним праймем.

Рубін, 47 байт

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

Джулія, 26 байт

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

Пітон, 65 байт

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

Виходи через вихідний код. Помилка рекурсії для помилкових. Немає помилок для True.

Як це працює

Оскільки 2^n-1в двійковій формі робиться повністю з 1-х, наступне 2^n-1число може бути згенеровано number|number+1.

Ця функція використовує цю функцію, рекурсивно переглядаючи кожне 2^n-1число, перевіряючи, чи є це простим числом та eqaul на вхід. Якщо число не є простим мерсеном, пітон зрештою видасть помилку, оскільки максимальна глибина рекурсії була б перевищена.

Пушистий , 7 байт

oBoIpP#

Спробуйте в Інтернеті!

Це використовує той факт, що числа мерсен у своєму двійковому представленні мають лише такі:

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 - потужність двох (тобто, якщо це число Мерсена), а потім виконує тест первинності. У Python boolє підкласом int, тому truthy трактується як 1, а фальшивість трактується як 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 байти завдяки @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

Запустити його або Запустити всі тестові випадки

Пітон, 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);

бере аргумент командного рядка; принти 1для Mersenne prime, порожній рядок else. Бігайте з -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;}

Повертає 1, якщо число є простим Mersenne Prime, 0 інакше.

Скала, 59 байт

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

Ця функція вимагає, щоб вхід був a BigInt. Ви можете легко перетворити рядок "162259276829213363391578010288127" (2 ** 107-1 - простий мерсмен) 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

Perl 5 , 53 байти

52 байти коду + 1 для -p

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

Спробуйте в Інтернеті!