Chowla numbers: Difference between revisions

:*   the OEIS entry for   [http://oeis.org/A048050 A48050 Chowla's function].

<br><br>

 

=={{header|Ada}}==

{{trans|C}}

 

procedure Chowla_Numbers is

Put_Prime;

Put_Perfect;

 

{{out}}

33550336 is a perfect number

There are 5 perfect numbers < 350000000</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f CHOWLA_NUMBERS.AWK

# converted from Go

}

}

{{out}}

<pre>

There are 5 perfect numbers <= 35,000,000

</pre>

=={{header|C}}==

 

unsigned chowla(const unsigned n) {

printf("There are %u perfect numbers < %u\n", count, limit);

return 0;

{{out}}

<pre>chowla(1) = 0

33550336 is a perfect number

There are 5 perfect numbers < 350000000</pre>

{{trans|Go}}

 

namespace chowla_cs

}

}

{{out}}

<pre>chowla(1) = 0

There are 5 perfect numbers <= 35,000,000

</pre>

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

{{trans|Go}}

#include <iostream>

 

cout << "There are " << count << " perfect numbers <= 35,000,000\n";

return 0;

{{out}}

<pre>chowla(1) = 0

33,550,336 is a number that is perfect

There are 5 perfect numbers <= 35,000,000</pre>

 

=={{header|Cowgol}}==

{{trans|C}}

 

sub chowla(n: uint32): (sum: uint32) is

print(" perfect numbers < ");

print_i32(LIMIT);

{{out}}

<pre>chowla(1) = 0

33550336 is a perfect number.

There are 5 perfect numbers < 35000000</pre>

=={{header|D}}==

{{trans|C#}}

 

int chowla(int n) {

}

writefln("There are %d perfect numbers <= 35,000,000", count);

{{out}}

<pre>chowla(1) = 0

33550336 is a number that is perfect

There are 5 perfect numbers <= 35,000,000</pre>

=={{header|Delphi}}==

See [[#Pascal]].

{{trans|C#}}

 

var sum = 0

var i = 2

while i * i <= n {

if n % i == 0 {

0

} else {

return sum

}

func sieve(limit) {

var i = 3

while i * 3 < limit {

return c

}

for i in 1..37 {

print("chowla(\(i)) = \(chowla(i))")

}

var count = 1

var limit = 10000000

var power = 100

var i = 3

while i < limit {

i += 2

}

count = 0

var k = 2

var kk = 3

var p

i = 2

while true {

break

}

kk += k

}

 

{{out}}

33550336 is a number that is perfect

There are 5 perfect numbers <= 35,000,000</pre>

=={{header|EasyLang}}==

{{trans|Go}}

.

.

.

.

.

print "chowla number from 1 to 37"

for i = 1 to 37

.

.

{{out}}

<pre>

33,550,336 is a perfect number

There are 5 perfect mumbers up to 35,000,000

</pre>

 

=={{header|Factor}}==

math.primes.factors math.ranges math.statistics sequences

tools.memory.private ;

count-primes nl 35e7 show-perfect ;

 

{{out}}

<pre>

33,550,336 is perfect

</pre>

 

{{trans|Visual Basic}}

' Chowla_numbers

 

Sleep

End

{{out}}

<pre>

Pulsa una tecla para salir

</pre>

 

=={{header|Go}}==

 

import "fmt"

}

fmt.Println("There are", count, "perfect numbers <= 35,000,000")

 

{{out}}

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

printf("There are %,d perfect numbers <= %,d\n", count, limit)

}

{{out}}

<pre>chowla( 1) = 0

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, (>=>))

. fmap (chowlaPrimes $ take (10^7) allChowlas)

perfects = chowlaPerfects allChowlas

{{out}}

<pre>Using 4 cores

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

'''Tasks:'''

1 0

2 0

25 168 1229 9592 78498 664579

findPerfectsbelow 35000000

=={{header|Java}}==

{{trans|C}}

public class Chowla {

 

}

}

{{out}}

<pre>

There are 5 perfect numbers < 35,000,000

</pre>

 

=={{header|Julia}}==

 

function chowla(n)

 

testchowla()

<pre>

The first 37 chowla numbers are:

The count of perfect numbers up to 35,000,000 is 5.

</pre>

=={{header|Kotlin}}==

{{trans|Go}}

 

fun chowla(n: Int): Int {

}

println("There are $count perfect numbers <= 35,000,000")

 

{{output}}

Same as Go example.

</pre>

=={{header|Lua}}==

{{trans|D}}

local sum = 0

local i = 2

end

 

{{out}}

<pre>chowla(1) = 0

33550336 is a number that is perfect

There are 5 perfect numbers <= 35,000,000</pre>

=={{header|MAD}}==

{{trans|C}}

INTERNAL FUNCTION(N)

DONE PRINT FORMAT PRFCNT, COUNT, LIMIT

{{out}}

<pre>CHOWLA( 1) = 0

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;

countPrimes(1000000);

countPrimes(10000000);

{{Out}}

<pre>

664579

[6, 28, 496, 8128, 33550336]</pre>

=={{header|Nim}}==

{{trans|C}}

import strutils

 

k = kk + 1

kk += k

{{out}}

<pre>

There are 5 perfect numbers < 350,000,000

</pre>

 

=={{header|Pascal}}==

{{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}

Count10Primes(10 * 1000 * 1000);

CheckPerf;

{{Out}}

<pre>

real 1m54,534s

</pre>

=={{header|Perl}}==

{{libheader|ntheory}}

use warnings;

use ntheory 'divisor_sum';

my @perfect = perfect(my $limit = 35_000_000);

printf "\nThere are %d perfect numbers up to %s: %s\n",

{{out}}

<pre>chowla( 1) = 0

 

There are 5 perfect numbers up to 35,000,000: 6 28 496 8,128 33,550,336</pre>

=={{header|Phix}}==

The use of chowla() in sieve() does not actually achieve anything other than slow it down, so I took it out.

{{out}}

become 4s and 90s respectively, without finding anything else. Obviously 1.4e11 and 2.4e18

were picked to minimise the run times.

 

=={{header|PicoLisp}}==

(if (assoc Key (val Var))

(con @ (inc (cdr @)))

(prinl "Count of primes up to 1000000 = " (countP 1000000))

(prinl "Count of primes up to 10000000 = " (countP 10000000))

 

{{out}}

(6 28 496 8128 33550336)

</pre>

=={{header|PowerBASIC}}==

 

 

{{trans|Visual Basic .NET}}

#DIM ALL

#COMPILER PBCC 6

CON.PRINT "press any key to exit program"

CON.WAITKEY$

{{out}}

<pre>chowla(1) = 0

There are 8 perfect numbers <= 2,305,843,009,213,693,950

press any key to exit program</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

 

for i in range(6, 8):

print(f"primes_to({10**i:_}) == {primes_to(10**i):_}")

 

{{out}}

* Splitting one function for the jit compiler to digest.

 

 

# https://docs.sympy.org/latest/modules/ntheory.html#sympy.ntheory.factor_.divisors

print(f" {i:_}")

c += 1

 

{{out}}

 

Speedup - not much, subjectively...

=={{header|Racket}}==

 

 

(require racket/fixnum)

 

(let ((ns (for/list ((n (sequence-filter perfect?/chowla (in-range 2 35000000)))) n)))

 

{{out}}

Primes < 10000000: 664579

There are 5 perfect numbers <= 35000000: (6 28 496 8128 33550336)</pre>

=={{header|Raku}}==

(formerly Perl 6)

(For a more reasonable test, reduce the orders-of-magnitude range in the "Primes count" line from 2..7 to 2..5)

 

 

sub schnitzel (\Radda, \radDA = 0) {

say "\nPerfect numbers less than 35,000,000";

 

 

{{out}}

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.*/

return s /*return " " " " " */

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

{{out|output|text=&nbsp; when using the input of: &nbsp; &nbsp; <tt> 1 &nbsp; &nbsp; 37 </tt>}}

<pre>

33,550,336 is a perfect number.

</pre>

=={{header|Ruby}}==

{{trans|C}}

sum = 0

i = 2

end

 

{{out}}

<pre>chowla(1) = 0

33550336 is a perfect number

There are 5 perfect numbers < 350000000</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...")

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

4: 8,128

5: 33,550,336</pre>

=={{header|Swift}}==

 

Uses Grand Central Dispatch to perform concurrent prime counting and perfect number searching

 

 

@inlinable

print("\(p) is a perfect number")

}

 

{{out}}

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

FreeConsole

 

{{out}}

<pre>chowla(1)=0

There are 5 perfect numbers <= 35.000.000

press enter to quit program.</pre>

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

{{trans|Go}}

 

Module Program

If System.Diagnostics.Debugger.IsAttached Then Console.ReadKey()

End Sub

{{out}}

<pre>chowla(1) = 0

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

If System.Diagnostics.Debugger.IsAttached Then Console.ReadKey()

End Sub

{{out}}

<pre>chowla(1) = 0

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|Wren}}==

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

 

var chowla = Fn.new { |n| (n > 1) ? Nums.sum(Int.properDivisors(n)) - 1 : 0 }

 

System.print()

var count = 1

if (!c[i]) count = count + 1

if (i == power - 1) {

power = power * 10

}

if (p > limit) break

if (chowla.call(p) == p-1) {

count = count + 1

}

i = i + 1

}

 

{{out}}

</pre>

 

=={{header|zkl}}==

{{trans|Go}}

if(n<1)

throw(Exception.ValueError("Chowla function argument must be positive"));

}

c

println("The first 37 Chowla numbers:\n",

[1..37].apply(chowla).concat(" ","[","]"), "\n");

}

println("There are %,d perfect numbers <= %,d".fmt(count,limit));

 

{{out}}