Pairs of Amicable Numbers (original) (raw)

Last Updated : 21 Jan, 2025

Amicable numbers are pairs of two integers (a, b) such that:

**Sum of the proper divisors of a = b and **Sum of the proper divisors of b = a,

where a ≠ b.

**Examples: (220,284)

Proper divisors of 220: 1, 2, 4, 5, 10, 11, 20, 22, 44, 55, 110
- Sum = 1 + 2 + 4 + 5 + 10 + 11 + 20 + 22 + 44 + 55 + 110 = 284
Proper divisors of 284: 1, 2, 4, 71, 142
- Sum = 1 + 2 + 4 + 71 + 142 = 220

Thus, (220, 284) is a pair of amicable numbers.

Some other examples include:

(1184, 1210)
(2620, 2924)
(5020, 5564)
(6232, 6368)

**Example:

Input : arr[] = {220, 284, 1184, 1210, 2, 5}
Output : 2
Explanation : (220, 284) and (1184, 1210) form amicable pair.

Input : arr[] = {2620, 2924, 5020, 5564, 6232, 6368}
Output : 3
Explanation : (2620, 2924), (5020, 5564) and (6232, 6368) forms amicable pair.

A **simple solution is to traverse each pair and check if they form an amicable pair, if they do we increment the count.

**Implementation:

C++ `

// A simple C++ program to count // amicable pairs in an array. #include <bits/stdc++.h> using namespace std;

// Calculate the sum // of proper divisors int sumOfDiv(int x) { // 1 is a proper divisor int sum = 1; for (int i = 2; i <= sqrt(x); i++) { if (x % i == 0) { sum += i;

        // To handle perfect squares
        if (x / i != i)
            sum += x / i;
    }
}
return sum;

}

// Check if pair is amicable bool isAmicable(int a, int b) { return (sumOfDiv(a) == b && sumOfDiv(b) == a); }

// This function prints pair // of amicable pairs present // in the input array int countPairs(int arr[], int n) { int count = 0;

// Iterate through each 
// pair, and find if it
// an amicable pair
for (int i = 0; i < n; i++)
    for (int j = i + 1; j < n; j++)
        if (isAmicable(arr[i], arr[j]))
            count++;

return count;

}

// Driver code int main() { int arr1[] = { 220, 284, 1184, 1210, 2, 5 }; int n1 = sizeof(arr1) / sizeof(arr1[0]); cout << countPairs(arr1, n1) << endl;

int arr2[] = { 2620, 2924, 5020, 
               5564, 6232, 6368 };
int n2 = sizeof(arr2) / sizeof(arr2[0]);
cout << countPairs(arr2, n2);
return 0;

}

Java

// A simple Java program to count // amicable pairs in an array. import java.io.*;

class GFG {

// Calculate the sum 
// of proper divisors
static int sumOfDiv(int x)
{

    // 1 is a proper divisor
    int sum = 1;
    for (int i = 2; i <= Math.sqrt(x); i++) 
    {
        if (x % i == 0) 
        {
            sum += i;

            // To handle perfect squares
            if (x / i != i)
                sum += x / i;
        }
    }

    return sum;
}

// Check if pair is amicable
static boolean isAmicable(int a, int b)
{
    return (sumOfDiv(a) == b && 
            sumOfDiv(b) == a);
}

// This function prints pair
//  of amicable pairs present
// in the input array
static int countPairs(int arr[], int n)
{
    int count = 0;

    // Iterate through each pair, 
    // and find if it an amicable pair
    for (int i = 0; i < n; i++)
        for (int j = i + 1; j < n; j++)
            if (isAmicable(arr[i], arr[j]))
                count++;

    return count;
}

// Driver code
public static void main(String args[])
{

    int arr1[] = { 220, 284, 1184, 
                   1210, 2, 5 };
    int n1 = arr1.length;

    System.out.println(countPairs(arr1, n1));

    int arr2[] = { 2620, 2924, 5020,
                   5564, 6232, 6368 };
    int n2 = arr2.length;

    System.out.println(countPairs(arr2, n2));
}

}

// This code is contributed by Anshika Goyal.

Python

Python3 program to count

amicable pairs in an array

Calculate the sum

of proper divisors

def sumOfDiv(x): sum = 1 for i in range(2, x): if x % i == 0: sum += i return sum

Check if pair is amicable

def isAmicable(a, b): if sumOfDiv(a) == b and sumOfDiv(b) == a: return True else: return False

This function prints pair

of amicable pairs present

in the input array

def countPairs(arr, n): count = 0 for i in range(0, n): for j in range(i + 1, n): if isAmicable(arr[i], arr[j]): count = count + 1 return count

Driver Code

arr1 = [220, 284, 1184, 1210, 2, 5] n1 = len(arr1) print(countPairs(arr1, n1))

arr2 = [2620, 2924, 5020, 5564, 6232, 6368] n2 = len(arr2) print(countPairs(arr2, n2))

This code is contributed

by Smitha Dinesh Semwal

C#

// A simple C# program to count // amicable pairs in an array. using System;

class GFG {

// Calculate the sum
// of proper divisors
static int sumOfDiv(int x)
{
    
    // 1 is a proper divisor
    int sum = 1;
    for (int i = 2; i <= Math.Sqrt(x); i++) 
    {
        if (x % i == 0) 
        {
            sum += i;

            // To handle perfect squares
            if (x / i != i)
                sum += x / i;
        }
    }
    
    return sum;
}

// Check if pair is amicable
static bool isAmicable(int a, int b)
{
    return (sumOfDiv(a) == b &&
            sumOfDiv(b) == a);
}

// This function prints pair
// of amicable pairs present 
// in the input array
static int countPairs(int []arr, int n)
{
    int count = 0;

    // Iterate through each pair, 
    // and find if it an amicable pair
    for (int i = 0; i < n; i++)
    
        for (int j = i + 1; j < n; j++)
            if (isAmicable(arr[i], arr[j]))
                count++;

    return count;
}

// Driver code
public static void Main() 
{

    int []arr1 = {220, 284, 1184, 
                  1210, 2, 5};
    int n1 = arr1.Length;
    
    Console.WriteLine(countPairs(arr1, n1));

    int []arr2 = {2620, 2924, 5020, 
                  5564, 6232, 6368};
    int n2 = arr2.Length;

    Console.WriteLine(countPairs(arr2, n2));
}

}

// This code is contributed by vt_m.

JavaScript

PHP

i=2;i = 2; i=2;i <= sqrt($x); $i++) { if ($x % $i == 0) { sum+=sum += sum+=i; // To handle perfect squares if ($x / i!=i != i!=i) sum+=sum += sum+=x / $i; } } return $sum; } // Check if pair is amicable function isAmicable( a,a, a,b) { return (sumOfDiv($a) == $b and sumOfDiv($b) == $a); } // This function prints pair // of amicable pairs present // in the input array function countPairs( arr,arr, arr,n) { $count = 0; // Iterate through each pair, // and find if it an amicable pair for ( i=0;i = 0; i=0;i < n;n; n;i++) for ( j=j = j=i + 1; j<j < j<n; $j++) if (isAmicable($arr[$i], arr[arr[arr[j])) $count++; return $count; } // Driver code $arr1 = array( 220, 284, 1184, 1210, 2, 5 ); n1=count(n1 = count(n1=count(arr1); echo countPairs($arr1, $n1),"\n"; $arr2 = array( 2620, 2924, 5020, 5564, 6232, 6368 ); n2=count(n2 = count(n2=count(arr2); echo countPairs($arr2, $n2); // This code is contributed by anuj_67. ?>

An **efficient solution is to keep the numbers stored in a map and for every number, we find the sum of its proper divisor and check if that's also present in the array. If it is present, we can check if they form an amicable pair or not.

Thus, the complexity would be considerably reduced. Below is the C++ program for the same.

**Implementation:

C++ `

// Efficient C++ program to count // Amicable pairs in an array. #include <bits/stdc++.h> using namespace std;

// Calculate the sum // of proper divisors int sumOfDiv(int x) { // 1 is a proper divisor int sum = 1; for (int i = 2; i <= sqrt(x); i++) { if (x % i == 0) { sum += i;

        // To handle perfect squares
        if (x / i != i)
            sum += x / i;
    }
}
return sum;

}

// Check if pair is amicable bool isAmicable(int a, int b) { return (sumOfDiv(a) == b && sumOfDiv(b) == a); }

// This function prints count // of amicable pairs present // in the input array int countPairs(int arr[], int n) { // Map to store the numbers unordered_set s; int count = 0; for (int i = 0; i < n; i++) s.insert(arr[i]);

// Iterate through each number, 
// and find the sum of proper 
// divisors and check if it's 
// also present in the array
for (int i = 0; i < n; i++) 
{
    if (s.find(sumOfDiv(arr[i])) != s.end()) 
    {
        // It's sum of proper divisors
        int sum = sumOfDiv(arr[i]);
        if (isAmicable(arr[i], sum))
            count++;
    }
}

// As the pairs are counted 
// twice, thus divide by 2
return count / 2;

}

// Driver code int main() { int arr1[] = { 220, 284, 1184, 1210, 2, 5 }; int n1 = sizeof(arr1) / sizeof(arr1[0]); cout << countPairs(arr1, n1) << endl;

int arr2[] = { 2620, 2924, 5020, 
               5564, 6232, 6368 };
int n2 = sizeof(arr2) / sizeof(arr2[0]);
cout << countPairs(arr2, n2) 
     << endl;
return 0;

}

Java

// Efficient Java program to count // Amicable pairs in an array. import java.util.*;

class GFG {

// Calculate the sum // of proper divisors static int sumOfDiv(int x) { // 1 is a proper divisor int sum = 1; for (int i = 2; i <= Math.sqrt(x); i++) { if (x % i == 0) { sum += i;

        // To handle perfect squares
        if (x / i != i)
            sum += x / i;
    }
}
return sum;

}

// Check if pair is amicable static boolean isAmicable(int a, int b) { return (sumOfDiv(a) == b && sumOfDiv(b) == a); }

// This function prints count // of amicable pairs present // in the input array static int countPairs(int arr[], int n) { // Map to store the numbers HashSet s = new HashSet(); int count = 0; for (int i = 0; i < n; i++) s.add(arr[i]);

// Iterate through each number, 
// and find the sum of proper 
// divisors and check if it's 
// also present in the array
for (int i = 0; i < n; i++) 
{
    if (s.contains(sumOfDiv(arr[i]))) 
    {
        // It's sum of proper divisors
        int sum = sumOfDiv(arr[i]);
        if (isAmicable(arr[i], sum))
            count++;
    }
}

// As the pairs are counted 
// twice, thus divide by 2
return count / 2;

}

// Driver code public static void main(String[] args) { int arr1[] = { 220, 284, 1184, 1210, 2, 5 }; int n1 = arr1.length; System.out.println(countPairs(arr1, n1));

int arr2[] = { 2620, 2924, 5020, 
               5564, 6232, 6368 };
int n2 = arr2.length;
System.out.println(countPairs(arr2, n2));

} }

// This code is contributed by PrinciRaj1992

Python

Efficient Python3 program to count

Amicable pairs in an array.

import math

Calculating the sum

of proper divisors

def sumOfDiv(x):

# 1 is a proper divisor
sum = 1;
for i in range(2,int(math.sqrt(x))):
    if x % i==0:
        sum += i
        
        # To handle perfect squares
        if i != x/i:
            sum += x/i
return int(sum);

check if pair is amicable

def isAmicable(a, b): return (sumOfDiv(a) == b and sumOfDiv(b) == a)

This function prints count

of amicable pairs present

in the input array

def countPairs(arr,n):

# Map to store the numbers
s = set()
count = 0
for i in range(n):
    s.add(arr[i])

# Iterate through each number, 
# and find the sum of proper 
# divisors and check if it's 
# also present in the array
for i in range(n):     
    if sumOfDiv(arr[i]) in s:
        
        # It's sum of proper divisors
        sum = sumOfDiv(arr[i])
        if isAmicable(arr[i], sum):
            count += 1        

# As the pairs are counted 
# twice, thus divide by 2
return int(count/2);

Driver Code

arr1 = [220, 284, 1184, 1210, 2, 5] n1 = len(arr1) print(countPairs(arr1, n1))

arr2 = [2620, 2924, 5020, 5564, 6232, 6368] n2 = len(arr2) print(countPairs(arr2, n2))

This code is contributed

by Naveen Babbar

C#

// Efficient C# program to count // Amicable pairs in an array. using System; using System.Collections.Generic;

class GFG {

// Calculate the sum // of proper divisors static int sumOfDiv(int x) { // 1 is a proper divisor int sum = 1; for (int i = 2; i <= Math.Sqrt(x); i++) { if (x % i == 0) { sum += i;

        // To handle perfect squares
        if (x / i != i)
            sum += x / i;
    }
}
return sum;

}

// Check if pair is amicable static Boolean isAmicable(int a, int b) { return (sumOfDiv(a) == b && sumOfDiv(b) == a); }

// This function prints count // of amicable pairs present // in the input array static int countPairs(int []arr, int n) { // Map to store the numbers HashSet s = new HashSet(); int count = 0; for (int i = 0; i < n; i++) s.Add(arr[i]);

// Iterate through each number, 
// and find the sum of proper 
// divisors and check if it's 
// also present in the array
for (int i = 0; i < n; i++) 
{
    if (s.Contains(sumOfDiv(arr[i]))) 
    {
        // It's sum of proper divisors
        int sum = sumOfDiv(arr[i]);
        if (isAmicable(arr[i], sum))
            count++;
    }
}

// As the pairs are counted 
// twice, thus divide by 2
return count / 2;

}

// Driver code public static void Main(String[] args) { int []arr1 = { 220, 284, 1184, 1210, 2, 5 }; int n1 = arr1.Length; Console.WriteLine(countPairs(arr1, n1));

int []arr2 = { 2620, 2924, 5020, 
               5564, 6232, 6368 };
int n2 = arr2.Length;
Console.WriteLine(countPairs(arr2, n2));

} }

// This code is contributed by Princi Singh

JavaScript

This article is contributed by **Ashutosh Kumar