Population count: Difference between revisions

{{trans|Python}}

 

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

 

 

print(evil[0.<30])

 

{{out}}

* in Unnormalized Double Floating Point, one is implemented X'4E00000000000001'

<br>

POPCNT CSECT

USING POPCNT,R13 base register

CC DS C

REGEQU

{{out}}

<pre>

It will only run correctly on a real 8080.

 

mvi e,30 ; 3^0 to 3^29 inclusive

powers: push d ; Keep counter

nl: db 13,10,'$'

pow3: db 1,0,0,0,0,0 ; pow3, starts at 1

 

{{out}}

=={{header|8086 Assembly}}==

 

bits 16

org 100h

mov dl,' '

int 21h

 

{{out}}

Specification and implementation of an auxiliary package "Population_Count". The same package is used for [[Pernicious numbers#Ada]]

 

 

package Population_Count is

subtype Num is Interfaces.Unsigned_64;

function Pop_Count(N: Num) return Natural;

 

function Pop_Count(N: Num) return Natural is

end Pop_Count;

 

The main program:

 

 

procedure Test_Pop_Count is

end loop;

New_Line;

 

{{out}}

 

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

# integer n #

PROC population count = ( LONG INT n )INT:

OD;

print( ( newline ) )

{{out}}

<pre>

 

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

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

integer procedure populationCount( integer value n ) ;

end odious_numbers_loop

end

{{out}}

<pre>

 

=={{header|APL}}==

APL (DYALOG APL)

popDemo←{⎕IO←0

'***Passes' '***Fails'⊃⍨(ans3≢act3)∨(actEvil≢ansEvil)∨(actOdious≢ansOdious)

}

{{out}}

popDemo 30

 

{{Trans|JavaScript}}

 

-- populationCount :: Int -> Int

set my text item delimiters to dlm

s

{{Out}}

<pre>Population counts of the first 30 powers of three:

===Straightforward===

 

set counter to 0

repeat until (n is 0)

as text

set AppleScript's text item delimiters to astid

 

{{output}}

1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

1st thirty evil numbers:

0 3 5 6 9 10 12 15 17 18 20 23 24 27 29 30 33 34 36 39 40 43 45 46 48 51 53 54 57 58

1st thirty odious numbers:

 

=={{header|Arturo}}==

size select split to :string as.binary num 'x -> x="1"

]

 

print "first thirty odious numbers"

 

{{out}}

 

=={{header|AutoHotkey}}==

Out1 .= PopCount(3 ** (A_Index - 1)) " "

Loop, 60

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

return (x * 0x0101010101010101) >> 56

{{Output}}

<pre>3^x: 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

 

=={{header|AWK}}==

# syntax: GAWK -f POPULATION_COUNT.AWK

# converted from VBSCRIPT

return(y)

}

{{out}}

<pre>

=={{header|BASIC256}}==

{{trans|Yabasic}}

for i = 0 to 29

print population(3^i); " "; #los últimos números no los muestra correctamente

next i

return popul

{{out}}

<pre>Same as Yabasic entry.</pre>

 

=={{header|BCPL}}==

 

// Definitions

printFirst(30, evil)

printFirst(30, odious)

{{out}}

<pre> 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

1 2 4 7 8 11 13 14 16 19 21 22 25 26 28 31 32 35 37 38 41 42 44 47 49 50 52 55 56 59</pre>

=={{header|BQN}}==

Odious ← 2|PopCount

Evil ← ¬Odious

>⟨PopCount¨ 3⋆↕30,

Evil _List 30,

{{out}}

<pre>┌─

=={{header|C}}==

{{works with|GCC}}

 

int main() {

 

return 0;

{{out}}

<pre>

 

GCC's builtin doesn't exist prior to 3.4, and the LL version is broken in 3.4 to 4.1. In 4.2+, if the platform doesn't have a good popcount instruction or isn't enabled (e.g. not compiled with <code>-march=native</code>), it typically emits unoptimized code which is over 2x slower than the C below. Alternative:

#define HAVE_BUILTIN_POPCOUNTLL

#endif

b = (b + (b >> 4)) & 0x0f0f0f0f;

return (b * 0x01010101) >> 24;

 

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

using System;

using System.Linq;

}

}

{{out}}

<pre>

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

{{works with|C++11}}

#include <bitset>

#include <climits>

 

return 0;

{{out}}

<pre>

 

=={{header|Clojure}}==

(defn population-count [n]

(Long/bitCount n)) ; use Java inter-op

 

(defn odious-numbers []

 

{{out}}

 

=={{header|CLU}}==

p: int := 0

while n>0 do

end

stream$putl(po, "")

{{out}}

<pre> 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

 

=={{header|COBOL}}==

PROGRAM-ID. HAMMING.

 

DIVIDE 2 INTO POPCOUNT-IN.

IF BIT-IS-SET, ADD 1 TO POPCOUNT-OUT.

{{out}}

<pre> 3^ EVIL ODD

 

=={{header|Common Lisp}}==

(loop for i below 30

collect (logcount (expt 3 i))))

finally (return (values evil odious)))

(format T "evil: ~{~a ~}~%" evil)

{{Out}}

<pre>3^x: 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

{{trans|Ruby}}

For Crystal select|reject are inherently lazy enumerators, and has popcount for upto unsigned 64-bit integers.

def evil?

self >= 0 && popcount.even?

puts "Powers of 3:", (0...30).map{|n| (3u64 ** n).popcount}.join(' ') # can also use &** (to prevent arithmetic overflow)

puts "Evil:" , 0.step.select(&.evil?).first(30).join(' ')

{{Out}}<pre>Powers of 3:

1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

 

=={{header|D}}==

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

 

uint.max.iota.filter!(i => pCount(i) % 2 == 0).take(30),

uint.max.iota.filter!(i => pCount(i) % 2).take(30));

{{out}}

<pre>[1, 2, 2, 4, 3, 6, 6, 5, 6, 8, 9, 13, 10, 11, 14, 15, 11, 14, 14, 17, 17, 20, 19, 22, 16, 18, 24, 30, 25, 25]

{{libheader| System.SysUtils, Math}}

{{Trans|C#}}

program Population_count;

 

end.

 

 

=={{header|Elixir}}==

 

def count(n), do: count(<<n :: integer>>, 0)

IO.inspect Stream.iterate(0, &(&1+1)) |> Stream.filter(&Population.evil?(&1)) |> Enum.take(30)

IO.puts "first thirty odious numbers:"

 

{{out}}

 

=={{header|Erlang}}==

-export([popcount/1]).

 

io:format("Powers of 3: ~p~n",[threes(30)]),

io:format("Evil:~p~n",[evil(30)]),

{{out}}

Powers of 3: [1,2,2,4,3,6,6,5,6,8,9,13,10,11,14,15,11,14,14,17,17,20,19,22,16,18,24,30,25,

25]

Odious:[1,2,4,7,8,11,13,14,16,19,21,22,25,26,28,31,32,35,37,38,41,42,44,47,49,

50,52,55,56,59]

 

=={{header|F_Sharp|F#}}==

// Population count. Nigel Galloway: February 18th., 2021

let pC n=Seq.unfold(fun n->match n/2L,n%2L with (0L,0L)->None |(n,g)->Some(g,n))n|>Seq.sum

printf "evil :"; Seq.initInfinite(int64)|>Seq.filter(fun n->(pC n) &&& 1L=0L)|>Seq.take 30|>Seq.iter(printf "%3d"); printfn ""

printf "odious:"; Seq.initInfinite(int64)|>Seq.filter(fun n->(pC n) &&& 1L=1L)|>Seq.take 30|>Seq.iter(printf "%3d"); printfn ""

{{out}}

<pre>

</pre>

=={{header|Factor}}==

math.functions namespaces prettyprint.config sequences ;

 

100 margin set 0 lfrom [ 3^n ] [ evil ] [ odious ] tri

[ 30 swap ltake list>array ] tri@

{{out}}

<pre>

 

=={{header|Fermat}}==

Func Odiousness(n) = p:=Popcount(n);if 2*(p\2) = p then 0 else 1 fi.

 

e:=0

n:=0

 

=={{header|Forth}}==

{{works with|Gforth|0.7.3}}

BEGIN dup WHILE tuck 1 AND + swap 1 rshift REPEAT

DROP ;

over odious? IF over . 1+ THEN swap 1+ swap

REPEAT DROP DROP CR ;

{{out}}

<pre>3**i popcnt: 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

=={{header|Fortran}}==

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

implicit none

 

 

end function

{{out}}

<pre> 3**i : 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

It accepts one integer parameter and is defined for all unsigned integer types.

Therefore its implementation is skipped.

var

// general advice: iterator variables are _signed_

end;

writeLn();

{{out}}

<pre> 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

 

=={{Header|FreeBASIC}}==

#define NTERMS 30

 

print s_tp

print s_evil

{{out}}

<pre>

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=538335b7b71f5ea7b59c0c82fbb0ea3e Click this link to run this code]'''

Dim sEvil, sOdious As String 'To store the output for printing Evil and Odious

Dim iCount, iEvil, iOdious As Integer 'Counters

Print "1st 30 Odious numbers =\t" & sOdious 'Print Odious

 

Output:

<pre>

===Standard Library===

As of Go 1.9, this function is in the standard Library.

 

import (

}

fmt.Println()

{{out}}

<pre>

===Implementation===

Method of WP example '''popcount_3''':

const (

ff = 1<<64 - 1

w = (w + w>>4) & maskf

return int(w * maskp >> 56)

Method of WP example '''popcount_4''':

for w != 0 {

w &= w - 1

}

return

 

=={{header|Haskell}}==

{{works with|GHC|7.4+}}

 

printPops :: (Show a, Integral a) => String -> [a] -> IO ()

printPops "popcount " $ map popCount $ iterate (*3) (1 :: Integer)

printPops "evil " $ filter (even . popCount) ([0..] :: [Integer])

{{out}}

<pre>

Or, if we want to write our own popCount, perhaps something like:

 

import Data.List (partition, unfoldr)

import Data.Tuple (swap)

( (popCount . (3 ^) <$> [0 .. 29]) :

biList (partition (even . popCount) [0 .. 59])

{{Out}}

<pre>Population count of powers of 3:

=={{header|Idris}}==

 

import Data.Vect

 

printCompact (filterUnfoldN 30 isEvil id (1 +) 0)

putStr "Odious: "

{{Out}}

<pre>popcnt(3**i): 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

Implementation:

 

isOdd=: 1 = 2&|

 

 

Task:

 

1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

30{.(#~ isOdd@countPopln) i. 100 NB. odd population count (aka "ODious numbers")

1 2 4 7 8 11 13 14 16 19 21 22 25 26 28 31 32 35 37 38 41 42 44 47 49 50 52 55 56 59

30{.(#~ isEven@countPopln) i. 100 NB. even population count (aka "EVil numbers")

 

=={{header|Java}}==

 

public class PopCount {

System.out.println();

}

{{out}}

<pre>

 

===ES6===

'use strict';

 

// ---

return main();

{{Out}}

<pre>Population counts of the first 30 powers of three:

=={{header|jq}}==

{{works with|jq|1.4}}

def bin: recurse( if . == 0 then empty else ./2 | floor end ) % 2;

[bin] | add;

;

 

{{Out}}

$ jq -n -r -c -f Population_count.jq

 

=={{header|Julia}}==

println("Evil numbers: ", join(filter(x -> iseven(count_ones(x)), 0:59), ", "))

 

{{out}}

 

=={{header|Kotlin}}==

 

fun popCount(n: Long) = when {

}

println()

 

{{out}}

 

=={{header|Lua}}==

function dec2bin (n)

local bin, bit = ""

firstThirty("3^x")

firstThirty("Evil")

{{out}}

<pre>3^x: 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

=={{header|MAD}}==

 

INTERNAL FUNCTION LOWBIT.(K) = K-K/2*2

VECTOR VALUES NUMFMT = $I2*$

 

{{out}}

 

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

Print["population count of powers of 3"]

popcount[#] & /@ (3^Range[0, 30])

]

Print["first thirty odious numbers"]

{{out}}

<pre>population count of powers of 3

=={{header|min}}==

{{works with|min|0.19.3}}

 

(

"3^n: " print! 30 iota (3 swap pow int pop-count) map puts!

60 iota (pop-count odd?) partition

{{out}}

<pre>

 

=={{header|Nim}}==

import strformat

 

for i in 0..<30:

write(stdout, fmt"{od[i]:2} ")

 

{{out}}

 

Another version, in functional style, with most computations done at compile time:

 

const

echo "3^n: ", popcounts.mapIt(($it).align(2)).join(" ")

echo "evil: ", evil.mapIt(($it).align(2)).join(" ")

 

{{out}}

 

=={{header|Oforth}}==

0 while ( n ) [ n isOdd + n bitRight(1) ->n ] ;

 

 

0 ->count

 

{{out}}

 

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

od=select(n->hammingweight(n)%2,[0..100]); ev=setminus([0..100],od);

ev[1..30]

{{out}}

<pre>%1 = [1, 2, 2, 4, 3, 6, 6, 5, 6, 8, 9, 13, 10, 11, 14, 15, 11, 14, 14, 17, 17, 20, 19, 22, 16, 18, 24, 30, 25, 25]

{{works with|freepascal}}

Like Ada a unit is used.

{$IFDEF FPC}

{$MODE DELPHI}

 

Begin

The program

uses

sysutils,popCount;

until k = 30;

writeln(s);

;Output:

<pre>PopCnt 3^i :1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

 

Some processors define the <code>card</code> function, which can be used in conjunction with sets:

i: integer;

f: set of 0..(bitSizeOf(i)-1) absolute i; // same address as i, but different interpretation

begin

writeLn(card(f));

 

=={{header|Perl}}==

We'll emulate infinite lists with closures.

 

use warnings;

use feature 'say';

 

say "Evil @evil";

{{out}}

<pre>1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

 

A faster population count can be done with pack/unpack:

 

Various modules can also perform a population count, with the first of these being faster than the pack/unpack builtins. The first three easily support bigints, the last will with some adjustment.

say hammingweight(1234567);

 

 

use Bit::Vector;

 

=={{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;">pop_count</span><span style="color: #0000FF;">(</span><span style="color: #004080;">atom</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">eo</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" evil"</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">eo</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"odious"</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

 

=={{header|PHP}}==

function convertToBinary($integer) {

$binary = "";

echo "\nfirst 30 odious numbers:";

printFirst30Odious();

{{out}}

<pre>

 

=={{header|Picat}}==

println(powers_of_three=[pop_count(3**I) : I in 0..29]),

println('evil_numbers '=take_n($evil_number, 30,0)),

odious_number(N) => pop_count(N) mod 2 == 1.

 

 

{{out}}

 

=={{header|PicoLisp}}==

(cnt

'((N) (= "1" N))

(when (bit? 1 (popz (inc 'N)))

(link N)

{{out}}

<pre>

 

=={{header|PowerShell}}==

function pop-count($n) {

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

"even pop_count: $($m = $n = 0; while($m -lt 30) {if(0 -eq ((pop-count $n)%2)) {$m += 1; $n}; $n += 1} )"

"odd pop_count: $($m = $n = 0; while($m -lt 30) {if(1 -eq ((pop-count $n)%2)) {$m += 1; $n}; $n += 1} )"

<b>Output:</b>

<pre>

 

=={{header|PureBasic}}==

Procedure PutR(v.i) : Print(RSet(Str(v),3)) : EndProcedure

 

Print("Evil numbers ") : ForEach ne() : PutR(ne()) : Next : PrintN("")

Print("Odious numb..") : ForEach no() : PutR(no()) : Next : Input()

{{out}}

<pre>

=={{header|Python}}==

===Procedural===

...

>>> [popcount(3**i) for i in range(30)]

>>> odious[:30]

[1, 2, 4, 7, 8, 11, 13, 14, 16, 19, 21, 22, 25, 26, 28, 31, 32, 35, 37, 38, 41, 42, 44, 47, 49, 50, 52, 55, 56, 59]

 

===Python: Kernighans' algorithm===

The algorithm is explained [https://www.techiedelight.com/brian-kernighans-algorithm-count-set-bits-integer/ here]. Replace popcount with pop_kernighan in the example above to get the same evil and odious results.

 

i = 0

while n:

i, n = i + 1, n & (n - 1)

return i

 

===Composition of pure functions===

{{Works with|Python|3}}

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>Population count of first 30 powers of 3:

=={{header|Quackery}}==

 

[ dup while

dup 1 &

cr

say "The first thirty odious numbers." cr

 

{{out}}

=={{header|R}}==

By default, R does not support 64-bit integer types. We therefore need the bit64 library and an awkward popCount function in order to make this work. Aside from the ugly one-liner that is the popCount function, the rest is trivial.

popCount <- function(x) sum(as.numeric(strsplit(as.bitstring(as.integer64(x)), "")[[1]]))

finder <- function()

cat("The first 30 odious numbers are:", odious)

}

{{out}}

<pre>The pop count of the 1st 30 powers of 3 are: 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

 

=={{header|Racket}}==

;; Positive version from "popcount_4" in:

;; https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation

(check-true (odious? 1) "the least odious number")

(check-true (odious? #b1011011011) "seven (which is odd) bits")

{{out}}

<pre>

=={{header|Raku}}==

(formerly Perl 6)

 

say map &population-count, 3 «**« ^30;

say "Evil: ", (grep { population-count($_) %% 2 }, 0 .. *)[^30];

{{out}}

<pre>1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

Odious: 1 2 4 7 8 11 13 14 16 19 21 22 25 26 28 31 32 35 37 38 41 42 44 47 49 50 52 55 56 59</pre>

That's the convenient way to write it, but the following avoids string processing and is therefore about twice as fast:

loop (my $c = 0; $n; $n +>= 1) {

$c += $n +& 1;

}

$c;

 

=={{header|REXX}}==

The &nbsp; ''pop count'' &nbsp; is used in some encryption/decryption methods; &nbsp; a major mainframe manufacturer was coerced &nbsp; <br>(many years ago) &nbsp; to add a hardware instruction to count the bits in a (binary) integer.

/*─────────────────── and also generates a specific number of EVIL and ODIOUS numbers.*/

parse arg N B . /*get optional arguments from the C.L. */

d2b: return word( strip( x2b( d2x( arg(1) ) ), 'L', 0) 0, 1) /*dec ──► bin.*/

popCount: return length( space( translate( d2b(arg(1) ), , 0), 0) ) /*count ones. */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ring}}==

 

odds = []

func showOne(title, ary)

? title

{{out}}

<pre>3^x:

=={{header|Ruby}}==

Demonstrating lazy enumerators.

def popcount

puts "Powers of 3:", (0...30).map{|n| (3**n).popcount}.join(' ')

puts "Evil:" , 0.step.lazy.select(&:evil?).first(30).join(' ')

{{Output}}<pre>

Powers of 3:

 

=={{header|Rust}}==

let mut num = 1u64;

let mut vec = Vec::new();

println!("\nFirst 30 even pop count:\n{:?}",even);

println!("\nFirst 30 odd pop count:\n{:?}",odd);

{{out}}

<pre>pop count of 3^0, 3^1 ... 3^29:

{{libheader|Scastie qualified}}

{{works with|Scala|2.13}}

 

object PopCount extends App {

println(series(0L).filter(bitCount(_) % 2 != 0).take(nNumber).mkString(", "))

 

 

=={{header|Seed7}}==

is used to compute the population count of the bitset.

 

const func integer: popcount (in integer: n) is

end for;

writeln;

{{out}}

<pre>1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

 

=={{header|Sidef}}==

say "#{0..29 «**« 3 «call« population_count -> join(' ')}"

 

 

say "Evil: #{numbers.grep{_[1] %% 2}.map{.first}.join(' ')}"

{{out}}

<pre>

 

=={{header|Swift}}==

guard n >= 0 else { fatalError() }

 

print("Powers:", Array(pows))

print("Evils:", Array(evils))

 

{{out}}

 

=={{header|Symsyn}}==

 

| Pop Count 3^i

endif

"' Odious Numbers : ' $o " []

 

{{out}}

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

 

proc hammingWeight {n} {

}

puts "evil: [lrange $e 0 29]"

{{out}}

<pre>

=={{header|UNIX Shell}}==

{{works with|bash}}

local -i n=$1

(( n < 0 )) && return 1

done

echo "evil nums: ${evil[*]:0:30}"

{{output}}

<pre>powers of 3 popcounts: 1 2 2 4 3 6 6 5 6 8 9 13 10 11 14 15 11 14 14 17 17 20 19 22 16 18 24 30 25 25

{{works with|VBA|VBA Excel 2013}}

The Decimal subtype of Variant does the job to expand 32-bit integers (Long) to 28-digit integers (Decimal).

nmax = 30

b = 3

Wend

popcount = y

{{out}}

<pre>

Use of the variant currency subtype. Currency mode is a gray area where some operators do not work,

for instance: ^ \ Mod

nmax=30

b=3

Wend

popcount=y

{{out}}

<pre>

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

{{trans|C#}}

 

Module Module1

End Function

 

{{out}}

Added a "Pattern" line. The "Pattern" line shows the sequence pattern of integers for the Evil and Odious output. The pattern goes to about 50, whereas only the first 30 Evil and Odious integers are shown.

{{libheader|Wren-fmt}}

The first part is slightly awkward for Wren as 'native' bit-wise operations are limited to unsigned 32-bit integers and 3^21 exceeds this limit. We therefore need to switch to BigInts just before that point to process the remaining powers.

import "/fmt" for Fmt

 

odious.add(n)

System.print("\n\nThe first 30 odious numbers are:")

 

{{out}}

 

=={{header|Yabasic}}==

 

for i = 0 to 29

next

return popul

 

=={{header|zkl}}==

Ints have the 1s count as a property.

println("evil: ",[0..].filter(30,fcn(n){ n.num1s.isEven }).concat(","));

// now, as an iterator aka lazy:

println("odious: ",(0).walker(*).tweak( // 0,1,2,3,4... iterator

{{out}}

<pre>