Pernicious numbers: Difference between revisions

 

=={{header|11l}}==

R bin(n).count(‘1’)

 

L(i) 888888877..888888888

I is_prime(popcount(i))

 

{{out}}

For maximum compatibility, this program uses only the basic instruction set (S/360)

with 2 ASSIST macros (XDECO,XPRNT).

PERNIC CSECT

USING PERNIC,R13 base register and savearea pointer

XDEC DS CL12 edit zone

YREGS

{{out}}

<pre>

Uses package Population_Count from [[Population count#Ada]].

 

 

procedure Pernicious is

end loop;

Ada.Text_IO.New_Line;

 

 

A small modification allows to count all the pernicious numbers between 1 and 2**32 in about 32 seconds:

 

begin

-- initialize array Prime; Prime(I) must be true if and only if I is a prime

end loop;

Ada.Text_IO.Put_Line(Natural'Image(Counter));

 

{{out}}

 

=={{header|ALGOL 68}}==

 

# returns the population (number of bits on) of the non-negative integer n #

OD;

print( ( newline ) )

{{out}}

<pre>

 

=={{header|ALGOL W}}==

% returns the population count of n %

integer procedure populationCount( integer value n ) ;

write();

end

{{out}}

<pre>

 

=={{header|AppleScript}}==

if (n < 4) then return (n > 1)

if ((n mod 2 is 0) or (n mod 3 is 0)) then return false

end task

 

 

{{output}}

 

=={{header|Arturo}}==

 

prime? size filter split as.binary n 'x -> x="0"

]

]

print ""

 

{{out}}

=={{header|AutoHotkey}}==

{{works with|AutoHotkey 1.1}}

while c < 25

if IsPern(A_Index)

, x := (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f

return p[(x * 0x0101010101010101) >> 56]

{{Out}}

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

 

=={{header|AWK}}==

# syntax: GAWK -f PERNICIOUS_NUMBERS.AWK

BEGIN {

return gsub(/1/,"&",n)

}

{{out}}

<pre>

Also note that the extra spaces in the output are just to ensure it's readable on buggy interpreters that don't include a space after numeric output. They can easily be removed by replacing the comma on line 3 with a dollar.

 

>8**`!#^_$@\<(^v^)>/#2^#\<2 2

^+**"X^yYo":+1<_:.48*,00v|: <%

v".D}Tx"$,+55_^#!p00:-1g<v |<

 

{{out}}

 

=={{header|C}}==

typedef unsigned uint;

return 0;

{{out}}

<pre>

 

=={{header|C sharp|C#}}==

using System.Linq;

 

}

}

{{out}}

<pre>

 

=={{header|C++}}==

#include <iostream>

using namespace std;

}

}

{{out}}

<pre>

 

=={{header|Clojure}}==

([] (counting-numbers 1))

([n] (lazy-seq (cons n (counting-numbers (inc n))))))

(prime? (count (filter #(= % \1) (Integer/toString n 2)))))

(println (take 25 (filter pernicious? (counting-numbers))))

{{Output}}

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

 

=={{header|CLU}}==

% higher than the amount of bits in it (max 64)

% so we can get away with a very simple primality test.

end

end

{{out}}

<pre>First 25 pernicious numbers:

 

=={{header|COBOL}}==

PROGRAM-ID. PERNICIOUS-NUMBERS.

CHECK-DSOR.

DIVIDE POPCOUNT BY DSOR GIVING DIV-RSLT.

{{out}}

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

Using <code>primep</code> from [[Primality_by_trial_division#Common_Lisp|Primality by trial division]] task.

 

(loop for n = 1 then (1+ n)

when (primep (logcount n))

(loop for n from 888888877 to 888888888

when (primep (logcount n))

 

{{Out}}

 

=={{header|D}}==

import std.stdio, std.algorithm, std.range, core.bitop;

 

uint.max.iota.filter!pernicious.take(25).writeln;

iota(888_888_877, 888_888_889).filter!pernicious.writeln;

{{out}}

<pre>[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]

This high-level code is fast enough to allow to count all the

1_421_120_880 Pernicious numbers in the unsigned 32 bit range in less than 48 seconds with this line:

 

=={{header|EchoLisp}}==

(lib 'sequences)

 

(take (filter pernicious? [888888877 .. 888888889]) #:all)

→ (888888877 888888878 888888880 888888883 888888885 888888886)

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

 

=={{header|Elixir}}==

defmodule SieveofEratosthenes do

def init(lim) do

def pernicious?(n,primes), do: Enum.member?(primes,ones(n))

end

 

PerniciousNumbers.take(25)

PerniciousNumbers.between(888_888_877..888_888_888)

 

{{out}}

 

=={{header|F#|F sharp}}==

 

//Taken from https://gist.github.com/rmunn/bc49d32a586cdfa5bcab1c3e7b45d7ac

[1 .. 100] |> Seq.filter (bitcount >> isPrime) |> Seq.take 25 |> Seq.toList |> printfn "%A"

[888888877 .. 888888888] |> Seq.filter (bitcount >> isPrime) |> Seq.toList |> printfn "%A"

{{out}}

<pre>[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]

 

=={{header|Factor}}==

prettyprint sequences ;

 

 

25 0 lfrom [ pernicious? ] lfilter ltake list>array . ! print first 25 pernicious numbers

{{out}}

<pre>

=={{header|Forth}}==

{{works with|Gforth}}

0

begin

888888877 888888888 pernicious_numbers_between

 

 

{{out}}

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

implicit none

 

end if

end function

{{out}}

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

=={{header|FreeBASIC}}==

{{trans|PureBasic}}

' FreeBASIC v1.05.0 win64

 

Sleep

End

 

{{out}}

 

=={{header|Frink}}==

bits = countToDict[integerDigits[x,2]].get[1,0]

return bits > 1 and isPrime[bits]

 

println["First 25: " + first[select[count[1], isPernicious], 25]]

{{out}}

<pre>

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println()

{{out}}

<pre>

 

=={{header|Groovy}}==

class example{

static void main(String[] args){

}

}

{{out}}

<pre>

 

=={{header|Haskell}}==

where

 

solution1 = take 25 $ filter isPernicious [1 ..]

{{output}}

<pre>[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]

Or, in a point-free and applicative style, using unfoldr for the population count:

 

import Data.List (unfoldr)

import Data.Tuple (swap)

[ take 25 $ filter isPernicious [1 ..]

, filter isPernicious [888888877 .. 888888888]

{{Out}}

<pre>[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]

 

Works in both languages:

 

procedure main(A)

while n > 0 do c +:= 1(n%2, n/:=2)

return c

 

{{Out}}

Implementation:

 

 

Task (thru taken from the [[Loops/Downward_for#J|Loops/Downward for]] task).:

 

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

 

thru=: <. + i.@(+*)@-~

(#~ ispernicious) 888888877 thru 888888888

 

=={{header|Java}}==

//very simple isPrime since x will be <= Long.SIZE

public static boolean isPrime(int x){

}

}

{{out}}

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

{{works with|jq|1.4}}

The most interesting detail in the following is perhaps the use of ''recurse/1'' to define the helper function ''bin'', which generates the binary bits.

def is_prime:

if . == 2 then true

;

 

{{Out}}

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

{{works with|Julia|0.6}}

 

 

ispernicious(n::Integer) = isprime(count_ones(n))

 

println("First 25 pernicious numbers: ", join(perniciouses(25), ", "))

 

{{out}}

 

=={{header|Kotlin}}==

 

fun isPrime(n: Int): Boolean {

if (isPernicious(i)) print("$i ")

}

 

{{out}}

 

=={{header|Ksh}}==

#!/bin/ksh

 

done

echo

{{out}}<pre>

First 25 Pernicious numbers:

 

=={{header|Lua}}==

function isPrime (x)

if x < 2 then return false end

-- Main procedure

pernicious(25)

{{out}}

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

 

=={{header|Maple}}==

return evalb(isprime(rhs(Statistics:-Tally(StringTools:-Explode(convert(convert(n, binary), string)))[-1])));

end proc;

end do;

return list_num;

{{out}}

<pre>[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]

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

perniciousQ[n_Integer] := popcount[n] // PrimeQ

perniciouscount = 0;

, {i, 888888877, 888888888}]

Print["Pernicious numbers between 888,888,877 and 888,888,888 (inclusive)"]

{{out}}

<pre>first 25 pernicious numbers

===Alternate Code===

test function

First 25 pernicious numbers

Pernicious numbers betweeen 888888877 and 888888888 inclusive

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|Nim}}==

{{trans|Python}}

 

proc count(s: string; sub: char): int =

inc i

 

{{Out}}

<pre>@[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]

 

=={{header|Panda}}==

a where count{{a.factor}}==2

fun pernisc(a) type integer->integer

 

1..36.pernisc

 

{{out}}

 

=={{header|PARI/GP}}==

select(pern, [1..36])

{{out}}

<pre>%1 = [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]

 

Added easy counting of pernicious numbers for full Bit ranges like 32-Bit

{$IFDEF FPC}

{$OPTIMIZATION ON,Regvar,ASMCSE,CSE,PEEPHOLE}// 3x speed up

inc(k,k);

until k>64;

{{out}}

<pre>

=={{header|Perl}}==

{{trans|C}}

my $n = shift;

my $c = 2693408940; # primes < 32 as set bits

}

 

{{out}}

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

Alternately, generating the same output using a method similar to Pari/GP:

{{libheader|ntheory}}

my $i = 1;

my @pern = map { $i++ while !is_prime(hammingweight($i)); $i++; } 1..25;

print "@pern\n";

 

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">pernicious</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">pp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|Picat}}==

println(take_n(pernicious_number,25,1)),

pop_count(N) = sum([1: I in N.to_binary_string(), I = '1']).

 

 

{{out}}

=={{header|PicoLisp}}==

Using 'prime?' from [[Primality by trial division#PicoLisp]].

Test:

(do 25

(until (pernicious? (inc 'N)))

 

: (filter pernicious? (range 888888877 888888888))

 

=={{header|PL/I}}==

pern: procedure options (main);

declare (i, n) fixed binary (31);

 

end pern;

Results:

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

 

=={{header|Plain English}}==

Find a population count of the number.

If the population count is prime, say yes.

If the number is past the other number, exit.

If the number is pernicious, show the number.

{{out}}

<pre>

 

=={{header|PowerShell}}==

function pop-count($n) {

(([Convert]::ToString($n, 2)).toCharArray() | where {$_ -eq '1'}).count

"pernicious numbers between 888,888,877 and 888,888,888"

"$(888888877..888888888 | where{isprime(pop-count $_)})"

<b>Output:</b>

<pre>

 

The '''PopCount''' property is available in each of the returned integers.

function Select-PerniciousNumber

{

}

}

$start, $end = 0, 999999

$range1 = $start..$end | Select-PerniciousNumber | Select-Object -First 25

 

"Pernicious numbers between {0} and {1}:`n{2}`n" -f $start, $end, ($range2 -join ", ")

{{Out}}

<pre>

 

=={{header|PureBasic}}==

EnableExplicit

 

CloseConsole()

EndIf

 

{{out}}

=={{header|Python}}==

===Procedural===

 

>>> primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61}

>>> p

[888888877, 888888878, 888888880, 888888883, 888888885, 888888886]

 

===Functional===

{{Works with|Python|3.7}}

 

from itertools import count, islice

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>[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]

=={{header|Quackery}}==

 

$ "rosetta/popcount.qky" loadfile ] now!

 

25 echopopwith isprime cr

 

{{out}}

=={{header|Racket}}==

 

(require math/number-theory rnrs/arithmetic/bitwise-6)

 

(module+ test

(require rackunit)

 

{{out}}

 

Straightforward implementation using Raku's ''is-prime'' built-in subroutine.

is-prime [+] $n.base(2).comb;

}

 

say (grep &is-pernicious, 0 .. *)[^25];

{{out}}

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

╚════════════════════════════════════════════════════════════════════════════════════════╝

</pre>

numeric digits 100 /*be able to handle large numbers. */

parse arg N L H . /*obtain optional arguments from the CL*/

return substr($, 2) /*return the results, sans 1st blank. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output''' &nbsp; when the default inputs are used:

<pre>

=={{header|Ring}}==

Programming note: &nbsp; as written, this program can't handle the large numbers required for the 2^nd task requirement &nbsp; (it receives a '''Numeric Overflow''').

# Project : Pernicious numbers

 

next

return 1

Output:

<pre>

 

=={{header|Ruby}}==

 

class Integer

 

p 1.step.lazy.select(&:pernicious?).take(25).to_a

{{out}}

<pre>

 

=={{header|Rust}}==

extern crate aks_test_for_primes;

 

is_prime(n.count_ones())

}

{{out}}

<pre>

 

=={{header|S-lang}}==

define is_prime(n)

{

}

print(strjoin(list_to_array(plist), " "));

{{out}}

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

 

=={{header|Scala}}==

 

// Generate the output

println( Stream.from(2).filter( isPernicious(_) ).take(a).toList.mkString(",") )

println( {for( i <- b1 to b2 if( isPernicious(i) ) ) yield i}.mkString(",") )

{{out}}

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

is used to compute the population count of the bitset.

 

 

const set of integer: primes is {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61};

end for;

writeln;

 

{{out}}

 

=={{header|Sidef}}==

n.sumdigits(2).is_prime

}

 

say is_pernicious.first(25).join(' ')

 

{{out}}

=={{header|Swift}}==

 

 

extension BinaryInteger {

 

print("First 25 Pernicious numbers: \(Array(first25))")

 

{{out}}

=={{header|Symsyn}}==

 

 

primes : 0b0010100000100000100010100010000010100000100010100010100010101100

return

 

 

{{out}}

=={{header|Tcl}}==

{{tcllib|math::numtheory}}

 

proc pernicious {n} {

if {[pernicious $n]} {lappend p $n}

}

{{out}}

<pre>

 

=={{header|VBA}}==

Dim result As Integer

Dim digit As Integer

End If

Next n

<pre> 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 888888878 888888880 888888883 888888885 888888886 </pre>

 

=={{header|VBScript}}==

Function IsPernicious(n)

IsPernicious = False

End If

Next

 

{{out}}

=={{header|Visual Basic .NET}}==

{{trans|C#}}

 

Function PopulationCount(n As Long) As Integer

End Sub

 

{{out}}

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

=={{header|Wortel}}==

The following function returns true if it's argument is a pernicious number:

Task:

 

=={{header|Wren}}==

{{trans|Go}}

var ff = 2.pow(32) - 1

var mask1 = (ff / 3).floor

if (pernicious.call(n)) System.write("%(n) ")

}

 

{{out}}

=={{header|zkl}}==

The largest number of bits is 30.

N:=0; foreach n in ([2..]){

if(n.num1s : primes.holds(_)){

foreach n in ([0d888888877..888888888]){

if (n.num1s : primes.holds(_)) "%,d; ".fmt(n).print();

Int.num1s returns the number of 1 bits. eg (3).num1s-->2

{{out}}

</pre>

Or in a more functional style:

p:='wrap(n){ primes.holds(n.num1s) };

 

[1..].filter(25,p).toString(*).println();

'wrap is syntactic sugar for a closure - it creates a function that

wraps local data (variable primes in this case). We assign that function to p.