Perfect numbers: Difference between revisions
Rename Perl 6 -> Raku, alphabetize, minor clean-up
(→{{header|Python}}: Add relative timings) |
Thundergnat (talk | contribs) (Rename Perl 6 -> Raku, alphabetize, minor clean-up) |
||
Line 366:
{{Out}}
<lang AppleScript>{6, 28, 496, 8128}</lang>
=={{header|Arturo}}==
<lang arturo>divisors : @(n)-> filter 1..[n/2+1] -> n % & = 0
isPerfect : @(n)-> n = [sum|divisors n]
loop 2..10000 -> if [isPerfect &] => print</lang>
{{out}}
<pre>6
28
496
8128</pre>
=={{header|AutoHotkey}}==
Line 391 ⟶ 405:
Return true
}</lang>
=={{header|AWK}}==
Line 414 ⟶ 413:
496
8128</lang>
=={{header|Axiom}}==
{{trans|Mathematica}}
Line 679:
<lang clojure>(defn perfect? [n]
(= (reduce + (filter #(zero? (rem n %)) (range 1 n))) n))</lang>
=={{header|COBOL}}==
Line 807 ⟶ 747:
.
END FUNCTION perfect.</lang>
=={{header|CoffeeScript}}==
Optimized version, for fun.
<lang coffeescript>is_perfect_number = (n) ->
do_factors_add_up_to n, 2*n
do_factors_add_up_to = (n, desired_sum) ->
# We mildly optimize here, by taking advantage of
# the fact that the sum_of_factors( (p^m) * x)
# is (1 + ... + p^m-1 + p^m) * sum_factors(x) when
# x is not itself a multiple of p.
p = smallest_prime_factor(n)
if p == n
return desired_sum == p + 1
# ok, now sum up all powers of p that
# divide n
sum_powers = 1
curr_power = 1
while n % p == 0
curr_power *= p
sum_powers += curr_power
n /= p
# if desired_sum does not divide sum_powers, we
# can short circuit quickly
return false unless desired_sum % sum_powers == 0
# otherwise, recurse
do_factors_add_up_to n, desired_sum / sum_powers
smallest_prime_factor = (n) ->
for i in [2..n]
return n if i*i > n
return i if n % i == 0
# tests
do ->
# This is pretty fast...
for n in [2..100000]
console.log n if is_perfect_number n
# For big numbers, let's just sanity check the known ones.
known_perfects = [
33550336
8589869056
137438691328
]
for n in known_perfects
throw Error("fail") unless is_perfect_number(n)
throw Error("fail") if is_perfect_number(n+1)</lang>
{{Out}}
<pre>
> coffee perfect_numbers.coffee
6
28
496
8128
</pre>
=={{header|Common Lisp}}==
Line 983:
496 is perfect... True
</pre>
=={{header|Elena}}==
ELENA 4.x:
Line 1,074 ⟶ 1,075:
496 is perfect
8128 is perfect</pre>
=={{header|Factor}}==
Line 1,084 ⟶ 1,081:
: perfect? ( n -- ? ) [ divisors sum ] [ 2 * ] bi = ;</lang>
=={{header|FALSE}}==
<lang false>[0\1[\$@$@-][\$@$@$@$@\/*=[@\$@+@@]?1+]#%=]p:
45p;!." "28p;!. { 0 -1 }</lang>
=={{header|Forth}}==
Line 2,000 ⟶ 2,001:
let perf n = n = List.fold_left (+) 0 (List.filter (fun i -> n mod i = 0) (1 -- (n-1)))</lang>
=={{header|Oforth}}==
Line 2,183:
is_mersenne_prime($v + 1);
}</lang>
=={{header|Phix}}==
Line 2,570 ⟶ 2,539:
(filter perfect? (filter even? (range 1e5)))
;-> '(0 6 28 496 8128)</lang>
=={{header|Raku}}==
(formerly Perl 6)
Naive (very slow) version
<lang perl6>sub is-perf($n) { $n == [+] grep $n %% *, 1 .. $n div 2 }
# used as
put ((1..Inf).hyper.grep: {.&is-perf})[^4];</lang>
{{out}}
<pre>6 28 496 8128</pre>
Much, much faster version:
<lang perl6>my @primes = lazy (2,3,*+2 … Inf).grep: { .is-prime };
my @perfects = lazy gather for @primes {
my $n = 2**$_ - 1;
take $n * 2**($_ - 1) if $n.is-prime;
}
.put for @perfects[^12];</lang>
{{out}}
<pre>6
28
496
8128
33550336
8589869056
137438691328
2305843008139952128
2658455991569831744654692615953842176
191561942608236107294793378084303638130997321548169216
13164036458569648337239753460458722910223472318386943117783728128
14474011154664524427946373126085988481573677491474835889066354349131199152128</pre>
=={{header|REBOL}}==
Line 3,092 ⟶ 3,093:
<lang smalltalk>1 to: 9000 do: [ :p | (p isPerfect) ifTrue: [ p printNl ] ]</lang>
=={{header|Swift}}==
{{trans|Java}}
Line 3,175 ⟶ 3,177:
496
8128 </pre>
=={{header|VBScript}}==
<lang vb>Function IsPerfect(n)
| |||