Skip to content
Related Articles

Related Articles

Improve Article
Find the sum of the all amicable numbers up to N
  • Last Updated : 02 Jun, 2021

Given a number N. FInd the sum of he all amicable numbers up to N. If A and B are Amicable pairs (Two numbers are amicable if the first is equal to the sum of divisors of the second) then A and B are called as Amicable numbers. 
Examples: 
 

Input : 284 
Output : 504 
Explanation : 220 and 284 are two amicable numbers upto 284
Input : 250 
Output : 220 
Explanation : 220 is the only amicable number

 

Approach
An efficient approach is to store all amicable numbers in a set and for a given N sum all the numbers in the set which are less than equals to N.
Below code is the implementation of the above approach: 
 

C++




// CPP program to find sum of all
// amicable numbers up to n
#include <bits/stdc++.h>
using namespace std;
 
#define N 100005
 
// Function to return all amicable numbers
set<int> AMICABLE()
{
    int sum[N];
    memset(sum, 0, sizeof sum);
    for (int i = 1; i < N; i++) {
 
        // include 1
        sum[i]++;
 
        for (int j = 2; j * j <= i; j++) {
 
            // j is proper divisor of i
            if (i % j == 0) {
                sum[i] += j;
 
                // if i is not a perfect square
                if (i / j != j)
                    sum[i] += i / j;
            }
        }
    }
 
    set<int> s;
    for (int i = 2; i < N; i++) {
 
        // insert amicable numbers
        if (i != sum[i] and sum[i] < N and i == sum[sum[i]]
            and !s.count(i) and !s.count(sum[i])) {
            s.insert(i);
            s.insert(sum[i]);
        }
    }
 
    return s;
}
 
// function to find sum of all
// amicable numbers up to N
int SumOfAmicable(int n)
{
    // to store required sum
    int sum = 0;
 
    // to store all amicable numbers
    set<int> s = AMICABLE();
 
    // sum all amicable numbers upto N
    for (auto i = s.begin(); i != s.end(); ++i) {
        if (*i <= n)
            sum += *i;
        else
            break;
    }
 
    // required answer
    return sum;
}
 
// Driver code to test above functions
int main()
{
    int n = 284;
 
    cout << SumOfAmicable(n);
 
    return 0;
}

Java




// Java program to find sum of all
// amicable numbers up to n
import java.util.*;
class GFG
{
     
static final int N=100005;
 
// Function to return all amicable numbers
static Set<Integer> AMICABLE()
{
    int sum[] = new int[N];
    for(int i = 0; i < N; i++)
        sum[i]=0;
     
    for (int i = 1; i < N; i++) 
    {
 
        // include 1
        sum[i]++;
 
        for (int j = 2; j * j <= i; j++)
        {
 
            // j is proper divisor of i
            if (i % j == 0)
            {
                sum[i] += j;
 
                // if i is not a perfect square
                if (i / j != j)
                    sum[i] += i / j;
            }
        }
    }
 
    Set<Integer> s = new HashSet<Integer>();
    for (int i = 2; i < N; i++)
    {
 
        // insert amicable numbers
        if (i != sum[i] && sum[i] < N && i == sum[sum[i]])
        {
            s.add(i);
            s.add(sum[i]);
        }
    }
    return s;
}
 
// function to find sum of all
// amicable numbers up to N
static int SumOfAmicable(int n)
{
    // to store required sum
    int sum = 0;
 
    // to store all amicable numbers
    Set<Integer> s = AMICABLE();
     
     
    // sum all amicable numbers upto N
    for (Integer x : s)
    {
        if (x <= n)
            sum += x;
    }
 
    // required answer
    return sum;
}
 
// Driver code
public static void main(String args[])
{
    int n = 284;
    System.out.println( SumOfAmicable(n));
}
}
 
// This code is contributed by Arnab Kundu

Python3




# Python3 program to findSum of all
# amicable numbers up to n
import math as mt
 
N = 100005
 
# Function to return all amicable numbers
def AMICABLE():
 
    Sum = [0 for i in range(N)]
     
    for i in range(1, N):
        Sum[i] += 1
 
        for j in range(2, mt.ceil(mt.sqrt(i))):
 
            # j is proper divisor of i
            if (i % j == 0):
                Sum[i] += j
 
                # if i is not a perfect square
                if (i // j != j):
                    Sum[i] += i // j
 
    s = set()
    for i in range(2, N):
        if(i != Sum[i] and Sum[i] < N and
           i == Sum[Sum[i]] and i not in s and
                Sum[i] not in s):
            s.add(i)
            s.add(Sum[i])
 
    return s
 
# function to findSum of all amicable
# numbers up to N
def SumOfAmicable(n):
 
    # to store requiredSum
    Sum = 0
 
    # to store all amicable numbers
    s = AMICABLE()
 
    #Sum all amicable numbers upto N
    s = sorted(s)
    for i in s:
        if (i <= n):
            Sum += i
        else:
            break
     
    # required answer
    return Sum
 
# Driver Code
n = 284
print(SumOfAmicable(n))
 
# This code is contributed by
# mohit kumar 29

C#




// C# program to find sum of all
// amicable numbers up to n
using System;
using System.Collections.Generic;
 
class GFG
{
     
static readonly int N = 100005;
 
// Function to return all amicable numbers
static HashSet<int> AMICABLE()
{
    int []sum = new int[N];
    for(int i = 0; i < N; i++)
        sum[i] = 0;
     
    for (int i = 1; i < N; i++)
    {
 
        // include 1
        sum[i]++;
 
        for (int j = 2; j * j <= i; j++)
        {
 
            // j is proper divisor of i
            if (i % j == 0)
            {
                sum[i] += j;
 
                // if i is not a perfect square
                if (i / j != j)
                    sum[i] += i / j;
            }
        }
    }
 
    HashSet<int> s = new HashSet<int>();
    for (int i = 2; i < N; i++)
    {
 
        // insert amicable numbers
        if (i != sum[i] && sum[i] < N &&
                            i == sum[sum[i]])
        {
            s.Add(i);
            s.Add(sum[i]);
        }
    }
    return s;
}
 
// function to find sum of all
// amicable numbers up to N
static int SumOfAmicable(int n)
{
    // to store required sum
    int sum = 0;
 
    // to store all amicable numbers
    HashSet<int> s = AMICABLE();
     
     
    // sum all amicable numbers upto N
    foreach (int x in s)
    {
        if (x <= n)
            sum += x;
    }
 
    // required answer
    return sum;
}
 
// Driver code
public static void Main()
{
    int n = 284;
    Console.WriteLine( SumOfAmicable(n));
}
}
 
/* This code contributed by PrinciRaj1992 */

PHP




<?php
// PHP program to find sum of all
// amicable numbers up to n
$N = 10005;
 
// Function to return all amicable
// numbers
function AMICABLE()
{
    global $N;
    $sum = array_fill(0, $N, 0);
    for ($i = 1; $i < $N; $i++)
    {
 
        // include 1
        $sum[$i]++;
 
        for ($j = 2; $j * $j <= $i; $j++)
        {
 
            // j is proper divisor of i
            if ($i % $j == 0)
            {
                $sum[$i] += $j;
 
                // if i is not a perfect square
                if ($i / $j != $j)
                    $sum[$i] += $i / $j;
            }
        }
    }
 
    $s = array();
    for ($i = 2; $i < $N; $i++)
    {
 
        // insert amicable numbers
        if ($i != $sum[$i] and $sum[$i] < $N and
                        $i == $sum[$sum[$i]] and
                           !in_array($i, $s) and
                           !in_array($sum[$i], $s))
        {
            array_push($s, $i);
            array_push($s, $sum[$i]);
        }
    }
 
    return $s;
}
 
// function to find sum of all
// amicable numbers up to N
function SumOfAmicable($n)
{
    // to store required sum
    $sum = 0;
 
    // to store all amicable numbers
    $s = AMICABLE();
    $s = array_unique($s);
    sort($s);
     
    // sum all amicable numbers upto N
    for ($i = 0; $i != count($s); ++$i)
    {
        if ($s[$i] <= $n)
            $sum += $s[$i];
        else
            break;
    }
     
    // required answer
    return $sum;
}
 
// Driver code
$n = 284;
 
echo SumOfAmicable($n);
 
// This code is contributed by mits
?>

Javascript




<script>
 
// JavaScript program to find sum of all
// amicable numbers up to n
 
let N=100005;
 
// Function to return all amicable numbers
function  AMICABLE()
{
    let sum = new Array(N);
    for(let i = 0; i < N; i++)
        sum[i]=0;
       
    for (let i = 1; i < N; i++) 
    {
   
        // include 1
        sum[i]++;
   
        for (let j = 2; j * j <= i; j++)
        {
   
            // j is proper divisor of i
            if (i % j == 0)
            {
                sum[i] += j;
   
                // if i is not a perfect square
                if (i / j != j)
                    sum[i] += i / j;
            }
        }
    }
   
    let s = new Set();
    for (let i = 2; i < N; i++)
    {
   
        // insert amicable numbers
        if (i != sum[i] && sum[i] < N && i == sum[sum[i]])
        {
            s.add(i);
            s.add(sum[i]);
        }
    }
    return s;
}
 
// function to find sum of all
// amicable numbers up to N
function SumOfAmicable(n)
{
    // to store required sum
    let sum = 0;
   
    // to store all amicable numbers
    let s = AMICABLE();
       
       
    // sum all amicable numbers upto N
    for (let x of s.values())
    {
        if (x <= n)
            sum += x;
    }
   
    // required answer
    return sum;
}
 
// Driver code
let n = 284;
document.write( SumOfAmicable(n));
 
 
// This code is contributed by unknown2108
 
</script>
Output: 
504

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes




My Personal Notes arrow_drop_up
Recommended Articles
Page :