Update all new Tasks

Task/Pernicious-numbers/00DESCRIPTION

@@ -0,0 +1,12 @@
+A ''[[wp:Pernicious number|pernicious number]]'' is a positive integer whose [[population count]] is a prime.
+<br>The ''population count'' (also known as ''pop count'') is the number of <code>1</code>'s (ones) in the binary representation of a non-negative integer.<br>
+For example, <math>22</math> (which is <code>10110</code> in binary) has a population count of <math>3</math>, which is prime and so <math>22</math> is a pernicious number.
+
+;Task requirements
+* display the first 25 pernicious numbers.
+* display all pernicious numbers between 888,888,877 and 888,888,888 (inclusive).
+* display each list of integers on one line (which may or may not include a title).
+
+;See also
+* Sequence [[oeis:A052294|A052294 pernicious numbers]] on The On-Line Encyclopedia of Integer Sequences.
+* Rosetta Code entry [[Population_count|population count, evil numbers, odious numbers]].

Task/Pernicious-numbers/00META.yaml

@@ -0,0 +1,2 @@
+---
+note: Prime Numbers

Task/Pernicious-numbers/Ada/pernicious-numbers-1.ada

@@ -0,0 +1,40 @@
+with Ada.Text_IO, Population_Count; use Population_Count;
+
+procedure Pernicious is
+
+   Prime: array(0 .. 64) of Boolean;
+     -- we are using 64-bit numbers, so the population count is between 0 and 64
+   X: Num; use type Num;
+   Cnt: Positive;
+begin
+   -- initialize array Prime; Prime(I) must be true if and only if I is a prime
+   Prime := (0 => False, 1 => False, others => True);
+   for I in 2 .. 8 loop
+      if Prime(I) then
+	 Cnt := I + I;
+	 while Cnt <= 64 loop
+	    Prime(Cnt) := False;
+	    Cnt := Cnt + I;
+	 end loop;
+      end if;
+   end loop;
+
+   -- print first 25 pernicious numbers
+   X := 1;
+   for I in 1 .. 25 loop
+      while not Prime(Pop_Count(X)) loop
+	 X := X + 1;
+      end loop;
+      Ada.Text_IO.Put(Num'Image(X));
+      X := X + 1;
+   end loop;
+   Ada.Text_IO.New_Line;
+
+   -- print pernicious numbers between  888_888_877 and 888_888_888 (inclusive)
+   for Y in Num(888_888_877) .. 888_888_888 loop
+      if Prime(Pop_Count(Y)) then
+	 Ada.Text_IO.Put(Num'Image(Y));
+      end if;
+   end loop;
+   Ada.Text_IO.New_Line;
+end;

Task/Pernicious-numbers/Ada/pernicious-numbers-2.ada

@@ -0,0 +1,14 @@
+   Counter: Natural;
+begin
+   -- initialize array Prime; Prime(I) must be true if and only if I is a prime
+   ...
+
+   Counter := 0;
+   -- count p. numbers below 2**32
+   for Y in Num(2) .. 2**32 loop
+      if Prime(Pop_Count(Y)) then
+	 Counter := Counter + 1;
+      end if;
+   end loop;
+   Ada.Text_IO.Put_Line(Natural'Image(Counter));
+end Count_Pernicious;

Task/Pernicious-numbers/AutoHotkey/pernicious-numbers.ahk

@@ -0,0 +1,16 @@
+c := 0
+while c < 25
+	if IsPern(A_Index)
+		Out1 .= A_Index " ", c++
+Loop, 12
+	if IsPern(n := 888888876 + A_Index)
+		Out2 .= n " "
+MsgBox, % Out1 "`n" Out2
+
+IsPern(x) {	;https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation
+	static p := {2:1, 3:1, 5:1, 7:1, 11:1, 13:1, 17:1, 19:1, 23:1, 29:1, 31:1, 37:1, 41:1, 43:1, 47:1, 53:1, 59:1, 61:1}
+	x -= (x >> 1) & 0x5555555555555555
+	, x := (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
+	, x := (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
+	return p[(x * 0x0101010101010101) >> 56]
+}

Task/Pernicious-numbers/C++/pernicious-numbers.cpp

@@ -0,0 +1,51 @@
+#include <iostream>
+#include <algorithm>
+#include <bitset>
+
+using namespace std;
+
+class pernNumber
+{
+public:
+    void displayFirst( unsigned cnt )
+    {
+	unsigned pn = 3;
+	while( cnt )
+	{
+	    if( isPernNumber( pn ) )
+	    {
+		cout << pn << " "; cnt--;
+	    }
+	    pn++;
+	}
+    }
+    void displayFromTo( unsigned a, unsigned b )
+    {
+	for( unsigned p = a; p <= b; p++ )
+	    if( isPernNumber( p ) )
+		cout << p << " ";
+    }
+
+private:
+    bool isPernNumber( unsigned p )
+    {
+	string bin = bitset<64>( p ).to_string();
+	unsigned c = count( bin.begin(), bin.end(), '1' );
+	return isPrime( c );
+    }
+    bool isPrime( unsigned p )
+    {
+	if( p == 2 ) return true;
+	if( p < 2 || !( p % 2 ) ) return false;
+	for( unsigned x = 3; ( x * x ) <= p; x += 2 )
+	    if( !( p % x ) ) return false;
+	return true;
+    }
+};
+int main( int argc, char* argv[] )
+{
+    pernNumber p;
+    p.displayFirst( 25 ); cout << endl;
+    p.displayFromTo( 888888877, 888888888 ); cout << endl;
+    return 0;
+}

Task/Pernicious-numbers/C/pernicious-numbers.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+typedef unsigned uint;
+uint is_pern(uint n)
+{
+        uint c = 2693408940u; // int with all prime-th bits set
+        while (n) c >>= 1, n &= (n - 1); // take out lowerest set bit one by one
+        return c & 1;
+}
+
+int main(void)
+{
+        uint i, c;
+        for (i = c = 0; c < 25; i++)
+                if (is_pern(i))
+                        printf("%u ", i), ++c;
+        putchar('\n');
+
+        for (i = 888888877u; i <= 888888888u; i++)
+                if (is_pern(i))
+                        printf("%u ", i);
+        putchar('\n');
+
+        return 0;
+}

Task/Pernicious-numbers/Common-Lisp/pernicious-numbers.lisp

@@ -0,0 +1,11 @@
+(format T "~{~a ~}~%"
+        (loop for n = 1 then (1+ n)
+              when (primep (logcount n))
+                collect n into numbers
+              when (= (length numbers) 25)
+                return numbers))
+
+(format T "~{~a ~}~%"
+        (loop for n from 888888877 to 888888888
+              when (primep (logcount n))
+                collect n))

Task/Pernicious-numbers/D/pernicious-numbers-1.d

@@ -0,0 +1,7 @@
+void main() {
+    import std.stdio, std.algorithm, std.range, core.bitop;
+
+    immutable pernicious = (in uint n) => (2 ^^ n.popcnt) & 0xA08A28AC;
+    uint.max.iota.filter!pernicious.take(25).writeln;
+    iota(888_888_877, 888_888_889).filter!pernicious.writeln;
+}

Task/Pernicious-numbers/D/pernicious-numbers-2.d

@@ -0,0 +1 @@
+uint.max.iota.filter!pernicious.walkLength.writeln;

Task/Pernicious-numbers/Go/pernicious-numbers.go

@@ -0,0 +1,33 @@
+package main
+
+import "fmt"
+
+func pernicious(w uint32) bool {
+    const (
+        ff    = 1<<32 - 1
+        mask1 = ff / 3
+        mask3 = ff / 5
+        maskf = ff / 17
+        maskp = ff / 255
+    )
+    w -= w >> 1 & mask1
+    w = w&mask3 + w>>2&mask3
+    w = (w + w>>4) & maskf
+    return 0xa08a28ac>>(w*maskp>>24)&1 != 0
+}
+
+func main() {
+    for i, n := 0, uint32(1); i < 25; n++ {
+        if pernicious(n) {
+            fmt.Printf("%d ", n)
+            i++
+        }
+    }
+    fmt.Println()
+    for n := uint32(888888877); n <= 888888888; n++ {
+        if pernicious(n) {
+            fmt.Printf("%d ", n)
+        }
+    }
+    fmt.Println()
+}

Task/Pernicious-numbers/Haskell/pernicious-numbers.hs

@@ -0,0 +1,17 @@
+module Pernicious
+   where
+
+isPernicious :: Integer -> Bool
+isPernicious num = isPrime $ toInteger $ length $ filter ( == 1 ) $ toBinary num
+
+isPrime :: Integer -> Bool
+isPrime number = divisors number == [1, number]
+   where
+      divisors :: Integer -> [Integer]
+      divisors number = [ m | m <- [1 .. number] , number `mod` m == 0 ]
+
+toBinary :: Integer -> [Integer]
+toBinary num = reverse $ map ( `mod` 2 ) ( takeWhile ( /= 0 ) $ iterate ( `div` 2 ) num )
+
+solution1 = take 25 $ filter isPernicious [1 ..]
+solution2 = filter isPernicious [888888877 .. 888888888]

Task/Pernicious-numbers/Icon/pernicious-numbers.icon

@@ -0,0 +1,16 @@
+link "factors"
+
+procedure main(A)
+    every writes((pernicious(seq())\25||" ") | "\n")
+    every writes((pernicious(888888877 to 888888888)||" ") | "\n")
+end
+
+procedure pernicious(n)
+    return (isprime(c1bits(n)),n)
+end
+
+procedure c1bits(n)
+    c := 0
+    while n > 0 do c +:= 1(n%2, n/:=2)
+    return c
+end

Task/Pernicious-numbers/J/pernicious-numbers-1.j

@@ -0,0 +1,3 @@
+ispernicious=: 1 p: +/"1@#:
+
+thru=: <./ + i.@(+*)@-~

Task/Pernicious-numbers/J/pernicious-numbers-2.j

@@ -0,0 +1,4 @@
+   25{.I.ispernicious i.100
+3 5 6 7 9 10 11 12 13 14 17 18 19 20 21 22 24 25 26 28 31 33 34 35 36
+   888888877 + I. ispernicious 888888877 thru 888888888
+888888877 888888878 888888880 888888883 888888885 888888886

Task/Pernicious-numbers/Java/pernicious-numbers.java

@@ -0,0 +1,29 @@
+public class Pernicious{
+    //very simple isPrime since x will be <= Long.SIZE
+    public static boolean isPrime(int x){
+        if(x < 2) return false;
+        for(int i = 2; i < x; i++){
+            if(x % i == 0) return false;
+        }
+        return true;
+    }
+
+    public static int popCount(long x){
+        return Long.bitCount(x);
+    }
+
+    public static void main(String[] args){
+        for(long i = 1, n = 0; n < 25; i++){
+            if(isPrime(popCount(i))){
+                System.out.print(i + " ");
+                n++;
+            }
+        }
+
+        System.out.println();
+
+        for(long i = 888888877; i <= 888888888; i++){
+            if(isPrime(popCount(i))) System.out.print(i + " ");
+        }
+    }
+}

Task/Pernicious-numbers/Mathematica/pernicious-numbers-1.math

@@ -0,0 +1,17 @@
+popcount[n_Integer] := IntegerDigits[n, 2] // Total
+perniciousQ[n_Integer] := popcount[n] // PrimeQ
+perniciouscount = 0;
+perniciouslist = {};
+i = 0;
+While[perniciouscount < 25,
+ If[perniciousQ[i], AppendTo[perniciouslist, i]; perniciouscount++];
+ i++]
+Print["first 25 pernicious numbers"]
+perniciouslist
+(*******)
+perniciouslist2 = {};
+Do[
+ If[perniciousQ[i], AppendTo[perniciouslist2, i]]
+ , {i, 888888877, 888888888}]
+Print["Pernicious numbers between 888,888,877 and 888,888,888 (inclusive)"]
+perniciouslist2

Task/Pernicious-numbers/Mathematica/pernicious-numbers-2.math

@@ -0,0 +1 @@
+perniciousQ[n_Integer] := PrimeQ@Total@IntegerDigits[n, 2]

Task/Pernicious-numbers/Mathematica/pernicious-numbers-3.math

@@ -0,0 +1 @@
+n = 0; NestWhile[Flatten@{#, If[perniciousQ[++n], n, {}]} &, {}, Length@# < 25 &]

Task/Pernicious-numbers/Mathematica/pernicious-numbers-4.math

@@ -0,0 +1 @@
+Cases[Range[888888877, 888888888], _?(perniciousQ@# &)]

Task/Pernicious-numbers/PARI-GP/pernicious-numbers.pari

@@ -0,0 +1,3 @@
+pern(n)=isprime(hammingweight(n))
+select(pern, [1..36])
+select(pern,[888888877..888888888])

Task/Pernicious-numbers/Pascal/pernicious-numbers.pascal

@@ -0,0 +1,65 @@
+program pernicious;
+{$IFDEF FPC}
+   {$OPTIMIZATION ON,Regvar,ASMCSE,CSE,PEEPHOLE}// 3x speed up
+{$ENDIF}
+uses
+  sysutils;//only used for time
+
+type
+  tbArr    = array[0..64] of byte;
+{
+  PrimeTil64 : array[0..64] of byte =
+  (0,0,2,3,0,5,0, 7,0,0,0,11,0,13,0,0,0,17,0,19,0,0,0,23,0,0,0,0,0,29,0,
+    31,0,0,0,0,0,37,0,0,0,41,0,43,0,0,0,47,0, 0,0,0,0,53,0,0,0,0,0,59,0,
+    61,0,0,0);
+}
+const
+  PrimeTil64 : tbArr =
+  (0,0,1,1,0,1,0, 1,0,0,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,
+     1,0,0,0,0,0, 1,0,0,0,1,0,1,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,
+     1,0,0,0);
+
+function popcnt32(n:Uint32):NativeUint;
+//https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation
+const
+  K1  = $0101010101010101;
+  K33 = $3333333333333333;
+  K55 = $5555555555555555;
+  KF1 = $0F0F0F0F0F0F0F0F;
+begin
+  n := n- (n shr 1) AND NativeUint(K55);
+  n := (n AND NativeUint(K33))+ ((n shr 2) AND NativeUint(K33));
+  n := (n + (n shr 4)) AND NativeUint(KF1);
+  n := (n*NativeUint(K1)) SHR 24;
+  popcnt32 := n;
+end;
+
+var
+  t : TDAteTime;
+  i,
+  k : LongWord;
+
+Begin
+  writeln('the 25 first pernicious numbers');
+  I:=1;k:=0;
+  repeat
+    IF PrimeTil64[popCnt32(i)] <> 0 then Begin
+      inc(k); write(i,' ');end;
+    inc(i);
+  until k >= 25;
+  writeln;
+
+  writeln('pernicious numbers in [888888877..888888888]');
+  For i :=  888888877 to 888888888 do
+    IF PrimeTil64[popCnt32(i)] <> 0  then
+      write(i,' ');
+  writeln;
+
+  //speedtest of popcount
+  t:= time;
+  k := 0;
+  For i :=  High(i) downto 0 do
+    k := k+PrimeTil64[popCnt32(i)];
+  t := time-t;
+  writeln(k,' pernicious numbers in [0..2^32-1] takes ',t*86400:0:3,' seconds');
+ end.

Task/Pernicious-numbers/Perl-6/pernicious-numbers.pl6

@@ -0,0 +1,6 @@
+sub is-pernicious(Int $n --> Bool) {
+    is-prime [+] $n.base(2).comb;
+}
+
+say (grep &is-pernicious, 0 .. *)[^25];
+say grep &is-pernicious, 888_888_877 .. 888_888_888;

Task/Pernicious-numbers/Perl/pernicious-numbers-1.pl

@@ -0,0 +1,22 @@
+sub is_pernicious {
+    my $n = shift;
+    my $c = 2693408940;  # primes < 32 as set bits
+    while ($n) { $c >>= 1; $n &= ($n - 1); }
+    $c & 1;
+}
+
+my ($i, @p) = 0;
+while (@p < 25) {
+    push @p, $i if is_pernicious($i);
+    $i++;
+}
+
+print join ' ', @p;
+print "\n";
+($i, @p) = (888888877,);
+while ($i < 888888888) {
+    push @p, $i if is_pernicious($i);
+    $i++;
+}
+
+print join ' ', @p;

Task/Pernicious-numbers/Perl/pernicious-numbers-2.pl

@@ -0,0 +1,5 @@
+use ntheory qw/is_prime hammingweight/;
+my $i = 1;
+my @pern = map { $i++ while !is_prime(hammingweight($i)); $i++; } 1..25;
+print "@pern\n";
+print join(" ", grep { is_prime(hammingweight($_)) } 888888877 .. 888888888), "\n";

Task/Pernicious-numbers/Python/pernicious-numbers.py

@@ -0,0 +1,20 @@
+>>> def popcount(n): return bin(n).count("1")
+
+>>> primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61}
+>>> p, i = [], 0
+>>> while len(p) < 25:
+        if popcount(i) in primes: p.append(i)
+        i += 1
+
+
+>>> p
+[3, 5, 6, 7, 9, 10, 11, 12, 13, 14, 17, 18, 19, 20, 21, 22, 24, 25, 26, 28, 31, 33, 34, 35, 36]
+>>> p, i = [], 888888877
+>>> while i <= 888888888:
+        if popcount(i) in primes: p.append(i)
+        i += 1
+
+
+>>> p
+[888888877, 888888878, 888888880, 888888883, 888888885, 888888886]
+>>>

Task/Pernicious-numbers/README

@@ -0,0 +1 @@
+Data source: http://rosettacode.org/wiki/Pernicious_numbers

Task/Pernicious-numbers/REXX/pernicious-numbers.rexx

@@ -0,0 +1,31 @@
+/*REXX program displays a number of pernicious numbers and also a range.*/
+numeric digits 30                      /*be able to handle large numbers*/
+parse arg N L H .                      /*get optional arguments: N, L, H*/
+if N=='' | N==','  then N=25           /*N given?  Then use the default.*/
+if L=='' | L==','  then L=888888877    /*L   "  ?    "   "   "     "    */
+if H=='' | H==','  then H=888888888    /*H   "  ?    "   "   "     "    */
+say 'The 1st '  N  " pernicious numbers are:"    /*display a nice title.*/
+say pernicious(1,,N)                   /*get all pernicious # from 1──►N*/
+say                                    /*display a blank line for a sep.*/
+say 'Pernicious numbers between '  L  " and "  H  ' (inclusive) are:'
+say pernicious(L,H)                    /*get all pernicious # from L──►H*/
+exit                                   /*stick a fork in it, we're done.*/
+/*──────────────────────────────────D2B subroutine──────────────────────*/
+d2b: return word(strip(x2b(d2x(arg(1))),'L',0) 0,1)  /*convert dec──►bin*/
+/*──────────────────────────────────PERNICIOUS subroutine───────────────*/
+pernicious: procedure; parse arg bot,top,m /*get the bot & top #s, limit*/
+_ = 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
+!.=0;  do k=1 until p=''; p=word(_,k); !.p=1; end  /*gen low prime array*/
+if m==''    then   m=999999999         /*assume an "infinite" limit.    */
+if top==''  then top=999999999         /*assume an "infinite" top limit.*/
+#=0                                    /*number of pernicious #s so far.*/
+$=;  do j=bot  to top  until #==m      /*gen pernicious until satisfied.*/
+     pc=popCount(j)                    /*obtain population count for  J.*/
+     if \!.pc  then iterate            /*if popCount ¬ in !.prime, skip.*/
+     $=$ j                             /*append a pernicious #  to list.*/
+     #=#+1                             /*bump the pernicious #  count.  */
+     end   /*j*/                       /* [↑]  append popCount to a list*/
+return substr($,2)                     /*return results, sans 1st blank.*/
+/*──────────────────────────────────POPCOUNT subroutine─────────────────*/
+popCount: procedure;_=d2b(abs(arg(1))) /*convert the # passed to binary.*/
+return length(_)-length(space(translate(_,,1),0))  /*count the one bits.*/

Task/Pernicious-numbers/Racket/pernicious-numbers.rkt

@@ -0,0 +1,21 @@
+#lang racket
+(require math/number-theory rnrs/arithmetic/bitwise-6)
+
+(define pernicious? (compose prime? bitwise-bit-count))
+
+(define (dnl . strs)
+  (for-each displayln strs))
+
+(define (show-sequence seq)
+  (string-join (for/list ((v (in-values*-sequence seq))) (~a ((if (list? v) car values) v))) ", "))
+
+(dnl
+ "Task requirements:"
+ "display the first 25 pernicious numbers."
+ (show-sequence (in-parallel (sequence-filter pernicious? (in-naturals 1)) (in-range 25)))
+ "display all pernicious numbers between 888,888,877 and 888,888,888 (inclusive)."
+ (show-sequence (sequence-filter pernicious? (in-range 888888877 (add1 888888888)))))
+
+(module+ test
+  (require rackunit)
+  (check-true (pernicious? 22)))

Task/Pernicious-numbers/Ruby/pernicious-numbers.rb

@@ -0,0 +1,16 @@
+require "prime"
+
+class Integer
+
+  def popcount
+    to_s(2).count("1")
+  end
+
+  def pernicious?
+    popcount.prime?
+  end
+
+end
+
+p 1.step.lazy.select(&:pernicious?).take(25).to_a
+p ( 888888877..888888888).select(&:pernicious?)

Task/Pernicious-numbers/Scala/pernicious-numbers.scala

@@ -0,0 +1,8 @@
+def isPernicious( v:Long ) : Boolean = BigInt(v.toBinaryString.toList.filter( _ == '1' ).length).isProbablePrime(16)
+
+// Generate the output
+{
+  val (a,b1,b2) = (25,888888877L,888888888L)
+  println( Stream.from(2).filter( isPernicious(_) ).take(a).toList.mkString(",") )
+  println( {for( i <- b1 to b2 if( isPernicious(i) ) ) yield i}.mkString(",") )
+}

Task/Pernicious-numbers/Tcl/pernicious-numbers.tcl

@@ -0,0 +1,14 @@
+package require math::numtheory
+
+proc pernicious {n} {
+    ::math::numtheory::isprime [tcl::mathop::+ {*}[split [format %b $n] ""]]
+}
+
+for {set n 0;set p {}} {[llength $p] < 25} {incr n} {
+    if {[pernicious $n]} {lappend p $n}
+}
+puts [join $p ","]
+for {set n 888888877; set p {}} {$n <= 888888888} {incr n} {
+    if {[pernicious $n]} {lappend p $n}
+}
+puts [join $p ","]