Liczby pierwsze z pierwszymi liczbami bitów

23

Zadanie

Znajdź wszystkie nieujemne liczby całkowite, aż do danej niezerowej dodatniej liczby całkowitej n , które są liczbą pierwszą, a liczba 1'si 0'sich reprezentacja binarna (bez zer wiodących) również jest liczbą pierwszą.

Oto pięć pierwszych takich liczb pierwszych,

17, 19, 37, 41, 79

10001, 10011, 100101, 101001, 1001111

Wyjaśnienia i zasady

  • Domyślne metody We / Wy są akceptowane .
  • Odpowiedzią może być program lub funkcja.
  • Jeśli nie ma takich liczb pierwszych, wyrzuć śmieci lub nic.
  • Standardowe luki są zabronione.
  • 2 3 5 7nie trafił na listę, ponieważ w ich reprezentacji binarnej liczba wystąpień 0'si 1'snie jest liczbą pierwszą. Zastanów się, 7czyja to reprezentacja binarna 111, tutaj 0występuje zero razy, a zero nie jest liczbą pierwszą.

  • Wbudowane są dozwolone.

  • Najkrótszy kod w bajtach wygrywa!

Przypadki testowe

10
[]

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

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

Pokaż fragment kodu

code-golf  primes  binary 
— Gurupad Mamadapur
źródło
1
Pytasz o wszystkie liczby pierwsze pod danym n, ale mówisz także o włączeniu. Co masz na myśli
— Riley,
@Riley Chodzi mi o to ... all the numbers from 1....n. Nie wiem, jak to sformułować w prosty sposób.
— Gurupad Mamadapur
6
— mbomb007 16.01.17
3
@ mbomb007 Oczywiście, dla każdego całkowitego uporządkowania sekwencji liczb całkowitych najmniejsza nieciekawa sekwencja liczb całkowitych byłaby sama w sobie interesująca, a zatem godna włączenia do OEIS. Ergo, OEIS zawiera wszystkie sekwencje liczb całkowitych, o dowolnym zainteresowaniu, prawdziwe lub wyobrażone :-)
— Nie będę istniał Idonotexist
9
Zastanawiam się, czy Mathematica zawiera więcej wbudowanych elementów niż sekwencje OEIS ...
— Neil

Odpowiedzi:

5

Galaretka , 14 13 bajtów

RBċþd`ÆPPTfÆR

Wypróbuj online!

Jak to działa

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.
— Dennis
źródło
2
Ta d`​sztuczka to coś innego ...
— ETHprodukcje
10

Python 2 , 106 102 100 bajtów

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

Wypróbuj online!

tło

Aby zidentyfikować liczby pierwsze, używamy następstwa twierdzenia Wilsona :

corollary of Wilson's theorem

Jak to działa

Zaczniemy od inicjalizacji k i m jako 1 i p jako zbiór {0} . Zauważ, że m = 1 = 0! ² = (k - 1)! ² . Natychmiast potem następujący kod jest wykonywany n razy, gdzie n jest liczbą całkowitą odczytaną ze standardowego wejścia.

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

W związku z tym m% k wyniesie 1, jeśli k jest liczbą pierwszą, a 0 w przeciwnym razie. Zatem {m%k*k,0}zwróci zestaw {k, 0}, jeśli k jest liczbą pierwszą, a zestaw {0} w przeciwnym razie.

Jeśli (i tylko jeśli) k jest liczbą pierwszą, ponieważ p nie może zawierać k w tym punkcie, różnica symetryczna w miejscu p^={m%k*k,0}doda k do zbioru p . Ponadto p będzie zawierało 0 po aktualizacji, tylko wtedy, gdy nie zawiera 0 wcześniej, więc 0 ∊ p wtedy i tylko wtedy, gdy k jest parzyste.

W tej samej linii definiujemy funkcję c pośrednictwem c=bin(k).count, która będzie liczyć wystąpień swojej argumentacji w k „s reprezentacji binarnej.

Drugi wiersz przedstawia rzeczywistą wydajność. {k,c('1'),c('0')-1}zwraca zestaw, który składa się z samego k , liczby ustawionych bitów w k oraz liczby nieustawionych bitów w k . Ponieważ dane wyjściowe bin(k)zaczynają się od 0b , musimy zmniejszyć wartość, c('0')aby uwzględnić wiodące 0 .

Jeśli wszystkie są liczbami pierwszymi, wszystkie będą należeć do p , który do tej pory zawiera wszystkie liczby pierwsze do k (i potencjalnie 0 ). Jeśli k jest liczbą Mersenne'a (tzn. Jeśli ma tylko ustawione bity), c('0')-1zwróci 0 . Ponieważ liczby Mersenne są nieparzyste, str nie będzie zawierać 0 , więc warunek się nie powiedzie.

Po (potencjalnie) wydrukowaniu k mnożymy m przez k² . Ponieważ m = (k-1)! ² przed aktualizacją, m = k! ² po niej. Po zwiększeniu k relacja m = (k-1)! ² ponownie i jesteśmy gotowi do następnej iteracji.

— Dennis
źródło
9

Mathematica, 80 68 54 bajtów

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

Wyjaśnienie

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 *)
— JungHwan Min
źródło
8

JavaScript (ES6), 123 118 115 111 104 96 bajtów

Zaoszczędź 4 bajty dzięki @Arnauld

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

Połączenie trzech typowych funkcji rekurencyjnych. Ostrzega sekwencję w odwrotnej kolejności i kończy się z powodu błędu „zbyt dużej rekurencji”.

Testowy fragment kodu

(zmodyfikowany w celu wyświetlenia na stronie)

Pokaż fragment kodu

Główna funkcja może zwrócić tablicę dla 104 bajtów:

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):[]

Może być również nierekurencyjny kosztem innego bajtu:

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]

Oto ten, od którego zacząłem: (Zapisałem 6 bajtów dzięki @Arnauld)

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:[]):[]

Próbowałem pograć w golfa i udało mi się to zrobić w 104 bajtach - potem zdałem sobie sprawę, że już znalazłem to rozwiązanie (jest na dole odpowiedzi). Czy nie nienawidzisz, kiedy to się dzieje? : P

Nierekurencyjna próba głównej funkcji (ponownie ta sama liczba bajtów):

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

Ten pozwala łatwo policzyć, ile zer i jedynek znajduje się w reprezentacji binarnej:

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):[]

To samo dotyczy zrozumienia tablicy:

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]

Ten obiera nieco trudniejszą drogę, aby zrobić to samo:

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):[]

A ta idzie inną pokrewną trasą, tak krótką jak oryginał:

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):[]

Ponownie możesz zagrać w 8 bajtów, ustawiając ostrzeżenie w odwrotnej kolejności:

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))
— ETHprodukcje
źródło
Naprawdę nie musisz rekurencyjnie zdawać a. Po prostu zainicjuj go w pierwszym wywołaniu do G. (To powinno zaoszczędzić 4 bajty.)
— Arnauld
@Arnauld O tak, dzięki! To jest fajne :-)
— ETHproductions
1
Wow, to dużo spadło. Dobra robota
— George Reith
6

Galaretka , 17 16 bajtów

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

Wypróbuj online!

W jaki sposób?

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
— Jonathan Allan
źródło
1
Ach, dzięki, widzę, że to zmieniłeś, to uratuje bajt.
— Jonathan Allan
1
Tam masz alfabet. ẠBÇЀfĠ...
— mbomb007
2
@ mbomb007 Tak, LƵ;Pbit zawsze mnie myli.
— Jonathan Allan
6

05AB1E , 14 bajtów

ƒNpNbSD_‚OpP&–

Wypróbuj online!

Wyjaśnienie

ƒ               # 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
— Emigna
źródło
Nadal nie mogę znaleźć zastosowania .¡, wyzwanie to wydawało się dobre, ale jest dłuższe:FNb{.¡€gpONp+3QiN}})
— Magic Octopus Urn
@carusocomputing: Miałem też podobne rozwiązanie, które rozważałem, ale skończyło się to nieco dłużej.
— Emigna
4

MATL , 16 15 bajtów

:"@tB!t~hshZp?@

Wypróbuj online!

:         % 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)
— Luis Mendo
źródło
4

Perl, 101 bajtów

99 bajtów kodu + -nlflagi.

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

Aby uruchomić:

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

Kilka krótkich wyjaśnień
$r zawiera klasyczną funkcję sprawdzania liczb pierwszych regex ( q/^1?$|^(11+)\1+$/).
Dla wszystkich liczb od 2 do danych wejściowych
(1x$@)!~$rsprawdza, czy liczba jest liczbą pierwszą,
y/01/1/dr!~$rsprawdza, czy liczba 0w reprezentacji binarnej jest liczbą pierwszą,
s/0//gr!~$rsprawdza, czy liczba 1w reprezentacji binarnej jest liczbą pierwszą.
(jeśli 3 warunki są spełnione, print$@drukuje je).

— Dada
źródło
Thanks for the explanation. Quite amazing what you can do with what is basically regex and some logic :)
— Emigna
@Emigna Thanks! The explanations aren't very detailed (I'm having a hard time writing longer explanations), but it seems it was enough for you :) (I still believe the code is slightly too long, but I don't see how to get it shorter, so here it is)
— Dada
1
As someone who doesn't know Perl I appreciate every explanation I can get. It won't help me make a Perl program but I understand some of the reasoning behind the method employed, which is always interesting.
— Emigna
3

Python, 129 125 123 bytes

If only zero were prime...

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

Try it online

Function p is the prime-checking function, which has >0 at the end so that it works for zero as well, which would otherwise return -1. The anonymous lambda is the lambda that checks all the conditions required.

Here's a slightly different method using a set comprehension. The result will be a set. (124 bytes):

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
źródło
3

Perl 6, 65 bytes

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

Try it

Expanded:

{           # 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

}
— Brad Gilbert b2gills
źródło
3

Octave, 73 bytes

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

Try It Online!

@(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
źródło
2

CJam, 26 27 bytes

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

Straightforward algorithm, will golf further.

EDIT: Forgot n was inclusive.

Try it online!

For fun, this is very similar and also 27 bytes:

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

Explanation

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
— Business Cat
źródło
2

Jelly, 14 bytes

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

Try it online!

Unfortunately, I could only tie with @Dennis, but the algorithm seems to be somewhat different so I'm posting this anyway.

Explanation

Helper function (deletes list elements that don't have a prime number of occurrences of a given bit):

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

Main program:

Æ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 bytes

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

Nothing crazy. Essentially a modified sieve of Eratosthenes that evaluates the primality of the 0 / 1 count in the same iteration as crossing out higher non-primes. With some whitespace:

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

But today I learned I could put continue in a ternary operator and Haxe doesn't even mind.

Edit: +2 because n is an inclusive upper bound!

— Aurel Bílý
źródło
Hey, the n is inclusive.
— Gurupad Mamadapur
@GurupadMamadapur You're right, fixed!
— Aurel Bílý
2

Bash + GNU utilities, 129 126 123 114 111 109 bytes

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

Try it online!

Noticed the comment that the output doesn't have to be in increasing order -- shaved off 3 bytes by counting down instead of counting up.

Replaced grep with wc to save 3 additional bytes.

Eliminated a variable (9 more bytes off).

Changed the way factor is used -- 3 more bytes.

Made it golfier with seq (2 bytes).

— Mitchell Spector
źródło
2

Python, 172 170 168 159 154 133 130 bytes

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

Usage: Call the anonymous lambda function
Method p checks whether a number is prime

Saved 2+2+9=13 bytes thanks to Gurupad Mamadapur
Saved 5 bytes thanks to mbomb007

— ovs
źródło
1
You can save 2 more by using this v - def v(n):a=bin(n)[2:];return p(n)and(p(a.count('1'))and p(a.count('0')))
— Gurupad Mamadapur
1
A much shorter one - v=lambda a:p(a)and all(p(bin(a)[2:].count(x))for x in['1','0'])
— Gurupad Mamadapur
2
Strings are iterable. So you can use for x in'01'.
— mbomb007
1

Pyke, 21 bytes

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

Try it here!

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")
— Blue
źródło
1

Groovy, 120 bytes

p={x->(2..<x).every{x%it!=0}&x>1|x==2}
{x->(1..x).findAll({y->p(y)&'10'.every{p(Integer.toBinaryString(y).count(it))}})}

This is an unnamed closure.

Try it here!

— Gurupad Mamadapur
źródło
1

Python 3, 97 bytes

def f(n,k=2,m=1,p={0}):f(n-1,k+1,m*k*k,p^{m%k*k,{*map(bin(m%k%n*k)[2:].count,'01')}<p==print(k)})

This is the same algorithm as in my Python 2 answer, but the implementation is quite different. The function prints to STDOUT and terminates with an error.

Try it online!

— Dennis
źródło
1

JavaScript (ES6), 110 bytes

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

Show code snippet

— George Reith
źródło
That primality test function is... just amazing :-) Did you create it yourself?
— ETHproductions
@ETHproductions You've seen it before codegolf.stackexchange.com/a/91309/11182 modified from here. I also borrowed your 1 and 0 counting code (whooped anything I could come up with) but alas I couldn't beat your byte count.
— George Reith
@ETHproductions Good catch thanks! Was an artefact of a previous version
— George Reith
1

MATLAB, 50 bytes

@(n)all(isprime([n,sum(de2bi(n)),sum(~de2bi(n))]))
— MattWH
źródło
1

Haxe, 158 147 bytes

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

Outputs to STDOUT and terminates on a "too much recursion" error; call with e.g. f(1000);. You can use a while loop with no error for 156 bytes:

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

Using a range turned out three bytes longer:

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

Test it online!

— ETHproductions
źródło
1

Rust, 147 bytes

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

playground link

The count_ones, count_zeros, and leading_zeros methods came in handy.

Formatted version

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)
        }
    }
}
— Seeker14491
źródło
1

Perl 6, 50 bytes

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

Variation of b2gills' answer, using the & junction operator to great effect.

Try it online!

How it works

{                                                }  # 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
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.