Amorces avec nombre de bits premier

23

Tâche

Trouver tous les entiers non négatifs jusqu'à et y compris un entier positif non nul donné n , qui sont premiers et le nombre de 1'set 0'sdans leur représentation binaire (sans zéros non significatifs) sont également premiers.

Voici les cinq premiers nombres premiers,

17, 19, 37, 41, 79

10001, 10011, 100101, 101001, 1001111

Clarifications et règles

  • Les méthodes d'E / S par défaut sont acceptées .
  • La réponse peut être un programme ou une fonction.
  • S'il n'y a pas de tels nombres premiers, sortez les ordures ou rien.
  • Les failles standard sont interdites.
  • 2 3 5 7n'a pas atteint la liste car dans leur représentation binaire, le nombre d'occurrences de 0'set 1'sn'est pas premier. Considérez 7dont la représentation binaire est 111, ici 0se produit zéro fois et zéro n'est pas premier.

  • Les fonctions intégrées sont autorisées.

  • Le code le plus court en octets gagne!

Cas de test

dix
[]

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

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

Afficher l'extrait de code

code-golf  primes  binary 
— Gurupad Mamadapur
source
1
Vous demandez tous les nombres premiers sous un n donné, mais vous dites également inclusif. Que voulez-vous dire?
— Riley
@Riley que je veux dire est ... all the numbers from 1....n. Je ne sais pas comment le reformuler de manière simple.
— Gurupad Mamadapur
6
— mbomb007
3
@ mbomb007 De toute évidence, pour tout ordre total de séquences entières, la plus petite séquence entière sans intérêt serait elle-même intéressante, et donc digne d'être incluse dans OEIS. Ergo, OEIS contient toutes les séquences entières, de tout intérêt réel ou imaginaire :-)
— Iwillnotexist Idonotexist
9
Je me demande si Mathematica contient plus de builtins qu'OEIS a de séquences ...
— Neil

Réponses:

5

Gelée , 14 13 octets

RBċþd`ÆPPTfÆR

Essayez-le en ligne!

Comment ça marche

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
source
2
Ce d`​truc est autre chose ...
— ETHproductions
10

Python 2 , 106 102 100 octets

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

Essayez-le en ligne!

Contexte

Pour identifier les nombres premiers, nous utilisons un corollaire du théorème de Wilson :

corollary of Wilson's theorem

Comment ça marche

Nous commençons par initialiser k et m comme 1 et p comme l'ensemble {0} . Notez que m = 1 = 0! ² = (k - 1)! ² . Immédiatement après, le code suivant est exécuté n fois, où n est l'entier lu à partir de l'entrée standard.

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

Par corollaire, m% k sera 1 si k est premier et 0 sinon. Ainsi, {m%k*k,0}retournera l'ensemble {k, 0} si k est premier et l'ensemble {0} sinon.

Si (et seulement si) k est premier, puisque p ne peut pas contenir k à ce stade, la différence symétrique en place p^={m%k*k,0}ajoutera k à l'ensemble p . De plus, p contiendra 0 après la mise à jour si et seulement s'il ne contient pas 0 avant, donc 0 ∊ p si et seulement si k est pair.

Sur la même ligne, nous définissons une fonction c via c=bin(k).count, qui comptera les occurrences de son argument dans la représentation binaire de k .

La deuxième ligne produit la sortie réelle. {k,c('1'),c('0')-1}renvoie l'ensemble composé de k lui-même, le nombre de bits définis dans k et le nombre de bits non définis dans k . Puisque la sortie de bin(k)commence par 0b , nous devons décrémenter c('0')pour tenir compte du 0 de tête .

Si tous sont premiers, ils appartiendront tous à p , qui contient maintenant tous les nombres premiers jusqu'à k (et potentiellement 0 ). Si k est un nombre de Mersenne (c'est-à-dire s'il n'a que des bits définis), c('0')-1donnera 0 . Étant donné que le nombre de Mersenne sont impairs, p va pas contenir 0 , donc la condition échouera.

Après avoir (potentiellement) imprimé k , on multiplie m par k² . Puisque m = (k-1)! ² avant la mise à jour, m = k! ² après celle-ci. Après avoir incrémenté k , la relation m = (k-1)! ² se vérifie à nouveau et nous sommes prêts pour la prochaine itération.

— Dennis
source
9

Mathematica, 80 68 54 octets

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

Explication

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
source
8

JavaScript (ES6), 123 118 115 111 104 96 octets

4 octets enregistrés grâce à @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))

Une combinaison de trois fonctions récursives typiques. Alerte la séquence dans l'ordre inverse et se termine sur une erreur "trop ​​de récursivité".

Extrait de test

(modifié pour sortir sur la page)

Afficher l'extrait de code

La fonction principale peut renvoyer un tableau de 104 octets:

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

Il peut également être non récursif au prix d'un autre octet:

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]

Voici celle avec laquelle j'ai commencé: (6 octets enregistrés grâce à @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:[]):[]

J'ai essayé de jouer au golf plus loin et j'ai réussi à le faire en 104 octets, puis j'ai réalisé que j'avais déjà trouvé cette solution (c'est au bas de la réponse). Tu ne détestes pas quand ça arrive? : P

Une tentative non récursive de la fonction principale (encore une fois, même nombre d'octets):

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

Celui-ci prend la route facile de compter combien de 0 et de 1 sont dans la représentation binaire:

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

Même chose avec une compréhension de tableau:

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]

Celui-ci prend un chemin un peu plus difficile pour faire la même chose:

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

Et celui-ci emprunte une autre voie connexe aussi courte que l'original:

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

Encore une fois, vous pouvez jouer au golf 8 octets en le faisant alerter la séquence dans l'ordre inverse:

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))
— ETHproductions
source
Vous n'avez pas vraiment besoin de passer récursivement a. Il suffit de l'initialiser lors de l'appel initial à G. (Cela devrait économiser 4 octets.)
— Arnauld
@Arnauld Oh oui, merci! C'est amusant :-)
— ETHproductions
1
Wow, cela a beaucoup baissé. Beau travail
— George Reith
6

Gelée , 17 16 octets

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

Essayez-le en ligne!

Comment?

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
source
1
Ah merci, je vois que vous avez changé cela, cela vous fera économiser un octet.
— Jonathan Allan
1
Vous avez l'alphabet en cours, là-bas. ẠBÇЀfĠ...
— mbomb007
2
@ mbomb007 Oui, le LƵ;Pbit me confond toujours.
— Jonathan Allan
6

05AB1E , 14 octets

ƒNpNbSD_‚OpP&–

Essayez-le en ligne!

Explication

ƒ               # 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
source
Je ne trouve toujours pas d'utilisation .¡, ce défi semblait bon pour lui, mais il est plus long:FNb{.¡€gpONp+3QiN}})
— Magic Octopus Urn
@carusocomputing: J'avais également une solution similaire que j'ai envisagée, mais elle s'est également avérée un peu plus longue que cela.
— Emigna
4

MATL , 16 15 octets

:"@tB!t~hshZp?@

Essayez-le en ligne!

:         % 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
source
4

Perl, 101 octets

99 octets de code + -nldrapeaux.

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

Pour l'exécuter:

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

Quelques brèves explications
$r contiennent le regex classique ( q/^1?$|^(11+)\1+$/).
Pour tous les nombres entre 2 et l'entrée,
(1x$@)!~$rvérifie si le nombre est premier,
y/01/1/dr!~$rvérifie si le nombre de 0dans la représentation binaire est premier,
s/0//gr!~$rvérifie si le nombre 1dans la représentation binaire est premier.
(si les 3 conditions sont remplies, l' print$@imprime).

— Dada
source
Merci pour l'explication. Tout à fait étonnant ce que vous pouvez faire avec ce qui est essentiellement des regex et de la logique :)
— Emigna
@Emigna Merci! Les explications ne sont pas très détaillées (j'ai du mal à écrire des explications plus longues), mais il semble que c'était suffisant pour vous :) (je pense toujours que le code est un peu trop long, mais je ne vois pas comment obtenir il est plus court, alors le voici)
— Dada
1
En tant que personne qui ne connaît pas Perl, j'apprécie chaque explication que je peux obtenir. Cela ne m'aidera pas à créer un programme Perl mais je comprends une partie du raisonnement derrière la méthode employée, ce qui est toujours intéressant.
— Emigna
3

Python, 129 125 123 octets

Si seulement zéro était premier ...

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

Essayez-le en ligne

La fonction pest la fonction de vérification principale, qui a >0à la fin de sorte qu'elle fonctionne également pour zéro, qui sinon reviendrait -1. La lambda anonyme est la lambda qui vérifie toutes les conditions requises.

Voici une méthode légèrement différente utilisant une compréhension d'ensemble. Le résultat sera un ensemble. ( 124 octets ):

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
source
3

Perl 6 , 65 octets

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

Essayez-le

Étendu:

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

Octave, 73 octets

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

Essayez-le en ligne!

@(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
source
2

CJam , 26 27 octets

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

Algorithme simple, jouera plus loin.

EDIT: oublié n était inclusif.

Essayez-le en ligne!

Pour le plaisir, c'est très similaire et aussi 27 octets:

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

Explication

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
— Chat d'affaires
source
2

Gelée , 14 octets

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

Essayez-le en ligne!

Malheureusement, je ne pouvais que lier avec @Dennis, mais l'algorithme semble être quelque peu différent, donc je le poste quand même.

Explication

Fonction d'assistance (supprime les éléments de liste qui n'ont pas un nombre premier d'occurrences d'un bit donné):

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

Programme principal:

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

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

Rien de fou. Essentiellement un tamis modifié d'Eratosthène qui évalue la primalité du compte 0/1 dans la même itération que de barrer des non-premiers supérieurs. Avec des espaces:

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

Mais aujourd'hui, j'ai appris que je pouvais mettre continueun opérateur ternaire et Haxe ne me dérange même pas.

Edit: +2 car nest une borne supérieure inclusive!

— Aurel Bílý
source
Hé, nc'est inclusif.
— Gurupad Mamadapur
@GurupadMamadapur Vous avez raison, fixe!
— Aurel Bílý
2

Bash utilitaires GNU +, 129 126 123 114 111 109 octets

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

Essayez-le en ligne!

A remarqué le commentaire selon lequel la sortie ne doit pas être dans l'ordre croissant - rasé de 3 octets en décomptant au lieu de décompter.

Grep remplacé par wc pour économiser 3 octets supplémentaires.

Suppression d'une variable (9 octets de plus hors tension).

Modification de la façon dont le facteur est utilisé - 3 octets supplémentaires.

Faites-en golfier avec seq (2 octets).

— Mitchell Spector
source
2

Python, 172 170 168 159 159 154 133 130 octets

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

Utilisation: Appelez la fonction lambda anonyme La
méthode pvérifie si un nombre est premier

Enregistré 2 + 2 + 9 = 13 octets grâce à Gurupad Mamadapur
Enregistré 5 octets grâce à mbomb007

— ovs
source
1
Vous pouvez économiser 2 de plus en utilisant ceci v-def v(n):a=bin(n)[2:];return p(n)and(p(a.count('1'))and p(a.count('0')))
— Gurupad Mamadapur
1
Un beaucoup plus court -v=lambda a:p(a)and all(p(bin(a)[2:].count(x))for x in['1','0'])
— Gurupad Mamadapur
2
Les chaînes sont itérables. Vous pouvez donc utiliser for x in'01'.
— mbomb007
1

Pyke, 21 octets

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

Essayez-le ici!

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")
— Bleu
source
1

Groovy, 120 octets

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

Il s'agit d'une fermeture sans nom.

Essayez-le ici!

— Gurupad Mamadapur
source
1

Python 3 , 97 octets

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
source
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
source
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
source
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
source
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
source
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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.