Abundant, deficient and perfect number classifications: Difference between revisions

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

</pre>

=={{header|8086 Assembly}}==

cpu 8086

org 100h

db '.....'

snum: db 13,10,'$'

{{out}}

<pre>Deficient: 15043

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}

/* ARM assembly AARCH64 Raspberry PI 3B or android 64 bits */

/* program numberClassif64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

{{Output}}

<pre>

</pre>

 

=={{header|Action!}}==

Because of the memory limitation on the non-expanded Atari 8-bit computer the array containing Proper Divisor Sums is generated and used twice for the first and the second half of numbers separately.

CARD i,j

 

PrintF(" Perfect: %I%E",perf)

PrintF(" Abudant: %I%E",abud)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Abundant,_deficient_and_perfect_number_classifications_v2.png Screenshot from Atari 8-bit computer]

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

INT abundant count := 0;

INT deficient count := 0;

INT perfect count := 0;

INT max number = 20 000;

# construct a table of the proper divisor sums #

# classify the numbers #

FOR n TO max number DO

ELSE # pd sum > n #

FI

OD;

{{out}}

<pre>

</pre>

 

=={{header|ALGOL W}}==

integer MAX_NUMBER;

MAX_NUMBER := 20000;

write( "Deficient numbers up to 20 000: ", dCount )

end

{{out}}

<pre>

 

=={{header|AppleScript}}==

if (n < 2) then return 0

set sum to 1

end task

 

 

{{output}}

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}

/* ARM assembly Raspberry PI */

/* program numberClassif.s */

blt 2f

lsl r5,r4,#1 @ number * 2

addeq r7,r7,#1 @ perfect

addgt r6,r6,#1 @ deficient

/* r1 contains address of divisors area */

/* r0 return divisors items in table */

decompFact:

push {r3-r12,lr} @ save registers

/***************************************************/

.include "../affichage.inc"

{{Output}}

<pre>

</pre>

=={{header|Arturo}}==

(factors n) -- n

 

print ["Found" abundant "abundant,"

deficient "deficient and"

{{out}}

 

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

20 DIM P(LM)

30 FOR I=1 TO LM: P(I)=-32767: NEXT

90 PRINT "DEFICIENT:";D

100 PRINT "PERFECT:";P

{{out}}

<pre>DEFICIENT: 15043

PERFECT: 4

ABUNDANT: 4953</pre>

 

=={{header|BCPL}}==

manifest $( maximum = 20000 $)

 

writef("Abundant numbers: %N*N", ab)

freevec(p)

{{out}}

<pre>Deficient numbers: 15043

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>

 

Three algorithms presented, the first is fast, but can be a memory hog when tabulating to larger limits. The second is slower, but doesn't have any memory issue. The third is quite a bit slower, but the code may be easier to follow.

 

Third method:

:Uses a loop with a inner Enumerable.Range reaching to i / 2, only adding one divisor at a time.

using System.Linq;

 

deficient = bound - abundant - perfect;

}

{{out|Output @ Tio.run}}

We see the second method is about 10 times slower than the first method, and the third method more than 120 times slower than the second method.

 

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

 

=={{header|Cowgol}}==

 

const MAXIMUM := 20000;

print_i16(def); print(" deficient numbers.\n");

print_i16(per); print(" perfect numbers.\n");

{{out}}

<pre>15043 deficient numbers.

 

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

See [[#Pascal]].

=={{header|Dyalect}}==

 

{{trans|C#}}

 

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

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

(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

func out(res) {

}

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

=={{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]).

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

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

 

{{out}}

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

 

=={{header|Haskell}}==

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

 

printRes "deficient: " LT

printRes "perfect: " EQ

{{out}}

<pre>deficient: 15043

Or, a little faster and more directly, as a single fold:

 

import Data.List (group, sort)

 

 

main :: IO ()

{{Out}}

<pre>(15043,4,4953)</pre>

[[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|jq}}==

{{works with|jq|1.4}}

The definition of proper_divisors is taken from [[Proper_divisors#jq]]:

def proper_divisors:

. as $n

end)

else empty

'''The task:'''

 

def classify:

| if . < $n then "deficient" elif . == $n then "perfect" else "abundant" end;

 

{{out}}

 

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

Abundant, 4953

</code>

 

=={{header|K}}==

/Classification of numbers into abundant, perfect and deficient

/ numclass.k

`0: ,"Perfect = ", $(#c[1])

`0: ,"Abundant = ", $(#c[2])

{{out}}

<pre>

Perfect = 4

Abundant = 4953

</pre>

 

=={{header|Kotlin}}==

{{trans|FreeBASIC}}

 

fun sumProperDivisors(n: Int) =

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

DIMENSION P(20000)

MAX = 20000

VECTOR VALUES FPER = $I5,S1,7HPERFECT*$

VECTOR VALUES FAB = $I5,S1,8HABUNDANT*$

{{out}}

<pre>15043 DEFICIENT

 

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

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>

 

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

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

WriteString(buf);

ReadChar

 

=={{header|NewLisp}}==

;;; The list (1 .. n-1) of integers is generated

;;; then each non-divisor of n is replaced by 0

;;; Running:

(println (count-types 20000))

 

{{out}}

 

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

<span style="color: #004080;">integer</span> <span style="color: #000000;">deficient</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">perfect</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">abundant</span><span style="color: #0000FF;">=</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">N</span>

<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">20000</span> <span style="color: #008080;">do</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"deficient:%d, perfect:%d, abundant:%d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">deficient</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">perfect</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">abundant</span><span style="color: #0000FF;">})</span>

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

 

=={{header|PL/M}}==

BDOS: PROCEDURE (FN, ARG); DECLARE FN BYTE, ARG ADDRESS; GO TO 5; END BDOS;

EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;

CALL PRINT(.(' ABUNDANT',13,10,'$'));

CALL EXIT;

{{out}}

<pre>15043 DEFICIENT

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

 

=={{header|Processing}}==

int deficient = 0, perfect = 0, abundant = 0;

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

}

return sum;

{{out}}

<pre>Deficient numbers less than 20000: 15043

 

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

===Python: Counter===

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

{{Works with|Python|3.7}}

In terms of a single fold:

 

from itertools import accumulate, chain, groupby, product

# MAIN ---

if __name__ == '__main__':

 

and the main function could be rewritten in terms of an nthArrow abstraction:

 

def nthArrow(f):

'''A simple function lifted to one which applies to a

x if m != i else f(x) for i, x in enumerate(v)

]

 

as something like:

 

def deficientPerfectAbundantCountsUpTo(n):

'''Counts of deficient, perfect, and abundant

)

)

 

{{Out}}

 

=== The Simple Way ===

an = 0

dn = 0

print(str(pn) + " Perfect Numbers")

print(str(an) + " Abundant Numbers")

 

{{Out}}

:Initialize the sum to 1 and start checking factors from 2 and up, which cuts one iteration from each factor checking loop, (a 19,999 iteration savings).<br>

Resulting optimized code is thirty five times faster than the simplified code, and not nearly as complicated as the ''Counter'' or ''Reduce'' methods (as this optimized method requires no imports, other than ''time'' for the performance comparison to ''the simple way'').

st = time()

pn, an, dn = 0, 0, 0

print(str(dn) + " Deficient Numbers")

print(et2 * 1000, "ms\n")

{{out|Output @ Tio.run using Python 3 (PyPy)}}

<pre>4 Perfect Numbers

<code>dpa</code> returns 0 if n is deficient, 1 if n is perfect and 2 if n is abundant.

 

 

[ factors -1 pluck

say "Deficient = " echo cr

say " Perfect = " echo cr

 

{{out}}

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

(formerly Perl 6)

{{Works with|rakudo|2018.12}}

my @l = 1 if x > 1;

(2 .. x.sqrt.floor).map: -> \d {

}

 

{{out}}

<pre>Bag(Less(15043), More(4953), Same(4))</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>

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

{{out|output|text=&nbsp; is identical to the 1^st REXX version.}}

 

 

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

{{Works with|ruby|2.7}}

With [[proper_divisors#Ruby]] in place:

puts "Deficient: #{res[-1]} Perfect: #{res[0]} Abundant: #{res[1]}"

{{out}}<pre>

Deficient: 15043 Perfect: 4 Abundant: 4953

 

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

 

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

 

const func integer: sumProperDivisors (in integer: number) is func

writeln("Perfect: " <& perfect);

writeln("Abundant: " <& abundant);

 

{{out}}

Abundant: 4953

</pre>

 

=={{header|Sidef}}==

 

var h = Hash()

{|i| ++(h{propdivsum(i) <=> i} := 0) } << 1..20000

{{out}}

<pre>

=={{header|Swift}}==

{{trans|C}}

var perfects = 0 // sumPd = n

var abundants = 0 // sumPd > n

}

 

{{out}}<pre>There are 15043 deficient, 4 perfect and 4953 abundant integers from 1 to 20000.</pre>

 

=={{header|Tcl}}==

 

if {$n == 1} {return 0}

set divs 1

foreach {kind count} [lsort -stride 2 -index 1 -integer $classes] {

puts "$kind: $count"

 

{{out}}

=={{header|uBasic/4tH}}==

This is about the limit of what is feasible with uBasic/4tH performance wise, since a full run takes over 5 minutes.

 

For n= 1 to 20000

 

If (b@ > 1) c@ = c@ * (b@+1)

{{out}}

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

=={{header|Vala}}==

{{trans|C}}

DEFICIENT,

PERFECT,

print(@" $(count_list[Classification.PERFECT]) perfect,");

print(@" $(count_list[Classification.ABUNDANT]) abundant numbers between 1 and 20000.\n");

{{out}}

<pre>

 

=={{header|VBA}}==

Option Explicit

If n Mod j = 0 Then SumPropers = j + SumPropers

Next

{{out}}

<pre>Execution Time : 2,6875 seconds.

 

=={{header|VBScript}}==

Perfect = 0

Abundant = 0

WScript.Echo "Deficient = " & Deficient & vbCrLf &_

"Perfect = " & Perfect & vbCrLf &_

{{out}}

<pre>Deficient = 15043

=={{header|Visual Basic .NET}}==

{{trans|FreeBASIC}}

 

Function SumProperDivisors(number As Integer) As Integer

End Sub

 

{{out}}

<pre>The classification of the numbers from 1 to 20,000 is as follows :

Perfect = 4

Abundant = 4953</pre>

 

=={{header|Wren}}==

{{libheader|Wren-math}}

 

var d = 0

System.print("There are %(d) deficient numbers between 1 and 20000")

System.print("There are %(a) abundant numbers between 1 and 20000")

 

{{out}}

There are 4953 abundant numbers between 1 and 20000

There are 4 perfect numbers between 1 and 20000

</pre>

 

=={{header|Yabasic}}==

{{trans|AWK}}

 

Deficient = 0

end if

return sum

 

=={{header|zkl}}==

{{trans|D}}

fcn classify(n){

abundant :=classified.filter('==(1)).len();

println("Deficient=%d, perfect=%d, abundant=%d".fmt(

{{out}}<pre>Deficient=15043, perfect=4, abundant=4953</pre>

 

=={{header|ZX Spectrum Basic}}==

Solution 1:

20 FOR i=2 TO 20000

30 LET sum=1

130 PRINT "Number deficient: ";nd

140 PRINT "Number perfect: ";np

 

Solution 2 (more efficient):

20 FOR j=1 TO 20000

30 GO SUB 120

170 NEXT i

180 LET sump=sum