An abundance of integers!

Question

An Abundant number is any number where the sum of its proper divisors is greater than the original number. For example, the proper divisors of 12 are:

1, 2, 3, 4, 6

And summing these results in 16. Since 16 is larger than 12, 12 is abundant. Note that this does not include "Perfect numbers", e.g. numbers that are equal to the sum of its proper divisors, such as 6 and 28.

Your task for today is to write a program or function that determines if a number is abundant or not. Your program should take a single integer as input, and output a truthy/falsy value depending on whether it is abundant or not. You can assume that the input will always be valid and greater than 0, so for bad inputs, undefined behavior is fine.

You may take your input and output in any reasonable format, for example STDIN/STDOUT, files, or arguments/return values would all be acceptable.

For reference, here are the abundant numbers up to 100:

12,
18,
20,
24,
30,
36,
40,
42,
48,
54,
56,
60,
66,
70,
72,
78,
80,
84,
88,
90,
96,
100

And more can be found on A005101

Since this is code-golf, standard loopholes are denied, and try to write the shortest possible code you can in whichever language you happen to choose!

Answer 1

Pyth, 11 bytes

>sPf!%QTS

Old:

L!%Qb>sPy#S

I can't use !% as a pfn for #, because it's two functions. Makes me sad :(.

---

L!%Qb>sPy#SQ    Program's argument: Q
L!%Qb           Define a lambda y, that takes b as an argument
 !%Qb           Return true if Q is divisible by b
          S     Make a range 1..Q
        y#      Filter that range with the lambda (y)
       P        Remove the last element (Q itself)
      s         Sum them
     >     Q    Check if that sum is greater than the program's argument

Answer 2

PowerShell, 43 bytes

param($n)1..$n|%{$s+=$_*!($n%$_)}
$s-gt2*$n

Try it online!

Answer 3

Common Lisp, 63 bytes

(lambda(n)(>(loop for i from 1 below n if(=(mod n i)0)sum i)n))

Try it online!

Answer 4

F#, 51 bytes

let f n=Seq.filter(fun x->n%x=0){1..n-1}|>Seq.sum>n

Try it online!

Filters out all the numbers that don't divide evenly into n, then sums them and compares them against n.

Answer 5

Japt, 4 bytes

<âÔx

Try it online!

Answer 6

C# (Visual C# Interactive Compiler), 48 bytes

x=>Enumerable.Range(1,x).Sum(y=>y<x&x%y<1?y:0)>x

Try it online!

Above is a LINQ based solution that creates a range of numbers slightly larger than the input number. Each element is tested for being a) being a proper divisor of the input and b) being less than the input. If both checks pass, it is added to a sum which is compared to the input.

Below is a a recursive solution that uses an inner function to calculate the summation. While this one seems the most interesting to me, I think the LINQ based approach will not be beat.

C# (Visual C# Interactive Compiler), 60 bytes

x=>{int g(int y)=>(x%y<1?y:0)+(++y<x?g(y):0);return g(1)>x;}

Try it online!

Finally, we have an iterative solution which currently is between the LINQ based approach and the recursive one.

C# (Visual C# Interactive Compiler), 53 bytes

x=>{int y=0,z=0;for(;++y<x;z+=x%y<1?y:0);return z>x;}

Try it online!

Answer 7

Ruby, 39 32 bytes

->n{n<(1...n).sum{|x|n%x>0?0:x}}

Try it online!

Updated to Ruby 2.6

Answer 8

R, 32 28 bytes

2*(n=scan())<(x=1:n)%*%!n%%x

Try it online!

Reads n from stdin, returns TRUE for abundant numbers and FALSE otherwise.

Answer 9

Whispers v2, 49 bytes

> Input
>> ∤1
>> ∑2
>> 3-1
>> 4>1
>> Output 5

Try it online!

How it works

Whispers is a non-linear language, where numbers don't refer to their numerical value; rather they reference the result of that line in the program. Execution always starts at the last line, and branches through these references.

Program structure tree (green are nilad lines):

Therefore, we start on line 6 by outputting the result of line 5, which is

>> 4>1

which calls lines 4 and 1 and compares the results.

Line 1 is the odd line out in the program: as it starts with a single >, rather than a double >>, it is a nilad line. This means it returns its value interpreted literally. Numbers return their numeric value, and Input is preprocessed at the start of execution, being replaced with the first input on STDIN. Therefore, line 5 checks if the result for line 4 is greater than the input.

Line 4, >> 3-1, subtracts the input from line 3's result, while line 3, >>∑2, sums the values on line 2. Line 2, >> ∤1, generates the list of the input's divisors. Therefore, together, the program generates a list of the input's divisors (including the input), sums them, then subtracts the input (in order to account for the input being included in the list of divisors). Finally, we compare the sum to the input, and output the result.

Answer 10

Zsh, 39 bytes

for ((;++b<$1;t+=$1%b?0:b)):
<<<$[t>$1]

Try it online!

Answer 11

Vyxal, 3 bytes

∆K<

Try it Online!

Answer 12

Lua (71 68 bytes)

Thank to @Deadcode for finding a typo in the byte length and for suggesting shorter code.

function A(n)z=0 for i=1,n-1 do z=z+i*#{[n%i+1]=0}end return z>n end

Answer 13

x86 opcode edited from 179016, 20 bytes

f:      mov ecx, eax       ; copy input number N into ECX
        lea ebx, [eax+eax] ; copy input number 2N into EBX
.a:     cdq                ; clear DX (high word for dividend)
        push eax           ; save original dividend
        div ecx            ; divide DX:AX / CX
        pop eax            ; restore dividend
        test edx, edx      ; if remainder = 0, it divides evenly and is a divisor of N
        jnz .b             ; if not, continue loop
        sub ebx, ecx       ; Subtract divisor from EBX; this simultaneously changes the
                           ; running total, and sets the flags for the return value.
        jc .c              ; If CF=1, the sum of divisors subtracted from N has exceeded
                           ; N, thus N is abundant, and we need to exit the loop now to
                           ; return this result in CF.
.b:     loop .a
.c:                        ; return value: CF=0 (non-abundant), CF=1 (abundant)

Try it online!

Saved from the reverse working

Answer 14

><>, 47+3 46+3 39+3 = 42 bytes

:l)?!v}l:{:}$%0=*{
 v-$0<
l<+v?=1
)n;>0

Expects the input number to be present on the stack at program start, so +3 bytes for the -v flag. Try it online!

Edit: Golfed 1 byte from 3rd line: -\~0$ => -\:+

Edit 2: Near complete rewrite, previous version:

1v
}/!?)@:{:}+1r~?$r}:}%@:{:
-\:+
?\+l1=
;>0)n

Answer 15

Haskell, 34 bytes

a n=n<sum[a|a<-[1..n-1],mod n a<1]

Try it online! Usage example: a 12 returns True.

Answer 16

JavaScript ES6, 61 50 bytes

a=>[...Array(a).keys()].reduce((b,c)=>a%c?b:b+c)>a

f=a=>[...Array(a).keys()].reduce((b,c)=>a%c?b:b+c)>a;

console.log(f(11));
console.log(f(12));
console.log(f(17));
console.log(f(18));

Answer 17

Pyth, 8 bytes

>s{*MPyP

Try it online here.

>s{*MPyPQQ   Implicit: Q=eval(input())
             Trailing QQ inferred
       PQ    Prime factors of Q
      y      Take the powerset of the above
     P       Discard the last one (i.e. the original set itself)
   *M        Take the product of each list
  {          Deduplicate
 s           Take the sum
>        Q   Is the above greater than Q? Implicit print

Answer 18

PHP, 63 bytes

function a($x){for($i=1;$i<$x;$i++){$s+=$x%$i?0:$i;}echo$s>$x;}

Usage: a(12);

Answer 19

APL(NARS) 11 chars, 22 bytes

{⍵<2÷⍨11π⍵}

11π is the function sum divisor, so sum proper divisor would be: {(-⍵)+11π⍵}; test:

  f←{⍵<2÷⍨11π⍵}
  {1=f ⍵:⍵⋄⍬}¨1..100
12  18  20  24  30  36  40  42  48  54  56  60  66  70  72  78  80  84  88  90  96  100 

Answer 20

Forth (gforth), 45 bytes

: f 0 over 1 ?do over i mod 0= i * - loop < ;

Try it online!

Explanation

Loops over every number from 1 to n-1, summing all values that divide n perfectly. Returns true if sum is greater than n

Code Explanation

: f                \ start word definition
  0 over 1         \ create a value to hold the sum and setup up the bounds of the loop
  ?do              \ start a counted loop from 1 to n. (?do skips if start = end)
    over           \ copy n to the top of the stack
    i mod 0=       \ check if i divides n perfectly
    i * -          \ if so, use the fact that -1 = true in forth to add i to the sum
  loop             \ end the counted loop
  <                \ check if n is less than the sum
;                  \ end the word definition
   

Answer 21

C# (.NET Core), 59, 53 bytes

Without LINQ.

EDIT: Thanks to ASCII-only for pointing out for(;++k<p;) instead of for(;k<p;k++).

C# (.NET Core), 53 bytes

p=>{int k=0,n=0;for(;++k<p;)n+=p%k<1?k:0;return n>p;}

Try it online!

Answer 22

Perl 5 -MList::Util=sum -pa, 32 bytes

$_=$_<sum grep!("@F"%$_),1..$_-1

Try it online!

Answer 23

Python 3, 45 bytes

lambda n:sum(i for i in range(1,n)if n%i<1)>n

Try it online!

Answer 24

Factor + project-euler.common, 9 bytes

abundant?

Try it online!

Builtin, lol

Answer 25

C (clang), 47 bytes

g,o;l(f){for(g=o=f;--o;)g-=f%o?0:o;return g<0;}

Try it online!

Answer 26

cQuents, 6 bytes

$<U\z$

Try it online!

Outputs 1 for true and 0 for false. If no input given, outputs the 1-indexed sequences of 1/0 for whether each index is an abundant number.

Explanation

        each term in the sequence equals
$       index
 <            <
  U             sum (                           )
   \z                 proper divisors (       )
     $                                  index

Answer 27

Pyt, 7 bytes

ĐĐð⇹\Ʃ<

Try it online!

ĐĐ          implicit input (n); duplicate on stack twice
  ð         get all factors of n
   ⇹\       remove n from list of factors (i.e. reduce list to proper divisors)
     Ʃ      sum proper divisors
      <     is the sum greater than n?; implicit print

Answer 28

Arturo, 26 bytes

$[n]->n<sum chop factors n

Try it

Answer 29

Scala, 39 bytes

(n:Int)=>(1 until n filter{n%_<1}sum)>n

Answer 30

Javascript, 47 Bytes

a=>{s=d=0;while(a>d){s+=a%d?0:d;d++}return s>d}

f=a=>{s=d=0;while(a>d){s+=a%d?0:d;d++}return s>d};
console.log(f(11));
console.log(f(12));
console.log(f(15));
console.log(f(18));

Quite straight forward: check all numbers smaller than the input, if the input is divisible by them add them to the sum, and return whether the sum is bigger than the input