具有素数的素数

23

任务

查找所有非负整数，直到并包括给定的非零正整数n，它们都是质数，1's并且0's在其二进制表示形式（无前导零）中的和的计数也都是质数。

这是前五个素数，

17, 19, 37, 41, 79

10001, 10011, 100101, 101001, 1001111

澄清和规则

  • 接受默认的I / O方法。
  • 答案可以是程序或函数。
  • 如果没有这样的素数，则输出垃圾或什么都不输出。
  • 禁止出现标准漏洞。
  • 2 3 5 7之所以没有列入清单，是因为它们的二进制表示形式中0's和的出现次数1's不是素数。考虑7其二进制表示为111，这里0出现零次，而零不是素数。

  • 允许内置。

  • 以字节为单位的最短代码胜出！

测试用例

10
[]

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

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

显示代码段

code-golf  primes  binary 
— 古鲁帕德·马马达普尔
source
1
您要求给定n 下的所有素数，但您也要说“包含”。你什么意思
— 莱利
@Riley我的意思是…… all the numbers from 1....n。我不知道如何以简单的方式重新措辞。
— Gurupad Mamadapur
6
— mbomb007 '17
3
@ mbomb007显然，对于整数序列的所有总排序，最小的无趣整数序列本身就是有趣的，因此值得包含在OEIS中。Ergo，OEIS包含所有整数序列，无论是真实的还是虚构的：-)
— Iwillnotexist Idonotexist
9
我想知道Mathematica是否包含比OEIS具有更多序列的内建函数……
— Neil

Answers:

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.
— 丹尼斯
source
2
那d`​把戏还
— 不止于此
10

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

在线尝试！

背景

为了确定素数，我们使用威尔逊定理的推论：

corollary of Wilson's theorem

怎么运行的

我们首先将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将是1，如果ķ是素数，0否则。因此，如果k为质数，{m%k*k,0}则将返回集合{k，0}，而集合{0}。

如果（且仅当）k为质数，因为p此时不能包含k，所以就地对称差p^={m%k*k,0}会将k添加到集合p中。而且，p将包含 0更新后，当且仅当它不包含0之前，所以0εp当且仅当ķ是偶数。

在同一行上，我们通过定义函数cc=bin(k).count，该函数将计算k的二进制表示形式中其自变量的出现次数。

第二行产生实际输出。{k,c('1'),c('0')-1}器返回一个由的设定ķ本身，在组的位的数目ķ，并且在未设置的比特数ķ。自输出bin(k)开头为0b，我们必须递减c('0')以考虑前导0。。

如果它们都是素数，则它们都属于p，到现在为止，它包含所有素数，最大为k（可能为0）。如果k是一个梅森数（即，如果它仅具有设置的位），c('0')-1则将得出0。由于梅森数是奇数，因此p将不包含0，因此条件将失败。

后（可能）打印ķ，我们乘法中号由K²。由于更新前m =（k-1）！²，因此更新后m = k！²。在增加k之后，关系m =（k-1）！²再次成立，我们准备进行下一次迭代。

— 丹尼斯
source
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 *)
— 郑焕民
source
8

的JavaScript（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字节做到这一点-然后意识到我已经找到了解决方案（在答案的底部）。发生这种情况时，您不讨厌吗？：P

对主函数的非递归尝试（再次，相同的字节数）：

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生产
source
您实际上不需要递归传递a。只需在初始调用中将其初始化G。（这应节省4个字节。）
— Arnauld
@Arnauld哦，是的，谢谢！这很有趣:-)
— ETHproductions'Jan
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
— 乔纳森·艾伦
source
1
啊，谢谢，我看到你改变了，这样可以节省一个字节。
— 乔纳森·艾伦
1
那里有字母。ẠBÇЀfĠ...
— mbomb007 '17
2
@ mbomb007是的，这LƵ;P点总是让我感到困惑。
— 乔纳森·艾伦
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
— 艾米尼亚
source
我仍然找不到用.¡，这个挑战似乎对它很有用，但是时间更长：FNb{.¡€gpONp+3QiN}})
— Magic Octopus Urn
@carusocomputing：我也曾考虑过类似的解决方案，但最终结果要比这个更长。
— Emigna
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)
— 路易斯·门多
source
4

Perl，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$@打印出来）。

— 达达
source
感谢您的解释。您基本上可以使用正则表达式和一些逻辑来做些什么:)
— Emigna
@Emigna谢谢！解释不是很详细（我很难写更长的解释），但似乎对您来说已经足够了：）（我仍然相信代码有点长，但是我看不出如何获得它更短，所以就在这里）
— Dada
1
作为一个不了解Perl的人，我感谢我能得到的所有解释。它不会帮助我编写Perl程序，但我了解所采用方法背后的一些原因，这总是很有趣的。
— Emigna
3

Python，第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在结尾处具有使其也可以为零的功能，否则将返回-1。匿名lambda是检查所有所需条件的lambda。

这是使用集合理解的稍微不同的方法。结果将是一组。（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
source
3

Perl 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
source
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
source
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
— 商务猫
source
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;}];

没什么疯狂的。本质上是修改过的Eratosthenes筛子，该筛子在与删除较高的非素数相同的迭代中评估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是一个包容的上限！

— 奥雷尔·比利
source
嘿，n包容性。
— Gurupad Mamadapur
@GurupadMamadapur你是正确的，固定的！
— AurelBílý17年
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个字节。

用wc替换了grep，以节省3个额外的字节。

消除了一个变量（关闭了9个字节）。

更改了使用系数的方式-再增加3个字节。

seq（2字节）使其更加高尔夫球。

— 米切尔·史派克
source
2

Python中，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')]

用法：调用匿名lambda函数
方法p检查数字是否为质数

感谢Gurupad Mamadapur保存了2 + 2 + 9 = 13个字节感谢mbomb007
保存了5个字节

— ovs
source
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 '01
1

Pyke，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")
— 蓝色
source
1

JavaScript（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

显示代码段

— 乔治·里斯
source
那个素数测试功能...真是太神奇了:-)您自己创建了吗？
— ETHproductions
@ETHproductions在从这里修改codegolf.stackexchange.com/a/91309/11182之前，您已经看到它。我还借用了您的1和0计数代码（想知道我想出的一切），但是我无法击败您的字节数。
— 乔治·里斯
@ETHproductions很好，谢谢！是先前版本的人工制品
— George Reith，2017年
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);。您可以使用while无错误的156个字节的循环：

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

使用范围会延长三个字节：

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生产
source
1

Rust，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
source
1

Perl 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! :)
— 短信
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.