Chowla numbers: Difference between revisions

{{trans|C}}

 

V sum = 0

V i = 2

k = kk + 1

kk += k

 

{{out}}

=={{header|Ada}}==

{{trans|C}}

 

procedure Chowla_Numbers is

Put_Prime;

Put_Perfect;

 

{{out}}

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

{{Trans|C}}

# returs the Chowla number of n #

PROC chowla = ( INT n )INT:

OD;

print( ( "There are ", whole( count, 0 ), " perfect numbers < ", whole( limit, 0 ), newline ) )

{{out}}

<pre>

=={{header|Arturo}}==

 

countPrimesUpTo: function [limit][

count: 1

if (chowla i) = i - 1 -> print i

i: i + 2

 

{{out}}

 

=={{header|AWK}}==

# syntax: GAWK -f CHOWLA_NUMBERS.AWK

# converted from Go

}

}

{{out}}

<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

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

{{trans|Go}}

 

namespace chowla_cs

}

}

{{out}}

<pre>chowla(1) = 0

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

{{trans|Go}}

#include <iostream>

 

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

return 0;

{{out}}

<pre>chowla(1) = 0

 

=={{header|CLU}}==

chowla = proc (n: int) returns (int)

sum: int := 0

stream$putl(po, "There are " || int$unparse(perfcount) ||

" perfect numbers < 35,000,000.")

{{out}}

<pre>chowla(1) = 0

=={{header|Cowgol}}==

{{trans|C}}

 

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

print(" perfect numbers < ");

print_i32(LIMIT);

{{out}}

<pre>chowla(1) = 0

=={{header|D}}==

{{trans|C#}}

 

int chowla(int n) {

}

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

{{out}}

<pre>chowla(1) = 0

{{trans|C#}}

 

var sum = 0

var i = 2

}

 

{{out}}

=={{header|EasyLang}}==

{{trans|Go}}

sum = 0

i = 2

print "There are " & count & " perfect mumbers up to " & s$

.

{{out}}

<pre>

 

=={{header|Factor}}==

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

tools.memory.private ;

count-primes nl 35e7 show-perfect ;

 

{{out}}

<pre>

=={{header|FreeBASIC}}==

{{trans|Visual Basic}}

' Chowla_numbers

 

Sleep

End

{{out}}

<pre>

 

=={{header|Go}}==

 

import "fmt"

}

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

 

{{out}}

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

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

 

The "brute-force" computation of the perfect number beyond 8,128 took many hours.

 

# input should be an integer

;

 

{{out}}

<pre>

 

=={{header|Julia}}==

 

function chowla(n)

 

testchowla()

<pre>

The first 37 chowla numbers are:

=={{header|Kotlin}}==

{{trans|Go}}

 

fun chowla(n: Int): Int {

}

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

 

{{output}}

=={{header|Lua}}==

{{trans|D}}

local sum = 0

local i = 2

end

 

{{out}}

<pre>chowla(1) = 0

=={{header|MAD}}==

{{trans|C}}

INTERNAL FUNCTION(N)

DONE PRINT FORMAT PRFCNT, COUNT, LIMIT

{{out}}

<pre>CHOWLA( 1) = 0

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

 

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

Chowla[0 | 1] := 0

Chowla[n_] := DivisorSigma[1, n] - 1 - n

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

{{out}}

<pre>25

=={{header|Nim}}==

{{trans|C}}

import strutils

 

k = kk + 1

kk += k

{{out}}

<pre>

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

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

 

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

<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 &lt;= %,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}}

{{trans|Prolog}}

{{works with|Picat}}

table

chowla(1) = 0.

end,

printf("There are %d perfect numbers less than %d.\n", Count, Limit).

{{out}}

<pre>

 

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

 

{{trans|Visual Basic .NET}}

#DIM ALL

#COMPILER PBCC 6

CON.PRINT "press any key to exit program"

CON.WAITKEY$

{{out}}

<pre>chowla(1) = 0

=={{header|Prolog}}==

{{works with|SWI Prolog}}

chowla(1, 0).

chowla(2, 0).

length(Nums, PerfectCount),

format('There are ~D perfect numbers < ~D.\n', [PerfectCount, Limit]).

{{out}}

<pre>

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

=={{header|Racket}}==

 

 

(require racket/fixnum)

 

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

 

{{out}}

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

 

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

=={{header|Ruby}}==

{{trans|C}}

sum = 0

i = 2

end

 

{{out}}

<pre>chowla(1) = 0

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

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

 

 

@inlinable

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

}

 

{{out}}

{{works with|Visual Basic|6}}

{{trans|Visual Basic .NET}}

 

Private Declare Function AllocConsole Lib "kernel32.dll" () As Long

FreeConsole

 

{{out}}

<pre>chowla(1)=0

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

=={{header|Vlang}}==

{{trans|Go}}

if n < 1 {

panic("argument must be a positive integer")

}

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

 

{{out}}

{{libheader|Wren-fmt}}

{{libheader|Wren-math}}

import "./math" for Int, Nums

 

i = i + 1

}

 

{{out}}

 

=={{header|XPL0}}==

int N, Div, Sum, Quot;

[Div:= 2; Sum:= 0;

[IntOut(0, N); CrLf(0)];

];

 

{{out}}

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