एक संख्या एक डी पोलिग्नैक संख्या है यदि और केवल अगर यह विषम है और इसे p + 2 ⁿ के रूप में प्रस्तुत नहीं किया जा सकता है जहां n एक गैर-नकारात्मक पूर्णांक है और p एक प्रमुख पूर्णांक है।

कार्य

कुछ कोड लिखें जो एक सकारात्मक पूर्णांक लेता है और यह निर्धारित करता है कि क्या यह डी पोलिग्नैक संख्या है। आप दो अलग-अलग मूल्यों को एक के लिए और एक को झूठे के लिए आउटपुट कर सकते हैं। आपको अपनी बाइट काउंट को कम करने का लक्ष्य रखना चाहिए।

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

सकारात्मक मामलों के लिए यहाँ 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

— गेहूं का जादूगर
स्रोत

क्या हमारे पास दो अलग-अलग आउटपुट के बजाय सत्य और मिथ्या आउटपुट हो सकते हैं?

— ओकेक्स

@ ओके मैं नहीं कहने जा रहा हूं।

— गेहूं जादूगर

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— गेहूं जादूगर

इर ... नकारात्मक मामलों के लिए, यह मूल रूप से किसी भी संख्या में सही नहीं है? यह सुनिश्चित करते हुए कि मैं कुछ स्पष्ट याद नहीं कर रहा हूँ।

— मैजिक ऑक्टोपस यूरेन

@MagicOctopusUrn हाँ।

— गेहूं जादूगर

11

जाप , ९ १४ १३ बाइट्स

o!²mnU dj |Uv

इसे ऑनलाइन टेस्ट करें! या 1000 के तहत सभी डी पोलिग्नैक पूर्णांक खोजें ।

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

— ETHproductions
स्रोत

ऐसा लगता है कि 2 और 3 के लिए गलत परिणाम दे रहा है; यह लौट रहा है, falseलेकिन वे पॉलिग्नैक संख्या नहीं हैं।

— झबरा

@ शैगी 3तय हो गई है, लेकिन हमें पहले भी मामलों को संभालने की जरूरत नहीं थी। फिक्सिंग।

— ETHproductions

@ शैगी अब ठीक हो गई।

— ETHproductions

मैं यह कहने वाला था कि यह एक अच्छी बात है कि 3किसी भी बाइट की कीमत तय नहीं की गई थी, तब मैंने इसके लिए फिक्स देखा 2- आउच!

— झबरा

: ओ +1 प्रतिस्पर्धी कार्यक्रम के लिए जो एन्कोडिंग त्रुटि की तरह नहीं दिखता है

— डाउनगैट

8

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

— ETHproductions
स्रोत

Ḷ2*⁸_ÆPS<Ḃ एक बाइट बचाता है। tio.run/##ASQA2/9qZWxsef//4bi2Mirigbhfw4ZQUzzhuIL/…

— डेनिस

@ डेनिस धन्यवाद, मुझे पता था कि 3-बाइट का विकल्प होना चाहिए ¬;ḂẠ। S<Ḃबॉक्स के बाहर रास्ता है, हालांकि, कम से कम मेरे लिए :-)

— ETHproductions

8

जावास्क्रिप्ट (ईएस 6), 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$ वापस करते हैं ।

सभी पुनरावृत्तियों के परिणाम एक साथ $0$ या को बूलियन मानों के साथ जोड़ रहे हैं $1$ ।

बशर्ते कि सभी मध्यवर्ती परिणाम सत्य थे, हम एक बिटवाइज़ टेस्ट जैसे:

1 & 1 & 1 & n

यह $1$ देता है और केवल अगर $n$ विषम है, जो कि डे पोलिग्नैक नंबर के रूप में इनपुट को मान्य करने के लिए आवश्यक अंतिम शर्त है।

— Arnauld
स्रोत

3

महान तकनीक। संभवतः एकमात्र वैध उत्तर जो स्पष्ट रूप से n%2या समान नहीं कहता है : P

— ETHproductions

यह प्रपत्र 2 ^ M + 1 के डी पोलिग्नैक संख्याओं के लिए गलत नकारात्मक है, जैसे कि 262145 और 2097153 (बाद वाले 4747366482869645213697, 38685626227858133590597633, 519229685858276285304949632932009797), आदि हैं। उदाहरण के लिए, यह 262139, 262259, 2097131 और 2097187 की सही पहचान करता है, क्योंकि यह एक समस्या है कि संख्याओं की सबसे बड़ी नहीं है। बेशक पुनरावृत्ति के कारण, मुझे इसे जांचने के लिए स्टैक के आकार को कुछ बहुत बड़ा करना पड़ा, और केवल ऊपर सूचीबद्ध पहले दो 2 ^ M + 1 de Polignac नंबरों के आस-पास की श्रेणियों का परीक्षण किया।

— डेडकोड

1

@Deadcode इस रिपोर्ट के लिए धन्यवाद। अब तय हो गया।

— अरनौलद

1

@Arnauld आह, आप सही कह रहे हैं :) बस कुछ निश्चित करने के लिए, मैंने यह किया और पर्याप्त यकीन है, यह तय है।

— डेडकोड

1

@ डेडकोड नीट! :)

— अरनुलद

7

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

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

— डेनिस
स्रोत

वाह, यह प्रभावशाली रूप से अक्षम है। विल्सन की प्रमेय के माध्यम से प्रधान परीक्षा । प्लस साइड पर यह 262145 और 2097153 के लिए सही ढंग से काम करता है (असीमित स्टैक और बिग्नम आकार को मानते हुए); कुछ अन्य प्रस्तुतियाँ नहीं हैं। इसका प्रधान-प्रधान एल्गोरिथ्म 4 के लिए "सत्य" है, क्योंकि (-6)% 4 = 2 है, लेकिन इससे समस्या समाप्त नहीं होती है क्योंकि संख्याओं को भी अस्वीकार कर दिया जाता है &n&। नंबर 5 एक गलत नकारात्मक होगा यदि यह एक डी पोलिग्नैक नंबर था, क्योंकि 1 + 4 = 5, लेकिन यह एक समस्या नहीं है क्योंकि 2 + 3 = 5 वैसे भी।

— डेडकोड

7

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

एक वैकल्पिक 10-बाइट जेली प्रस्तुत करने के लिए पहले से ही पोस्ट।

_ÆRBS€’×ḂẠ

एक Poladac संख्या और 0 अन्यथा के लिए एक लौटाने वाला लिंक 1 ।

इसे ऑनलाइन आज़माएं! या 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

— जोनाथन एलन
स्रोत

मुझे यह समझने में लगभग 10 मिनट लगे कि यह कैसे काम करता है ... महान तकनीक, मैं यह जांचने के लिए एक अच्छा तरीका नहीं सोच सकता था कि क्या किसी सरणी में दो की कोई शक्तियां नहीं हैं :-)

— ETHproductions

7

05AB1E , 9 8 बाइट्स

-1 बाइट एमिग्ना के लिए धन्यवाद

Ýo-pZ¹È~

0सत्य आदानों के लिए आउटपुट और 1मिथ्या इनपुट के लिए।

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

— Okx
स्रोत

1åहो सकता है Z।

— एमिगा जूल

@Emigna आह। मुझे पता था कि उस के लिए 1-बाइट विकल्प था!

— ओकेक्स

6

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

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

-4 बाइट्स लीक लियुन के लिए धन्यवाद

-2 बाइट्स वंडरक्रिकेट की बदौलत

एक गलती को ठीक करने के लिए +8 बाइट्स

-1 बाइट मिस्टर एक्सकोडर की बदौलत

-3 बाइट्स Einkorn करामाती के लिए धन्यवाद

एक गलती को ठीक करने के लिए +12 बाइट्स

— HyperNeutrino
स्रोत

मुझे लगता है कि यह पायथन 3 संगत जवाब भी है?

— अरी कूपर-डेविस

1 के लिए यह गलत है और फॉर्म 2 ^ M + 1 के सभी डे पोलिग्नैक नंबरों के लिए, जैसे कि 262145 और 2097153 (बाद वाले 4747366482869645213697, 38685826227668133590597633, 51922968585827628530304963232323232) हैं। उदाहरण के लिए, यह 262139, 262259, 2097131 और 2097187 की सही पहचान करता है, क्योंकि यह एक समस्या है कि संख्याओं की सबसे बड़ी नहीं है।

— डेडकोड

1

@Deadcode स्पष्ट जाँच सुनिश्चित करने के लिए कि "प्राइम" 1 नहीं है; अब काम करना चाहिए

— HyperNeutrino

6

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

इस समस्या ने गैर-परमाणु लुकाहेड की कमी की समस्या के आसपास काम करने के लिए एक दिलचस्प मामला पेश किया। और यह अब तक का एकमात्र समय है जब मेरे पास 2 परीक्षण की शक्ति के दोनों संस्करणों को रखने का एक अच्छा कारण है, ((x+)(?=\2$))*x$और (?!(x(xx)+)\1*$), एक ही regex में, और अब तक केवल उसी समय जब मुझे मिलान के खिलाफ मुख्य परीक्षण की रक्षा करने की आवश्यकता है 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 + आणविक लुकहेड), 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.
)

यह संस्करण न केवल बहुत क्लीनर है, बल्कि बहुत तेज है, क्योंकि सभी संभावित तरीकों से चक्र करने के बजाय कि एन दो संख्याओं का योग है, यह सिर्फ एन से 2 की हर शक्ति को घटाकर चक्र कर सकता है और प्रमुख होने के लिए अंतर का परीक्षण कर सकता है ।

आणविक लुकहेड को आसानी से एक चर-लंबाई लुकबाइंड में परिवर्तित किया जा सकता है:

रेगेक्स (.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
    )
)

— Deadcode
स्रोत

आपका रेगेक्स ^(?!(x+)((?!(xx+)\3+$)x*(?!(x(xx)+)\4*$)|x(?!(x(xx)+)\6*$)x*(?!(xx+)\8+$)x)?\1$)बहुत अधिक कठिनाई के बिना अनुकूलित किया जा सकता है। फिर, कुछ सावधान विचार के साथ, आगे गोल्फ हो सकता है ^(?!(x+)((x?)(?!(x(x\3)+)\4+$)x*(?!(x(xx)+|\3\3+)\6+$)\3)?\1$)। शॉर्टर अभी तक संभव हो सकता है

— H.PWiz

मेरा सबसे छोटा बहुत धीमा है, हालांकि

— H.PWiz

ओह, (x(xx)+|\3\3+)->(x\3?(xx)+)

— H.PWiz

4

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

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

— alephalpha
स्रोत

1

इसके लिए कोई बिल्टिन नहीं है? वाह, मैं हैरान हूं।

— हाइपरनेत्रिनो

1

यह बहुत कष्टप्रद है कि यहाँ मेथेमेटिका नकारात्मक अभाज्य संख्या समझे प्रधानमंत्री होने के लिए, वरना आप को बदल कर बाइट्स बचा सकता है PrimeQ[#-2^Range[0,Log2@#]]के साथ PrimeQ[#-2^Range[0,#]]द्वारा और उसके बाद PrimeQ[#-2^Range@#/2]।

— ग्रेग मार्टिन

4

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 Integers

— जार्ग हुल्सरमन
स्रोत

4

परी / जीपी , 34 बाइट्स

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

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

— alephalpha
स्रोत

4

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

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

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

आउटपुट डी पॉलिग्नैक संख्या 1000 तक।

false.डी पोलिग्नैक संख्या के लिए रिटर्न और true.अन्यथा।

@ LeakyNun के हटाए गए उत्तर के आधार पर, कुछ बगफिक्स (उनकी अनुमति के साथ पोस्ट किए गए) के साथ।

(नंबर दो की शक्ति है यह जांचने के लिए @ जोनाथन एलन की विधि का उपयोग करके -2 बाइट्स।)

दी गई संख्या एक डे पोलिग्नैक संख्या नहीं है यदि:

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

— sundar - मोनिका को बहाल करना
स्रोत

=h21 बाइट छोटा होगा, लेकिन यह किसी भी काम नहीं करेगा 3।

— घातक

(गैर मोबाइल) स्वयं पर ध्यान दें: 14 बाइट्स इसे ऑनलाइन आज़माएं! । जोनाथन एलन के जेली उत्तर से प्रेरित।

— सूंदर -

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

— सूंदर - मोनिका

अपने नोट्स के लिए अनुस्मारक मुझे लगता है?

— क्रॉपेब

1

@Deadcode जब यह पोस्ट किया गया था तो यह काम करता था, और विभाजन के बारे में कुछ इस बीच बदल गया लगता है - उदाहरण के लिए। इसे ऑनलाइन आज़माएं! 64 के बजाय गलत रिटर्न। इस कमिट से भाषा में बदलाव की संभावना है , लेकिन मैं थोड़ी देर में यहां सक्रिय नहीं हुआ हूं, इसलिए यह नहीं पता कि यह जानबूझकर है या बग।

— सूंदर -

3

जेली , 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सच्चे के लिए आउटपुट ।

— HyperNeutrino
स्रोत

Ḷ2*ạfÆRṆतब समता की जाँच करें

— लीक नून

@LeakyNun Ḷ2*ạfÆRṆo‘Ḃरिटर्न 1दोनों के लिए 127और 22; यह सही नहीं है। जब तक कि आपने क्या सुझाव नहीं दिया।

— हाइपरनेत्रिनो

आपको उपयोग करने की आवश्यकता है और, या नहीं। (या आप मेरी पिछली उपेक्षा को दूर कर सकते हैं और फिर इसे 9/10 बाइट्स में आगे बढ़ा सकते हैं)

— लीक नून

@LeakyNun आपका स्निपेट 0149 के लिए देता है।

— ETHproductions

@ETHproductions सही है। इसे ठीक ạकरने के लिए बदल रहा है _@।

— लीक से हटकर

2

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

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

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

(1, 2, 4 ... * > $_) दो की शक्तियों का एक क्रम है जब तक इनपुट तर्क (पर्ल प्रदान तत्वों से ज्यामितीय श्रृंखला को प्रभावित करता है)।
grep &is-prime, ^$_ इनपुट तर्क तक अभाज्य संख्याओं की सूची है।
[X+] दो श्रृंखलाओं के क्रॉस उत्पाद के सभी तत्वों के योग का मूल्यांकन करता है।

मैं soदो बाइट्स के बिना कम कर सकता था , लेकिन फिर यह दो अलग-अलग मिथ्या मान ( 0और False) देता है।

— शॉन
स्रोत

2

Axiom, 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

— RosLuP
स्रोत

2

हास्केल, 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]
प्राइम के लिए इनपुट करने के लिए फ़िल्टर की गई सूची में उपरोक्त को लागू करना
हर संभव मान के परिणामी कार्टेसियन उत्पाद को यह सुनिश्चित करने के लिए खोजा जाता है कि कार्टेजियन उत्पाद में इनपुट मौजूद नहीं है
यह सुनिश्चित करने के लिए पहरा दिया जाता है कि एक सम इनपुट स्वचालित रूप से गलत है।

अद्यतन: दो बाइट गोल्फिंग के लिए Einkorn करामाती को चिल्लाओ!

— maple_shaft
स्रोत

1

p x=[x]==[i|i<-[2..x],x`mod`i<1]एक छोटी परिक्षण परीक्षा है।

— गेहूं जादूगर

@EinkornEnchanter शानदार कैच! आपने मुझे दो बाइट्स दीं!

— मेपल_शफ्ट

1

आप filter p[1..k]इसके बजाय भी कर सकते हैंfilter(p)[1..k]

— गेहूं जादूगर

1

आम लिस्प, 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।

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

Ungolfed:

(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

— रेंज़ो
स्रोत

1

APL (Dyalog Extended) , 12 बाइट्स

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

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

अनाम उपसर्ग tacit फ़ंक्शन। सत्य के लिए 1 लौटाता है, झूठा के लिए 0।

लगभग ETHProductions 'Japt उत्तर पर आधारित है ।

@ Adám को मेरे मूल उत्तर को प्राप्त करने में मदद करने के लिए और उस मामले के लिए Dyalog को विस्तारित करने के लिए धन्यवाद।

किस तरह:

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

— जे। सल्ल
स्रोत

0

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

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

— officialaimm
स्रोत

0

अजगर , 14 बाइट्स

&%Q2!smP-^2dQl

कोशिश करो!

— KarlKastor
स्रोत

0

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

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

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

— alephalpha
स्रोत

0

एपीएल (एनएआरएस) 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 prime वह फ़ंक्शन है जो अपना तर्क लौटाता है, प्रधान है या नहीं। मेरे लिए यह फ़ंक्शन पुनरावर्ती नहीं है, इसलिए यह थोड़ा अधिक लंबा है ... टेस्ट:

  {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

— RosLuP
स्रोत

0

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 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))
     );
}

— दाना
स्रोत

क्या मेरा नंबर डे पोलिग्नैक नंबर है?

कार्य

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

जाप , ९ १४ १३ बाइट्स

व्याख्या

जेली , 11 10 बाइट्स

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

जावास्क्रिप्ट (ईएस 6), 56 54 53 बाइट्स

कैसे?

पायथन 2 , 60 57 56 बाइट्स

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

कैसे?

05AB1E , 9 8 बाइट्स

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

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

रेगेक्स (ECMAScript + आणविक लुकहेड), 53 52 बाइट्स

रेगेक्स (.NET या ECMAScript 2018), 55 54 बाइट्स

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

PHP , 75 बाइट्स

परी / जीपी , 34 बाइट्स

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

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

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

Axiom, 86 बाइट्स

हास्केल, 104 102 बाइट्स

आम लिस्प, 134 बाइट्स

APL (Dyalog Extended) , 12 बाइट्स

किस तरह:

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

अजगर , 14 बाइट्स

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

एपीएल (एनएआरएस) 80 चार्ट, 160 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 107 बाइट्स