Abundant, deficient and perfect number classifications: Difference between revisions

These define three classifications of positive integers based on their   [[Proper divisors|proper divisors]].

 

*   [[Proper divisors]]

*   [[Amicable pairs]]

 

=={{header|11l}}==

{{trans|Kotlin}}

R I n < 2 {0} E sum((1 .. n I/ 2).filter(it -> (@n % it) == 0))

 

print(‘Deficient = ’deficient)

print(‘Perfect = ’perfect)

{{out}}

<pre>

For maximum compatibility, this program uses only the basic instruction set (S/360)

with 2 ASSIST macros (XDECO,XPRNT).

ABUNDEFI CSECT

USING ABUNDEFI,R13 set base register

XDEC DS CL12

REGEQU

{{out}}

<pre>

deficient=15043 perfect= 4 abundant= 4953

</pre>

 

[[http://rosettacode.org/wiki/Proper_divisors#Ada]].

 

 

procedure ADB_Classification is

Ada.Text_IO.New_Line;

Ada.Text_IO.Put_Line("====================");

 

{{out}}

 

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

 

 

 

 

<pre>

</pre>

 

=={{header|AutoHotkey}}==

{

m := A_index

 

esc::ExitApp

{{out}}

<pre>

=={{header|AWK}}==

works with GNU Awk 3.1.5 and with BusyBox v1.21.1

#!/bin/gawk -f

function sumprop(num, i,sum,root) {

print "Deficient: " deficient

}

 

{{out}}

=={{header|Batch File}}==

As batch files aren't particularly well-suited to increasingly large arrays of data, this code will chew through processing power.

@echo off

setlocal enabledelayedexpansion

 

exit /b %sumdivisers%

 

=={{header|Befunge}}==

This is not a particularly efficient implementation, so unless you're using a compiler, you can expect it to take a good few minutes to complete. But you can always test with a shorter range of numbers by replacing the 20000 (<tt>"2":*8*</tt>) near the start of the first line.

 

++\1-:1`#^_$:28*:*:*/\28*vv_^#<<<!%*:*:*82:-1\-1\<<<\+**:*:*82<+>*:*:**\2-!#+

v"There are "0\g00+1%*:*:<>28*:*:*/\28*:*:*/:0\`28*:*:**+-:!00g^^82!:g01\p01<

 

{{out}}

=={{header|Bracmat}}==

Two solutions are given. The first solution first decomposes the current number into a multiset of prime factors and then constructs the proper divisors. The second solution finds proper divisors by checking all candidates from 1 up to the square root of the given number. The first solution is a few times faster, because establishing the prime factors of a small enough number (less than 2^32 or less than 2^64, depending on the bitness of Bracmat) is fast.

& ( multiples

= prime multiplicity

& clk$:?t3

& out$(flt$(!t3+-1*!t2,2) sec)

Output:

<pre>deficient 15043 perfect 4 abundant 4953

 

=={{header|C}}==

#include<stdio.h>

#define de 0

return 0;

}

{{out}}

<pre>

</pre>

 

using System.Linq;

 

{

int abundant, deficient, perfect;

ClassifyNumbers.UsingDivision(20000, out abundant, out deficient, out perfect);

}

}

public static class ClassifyNumbers

{

public static void UsingSieve(int bound, out int abundant, out int deficient, out int perfect) {

//For very large bounds, this array can get big.

int[] sum = new int[bound + 1];

sum[i] += divisor;

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

}

}

public static void UsingDivision(int bound, out int abundant, out int deficient, out int perfect) {

int sum = Enumerable.Range(1, (i + 1) / 2)

}

}

<pre>

</pre>

 

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

#include <algorithm>

#include <vector>

std::cout << "Abundant : " << abundants.size( ) << std::endl ;

return 0 ;

{{out}}

<pre>Deficient : 15043

 

=={{header|Ceylon}}==

 

function divisors(Integer int) =>

print("perfect: ``counts[equal] else "none"``");

print("abundant: ``counts[larger] else "none"``");

{{out}}

<pre>

 

=={{header|Clojure}}==

[n]

(let [divs (filter #(zero? (mod n %)) (range 1 n))

{:perfect (count (filter #(= % :perfect) classes))

:abundant (count (filter #(= % :abundant) classes))

 

Example:

 

;=> {:perfect 4,

; :abundant 4953,

 

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

 

(let ((divisor-sum (sum-divisors n)))

(cond ((< divisor-sum n) :deficient)

:count (eq class :perfect) :into perfect

:count (eq class :abundant) :into abundant

 

Output:

4

4953</pre>

 

=={{header|D}}==

import std.stdio, std.algorithm, std.range;

 

//iota(1, 1 + rangeMax).map!classify.hashGroup.writeln;

iota(1, 1 + rangeMax).map!classify.array.sort().group.writeln;

{{out}}

<pre>[Tuple!(Class, uint)(deficient, 15043), Tuple!(Class, uint)(perfect, 4), Tuple!(Class, uint)(abundant, 4953)]</pre>

 

=={{header|Dyalect}}==

{{trans|C#}}

 

var (a, d, p) = (0, 0, 0)

for divisor in 1..(bound / 2) {

var i = divisor + divisor

}

}

(abundant: a, deficient: d, perfect: p)

}

 

}

}

}

var (a, d, p) = (0, 0, 0)

for i in 1..20000 {

var sum = ( 1 .. ((i + 1) / 2) )

if sum < i {

d += 1

}

}

(abundant: a, deficient: d, perfect: p)

}

func out(res) {

print("Abundant: \(res.abundant), Deficient: \(res.deficient), Perfect: \(res.perfect)");

}

out( sieve(20000) )

 

{{out}}

<pre>Abundant: 4953, Deficient: 15043, Perfect: 4

Abundant: 4953, Deficient: 15043, Perfect: 4</pre>

 

=={{header|EchoLisp}}==

(lib 'math) ;; sum-divisors function

 

deficient 15043

perfect 4

 

=={{header|Ela}}==

{{trans|Haskell}}

 

 

divisors n = filter ((0 ==) << (n `mod`)) [1 .. (n `div` 2)]

printRes "deficient: " LT

printRes "perfect: " EQ

 

{{out}}

perfect: 4

abundant: 4953</pre>

=={{header|Elena}}==

{{trans|C#}}

 

classifyNumbers(int bound, ref int abundant, ref int deficient, ref int perfect)

int[] sum := new int[](bound + 1);

{

{

sum[i] := sum[i] + divisor

};

{

int t := sum[i];

classifyNumbers(20000, ref abundant, ref deficient, ref perfect);

console.printLine("Abundant: ",abundant,", Deficient: ",deficient,", Perfect: ",perfect)

{{out}}

<pre>

 

=={{header|Elixir}}==

def divisors(1), do: []

def divisors(n), do: [1 | divisors(2,n,:math.sqrt(n))] |> Enum.sort

end

end)

 

{{out}}

 

=={{header|Erlang}}==

-module(properdivs).

-export([divs/1,sumdivs/1,class/1]).

divs(0) -> [];

divs(1) -> [];

divisors(1,N) ->

divisors(2,N,math:sqrt(N),[1]).

divisors(K,N,_Q,L) when N rem K =/= 0 ->

divisors(K+1,N,_Q,L);

class(D,P,A,Sum,Acc,L) when Acc > Sum ->

class(D+1,P,A,sumdivs(Acc+1),Acc+1,L).

 

{{out}}

 

The above divisors method was slightly rewritten to satisfy the observation below but preserve the different programming style.

 

===Erlang 2===

The version above is not tail-call recursive, and so cannot classify large ranges. Here is a more optimal solution.

-module(proper_divisors).

-export([classify_range/2]).

proper_divisors(I, L, N, A) ->

proper_divisors(I+1, L, N, [N div I, I|A]).

{{output}}

<pre>

</pre>

 

let mutable a=0

let mutable b=0

printfn "perfect %i"d

printfn "abundant %i"e

 

An immutable solution.

let deficient, perfect, abundant = 0,1,2

 

|> List.zip [ "deficient"; "perfect"; "abundant" ]

|> List.iter (fun (label, count) -> printfn "%s: %d" label count)

 

=={{header|Factor}}==

USING: fry math.primes.factors math.ranges ;

: psum ( n -- m ) divisors but-last sum ;

[ +eq+ pcount "Perfect: " write . ]

[ +gt+ pcount "Abundant: " write . ] tri

{{out}}

<pre>

=={{header|Forth}}==

{{works with|Gforth|0.7.3}}

: SLOT ( x y -- 0|1|2) OVER OVER < -ROT > - 1+ ;

: CLASSIFY ( n -- n') \ 0 == deficient, 1 == perfect, 2 == abundant

." Perfect : " [ COUNTS 1 CELLS + ]L @ . CR

." Abundant : " [ COUNTS 2 CELLS + ]L @ . CR ;

{{out}}

<pre>Deficient : 15043

Abundant 4953

 

MODULE FACTORSTUFF !This protocol evades the need for multiple parameters, or COMMON, or one shapeless main line...

Concocted by R.N.McLean, MMXV.

WRITE (6,*) "Abundant ",COUNT(TEST .GT. 0) !Alternatively, make one pass with three counts.

END !Done.

 

=={{header|FreeBASIC}}==

' FreeBASIC v1.05.0 win64

 

Sleep

End

 

{{out}}

 

=={{header|Frink}}==

d = new dict

for n = 1 to 20000

println["Perfect: " + d@0]

println["Abundant: " + d@1]

{{out}}

<pre>

Abundant: 4953

</pre>

=={{header|GFA Basic}}==

 

num_deficient%=0

num_perfect%=0

RETURN sum%

ENDFUNC

 

Output is:

 

=={{header|Go}}==

 

import "fmt"

fmt.Printf("There are %d abundant numbers between 1 and 20000\n", a)

fmt.Printf("There are %d perfect numbers between 1 and 20000\n", p)

 

{{out}}

=====Solution:=====

Uses the "factorize" closure from [[Factors of an integer]]

def n = factors.pop()

def fSum = factors.sum()

map

}

{{out}}

<pre>deficient=15043

perfect=4

abundant=4953</pre>

=={{header|Haskell}}==

divisors n = filter ((0 ==) . (n `mod`)) [1 .. (n `div` 2)]

 

printRes "deficient: " LT

printRes "perfect: " EQ

{{out}}

<pre>deficient: 15043

perfect: 4

abundant: 4953</pre>

 

=={{header|J}}==

[[Proper divisors#J|Supporting implementation]]:

 

 

We can subtract the sum of a number's proper divisors from itself to classify the number:

 

 

Except, we are only concerned with the sign of this difference:

 

 

Also, we do not care about the individual classification but only about how many numbers fall in each category:

 

 

So: 15043 deficient, 4 perfect and 4953 abundant numbers in this range.

How do we know which is which? We look at the unique values (which are arranged by their first appearance, scanning the list left to right):

 

 

The sign of the difference is negative for the abundant case - where the sum is greater than the number. And we rely on order being preserved in sequences (this happens to be a fundamental property of computer memory, also).

=={{header|Java}}==

{{works with|Java|8}}

 

public class NumberClassifications {

return LongStream.rangeClosed(1, (n + 1) / 2).filter(i -> n != i && n % i == 0).sum();

}

 

<pre>Deficient: 15043

 

===ES5===

for (var ds=0, d=1, e=n/2+1; d<e; d+=1) if (n%d==0) ds+=d

dpa[ds<n ? 0 : ds==n ? 1 : 2]+=1

}

'''Or:'''

for (var ds=1, d=2, e=Math.sqrt(n); d<e; d+=1) if (n%d==0) ds+=d+n/d

if (n%e==0) ds+=e

dpa[ds<n ? 0 : ds==n ? 1 : 2]+=1

}

'''Or:'''

var ps = {2:true, 3:true}

next: for (var n=5, i=2; n<=t; n+=i, i=6-i) {

dpa[ds<n ? 0 : ds==n ? 1 : 2]+=1

}

{{output}}

<pre>Deficient:15043, Perfect:4, Abundant:4953</pre>

===ES6===

{{Trans|Haskell}}

'use strict';

 

.length.toString())

.join('\n');

 

{{Out}}

perfect: 4

abundant: 4953</pre>

 

=={{header|Jsish}}==

From Javascript ES5 entry.

 

function classifyDPA(stop:number, start:number=0, step:number=1):array {

var dpa = [1, 0, 0];

 

var dpa = classifyDPA(20000, 2);

 

{{out}}

<code>divisorsum</code> calculates the sum of aliquot divisors. It uses <code>pcontrib</code> to calculate the contribution of each prime factor.

 

function pcontrib(p::Int64, a::Int64)

n = one(p)

dsum -= n

end

Perhaps <code>pcontrib</code> could be made more efficient by caching results to avoid repeated calculations.

 

Use a three element array, <code>iclass</code>, rather than three separate variables to tally the classifications. Take advantage of the fact that the sign of <code>divisorsum(n) - n</code> depends upon its class to increment <code>iclass</code>. 1 is a difficult case, it is deficient by convention, so I manually add its contribution and start the accumulation with 2. All primes are deficient, so I test for those and tally accordingly, bypassing <code>divisorsum</code>.

 

const L = 2*10^4

iclasslabel = ["Deficient", "Perfect", "Abundant"]

println(" ", iclasslabel[i], ", ", iclass[i])

end

 

{{out}}

</code>

 

 

 

{{out}}

 

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

fun sumProperDivisors(n: Int) =

println("Perfect = $perfect")

println("Abundant = $abundant")

 

{{out}}

Perfect = 4

Abundant = 4953

</pre>

 

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

print "ROSETTA CODE - Abundant, deficient and perfect number classifications"

print

next y

end function

{{out}}

<pre>

 

=={{header|Lua}}==

if n < 2 then return 0 end

local sum, sr = 1, math.sqrt(n)

print("Abundant:", a)

print("Deficient:", d)

{{out}}

<pre>Abundant: 4953

Deficient: 15043

Perfect: 4</pre>

 

=={{header|Maple}}==

if evalb(NumberTheory:-SumOfDivisors(n) < 2*n) then

return "Deficient";

num_list := map(classify_number, [seq(1..k)]);

return Statistics:-Tally(num_list)

 

{{out}}<pre>["Perfect" = 4, "Abundant" = 4953, "Deficient" = 15043]</pre>

 

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

 

StringJoin[

Table[classify[n], {n, 20000}]] /. {-1 -> "deficient: ",

0 -> " perfect: ", 1 -> " abundant: "}] /.

 

{{out}}<pre>deficient: 15043 perfect: 4 abundant: 4953</pre>

 

=={{header|MatLab}}==

abundant=0; deficient=0; perfect=0; p=[];

for N=2:20000

end

disp(table([deficient;perfect;abundant],'RowNames',{'Deficient','Perfect','Abundant'},'VariableNames',{'Quantities'}))

{{out}}

<pre>

Abundant 4953

</pre>

=={{header|ML}}==

==={{header|mLite}}===

(number, count, limit, remainder, results) where (count > limit) = rev results

| (number, count, limit, remainder, results) =

print "Perfect numbers between 1 and 20000: ";

println ` fold (op +, 0) ` map ((fn n = if n then 1 else 0) o is_perfect) one_to_20000;

Output

<pre>

 

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

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

WriteString(buf);

ReadChar

 

=={{header|Nim}}==

proc sumProperDivisors(number: int) : int =

if number < 2 : return 0

echo " Perfect = " , perfect

echo " Abundant = " , abundant

 

{{out}}

=={{header|Oforth}}==

 

 

Integer method: properDivs -- []

"Perfects :" . perfect .cr

"Abundant :" . .cr

 

{{out}}

 

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

{

my(v=[0,0,0],t);

v;

}

{{out}}

<pre>%1 = [15043, 4, 4953]</pre>

 

=={{header|Pascal}}==

{$IFDEF FPC}

{$ENDIF}

uses

type

 

var

repeat

end;

 

 

 

 

</pre>

 

1 is classified as a [[wp:Deficient_number|deficient number]], 6 is a [[wp:Perfect_number|perfect number]], 12 is an [[wp:Abundant_number|abundant number]]. As per task spec, also showing the totals for the first 20,000 numbers.

 

my @type = <Perfect Abundant Deficient>;

say join "\n", map { sprintf "%2d %s", $_, $type[divisor_sum($_)-$_ <=> $_] } 1..12;

my %h;

$h{divisor_sum($_)-$_ <=> $_}++ for 1..20000;

{{out}}

<pre> 1 Deficient

===Not using a module===

Everything as above, but done more slowly with <code>div_sum</code> providing sum of proper divisors.

my($n) = @_;

my $sum = 0;

my %h;

$h{div_sum($_) <=> $_}++ for 1..20000;

 

=={{header|Phix}}==

{{out}}

<pre>

deficient:15043, perfect:4, abundant:4953

</pre>

 

=={{header|PicoLisp}}==

(if (assoc Key (val Var))

(con @ (inc (cdr @)))

((> @@ I) (inc 'A)) ) )

(println D P A) ) )

{{Output}}

<pre>

 

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

apd: Proc Options(main);

p9a=time();

End;

 

{{out}}

<pre>In the range 1 - 20000

0.560 seconds elapsed

</pre>

 

=={{header|PowerShell}}==

{{works with|PowerShell|2}}

function Get-ProperDivisorSum ( [int]$N )

{

"Perfect : $Perfect"

"Abundant : $Abundant"

{{out}}

<pre>

===As a single function===

Using the <code>Get-ProperDivisorSum</code> as a helper function in an advanced function:

function Get-NumberClassification

{

}

}

1..20000 | Get-NumberClassification

{{Out}}

<pre>

4953 Abundant {12, 18, 20, 24...}

</pre>

 

=={{header|Prolog}}==

proper_divisors(1, []) :- !.

proper_divisors(N, [1|L]) :-

[LD, LA, LP]),

format("took ~f seconds~n", [Dur]).

{{out}}

<pre>

 

=={{header|PureBasic}}==

EnableExplicit

 

CloseConsole()

EndIf

 

{{out}}

 

=={{header|Python}}==

Importing [[Proper_divisors#Python:_From_prime_factors|Proper divisors from prime factors]]:

>>> from collections import Counter

>>>

>>> classes.most_common()

[('deficient', 15043), ('abundant', 4953), ('perfect', 4)]

 

{{out}}

4 perfect numbers

</pre>

 

=={{header|R}}==

{{Works with|R|3.3.2 and above}}

 

# Abundant, deficient and perfect number classifications. 12/10/16 aev

require(numbers);

}

propdivcls(20000);

 

{{Output}}

=={{header|Racket}}==

 

(require math)

(define (proper-divisors n) (drop-right (divisors n) 1))

(hash-set! t c (add1 (hash-ref t c 0))))

(printf "The range between 1 and ~a has:\n" N)

 

{{out}}

4953 abundant numbers

</pre>

 

=={{header|REXX}}==

===version 1===

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

high=word(high low 20000,1); low= word(low 1,1) /*obtain the LOW and HIGH values.*/

end /*k*/ /* [↑] % is the REXX integer division*/

if k*k==x then return s + k /*Was X a square? If so, add √ x */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

<br>limit of the &nbsp; '''do''' &nbsp; loop in the &nbsp; '''sigma''' &nbsp; function.

 

" 100k " " " '''20%''' "

" 1m " " " '''30%''' "

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

high=word(high low 20000,1); low=word(low 1, 1) /*obtain the LOW and HIGH values.*/

end /*k*/ /* [↑] % is the REXX integer division*/

if r*r==x then return s - k /*Was X a square? If so, subtract √ x */

 

===version 2===

Call time 'R'

cnt.=0

sum=sum+word(list,i)

End

{{out}}

<pre>In the range 1 - 20000

 

=={{header|Ring}}==

n = 30

perfect(n)

else see " is a abundant number" + nl ok

next

 

=={{header|Rust}}==

 

With [[proper_divisors#Rust]] in place:

// deficient starts at 1 because 1 is deficient but proper_divisors returns

// and empty Vec

deficient, perfect, abundant);

}

 

{{out}}

perfect: 4

abundant: 4953

</pre>

 

=={{header|Scala}}==

def classifier(i: Int) = properDivisors(i).sum compare i

val groups = (1 to 20000).groupBy( classifier )

println("Deficient: " + groups(-1).length)

println("Abundant: " + groups(1).length)

{{out}}

<pre>Deficient: 15043

 

=={{header|Scheme}}==

(define (classify n)

(define (sum_of_factors x)

((equal? (classify n) 1) (begin (set! n_abundant (+ 1 n_abundant)) (count (- n 1))))

((equal? (classify n) -1) (begin (set! n_deficient (+ 1 n_deficient)) (count (- n 1))))))

 

=={{header|Seed7}}==