Perfect numbers: Difference between revisions

Content added Content deleted
(add JavaScript)
m (Fixed lang tags.)
Line 11:
 
=={{header|Ada}}==
<lang ada>function Is_Perfect(N : Positive) return Boolean is▼
<lang ada>▼
▲function Is_Perfect(N : Positive) return Boolean is
Sum : Natural := 0;
begin
Line 21 ⟶ 20:
end loop;
return Sum = N;
end Is_Perfect;</lang>
</lang>▼
=={{header|ALGOL 68}}==
<lang algol68>PROC is perfect = (INT candidate)BOOL: (
INT sum :=1;
FOR f1 FROM 2 TO ENTIER ( sqrt(candidate)*(1+2*small real) ) WHILE
IF candidate MOD f1 = 0 THEN
sum +:= f1;
INT f2 = candidate OVER f1;
IF f2 > f1 THEN
sum +:= f2
FI
FI;
# WHILE # sum <= candidate DO
SKIP
OD;
sum=candidate
);
# test #
FOR i FROM 2 TO 33550336 DO
IF is perfect(i) THEN print((i, new line)) FI
OD</lang>
OD
Output:
<lang algol68> +6
+28
+496
+8128
+33550336</lang>
=={{header|AutoHotkey}}==
This will find the first 8 perfect numbers.
<lang ahkautohotkey>Loop, 30 {
Loop, 30 {
If isMersennePrime(A_Index + 1)
res .= "Perfect number: " perfectNum(A_Index + 1) "`n"
Line 76 ⟶ 73:
 
=={{header|AWK}}==
<lang awk>$ awk 'func perf(n){s=0;for(i=1;i<n;i++)if(n%i==0)s+=i;return(s==n)}▼
<lang awk>▼
▲$ awk 'func perf(n){s=0;for(i=1;i<n;i++)if(n%i==0)s+=i;return(s==n)}
BEGIN{for(i=1;i<10000;i++)if(perf(i))print i}'
6
Line 129 ⟶ 125:
 
return 0;
▲}</lang ada>
}
</lang>▼
 
=={{header|C++}}==
Line 154 ⟶ 149:
sum += i ;
return ( ( sum == 2 * number ) || ( sum - number == number ) ) ;
▲}</lang>
}
▲</lang>
 
=={{header|Clojure}}==
<lang lisp>(defn proper-divisors [n]▼
<lang clojure>
▲(defn proper-divisors [n]
(if (< n 4)
'(1)
Line 166 ⟶ 159:
(defn perfect? [n]
(== (reduce + (proper-divisors n)) n)
▲)</lang awk>
)
</lang>
 
=={{header|Common Lisp}}==
Line 176 ⟶ 168:
=={{header|D}}==
Based on the Algol version:
<lang d>import std.math: sqrt;
import std.math: sqrt;
 
bool perfect(int n) {
Line 200 ⟶ 191:
if (perfect(n))
printf("%d\n", n);
▲}</lang>
}
</lang>
 
=={{header|E}}==
Line 216 ⟶ 206:
 
=={{header|Erlang}}==
<lang erlang>is_perfect(X) ->
X == lists:sum([N || N <- lists:seq(1,X-1), X rem N == 0]).</lang>▼
is_perfect(X) ->
▲ X == lists:sum([N || N <- lists:seq(1,X-1), X rem N == 0]).
</lang>
 
=={{header|Forth}}==
<lang forth>: perfect? ( n -- ? )
1
over 2/ 1+ 2 ?do
over i mod 0= if i + then
loop
= ;</lang>
 
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<lang fortran> FUNCTION isPerfect(n)
LOGICAL :: isPerfect
INTEGER, INTENT(IN) :: n
INTEGER :: i, factorsum
 
isPerfect = .FALSE.
factorsum = 1
DO i = 2, INT(SQRT(REAL(n)))
IF(MOD(n, i) == 0) factorsum = factorsum + i + (n / i)
END DO
IF (factorsum == n) isPerfect = .TRUE.
END FUNCTION isPerfect</lang>
 
=={{header|Groovy}}==
Line 259 ⟶ 247:
8128</pre>
=={{header|Haskell}}==
<lang haskell>perf n = n == sum [i | i <- [1..n-1], n `mod` i == 0]</lang>
 
=={{header|J}}==
<lang j>is_perfect=: = [: +/ ((0=]|[)i.) # i.</lang>
The program defined above, like programs found here in other languages, assumes that the input will be a scalar positive integer.
 
Examples of use, including extensions beyond those assumptions:
<lang j> is_perfect 33550336
1
}.I. is_perfect"0 i. 10000
6 28 496 8128
 
] zero_through_twentynine =. i. 3 10
0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29
is_pos_int=: 0&< *. ]=>.
(is_perfect"0 *. is_pos_int) zero_through_twentynine
0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0</lang>
 
=={{header|Java}}==
Line 331 ⟶ 319:
 
=={{header|Logo}}==
<lang logo>to perfect? :n
to perfect? :n
output equal? :n apply "sum filter [equal? 0 modulo :n ?] iseq 1 :n/2
end</lang>
</lang>
 
=={{header|M4}}==
<lang M4>define(`for',
define(`for',
`ifelse($#,0,``$0'',
`ifelse(eval($2<=$3),1,
Line 357 ⟶ 342:
for(`x',`2',`33550336',
`ifelse(isperfect(x),1,`x
')')</lang>
</lang>
 
=={{header|Mathematica}}==
Custom function:
<lang Mathematica>PerfectQ[i_Integer] := Total[Divisors[i]] == 2 i</lang>
PerfectQ[i_Integer] := Total[Divisors[i]] == 2 i
</lang>
Examples (testing 496, testing 128, finding all perfect numbers in 1...10000):
<lang Mathematica>PerfectQ[496]
PerfectQ[496128]
Flatten[PerfectQ/@Range[10000]//Position[#,True]&]</lang>▼
PerfectQ[128]
▲ Flatten[PerfectQ/@Range[10000]//Position[#,True]&]
</lang>
gives back:
<lang Mathematica>True
False▼
True
{6,28,496,8128}</lang>▼
▲ False
▲ {6,28,496,8128}
</lang>
 
=={{header|MAXScript}}==
<prelang maxscript>fn isPerfect n =
(
local sum = 0
Line 390 ⟶ 368:
)
sum == n
)</prelang>
 
=={{header|OCaml}}==
Line 440 ⟶ 418:
 
=={{header|R}}==
<lang R>is.perf <- function(n){
is.perf <- function(n){
if (n==0|n==1) return(FALSE)
s <- seq (1,n-1)
Line 451 ⟶ 428:
# Usage - Warning High Memory Usage
is.perf(28)
sapply(c(6,28,496,8128,33550336),is.perf)</lang>
</lang>
=={{header|Ruby}}==
<lang ruby>def perf(n)
Line 480 ⟶ 456:
 
=={{header|Slate}}==
<lang slate>n@(Integer traits) isPerfect
n@(Integer traits) isPerfect
[
(((2 to: n // 2 + 1) select: [| :m | (n rem: m) isZero])
inject: 1 into: #+ `er) = n
].</lang>
</lang>
 
=={{header|Smalltalk}}==
Line 524 ⟶ 498:
 
=={{header|Ursala}}==
<lang Ursala>#import std
#import std
#import nat
 
Retrieved from "https://rosettacode.org/wiki/Perfect_numbers"