Population count: Difference between revisions
m
typo
No edit summary |
Not a robot (talk | contribs) m (typo) |
||
(40 intermediate revisions by 22 users not shown) | |||
Line 31:
;See also
* The On-Line Encyclopedia of Integer Sequences: [[oeis:A000120|A000120 population count]].
* The On-Line Encyclopedia of Integer Sequences: [[oeis:A000069|A000069 odious numbers]].
* The On-Line Encyclopedia of Integer Sequences: [[oeis:A001969|A001969 evil numbers]].
Line 38 ⟶ 39:
{{trans|Python}}
<
[Int] evil, odious
V i = 0
L evil.len < 30 | odious.len < 30
V p = bits:popcount(i)
I (p % 2) != 0
odious.append(i)
Line 54 ⟶ 52:
print(evil[0.<30])
print(odious[0.<30])</
{{out}}
Line 69 ⟶ 67:
* in Unnormalized Double Floating Point, one is implemented X'4E00000000000001'
<br>
<
POPCNT CSECT
USING POPCNT,R13 base register
Line 150 ⟶ 148:
CC DS C
REGEQU
END POPCNT </
{{out}}
<pre>
Line 164 ⟶ 162:
It will only run correctly on a real 8080.
<
mvi e,30 ; 3^0 to 3^29 inclusive
powers: push d ; Keep counter
Line 261 ⟶ 259:
nl: db 13,10,'$'
pow3: db 1,0,0,0,0,0 ; pow3, starts at 1
pow3c: equ $ ; room for copy</
{{out}}
Line 271 ⟶ 269:
=={{header|8086 Assembly}}==
<
bits 16
org 100h
Line 360 ⟶ 358:
mov dl,' '
int 21h
ret</
{{out}}
Line 367 ⟶ 365:
00 03 05 06 09 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
01 02 04 07 08 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|ABC}}==
<syntaxhighlight lang="abc">HOW TO RETURN popcount n:
IF n=0: RETURN 0
RETURN (n mod 2) + popcount (floor (n/2))
HOW TO REPORT evil n:
REPORT (popcount n) mod 2 = 0
HOW TO REPORT odious n:
REPORT (popcount n) mod 2 = 1
FOR i IN {0..29}: WRITE popcount (3 ** i)
WRITE /
PUT {} IN evilnums
PUT {} IN odiousnums
FOR n IN {0..59}:
SELECT:
evil n: INSERT n IN evilnums
odious n: INSERT n IN odiousnums
FOR i IN {1..30}: WRITE evilnums item i
WRITE /
FOR i IN {1..30}: WRITE odiousnums item i
WRITE /</syntaxhighlight>
{{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
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
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|Ada}}==
Line 372 ⟶ 401:
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;
end Population_Count;</
<
function Pop_Count(N: Num) return Natural is
Line 396 ⟶ 425:
end Pop_Count;
end Population_Count;</
The main program:
<
procedure Test_Pop_Count is
Line 436 ⟶ 465:
end loop;
New_Line;
end Test_Pop_Count;</
{{out}}
Line 445 ⟶ 474:
=={{header|ALGOL 68}}==
<
# integer n #
PROC population count = ( LONG INT n )INT:
Line 486 ⟶ 515:
OD;
print( ( newline ) )
</syntaxhighlight>
{{out}}
<pre>
Line 495 ⟶ 524:
=={{header|ALGOL W}}==
<
% returns the population count (number of bits on) of the non-negative integer n %
integer procedure populationCount( integer value n ) ;
Line 563 ⟶ 592:
end odious_numbers_loop
end
end.</
{{out}}
<pre>
Line 572 ⟶ 601:
=={{header|APL}}==
<syntaxhighlight lang="apl">
APL (DYALOG APL)
popDemo←{⎕IO←0
Line 600 ⟶ 629:
'***Passes' '***Fails'⊃⍨(ans3≢act3)∨(actEvil≢ansEvil)∨(actOdious≢ansOdious)
}
</syntaxhighlight>
{{out}}
popDemo 30
Line 612 ⟶ 641:
{{Trans|JavaScript}}
<
-- populationCount :: Int -> Int
Line 834 ⟶ 863:
set my text item delimiters to dlm
s
end unlines</
{{Out}}
<pre>Population counts of the first 30 powers of three:
Line 848 ⟶ 877:
===Straightforward===
<
set counter to 0
repeat until (n is 0)
Line 880 ⟶ 909:
as text
set AppleScript's text item delimiters to astid
return output</
{{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:
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|Arturo}}==
<
size select split to :string as.binary num 'x -> x="1"
]
Line 902 ⟶ 931:
print "first thirty odious numbers"
print take select 0..100 => [odd? popCount &] 30</
{{out}}
Line 914 ⟶ 943:
=={{header|AutoHotkey}}==
<
Out1 .= PopCount(3 ** (A_Index - 1)) " "
Loop, 60
Line 926 ⟶ 955:
, 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
Line 933 ⟶ 962:
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f POPULATION_COUNT.AWK
# converted from VBSCRIPT
Line 970 ⟶ 999:
return(y)
}
</syntaxhighlight>
{{out}}
<pre>
Line 977 ⟶ 1,006:
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>
=={{header|BASIC}}==
==={{header|BASIC256}}===
{{trans|Yabasic}}
<syntaxhighlight lang="basic256">print "Pop cont (3^x): ";
for i = 0 to 29
print population(3^i); " "; #los últimos números no los muestra correctamente
next i
print : print
print "Evil numbers: ";
call EvilOdious(30, 0)
print : print
print "Odious numbers: ";
call EvilOdious(30, 1)
end
subroutine EvilOdious(limit, type)
i = 0 : cont = 0
do
eo = (population(i) mod 2)
if (type and eo) or (not type and not eo) then
cont += 1 : print i; " ";
end if
i += 1
until (cont = limit)
end subroutine
function population(number)
popul = 0
binary$ = tobinary(number)
for i = 1 to length(binary$)
popul += int(mid(binary$, i, 1))
next i
return popul
end function</syntaxhighlight>
==={{header|Run BASIC}}===
<syntaxhighlight lang="vb">function tobin$(num)
bin$ = ""
if num = 0 then bin$ = "0"
while num >= 1
num = num / 2
X$ = str$(num)
D$ = "": F$ = ""
for i = 1 to len(X$)
L$ = mid$(X$, i, 1)
if L$ <> "." then
D$ = D$ + L$
else
F$ = F$ + right$(X$, len(X$) - i)
exit for
end if
next i
if F$ = "" then B$ = "0" else B$ = "1"
bin$ = bin$ + B$
num = val(D$)
wend
B$ = ""
for i = len(bin$) to 1 step -1
B$ = B$ + mid$(bin$, i, 1)
next i
tobin$ = B$
end function
function population(number)
popul = 0
'digito$ = tobin$(number)
'print tobin$(number)
for i = 1 to len(tobin$(number))
popul = popul + val(mid$(tobin$(number), i, 1))
next i
population = popul
end function
sub evilodious limit, tipo
i = 0
cont = 0
while 1
eo = (population(i) mod 2)
if (tipo and eo = 1) or ((not(tipo) and not(eo)) = 1) then
cont = cont + 1: print i; " ";
end if
i = i + 1
if cont = limit then exit while
wend
end sub
print "Pop cont (3^x): ";
for i = 0 to 14
print population(3 ^ i); " ";
next i
print
print "Evil numbers: ";
call evilodious 15, 0
print
print "Odious numbers: ";
call evilodious 15, 1
end</syntaxhighlight>
=={{header|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"
// Definitions
let popcount(n) = n=0 -> 0, (n&1) + popcount(n >> 1)
let evil(n) = (popcount(n) & 1) = 0
let odious(n) = (popcount(n) & 1) = 1
// The BCPL word size is implementation-dependent,
// but very unlikely to be big enough to store 3^29.
// This implements a 48-bit integer using byte strings.
let move48(dest, src) be
for i=0 to 5 do dest%i := src%i
let set48(dest, n) be
for i=5 to 0 by -1
$( dest%i := n & #XFF
n := n >> 8
$)
let add48(dest, src) be
$( let temp = ? and carry = 0
for i=5 to 0 by -1
$( temp := dest%i + src%i + carry
carry := temp > #XFF -> 1, 0
dest%i := temp & #XFF
$)
$)
let mul3(n) be
$( let temp = vec 2 // big enough even on a 16-bit machine
move48(temp, n)
add48(n, n)
add48(n, temp)
$)
let popcount48(n) = valof
$( let total = 0
for i=0 to 5 do
total := total + popcount(n%i)
resultis total
$)
// print the first N numbers
let printFirst(amt, prec) be
$( let seen = 0 and n = 0
until seen >= amt
$( if prec(n)
$( writed(n, 3)
seen := seen + 1
$)
n := n + 1
$)
wrch('*N')
$)
let start() be
$( let pow3 = vec 2
// print 3^0 to 3^29
set48(pow3, 1)
for i = 0 to 29
$( writed(popcount48(pow3), 3)
mul3(pow3)
$)
wrch('*N')
// print the first 30 evil and odious numbers
printFirst(30, evil)
printFirst(30, odious)
$)</syntaxhighlight>
{{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
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
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}}==
<syntaxhighlight lang="bqn">PopCount ← {(2|𝕩)+𝕊⍟×⌊𝕩÷2}
Odious ← 2|PopCount
Evil ← ¬Odious
_List ← {𝕩↑𝔽¨⊸/↕2×𝕩}
>⟨PopCount¨ 3⋆↕30,
Evil _List 30,
Odious _List 30⟩</syntaxhighlight>
{{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
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
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|C}}==
{{works with|GCC}}
<
int main() {
Line 1,018 ⟶ 1,247:
return 0;
}</
{{out}}
<pre>
Line 1,028 ⟶ 1,257:
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
Line 1,043 ⟶ 1,272:
b = (b + (b >> 4)) & 0x0f0f0f0f;
return (b * 0x01010101) >> 24;
}</
=={{header|C sharp|C#}}==
<
using System;
using System.Linq;
Line 1,117 ⟶ 1,346:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 1,128 ⟶ 1,357:
=={{header|C++}}==
{{works with|C++11}}
<
#include <bitset>
#include <climits>
Line 1,169 ⟶ 1,398:
return 0;
}</
{{out}}
<pre>
Line 1,179 ⟶ 1,408:
=={{header|Clojure}}==
<syntaxhighlight lang="clojure">
(defn population-count [n]
(Long/bitCount n)) ; use Java inter-op
Line 1,207 ⟶ 1,436:
(defn odious-numbers []
(filter odious? (integers)))</
{{out}}
Line 1,227 ⟶ 1,456:
; ==> (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|CLU}}==
<syntaxhighlight lang="clu">pop_count = proc (n: int) returns (int)
p: int := 0
while n>0 do
p := p + n//2
n := n/2
end
return(p)
end pop_count
evil = proc (n: int) returns (bool)
return(pop_count(n)//2 = 0)
end evil
odious = proc (n: int) returns (bool)
return(~evil(n))
end odious
first = iter (n: int, p: proctype (int) returns (bool)) yields (int)
i: int := 0
while n>0 do
if p(i) then
yield(i)
n := n-1
end
i := i+1
end
end first
start_up = proc ()
po: stream := stream$primary_output()
for i: int in int$from_to(0,29) do
stream$putright(po, int$unparse(pop_count(3**i)), 3)
end
stream$putl(po, "")
for i: int in first(30, evil) do
stream$putright(po, int$unparse(i), 3)
end
stream$putl(po, "")
for i: int in first(30, odious) do
stream$putright(po, int$unparse(i), 3)
end
stream$putl(po, "")
end start_up</syntaxhighlight>
{{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
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
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|COBOL}}==
<syntaxhighlight lang="cobol"> IDENTIFICATION DIVISION.
PROGRAM-ID. HAMMING.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 POPCOUNT-VARIABLES.
03 POPCOUNT-IN PIC 9(15)V9.
03 FILLER REDEFINES POPCOUNT-IN.
05 POPCOUNT-REST PIC 9(15).
05 FILLER PIC 9.
88 BIT-IS-SET VALUE 5.
03 POPCOUNT-OUT PIC 99.
03 FILLER REDEFINES POPCOUNT-OUT.
05 FILLER PIC 9.
05 FILLER PIC 9.
88 EVIL VALUES 0, 2, 4, 6, 8.
88 ODIOUS VALUES 1, 3, 5, 7, 9.
01 STATE-VARIABLES.
03 CUR-POWER-3 PIC 9(15) VALUE 1.
03 CUR-EVIL-NUM PIC 99 VALUE 0.
03 CUR-ODIOUS-NUM PIC 99 VALUE 0.
03 LINE-INDEX PIC 99 VALUE 1.
01 OUTPUT-FORMAT.
03 LINENO PIC Z9.
03 FILLER PIC X VALUE '.'.
03 FILLER PIC XX VALUE SPACES.
03 OUT-POW3 PIC Z9.
03 FILLER PIC X(4) VALUE SPACES.
03 OUT-EVIL PIC Z9.
03 FILLER PIC X(4) VALUE SPACES.
03 OUT-ODIOUS PIC Z9.
PROCEDURE DIVISION.
BEGIN.
DISPLAY " 3^ EVIL ODD"
PERFORM MAKE-LINE 30 TIMES.
STOP RUN.
MAKE-LINE.
MOVE LINE-INDEX TO LINENO.
MOVE CUR-POWER-3 TO POPCOUNT-IN.
PERFORM FIND-POPCOUNT.
MOVE POPCOUNT-OUT TO OUT-POW3.
PERFORM FIND-EVIL.
MOVE CUR-EVIL-NUM TO OUT-EVIL.
PERFORM FIND-ODIOUS.
MOVE CUR-ODIOUS-NUM TO OUT-ODIOUS.
DISPLAY OUTPUT-FORMAT.
MULTIPLY 3 BY CUR-POWER-3.
ADD 1 TO CUR-EVIL-NUM.
ADD 1 TO CUR-ODIOUS-NUM.
ADD 1 TO LINE-INDEX.
FIND-EVIL.
MOVE CUR-EVIL-NUM TO POPCOUNT-IN.
PERFORM FIND-POPCOUNT.
IF NOT EVIL, ADD 1 TO CUR-EVIL-NUM, GO TO FIND-EVIL.
FIND-ODIOUS.
MOVE CUR-ODIOUS-NUM TO POPCOUNT-IN.
PERFORM FIND-POPCOUNT.
IF NOT ODIOUS, ADD 1 TO CUR-ODIOUS-NUM, GO TO FIND-ODIOUS.
FIND-POPCOUNT.
MOVE 0 TO POPCOUNT-OUT.
PERFORM PROCESS-BIT UNTIL POPCOUNT-IN IS EQUAL TO ZERO.
PROCESS-BIT.
DIVIDE 2 INTO POPCOUNT-IN.
IF BIT-IS-SET, ADD 1 TO POPCOUNT-OUT.
MOVE POPCOUNT-REST TO POPCOUNT-IN.</syntaxhighlight>
{{out}}
<pre> 3^ EVIL ODD
1. 1 0 1
2. 2 3 2
3. 2 5 4
4. 4 6 7
5. 3 9 8
6. 6 10 11
7. 6 12 13
8. 5 15 14
9. 6 17 16
10. 8 18 19
11. 9 20 21
12. 13 23 22
13. 10 24 25
14. 11 27 26
15. 14 29 28
16. 15 30 31
17. 11 33 32
18. 14 34 35
19. 14 36 37
20. 17 39 38
21. 17 40 41
22. 20 43 42
23. 19 45 44
24. 22 46 47
25. 16 48 49
26. 18 51 50
27. 24 53 52
28. 30 54 55
29. 25 57 56
30. 25 58 59</pre>
=={{header|Common Lisp}}==
<
(loop for i below 30
collect (logcount (expt 3 i))))
Line 1,240 ⟶ 1,628:
finally (return (values evil odious)))
(format T "evil: ~{~a ~}~%" evil)
(format T "odious: ~{~a ~}~%" odious))</
{{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
Line 1,249 ⟶ 1,637:
{{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?
Line 1,257 ⟶ 1,645:
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(' ')
puts "Odious:", 0.step.reject(&.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
Line 1,267 ⟶ 1,655:
=={{header|D}}==
<
import std.stdio, std.algorithm, std.range, core.bitop;
Line 1,275 ⟶ 1,663:
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]
Line 1,284 ⟶ 1,672:
{{libheader| System.SysUtils, Math}}
{{Trans|C#}}
<syntaxhighlight lang="delphi">
program Population_count;
Line 1,350 ⟶ 1,738:
end.
</syntaxhighlight>
=={{header|EasyLang}}==
<syntaxhighlight>
func popcnt x .
while x > 0
r += x mod 2
x = x div 2
.
return r
.
proc show3 . .
write "3^n:"
bb = 1
for i = 1 to 30
write " " & popcnt bb
bb *= 3
.
print ""
.
proc show s$ x . .
write s$
while n < 30
if popcnt i mod 2 = x
n += 1
write " " & i
.
i += 1
.
print ""
.
show3
show "evil:" 0
show "odious:" 1
</syntaxhighlight>
=={{header|Elixir}}==
<
def count(n), do: count(<<n :: integer>>, 0)
Line 1,372 ⟶ 1,795:
IO.inspect Stream.iterate(0, &(&1+1)) |> Stream.filter(&Population.evil?(&1)) |> Enum.take(30)
IO.puts "first thirty odious numbers:"
IO.inspect Stream.iterate(0, &(&1+1)) |> Stream.filter(&Population.odious?(&1)) |> Enum.take(30)</
{{out}}
Line 1,385 ⟶ 1,808:
=={{header|Erlang}}==
<
-export([popcount/1]).
Line 1,434 ⟶ 1,857:
io:format("Powers of 3: ~p~n",[threes(30)]),
io:format("Evil:~p~n",[evil(30)]),
io:format("Odious:~p~n",[odious(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]
Line 1,443 ⟶ 1,866:
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]
ok</
=={{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
Line 1,452 ⟶ 1,875:
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 ""
</syntaxhighlight>
{{out}}
<pre>
Line 1,460 ⟶ 1,883:
</pre>
=={{header|Factor}}==
<
math.functions namespaces prettyprint.config sequences ;
Line 1,469 ⟶ 1,892:
100 margin set 0 lfrom [ 3^n ] [ evil ] [ odious ] tri
[ 30 swap ltake list>array ] tri@
"3^n: %u\nEvil: %u\nOdious: %u\n" printf</
{{out}}
<pre>
Line 1,476 ⟶ 1,899:
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>
=={{header|Fermat}}==
<syntaxhighlight lang="fermat">Func Popcount(n) = if n = 0 then 0 else if 2*(n\2)=n then Popcount(n\2) else Popcount((n-1)\2)+1 fi fi.
Func Odiousness(n) = p:=Popcount(n);if 2*(p\2) = p then 0 else 1 fi.
for n=0 to 29 do !Popcount(3^n);!' ' od
e:=0
n:=0
while e<30 do if Odiousness(n)=0 then !n;!' ';e:=e+1 fi; n:=n+1 od
e:=0
n:=0
while e<30 do if Odiousness(n)=1 then !n;!' ';e:=e+1 fi; n:=n+1 od</syntaxhighlight>
=={{header|Forth}}==
{{works with|Gforth|0.7.3}}
<
BEGIN dup WHILE tuck 1 AND + swap 1 rshift REPEAT
DROP ;
Line 1,498 ⟶ 1,933:
over odious? IF over . 1+ THEN swap 1+ swap
REPEAT DROP DROP CR ;
task1 task2 task3 BYE</
{{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
Line 1,506 ⟶ 1,941:
=={{header|Fortran}}==
{{works with|Fortran|95 and later}}
<
implicit none
Line 1,556 ⟶ 1,991:
end function
end program</
{{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
Line 1,566 ⟶ 2,001:
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_
Line 1,627 ⟶ 2,062:
end;
writeLn();
end.</
{{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
Line 1,635 ⟶ 2,070:
=={{header|Fōrmulæ}}==
'''Solution'''
Fōrmulæ has an integrated expression BitCount that counts the number of 1's of the binary representation of the number.
However, a function can also be written, as follows:
[[File:Fōrmulæ - Population count 01.png]]
'''Case 1. Display the pop count of the 1st thirty powers of 3'''
[[File:Fōrmulæ - Population count 02.png]]
[[File:Fōrmulæ - Population count 03.png]]
'''Case 2. Display the 1st thirty evil numbers'''
We need first a function to calculate the first numbers whose population count satisfies a given condition, passed as a lambda expression:
[[File:Fōrmulæ - Population count 04.png]]
[[File:Fōrmulæ - Population count 05.png]]
[[File:Fōrmulæ - Population count 06.png]]
'''Case 3. Display the 1st thirty odious numbers'''
[[File:Fōrmulæ - Population count 07.png]]
[[File:Fōrmulæ - Population count 08.png]]
=={{Header|FreeBASIC}}==
<
#define NTERMS 30
Line 1,679 ⟶ 2,140:
print s_tp
print s_evil
print s_odious</
{{out}}
<pre>
Line 1,686 ⟶ 2,147:
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|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
_limit = 30
local fn Population( x as long ) as long
long q, r, y = 0
while ( x > 0 )
q = int( x / 2 )
r = x - q * 2
if r == 1 then y++
x = q
wend
end fn = y
void local fn EvilOdious
long i = 0, k, ee = 0, eo = 0
long type(_limit - 1), evil(_limit - 1), odious(_limit - 1)
Str255 typeStr, evilStr, odiousStr
while ( ( ee < _limit ) or ( eo < _limit ) )
if i < _limit then type(i) = fn Population(3^i)
k = fn Population(i)
if k mod 2 == 0 and ee < _limit then evil(ee) = i : ee++
if k mod 2 == 1 and eo < _limit then odious(eo) = i : eo++
i++
wend
typeStr = "" : evilStr = "" : odiousStr = ""
for i = 0 to _limit - 1
typeStr = typeStr + str$( type(i) ) + " "
evilStr = evilStr + str$( evil(i) ) + " "
odiousStr = odiousStr + str$( odious(i) ) + " "
next
print typeStr : print evilStr : print odiousStr
end fn
fn EvilOdious
HandleEvent
</syntaxhighlight>
{{output}}
<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
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
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|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
Line 1,716 ⟶ 2,227:
Print "1st 30 Odious numbers =\t" & sOdious 'Print Odious
End</
Output:
<pre>
Line 1,727 ⟶ 2,238:
===Standard Library===
As of Go 1.9, this function is in the standard Library.
<
import (
Line 1,764 ⟶ 2,275:
}
fmt.Println()
}</
{{out}}
<pre>
Line 1,776 ⟶ 2,287:
===Implementation===
Method of WP example '''popcount_3''':
<
const (
ff = 1<<64 - 1
Line 1,788 ⟶ 2,299:
w = (w + w>>4) & maskf
return int(w * maskp >> 56)
}</
Method of WP example '''popcount_4''':
<
for w != 0 {
w &= w - 1
Line 1,796 ⟶ 2,307:
}
return
}</
=={{header|Haskell}}==
{{works with|GHC|7.4+}}
<
printPops :: (Show a, Integral a) => String -> [a] -> IO ()
Line 1,809 ⟶ 2,320:
printPops "popcount " $ map popCount $ iterate (*3) (1 :: Integer)
printPops "evil " $ filter (even . popCount) ([0..] :: [Integer])
printPops "odious " $ filter ( odd . popCount) ([0..] :: [Integer])</
{{out}}
<pre>
Line 1,819 ⟶ 2,330:
Or, if we want to write our own popCount, perhaps something like:
<syntaxhighlight lang
import Data.
import Data.Tuple (swap)
popCount :: Int -> Int
popCount = sum . unfoldr go
where
go x
| 0 < x = (Just . swap) (quotRem x 2)
| otherwise = Nothing
main :: IO ()
main =
mapM_ putStrLn $
zipWith
(\k xs ->
["Population count of powers of 3", "evil", "odious"]
( (popCount . (3 ^) <$> [0 .. 29]) :
biList (partition (even . popCount) [0 .. 59])
)</syntaxhighlight>
{{Out}}
<pre>Population count of powers of 3:
Line 1,850 ⟶ 2,364:
=={{header|Idris}}==
<
import Data.Vect
Line 1,889 ⟶ 2,403:
printCompact (filterUnfoldN 30 isEvil id (1 +) 0)
putStr "Odious: "
printCompact (filterUnfoldN 30 isOdious id (1 +) 0)</
{{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
Line 1,899 ⟶ 2,413:
Implementation:
<
isOdd=: 1 = 2&|
isEven=: 0 = 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")
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</
=={{header|Java}}==
<
public class PopCount {
Line 1,969 ⟶ 2,483:
System.out.println();
}
}</
{{out}}
<pre>
Line 1,982 ⟶ 2,496:
===ES6===
<
'use strict';
Line 2,111 ⟶ 2,625:
// ---
return main();
})();</
{{Out}}
<pre>Population counts of the first 30 powers of three:
Line 2,124 ⟶ 2,638:
=={{header|jq}}==
{{works with|jq|1.4}}
<
def bin: recurse( if . == 0 then empty else ./2 | floor end ) % 2;
[bin] | add;
Line 2,149 ⟶ 2,663:
;
task</
{{Out}}
$ jq -n -r -c -f Population_count.jq
Line 2,160 ⟶ 2,674:
=={{header|Julia}}==
<
println("Evil numbers: ", join(filter(x -> iseven(count_ones(x)), 0:59), ", "))
println("Odious numbers: ", join(filter(x -> isodd(count_ones(x)), 0:59), ", "))</
{{out}}
Line 2,170 ⟶ 2,684:
=={{header|Kotlin}}==
<
fun popCount(n: Long) = when {
Line 2,209 ⟶ 2,723:
}
println()
}</
{{out}}
Line 2,224 ⟶ 2,738:
=={{header|Lua}}==
<
function dec2bin (n)
local bin, bit = ""
Line 2,266 ⟶ 2,780:
firstThirty("3^x")
firstThirty("Evil")
firstThirty("Odious")</
{{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
Evil: 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
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>
=={{header|M2000 Interpreter}}==
=====Using just Count() and loops=====
<syntaxhighlight lang="m2000 interpreter">
Module Population_count{
Function Count(x as long long) {
integer Count
long long m=x
m|div 0x1_0000_0000&&
x|mod 0x1_0000_0000&&
While x<>0&
x=Binary.And(X, X-1&&)
Count++
End While
x=m
While x<>0&
x=Binary.And(X, X-1&&)
Count++
End While
=Count
}
long long i, b=3
stack new {
for i=0 to 29
Data count(b^i)
next
print "3^x population:", array([])#str$()
i=0: b=0
while i<30
if Count(b) mod 2=0 then data b:i++
b++
end while
print "evil numbers:", array([])#str$()
i=0: b=0
while i<30
if Count(b) mod 2=1 then data b:i++
b++
end while
print "odious numbers:", array([])#str$()
}
}
Population_count
</syntaxhighlight>
=====Using Generators=====
<syntaxhighlight lang="m2000 interpreter">
Module Population_count{
Count=lambda (x as long long)->{
integer Count
long long m=x
m|div 0x1_0000_0000&&
x|mod 0x1_0000_0000&&
While x<>0&
x=Binary.And(X, X-1&&)
Count++
End While
x=m
While x<>0&
x=Binary.And(X, X-1&&)
Count++
End While
=Count
}
series3pow=lambda Count, i=0&& -> {
=count(3&&^i):i++
}
seriesEvil=lambda Count, i=0&&-> {
while Count(i) mod 2=1{i++}
=i:i++
}
seriesOdious=lambda Count, i=0&&-> {
while Count(i) mod 2=0{i++}
=i:i++
}
Dim a(30)<<series3pow()
print "3^x population:", a()#str$()
Dim a(30)<<seriesEvil()
print "evil numbers:", a()#str$()
Dim a(30)<<seriesOdious()
print "odious numbers:", a()#str$()
}
Population_count
</syntaxhighlight>
{{out}}
<pre>
3^x population: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
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
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
</pre>
=={{header|MAD}}==
<
INTERNAL FUNCTION LOWBIT.(K) = K-K/2*2
Line 2,317 ⟶ 2,922:
VECTOR VALUES NUMFMT = $I2*$
END OF PROGRAM</
{{out}}
Line 2,415 ⟶ 3,020:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
Print["population count of powers of 3"]
popcount[#] & /@ (3^Range[0, 30])
Line 2,440 ⟶ 3,045:
]
Print["first thirty odious numbers"]
odiouslist</
{{out}}
<pre>population count of powers of 3
Line 2,451 ⟶ 3,056:
=={{header|min}}==
{{works with|min|0.19.3}}
<
(
Line 2,463 ⟶ 3,068:
"3^n: " print! 30 iota (3 swap pow int pop-count) map puts!
60 iota (pop-count odd?) partition
"Evil: " print! puts! "Odious: " print! puts!</
{{out}}
<pre>
Line 2,470 ⟶ 3,075:
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>
=={{header|Miranda}}==
<syntaxhighlight lang="miranda">main :: [sys_message]
main = [Stdout (lay (map (show . take 30) [powers_of_3, evil, odious]))]
powers_of_3 :: [num]
powers_of_3 = map (popcount . (3^)) [0..]
evil :: [num]
evil = filter f [0..] where f n = popcount n mod 2 = 0
odious :: [num]
odious = filter f [0..] where f n = popcount n mod 2 = 1
popcount :: num -> num
popcount 0 = 0
popcount n = n mod 2 + popcount (n div 2)</syntaxhighlight>
{{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]
[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]
[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|Nim}}==
<
import strformat
Line 2,499 ⟶ 3,125:
for i in 0..<30:
write(stdout, fmt"{od[i]:2} ")
write(stdout, '\n')</
{{out}}
Line 2,509 ⟶ 3,135:
Another version, in functional style, with most computations done at compile time:
<
const
Line 2,520 ⟶ 3,146:
echo "3^n: ", popcounts.mapIt(($it).align(2)).join(" ")
echo "evil: ", evil.mapIt(($it).align(2)).join(" ")
echo "odious:", odious.mapIt(($it).align(2)).join(" ")</
{{out}}
Line 2,526 ⟶ 3,152:
evil: 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
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>
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let popcount n =
let rec aux acc = function
| 0 -> acc
| x -> aux (succ acc) (x land pred x)
in
aux 0 n
let is_parity p x =
p = 1 land popcount x
(* test code *)
let powers3_seq () =
Seq.unfold (fun x -> Some (popcount x, x * 3)) 1
let parity_seq p =
Seq.(filter (is_parity p) (ints 0))
let print_seq_30 s =
Seq.(s |> take 30 |> map string_of_int)
|> List.of_seq |> String.concat " " |> print_endline
let () = print_seq_30 (powers3_seq ())
let () = print_seq_30 (parity_seq 0)
let () = print_seq_30 (parity_seq 1)</syntaxhighlight>
{{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
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
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|Oforth}}==
<
0 while ( n ) [ n isOdd + n bitRight(1) ->n ] ;
Line 2,539 ⟶ 3,198:
0 ->count
0 while( count 30 <> ) [ dup popcount isOdd ifTrue: [ dup . count 1+ ->count ] 1+ ] drop ;</
{{out}}
Line 2,547 ⟶ 3,206:
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
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 ok
</pre>
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(define (popcount n)
(let loop ((n n) (c 0))
(if (= n 0)
c
(loop (>> n 1)
(if (eq? (band n 1) 0) c (+ c 1))))))
(print (popcount 31415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253))
(define thirty 30)
(display "popcount:")
(for-each (lambda (i)
(display " ")
(display (popcount (expt 3 i))))
(iota thirty 0))
(print)
(define (evenodd name test)
(display name) (display ":")
(for-each (lambda (i)
(display " ")
(display i))
(reverse
(let loop ((n 0) (i 0) (out '()))
(if (= i thirty)
out
(if (test (popcount n))
(loop (+ n 1) (+ i 1) (cons n out))
(loop (+ n 1) i out))))))
(print))
(evenodd "evil" even?)
(evenodd "odius" odd?)
</syntaxhighlight>
{{out}}
<pre>
159
popcount: 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
evil: 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
odius: 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|PARI/GP}}==
<
od=select(n->hammingweight(n)%2,[0..100]); ev=setminus([0..100],od);
ev[1..30]
od[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]
Line 2,562 ⟶ 3,266:
{{works with|freepascal}}
Like Ada a unit is used.
<
{$IFDEF FPC}
{$MODE DELPHI}
Line 2,643 ⟶ 3,347:
Begin
End.</
The program
<
uses
sysutils,popCount;
Line 2,693 ⟶ 3,397:
until k = 30;
writeln(s);
end.</
;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
Line 2,701 ⟶ 3,405:
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));
end;</
=={{header|Perl}}==
Line 2,713 ⟶ 3,417:
We'll emulate infinite lists with closures.
<
use warnings;
use feature 'say';
sub evil {
my $i = 0;
sub { $i++ while population_count($i) % 2; $i++ }
}
sub odious {
my $i = 0;
Line 2,737 ⟶ 3,431:
}
sub population_count {
my
my $c;
for ($c = 0; $n; $n >>= 1) { $c += $n & 1 }
$c
}
say join ' ', map { population_count 3**$_ } 0 .. 30 - 1;
my (@evil, @odious);
my ($evil, $odious) = (evil, odious);
push( @evil, $evil->() ), push @odious, $odious->() for 1 .. 30;
say "Evil @evil";
say "Odious @odious";</syntaxhighlight>
{{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
Evil
Odious
A faster population count can be done with pack/unpack:
<syntaxhighlight lang="text">say unpack("%b*",pack "J*", 1234567); # J = UV</
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);
Line 2,766 ⟶ 3,465:
use Bit::Vector;
say Bit::Vector->new_Dec(64,1234567)->Norm;</
=={{header|Phix}}==
As of 1.0.2 there is a builtin count_bits(), and also mpz_popcount(), both of which match the results from pop_count() below.
<!--<syntaxhighlight lang="phix">(phixonline)-->
<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: #008080;">if</span> <span style="color: #000000;">n</span><span style="color: #0000FF;"><</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">9</span><span style="color: #0000FF;">/</span><span style="color: #000000;">0</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">n</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">0</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">res</span> <span style="color: #0000FF;">+=</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">floor</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">/</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">return</span> <span style="color: #000000;">res</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"3^x pop_counts:%v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #004600;">true</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">power</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">29</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)}),</span><span style="color: #000000;">pop_count</span><span style="color: #0000FF;">)})</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">eo</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">b0</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">name</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">30</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">integer</span> <span style="color: #000000;">k</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">l</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">l</span><span style="color: #0000FF;"><=</span><span style="color: #000000;">30</span> <span style="color: #008080;">do</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">pop_count</span><span style="color: #0000FF;">(</span><span style="color: #000000;">k</span><span style="color: #0000FF;">),</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)=</span><span style="color: #000000;">b0</span> <span style="color: #008080;">then</span>
<span style="color: #000000;">s</span><span style="color: #0000FF;">[</span><span style="color: #000000;">l</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">k</span>
<span style="color: #000000;">l</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">k</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s numbers:%v\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">name</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</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>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 2,806 ⟶ 3,506:
=={{header|PHP}}==
<syntaxhighlight lang="php">
function convertToBinary($integer) {
$binary = "";
Line 2,875 ⟶ 3,575:
echo "\nfirst 30 odious numbers:";
printFirst30Odious();
</syntaxhighlight>
{{out}}
<pre>
Line 2,882 ⟶ 3,582:
first 30 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
</pre>
=={{header|Picat}}==
<syntaxhighlight lang="picat">go =>
println(powers_of_three=[pop_count(3**I) : I in 0..29]),
println('evil_numbers '=take_n($evil_number, 30,0)),
println('odious_numbers '=take_n($odious_number, 30,0)),
nl.
% Get the first N numbers that satisfies function F, starting with S
take_n(F,N,S) = L =>
I = S,
C = 0,
L = [],
while(C < N)
if call(F,I) then
L := L ++ [I],
C := C + 1
end,
I := I + 1
end.
evil_number(N) => pop_count(N) mod 2 == 0.
odious_number(N) => pop_count(N) mod 2 == 1.
pop_count(N) = sum([1: I in N.to_binary_string(), I = '1']).</syntaxhighlight>
{{out}}
<pre>powers_of_three = [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]
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]
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]</pre>
=={{header|PicoLisp}}==
<
(cnt
'((N) (= "1" N))
Line 2,909 ⟶ 3,640:
(when (bit? 1 (popz (inc 'N)))
(link N)
(inc 'C) ) ) ) )</
{{out}}
<pre>
Line 2,918 ⟶ 3,649:
=={{header|PowerShell}}==
<syntaxhighlight lang="powershell">
function pop-count($n) {
(([Convert]::ToString($n, 2)).toCharArray() | where {$_ -eq '1'}).count
Line 2,925 ⟶ 3,656:
"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} )"
</syntaxhighlight>
<b>Output:</b>
<pre>
Line 2,934 ⟶ 3,665:
=={{header|PureBasic}}==
<
Procedure PutR(v.i) : Print(RSet(Str(v),3)) : EndProcedure
Line 2,948 ⟶ 3,679:
Print("Evil numbers ") : ForEach ne() : PutR(ne()) : Next : PrintN("")
Print("Odious numb..") : ForEach no() : PutR(no()) : Next : Input()
EndIf</
{{out}}
<pre>
Line 2,958 ⟶ 3,689:
=={{header|Python}}==
===Procedural===
<
...
>>> [popcount(3**i) for i in range(30)]
Line 2,973 ⟶ 3,704:
>>> 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
</syntaxhighlight>
===Composition of pure functions===
{{Works with|Python|3}}
<
from functools import reduce
Line 3,112 ⟶ 3,843:
# MAIN ---
if __name__ == '__main__':
main()</
{{Out}}
<pre>Population count of first 30 powers of 3:
Line 3,125 ⟶ 3,856:
=={{header|Quackery}}==
<
[ dup while
dup 1 &
Line 3,156 ⟶ 3,887:
cr
say "The first thirty odious numbers." cr
30 echopopwith odd cr</
{{out}}
Line 3,168 ⟶ 3,899:
The first thirty 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</pre>
=={{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.
<syntaxhighlight lang="rsplus">library(bit64)
popCount <- function(x) sum(as.numeric(strsplit(as.bitstring(as.integer64(x)), "")[[1]]))
finder <- function()
{
odious <- evil <- integer(0)
x <- odiousLength <- evilLength <- 0
while(evilLength + odiousLength != 60)#We could be smarter, but this condition suffices.
{
if(popCount(x) %% 2 == 0) evil[evilLength + 1] <- x else odious[odiousLength + 1] <- x
x <- x + 1
evilLength <- length(evil)
odiousLength <- length(odious)
}
cat("The pop count of the 1st 30 powers of 3 are:", sapply(3^(0:29), popCount), "\n")
cat("The first 30 evil numbers are:", evil, "\n")
cat("The first 30 odious numbers are:", odious)
}
finder()</syntaxhighlight>
{{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
The first 30 evil numbers are: 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
The first 30 odious numbers are: 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|Racket}}==
<
;; Positive version from "popcount_4" in:
;; https://en.wikipedia.org/wiki/Hamming_weight#Efficient_implementation
Line 3,210 ⟶ 3,966:
(check-true (odious? 1) "the least odious number")
(check-true (odious? #b1011011011) "seven (which is odd) bits")
(check-false (odious? #b011011011) "six bits... is evil"))</
{{out}}
<pre>
Line 3,223 ⟶ 3,979:
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
say map &population-count, 3 «**« ^30;
say "Evil: ", (grep { population-count($_) %% 2 }, 0 .. *)[^30];
say "Odious: ", (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
Line 3,233 ⟶ 3,989:
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:
<syntaxhighlight lang="raku"
loop (my $c = 0; $n; $n +>= 1) {
$c += $n +& 1;
}
$c;
}</
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <Prout <Gen 30 All Pow3 (1)>>
<Prout <Gen 30 Evil Iota (0)>>
<Prout <Gen 30 Odious Iota (0)>>;
};
Gen {
0 s.Fil s.Gen (s.State) = ;
s.N s.Fil s.Gen (s.State),
<Mu s.Gen s.State>: (s.Next) s.Item,
<Mu s.Fil s.Item>: {
T = s.Item <Gen <- s.N 1> s.Fil s.Gen (s.Next)>;
F = <Gen s.N s.Fil s.Gen (s.Next)>;
};
};
Popcount {
0 = 0;
s.N, <Divmod s.N 2>: (s.R) s.B = <+ s.B <Popcount s.R>>;
};
Pow3 {
s.N = (<* 3 s.N>) <Popcount s.N>;
};
Evil {
s.N, <Mod <Popcount s.N> 2>: {
0 = T;
1 = F;
};
};
Odious {
s.N, <Mod <Popcount s.N> 2>: {
0 = F;
1 = T;
};
};
All { s.X = T; }
Iota { s.N = (<+ 1 s.N>) s.N; }</syntaxhighlight>
{{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
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
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|REXX}}==
The ''pop count'' is used in some encryption/decryption methods; a major mainframe manufacturer was coerced <br>(many years ago) 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. */
Line 3,272 ⟶ 4,075:
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. */
showList: say; say 'The 1st' N arg(1)":"; say strip($); #= 0; $=; return</
{{out|output|text= when using the default input:}}
<pre>
Line 3,286 ⟶ 4,089:
=={{header|Ring}}==
<syntaxhighlight lang="ring"># Project : Population count
odds = []
for n = 0 to 59
if n < 30 add(pows, onesCount(pow(3, n))) ok
next
showOne("3^x:", pows)
showOne("Evil numbers:", evens)
showOne("Odious numbers:", odds)
func
c =
while b
if b
end return c
func arrayToStr(ary)
res = "[" s = ", "
for n = 1 to len(ary)
if ary[n] < 10 res += " " ok
if n = len(ary) s = "]" ok
res += "" + ary[n] + s
next return res
func showOne(title, ary)
? title
? arrayToStr(ary) + nl</syntaxhighlight>
{{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]
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]
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
=={{header|RPL}}==
{{Trans|Forth}}
≪ # 0b SWAP
'''WHILE''' DUP # 0b ≠ '''REPEAT'''
DUP # 1b AND ROT + SWAP SR '''END'''
DROP B→R
≫ ''''POPCT'''' STO
≪ '''POPCT''' 2 MOD
≫ ‘'''ODUS?'''’ STO
≪ '''ODUS?''' NOT
≫ ‘'''EVIL?'''’ STO
≪ → n
≪ { } # 1b 1 n START
DUP '''POPCT''' ROT SWAP + SWAP 3 * NEXT DROP
{ } # 0b WHILE OVER SIZE n < REPEAT
IF DUP '''EVIL?''' THEN SWAP OVER B→R + SWAP END 1 + END DROP
{ } # 0b WHILE OVER SIZE n < REPEAT
IF DUP '''ODUS?''' THEN SWAP OVER B→R + SWAP END 1 + END DROP
≫ ≫ ‘TASK’ STO
30 TASK
{{out}}
<pre>
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 }
2: { 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 }
1: { 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|Ruby}}==
Demonstrating lazy enumerators.
<
def popcount
Line 3,380 ⟶ 4,181:
puts "Powers of 3:", (0...30).map{|n| (3**n).popcount}.join(' ')
puts "Evil:" , 0.step.lazy.select(&:evil?).first(30).join(' ')
puts "Odious:", 0.step.lazy.reject(&:evil?).first(30).join(' ')</
{{Output}}<pre>
Powers of 3:
Line 3,391 ⟶ 4,192:
=={{header|Rust}}==
<
let mut num = 1u64;
let mut vec = Vec::new();
Line 3,412 ⟶ 4,213:
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:
Line 3,430 ⟶ 4,231:
{{libheader|Scastie qualified}}
{{works with|Scala|2.13}}
<
object PopCount extends App {
Line 3,448 ⟶ 4,249:
println(series(0L).filter(bitCount(_) % 2 != 0).take(nNumber).mkString(", "))
}</
=={{header|Seed7}}==
Line 3,456 ⟶ 4,257:
is used to compute the population count of the bitset.
<
const func integer: popcount (in integer: n) is
Line 3,487 ⟶ 4,288:
end for;
writeln;
end func;</
{{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
Line 3,493 ⟶ 4,294:
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>
=={{header|SETL}}==
<syntaxhighlight lang="setl">program population_count;
print([popcount(3**n) : n in [0..29]]);
print([n : n in [0..59] | evil n]);
print([n : n in [0..59] | odious n]);
op evil(n);
return even popcount n;
end op;
op odious(n);
return odd popcount n;
end op;
op popcount(n);
return +/[[n mod 2, n div:=2](1) : until n=0];
end op;
end program;</syntaxhighlight>
{{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]
[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]
[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|Sidef}}==
<
say "#{0..29 «**« 3 «call« population_count -> join(' ')}"
Line 3,502 ⟶ 4,325:
say "Evil: #{numbers.grep{_[1] %% 2}.map{.first}.join(' ')}"
say "Odious: #{numbers.grep{_[1] & 1}.map{.first}.join(' ')}"</
{{out}}
<pre>
Line 3,511 ⟶ 4,334:
=={{header|Swift}}==
<
guard n >= 0 else { fatalError() }
Line 3,535 ⟶ 4,358:
print("Powers:", Array(pows))
print("Evils:", Array(evils))
print("Odious:", Array(odious))</
{{out}}
Line 3,544 ⟶ 4,367:
=={{header|Symsyn}}==
<syntaxhighlight lang="symsyn">
| Pop Count 3^i
Line 3,595 ⟶ 4,418:
endif
"' Odious Numbers : ' $o " []
</syntaxhighlight>
{{out}}
Line 3,605 ⟶ 4,428:
=={{header|Tcl}}==
{{works with|Tcl|8.6}}
<
proc hammingWeight {n} {
Line 3,618 ⟶ 4,441:
}
puts "evil: [lrange $e 0 29]"
puts "odious: [lrange $o 0 29]"</
{{out}}
<pre>
Line 3,628 ⟶ 4,451:
=={{header|UNIX Shell}}==
{{works with|bash}}
<
local -i n=$1
(( n < 0 )) && return 1
Line 3,660 ⟶ 4,483:
done
echo "evil nums: ${evil[*]:0:30}"
echo "odious nums: ${odious[*]: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
Line 3,670 ⟶ 4,493:
{{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
Line 3,705 ⟶ 4,528:
Wend
popcount = y
End Function 'popcount </
{{out}}
<pre>
Line 3,719 ⟶ 4,542:
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
Line 3,751 ⟶ 4,574:
Wend
popcount=y
End Function 'popcount </
{{out}}
<pre>
Line 3,764 ⟶ 4,587:
=={{header|Visual Basic .NET}}==
{{trans|C#}}
<
Module Module1
Line 3,814 ⟶ 4,637:
End Function
End Module</
{{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.
Line 3,828 ⟶ 4,651:
{{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
var popCount = Fn.new { |n|
Line 3,863 ⟶ 4,686:
odious.add(n)
System.print("\n\nThe first 30 odious numbers are:")
Fmt.print("$d", odious)</
{{out}}
Line 3,875 ⟶ 4,698:
The first 30 odious numbers are:
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|XPL0}}==
Double precision floating point numbers are used because XPL0's 32-bit
integers don't have sufficient precision to reach 3^29. Double precision
has a 53-bit mantissa that can represent integers up to 2^53, which is
approximately 9.0e15 or approximately 3^33, which is sufficient.
<syntaxhighlight lang "XPL0">func PopCnt(N); \Return count of 1s in binary representation of N
real N; int C;
[C:= 0;
while N >= 0.5 do
[if fix(Mod(N, 2.)) = 1 then C:= C+1;
N:= Floor(N/2.);
];
return C;
];
proc Show30(LSb); \Display 30 numbers with even or odd population count
int LSb, C; real N; \Least Significant bit determines even or odd
[N:= 0.; C:= 0;
repeat if (PopCnt(N)&1) = LSb then
[RlOut(0, N); C:= C+1];
N:= N+1.;
until C >= 30;
CrLf(0);
];
real N; int P;
[Format(3, 0);
Text(0, "Pow 3: ");
N:= 1.;
for P:= 0 to 29 do
[RlOut(0, float(PopCnt(N))); N:= N*3.];
CrLf(0);
Text(0, "Evil: "); Show30(0);
Text(0, "Odious:"); Show30(1);
]</syntaxhighlight>
{{out}}
<pre>
Pow 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
Evil: 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
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>
=={{header|Yabasic}}==
<
for i = 0 to 29
Line 3,911 ⟶ 4,776:
next
return popul
end sub</
=={{header|zkl}}==
Ints have the 1s count as a property.
<
println("evil: ",[0..].filter(30,fcn(n){ n.num1s.isEven }).concat(","));
Line 3,921 ⟶ 4,786:
// now, as an iterator aka lazy:
println("odious: ",(0).walker(*).tweak( // 0,1,2,3,4... iterator
fcn(n){ if(n.num1s.isEven) Void.Skip else n }).walk(30).concat(","));</
{{out}}
<pre>
|