Primes con conteggi di bit primi


23

Compito

Trova tutti gli interi non negativi fino a compreso un dato intero positivo diverso da zero n , che sono primi e anche il conteggio di 1'se 0'snella loro rappresentazione binaria (senza zero iniziali) sono primi.

Ecco i primi cinque numeri primi,

17, 19, 37, 41, 79

10001, 10011, 100101, 101001, 1001111

Chiarimenti e regole

  • Sono accettati i metodi I / O predefiniti .
  • La risposta può essere un programma o una funzione.
  • Se non ci sono numeri primi di questo tipo, genera immondizia o niente.
  • Sono vietate le scappatoie standard .
  • 2 3 5 7non è arrivato alla lista perché nella loro rappresentazione binaria il numero di occorrenze di 0'se 1'snon sono primi. Considera la 7cui rappresentazione binaria è 111, qui si 0verifica zero volte e zero non è primo.
  • Sono ammessi gli incorporati.

  • Vince il codice più breve in byte!

Casi test

10
[]

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

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


1
Chiedi tutti i numeri primi in una data n, ma dici anche inclusivo. Che vuoi dire?
Riley,

@Riley Voglio dire ... all the numbers from 1....n. Non so come riformularlo in modo semplice.
Gurupad Mamadapur,


3
@ mbomb007 Chiaramente, per qualsiasi ordinamento totale di sequenze di numeri interi, la più piccola sequenza di numeri interi non interessante sarebbe di per sé interessante e quindi degna di essere inclusa in OEIS. Ergo, OEIS contiene tutte le sequenze di numeri interi, di qualsiasi interesse reale o immaginario :-)
Iwillnotexist Idonotexist

9
Mi chiedo se Mathematica contenga più builtin di quanto OEIS abbia sequenze ...
Neil

Risposte:


5

Gelatina , 14 13 byte

RBċþd`ÆPPTfÆR

Provalo online!

Come funziona

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
Quel d`​trucco è qualcos'altro ...
ETHproductions

10

Python 2 , 106 102 100 byte

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

Provalo online!

sfondo

Per identificare i numeri primi, usiamo un corollario del teorema di Wilson :

corollary of Wilson's theorem

Come funziona

Iniziamo inizializzando k e m come 1 e p come il set {0} . Nota che m = 1 = 0! ² = (k - 1)! ² . Immediatamente dopo, il seguente codice viene eseguito n volte, dove n è il numero intero letto dallo standard input.

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

Dal corollario, m% k sarà 1 se k è primo e 0 altrimenti. Pertanto, {m%k*k,0}restituirà il set {k, 0} se k è primo e il set {0} in caso contrario.

Se (e solo se) k è primo, poiché p non può contenere k a questo punto, la differenza simmetrica sul posto p^={m%k*k,0}aggiungerà k all'insieme p . Anche, p conterrà 0 dopo l'aggiornamento se e solo se non contiene 0 prima, quindi 0 ∊ p se e solo se k è pari.

Sulla stessa linea, definiamo una funzione c via c=bin(k).count, che conterà le occorrenze del suo argomento nella rappresentazione binaria di k .

La seconda riga produce l'output effettivo. {k,c('1'),c('0')-1}restituisce l'insieme costituito da k stesso, il numero di bit impostati in k e il numero di bit non impostati in k . Poiché l'output di bin(k)inizia con 0b , dobbiamo diminuire c('0')per tenere conto dello 0 iniziale .

Se sono tutti primi, appartengono tutti a p , che ormai contiene tutti i numeri primi fino a k (e potenzialmente 0 ). Se k è un numero di Mersenne (ovvero, se ha impostato solo bit), c('0')-1si ottiene 0 . Dal momento che i numeri di Mersenne sono dispari, p sarà non contiene 0 , quindi la condizione non riuscirà.

Dopo aver (potenzialmente) stampato k , moltiplichiamo m per . Poiché m = (k-1)! ² prima dell'aggiornamento, m = k! ² dopo. Dopo aver incrementato k , la relazione m = (k-1)! ² regge e siamo pronti per la prossima iterazione.


9

Mathematica, 80 68 54 byte

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

Spiegazione

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

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

Salvato 4 byte grazie a @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))

Una combinazione di tre tipiche funzioni ricorsive. Avvisa la sequenza in ordine inverso e termina con un errore "troppa ricorsione".

Test snippet

(modificato per l'output alla pagina)

La funzione principale può restituire un array per 104 byte:

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

Può anche essere non ricorsivo al costo di un altro byte:

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]

Ecco quello con cui ho iniziato: (6 byte salvati grazie a @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:[]):[]

Ho provato ulteriormente a giocare a golf e sono riuscito a farlo in 104 byte, poi ho capito che avevo già trovato quella soluzione (è in fondo alla risposta). Non lo odi quando succede? : P

Un tentativo non ricorsivo della funzione principale (di nuovo, stesso conteggio byte):

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

Questo prende la via facile per contare quanti 0 e 1 ci sono nella rappresentazione binaria:

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

Stessa cosa con una comprensione dell'array:

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]

Questo prende un percorso leggermente più difficile per fare la stessa cosa:

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

E questo prende ancora un altro percorso correlato che è breve come l'originale:

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

Ancora una volta, puoi giocare a golf a 8 byte facendone allertare la sequenza in ordine inverso:

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

Non hai davvero bisogno di passare ricorsivamente a. Inizializzalo nella chiamata iniziale a G. (Ciò dovrebbe salvare 4 byte.)
Arnauld

@Arnauld Oh sì, grazie! Questo è divertente :-)
ETHproductions

1
Wow, questo è diminuito molto. Bel lavoro
George Reith,

6

Gelatina , 17 16 byte

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

Provalo online!

Come?

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
Ah, grazie, vedo che l'hai cambiato, che farà risparmiare un byte.
Jonathan Allan,

1
Hai l'alfabeto in corso, lì. ẠBÇЀfĠ...
mbomb007,

2
@ mbomb007 Sì, il LƵ;Pbit mi confonde sempre.
Jonathan Allan,

6

05AB1E , 14 byte

ƒNpNbSD_‚OpP&–

Provalo online!

Spiegazione

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

Non riesco ancora a trovare un uso , questa sfida mi è sembrata buona, ma è più lunga:FNb{.¡€gpONp+3QiN}})
Magic Octopus Urn

@carusocomputing: anch'io ho preso in considerazione una soluzione simile, ma è anche risultata leggermente più lunga di questa.
Emigna,


4

MATL , 16 15 byte

:"@tB!t~hshZp?@

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

4

Perl, 101 byte

99 byte di codice + -nlflag.

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

Per eseguirlo:

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

Alcune brevi spiegazioni
$r contengono il classico controllo di regex ( q/^1?$|^(11+)\1+$/).
Per tutti i numeri tra 2 e l'input,
(1x$@)!~$rcontrolla se il numero è primo,
y/01/1/dr!~$rcontrolla se il numero 0nella rappresentazione binaria è primo,
s/0//gr!~$rcontrolla se il numero 1nella rappresentazione binaria è primo.
(se sono soddisfatte le 3 condizioni, la print$@stampa).


Grazie per la spiegazione. Abbastanza sorprendente quello che puoi fare con ciò che è fondamentalmente regex e un po 'di logica :)
Emigna,

@Emigna Grazie! Le spiegazioni non sono molto dettagliate (sto facendo fatica a scrivere spiegazioni più lunghe), ma sembra che sia abbastanza per te :) (credo ancora che il codice sia leggermente troppo lungo, ma non vedo come ottenere è più corto, quindi eccolo qui)
Dada,

1
Come qualcuno che non conosce Perl apprezzo ogni spiegazione che posso ottenere. Non mi aiuterà a creare un programma Perl, ma comprendo alcuni dei ragionamenti alla base del metodo impiegato, che è sempre interessante.
Emigna,

3

Python, 129 125 123 byte

Se solo zero fossero primi ...

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

Provalo online

La funzione pè la funzione di verifica primaria, che ha >0alla fine in modo che funzioni anche per zero, che altrimenti tornerebbe -1. La lambda anonima è la lambda che controlla tutte le condizioni richieste.


Ecco un metodo leggermente diverso usando una comprensione set. Il risultato sarà un set. ( 124 byte ):

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}

3

Perl 6 , 65 byte

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

Provalo

Allargato:

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

}

3

Ottava, 73 byte

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

Provalo 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

2

CJam , 26 27 byte

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

Algoritmo semplice, golf ulteriormente.

EDIT: Forgot n era inclusivo.

Provalo online!

Per divertimento, questo è molto simile e anche 27 byte:

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

Spiegazione

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

Gelatina , 14 byte

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

Provalo online!

Sfortunatamente, ho potuto legare solo con @Dennis, ma l'algoritmo sembra essere leggermente diverso, quindi sto pubblicando questo comunque.

Spiegazione

Funzione helper (elimina gli elementi dell'elenco che non hanno un numero primo di occorrenze di un dato 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

Programma principale:

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

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

Niente di pazzo. Sostanzialmente un setaccio modificato di Eratostene che valuta la primalità del conteggio 0/1 nella stessa iterazione che attraversa i non-primi più alti. Con alcuni spazi bianchi:

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

Ma oggi ho imparato che avrei potuto mettere continueun operatore ternario e a Haxe non importa nemmeno.

Modifica: +2 perché nè un limite superiore inclusivo!


Ehi, nè inclusivo.
Gurupad Mamadapur,

@GurupadMamadapur Hai ragione, riparato!
Aurel Bílý,

2

Utilità Bash + GNU, 129 126 123 114 111 109 byte

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

Provalo online!

Ho notato il commento secondo cui l'output non deve essere in ordine crescente: è stato eliminato 3 byte eseguendo il conto alla rovescia anziché il conto alla rovescia.

Sostituito grep con wc per salvare 3 byte aggiuntivi.

Eliminata una variabile (9 byte in più off).

Modificato il modo in cui viene utilizzato il fattore - 3 byte in più.

Reso più golfista con seq (2 byte).


2

Python, 172 170 168 159 154 133 133 130 byte

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

Utilizzo: chiamare la funzione lambda anonima Il
metodo pcontrolla se un numero è primo


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


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

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!



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!


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


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

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!


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

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! :)
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.