परिभाषित करें कि प्राकृतिक संख्या पी एक है +1 प्रधानमंत्री प्राकृतिक संख्या के n अगर पी का एक प्रमुख संख्या और मानक द्विआधारी प्रतिनिधित्व है (यानी, अग्रणी शून्य के बिना) पी जोड़ने (यानी, prepending, जोड़कर या डालने) द्वारा प्राप्त किया जा सकता n के मानक बाइनरी प्रतिनिधित्व के लिए एक एकल 1 ।

उदाहरण के लिए, 17 का द्विआधारी प्रतिनिधित्व 10001 _{2 है} । विशिष्ट प्राकृतिक संख्या है कि एक जोड़कर गठन किया जा सकता 1 करने के लिए 10001 ₂ हैं 110001 ₂ या 49 , 101,001 ₂ या 41 , 100,101 ₂ या 37 , और 100,011 ₂ या 35 ।

इनमें से 41 और 37 अभाज्य संख्याएँ हैं, इसलिए 17 में दो +1 प्राइम हैं ।

कार्य

एक प्रोग्राम या समारोह है कि एक सख्ती से सकारात्मक पूर्णांक स्वीकार करता लिखें n इनपुट और प्रिंट या रिटर्न अलग की संख्या के रूप में +1 अभाज्य संख्या की एन ।

इनपुट और आउटपुट या तो पूर्णांक होना चाहिए, या इसका दशमलव या यूनीरी स्ट्रिंग प्रतिनिधित्व होना चाहिए।

मानक कोड-गोल्फ नियम लागू होते हैं।

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

Input:  4
Output: 0

Input:  1
Output: 1

Input:  17
Output: 2

Input:  33
Output: 3

Input:  553
Output: 4

Input:  3273
Output: 5

Input:  4145
Output: 6

Input:  4109
Output: 7

Input:  196869
Output: 8

— डेनिस
स्रोत

1

ठंडा! अगर मेरे पास आज रात का समय होता तो मैं अभी जवाब देता

— एकोक्विक्लेर

5

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

s/LPd{mij\1c.BQ]d2hQ

परीक्षण सूट

s/LPd{mij\1c.BQ]d2hQ
                        Q = eval(input())
      m           hQ    For insertion position in [0 ... Q]
            .BQ         Convert Q to binary string
           c   ]d       Chop at insertion position
        j\1             Join on '1'
       i         2      Convert to integer
     {                  Deduplicate
 /LPd                   Map each number to the number of times it occurs in its
                        prime factorization, e.g. whether or not it is prime.
s                       Sum and print.

— isaacg
स्रोत

1

हुह, "समर्पण" वास्तव में एक शब्द है।

— lirtosiast

8

जावास्क्रिप्ट ईएस 6, 141 बाइट 143 147 160

13 बाइट्स बचाता है, @Naouak को धन्यवाद

n=>[...t=n.toString(2)].map((l,i)=>t.slice(0,v=i+1)+1+t.slice(v)).filter((l,i,a)=>a.indexOf(l)==i&&(p=(n,c)=>n%c&&c>n-2||p(n,++c))('0b'+l,2))

मेरे TeaScript जवाब के लिए इसी तरह की विधि, RegExp का उपयोग करता है (आपने मुझे सही सुना) primes की जांच करने के लिए।

Ungolfed

n=>
   [...t = n.toString(2)]                  // To binary
   .map((l,i)=>                            // Make cycles
               t.slice(0, v = i+1)
               + 1
               + t.slice(v)
   ).filter((l,i,a)=>  
                     a.indexOf(l) == i &&  // Remove Duplicates
                     (p=(n,c)=>            // Prime checking
                               n % c &&
                                 c > n - 2 ||
                                 p(n,++c)
                     )('0b'+l,2)
   ).length

— Downgoat
स्रोत

मुझे लगता है कि आप इस तरह से थोड़ा सा प्राइम चेकिंग को छोटा कर सकते हैं: (p=(n,c)=>n%c!=0?c>=n-1?1:p(n,++c):0)('0b'+l,2)इसके बजाय!Array(+('0b'+l)+1).join(1).match(/^1?$|^(11+?)\1+$/)

— नौवैक

@ नौआक भयानक जो 13 बाइट्स बचाता है! :)

— डाउनवेज

4

मिंकोलंग 0.11 , 54 52 बाइट्स

n1(2*d0c`,)(0c1c$%$r2*1c*1c++1g2:d1G)rxSI1-[0g2M+]N.

व्याख्या

n             Get integer from input (let's call it n)
1(       )    Get the smallest power of 2 (say, k) greater than input (starting with 1)
  2*d         Multiply by 2 and duplicate
     0c`,     Copy n and see if it's greater (while loop breaks on 0)

(0c1c$%                       Copy n, copy k, and divmod (pushes n//k, n%k)
       $r                     Swap top two elements
         2*                   Multiply by 2
           1c*                Copy k and multiply
              1c+             Copy k and add
                 +            Add
                  1g2:        Get k and divide by 2
                      d1G)    Duplicate and put one copy back in its former place

rx            Reverse and dump (dumps n and top of stack is now 0)
S             Remove duplicates
I1-[     ]    Check each element for primality
    0g        Get potential prime from bottom of stack
      2M      1 if prime, 0 otherwise
        +     Add (this is why I didn't dump the left-over 0 earlier)
N.            Output as integer and stop.

— एलेंडिया स्ट्राटन
स्रोत

मैं हमेशा एक और मिंकोलंग संस्करण कहने के लिए उत्साहित हूं।

— कोनोर ओ'ब्रायन

4

टीस्क्रिप्ट , 22 बाइट्स

x÷¿®x÷E(i¬,1)¤©d¡F(¥)n

TeaScript एपीएल की तरह दिखना शुरू हो रहा है ... विशेष वर्ण लंबे, आमतौर पर दोहराए जाने वाले दृश्यों में परिवर्तित हो जाते हैं

ऑनलाइन इंटरप्रिटर यह जांचना सुनिश्चित करें कि "इनपुट नंबर हैं।"

स्पष्टीकरण और & nbsp;

xT(2)s``m(#P(xT(2)E(i+1,1),2))d()F($P)n

xT(2)      // Take input, convert to binary
s``m(#     // Loop over input

  P(         // Convert to decimal...
     xT(2)     // Input to binary
     E(i+1,1)  // Inset 1 into (above) at current index in loop
  ,2)    

)d()       // Remove duplicates
F($P)      // Filter items that aren't prime
n          // Grab length.

— Downgoat
स्रोत

यह 31 बाइट्स है, वैसे, Xubuntu पर ग्लेडिट का उपयोग करके

— ग्लेन ओ

1

यह UTF-8 एन्कोडिंग के साथ 31 बाइट्स है, लेकिन ISO-8859-1 के साथ 22 बाइट्स है।

— डेनिस

4

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

n->sum(isprime,∪(2n+(k=2.^(0:endof(bin(n))))-n%k))

k=2.^(0:endof(bin(n)))एक सरणी उत्पन्न करता है जिसमें 2 की शक्तियाँ 1 से उच्चतम शक्ति से कम होती हैं n। 2n+k-n%kफिर सभी संभावित "+1 नंबर" निर्धारित करने के लिए सरणी संचालन का उपयोग करता है। ∪(समतुल्य union, जो uniqueइस स्थिति में जैसा करता है) दोहराए गए मूल्यों को हटा देता है। फिर sum(isprime,)सूची में primes की संख्या गिना जाता है।

— ग्लेन हे
स्रोत

4

सीजेएम, 26 बाइट्स

विजेता नहीं, लेकिन यह मौजूदा सीजेएम के जवाबों को काफी ठोस रूप से हराता है और यह पहली बार मुझे 0.6.5 कमांड का उपयोग करने के लिए मिला है e\।

1ri2b+_,{_)e\_}%_&{2bmp},,

इसका परीक्षण यहां करें।

व्याख्या

1       e# Push a 1 (this is the 1 we'll be inserting everywhere).
ri      e# Read input and convert to integer.
2b      e# Convert to base 2.
+       e# Prepend the 1.
_,      e# Duplicate and get the number of bits N.
{       e# Map this block over i from 0 to N-1...
  _)    e#   Create a copy and increment to i+1.
  e\    e#   Swap the bits at positions i and i+1, moving the 1 one step through the array.
  _     e#   Duplicate so we keep this version on the stack.
}%
_&      e# Remove duplicates via set intersection with itself.
{       e# Filter the remaining digit lists based on this block...
  2b    e#   Convert bits back to an integer.
  mp    e#   Test for primality.
},
,       e# Get the length of the remaining list.

ध्यान देने योग्य एक बात यह है कि हम पहली प्रति बनाने से पहले 0और बाद में बिट्स स्वैप करते हैं 1, इसलिए हम 1सामने की ओर पूर्वनिर्मित के साथ मूल सरणी खो देते हैं । हालांकि, इनपुट हमेशा सकारात्मक होता है, इसलिए अग्रणी अंक हमेशा एक होगा। इसका मतलब है कि एक दूसरे को तैयार करने के बाद, अंकों की सूची हमेशा शुरू हो जाएगी, [1 1 ...]इसलिए किसी भी मामले में पहली स्वैप कोई नहीं होगा।

— मार्टिन एंडर
स्रोत

3

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

Union[#~FromDigits~2&/@StringReplaceList[#~IntegerString~2,a_:>a<>"1"]]~Count~_?PrimeQ&

— LegionMammal978
स्रोत

3

जूलिया, 110 108 104 87 बाइट्स

n->sum(i->isprime(parse(Int,i,2)),(b=bin(n);∪([b[[1:i;1;i+1:end]]for i=1:endof(b)])))

यह एक अनाम फ़ंक्शन बनाता है जो पूर्णांक को स्वीकार करता है और पूर्णांक देता है। इसे कॉल करने के लिए, इसे एक नाम दें, उदा f=n->...।

Ungolfed:

function f(n::Integer)
    # Get the binary representation of n as a string
    b = bin(n)

    # Construct an array consisting of binary strings with
    # a one prepended, appended, and each insertion
    x = [b[[1:i; 1; i+1:end]] for i = 1:endof(b)]

    # Count the number of primes
    c = sum(i -> isprime(parse(Int, i, 2)), unique(x))

    return c
end

ग्लेन ओ को 17 बाइट्स धन्यवाद!

— एलेक्स ए।
स्रोत

bin1 से शुरू करना है, इसलिए आपको अलग से संभालने की आवश्यकता नहीं है "1"b। और जब i=length(b), आप के b[i+1:end]बराबर होगा "", तो उस प्रविष्टि के लिए कोई ज़रूरत नहीं है (बस b=bin(n)कुछ बिंदु पर संभाल करने की आवश्यकता है )। और दो कम बाइट के लिए sumएक ही काम करेंगे count।

— ग्लेन ओ

इसके अलावा, चूंकि आप किसी bभी तरह की लंबाई पर एक सीमा का उपयोग करने जा रहे हैं, इसलिए इसे थोड़ी सी चाल के साथ प्राप्त कर सकते हैं - b=bin(n)[s=1:end]और फिर for i=sसमझ के लिए।

— ग्लेन ओ

आप इस तथ्य का उपयोग करके एक और बाइट भी बचा सकते हैं कि bin1 में पहला बिट होना चाहिए, और आपको यह मिलेगा: n->sum(i->isprime(parse(Int,i,2)),(b=bin(n);unique([b[[1:i;1;i+1:end]]for i=1:endof(b)])))- यह गिनती को 90 बाइट्स तक ले आता है।

— ग्लेन ओ

वास्तव में, एक और बाइट को हटा दें, के uniqueसाथ प्रतिस्थापित करके union- यह एक ही काम करेगा, अगर इनपुट के रूप में केवल एक ही सरणी दी जाए। या ∪इसके बजाय अभी तक बेहतर है union।

— Glen O

@ गेलनो तुम मास्टर हो। धन्यवाद, 先生!

— एलेक्स ए।

2

सीजेएम, 58 बाइट्स

L{:TQ\=A+Q\+TWe\-2<s:~2b}q~2b0+:Q,(%{:BLe=!{B+:L}&}%~:mp:+

यह मुझे एक दिन लगा, और यह मेरी 4 वीं यात्रा थी।

— anOKsquirrel
स्रोत

2

जाप `-x` , 14 11 बाइट्स

Æ¤iX1Ãâ ®Íj

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

Æ¤iX1Ãâ ®Íj     :Implicit input of integer U
Æ               :Map each X in the range [0,U)
 ¤              :  Convert U to binary string
  iX1           :  Insert "1" at 0-based index X
     Ã          :End map
      â         :Deduplicate
        ®       :Map
         Í      :  Convert to decimal
          j     :  Is prime?
                :Implicit output of array sum

— झबरा
स्रोत

1

PHP, 145 बाइट्स

मैंने पठनीयता के लिए एक नई पंक्ति जोड़ी है:

function($n){for($b=base_convert;++$i<=strlen($s=$b($n,10,2));$r+=!$s[$i]&$k<=$j)
for($j=1;($k=$b(substr_replace($s,1,$i,0),2,10))%++$j;);echo$r;}

— ब्लैक होल
स्रोत

1

CJam, 34 बाइट्स

li2b_,),\f{_2$<@@>1\++}_&2fb{mp},,

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

पहला संस्करण, अद्यतन करेगा अगर मैं कुछ बेहतर के साथ आता हूं।

— रेटो कोराडी
स्रोत

1

एपीएल, ५५

{+/{2=+/0=⍵|⍨⍳⍵}¨∪⍵{2⊥(⍵↑X),1,⍵↓X←⍺⊤⍨N⍴2}¨-1-⍳N←1+⌊2⍟⍵}

2 बाइट्स Dyalog- विशिष्ट संस्करण:

{+/2=+/¨0=|⍨∘⍳⍨¨∪⍵{2⊥⍵(↑,(1∘,↓))⍺⊤⍨N⍴2}¨-1-⍳N←1+⌊2⍟⍵}

— user46915
स्रोत

1

मतलाब (120)

n=input('');a=dec2bin(n);g=arrayfun(@(x)bin2dec(cat(2,a(1:x),49,a(x+1:end))),1:log2(n));nnz(unique(g(find(isprime(g)))))

अधिक गोल्फ प्रगति पर है ...

— Abr001am
स्रोत

1

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

{ḃ~c₂{,1}ʰc~ḃṗ}ᶜ¹

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

इनपुट चर और आउटपुट के माध्यम से इनपुट आउटपुट चर के माध्यम से।

{             }ᶜ¹    Count every unique
             ṗ       prime number
           ~ḃ        the binary representation of which is
 ḃ                   the binary representation of the input
  ~c₂                partitioned into two (possibly empty) lists
     {  }ʰ           with the first list
      ,1             having a 1 appended
          c          and the two lists then being concatenated back into one.

— असंबंधित स्ट्रिंग
स्रोत

1

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

BLṬkj1ʋ€$QḄẒS

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

— आउटगोल्फर को एरिक करें
स्रोत

0

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

lambda n:sum(all(i%j for j in range(2,i))for i in{n%2**i+((n>>i)*2+1<<i)for i in range(len(bin(n))-2)})

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

— आउटगोल्फर को एरिक करें
स्रोत

गिनती 1 primes

कार्य

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

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

जावास्क्रिप्ट ईएस 6, 141 बाइट 143 147 160

Ungolfed

मिंकोलंग 0.11 , 54 52 बाइट्स

व्याख्या

टीस्क्रिप्ट , 22 बाइट्स

स्पष्टीकरण और & nbsp;

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

सीजेएम, 26 बाइट्स

व्याख्या

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

जूलिया, 110 108 104 87 बाइट्स

सीजेएम, 58 बाइट्स

जाप -x , 14 11 बाइट्स

PHP, 145 बाइट्स

CJam, 34 बाइट्स

एपीएल, ५५

मतलाब (120)

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

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

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

जाप `-x` , 14 11 बाइट्स