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|360 Assembly}}==

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>

 

 

 

 

 

{{out}}

<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|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>

 

int main(){

int try_max = 0;

//1 is deficient by default and can add it deficient list

try_max = i/2;

//1 is in all proper division number

for(j=2; j<try_max; j++){

//Check for proper division

try_max = i/j;

//Add j to sum

if (j != try_max)

}

//Categorize summation

continue;

}

continue;

}

}

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|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|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(1) -> [];

divs(N) -> lists:sort(divisors(1,N)).

divisors(1,N) ->

 

sumdivs(N) -> lists:sum(divs(N)).

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

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

{{out}}

<pre>

</pre>

 

let mutable a=0

let mutable b=0

printfn "perfect %i"d

printfn "abundant %i"e

 

 

 

=={{header|Fortran}}==

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}}

Abundant = 4953

</pre>

 

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

 

num_deficient%=0

num_perfect%=0

RETURN sum%

ENDFUNC

 

Output is:

Number perfect 4

Number abundant 4953

</pre>

 

=====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 {

public static void main(String[] args) {

long sum = properDivsSum(i);

if (sum < i)

else if (sum == i)

else

}

}

}

 

<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|Julia}}==

<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 main(args: Array<String>) {

 

for (n in 1..20000) {

sum = sumProperDivisors(n)

when {

sum == n -> perfect++

}

}

println("Perfect = $perfect")

println("Abundant = $abundant")

 

{{out}}

 

=={{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|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|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>

Deficient numbers between 1 and 20000: 15043

Perfect numbers between 1 and 20000: 4

</pre>

 

=={{header|Nim}}==

proc sumProperDivisors(number: int) : int =

if number < 2 : return 0

echo " Perfect = " , perfect

echo " Abundant = " , abundant

 

{{out}}

=={{header|Oforth}}==

 

: numberClasses

0 0 ->deficient ->perfect

0 20000 loop: i [

s i < ifTrue: [ deficient 1+ ->deficient continue ]

s i == ifTrue: [ perfect 1+ ->perfect continue ]

1+

]

 

{{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>

 

===Using a module===

{{libheader|ntheory}}

 

my %h;

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

{{out}}

 

}

 

 

=={{header|Phix}}==

{{out}}

<pre>

deficient:15043, perfect:4, abundant:4953

</pre>

 

=={{header|PicoLisp}}==

(if (assoc Key (val Var))

(con @ (inc (cdr @)))

(push Var (cons Key 1)) )

Key )

(de factor-sum (N)

(if (=1 N)

(accud 'R N1)

(for I R

(- S N) ) ) )

(bench

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

(println D P A) ) )

{{Output}}

<pre>

15043 4 4953

</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>