# Check for Amicable Pair

Amicable numbers are two different numbers so related that the sum of the proper divisors of each is equal to the other number. (A proper divisor of a number is a positive factor of that number other than the number itself.

Examples:

```Input : x = 220, y = 284
Output : Yes
Proper divisors of 220 are 1, 2, 4, 5,
10, 11, 20, 22, 44, 55 and 110. Sum of
these is 284. Proper divisors of 284
are 1, 2, 4, 71 and 142 with sum 220.

Input : 1 2
Output :No
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The logic is very simple. We compare sum of the proper divisors of both numbers and compare sum for one number with other number.

## C++

 `// CPP program to check if two numbers are ` `// Amicable or not. ` `#include ` `using` `namespace` `std; ` ` `  `// Function to calculate sum of all  ` `// proper divisors of a given number ` `int` `divSum(``int` `n) ` `{ ` `    ``// Sum of divisors ` `    ``int` `result = 0; ` `   `  `    ``// find all divisors which divides 'num' ` `    ``for` `(``int` `i = 2; i <= ``sqrt``(n); i++) ` `    ``{ ` `        ``// if 'i' is divisor of 'n' ` `        ``if` `(n % i == 0) ` `        ``{ ` `            ``// if both divisors are same ` `            ``// then add it once else add ` `            ``// both ` `            ``if` `(i == (n / i)) ` `                ``result += i; ` `            ``else` `                ``result += (i + n/i); ` `        ``} ` `    ``} ` `   `  `    ``// Add 1 and n to result as above loop ` `    ``// considers proper divisors greater  ` `    ``// than 1. ` `    ``return` `(result + 1); ` `} ` `   `  `// Returns true if x and y are Amicable ` `// else false. ` `bool` `areAmicable(``int` `x, ``int` `y) ` `{ ` `    ``if` `(divSum(x) != y) ` `       ``return` `false``; ` ` `  `    ``return` `(divSum(y) == x); ` `} ` ` `  `int` `main() { ` `    ``int` `x = 220, y = 284; ` `    ``if` `(areAmicable(x, y)) ` `       ``cout << ``"Yes"``; ` `    ``else` `       ``cout << ``"No"``; ` `    ``return` `0; ` `}`

## Java

 `// JAVA program to check if two numbers are ` `// Amicable or not. ` `import` `java.io.*; ` ` `  `class` `GFG  ` `{ ` `    ``// Function to calculate sum of all  ` `    ``// proper divisors of a given number ` `    ``static` `int` `divSum(``int` `n) ` `    ``{ ` `        ``// Sum of divisors ` `        ``int` `result = ``0``; ` `     `  `        ``// find all divisors which divides 'num' ` `        ``for` `(``int` `i = ``2``; i <= Math.sqrt(n); i++) ` `        ``{ ` `            ``// if 'i' is divisor of 'n' ` `            ``if` `(n % i == ``0``) ` `            ``{ ` `                ``// if both divisors are same ` `                ``// then add it once else add ` `                ``// both ` `                ``if` `(i == (n / i)) ` `                    ``result += i; ` `                ``else` `                    ``result += (i + n / i); ` `            ``} ` `        ``} ` `     `  `        ``// Add 1 and n to result as above loop ` `        ``// considers proper divisors greater  ` `        ``// than 1. ` `        ``return` `(result + ``1``); ` `    ``} ` `     `  `    ``// Returns true if x and y are Amicable ` `    ``// else false. ` `    ``static` `boolean` `areAmicable(``int` `x, ``int` `y) ` `    ``{ ` `        ``if` `(divSum(x) != y) ` `        ``return` `false``; ` `     `  `        ``return` `(divSum(y) == x); ` `    ``} ` `     `  `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `        ``int` `x = ``220``, y = ``284``; ` `        ``if` `(areAmicable(x, y)) ` `        ``System.out.println( ``"Yes"``); ` `        ``else` `        ``System.out.println(``"No"``); ` `     `  `    ``} ` `}  ` ` `  `// This code is contributed by vt_m. `

## Python3

 `# Python program to check  ` `# if two numbers are ` `# Amicable or not. ` `import` `math ` ` `  `# def to calculate sum  ` `# of all proper divisors ` `# of a given number ` `def` `divSum(n) : ` `     `  `    ``# Sum of divisors ` `    ``result ``=` `0` ` `  `    ``# find all divisors  ` `    ``# which divides 'num' ` `    ``for` `i ``in` `range``(``2``, ``int``(math.sqrt(n)) ``+` `1``) : ` `         `  `        ``# if 'i' is  ` `        ``# divisor of 'n' ` `        ``if` `(n ``%` `i ``=``=` `0``) : ` `             `  `            ``# if both divisors are same ` `            ``# then add it once else add ` `            ``# both ` `            ``if` `(i ``=``=` `int``(n ``/` `i)) : ` `                ``result ``=` `result ``+` `i ` `            ``else` `: ` `                ``result ``=` `result ``+`  `                         ``(i ``+` `int``(n ``/` `i)) ` ` `  `    ``# Add 1 and n to result  ` `    ``# as above loop considers ` `    ``# proper divisors greater  ` `    ``# than 1. ` `    ``return` `(result ``+` `1``) ` ` `  `# Returns true if x and y  ` `# are Amicable else false. ` `def` `areAmicable(x, y) : ` ` `  `    ``if` `(divSum(x) !``=` `y) : ` `        ``return` `False` `         `  `    ``return` `(divSum(y) ``=``=` `x)  ` ` `  `# Driver Code ` `x ``=` `220` `y ``=` `284` `if` `(areAmicable(x, y)) : ` `    ``print` `(``"Yes"``) ` `else` `: ` `    ``print` `(``"No"``) ` `     `  `# This code is contributed by  ` `# Manish Shaw(manishshaw1) `

## C#

 `// C# program to check if two numbers are ` `// Amicable or not. ` `using` `System; ` ` `  `class` `GFG  ` `{ ` `    ``// Function to calculate sum of all  ` `    ``// proper divisors of a given number ` `    ``static` `int` `divSum(``int` `n) ` `    ``{ ` `        ``// Sum of divisors ` `        ``int` `result = 0; ` `     `  `        ``// find all divisors which divides 'num' ` `        ``for` `(``int` `i = 2; i <= Math.Sqrt(n); i++) ` `        ``{ ` `            ``// if 'i' is divisor of 'n' ` `            ``if` `(n % i == 0) ` `            ``{ ` `                ``// if both divisors are same ` `                ``// then add it once else add ` `                ``// both ` `                ``if` `(i == (n / i)) ` `                    ``result += i; ` `                ``else` `                    ``result += (i + n / i); ` `            ``} ` `        ``} ` `     `  `        ``// Add 1 and n to result as above loop ` `        ``// considers proper divisors greater  ` `        ``// than 1. ` `        ``return` `(result + 1); ` `    ``} ` `     `  `    ``// Returns true if x and y are Amicable ` `    ``// else false. ` `    ``static` `bool` `areAmicable(``int` `x, ``int` `y) ` `    ``{ ` `        ``if` `(divSum(x) != y) ` `        ``return` `false``; ` `     `  `        ``return` `(divSum(y) == x); ` `    ``} ` `     `  `    ``public` `static` `void` `Main ()  ` `    ``{ ` `        ``int` `x = 220, y = 284; ` `         `  `        ``if` `(areAmicable(x, y)) ` `            ``Console.WriteLine( ``"Yes"``); ` `        ``else` `            ``Console.WriteLine(``"No"``); ` `     `  `    ``} ` `}  ` ` `  `// This code is contributed by vt_m. `

## PHP

 ` `

Output:

```Yes
```

My Personal Notes arrow_drop_up Budding Web DeveloperKeen learnerAverage CoderDancer&Social Activist

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : vt_m, manishshaw1

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.