숫자는 홀수 이고 p + 2 ⁿ 형식으로 표현할 수없는 경우에만 폴리곤 숫자입니다. 여기서 n 은 음이 아닌 정수이고 p 는 소수입니다.

태스크

양의 정수를 사용하고 그것이 Polignac 수인지 결정하는 코드를 작성하십시오. 하나는 true, 하나는 false의 두 가지 고유 한 값을 출력 할 수 있습니다. 바이트 수를 최소화하는 것을 목표로해야합니다.

테스트 사례

긍정적 인 경우 여기에 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, ...

부정적인 경우는 다음과 같습니다.

22, 57

Japt , 9 14 13 바이트

o!²mnU dj |Uv

온라인으로 테스트하십시오! 또는 1000 미만의 모든 Polignac 정수를 찾으십시오 .

1허위 입력 및 진실에 대한 출력 0.

설명

 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

젤리 , 11 10 바이트

@Dennis 덕분에 1 바이트 절약

Ḷ2*³_ÆPS<Ḃ

온라인으로 사용해보십시오!

작동 원리

Ḷ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.

자바 스크립트 (ES6),  56 54  53 바이트

$0$ 또는 $1$ 반환합니다 .

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

온라인으로 사용해보십시오!

방법?

$p = 1$ 시작 합니다. $y = n - p$ 가 합성 인지 테스트 하고 그에 따라 부울을 생성합니다. 다음 테스트는 $p \times 2$ 수행됩니다 .

즉시로 $p$ 보다 큰 $n$ , 우리는 재귀 및 반환 중지 $n$ .

모든 반복의 결과는 AND이며, 부울 값을 $0$ 또는 $1$ 로 강제 변환합니다 .

모든 중간 결과가 사실이라면 우리는 다음과 같은 비트 테스트로 끝납니다.

1 & 1 & 1 & n

이것은 n 이 홀수 인 경우에만 $1$ 제공 하는데, 이는 입력을 de Polignac 번호로 검증하는 데 필요한 마지막 조건입니다.$n$

파이썬 2 , 60 57 56 바이트

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

온라인으로 사용해보십시오!

젤리 , 10 바이트

이미 게시 된 것에 대한 대체 10 바이트 젤리 제출.

_ÆRBS€’×ḂẠ

Polignac 번호 로 1 을 반환 하고 그렇지 않으면 0 을 반환하는 모나드 링크 .

온라인으로 사용해보십시오! 또는 1000 미만의 사람들을 참조하십시오.

방법?

_Æ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 바이트

Emigna 덕분에 -1 바이트

Ýo-pZ¹È~

0정확한 입력 및 잘못된 입력에 대한 출력 1.

온라인으로 사용해보십시오!

파이썬 2 , 99 바이트

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

온라인으로 사용해보십시오!

Leaky Nun 덕분에 -4 바이트

Wondercricket 덕분에 -2 바이트

실수를 고치기 위해 +8 바이트

Mr. Xcoder 덕분에 -1 바이트

Einkorn Enchanter 덕분에 -3 바이트

실수를 고치기 위해 +12 바이트

정규식 (ECMAScript), 97 바이트

이 문제는 비 원자 lookahead가없는 문제를 해결하는 흥미로운 사례를 제시했습니다. 그리고 지금까지 내가이 테스트의 힘의 두 버전을 모두 넣어 좋은 이유를 했어 유일한 시간이다, ((x+)(?=\2$))*x$와 (?!(x(xx)+)\1*$)같은 정규 표현식에서, 유일한 시간은 지금까지 내가 일치에 대한 주요 테스트를 보호하기 위해 필요한 것 (1)로서 (?!(xx+)\1+$)xx,보다 큰 정규 표현식에서 사용하는 경우.

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

온라인으로 사용해보십시오!

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

정규식 (ECMAScript + 분자 lookahead), 53 52 바이트

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

이 버전은 N이 두 숫자의 합인 가능한 모든 방법을 순환 해야하는 대신 N에서 2의 모든 거듭 제곱을 빼고 순환하는 것의 차이를 테스트 할 수 있기 때문에 훨씬 깨끗하지만 훨씬 빠릅니다. .

분자 lookahead는 가변 길이 lookbehind로 쉽게 변환 할 수 있습니다.

정규식 (.NET 또는 ECMAScript 2018) 55 54 바이트

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

온라인으로 사용해보십시오! (.NET)
온라인으로 사용해보십시오! (ECMAScript 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
    )
)

수학, 41 바이트

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

PHP , 75 바이트

진실을 위해 1을, 거짓을 위해 0을 인쇄합니다

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

온라인으로 사용해보십시오!

온라인으로 사용해보십시오! 10000 미만의 Polignac 정수

Pari / GP , 34 바이트

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

온라인으로 사용해보십시오!

Brachylog , 15 13 바이트

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

온라인으로 사용해보십시오!

Polignac 수를 1000까지 출력합니다.

보고 false. 드 Polignac 번호와 대한 true.그렇지 않으면.

@LeakyNun의 삭제 된 답변과 몇 가지 버그 수정 (허가로 게시 됨)을 기반으로합니다.

(@Jonathan Allan의 방법을 사용하여 숫자가 2의 거듭 제곱인지 확인하여 2 바이트.)

다음과 같은 경우 주어진 숫자는 de Polignac 숫자가 아닙니다.

/₂ℕ              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

젤리 , 13 바이트

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

온라인으로 사용해보십시오!

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

1거짓과 0참에 대한 출력 .

펄 6 , 55 바이트

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

온라인으로 사용해보십시오!

• (1, 2, 4 ... * > $_) 입력 인수까지의 2의 거듭 제곱 시퀀스입니다 (Perl은 제공된 요소에서 기하 계열을 추론합니다).
• grep &is-prime, ^$_ 입력 인수까지의 소수 목록입니다.
• [X+] 두 계열의 교차 곱의 모든 요소의 합을 평가합니다.

나는 so2 바이트 이하로 수행 할 수 없었지만 두 개의 잘못된 거짓 값 ( 0및 False)을 반환합니다 .

공리, 86 바이트

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

테스트 및 결과

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

하스켈 104 102 바이트

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]

설명

• p는 소수를 찾는 함수입니다 (매우 비효율적입니다!)
• 리스트에 (+)적용되는 2 ^ 부분 함수에 적용되는리스트 생성 [0..input]
• 필터링 된 목록에 위의 내용을 적용하여 소수 입력
• 직교 곱에 입력이 존재하지 않도록 가능한 모든 값의 결과 직교 곱을 검색합니다.
• 짝수 입력이 자동으로 거짓인지 확인합니다.

업데이트 : 2 바이트 골프를 위해 Einkorn Enchanter에게 외치십시오!

공통 리스프, 134 바이트

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

반환 NIL인수가 Polignac 번호 인 경우, T그렇지.

온라인으로 사용해보십시오!

언 골프 드 :

(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 Extended) , 12 바이트

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

온라인으로 사용해보십시오!

익명 접두사 암묵적 기능. 진실의 경우 1을, 거짓의 경우 0을 반환합니다.

대체로 ETHProductions의 Japt 답변을 합니다.

원래 답변을 골라 내고 Dyalog Extended를이 문제에 대해 알려 주신 @ Adám에게 감사드립니다.

방법:

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

파이썬 2 , 98 바이트

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

온라인으로 사용해보십시오!

Pyth , 14 바이트

&%Q2!smP-^2dQl

시도 해봐!

Julia 0.4 , 31 바이트

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

온라인으로 사용해보십시오!

APL (NARS) 80 자, 160 바이트

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

함수 0π는 인수를 리턴하는 함수가 소수입니다. 나를 위해이 함수는 재귀 적이 지 않으므로 조금 더 길다 ... 테스트 :

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

입력 <= 0 또는 입력> = 9E9의 경우 ¯1 (오류)을 반환합니다.

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

C # (Visual C # 대화식 컴파일러) , 107 바이트

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

온라인으로 사용해보십시오!

가장 효율적인 코드는 아니지만 작동하는 것 같습니다. 내 원래 솔루션 은 수식에서 테스트하기 전에 소수를 필터링했으며 훨씬 더 잘 수행했습니다. 현재 버전은 11 바이트 더 짧습니다.

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