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.