Primes com contagens primárias de bits

23

Tarefa

Encontre todos os números inteiros não negativos até e incluindo um número inteiro positivo n diferente de zero n , que são primos e a contagem de 1'se 0'sem sua representação binária (sem zeros à esquerda) também são primos.

Aqui estão os cinco primeiros números primos,

17, 19, 37, 41, 79

10001, 10011, 100101, 101001, 1001111

Esclarecimentos e regras

  • Métodos de E / S padrão são aceitos .
  • A resposta pode ser um programa ou uma função.
  • Se não houver esses primos, emita lixo ou nada.
  • As brechas padrão são proibidas.
  • 2 3 5 7não chegaram à lista porque, em sua representação binária, número de ocorrências 0'se 1'snão são primos. Considere 7cuja representação binária é 111, aqui 0ocorre zero vezes e zero não é primo.

  • Built-ins são permitidos.

  • O código mais curto em bytes vence!

Casos de teste

10
[]

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

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

Mostrar snippet de código

code-golf  primes  binary 
— Gurupad Mamadapur
fonte
1
Você solicita todos os números primos sob um dado n, mas também diz inclusivo. O que você quer dizer?
— Riley #
@Riley O que quero dizer é ... all the numbers from 1....n. Eu não sei como reformulá-lo de uma maneira simples.
— Gurupad Mamadapur
6
— mbomb007
3
@ mbomb007 Claramente, para qualquer ordem total de seqüências inteiras, a menor sequência inteira desinteressante seria interessante e, portanto, digna de inclusão no OEIS. Portanto, o OEIS contém todas as seqüências inteiras, de qualquer interesse real ou imaginado :-)
— Eu não vou existir idonotexista
9
Eu estou querendo saber se Mathematica contém mais builtins que OEIS tem sequências ...
— Neil

Respostas:

5

Geléia , 14 13 bytes

RBċþd`ÆPPTfÆR

Experimente online!

Como funciona

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
fonte
2
Esse d`​truque é outra coisa ...
— ETHproductions
10

Python 2 , 106 102 100 bytes

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

Experimente online!

fundo

Para identificar números primos, usamos um corolário do teorema de Wilson :

corolário do teorema de Wilson

Como funciona

Nós começar por inicializar k e m como 1 e p como o conjunto {0} . Note que m = 1 = 0! ² = (k - 1)! ² . Imediatamente depois, o código a seguir é executado n vezes, onde n é o número inteiro lido da entrada padrão.

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

Pelo corolário, m% k será 1 se k for primo e 0 caso contrário. Assim, {m%k*k,0}retornará o conjunto {k, 0} se k for primo e o conjunto {0} caso contrário.

Se (e somente se) k for primo, já que p não pode conter k neste momento, a diferença simétrica no local p^={m%k*k,0}adicionará k ao conjunto p . Além disso, p conterá 0 após a atualização se e somente se não contiver 0 antes, então 0 ∊ p se e somente se k for par.

Na mesma linha, definimos uma função c via c=bin(k).count, que contará as ocorrências de seu argumento na representação binária de k .

A segunda linha produz a saída real. {k,c('1'),c('0')-1}retorna o conjunto que consiste em k , o número de bits definidos em k e o número de bits não definidos em k . Como a saída bin(k)começa com 0b , temos que diminuir c('0')para dar conta do 0 inicial .

Se todos eles forem primos, todos pertencerão a p , que agora contém todos os números primos até k (e potencialmente 0 ). Se k for um número de Mersenne (ou seja, se tiver apenas bits definidos), c('0')-1produzirá 0 . Como os números de Mersenne são impares, p irá não contêm 0 , então a condição falhará.

Após (potencialmente) imprimir k , multiplicamos m por k² . Como m = (k-1)! ² antes da atualização, m = k! ² depois dela. Depois de incrementar k , a relação m = (k-1)! ² se mantém novamente e estamos prontos para a próxima iteração.

— Dennis
fonte
9

Mathematica, 80 68 54 bytes

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

Explicação

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

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

Guardado 4 bytes graças 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))

Uma combinação de três funções recursivas típicas. Alerta a sequência na ordem inversa e termina com um erro "muita recursão".

Snippet de teste

(modificado para enviar para a página)

Mostrar snippet de código

A função principal pode retornar uma matriz para 104 bytes:

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

Também pode ser não recursivo à custa de outro 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]

Aqui está o que eu comecei: (Salvo 6 bytes graças 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:[]):[]

Tentei jogar mais e consegui fazê-lo em 104 bytes - depois percebi que já havia encontrado a solução (está na parte inferior da resposta). Você não odeia quando isso acontece? : P

Uma tentativa não recursiva na função principal (novamente, mesma contagem de bytes):

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

Este segue a rota fácil de contar quantos 0 e 1 estão na representação binária:

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

A mesma coisa com uma compreensão de matriz:

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]

Este segue um caminho um pouco mais difícil para fazer a mesma coisa:

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 este segue mais uma rota relacionada que é tão curta quanto a 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):[]

Novamente, você pode obter 8 bytes de golfe, alertando a sequência na ordem inversa:

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
fonte
Você realmente não precisa passar recursivamente a. Apenas inicialize-o na chamada inicial para G. (Isso deve salvar 4 bytes.)
— Arnauld
@ Arnauld Oh sim, obrigado! Isso é divertido :-)
— ETHproductions
1
Uau, isso caiu muito. Bom trabalho
— George Reith
6

Geléia , 17 16 bytes

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

Experimente online!

Quão?

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
fonte
1
Ah, obrigado, vejo que você mudou isso, isso economizará um byte.
— Jonathan Allan
1
Você tem o alfabeto indo lá. ẠBÇЀfĠ...
— mbomb007
2
@ mbomb007 Sim, a coisa LƵ;Psempre me confunde.
— Jonathan Allan
6

05AB1E , 14 bytes

ƒNpNbSD_‚OpP&–

Experimente online!

Explicação

ƒ               # 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
fonte
Ainda não consigo encontrar um uso para .¡, esse desafio parecia bom para ele, mas é mais longo:FNb{.¡€gpONp+3QiN}})
— Magic Octopus Urn
@carusocomputing: Eu também tinha uma solução semelhante, mas também acabou um pouco mais do que isso.
— Emigna
4

MATL , 16 15 bytes

:"@tB!t~hshZp?@

Experimente 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
fonte
4

Perl, 101 bytes

99 bytes de código + -nlsinalizadores.

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

Para executá-lo:

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

Algumas explicações curtas
$r contêm o clássico regex de verificação primária ( q/^1?$|^(11+)\1+$/).
Para todos os números entre 2 e a entrada,
(1x$@)!~$rverifica se o número é primo,
y/01/1/dr!~$rverifica se o número de 0na representação binária é primo,
s/0//gr!~$rverifica se o número 1na representação binária é primo.
(se as três condições forem atendidas, print$@imprima-a).

— dada
fonte
Obrigada pelo esclarecimento. Muito impressionante o que você pode fazer com o que é basicamente regex e alguma lógica :)
— Emigna
@Emigna Thanks! As explicações não são muito detalhadas (estou tendo dificuldade para escrever explicações mais longas), mas parece que foi o suficiente para você :) (ainda acredito que o código é um pouco longo demais, mas não vejo como obter mais curto, então aqui está ele)
— Dada
1
Como alguém que não conhece Perl, aprecio todas as explicações que posso obter. Isso não vai me ajudar a criar um programa Perl, mas eu entendo algumas das razões por trás do método empregado, o que é sempre interessante.
— Emigna
3

Python, 129 125 123 bytes

Se apenas zero fosse primo ...

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

Experimente online

Function pé a função de verificação primária, que possui >0no final, para que também funcione com zero, que de outra forma retornaria -1. O lambda anônimo é o lambda que verifica todas as condições necessárias.

Aqui está um método ligeiramente diferente usando uma compreensão de conjunto. O resultado será um conjunto. ( 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
fonte
3

Perl 6 , 65 bytes

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

Tente

Expandido:

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

Oitava, 73 bytes

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

Experimente 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
fonte
2

CJam , 26 27 bytes

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

Algoritmo simples, irá jogar mais.

EDIT: Esqueceu n foi inclusivo.

Experimente online!

Por diversão, isso é muito semelhante e também 27 bytes:

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

Explicação

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
— Gato de negócios
fonte
2

Gelatina , 14 bytes

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

Experimente online!

Infelizmente, eu só poderia amarrar com @Dennis, mas o algoritmo parece ser um pouco diferente, então eu estou postando isso de qualquer maneira.

Explicação

Função auxiliar (exclui elementos da lista que não possuem um número primo de ocorrências de um determinado 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

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

Nada maluco. Essencialmente, uma peneira modificada de Eratóstenes que avalia a primalidade da contagem de 0/1 na mesma iteração que o cruzamento de não primos mais altos. Com algum espaço em branco:

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

Mas hoje eu aprendi que poderia continuecontratar um operador ternário e Haxe nem se importa.

Edit: +2 porque né um limite superior inclusivo!

— Aurel Bílý
fonte
Ei, o né inclusivo.
— Gurupad Mamadapur
@GurupadMamadapur Você está certo, consertado!
— Aurel Bílý 17/01
2

Utilitários Bash + GNU, 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

Experimente online!

Percebeu o comentário de que a saída não precisa estar em ordem crescente - reduza 3 bytes fazendo contagem regressiva em vez de contagem regressiva.

Grep substituído por wc para salvar 3 bytes adicionais.

Eliminada uma variável (mais 9 bytes de desconto).

Mudou a maneira como o fator é usado - mais 3 bytes.

Tornou-o mais golfista com seq (2 bytes).

— Mitchell Spector
fonte
2

Python, 172 170 168 159 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')]

Uso: Chame a função lambda anônima. O
método pverifica se um número é primo

Guardado 2 + 2 + 9 = 13 bytes graças a Gurupad Mamadapur
Guardado 5 bytes graças a mbomb007

— ovs
fonte
1
Você pode economizar mais 2 usando isso v-def v(n):a=bin(n)[2:];return p(n)and(p(a.count('1'))and p(a.count('0')))
— Gurupad Mamadapur
1
Um muito mais curto -v=lambda a:p(a)and all(p(bin(a)[2:].count(x))for x in['1','0'])
— Gurupad Mamadapur
2
Strings são iteráveis. Então você pode usar for x in'01'.
— mbomb007
1

Pyke, 21 bytes

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

Experimente aqui!

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")
— Azul
fonte
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))}})}

Este é um fechamento sem nome.

Experimente aqui!

— Gurupad Mamadapur
fonte
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

Mostrar snippet de código

— George Reith
fonte
Essa função de teste de primalidade é ... simplesmente incrível :-) Você a criou?
— ETHproductions
@ETHproductions Você já viu isso antes do codegolf.stackexchange.com/a/91309/11182 modificado a partir daqui. Também emprestei seu código de contagem 1 e 0 (gritou qualquer coisa que eu pudesse criar), mas infelizmente não consegui superar sua contagem de bytes.
— George Reith
@ETHproductions Boa captura, obrigado! Era um artefato de uma versão anterior
— George Reith
1

MATLAB, 50 bytes

@(n)all(isprime([n,sum(de2bi(n)),sum(~de2bi(n))]))
— MattWH
fonte
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);};

Sai para STDOUT e termina com um erro "muita recursão"; ligue com por exemplo f(1000);. Você pode usar um whileloop sem erro para 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--;}};

O uso de um intervalo ficou três bytes mais longo:

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

Teste online!

— ETHproductions
fonte
1

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

link para parque infantil

Os count_ones, count_zerose leading_zerosmétodos veio a calhar.

Versão formatada

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
fonte
1

Perl 6 , 50 bytes

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

Variação da resposta de b2gills , usando o operador de & junção com grande efeito.

Experimente online!

Como funciona

{                                                }  # 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
fonte
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.