# First N natural can be divided into two sets with given difference and co-prime sums

Given N and M, task is to find whether numbers 1 to N can be divided into two sets such that the absolute difference between the sum of two sets is M and gcd of the sum of two sets is 1 (i.e. Sum of both sets are co-prime).

Prerequisite : GCD in CPP | GCD

Examples :

Input : N = 5 and M = 7
Output : YES
Explanation : as numbers from 1 to 5 can be divided into two sets {1, 2, 3, 5} and {4} such that absolute difference between the sum of both sets is 11 – 4 = 7 which is equal to M and also GCD(11, 4) = 1.

Input : N = 6 and M = 3
Output : NO
Explanation : In this case, Numbers from 1 to 6 can be divided into two sets {1, 2, 4, 5} and {3, 6} such that absolute difference between their sum is 12 – 9 = 3. But, since 12 and 9 are not co-prime as GCD(12, 9) = 3, the answer is ‘NO’.

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

Approach : Since we have 1 to N numbers, we know that the sum of all the numbers is N * (N + 1) / 2. Let S1 and S2 be two sets such that,
1) sum(S1) + sum(S2) = N * (N + 1) / 2
2) sum(S1) – sum(S2) = M
Solving these two equations will give us the sum of both the sets. If sum(S1) and sum(S2) are integers and they are co-prime (their GCD is 1), then there exists a way to split the numbers into two sets. Otherwise, there is no way to split these N numbers.

Below is the implementation of the solution described above.

## C++

 `/* CPP code to determine whether numbers ` `   ``1 to N can be divided into two sets ` `   ``such that absolute difference between  ` `   ``sum of these two sets is M and these ` `   ``two sum are co-prime*/` `#include ` `using` `namespace` `std; ` ` `  `// function that returns boolean value ` `// on the basis of whether it is possible ` `// to divide 1 to N numbers into two sets ` `// that satisfy given conditions. ` `bool` `isSplittable(``int` `n, ``int` `m) ` `{ ` `    ``// initializing total sum of 1 ` `    ``// to n numbers ` `    ``int` `total_sum = (n * (n + 1)) / 2; ` ` `  `    ``// since (1) total_sum = sum_s1 + sum_s2 ` `    ``// and (2) m = sum_s1 - sum_s2 ` `    ``// assuming sum_s1 > sum_s2. ` `    ``// solving these 2 equations to get ` `    ``// sum_s1 and sum_s2 ` `    ``int` `sum_s1 = (total_sum + m) / 2; ` ` `  `    ``// total_sum = sum_s1 + sum_s2 ` `    ``// and therefore ` `    ``int` `sum_s2 = total_sum - sum_s1; ` ` `  `    ``// if total sum is less than the absolute ` `    ``// difference then there is no way we ` `    ``// can split n numbers into two sets ` `    ``// so return false ` `    ``if` `(total_sum < m) ` `        ``return` `false``; ` ` `  `    ``// check if these two sums are ` `    ``// integers and they add up to ` `    ``// total sum and also if their ` `    ``// absolute difference is m. ` `    ``if` `(sum_s1 + sum_s2 == total_sum && ` `        ``sum_s1 - sum_s2 == m) ` ` `  `        ``// Now if two sum are co-prime ` `        ``// then return true, else return false. ` `        ``return` `(__gcd(sum_s1, sum_s2) == 1); ` ` `  `    ``// if two sums don't add up to total ` `    ``// sum or if their absolute difference ` `    ``// is not m, then there is no way to ` `    ``// split n numbers, hence return false ` `    ``return` `false``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `n = 5, m = 7; ` ` `  `    ``// function call to determine answer ` `    ``if` `(isSplittable(n, m)) ` `        ``cout << ``"Yes"``; ` `    ``else` `        ``cout << ``"No"``; ` ` `  `    ``return` `0; ` `} `

## Java

 `/* Java code to determine whether numbers ` `1 to N can be divided into two sets ` `such that absolute difference between  ` `sum of these two sets is M and these ` `two sum are co-prime*/` `class` `GFG  ` `{ ` `    ``static` `int` `GCD (``int` `a, ``int` `b) ` `    ``{ ` `        ``return` `b == ``0` `? a : GCD(b, a % b); ` `    ``} ` `     `  `    ``// function that returns boolean value ` `    ``// on the basis of whether it is possible ` `    ``// to divide 1 to N numbers into two sets ` `    ``// that satisfy given conditions. ` `    ``static` `boolean` `isSplittable(``int` `n, ``int` `m) ` `    ``{ ` `         `  `        ``// initializing total sum of 1 ` `        ``// to n numbers ` `        ``int` `total_sum = (n * (n + ``1``)) / ``2``; ` `     `  `        ``// since (1) total_sum = sum_s1 + sum_s2 ` `        ``// and (2) m = sum_s1 - sum_s2 ` `        ``// assuming sum_s1 > sum_s2. ` `        ``// solving these 2 equations to get ` `        ``// sum_s1 and sum_s2 ` `        ``int` `sum_s1 = (total_sum + m) / ``2``; ` `     `  `        ``// total_sum = sum_s1 + sum_s2 ` `        ``// and therefore ` `        ``int` `sum_s2 = total_sum - sum_s1; ` `     `  `        ``// if total sum is less than the absolute ` `        ``// difference then there is no way we ` `        ``// can split n numbers into two sets ` `        ``// so return false ` `        ``if` `(total_sum < m) ` `            ``return` `false``; ` `     `  `        ``// check if these two sums are ` `        ``// integers and they add up to ` `        ``// total sum and also if their ` `        ``// absolute difference is m. ` `        ``if` `(sum_s1 + sum_s2 == total_sum && ` `                    ``sum_s1 - sum_s2 == m) ` `     `  `            ``// Now if two sum are co-prime ` `            ``// then return true, else return false. ` `            ``return` `(GCD(sum_s1, sum_s2) == ``1``); ` ` `  `        ``// if two sums don't add up to total ` `        ``// sum or if their absolute difference ` `        ``// is not m, then there is no way to ` `        ``// split n numbers, hence return false ` `        ``return` `false``; ` `    ``} ` `     `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String args[])  ` `    ``{ ` `        ``int` `n = ``5``, m = ``7``; ` ` `  `        ``// function call to determine answer ` `        ``if` `(isSplittable(n, m)) ` `            ``System.out.println(``"Yes"``); ` `        ``else` `            ``System.out.println(``"No"``); ` `         `  `    ``} ` `} ` ` `  `// This code is contributed by Sam007 `

## Python3

 `# Python3 code to determine whether numbers ` `# 1 to N can be divided into two sets ` `# such that absolute difference between  ` `# sum of these two sets is M and these ` `# two sum are co-prime ` ` `  `def` `__gcd (a, b): ` ` `  `        ``return` `a ``if``(b ``=``=` `0``) ``else` `__gcd(b, a ``%` `b); ` ` `  `# function that returns boolean value ` `# on the basis of whether it is possible ` `# to divide 1 to N numbers into two sets ` `# that satisfy given conditions. ` `def` `isSplittable(n, m): ` ` `  `    ``# initializing total sum of 1 ` `    ``# to n numbers ` `    ``total_sum ``=` `(``int``)((n ``*` `(n ``+` `1``)) ``/` `2``); ` ` `  `    ``# since (1) total_sum = sum_s1 + sum_s2 ` `    ``# and (2) m = sum_s1 - sum_s2 ` `    ``# assuming sum_s1 > sum_s2. ` `    ``# solving these 2 equations to get ` `    ``# sum_s1 and sum_s2 ` `    ``sum_s1 ``=` `int``((total_sum ``+` `m) ``/` `2``); ` ` `  `    ``# total_sum = sum_s1 + sum_s2 ` `    ``# and therefore ` `    ``sum_s2 ``=` `total_sum ``-` `sum_s1; ` ` `  `    ``# if total sum is less than the absolute ` `    ``# difference then there is no way we ` `    ``# can split n numbers into two sets ` `    ``# so return false ` `    ``if` `(total_sum < m): ` `        ``return` `False``; ` ` `  `    ``# check if these two sums are ` `    ``# integers and they add up to ` `    ``# total sum and also if their ` `    ``# absolute difference is m. ` `    ``if` `(sum_s1 ``+` `sum_s2 ``=``=` `total_sum ``and`  `                 ``sum_s1 ``-` `sum_s2 ``=``=` `m): ` ` `  `        ``# Now if two sum are co-prime ` `        ``# then return true, else return false. ` `        ``return` `(__gcd(sum_s1, sum_s2) ``=``=` `1``); ` ` `  `    ``# if two sums don't add up to total ` `    ``# sum or if their absolute difference ` `    ``# is not m, then there is no way to ` `    ``# split n numbers, hence return false ` `    ``return` `False``; ` ` `  `# Driver code ` `n ``=` `5``; ` `m ``=` `7``; ` ` `  `# function call to determine answer ` `if` `(isSplittable(n, m)): ` `    ``print``(``"Yes"``); ` `else``: ` `    ``print``(``"No"``); ` ` `  `# This code is contributed by mits `

## C#

 `/* C# code to determine whether numbers ` `1 to N can be divided into two sets ` `such that absolute difference between  ` `sum of these two sets is M and these ` `two sum are co-prime*/` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``static` `int` `GCD (``int` `a, ``int` `b) ` `    ``{ ` `        ``return` `b == 0 ? a : GCD(b, a % b); ` `    ``} ` `     `  `    ``// function that returns boolean value ` `    ``// on the basis of whether it is possible ` `    ``// to divide 1 to N numbers into two sets ` `    ``// that satisfy given conditions. ` `    ``static` `bool` `isSplittable(``int` `n, ``int` `m) ` `    ``{ ` `         `  `        ``// initializing total sum of 1 ` `        ``// to n numbers ` `        ``int` `total_sum = (n * (n + 1)) / 2; ` `     `  `        ``// since (1) total_sum = sum_s1 + sum_s2 ` `        ``// and (2) m = sum_s1 - sum_s2 ` `        ``// assuming sum_s1 > sum_s2. ` `        ``// solving these 2 equations to get ` `        ``// sum_s1 and sum_s2 ` `        ``int` `sum_s1 = (total_sum + m) / 2; ` `     `  `        ``// total_sum = sum_s1 + sum_s2 ` `        ``// and therefore ` `        ``int` `sum_s2 = total_sum - sum_s1; ` `     `  `        ``// if total sum is less than the absolute ` `        ``// difference then there is no way we ` `        ``// can split n numbers into two sets ` `        ``// so return false ` `        ``if` `(total_sum < m) ` `            ``return` `false``; ` `     `  `        ``// check if these two sums are ` `        ``// integers and they add up to ` `        ``// total sum and also if their ` `        ``// absolute difference is m. ` `        ``if` `(sum_s1 + sum_s2 == total_sum && ` `                       ``sum_s1 - sum_s2 == m) ` `     `  `            ``// Now if two sum are co-prime ` `            ``// then return true, else return false. ` `            ``return` `(GCD(sum_s1, sum_s2) == 1); ` ` `  `        ``// if two sums don't add up to total ` `        ``// sum or if their absolute difference ` `        ``// is not m, then there is no way to ` `        ``// split n numbers, hence return false ` `        ``return` `false``; ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `n = 5, m = 7; ` ` `  `        ``// function call to determine answer ` `        ``if` `(isSplittable(n, m)) ` `            ``Console.Write(``"Yes"``); ` `        ``else` `            ``Console.Write(``"No"``); ` `    ``} ` `} ` ` `  `// This code is contributed by Sam007. `

## PHP

 ` sum_s2. ` `    ``// solving these 2 equations to get ` `    ``// sum_s1 and sum_s2 ` `    ``\$sum_s1` `= (int)((``\$total_sum` `+ ``\$m``) / 2); ` ` `  `    ``// total_sum = sum_s1 + sum_s2 ` `    ``// and therefore ` `    ``\$sum_s2` `= ``\$total_sum` `- ``\$sum_s1``; ` ` `  `    ``// if total sum is less than the absolute ` `    ``// difference then there is no way we ` `    ``// can split n numbers into two sets ` `    ``// so return false ` `    ``if` `(``\$total_sum` `< ``\$m``) ` `        ``return` `false; ` ` `  `    ``// check if these two sums are ` `    ``// integers and they add up to ` `    ``// total sum and also if their ` `    ``// absolute difference is m. ` `    ``if` `(``\$sum_s1` `+ ``\$sum_s2` `== ``\$total_sum` `&& ` `        ``\$sum_s1` `- ``\$sum_s2` `== ``\$m``) ` ` `  `        ``// Now if two sum are co-prime ` `        ``// then return true, else return false. ` `        ``return` `(__gcd(``\$sum_s1``, ``\$sum_s2``) == 1); ` ` `  `    ``// if two sums don't add up to total ` `    ``// sum or if their absolute difference ` `    ``// is not m, then there is no way to ` `    ``// split n numbers, hence return false ` `    ``return` `false; ` `} ` ` `  `// Driver code ` `\$n` `= 5; ` `\$m` `= 7; ` ` `  `// function call to determine answer ` `if` `(isSplittable(``\$n``, ``\$m``)) ` `    ``echo` `"Yes"``; ` `else` `    ``echo` `"No"``; ` ` `  `// This Code is Contributed by mits ` `?> `

Output:

```Yes
```

Time Complexity : O(log(n))

My Personal Notes arrow_drop_up A competitive coder developer and a learner by choice who is always eager to contribute to the computer science and developer community

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 : Sam007, Mithun Kumar

Article Tags :

3

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