Anonymous user
Chowla numbers: Difference between revisions
m
no edit summary
imported>Wilm mNo edit summary |
|||
(18 intermediate revisions by 9 users not shown) | |||
Line 74:
:* the OEIS entry for [http://oeis.org/A048050 A48050 Chowla's function].
<br><br>
=={{header|11l}}==
{{trans|C}}
<
V sum = 0
V i = 2
Line 115 ⟶ 114:
k = kk + 1
kk += k
print(‘There are ’count‘ perfect numbers < ’limit)</
{{out}}
Line 169 ⟶ 168:
There are 5 perfect numbers < 350000000
</pre>
=={{header|Ada}}==
{{trans|C}}
<
procedure Chowla_Numbers is
Line 241 ⟶ 239:
Put_Prime;
Put_Perfect;
end Chowla_Numbers;</
{{out}}
Line 293 ⟶ 291:
33550336 is a perfect number
There are 5 perfect numbers < 350000000</pre>
=={{header|ALGOL 68}}==
{{Trans|C}}
<
# returs the Chowla number of n #
PROC chowla = ( INT n )INT:
Line 333 ⟶ 330:
OD;
print( ( "There are ", whole( count, 0 ), " perfect numbers < ", whole( limit, 0 ), newline ) )
END</
{{out}}
<pre>
Line 386 ⟶ 383:
There are 5 perfect numbers < 350000000
</pre>
=={{header|Arturo}}==
<
countPrimesUpTo: function [limit][
count: 1
Line 410 ⟶ 406:
if (chowla i) = i - 1 -> print i
i: i + 2
]</
{{out}}
Line 465 ⟶ 461:
8128
33550336</pre>
=={{header|AWK}}==
<syntaxhighlight lang="awk">
# syntax: GAWK -f CHOWLA_NUMBERS.AWK
# converted from Go
Line 543 ⟶ 538:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 595 ⟶ 590:
There are 5 perfect numbers <= 35,000,000
</pre>
=={{header|C}}==
<
unsigned chowla(const unsigned n) {
Line 628 ⟶ 622:
printf("There are %u perfect numbers < %u\n", count, limit);
return 0;
}</
{{out}}
<pre>chowla(1) = 0
Line 679 ⟶ 673:
33550336 is a perfect number
There are 5 perfect numbers < 350000000</pre>
=={{header|C sharp|C#}}==
{{trans|Go}}
<
namespace chowla_cs
Line 740 ⟶ 733:
}
}
}</
{{out}}
<pre>chowla(1) = 0
Line 792 ⟶ 785:
There are 5 perfect numbers <= 35,000,000
</pre>
=={{header|C++}}==
{{trans|Go}}
<
#include <iostream>
Line 851 ⟶ 843:
cout << "There are " << count << " perfect numbers <= 35,000,000\n";
return 0;
}</
{{out}}
<pre>chowla(1) = 0
Line 902 ⟶ 894:
33,550,336 is a number that is perfect
There are 5 perfect numbers <= 35,000,000</pre>
=={{header|CLU}}==
<
chowla = proc (n: int) returns (int)
sum: int := 0
Line 973 ⟶ 964:
stream$putl(po, "There are " || int$unparse(perfcount) ||
" perfect numbers < 35,000,000.")
end start_up</
{{out}}
<pre>chowla(1) = 0
Line 1,026 ⟶ 1,017:
=={{header|Cowgol}}==
{{trans|C}}
<
sub chowla(n: uint32): (sum: uint32) is
Line 1,092 ⟶ 1,083:
print(" perfect numbers < ");
print_i32(LIMIT);
print_nl();</
{{out}}
<pre>chowla(1) = 0
Line 1,143 ⟶ 1,134:
33550336 is a perfect number.
There are 5 perfect numbers < 35000000</pre>
=={{header|D}}==
{{trans|C#}}
<
int chowla(int n) {
Line 1,208 ⟶ 1,198:
}
writefln("There are %d perfect numbers <= 35,000,000", count);
}</
{{out}}
<pre>chowla(1) = 0
Line 1,259 ⟶ 1,249:
33550336 is a number that is perfect
There are 5 perfect numbers <= 35,000,000</pre>
=={{header|Delphi}}==
See [[#Pascal]].
Line 1,266 ⟶ 1,255:
{{trans|C#}}
<
var sum = 0
var i = 2
Line 1,342 ⟶ 1,331:
}
print("There are \(count) perfect numbers <= 35,000,000")</
{{out}}
Line 1,395 ⟶ 1,384:
33550336 is a number that is perfect
There are 5 perfect numbers <= 35,000,000</pre>
=={{header|EasyLang}}==
{{trans|Go}}
<syntaxhighlight lang="text">
fastfunc chowla n .
while
sum += i + j
.
.
return sum
.
i = 3
while i * 3 <= len c[]
if c[i] = 0
while j <=
.
.
.
s$[] = strchars n
s$ = ""
l = len s$[]
for i
if i >
s$ &= ","
.
l -= 1
s$ &= s$[i]
.
.
print "chowla number from 1 to 37"
for i = 1 to 37
print " " & i & ": " & chowla i
.
print ""
len c[] 10000000
count = 1
power = 100
i = 3
while i <= len c[]
if c[i] = 0
count += 1
.
if i = power - 1
print "There are " & c$ & " primes up to " & p$
power *= 10
.
i += 2
.
print ""
limit = 35000000
count = 0
i = 2
k = 2
kk = 3
repeat
p = k * kk
until p > limit
print s$ & " is a perfect number"
commatize limit s$
print "There are " & count & " perfect mumbers up to " & s$
.
</syntaxhighlight>
{{out}}
<pre>
Line 1,542 ⟶ 1,530:
33,550,336 is a perfect number
There are 5 perfect mumbers up to 35,000,000
</pre>
=={{header|EMal}}==
{{trans|Go}}
<syntaxhighlight lang="emal">
fun chowla = int by int n
int sum = 0
int j = 0
for int i = 2; i * i <= n; i++ do
if n % i == 0 do sum += i + when(i == (j = n / i), 0, j) end
end
return sum
end
fun sieve = List by int limit
List c = logic[].with(limit)
for int i = 3; i * 3 < limit; i += 2
if c[i] or chowla(i) != 0 do continue end
for int j = 3 * i; j < limit; j += 2 * i do c[j] = true end
end
return c
end
# find and display (1 per line) for the 1st 37 integers
for int i = 1; i <= 37; i++ do writeLine("chowla(" + i + ") = " + chowla(i)) end
int count = 1
int limit = 10000000
int power = 100
List c = sieve(limit)
for int i = 3; i < limit; i += 2
if not c[i] do count++ end
if i == power - 1
writeLine("Count of primes up to " + power + " = " + count)
power *= 10
end
end
count = 0
limit = 35000000
int k = 2
int kk = 3
int p
for int i = 2; ; i++
if (p = k * kk) > limit do break end
if chowla(p) == p - 1
writeLine(p + " is a number that is perfect")
count++
end
k = kk + 1
kk += k
end
writeLine("There are " + count + " perfect numbers <= 35,000,000")
</syntaxhighlight>
It takes about fifteen minutes to complete on my i7-8650U with 8.00GB of RAM.
{{out}}
<pre>
chowla(1) = 0
chowla(2) = 0
chowla(3) = 0
chowla(4) = 2
chowla(5) = 0
chowla(6) = 5
chowla(7) = 0
chowla(8) = 6
chowla(9) = 3
chowla(10) = 7
chowla(11) = 0
chowla(12) = 15
chowla(13) = 0
chowla(14) = 9
chowla(15) = 8
chowla(16) = 14
chowla(17) = 0
chowla(18) = 20
chowla(19) = 0
chowla(20) = 21
chowla(21) = 10
chowla(22) = 13
chowla(23) = 0
chowla(24) = 35
chowla(25) = 5
chowla(26) = 15
chowla(27) = 12
chowla(28) = 27
chowla(29) = 0
chowla(30) = 41
chowla(31) = 0
chowla(32) = 30
chowla(33) = 14
chowla(34) = 19
chowla(35) = 12
chowla(36) = 54
chowla(37) = 0
Count of primes up to 100 = 25
Count of primes up to 1000 = 168
Count of primes up to 10000 = 1229
Count of primes up to 100000 = 9592
Count of primes up to 1000000 = 78498
Count of primes up to 10000000 = 664579
6 is a number that is perfect
28 is a number that is perfect
496 is a number that is perfect
8128 is a number that is perfect
33550336 is a number that is perfect
There are 5 perfect numbers <= 35,000,000
</pre>
=={{header|Factor}}==
<
math.primes.factors math.ranges math.statistics sequences
tools.memory.private ;
Line 1,572 ⟶ 1,662:
count-primes nl 35e7 show-perfect ;
MAIN: chowla-demo</
{{out}}
<pre>
Line 1,626 ⟶ 1,716:
33,550,336 is perfect
</pre>
=={{header|Fortran}}==
{{works with|VAX Fortran|V4.6-244}}
{{libheader|VAX/VMS V4.6}}This compiler implements the Fortran-77 standard. The VAX/VMS operating system runs on simulated hardware using the open source [https://opensimh.org/ opensimh] platform.
{{trans|Ada}}
Run time on a Raspberry Pi 4 Model B Rev 1.1 (Raspbian GNU/Linux 10 buster) was 7h 21m
<syntaxhighlight lang="fortran" line="1">
PROGRAM CHOWLA
CALL PUT_1ST_37
CALL PUT_PRIME
CALL PUT_PERFECT
END
INTEGER*4 FUNCTION CHOWLA1(N)
C The Chowla number of N is the sum of the divisors of N
C excluding unity and N where N is a positive integer
IMPLICIT INTEGER*4 (A-Z)
IF (N .LE. 0) STOP 'Argument to Chowla function must be > 0'
SUM = 0
I = 2
100 CONTINUE
IF (I * I .GT. N) GOTO 200
IF (MOD(N, I) .NE. 0) GOTO 110
J = N / I
SUM = SUM + I
IF ( I .NE. J) SUM = SUM + J
110 CONTINUE
I = I + 1
GOTO 100
200 CONTINUE
CHOWLA1 = SUM
RETURN
END
SUBROUTINE PUT_1ST_37
IMPLICIT INTEGER*4 (A-Z)
DO 100 I = 1, 37
PRINT 900, I, CHOWLA1(I)
100 CONTINUE
RETURN
900 FORMAT(1H , 'CHOWLA(', I2, ') = ', I2)
END
SUBROUTINE PUT_PRIME
IMPLICIT INTEGER*4 (A-Z)
PARAMETER LIMIT = 10000000
COUNT = 0
POWER = 100
DO 200 N = 2, LIMIT
IF (CHOWLA1(N) .EQ. 0) COUNT = COUNT + 1
IF (MOD(N, POWER) .NE. 0) GOTO 100
PRINT 900, COUNT, POWER
POWER = POWER * 10
100 CONTINUE
200 CONTINUE
RETURN
900 FORMAT(1H ,'There are ', I12, ' primes < ', I12)
END
SUBROUTINE PUT_PERFECT
IMPLICIT INTEGER*4 (A-Z)
PARAMETER LIMIT = 35000000
COUNT = 0
K = 2
KK = 3
100 CONTINUE
P = K * KK
IF (P .GT. LIMIT) GOTO 300
IF (CHOWLA1(P) .NE. P - 1) GOTO 200
PRINT 900, P
COUNT = COUNT + 1
200 CONTINUE
K = KK + 1
KK = KK + K
GOTO 100
300 CONTINUE
PRINT 910, COUNT, LIMIT
RETURN
900 FORMAT(1H , I10, ' is a perfect number')
910 FORMAT(1H , 'There are ', I10, ' perfect numbers < ', I10)
END
</syntaxhighlight>
{{out}}<pre>
CHOWLA( 1) = 0
CHOWLA( 2) = 0
CHOWLA( 3) = 0
CHOWLA( 4) = 2
CHOWLA( 5) = 0
CHOWLA( 6) = 5
CHOWLA( 7) = 0
CHOWLA( 8) = 6
CHOWLA( 9) = 3
CHOWLA(10) = 7
CHOWLA(11) = 0
CHOWLA(12) = 15
CHOWLA(13) = 0
CHOWLA(14) = 9
CHOWLA(15) = 8
CHOWLA(16) = 14
CHOWLA(17) = 0
CHOWLA(18) = 20
CHOWLA(19) = 0
CHOWLA(20) = 21
CHOWLA(21) = 10
CHOWLA(22) = 13
CHOWLA(23) = 0
CHOWLA(24) = 35
CHOWLA(25) = 5
CHOWLA(26) = 15
CHOWLA(27) = 12
CHOWLA(28) = 27
CHOWLA(29) = 0
CHOWLA(30) = 41
CHOWLA(31) = 0
CHOWLA(32) = 30
CHOWLA(33) = 14
CHOWLA(34) = 19
CHOWLA(35) = 12
CHOWLA(36) = 54
CHOWLA(37) = 0
There are 25 primes < 100
There are 168 primes < 1000
There are 1229 primes < 10000
There are 9592 primes < 100000
There are 78498 primes < 1000000
There are 664579 primes < 10000000
6 is a perfect number
28 is a perfect number
496 is a perfect number
8128 is a perfect number
33550336 is a perfect number
There are 5 perfect numbers < 35000000
</pre>
== {{header|FreeBASIC}} ==
{{trans|Visual Basic}}
<
' Chowla_numbers
Line 1,712 ⟶ 1,976:
Sleep
End
</syntaxhighlight>
{{out}}
<pre>
Line 1,773 ⟶ 2,037:
Pulsa una tecla para salir
</pre>
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn Chowla( n as NSUInteger ) as NSUInteger
NSUInteger i, j, r = 0
i = 2
while ( i * i <= n )
j = n / i
if ( n mod i == 0 )
r += i
if ( i != j )
r += j
end if
end if
i++
wend
end fn = r
local fn DoIt
NSUInteger n, count = 0, power = 100, limit, k, kk, p = 0
for n = 1 to 37
printf @"chowla(%u) = %u", n, fn Chowla( n )
next
for n = 2 to 10000000
if ( fn Chowla(n) == 0 ) then count ++
if ( n mod power == 0 ) then printf @"There are %u primes < %-7u", count, power : power *= 10
next
count = 0
limit = 350000000
k = 2 : kk = 3
do
p = k * kk
if ( fn Chowla( p ) == p - 1 )
printf @"%9u is a perfect number", p
count++
end if
k = kk + 1
kk = kk + k
until ( p > limit )
printf @"There are %u perfect numbers < %u", count, limit
end fn
fn DoIt
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
chowla(1) = 0
chowla(2) = 0
chowla(3) = 0
chowla(4) = 2
chowla(5) = 0
chowla(6) = 5
chowla(7) = 0
chowla(8) = 6
chowla(9) = 3
chowla(10) = 7
chowla(11) = 0
chowla(12) = 15
chowla(13) = 0
chowla(14) = 9
chowla(15) = 8
chowla(16) = 14
chowla(17) = 0
chowla(18) = 20
chowla(19) = 0
chowla(20) = 21
chowla(21) = 10
chowla(22) = 13
chowla(23) = 0
chowla(24) = 35
chowla(25) = 5
chowla(26) = 15
chowla(27) = 12
chowla(28) = 27
chowla(29) = 0
chowla(30) = 41
chowla(31) = 0
chowla(32) = 30
chowla(33) = 14
chowla(34) = 19
chowla(35) = 12
chowla(36) = 54
chowla(37) = 0
There are 25 primes < 100
There are 168 primes < 1,000
There are 1,229 primes < 10,000
There are 9,592 primes < 100,000
There are 78,498 primes < 1,000,000
There are 664,579 primes < 10,000,000
6 is a perfect number
28 is a perfect number
496 is a perfect number
8,128 is a perfect number
33,550,336 is a perfect number
There are 5 perfect numbers < 35,000,000
</pre>
=={{header|Go}}==
<
import "fmt"
Line 1,854 ⟶ 2,221:
}
fmt.Println("There are", count, "perfect numbers <= 35,000,000")
}</
{{out}}
Line 1,910 ⟶ 2,277:
There are 5 perfect numbers <= 35,000,000
</pre>
=={{header|Groovy}}==
{{trans|Kotlin}}
<
static int chowla(int n) {
if (n < 1) throw new RuntimeException("argument must be a positive integer")
Line 1,977 ⟶ 2,343:
printf("There are %,d perfect numbers <= %,d\n", count, limit)
}
}</
{{out}}
<pre>chowla( 1) = 0
Line 2,033 ⟶ 2,399:
Uses arithmoi Library: https://hackage.haskell.org/package/arithmoi-0.11.0.0
compiled with "-O2 -threaded -rtsopts"<br/>
<
import Control.Monad.Par (runPar, get, spawnP)
import Control.Monad (join, (>=>))
Line 2,095 ⟶ 2,461:
. fmap (chowlaPrimes $ take (10^7) allChowlas)
perfects = chowlaPerfects allChowlas
allChowlas = chowlas [1..35*10^6]</
{{out}}
<pre>Using 4 cores
Line 2,147 ⟶ 2,513:
33,550,336 is a perfect number.
There are 5 perfect numbers < 35,000,000</pre>
=={{header|J}}==
'''Solution:'''
<
intsbelow=: (2 }. i.)"0
countPrimesbelow=: +/@(0 = chowla)@intsbelow
findPerfectsbelow=: (#~ <: = chowla)@intsbelow</
'''Tasks:'''
<
1 0
2 0
Line 2,197 ⟶ 2,562:
25 168 1229 9592 78498 664579
findPerfectsbelow 35000000
6 28 496 8128 33550336</
=={{header|Java}}==
{{trans|C}}
<syntaxhighlight lang="java">
public class Chowla {
Line 2,287 ⟶ 2,651:
}
}
</syntaxhighlight>
{{out}}
<pre>
Line 2,342 ⟶ 2,706:
There are 5 perfect numbers < 35,000,000
</pre>
=={{header|jq}}==
{{works with|jq}}
Line 2,348 ⟶ 2,711:
The "brute-force" computation of the perfect number beyond 8,128 took many hours.
<
# input should be an integer
Line 2,420 ⟶ 2,783:
;
task</
{{out}}
<pre>
Line 2,477 ⟶ 2,840:
33,550,336
</pre>
=={{header|Julia}}==
<
function chowla(n)
Line 2,520 ⟶ 2,881:
testchowla()
</
<pre>
The first 37 chowla numbers are:
Line 2,573 ⟶ 2,934:
The count of perfect numbers up to 35,000,000 is 5.
</pre>
=={{header|Kotlin}}==
{{trans|Go}}
<
fun chowla(n: Int): Int {
Line 2,636 ⟶ 2,996:
}
println("There are $count perfect numbers <= 35,000,000")
}</
{{output}}
Line 2,642 ⟶ 3,002:
Same as Go example.
</pre>
=={{header|Lua}}==
{{trans|D}}
<
local sum = 0
local i = 2
Line 2,722 ⟶ 3,081:
end
main()</
{{out}}
<pre>chowla(1) = 0
Line 2,773 ⟶ 3,132:
33550336 is a number that is perfect
There are 5 perfect numbers <= 35,000,000</pre>
=={{header|MAD}}==
{{trans|C}}
<
INTERNAL FUNCTION(N)
Line 2,826 ⟶ 3,184:
DONE PRINT FORMAT PRFCNT, COUNT, LIMIT
END OF PROGRAM</
{{out}}
<pre>CHOWLA( 1) = 0
Line 2,877 ⟶ 3,235:
33550336 IS A PERFECT NUMBER.
THERE ARE 5 PERFECT NUMBERS BELOW 35000000</pre>
=={{header|Maple}}==
{{incorrect|Maple| <br><br> The output for Chowla(1) is incorrect. <br><br> }}
<
PrintChowla := proc(n::posint) local i;
Line 2,910 ⟶ 3,267:
countPrimes(1000000);
countPrimes(10000000);
findPerfect(35000000)</
{{Out}}
<pre>
Line 2,958 ⟶ 3,315:
664579
[6, 28, 496, 8128, 33550336]</pre>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
Chowla[0 | 1] := 0
Chowla[n_] := DivisorSigma[1, n] - 1 - n
Line 2,971 ⟶ 3,327:
i = 1; Do[If[Chowla[n] == 0, i++], {n, 3, 1000000, 2}]; i
i = 1; Do[If[Chowla[n] == 0, i++], {n, 3, 10000000, 2}]; i
Reap[Do[If[Chowla[n] == n - 1, Sow[n]], {n, 1, 35 10^6}]][[2, 1]]</
{{out}}
<pre>25
Line 2,980 ⟶ 3,336:
664579
{1, 6, 28, 496, 8128, 33550336}</pre>
=={{header|Nim}}==
{{trans|C}}
<
import strutils
Line 3,025 ⟶ 3,380:
k = kk + 1
kk += k
echo &"There are {count} perfect numbers < {insertSep($limit, ',')}"</
{{out}}
<pre>
Line 3,077 ⟶ 3,432:
33,550,336 is a perfect number
There are 5 perfect numbers < 350,000,000
</pre>
=={{header|PARI/GP}}==
{{trans|Julia}}
<syntaxhighlight lang="PARI/GP">
chowla(n) = {
if (n < 1, error("Chowla function argument must be positive"));
if (n < 4, return(0));
my(divs = divisors(n));
sum(i=1, #divs, divs[i]) - n - 1;
}
\\ Function to count Chowla numbers
countchowlas(n, asperfect = 1, verbose = 1) = {
my(count = 0, chow, i);
for (i = 2, n,
chow = chowla(i);
if ( (asperfect && (chow == i - 1)) || ((!asperfect) && (chow == 0)),
count++;
if (verbose, print("The number " i " is " if (asperfect, "perfect.", "prime.")));
);
);
count;
}
\\ Main execution block
{
print("The first 37 chowla numbers are:");
for (i = 1, 37, printf("Chowla(%s) is %s\n", Str(i), Str(chowla(i)) ) );
m=100;
while(m<=10000000, print("The count of the primes up to " m " is " countchowlas(m, 0, 0)); m=m*10);
print("The count of perfect numbers up to 35,000,000 is " countchowlas(35000000, 1, 1));
}
</syntaxhighlight>
{{out}}
<pre>
The first 37 chowla numbers are:
Chowla(1) is 0
Chowla(2) is 0
Chowla(3) is 0
Chowla(4) is 2
Chowla(5) is 0
Chowla(6) is 5
Chowla(7) is 0
Chowla(8) is 6
Chowla(9) is 3
Chowla(10) is 7
Chowla(11) is 0
Chowla(12) is 15
Chowla(13) is 0
Chowla(14) is 9
Chowla(15) is 8
Chowla(16) is 14
Chowla(17) is 0
Chowla(18) is 20
Chowla(19) is 0
Chowla(20) is 21
Chowla(21) is 10
Chowla(22) is 13
Chowla(23) is 0
Chowla(24) is 35
Chowla(25) is 5
Chowla(26) is 15
Chowla(27) is 12
Chowla(28) is 27
Chowla(29) is 0
Chowla(30) is 41
Chowla(31) is 0
Chowla(32) is 30
Chowla(33) is 14
Chowla(34) is 19
Chowla(35) is 12
Chowla(36) is 54
Chowla(37) is 0
The count of the primes up to 100 is 25
The count of the primes up to 1000 is 168
The count of the primes up to 10000 is 1229
The count of the primes up to 100000 is 9592
The count of the primes up to 1000000 is 78498
The count of the primes up to 10000000 is 664579
The number 6 is perfect.
The number 28 is perfect.
The number 496 is perfect.
The number 8128 is perfect.
The number 33550336 is perfect.
The count of perfect numbers up to 35000000 is 5.
</pre>
Line 3,085 ⟶ 3,526:
{{trans|Go}} but not using a sieve, cause a sieve doesn't need precalculated small primes.<BR>
So runtime is as bad as trial division.
<
{$IFDEF FPC}
Line 3,190 ⟶ 3,631:
Count10Primes(10 * 1000 * 1000);
CheckPerf;
end.</
{{Out}}
<pre>
Line 3,246 ⟶ 3,687:
real 1m54,534s
</pre>
=={{header|Perl}}==
{{libheader|ntheory}}
<
use warnings;
use ntheory 'divisor_sum';
Line 3,284 ⟶ 3,724:
my @perfect = perfect(my $limit = 35_000_000);
printf "\nThere are %d perfect numbers up to %s: %s\n",
1+$#perfect, comma($limit), join(' ', map { comma($_) } @perfect);</
{{out}}
<pre>chowla( 1) = 0
Line 3,333 ⟶ 3,773:
There are 5 perfect numbers up to 35,000,000: 6 28 496 8,128 33,550,336</pre>
=={{header|Phix}}==
<!--<
<span style="color: #008080;">function</span> <span style="color: #000000;">chowla</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;">return</span> <span style="color: #7060A8;">sum</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">factors</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">))</span>
Line 3,385 ⟶ 3,824:
<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;">"There are %d perfect numbers <= %,d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">count</span><span style="color: #0000FF;">,</span><span style="color: #000000;">limit</span><span style="color: #0000FF;">})</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">elapsed</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">time</span><span style="color: #0000FF;">()-</span><span style="color: #000000;">t0</span><span style="color: #0000FF;">)</span>
<!--</
The use of chowla() in sieve() does not actually achieve anything other than slow it down, so I took it out.
{{out}}
Line 3,410 ⟶ 3,849:
become 4s and 90s respectively, without finding anything else. Obviously 1.4e11 and 2.4e18
were picked to minimise the run times.
=={{header|Picat}}==
{{trans|Prolog}}
{{works with|Picat}}
<syntaxhighlight lang="picat">
table
chowla(1) = 0.
Line 3,454 ⟶ 3,892:
end,
printf("There are %d perfect numbers less than %d.\n", Count, Limit).
</syntaxhighlight>
{{out}}
<pre>
Line 3,507 ⟶ 3,945:
There are 5 perfect numbers less than 35000000.
</pre>
=={{header|PicoLisp}}==
<
(if (assoc Key (val Var))
(con @ (inc (cdr @)))
Line 3,572 ⟶ 4,009:
(prinl "Count of primes up to 1000000 = " (countP 1000000))
(prinl "Count of primes up to 10000000 = " (countP 10000000))
(println (listP 35000000))</
{{out}}
Line 3,621 ⟶ 4,058:
(6 28 496 8128 33550336)
</pre>
=={{header|PowerBASIC}}==
Line 3,627 ⟶ 4,063:
{{trans|Visual Basic .NET}}
<
#DIM ALL
#COMPILER PBCC 6
Line 3,724 ⟶ 4,160:
CON.PRINT "press any key to exit program"
CON.WAITKEY$
END FUNCTION</
{{out}}
<pre>chowla(1) = 0
Line 3,779 ⟶ 4,215:
There are 8 perfect numbers <= 2,305,843,009,213,693,950
press any key to exit program</pre>
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<syntaxhighlight lang="prolog">
chowla(1, 0).
chowla(2, 0).
Line 3,847 ⟶ 4,282:
length(Nums, PerfectCount),
format('There are ~D perfect numbers < ~D.\n', [PerfectCount, Limit]).
</syntaxhighlight>
{{out}}
<pre>
Line 3,900 ⟶ 4,335:
There are 5 perfect numbers < 35,000,000.
</pre>
=={{header|Python}}==
Uses [https://www.python.org/dev/peps/pep-0515/ underscores to separate digits] in numbers, and th [https://www.sympy.org/en/index.htm sympy library] to aid calculations.
<
from sympy import divisors
Line 3,935 ⟶ 4,369:
for i in range(6, 8):
print(f"primes_to({10**i:_}) == {primes_to(10**i):_}")
perfect_between(1_000_000, 35_000_000)</
{{out}}
Line 4,001 ⟶ 4,435:
* Splitting one function for the jit compiler to digest.
<
# https://docs.sympy.org/latest/modules/ntheory.html#sympy.ntheory.factor_.divisors
Line 4,034 ⟶ 4,468:
print(f" {i:_}")
c += 1
print(f"Found {c} Perfect numbers between [{n:_}, {m:_})")</
{{out}}
Line 4,040 ⟶ 4,474:
Speedup - not much, subjectively...
=={{header|Racket}}==
<
(require racket/fixnum)
Line 4,087 ⟶ 4,520:
(let ((ns (for/list ((n (sequence-filter perfect?/chowla (in-range 2 35000000)))) n)))
(printf "There are ~a perfect numbers <= 35000000: ~a~%" (length ns) ns)))</
{{out}}
Line 4,135 ⟶ 4,568:
Primes < 10000000: 664579
There are 5 perfect numbers <= 35000000: (6 28 496 8128 33550336)</pre>
=={{header|Raku}}==
(formerly Perl 6)
Line 4,144 ⟶ 4,576:
(For a more reasonable test, reduce the orders-of-magnitude range in the "Primes count" line from 2..7 to 2..5)
<syntaxhighlight lang="raku"
sub schnitzel (\Radda, \radDA = 0) {
Line 4,171 ⟶ 4,603:
say "\nPerfect numbers less than 35,000,000";
.&comma.say for mung-daal[^5];</
{{out}}
Line 4,226 ⟶ 4,658:
33,550,336
</pre>
=={{header|REXX}}==
<
parse arg LO HI . /*obtain optional arguments from the CL*/
if LO=='' | LO=="," then LO= 1 /*Not specified? Then use the default.*/
Line 4,256 ⟶ 4,687:
return s /*return " " " " " */
/*──────────────────────────────────────────────────────────────────────────────────────*/
commas: parse arg _; do k=length(_)-3 to 1 by -3; _= insert(',', _, k); end; return _</
{{out|output|text= when using the input of: <tt> 1 37 </tt>}}
<pre>
Line 4,333 ⟶ 4,764:
33,550,336 is a perfect number.
</pre>
=={{header|Ruby}}==
{{trans|C}}
<
sum = 0
i = 2
Line 4,388 ⟶ 4,818:
end
main()</
{{out}}
<pre>chowla(1) = 0
Line 4,439 ⟶ 4,869:
33550336 is a perfect number
There are 5 perfect numbers < 350000000</pre>
=={{header|Rust}}==
{{trans|C++}}
<syntaxhighlight lang="Rust">
fn chowla(n: usize) -> usize {
let mut sum = 0;
let mut i = 2;
while i * i <= n {
if n % i == 0 {
sum += i;
let j = n / i;
if i != j {
sum += j;
}
}
i += 1;
}
sum
}
fn sieve(limit: usize) -> Vec<bool> {
let mut c = vec![false; limit];
let mut i = 3;
while i * i < limit {
if !c[i] && chowla(i) == 0 {
let mut j = 3 * i;
while j < limit {
c[j] = true;
j += 2 * i;
}
}
i += 2;
}
c
}
fn main() {
for i in 1..=37 {
println!("chowla({}) = {}", i, chowla(i));
}
let mut count = 1;
let limit = 1e7 as usize;
let mut power = 100;
let c = sieve(limit);
for i in (3..limit).step_by(2) {
if !c[i] {
count += 1;
}
if i == power - 1 {
println!("Count of primes up to {} = {}", power, count);
power *= 10;
}
}
count = 0;
let limit = 35000000;
let mut k = 2;
let mut kk = 3;
loop {
let p = k * kk;
if p > limit {
break;
}
if chowla(p) == p - 1 {
println!("{} is a number that is perfect", p);
count += 1;
}
k = kk + 1;
kk += k;
}
println!("There are {} perfect numbers <= 35,000,000", count);
}
</syntaxhighlight>
{{out}}
<pre>
chowla(1) = 0
chowla(2) = 0
chowla(3) = 0
chowla(4) = 2
chowla(5) = 0
chowla(6) = 5
chowla(7) = 0
chowla(8) = 6
chowla(9) = 3
chowla(10) = 7
chowla(11) = 0
chowla(12) = 15
chowla(13) = 0
chowla(14) = 9
chowla(15) = 8
chowla(16) = 14
chowla(17) = 0
chowla(18) = 20
chowla(19) = 0
chowla(20) = 21
chowla(21) = 10
chowla(22) = 13
chowla(23) = 0
chowla(24) = 35
chowla(25) = 5
chowla(26) = 15
chowla(27) = 12
chowla(28) = 27
chowla(29) = 0
chowla(30) = 41
chowla(31) = 0
chowla(32) = 30
chowla(33) = 14
chowla(34) = 19
chowla(35) = 12
chowla(36) = 54
chowla(37) = 0
Count of primes up to 100 = 25
Count of primes up to 1000 = 168
Count of primes up to 10000 = 1229
Count of primes up to 100000 = 9592
Count of primes up to 1000000 = 78498
Count of primes up to 10000000 = 664579
6 is a number that is perfect
28 is a number that is perfect
496 is a number that is perfect
8128 is a number that is perfect
33550336 is a number that is perfect
There are 5 perfect numbers <= 35,000,000
</pre>
=={{header|Scala}}==
This solution uses a lazily-evaluated iterator to find and sum the divisors of a number, and speeds up the large searches using parallel vectors.
<
def main(args: Array[String]): Unit = {
println("Chowla Numbers...")
Line 4,456 ⟶ 5,013:
def chowlaNum(num: Int): Int = Iterator.range(2, math.sqrt(num).toInt + 1).filter(n => num%n == 0).foldLeft(0){case (s, n) => if(n*n == num) s + n else s + n + (num/n)}
}</
{{out}}
Line 4,512 ⟶ 5,069:
4: 8,128
5: 33,550,336</pre>
=={{header|Swift}}==
Uses Grand Central Dispatch to perform concurrent prime counting and perfect number searching
<
@inlinable
Line 4,600 ⟶ 5,156:
print("\(p) is a perfect number")
}
</syntaxhighlight>
{{out}}
Line 4,652 ⟶ 5,208:
8128 is a perfect number
33550336 is a perfect number</pre>
=={{header|Visual Basic}}==
{{works with|Visual Basic|6}}
{{trans|Visual Basic .NET}}
<
Private Declare Function AllocConsole Lib "kernel32.dll" () As Long
Line 4,766 ⟶ 5,321:
FreeConsole
End Sub</
{{out}}
<pre>chowla(1)=0
Line 4,818 ⟶ 5,373:
There are 5 perfect numbers <= 35.000.000
press enter to quit program.</pre>
=={{header|Visual Basic .NET}}==
{{trans|Go}}
<
Module Program
Line 4,869 ⟶ 5,423:
If System.Diagnostics.Debugger.IsAttached Then Console.ReadKey()
End Sub
End Module</
{{out}}
<pre>chowla(1) = 0
Line 4,923 ⟶ 5,477:
===More Cowbell===
{{libheader|System.Numerics}}One can get a little further, but that 8th perfect number takes nearly a minute to verify. The 9th takes longer than I have patience. If you care to see the 9th and 10th perfect numbers, change the 31 to 61 or 89 where indicated by the comment.
<
Module Program
Line 4,981 ⟶ 5,535:
If System.Diagnostics.Debugger.IsAttached Then Console.ReadKey()
End Sub
End Module</
{{out}}
<pre>chowla(1) = 0
Line 5,035 ⟶ 5,589:
2,305,843,008,139,952,128 is a number that is perfect
There are 8 perfect numbers <= 25,000,000,000,000,000,000</pre>
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="v (vlang)">fn chowla(n int) int {
if n < 1 {
panic("argument must be a positive integer")
Line 5,104 ⟶ 5,657:
}
println("There are $count perfect numbers <= 35,000,000")
}</
{{out}}
Line 5,164 ⟶ 5,717:
{{libheader|Wren-fmt}}
{{libheader|Wren-math}}
<
import "./math" for Int, Nums
Line 5,197 ⟶ 5,750:
i = i + 1
}
System.print("There are %(count) perfect numbers <= 35,000,000")</
{{out}}
Line 5,254 ⟶ 5,807:
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">func Chowla(N); \Return sum of divisors
int N, Div, Sum, Quot;
[Div:= 2; Sum:= 0;
loop [Quot:= N/Div;
if Quot < Div then quit;
if Quot = Div and rem(0) = 0 then \N is a square
[Sum:= Sum+Quot; quit];
if rem(0) = 0 then
Sum:= Sum + Div + Quot;
Div:= Div+1;
];
return Sum;
];
int N, C, P;
[for N:= 1 to 37 do
[IntOut(0, N); Text(0, ": ");
IntOut(0, Chowla(N)); CrLf(0);
];
C:= 1; \count 2 as prime
N:= 3; \only check odd numbers
repeat if Chowla(N) = 0 then \N is prime
C:= C+1;
case N+1 of 100, 1000, 10_000, 100_000, 1_000_000, 10_000_000:
[Text(0, "There are "); IntOut(0, C); Text(0, " primes < ");
IntOut(0, N+1); CrLf(0)]
other [];
N:= N+2;
until N >= 10_000_000;
P:= 1; \perfect numbers are of form: 2^(P-1) * (2^P - 1)
loop [P:= P*2;
N:= P*(P*2-1);
if N > 35_000_000 then quit;
if Chowla(N) = N-1 then \N is perfect
[IntOut(0, N); CrLf(0)];
];
]</syntaxhighlight>
{{out}}
<pre>
1: 0
2: 0
3: 0
4: 2
5: 0
6: 5
7: 0
8: 6
9: 3
10: 7
11: 0
12: 15
13: 0
14: 9
15: 8
16: 14
17: 0
18: 20
19: 0
20: 21
21: 10
22: 13
23: 0
24: 35
25: 5
26: 15
27: 12
28: 27
29: 0
30: 41
31: 0
32: 30
33: 14
34: 19
35: 12
36: 54
37: 0
There are 25 primes < 100
There are 168 primes < 1000
There are 1229 primes < 10000
There are 9592 primes < 100000
There are 78498 primes < 1000000
There are 664579 primes < 10000000
6
28
496
8128
33550336
</pre>
=={{header|zkl}}==
{{trans|Go}}
<
if(n<1)
throw(Exception.ValueError("Chowla function argument must be positive"));
Line 5,279 ⟶ 5,922:
}
c
}</
<
println("The first 37 Chowla numbers:\n",
[1..37].apply(chowla).concat(" ","[","]"), "\n");
Line 5,305 ⟶ 5,948:
}
println("There are %,d perfect numbers <= %,d".fmt(count,limit));
}();</
{{out}}
|