소수 비트 수를 가진 소수

23

태스크

주어진 0이 아닌 양의 정수 n 이하의 소수 가 아닌 모든 음수가 아닌 정수를 찾으십시오. 이는 소수이고 이진 표현 의 수 1's와 0's선행 0이없는 소수도 소수입니다.

여기에 처음 다섯 가지 소수가 있습니다.

17, 19, 37, 41, 79

10001, 10011, 100101, 101001, 1001111

설명 및 규칙

  • 기본 I / O 방법이 허용 됩니다.
  • 답은 프로그램이나 기능 일 수 있습니다.
  • 그러한 소수가 없으면 출력 쓰레기 또는 아무것도 없습니다.
  • 표준 허점 은 금지되어 있습니다.
  • 2 3 5 7이진 표현에서 발생 횟수 0's와 1's소수가 아니기 때문에 목록에 표시 하지 않았습니다. 7이진 표현이 누구인지 고려 111하십시오. 여기서는 00 번 발생하고 0은 소수가 아닙니다.

  • 내장이 허용됩니다.

  • 바이트 단위의 가장 짧은 코드가 이깁니다!

테스트 사례

10
[]

100
[17, 19, 37, 41, 79]

150
[17, 19, 37, 41, 79, 103, 107, 109, 131, 137]

코드 스 니펫 표시

code-golf  primes  binary 
— 구루 파드 마마다 푸르
소스
1
당신 은 주어진 n 이하 의 모든 소수를 요구 하지만, 또한 포괄적이라고 말합니다. 무슨 뜻인가요?
— Riley
... 평균 무엇입니까 I @Riley all the numbers from 1....n. 간단한 방법으로 문구를 바꾸는 방법을 모르겠습니다.
— Gurupad Mamadapur
6
— mbomb007
3
@ mbomb007 분명히, 정수 시퀀스의 전체 순서에 대해, 가장 작은 무관심 정수 시퀀스는 그 자체가 흥미로워 서 OEIS에 포함될 가치가 있습니다. Ergo, OEIS는 실제 또는 상상 된 모든 정수 시퀀스를 포함합니다. :-)
— Idonotexist Idonotexist
9
Mathematica에 OEIS보다 많은 내장이 포함되어 있는지 궁금합니다.
— Neil

답변:

5

젤리 , 14 13 바이트

RBċþd`ÆPPTfÆR

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

작동 원리

RBċþd`ÆPPTfÆR  Main link. Argument: n

R              Range; yield [1, ..., n].
 B             Binary; convert each integer to base 2.
    d`         Divmod self; yield [n : n, n % n], i.e., [1, 0].
  ċþ           Count table; count the occurrences of 1 and 0 in each binary
               representation, yielding a pair of lists of length n.
      ÆP       Test each count for primality.
        P      Product; multiply the corresponding Booleans.
         T     Truth; get all indices of 1, yielding the list of integers in
               [1, ..., n] that have a prime amount of 0's and 1's.
           ÆR  Prime range; yield all primes in [1, ..., n].
          f    Filter; intersect the lists.
— 데니스
소스
2
그 d`​트릭은 다른 것입니다 ...
— ETHproductions
10

파이썬 (2) , 106 (102) 100 바이트

k=m=1;p={0}
exec"p^={m%k*k,0};c=bin(k).count\nif{k,c('1'),c('0')-1}<p:print k\nm*=k*k;k+=1;"*input()

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

배경

소수를 식별하기 위해 우리는 윌슨 정리의 목록을 사용합니다 .

윌슨 정리의 목록

작동 원리

k 와 m 을 1 로 초기화 하고 p 를 {0} 세트 로 초기화 합니다. 참고 m = 1 = 0 ² = (K - 1)! ² . 그 후 즉시 다음 코드가 n 번 실행 됩니다. 여기서 n 은 표준 입력에서 읽은 정수입니다.

p^={m%k*k,0};c=bin(k).count
if{k,c('1'),c('0')-1}<p:print k
m*=k*k;k+=1

결과적으로 k 가 소수 이면 m % k 는 1 이되고 그렇지 않으면 0이 됩니다. 따라서 k 가 소수 이면 세트 {k, 0}을, 그렇지 않으면 세트 {0} 을 리턴합니다 .{m%k*k,0}

k 가 소수 인 경우 p 는 이 시점에서 k 를 포함 할 수 없으므로 전체 대칭 차이 p^={m%k*k,0}는 k 를 세트 p에 추가 합니다. 또한 p 는 이전에 0 을 포함하지 않은 경우에만 업데이트 후 0 을 포함 하므로 k 가 짝수 인 경우에만 0 ∊ p 입니다.

같은 줄에 함수 c via를 정의하면 k 의 이진 표현 c=bin(k).count에서 인수의 발생 횟수를 계산합니다 .

두 번째 줄은 실제 출력을 생성합니다. {k,c('1'),c('0')-1}구성 설정 반환 K 자체에 설정된 비트 수 (K) 및 설정 해제의 비트 수 (k)를 . 의 출력은 0b 로 bin(k)시작 하므로 선행 0 을 설명하기 위해 감소 해야합니다 .c('0')

모두 소수 인 경우 모두 p 에 속하며 , 이제는 최대 k 까지의 모든 소수 (및 잠재적으로 0 )를 포함합니다. 경우 K는 메르 센 수이다 (이 전용 비트를 설정 한 경우, 즉,) c('0')-1수득한다 0 . 메르 센 수가 홀수이기 때문에, P는 것이다 하지 함유 0 상태가되지 않도록.

k를 (잠재적으로) 인쇄 한 후 m 에 k²을 곱 합니다. 업데이트 전에 m = (k-1)! ² 이므로 업데이트 후 m = k! ² 입니다. 증가 후 K , 관계 m를 = (K-1)! ² 다시 보유하고 있으며 우리가 다음 반복에 대한 준비가 된 것입니다.

— 데니스
소스
9

Mathematica, 80 68 54 바이트

Select[p=PrimeQ;Range@#,p@#&&And@@p/@#~DigitCount~2&]&

설명

Select[p=PrimeQ;Range@#,p@#&&And@@p/@#~DigitCount~2&]&

       p=PrimeQ                                        (* Store prime check func. in p *)
Select[                                             ]  (* Select *)
                Range@#                                (* from a list {1..n} *)
                        p@#                            (* numbers that are prime *)
                           &&                          (* And *)
                                     #~DigitCount~2    (* whose digit counts in binary *)
                             And@@p/@                  (* are prime as well *)
— 정환 민
소스
8

자바 스크립트 (ES6) 123 118 115 111 104 96 바이트

@Arnauld 덕분에 4 바이트 절약

G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
F=n=>F(n-1,G(n,a=[0,0,n])||alert(n))

세 가지 일반적인 재귀 함수의 조합입니다. 순서를 역순으로 경고하고 "너무 많은 재귀"오류가 발생하면 종료됩니다.

테스트 스 니펫

(페이지로 출력되도록 수정)

코드 스 니펫 표시

주 함수는 104 바이트의 배열을 반환 할 수 있습니다.

G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
F=n=>n?F(n-1).concat(G(n,a=[0,0,n])?[]:n):[]

다른 바이트 비용으로 비 재귀적일 수도 있습니다.

G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
n=>[for(_ of Array(n))if(!G(--n,a=[0,0,n]))n]

여기에 내가 시작한 것이 있습니다 : (@Arnauld 덕분에 6 바이트 저장)

P=(n,x=n)=>n>1&--x<2||n%x&&P(n,x)
G=n=>n?G(n>>1,o+=n%2,t++):P(o)&P(t-o)
F=n=>n?F(n-1).concat(P(n)&G(n,o=t=0)?n:[]):[]

나는 이것을 더 골프로 치고 104 바이트로 그것을 할 수 있었다. 그리고 나는 그 해결책을 이미 발견했다는 것을 깨달았다 (답의 맨 아래에있다). 그럴 때 미워하지 않습니까? :피

메인 함수에서의 비재 귀적 시도 (다시 같은 바이트 수) :

n=>[for(i of Array(n))if(P(--n)&G(n,o=t=0))n]

이것은 바이너리 표현에 몇 개의 0과 1이 있는지 계산하는 쉬운 경로를 취합니다.

F=n=>n?F(n-1).concat([n,(G=x=>n.toString(2).split(x).length-1)(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]

배열 이해와 같은 것 :

n=>[for(_ of Array(n))if(![--n,(G=x=>n.toString(2).split(x).length-1)(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1))n]

이것은 동일한 작업을 수행하기 위해 약간 더 어려운 경로를 사용합니다.

F=n=>n?F(n-1).concat([n,(G=(x,w=n)=>w&&G(x,w>>1)+(w%2==x))(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]

그리고 이것은 원래의 것보다 짧은 또 다른 관련 경로를 취합니다.

F=n=>n?F(n-1).concat([n,o=(G=x=>x&&x%2+G(n>>++t))(n,t=0),t-o].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]

다시, 시퀀스를 역순으로 경고하여 8 바이트를 골프화 할 수 있습니다.

F=n=>F(n-1,[n,o=(G=x=>x&&x%2+G(n>>++t))(n,t=0),t-o].some(n=>(P=x=>n%--x?P(x):x)(n)-1)||alert(n))
— ETH 프로덕션
소스
실제로 재귀 적으로 전달할 필요는 없습니다 a. 에 대한 초기 호출에서 초기화하십시오 G. (4 바이트를 절약해야합니다.)
— Arnauld
@Arnauld 오 예, 감사합니다! 이것은 재미있다 :-)
— ETHproductions
1
와우 많이 떨어졌습니다. 잘 했어
— George Reith
6

젤리 , 17 16 바이트

BĠL€µ;LÆPẠ
ÆRÇÐf

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

방법?

BĠL€µ;LÆPẠ - Link 1, hasPrimeBits: n  e.g. 7         or 13
B          - convert to binary        e.g. [1,1,1]  or [1,1,0,1]
 Ġ         - group indices            e.g. [1,2,3]  or [3,[1,2,4]]
  L€       - length of €ach           e.g. 3          or [1,3]
    µ      - monadic chain separation
     ;L    - concatenate length       e.g. [3,1]      or [1,3,2]
           -     this caters for the edge case of Mersenne primes (like 7), which have
           -     no zero bits, the length will be 1, which is not prime.
       ÆP  - isPrime?                 e.g. [1,0]      or [0,1,1]
         Ạ - All?                     e.g. 0          or 0

ÆRÇÐf - Main link: N
ÆR    - prime range (primes up to and including N)
   Ðf - filter keep those satisfying
  Ç   - last link (1) as a monad
— 조나단 앨런
소스
1
고마워요, 당신이 그것을 보았을 때 바이트가 절약됩니다.
— Jonathan Allan
1
거기에 알파벳이 있습니다. ẠBÇЀfĠ...
— mbomb007
2
@ mbomb007 그래, LƵ;P비트는 항상 나를 혼동한다.
— Jonathan Allan
6

05AB1E , 14 바이트

ƒNpNbSD_‚OpP&–

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

설명

ƒ               # for N in [0 ... input]
 Np             # push N is prime
   Nb           # push N converted to binary
     S          # split into individual digits
      D_        # push an inverted copy
        ‚       # pair the 2 binary lists
         O      # sum them
          p     # elementwise check for primality
           P    # product of list
            &   # and with the primality of N
             –  # if true, print N
— 에미 냐
소스
나는 아직도 용도를 찾을 수 없다 .¡.이 도전은 좋아 보이지만 더 길다.FNb{.¡€gpONp+3QiN}})
— Magic Octopus Urn
@ carusocomputing : 비슷한 솔루션을 가지고 있었지만 이것보다 약간 길었습니다.
— Emigna 2012 년
4

MATL , 16 15 바이트

:"@tB!t~hshZp?@

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

:         % Input n (implicit). Push range [1 2 ... n]
"         % For each k in [1 2 ... n]
  @       %   Push k
  tB!     %   Duplicate. Binary expansion as an m×1 vector
  t~      %   Duplicate. Negate
  hs      %   Concatenate horizontally into an m×2 matrix. Sum of each column.
          %   This gives a 1×2 vector. However, for k==1 this gives the sum of
          %   the original 1×2 matrix (m==1). But fortunately it doesn't matter
          %   because 1 is not a prime anyway
  h       %   Concatenate horizontally into a 1×3 row vector
  Zp      %   Isprime function applied on each of those three numbers
  ?       %   If all gave true
    @     %     Push k
          %   End (implicit)
          % End (implicit)
          % Display (implicit)
— 루이스 멘도
소스
4

펄, 101 바이트

99 바이트의 코드 + -nl플래그

$r=q/^1?$|^(11+)\1+$/;for$@(2..$_){$_=sprintf"%b",$@;print$@if(1x$@)!~$r&y/01/1/dr!~$r&s/0//gr!~$r}

그것을 실행하려면 :

perl -lne '$r=q/^1?$|^(11+)\1+$/;for$@(2..$_){$_=sprintf"%b",$@;print$@if(1x$@)!~$r&y/01/1/dr!~$r&s/0//gr!~$r}' <<< 150

몇 가지 간단한 설명
$r 에는 고전적인 프라임 검사 정규식 ( q/^1?$|^(11+)\1+$/)이 있습니다.
2와 입력 사이의 모든 숫자에
(1x$@)!~$r대해 숫자가 소수
y/01/1/dr!~$r인지 확인 0하고 이진 표현
s/0//gr!~$r의 수가 소수 인지 확인 1하고 이진 표현 의 숫자 가 소수 인지 확인합니다 .
(3 가지 조건이 충족되면 print$@인쇄합니다).

— 다다이즘
소스
설명 주셔서 감사합니다. 기본적으로 정규식과 논리로 무엇을 할 수 있는지 놀랍습니다 :)
— Emigna
@Emigna 감사합니다! 설명이 매우 상세하지는 않지만 (더 긴 설명을 작성하는 데 어려움을 겪고 있습니다) 충분합니다. :) (여전히 코드가 너무 길다고 생각하지만 더 짧아서 여기 있습니다)
— Dada
1
Perl을 모르는 사람으로서 내가 얻을 수있는 모든 설명에 감사합니다. Perl 프로그램을 만드는 데 도움이되지 않지만 사용 된 방법의 이유를 이해합니다. 항상 흥미 롭습니다.
— Emigna
3

파이썬 129 125 123 바이트

제로 만 소수라면 ...

p=lambda n:all(n%m for m in range(2,n))*n>1
lambda n:[i for i in range(n+1)if p(i)*all(p(bin(i)[2:].count(x))for x in'01')]

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

함수 p는 프라임 검사 기능으로, >0마지막에 0으로 작동하여 그렇지 않으면를 반환 -1합니다. 익명 람다는 필요한 모든 조건을 확인하는 람다입니다.

이해력을 사용하는 약간 다른 방법이 있습니다. 결과가 설정됩니다. ( 124 바이트 ) :

p=lambda n:all(n%m for m in range(2,n))*n>1
lambda n:{i*p(i)*all(p(bin(i)[2:].count(x))for x in'01')for i in range(n+1)}-{0}
— mbomb007
소스
3

펄 6 , 65 바이트

{grep {all($^a,|map {+$a.base(2).comb(~$_)},0,1).is-prime},0..$_}

시도 해봐

넓히는:

{           # bare block lambda with implicit parameter ｢$_｣

  grep      # find all of the values where

  {         # lambda with placeholder parameter ｢$a｣

    all(    # all junction ( treat multiple values as a single value )

      $^a,  # declare parameter to block

      |\    # slip the following list into the outer list

      # get the count of 0's and 1's in the binary representation
      map

      {             # bare block lambda with implicit parameter ｢$_｣

        +           # turn to numeric ( count the values in the list )
        $a          # the outer parameter
        .base(2)    # in base 2
        .comb(~$_)  # find the characters that are the same as
      },0,1         # 0 or 1

    # ask if $a, count of 0's, count of 1's are all prime
    ).is-prime

  },

  0 .. $_ # Range from 0 to the input inclusive

}
— 브래드 길버트 b2gills
소스
3

옥타브, 73 바이트

@(n)(p=primes(n))(all(isprime([s=sum(dec2bin(p)'-48);fix(log2(p))+1-s])))

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

@(n)
    (p=primes(n))                           generate prime numbers
        (all(                               from them select those that
            isprime(                        are prime both
                [s=sum(dec2bin(p)'-48);     sum of 1s
                fix(log2(p))+1-s])))        and sum of 0s
— rahnema1
소스
2

CJam , 26 27 바이트

ri){mp},{2b_1-,mp\0-,mp&},p

간단한 알고리즘, 더 골프.

편집 : 잊어 버린 n 포함했다.

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

재미를 위해 이것은 매우 비슷하며 27 바이트입니다.

ri){_mp\2b_1-,mp\0-,mp&&},p

설명

ri                          e# Take an int as input
  ){mp},                    e# Take the range up and including to the input, 
                            e#   including only prime numbers
       {                    e# For each prime...
        2b_                 e# Convert it to binary and copy it
           1-,mp            e# Take the top binary number, remove 1's, check if the length 
                            e#   is prime
                \           e# Swap top elements
                 0-,mp      e# Do the same but remove 0's
                      &     e# And
                       },   e# Filter out primes for which the above block was false
                         p  e# Print nicely
— 비즈니스 고양이
소스
2

젤리 , 14 바이트

BċÆPðÐf
ÆRç0ç1

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

불행히도 @Dennis 와만 연결할 수는 있지만 알고리즘이 약간 다른 것처럼 보이므로 어쨌든 게시하고 있습니다.

설명

도우미 기능 (주어진 비트 수가 소수가 아닌 목록 요소 삭제) :

BċÆPðÐf
     Ðf   Filter {the first argument}, looking for truthy returns from
    ð     the preceding code, which takes two arguments:
B         Convert {the element being checked} to binary
 ċ        Count the number of occurrences of {the second argument}
  ÆP      Return true if prime, false if not prime

주요 프로그램 :

ÆRç0ç1
ÆR        Generate all primes from 2 to the input
  ç0      Call the subroutine to require a prime 0 count
    ç1    Call the subroutine to require a prime 1 count
2

Haxe, 169 171 바이트

function f(n,?p)return[for(j in(p=[for(i in 0...++n)i<2?0:i]))if(j>0){var x=j*2,y=0,z=0,k=j;while(k<n)p[k+=j]=0;while((x>>=1)>0)x&1>0?y++:z++;p[y]<1||p[z]<1?continue:j;}];

미쳤어 기본적으로 더 높은 비 프라임을 가로 지르는 것과 동일한 반복에서 0 / 1 카운트의 우선 순위를 평가하는 수정 된 에라토스테네스 체. 공백이있는 경우 :

function f(n, ?p)
  return [ for (j in (p = [ for(i in 0...++n) i < 2 ? 0 : i ]))
    if (j > 0){
      var x = j * 2, y = 0, z = 0, k = j;
      while (k < n)
        p[k += j] = 0;
      while((x >>= 1) > 0)
        x & 1 > 0 ? y++ : z++;
      p[y] < 1 || p[z] < 1 ? continue : j;
    }
  ];

그러나 오늘 나는 continue삼항 연산자를 넣을 수 있다는 것을 배웠고 Haxe는 신경 쓰지 않습니다.

편집 : +2 n는 상한을 포함 하기 때문에 !

— 오럴 빌리
소스
이봐, n포함입니다.
— Gurupad Mamadapur
@GurupadMamadapur 당신 말이 맞아요!
— Aurel
2

배시 + GNU 유틸리티 129 126 123 114 111 109 바이트

seq '-fp()([ `factor|wc -w` = 2 ]);g()(dc -e2o${n}n|tr -cd $1|wc -c|p);n=%.f;p<<<$n&&g 0&&g 1&&echo $n' $1|sh

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

출력이 순서대로 증가 할 필요가 없다는 의견에 주목하십시오. 카운트 업 대신 카운트 다운하여 3 바이트를 줄였습니다.

grep을 wc로 교체하여 3 바이트를 더 절약했습니다.

변수를 제거했습니다 (9 바이트 더 떨어져).

요소 사용 방식이 변경되었습니다 (3 바이트 더).

seq (2 바이트)로 골퍼로 만들었습니다.

— 미첼 스펙터
소스
2

파이썬 172 170 168 159 154 133 130 바이트

p=lambda n:[i for i in range(1,n)if n%i==0]==[1]
lambda n:[i for i in range(n+1)if p(i)*all(p(bin(i)[2:].count(x))for x in'10')]

사용법 : 익명의 람다 함수 호출
메소드 p는 숫자가 소수인지 확인합니다.

Gurupad Mamadapur 덕분에 2 + 2 + 9 = 13 바이트 절약 mbomb007
덕분에 5 바이트 절약

— ovs
소스
1
이것을 사용하면 2 개를 더 절약 할 수 있습니다 v–def v(n):a=bin(n)[2:];return p(n)and(p(a.count('1'))and p(a.count('0')))
— Gurupad Mamadapur
1
훨씬 짧은 것 –v=lambda a:p(a)and all(p(bin(a)[2:].count(x))for x in['1','0'])
— Gurupad Mamadapur
2
문자열은 반복 가능합니다. 사용할 수 있습니다 for x in'01'.
— mbomb007
1

파이크, 21 바이트

S#j_PI\0[jb2R/_P)I\1[

여기 사용해보십시오!

S#j                   - for j in filter(range(1, input+1))
   _PI                -  if is_prime(j):
        [jb2R/_P)     -   function_[(a) = V
         jb2          -      base_2(j)
            R/        -     ^.count(a)
      \0         I    -   if function_[("0"):
                  \1[ -    function_[("1")
— 푸른
소스
1

자바 스크립트 (ES6), 110 바이트

B=n=>n?B(n>>1,v[n%2]++):v.every(n=>(P=i=>n%--i?P(i):1==i)(n))
F=(n,a=[])=>n?F(n-1,B(n,v=[0,0,n])?[n,...a]:a):a

코드 스 니펫 표시

— 조지 레이스
소스
그 원시성 테스트 기능은 ... 놀랍습니다 :-) 직접 만들었습니까?
— ETHproductions
@ETHproductions 여기에서 codegolf.stackexchange.com/a/91309/11182를 수정 하기 전에 본 적이 있습니다. 나는 또한 당신의 1과 0 카운팅 코드를 빌 렸지만 (아무것도 할 수없는 모든 것) 아아 나는 바이트 수를 이길 수 없었다.
— George Reith
@ETHproductions 감사합니다! 이전 버전의 인공물
— George Reith
1

MATLAB, 50 바이트

@(n)all(isprime([n,sum(de2bi(n)),sum(~de2bi(n))]))
— MattWH
소스
1

Haxe, 158 147 바이트

function p(n,x=1)return n%++x<1||n<2?x==n:p(n,x);function f(n){var q=n,t=0,o=0;while(q>0){t++;o+=q%2;q>>=1;}p(n)&&p(o)&&p(t-o)?trace(n):0;f(n-1);};

STDOUT으로 출력하고 "너무 많은 재귀"오류가 발생하면 종료됩니다. 예를 들어로 전화하십시오 f(1000);. while156 바이트에 대해 오류없이 루프를 사용할 수 있습니다 .

function p(n,x=1)return n%++x<1||n<2?x==n:p(n,x);function f(n){while(n>0){var q=n,t=0,o=0;while(q>0){t++;o+=q%2;q>>=1;}p(n)&&p(o)&&p(t-o)?trace(n):0;n--;}};

범위를 사용하면 3 바이트 더 길어졌습니다.

function p(n,x=1)return n%++x<1||n<2?x==n:p(n,x);function f(n){for(i in 0...n+1){var q=i,t=0,o=0;while(q>0){t++;o+=q%2;q>>=1;}p(i)&&p(o)&&p(t-o)?trace(i):0;}};

온라인으로 테스트하십시오!

— ETH 프로덕션
소스
1

녹, 147 바이트

fn f(x:u32){let p=|n|n>1&&(2..n).all(|x|n%x!=0);for n in 9..x+1{if p(n)&&p(n.count_ones())&&p(n.count_zeros()-n.leading_zeros()){print!("{} ",n)}}}

놀이터 링크

count_ones, count_zeros및 leading_zeros방법은 유용했다.

형식화 된 버전

fn f(x: u32) {
    // primality test closure using trial division
    let p = |n| n > 1 && (2..n).all(|x| n % x != 0);

    for n in 9..x + 1 {
        if p(n) && p(n.count_ones()) && p(n.count_zeros() - n.leading_zeros()) {
            print!("{} ", n)
        }
    }
}
— 시커 14491
소스
1

펄 6 , 50 바이트

{grep {($_&+.base(2).comb(~0&~1)).is-prime},0..$_}

정션 연산자를 사용하여 b2gills 응답의 변형 을 크게 적용 할 수 있습니다.&

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

작동 원리

{                                                }  # Lambda
                                            0..$_   # Range from 0 to the lambda argument.
 grep {                                   },        # Filter values satisfying:
       ($_                      ).is-prime          #  a) The Number itself is prime.
       (   +.base(2).comb(~0   )).is-prime          #  b) The count of 0's is prime.
       (   +.base(2).comb(   ~1)).is-prime          #  c) The count of 1's is prime.
          &                 &                       # Junction magic! :)
— smls
소스
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.