Perfect numbers: Difference between revisions

{{trans|Python}}

 

V sum = 0

L(i) 1 .< n

L(i) 1..10000

I perf(i)

 

{{out}}

The only added optimization is the loop up to n/2 instead of n-1.

With 31 bit integers the limit is 2,147,483,647.

PERFECTN CSECT

USING PERFECTN,R13 prolog

PG DC CL12' ' buffer

YREGS

{{out}}

<pre>

Use of optimizations found in Rexx algorithms and use of packed decimal to have bigger numbers.

With 15 digit decimal integers the limit is 999,999,999,999,999.

PERFECPO CSECT

USING PERFECPO,R13 prolog

PW2 DS PL16

YREGS

{{out}}

<pre>

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program perfectNumber64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

<pre>

Perfect : 6

</pre>

=={{header|Action!}}==

DEFINE MAXNUM="10000"

CARD ARRAY pds(MAXNUM+1)

FI

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Perfect_numbers.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

Sum : Natural := 0;

begin

end loop;

return Sum = N;

 

=={{header|ALGOL 60}}==

{{works with|A60}}

begin

 

 

end

{{out}}

<pre>

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d]}}

INT sum :=1;

FOR f1 FROM 2 TO ENTIER ( sqrt(candidate)*(1+2*small real) ) WHILE

IF is perfect(i) THEN print((i, new line)) FI

OD

{{Out}}

<pre>

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

Based on the Algol 68 version.

% returns true if n is perfect, false otherwise %

% n must be > 0 %

% test isPerfect %

for n := 2 until 10000 do if isPerfect( n ) then write( n );

{{out}}

<pre>

===Functional===

{{Trans|JavaScript}}

 

-- perfect :: integer -> bool

end script

end if

{{Out}}

----

===Idiomatic===

====Sum of proper divisors====

if (n < 2) then return 0

set sum to 1

if (isPerfect(n)) then set end of output to n

end repeat

 

{{output}}

 

====Euclid====

-- All the known perfect numbers listed in Wikipedia end with either 6 or 28.

-- These endings are either preceded by odd digits or are the numbers themselves.

if (isPerfect(n)) then set end of output to n

end repeat

 

{{output}}

 

====Practical====

But since AppleScript can only physically manage seven of the known perfect numbers, they may as well be in a look-up list for maximum efficiency:

 

if (n > 1.37438691328E+11) then return missing value -- Too high for perfection to be determinable.

return (n is in {6, 28, 496, 8128, 33550336, 8.589869056E+9, 1.37438691328E+11})

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

 

/* ARM assembly Raspberry PI */

/***************************************************/

.include "../affichage.inc"

<pre>

Perfect : 6

</pre>

=={{header|Arturo}}==

perfect?: $[n][ n = sum divisors n ]

loop 2..1000 'i [

if perfect? i -> print i

 

=={{header|AutoHotkey}}==

This will find the first 8 perfect numbers.

If isMersennePrime(A_Index + 1)

res .= "Perfect number: " perfectNum(A_Index + 1) "`n"

Return false

Return true

 

=={{header|AWK}}==

BEGIN{for(i=1;i<10000;i++)if(perf(i))print i}'

6

28

496

 

=={{header|Axiom}}==

{{trans|Mathematica}}

Using the interpreter, define the function:

Alternatively, using the Spad compiler:

TestPackage() : withma

perfect?: Integer -> Boolean

add

import IntegerNumberTheoryFunctions

 

Examples (testing 496, testing 128, finding all perfect numbers in 1...10000):

perfect? 128

{{Out}}

false

 

=={{header|BASIC}}==

{{works with|QuickBasic|4.5}}

sum = 0

for i = 1 to n - 1

perf = 0

END IF

 

 

==={{header|BASIC256}}===

{{trans|FreeBASIC}}

function isPerfect(n)

if (n < 2) or (n mod 2 = 1) then return False

next i

end

 

 

==={{header|IS-BASIC}}===

110 FOR X=1 TO 10000

120 IF PERFECT(X) THEN PRINT X;

190 NEXT

200 LET PERFECT=N=S

 

==={{header|Sinclair ZX81 BASIC}}===

Call this subroutine and it will (eventually) return <tt>PERFECT</tt> = 1 if <tt>N</tt> is perfect or <tt>PERFECT</tt> = 0 if it is not.

2010 FOR F=1 TO N-1

2020 IF N/F=INT (N/F) THEN LET SUM=SUM+F

2030 NEXT F

2040 LET PERFECT=SUM=N

 

==={{header|True BASIC}}===

FUNCTION perf(n)

IF n < 2 or ramainder(n,2) = 1 then LET perf = 0

PRINT "Presione cualquier tecla para salir"

END

 

=={{header|BBC BASIC}}==

===BASIC version===

IF FNperfect(n%) PRINT n%

NEXT

NEXT

IF I% = SQR(N%) S% += I%

{{Out}}

<pre>

===Assembler version===

{{works with|BBC BASIC for Windows}}

[OPT 2 :.S% xor edi,edi

.perloop mov eax,ebx : cdq : div ecx : or edx,edx : loopnz perloop : inc ecx

IF B% = USRS% PRINT B%

NEXT

{{Out}}

<pre>

 

=={{header|Bracmat}}==

= sum i

. 0:?sum

& (perf$!n&out$!n|)

)

{{Out}}

<pre>6

 

=={{header|Burlesque}}==

 

 

 

=={{header|C}}==

{{trans|D}}

#include "math.h"

 

 

return 0;

Using functions from [[Factors of an integer#Prime factoring]]:

{

int j;

return 0;

 

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

{{trans|C++}}

{

Console.WriteLine("Perfect numbers from 1 to 33550337:");

 

return sum == num ;

===Version using Lambdas, will only work from version 3 of C# on===

{

Console.WriteLine("Perfect numbers from 1 to 33550337:");

{

return Enumerable.Range(1, num - 1).Sum(n => num % n == 0 ? n : 0 ) == num;

 

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

{{works with|gcc}}

using namespace std ;

 

return 0 ;

}

 

=={{header|Clojure}}==

(if (< n 4)

[1]

 

(defn perfect? [n]

 

{{trans|Haskell}}

(->> (for [i (range 1 n)] :when (zero? (rem n i))] i)

(reduce +)

 

===Functional version===

 

=={{header|COBOL}}==

{{works with|Visual COBOL}}

main.cbl:

IDENTIFICATION DIVISION.

GOBACK

.

 

perfect.cbl:

FUNCTION-ID. perfect.

GOBACK

.

 

=={{header|CoffeeScript}}==

Optimized version, for fun.

do_factors_add_up_to n, 2*n

for n in known_perfects

throw Error("fail") unless is_perfect_number(n)

{{Out}}

<pre>

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

{{trans|Haskell}}

 

=={{header|D}}==

===Functional Version===

 

bool isPerfectNumber1(in uint n) pure nothrow

void main() {

iota(1, 10_000).filter!isPerfectNumber1.writeln;

{{out}}

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

===Faster Imperative Version===

{{trans|Algol}}

 

bool isPerfectNumber2(in int n) pure nothrow {

void main() {

10_000.iota.filter!isPerfectNumber2.writeln;

{{out}}

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

=={{header|Dart}}==

=== Explicit Iterative Version ===

* Function to test if a number is a perfect number

* A number is a perfect number if it is equal to the sum of all its divisors

// We return the test if n is equal to sumOfDivisors

return n == sumOfDivisors;

 

=== Compact Version ===

{{trans|Julia}}

 

In either case, if we test to find all the perfect numbers up to 1000, we get:

{{out}}

<pre>6

=={{header|Dyalect}}==

 

var sum = 0

for i in 1..<num {

print("\(x) is perfect")

}

 

=={{header|E}}==

def isPerfectNumber(x :int) {

var sum := 0

}

return sum <=> x

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

=={{header|Elena}}==

ELENA 4.x:

import system'math;

import extensions;

console.readChar()

{{out}}

<pre>

 

=={{header|Elixir}}==

def is_perfect(1), do: false

def is_perfect(n) when n > 1 do

end

 

 

{{out}}

 

=={{header|Erlang}}==

 

=={{header|ERRE}}==

 

PROCEDURE PERFECT(N%->OK%)

IF OK% THEN PRINT(N%)

END FOR

{{Out}}

<pre>

 

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

 

{{Out}}

<pre>6 is perfect

 

=={{header|Factor}}==

IN: rosettacode.perfect-numbers

 

 

=={{header|FALSE}}==

 

=={{header|Forth}}==

1

over 2/ 1+ 2 ?do

over i mod 0= if i + then

loop

 

=={{header|Fortran}}==

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

LOGICAL :: isPerfect

INTEGER, INTENT(IN) :: n

END DO

IF (factorsum == n) isPerfect = .TRUE.

 

=={{header|FreeBASIC}}==

{{trans|C (with some modifications)}}

 

Function isPerfect(n As Integer) As Boolean

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Frink}}==

 

{{out}}

 

=={{header|FunL}}==

 

 

{{out}}

 

=={{header|GAP}}==

 

=={{header|Go}}==

 

 

import "fmt"

}

 

{{Out}}

<pre>

=={{header|Groovy}}==

Solution:

n > 4 && (n == (2..Math.sqrt(n)).findAll { n % it == 0 }.inject(1) { factorSum, i -> factorSum += i + n/i })

Test program:

{{Out}}

<pre>6

 

=={{header|Haskell}}==

 

Create a list of known perfects:

(\x -> (2 ^ x - 1) * (2 ^ (x - 1))) <$>

filter (\x -> isPrime x && isPrime (2 ^ x - 1)) maybe_prime

main = do

mapM_ print $ take 10 perfect

 

 

or, restricting the search space to improve performance:

isPerfect n =

let lows = filter ((0 ==) . rem n) [1 .. floor (sqrt (fromIntegral n))]

 

main :: IO ()

{{Out}}

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

 

=={{header|HicEst}}==

IF( perfect(i) ) WRITE() i

ENDDO

ENDDO

perfect = sum == n

 

=={{header|Icon}} and {{header|Unicon}}==

limit := \arglist[1] | 100000

write("Perfect numbers from 1 to ",limit,":")

end

 

 

{{libheader|Icon Programming Library}} [http://www.cs.arizona.edu/icon/library/src/procs/factors.icn Uses divisors from factors]

 

=={{header|J}}==

 

Examples of use, including extensions beyond those assumptions:

1

I. is_perfect i. 100000

0 0 0 0 0 0 0 0 1 0

is_perfect 191561942608236107294793378084303638130997321548169216x

 

More efficient version based on [http://jsoftware.com/pipermail/programming/2014-June/037695.html comments] by Henry Rich and Roger Hui (comment train seeded by Jon Hough).

 

=={{header|Java}}==

int sum= 0;

for(int i= 1;i < n;i++){

}

return sum == n;

Or for arbitrary precision:[[Category:Arbitrary precision]]

 

public static boolean perf(BigInteger n){

}

return sum.equals(n);

 

=={{header|JavaScript}}==

 

{{trans|Java}}

{

var sum = 1, i, sqrt=Math.floor(Math.sqrt(n));

if (is_perfect(i))

print(i);

 

{{Out}}

Naive version (brute force)

 

 

function perfect(n) {

return range(nFrom, nTo).filter(perfect);

 

 

Output:

 

 

Much faster (more efficient factorisation)

 

 

function perfect(n) {

return range(nFrom, nTo).filter(perfect)

 

 

Output:

 

 

Note that the filter function, though convenient and well optimised, is not strictly necessary.

(Monadic return/inject for lists is simply lambda x --> [x], inlined here, and fail is [].)

 

 

// MONADIC CHAIN (bind) IN LIEU OF FILTER

}

 

 

Output:

 

 

====ES6====

 

const main = () =>

enumFromTo(1, 10000).filter(perfect);

// MAIN ---

return main();

 

{{Out}}

 

=={{header|jq}}==

def is_perfect:

. as $in

 

# Example:

{{Out}}

$ jq -n -f is_perfect.jq

{{works with|Julia|0.6}}

 

perfects(n::Integer) = filter(isperfect, 1:n)

 

 

{{out}}

=={{header|K}}==

{{trans|J}}

perfect 33550336

1

(0 0 0 0 0 0 1 0 0 0

0 0 0 0 0 0 0 0 0 0

 

=={{header|Kotlin}}==

{{trans|C}}

 

fun isPerfect(n: Int): Boolean = when {

println("The first five perfect numbers are:")

for (i in 2 .. 33550336) if (isPerfect(i)) print("$i ")

 

{{out}}

 

=={{header|Lasso}}==

define isPerfect(n::integer) => {

with x in generateSeries(1, 10000)

where isPerfect(#x)

{{Out}}

 

=={{header|Liberty BASIC}}==

if perfect( n) =1 then print n; " is perfect."

next n

perfect =0

end if

 

=={{header|Lingo}}==

sum = 1

cnt = n/2

end repeat

return sum=n

 

=={{header|Logo}}==

output equal? :n apply "sum filter [equal? 0 modulo :n ?] iseq 1 :n/2

 

=={{header|Lua}}==

local sum = 0

for i = 1, x-1 do

end

return sum == x

 

=={{header|M2000 Interpreter}}==

Module PerfectNumbers {

Function Is_Perfect(n as decimal) {

PerfectNumbers

 

{{out}}

 

=={{header|M4}}==

`ifelse($#,0,``$0'',

`ifelse(eval($2<=$3),1,

for(`x',`2',`33550336',

`ifelse(isperfect(x),1,`x

 

=={{header|MAD}}==

 

R FUNCTION THAT CHECKS IF NUMBER IS PERFECT

PRINT COMMENT $ $

END OF PROGRAM

 

{{out}}

 

=={{header|Maple}}==

isperfect(6);

 

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

Custom function:

Examples (testing 496, testing 128, finding all perfect numbers in 1...10000):

PerfectQ[128]

gives back:

False

 

=={{header|MATLAB}}==

Standard algorithm:

total = 0;

for k = 1:n-1

end

perf = total == n;

Faster algorithm:

if n < 2

perf = false;

perf = total == n;

end

 

=={{header|Maxima}}==

infix("..")$

 

 

sublist(1 .. 10000, perfectp);

 

=={{header|MAXScript}}==

(

local sum = 0

)

sum == n

 

=={{header|Microsoft Small Basic}}==

{{trans|BBC BASIC}}

For n = 2 To 10000 Step 2

VerifyIfPerfect()

EndIf

EndSub

 

=={{header|Modula-2}}==

{{trans|BBC BASIC}}

{{works with|ADW Modula-2|any (Compile with the linker option ''Console Application'').}}

MODULE PerfectNumbers;

 

END;

END PerfectNumbers.

 

=={{header|Nanoquery}}==

{{trans|Python}}

sum = 0

for i in range(1, n - 1)

end

return sum = n

 

=={{header|Nim}}==

 

proc isPerfect(n: int): bool =

for n in 2..10_000:

if n.isPerfect:

 

{{out}}

 

=={{header|Objeck}}==

class Test {

function : Main(args : String[]) ~ Nil {

}

}

 

=={{header|OCaml}}==

let sum = ref 0 in

for i = 1 to n-1 do

sum := !sum + i

done;

Functional style:

let rec (--) a b =

if a > b then

a :: (a+1) -- b

 

 

=={{header|Oforth}}==

 

 

{{out}}

 

=={{header|ooRexx}}==

loop i = 1 to 10000

if perfectNumber(i) then say i "is a perfect number"

end

 

{{out}}

<pre>6 is a perfect number

 

=={{header|Oz}}==

fun {IsPerfect N}

fun {IsNFactor I} N mod I == 0 end

in

{Show {Filter {List.number 1 10000 1} IsPerfect}}

 

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

Uses built-in method. Faster tests would use the LL test for evens and myriad results on OPNs otherwise.

Show perfect numbers

if(isprime(2^p-1),

Faster with Lucas-Lehmer test

while(p<2281,

if(isprime(p),

if(s==0 || p==2,

print("(2^"p"-1)2^("p"-1)=\t"n1*n"\n")));

{{Out}}

<pre>(2^2-1)2^(2-1)= 6

 

=={{header|Pascal}}==

 

function isPerfect(number: longint): boolean;

if isPerfect(candidate) then

writeln (candidate, ' is a perfect number.');

{{Out}}

<pre>

=={{header|Perl}}==

=== Functions ===

my $n = shift;

my $sum = 0;

}

return $sum == $n;

Functional style:

 

sub perf {

my $n = shift;

$n == sum(0, grep {$n % $_ == 0} 1..$n-1);

=== Modules ===

The functions above are terribly slow. As usual, this is easier and faster with modules. Both ntheory and Math::Pari have useful functions for this.

{{libheader|ntheory}}

A simple predicate:

Use this naive method to show the first 5. Takes about 15 seconds:

for (1..33550336) {

print "$_\n" if divisor_sum($_) == 2*$_;

Or we can be clever and look for 2^(p-1) * (2^p-1) where 2^p -1 is prime. The first 20 takes about a second.

use bigint;

forprimes {

my $n = 2**$_ - 1;

print "$_\t", $n * 2**($_-1),"\n" if is_prime($n);

{{out}}

<pre>

 

We can speed this up even more using a faster program for printing the large results, as well as a faster primality solution. The first 38 in about 1 second with most of the time printing the large results. Caveat: this goes well past the current bound for odd perfect numbers and does not check for them.

use Math::GMP qw/:constant/;

forprimes {

print "$_\t", (2**$_-1)*2**($_-1),"\n" if is_mersenne_prime($_);

 

In addition to generating even perfect numbers, we can also have a fast function which returns true when a given even number is perfect:

 

sub is_even_perfect {

($m >> $v) == 1 || return;

is_mersenne_prime($v + 1);

 

=={{header|Phix}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">is_perfect</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</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: #000000;">1</span><span style="color: #0000FF;">))=</span><span style="color: #000000;">n</span>

<span style="color: #008080;">if</span> <span style="color: #000000;">is_perfect</span><span style="color: #0000FF;">(</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">i</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

{{out}}

<pre>

=== gmp version ===

{{libheader|Phix/mpfr}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #000080;font-style:italic;">-- demo\rosetta\Perfect_numbers.exw (includes native version above)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #000000;">n</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">mpz_free</span><span style="color: #0000FF;">(</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|PHP}}==

{{trans|C++}}

{

$sum = 0;

if(is_perfect($num))

echo $num . PHP_EOL;

 

=={{header|Picat}}==

===Simple divisors/1 function===

First is the slow <code>perfect1/1</code> that use the simple divisors/1 function:

println(perfect1=[I : I in 1..10_000, perfect1(I)]),

nl.

perfect1(N) => sum(divisors(N)) == N.

 

{{out}}

===Using formula for perfect number candidates===

The formula for perfect number candidates is: 2^(p-1)*(2^p-1) for prime p. This is used to find some more perfect numbers in reasonable time. <code>perfect2/1</code> is a faster version of checking if a number is perfect.

println("Using the formula: 2^(p-1)*(2^p-1) for prime p"),

foreach(P in primes(32))

% I is not a divisor of N.

sum_divisors(I,N,Sum0,Sum) =>

 

{{out}}

 

The perfect numbers are printed only if they has < 80 digits, otherwise the number of digits are shown. The program stops when reaching a number with more than 100 000 digits. (Note: The major time running this program is getting the number of digits.)

ValidP = [2, 3, 5, 7, 13, 17, 19, 31, 61, 89, 107, 127, 521, 607,

1279, 2203, 2281, 3217, 4253, 4423, 9689, 9941, 11213,

end

end,

 

{{out}}

 

=={{header|PicoLisp}}==

(let C 0

(for I (/ N 2)

(and (=0 (% N I)) (inc 'C I)) )

 

(let (C 1 Stop (sqrt N))

(for (I 2 (<= I Stop) (inc I))

(=0 (% N I))

(inc 'C (+ (/ N I) I)) ) )

 

=={{header|PL/I}}==

declare n fixed;

declare sum fixed;

end;

return (sum=n);

 

==={{header|PL/I-80}}===

 

%replace

end isperfect;

 

 

{{out}}

=={{header|PL/M}}==

{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)

/* DIVISORS */

/* CP/M SYSTEM CALL AND I/O ROUTINES */

END;

END;

{{out}}

<pre>

{{Trans|Action!}}

{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)

/* DIVISORS */

/* CP/M SYSTEM CALL AND I/O ROUTINES */

END;

END;

{{out}}

<pre>

 

=={{header|PowerShell}}==

{

$sum=0

}

 

 

=={{header|Prolog}}==

===Classic approach===

Works with SWI-Prolog

Q is X / N,

( 0 is X mod N -> (Q = N -> TT1 is N + TT;

perfect_numbers(N, L) :-

numlist(2, N, LN),

 

===Faster method===

Since a perfect number is of the form 2^(n-1) * (2^n - 1), we can eliminate a lot of candidates by merely factoring out the 2s and seeing if the odd portion is (2^(n+1)) - 1.

perfect(N) :-

factor_2s(N, Chk, Exp),

N mod D =\= 0,

D2 is D + A, prime(N, D2, As).

{{out}}

<pre>

===Functional approach===

Works with SWI-Prolog and module lambda, written by <b>Ulrich Neumerkel</b> found there http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl

 

is_divisor(V, N) :-

%% f_compose_1(Pred1, Pred2, Pred1(Pred2)).

%

 

=={{header|PureBasic}}==

Protected summa, i=1, result=#False

Repeat

EndIf

ProcedureReturn result

 

=={{header|Python}}==

 

===Python: Procedural===

sum = 0

for i in range(1, n):

if n % i == 0:

sum += i

 

===Python: Optimised Procedural===

 

def factor2(n):

def perf4(n):

"Using most efficient prime factoring routine from: http://rosettacode.org/wiki/Factors_of_an_integer#Python"

 

===Python: Functional===

return n == sum(i for i in range(1, n) if n % i == 0)

 

print (

list(filter(perf2, range(1, 10001)))

 

 

 

 

from math import sqrt

 

if __name__ == '__main__':

{{Out}}

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

<code>factors</code> is defined at [http://rosettacode.org/wiki/Factors_of_an_integer#Quackery Factors of an integer].

 

 

[ factors -1 pluck dip sum = ] is perfect ( n --> n )

10000 times

[ i^ 1+ perfect if [ i^ 1+ echo cr ] ]

 

{{out}}

 

=={{header|R}}==

if (n==0|n==1) return(FALSE)

s <- seq (1,n-1)

# Usage - Warning High Memory Usage

is.perf(28)

 

=={{header|Racket}}==

(require math)

 

; filtering to only even numbers for better performance

(filter perfect? (filter even? (range 1e5)))

 

=={{header|Raku}}==

(formerly Perl 6)

Naive (very slow) version

 

# used as

{{out}}

<pre>6 28 496 8128</pre>

Much, much faster version:

my @perfects = lazy gather for @primes {

my $n = 2**$_ - 1;

}

 

 

{{out}}

 

=={{header|REBOL}}==

sum: 0

repeat i (n - 1) [

]

sum = n

 

=={{header|REXX}}==

===Classic REXX version of ooRexx===

This version is a '''Classic Rexx''' version of the '''ooRexx''' program as of 14-Sep-2013.

do i=1 to 10000 /*statement changed: LOOP ──► DO*/

if perfectNumber(i) then say i "is a perfect number"

if n//i==0 then sum=sum+i /*statement changed: sum += i */

end

'''output''' &nbsp; when using the default of 10000:

<pre>

This version is a '''Classic REXX''' version of the '''PL/I''' program as of 14-Sep-2013, &nbsp; a REXX &nbsp; '''say''' &nbsp; statement

<br>was added to display the perfect numbers. &nbsp; Also, an epilog was written for the re-worked function.

parse arg low high . /*obtain the specified number(s).*/

if high=='' & low=='' then high=34000000 /*if no arguments, use a range. */

if n//i==0 then sum=sum+i /*I is a factor of N, so add it.*/

end /*i*/

'''output''' &nbsp; when using the input defaults of: &nbsp; <tt> 1 &nbsp; 10000 </tt>

 

:::* &nbsp; testing bypasses the test of the first and last factors

:::* &nbsp; the &nbsp; ''corresponding factor'' &nbsp; is also used when a factor is found

parse arg low high . /*obtain optional arguments from the CL*/

if high=='' & low=="" then high=34000000 /*if no arguments, then use a range. */

s = s + j + x%j /* ··· add it and the other factor. */

end /*j*/ /*(above) is marginally faster. */

'''output''' &nbsp; when using the default inputs:

<pre>

===optimized using digital root===

This REXX version makes use of the fact that all &nbsp; ''known'' &nbsp; perfect numbers > 6 have a &nbsp; ''digital root'' &nbsp; of &nbsp; '''1'''.

parse arg low high . /*obtain the specified number(s). */

if high=='' & low=="" then high=34000000 /*if no arguments, then use a range. */

s = s + j + x%j /*··· add it and the other factor. */

end /*j*/ /*(above) is marginally faster. */

'''output''' &nbsp; is the same as the traditional version &nbsp; and is about &nbsp; '''5.3''' &nbsp; times faster &nbsp; (testing '''34,000,000''' numbers).

 

===optimized using only even numbers===

This REXX version uses the fact that all &nbsp; ''known'' &nbsp; perfect numbers are &nbsp; ''even''.

parse arg low high . /*obtain optional arguments from the CL*/

if high=='' & low=="" then high=34000000 /*if no arguments, then use a range. */

s = s + j + x%j /* ··· add it and the other factor. */

end /*j*/ /*(above) is marginally faster. */

'''output''' &nbsp; is the same as the traditional version &nbsp; and is about &nbsp; '''11.5''' &nbsp; times faster &nbsp; (testing '''34,000,000''' numbers).

 

===Lucas-Lehmer method===

This version uses memoization to implement a fast version of the Lucas-Lehmer test.

parse arg low high . /*obtain the optional arguments from CL*/

if high=='' & low=="" then high=34000000 /*if no arguments, then use a range. */

s=s + j + x%j /*··· add it and the other factor. */

end /*j*/ /*(above) is marginally faster. */

'''output''' &nbsp; is the same as the traditional version &nbsp; and is about &nbsp; '''75''' &nbsp; times faster &nbsp; (testing '''34,000,000''' numbers).

 

 

An integer square root function was added to limit the factorization of a number.

parse arg low high . /*obtain optional arguments from the CL*/

if high=='' & low=="" then high=34000000 /*No arguments? Then use a range. */

if x//j==0 then s=s+j+x%j /*J divisible by X? Then add J and X÷J*/

end /*j*/

'''output''' &nbsp; is the same as the traditional version &nbsp; and is about &nbsp; '''500''' &nbsp; times faster &nbsp; (testing '''34,000,000''' numbers). <br><br>

 

=={{header|Ring}}==

for i = 1 to 10000

if perfect(i) see i + nl ok

if sum = n return 1 else return 0 ok

return sum

 

=={{header|Ruby}}==

sum = 0

for i in 1...n

end

sum == n

Functional style:

n == (1...n).select {|i| n % i == 0}.inject(:+)

Faster version:

divisors = []

for i in 1..Integer.sqrt(n)

end

divisors.uniq.inject(:+) == 2*n

Test:

puts n if perf(n)

{{out}}

<pre>

===Fast (Lucas-Lehmer)===

Generate and memoize perfect numbers as needed.

 

def mersenne_prime_pow?(p)

p perfect?(13164036458569648337239753460458722910223472318386943117783728128)

p Time.now - t1

{{out}}

<pre>

 

=={{header|Run BASIC}}==

if perf(i) then print i;" ";

next i

next i

IF sum = n THEN perf = 1

{{Out}}

<pre>6 28 496 8128</pre>

 

=={{header|Rust}}==

fn main ( ) {

fn factor_sum(n: i32) -> i32 {

perfect_nums(10000);

}

 

=={{header|SASL}}==

Copied from the SASL manual, page 22:

|| The function which takes a number and returns a list of its factors (including one but excluding itself)

|| can be written

|| we can write the list of all perfect numbers as

perfects = { n <- 1... ; n = sum(factors n) }

 

=={{header|S-BASIC}}==

$lines

 

 

end

{{out}}

<pre>

 

=={{header|Scala}}==

 

'''or'''

 

(for (x <- 2 to n/2 if n % x == 0) yield x).sum + 1 == n

 

=={{header|Scheme}}==

(let loop ((i 1)

(sum 0))

(loop (+ i 1) (+ sum i)))

(else

 

=={{header|Seed7}}==

 

const func boolean: isPerfect (in integer: n) is func

end if;

end for;

{{Out}}

<pre>

 

=={{header|Sidef}}==

n.sigma == 2*n

}

for n in (1..10000) {

say n if is_perfect(n)

 

Alternatively, a more efficient check for even perfect numbers:

 

var square = (8*n + 1)

for n in (1..10000) {

say n if is_even_perfect(n)

 

{{out}}

 

=={{header|Simula}}==

BEGIN

INTEGER SUM;

SUM := SUM + I;

PERF := SUM = N;

 

=={{header|Slate}}==

[

(((2 to: n // 2 + 1) select: [| :m | (n rem: m) isZero])

inject: 1 into: #+ `er) = n

 

=={{header|Smalltalk}}==

 

"Translation of the C version; this is faster..."

inject: 1 into: [ :a :b | a + b ] ) = self

]

 

 

=={{header|Swift}}==

{{trans|Java}}

var sum = 0

for i in 1..<n {

println(i)

}

{{out}}

<pre>

 

=={{header|Tcl}}==

set sum 0

for {set i 1} {$i <= $n} {incr i} {

}

expr {$sum == 2*$n}

 

=={{header|Ursala}}==

#import nat

 

This test program applies the function to a list of the first five hundred natural

numbers and deletes the imperfect ones.

 

{{Out}}

<pre><6,28,496></pre>

{{trans|Phix}}

Using [[Factors_of_an_integer#VBA]], slightly adapted.

Application.Volatile

Dim i As Long

If is_perfect(i) Then Debug.Print i

Next i

<pre> 6

28

 

=={{header|VBScript}}==

IsPerfect = False

i = n - 1

 

WScript.StdOut.Write IsPerfect(CInt(WScript.Arguments(0)))

 

{{out}}

=={{header|Vlang}}==

{{trans|go}}

mut sum := i64(0)

for i := i64(1); i < n; i++ {

}

}

{{Out}}

<pre>

{{trans|D}}

Restricted to the first four perfect numbers as the fifth one is very slow to emerge.

if (n <= 2) return false

var tot = 1

i = i + 2 // there are no known odd perfect numbers

}

 

{{out}}

{{libheader|Wren-math}}

This makes use of the fact that all known perfect numbers are of the form <big> (2^''n'' - 1) × 2^{''n'' - 1}</big> where <big> (2^''n'' - 1)</big> is prime and finds the first seven perfect numbers instantly. The numbers are too big after that to be represented accurately by Wren.

 

var isPerfect = Fn.new { |n|

p = p + 1

}

 

{{out}}

 

=={{header|XPL0}}==

 

func Perfect(N); \Return 'true' if N is a perfect number

if Perfect(N) then [IntOut(0, N); CrLf(0)];

];

 

{{out}}

=={{header|Yabasic}}==

{{trans|True BASIC}}

sub isPerfect(n)

if (n < 2) or mod(n, 2) = 1 then return false : endif

print

end

 

 

=={{header|Zig}}==

const std = @import("std");

const expect = std.testing.expect;

expect(propersum(30) == 42);

}

{{Out}}

<pre>

=={{header|zkl}}==

{{trans|D}}

{{out}}

<pre>