Một số là một số de Polignac khi và chỉ khi nó là số lẻ và không thể được biểu diễn dưới dạng p + 2 ⁿ trong đó n là số nguyên không âm và p là số nguyên tố.

Bài tập

Viết một số mã lấy một số nguyên dương và xác định nếu đó là số de Polignac. Bạn có thể xuất hai giá trị riêng biệt một cho đúng và một cho sai. Bạn nên cố gắng giảm thiểu số lượng byte của bạn.

Các trường hợp thử nghiệm

Đối với các trường hợp tích cực, đây là OEIS

1, 127, 149, 251, 331, 337, 373, 509, 599, 701, 757, 809, 877, 905, 907, 959, 977, 997, 1019, 1087, 1199, 1207, 1211, 1243, 1259, 1271, 1477, 1529, 1541, 1549, 1589, 1597, 1619, 1649, 1657, 1719, 1759, 1777, 1783, 1807, 1829, 1859, 1867, 1927, 1969, 1973, ...

Dưới đây là một số trường hợp tiêu cực:

22, 57

Japt , 9 14 13 byte

o!²mnU dj |Uv

Kiểm tra nó trực tuyến! hoặc Tìm tất cả các số nguyên de Polignac dưới 1000 .

Đầu ra 1cho đầu vào giả và 0cho sự thật.

Giải trình

 o!²  mnU dj |Uv
Uo!p2 mnU dj |Uv  : Ungolfed
                  : Implicit: U = input integer (e.g. 9)
Uo                : Create the range [0..U), and map each item X to
  !p2             :   2 ** X.               [1, 2, 4, 8, 16, 32, 64, 128, 256]
      m           : Map each of these powers of 2 by
       nU         :   subtracting from U.   [8, 7, 5, 1, -7, -23, -57, -119, -247]
          d       : Return whether any item in the result is
           j      :   prime.                (5 and 7 are, so `true`)
             |    : Take the bitwise OR of this and
              Uv  :   U is divisble by (missing argument = 2).
                  : This gives 1 if U cannot be represented as p + 2^n or if U is even.
                  : Implicit: output result of last expression

Thạch , 11 10 byte

Đã lưu 1 byte nhờ @Dennis

Ḷ2*³_ÆPS<Ḃ

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Ḷ2*³_ÆPS<Ḃ   Main link. Argument: n (integer)
Ḷ            Lowered range; yield [0, 1, 2, ..., n-1].
 2*          Reversed exponentiation with 2; yield [1, 2, 4, ..., 2**(n-1)].
   ³_        Reversed subtraction with the input; yield [n-1, n-2, n-4, ..., n-2**(n-1)].
     ÆP      Replace each item with 1 if it is prime, 0 otherwise.
       S     Sum; yield a positive integer if any item was prime, 0 otherwise.
         Ḃ   Yield n % 2.
        <    Yield 1 if the sum is less than n % 2, 0 otherwise.
             This yields 1 if and only if the sum is 0 and n is odd.

JavaScript (ES6),  56 54  53 byte

Trả về $0$ hoặc $1$ .

f=(n,p=1,x=y=n-p)=>n>p?y%--x?f(n,p,x):x!=1&f(n,p*2):n

Hãy thử trực tuyến!

Làm sao?

Chúng tôi bắt đầu với $p = 1$ . Chúng tôi kiểm tra xem $y = n - p$ có phải là hợp số hay không và mang lại giá trị boolean tương ứng. Thử nghiệm tiếp theo được thực hiện với $p \times 2$ .

Ngay khi $p$ lớn hơn $n$ , chúng ta dừng đệ quy và trả về $n$ .

Kết quả của tất cả các lần lặp là AND'd với nhau, ép các giá trị boolean thành $0$ hoặc $1$ .

Với điều kiện là tất cả các kết quả trung gian đều là sự thật, chúng tôi kết thúc bằng một bài kiểm tra bitwise như:

1 & 1 & 1 & n

Điều này cho $1$ khi và chỉ khi $n$ là số lẻ, đây là điều kiện cuối cùng cần thiết để xác thực đầu vào dưới dạng số de Polignac.

Python 2 , 60 57 56 byte

f=lambda n,k=1,p=-1:k/n or(n-k&n-k-p%k>0)&n&f(n,k+1,p*k)

Hãy thử trực tuyến!

Thạch , 10 byte

Một bài nộp Jelly 10 byte thay thế cho bài đã được đăng.

_ÆRBS€’×ḂẠ

Một liên kết đơn trả về 1 cho các số de Polignac và 0 nếu không.

Hãy thử trực tuyến! hoặc xem những người dưới 1000 .

Làm sao?

_ÆRBS€’×ḂẠ - Link: number, n  e.g.  1    3      5                  6                   127
 ÆR        - prime range            []   [2]    [2,3,5]            [2,3,5]             [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127]
_          - subtract from n        []   [1]    [3,2,0]            [4,3,1]             [125,124,122,120,116,114,110,108,104,98,96,90,86,84,80,74,68,66,60,56,54,48,44,38,30,26,24,20,18,14,0]
   B       - convert to binary      []   [[1]]  [[1,1],[1,0],[0]]  [[1,0,0],[1,1],[1]  [[1,1,1,1,1,0,1],[1,1,1,1,1,0,0],[1,1,1,1,0,1,0],[1,1,1,1,0,0,0],[1,1,1,0,1,0,0],[1,1,1,0,0,1,0],[1,1,0,1,1,1,0],[1,1,0,1,1,0,0],[1,1,0,1,0,0,0],[1,1,0,0,0,1,0],[1,1,0,0,0,0,0],[1,0,1,1,0,1,0],[1,0,1,0,1,1,0],[1,0,1,0,1,0,0],[1,0,1,0,0,0,0],[1,0,0,1,0,1,0],[1,0,0,0,1,0,0],[1,0,0,0,0,1,0],[1,1,1,1,0,0],[1,1,1,0,0,0],[1,1,0,1,1,0],[1,1,0,0,0,0],[1,0,1,1,0,0],[1,0,0,1,1,0],[1,1,1,1,0],[1,1,0,1,0],[1,1,0,0,0],[1,0,1,0,0],[1,0,0,1,0],[1,1,1,0],0]
    S€     - sum €ach               []   [1]    [2,1,0]            [1,2,1]             [6,5,5,4,4,4,5,4,3,3,2,4,4,3,2,3,2,2,4,3,4,2,3,3,4,3,2,2,2,3,0]
      ’    - decrement              []   [0]    [1,0,-1]           [0,1,0]             [5,4,4,3,3,3,4,3,2,2,1,3,3,2,1,2,1,1,3,2,3,1,2,2,3,2,1,1,1,2,-1]
        Ḃ  - n mod 2                1    1      1                  0                   1
       ×   - multiply               []   [0]    [1,0,-1]           [0,0,0]             [5,4,4,3,3,3,4,3,2,2,1,3,3,2,1,2,1,1,3,2,3,1,2,2,3,2,1,1,1,2,-1]
         Ạ - all truthy?            1    0      0                  0                   1

05AB1E , 9 8 byte

-1 byte nhờ Emigna

Ýo-pZ¹È~

Đầu ra 0cho đầu vào trung thực và 1đầu vào giả.

Hãy thử trực tuyến!

Python 2 , 99 byte

lambda n:n&1-any(n-2**k>1and all((n-2**k)%j for j in range(2,n-2**k))for k in range(len(bin(n))-2))

Hãy thử trực tuyến!

-4 byte nhờ Leaky Nun

-2 byte nhờ có Fantercricket

+8 byte để sửa lỗi

-1 byte nhờ ông Xcoder

-3 byte nhờ Einkorn Enchanter

+12 byte để sửa lỗi

Regex (ECMAScript), 97 byte

Vấn đề này đặt ra một trường hợp thú vị để giải quyết vấn đề thiếu cái nhìn phi nguyên tử. Và đó là lần duy nhất cho đến nay tôi có lý do chính đáng để đặt cả hai phiên bản sức mạnh của 2 bài kiểm tra, ((x+)(?=\2$))*x$và (?!(x(xx)+)\1*$)trong cùng một chế độ, và là lần duy nhất cho đến nay tôi cần bảo vệ bài kiểm tra chính chống lại sự phù hợp 1, như (?!(xx+)\1+$)xx, khi được sử dụng trong một regex lớn hơn.

^(?!(xx)*$|(x+)((?!(xx+)\4+$).*(?=\2$)((x+)(?=\6$))*x$|(?!(x(xx)+)\7*$).*(?=\2$)(?!(xx+)\9+$)xx))

Hãy thử trực tuyến!

# For the purposes of these comments, the input number = N.
^
# Assert that N is not the sum of a prime number and a power of 2.
(?!
    (xx)*$                 # Assert that N is odd.
|
    # Since we must cycle through all values for a number X and a corresponding number
    # N-X, this cannot be in an atomic lookahead. The problem then becomes that it
    # consumes characters. Thus we must let X be the larger of the two and N-X be the
    # smaller, and do tests on X followed by tests on N-X. We can't just test X for
    # being prime and N-X for being a power of 2, nor vice versa, because either one
    # could be smaller or larger. Thus, we must test X for being either prime or a
    # power of 2, and if it matches as being one of those two, do the opposite test on
    # N-X.
    # Note that the prime test used below, of the form (?!(xx+)\2+$), has a false match
    # for 0 and 1 being prime. The 0 match is harmless for our purposes, because it
    # will only result in a match for N being a power of 2 itself, thus rejecting
    # powers of 2 as being de Polignac numbers, but since we already require that N is
    # odd, we're already rejecting powers of 2 implicitly. However, the 1 match would
    # break the robustness of this test. There can be de Polignac numbers of the form
    # 2^M+1, for example 262145 and 2097153. So we must discard the 1 match by changing
    # the prime test to "(?!(xx+)\2+$)xx". We only need to do this on the N-X test,
    # though, because as X is the larger number, it is already guaranteed not to be 1.
    (x+)           # \2 = N-X = Smaller number to test for being prime or a power of 2;
                   # tail = X = larger number to test for being prime or a power of 2.
    (
        (?!(xx+)\4+$)      # Test X for being prime.
        .*(?=\2$)          # tail = N-X
        ((x+)(?=\6$))*x$   # Test N-X for being a power of 2. Use the positive version
                           # since it's faster and doesn't have a false match of 0.
    |
        (?!(x(xx)+)\7*$)   # Test X for being a power of 2. Use the negative version
                           # because the testing of X has to be in a lookahead, and
                           # putting the positive version in a positive lookahead would
                           # be worse golf. It doesn't matter that this can have a false
                           # match of 0, because X is guaranteed never to be 0.
        .*(?=\2$)          # tail = N-X
        (?!(xx+)\9+$)xx    # Test N-X for being prime. We must prevent a false match of
                           # 1 for the reason described above.
    )
)

Regex (ECMAScript + lookahead phân tử), 53 52 byte

^(?!(xx)*$|(?*xx+(((x+)(?=\4$))*x$))\2(?!(xx+)\5+$))

# For the purposes of these comments, the input number = N.
^
# Assert that N is not the sum of a prime number and a power of 2.
(?!
    (xx)*$                   # Assert that N is odd.
|
    (?*
        xx+                  # Force N - \2 to be > 1, because the prime test used
                             # below has a false match of 1, which would otherwise
                             # give us false negatives on de Polignac numbers of the
                             # form 2^M+1, such as 262145 and 2097153.
        (((x+)(?=\4$))*x$)   # Cycle through subtracting all possible powers of 2 from
                             # tail, so we can then test {N - {power of 2}} for being
                             # prime.
                             # \2 = the power of 2
    )
    \2                       # tail = N - \2
    (?!(xx+)\5+$)            # Test tail for being prime. If it matches, this will fail
                             # the outside negative lookahead, showing that N is not a
                             # de Polignac number.
)

Phiên bản này không chỉ sạch hơn nhiều, mà còn nhanh hơn nhiều, vì thay vì phải xoay vòng qua tất cả các cách có thể mà N là tổng của hai số, nó chỉ có thể quay vòng trừ đi mọi lũy thừa 2 từ N và kiểm tra sự khác biệt để trở thành số nguyên tố .

Giao diện phân tử có thể dễ dàng chuyển đổi thành giao diện có chiều dài thay đổi:

Regex (.NET hoặc ECMAScript 2018), 55 54 byte

^(?!(xx)*$|xx+(((x+)(?=\4$))*x$)(?<=(?<!^\5+(x+x))\2))

Hãy thử trực tuyến! (.NET)
Hãy thử trực tuyến! (Bản thảo năm 2018)

# For the purposes of these comments, the input number = N.
^
# Assert that N is not the sum of a prime number and a power of 2.
(?!
    (xx)*$                 # Assert that N is odd.
|
    xx+                    # Force N - \2 to be > 1, because the prime test used
                           # below has a false match of 1, which would otherwise
                           # give us false negatives on de Polignac numbers of the
                           # form 2^M+1, such as 262145 and 2097153.
    (((x+)(?=\4$))*x$)     # Cycle through subtracting all possible powers of 2 from
                           # tail, so we can then test {N - {power of 2}} for being
                           # prime.
                           # \2 = the power of 2
    (?<=
        (?<!^\5+(x+x))     # Test tail for being prime. If it matches, this will fail
                           # the outside negative lookahead, showing that N is not a
                           # de Polignac number.
        \2                 # tail = N - \2
    )
)

Toán học, 41 byte

OddQ@#&&!Or@@PrimeQ[#-2^Range[0,Log2@#]]&

PHP , 75 byte

in 1 cho sự thật và 0 cho giả

for($t=1&$argn;0<$d=$n=$argn-2**$i++;$d-1?:$t&=0)for(;--$d&&$n%$d;);echo$t;

Hãy thử trực tuyến!

Hãy thử trực tuyến! Số nguyên Polignac dưới 10000

Pari / GP , 34 byte

n->n%2*prod(i=0,n,!isprime(n-2^i))

Hãy thử trực tuyến!

Brachylog , 15 13 byte

/₂ℕ|>ṗ;?-₍ḃ+1

Hãy thử trực tuyến!

Đầu ra số Polignac lên tới 1000.

Trả về false.số de Polignac và true.cách khác.

Dựa trên câu trả lời đã bị xóa của @ LeakyNun, với một vài lỗi (được đăng với sự cho phép của họ).

(-2 byte bằng cách sử dụng phương thức của @Jonathan Allan để kiểm tra xem số đó có phải là lũy thừa của hai không.)

Số đã cho không phải là số de Polignac nếu:

/₂ℕ              It's an even number
   |>ṗ           Or there exists a prime number less than the input
      ;?-₍       which when subtracted from the input
          ḃ      gives a result that has a binary form
           +     such that the sum of the bits 
            1    is 1

Thạch , 13 byte

ÆRạl2=Ḟ$o/o‘Ḃ

Hãy thử trực tuyến!

ÆRạl2=Ḟ$o/     Main link; argument is z
ÆR             Generate all primes in the range [2..z]
  ạ            Absolute difference with z for each prime
   l2          Logarithm Base 2
     =Ḟ$       For each one, check if it's equal to its floored value (i.e. if it is an integer)
        o/     Reduce by Logical OR to check if any prime plus a power of two equals the z
          o‘Ḃ  Or it's not an odd number. If it's not an odd number, then automatically return 1 (false).

Đầu ra 1cho sai và 0đúng.

Perl 6 , 55 byte

{so$_%2&&$_∉((1,2,4...*>$_) [X+] grep &is-prime,^$_)}

Hãy thử trực tuyến!

• (1, 2, 4 ... * > $_) là một chuỗi các lũy thừa của hai cho đến khi đối số đầu vào (Perl nhập chuỗi hình học từ các phần tử được cung cấp).
• grep &is-prime, ^$_ là danh sách các số nguyên tố cho đến đối số đầu vào.
• [X+] đánh giá tổng của tất cả các yếu tố của sản phẩm chéo của hai loạt.

Tôi có thể đã thực hiện mà không cần soít hơn hai byte, nhưng sau đó nó trả về hai giá trị giả ( 0và False) khác biệt .

Tiên đề, 86 byte

f(n:PI):Boolean==(~odd?(n)=>false;d:=1;repeat(n<=d or prime?(n-d)=>break;d:=d*2);n<=d)

kiểm tra và kết quả

(21) -> for i in 1..600 repeat if f(i) then output i
   1
   127
   149
   251
   331
   337
   373
   509
   599

Haskell, 104 102 byte

p x=[x]==[i|i<-[2..x],x`mod`i<1]
h k|even k=1>2|2>1=notElem k$((+)<$>(2^)<$>[0..k])<*>filter(p)[1..k]

Giải trình

• p là hàm tìm số nguyên tố (rất kém hiệu quả!)
• Tạo danh sách (+)áp dụng cho chức năng một phần 2 ^ được áp dụng cho danh sách [0..input]
• Áp dụng ở trên vào danh sách được lọc 1 vào đầu vào cho các số nguyên tố
• Kết quả sản phẩm cartesian của mọi giá trị có thể được tìm kiếm để đảm bảo đầu vào không tồn tại trong sản phẩm cartesian
• Được bảo vệ để đảm bảo rằng một đầu vào chẵn tự động là sai.

CẬP NHẬT: Hét lên với Einkorn Enchanter để chơi gôn hai byte!

Lisp thông thường, 134 byte

(lambda(x)(flet((p(x)(loop for i from 2 below x always(>(mod x i)0))))(or(evenp x)(do((j 1(* j 2))(m()(p(- x j))))((or(>= j x)m)m)))))

Trả về NILkhi đối số là số Polignac, Tnếu không.

Hãy thử trực tuyến!

Ung dung:

(lambda (n)
  (flet ((prime? (x)                 ; x is prime
           loop for i from 2 below x ; if for i in [2..n-1]
           always (> (mod x i) 0)))  ; is x is not divisible by i
    (or (evenp n)                    ; if n is even is not a Polignac number
        (do ((j 1( * j 2))           ; loop with j = 2^i, i = 0, 1,... 
             (m () (prime? (- n j)))); m = n - 2^i is prime?
            ((or (>= j n)            ; terminate if 2^i ≥ n
                 m)                  ; or if n - 2^i is prime
             m)))))                  ; not a polignac if n - 2^i is prime

APL (Dyalog mở rộng) , 12 byte

⍱2∘|⍲0⍭⊢-2*…

Hãy thử trực tuyến!

Chức năng ẩn danh tiền tố ẩn danh. Trả về 1 cho sự thật, 0 cho giả.

Phần lớn dựa trên câu trả lời Japt của ETH Productstions .

Cảm ơn @ Adám đã giúp đánh golf câu trả lời ban đầu của tôi và đã tạo ra Dyalog Extended cho vấn đề đó.

Làm sao:

⍱2∘|⍲0⍭⊢-2*…   ⍝ Tacit prefix function; input will be called ⍵
           …    ⍝ Inclusive Range [0..⍵]
         2*     ⍝ 2 to the power of each number in the range
       ⊢-       ⍝ Subtract each from ⍵
     0⍭         ⍝ Non-primality check on each resulting number
    ⍲           ⍝ Logical NAND
 2∘|            ⍝ Mod 2
⍱               ⍝ Not any (bitwise OR reduction, then negated)

Python 2 , 98 byte

lambda x:not(x%2<1or any((lambda x:x>1and all(x%j for j in range(2,x)))(x-2**i)for i in range(x)))

Hãy thử trực tuyến!

Bình thường , 14 byte

&%Q2!smP-^2dQl

Thử nó!

Julia 0,4 , 31 byte

n->n%2*!any(ispow2,n-primes(n))

Hãy thử trực tuyến!

APL (NARS) 80 ký tự, 160 byte

∇r←f w;n
r←¯1⋄→0×⍳(w≤0)∨w≥9E9⋄r←0⋄→0×⍳0=2∣w⋄n←r←1
→0×⍳w≤n⋄→3×⍳0πw-n⋄n×←2⋄→2
r←0
∇

Hàm 0π là hàm trả về đối số của nó có phải là số nguyên tố hay không. Đối với tôi chức năng này không được đệ quy nên nó dài hơn một chút ... Kiểm tra:

  {1=f ⍵:⍵⋄⍬}¨1..1000
1  127  149  251  331  337  373  509  599  701  757  809  877  905  907  959  977  997 

đối với đầu vào <= 0 hoặc đầu vào> = 9E9, nó trả về ¯1 (lỗi)

  f¨0 ¯1 ¯2 900000000001
¯1 ¯1 ¯1 ¯1 

C # (Trình biên dịch tương tác Visual C #) , 107 byte

x=>{var r=Enumerable.Range(2,x);return x%2>0&r.All(p=>r.Any(d=>d<p&p%d<1)|r.All(n=>x!=p+Math.Pow(2,n-2)));}

Hãy thử trực tuyến!

Không phải là mã hiệu quả nhất, nhưng dường như làm việc. Giải pháp ban đầu của tôi đã lọc các số nguyên tố trước khi kiểm tra chúng trong công thức và nó hoạt động tốt hơn nhiều. Phiên bản hiện tại ngắn hơn 11 byte.

// input x is an integer
x=>{
  // we need to generate several
  // ranges. since this is verbose,
  // generate 1 and keep a reference
  var r=Enumerable.Range(2,x);
  // this is the main condition
  return
     // input must be odd
     x%2>0&
     // generate all possible p's
     // over our range and ensure that
     // they satisfy the following
     r.All(p=>
       // either p is not prime
       r.Any(d=>d<p&p%d<1)
       |
       // or there is no n that satisfies
       // the formula: x=p+2^n
       r.All(n=>x!=p+Math.Pow(2,n-2))
     );
}