천연 수 있다고 정의 P가 A는 +1 주요한 고유 번호의 해당 하는 경우 , p는 소수 표준 이진 표현된다 (즉, 선행 0없이) P (즉, 덧붙이, 부가 또는 삽입)을 첨가함으로써 얻을 수있다 하나 하나 의 표준 이진 표현 없음 .

예를 들어 17 의 이진 표현 은 10001 ₂ 입니다. 1 에 10001 ₂ 를 더하여 형성 할 수있는 고유 한 자연수 는 110001 ₂ 또는 49 , 101001 ₂ 또는 41 , 100101 ₂ 또는 37 , 100011 ₂ 또는 35 입니다.

이 중 41 과 37 은 소수이므로 17 은 두 개의 +1 소수 입니다.

태스크

엄격히 양의 정수받는 프로그램이나 함수 작성 N 입력 지문 또는 반환 별개의 개수 +1 소수 의 N을 .

입력 및 출력은 정수이거나 십진 또는 단항 문자열 표현이어야합니다.

표준 코드 골프 규칙이 적용됩니다.

테스트 사례

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

Pyth, 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.

자바 스크립트 ES6, 141 바이트 143 (147) (160)

@Naouak 덕분에 13 바이트 절약

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 (잘 들었습니다)를 사용하여 소수를 확인하십시오.

언 골프

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

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

티 스크립트 , 22 바이트

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

TeaScript가 APL처럼 보이기 시작합니다. 특수 문자가 길고 일반적으로 반복되는 시퀀스로 변환됩니다.

온라인 통역사 는 "입력은 숫자입니다"를 확인하십시오.

&& Ungolfed

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.

줄리아, 55 52 바이트

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

k=2.^(0:endof(bin(n)))1에서 2보다 작은 2의 거듭 제곱을 포함하는 배열을 생성합니다 n. 2n+k-n%k그런 다음 배열 연산을 사용하여 가능한 모든 "+1 숫자"를 결정합니다. ∪( 이 상황에서 union와 동일한 기능을하는에 해당 unique)은 반복 값을 제거합니다. 그런 다음 sum(isprime,)목록에서 소수의 수를 계산합니다.

CJam, 26 바이트

승자는 아니지만 기존 CJam의 대답을 확실히 능가하며 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 1 ...]하므로 첫 번째 스왑은 아무 문제가 없습니다.

수학, 87 바이트

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

줄리아 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->....

언 골프 드 :

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

Glen O 덕분에 17 바이트를 절약했습니다!

CJam, 58 바이트

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

이것은 하루가 걸렸고 이것은 네 번째 반복이었습니다.

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

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

CJam, 34 바이트

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

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

첫 번째 버전은 더 나은 것을 생각해 내면 업데이트됩니다.

APL, 55

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

2 바이트 더 짧은 Dyalog 특정 버전 :

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

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

• 더 많은 골프 진행 중 ...

Brachylog , 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.

젤리 , 13 바이트

BLṬkj1ʋ€$QḄẒS

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

파이썬 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)})

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