# 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’.

**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 <bits/stdc++.h> ` `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; ` `} ` |

*chevron_right*

*filter_none*

## 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 ` |

*chevron_right*

*filter_none*

## 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
[tabby title="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. ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `/* PHP 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*/` ` ` `function` `__gcd (` `$a` `, ` `$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. ` `function` `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` `&& ` ` ` `$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 ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

Yes

**Time Complexity : ** O(log(n))

## Recommended Posts:

- Possible two sets from first N natural numbers difference of sums as D
- Find the sums for which an array can be divided into sub-arrays of equal sum
- Sum of square-sums of first n natural numbers
- Newton's Divided Difference Interpolation Formula
- Difference between sums of odd and even digits
- Composite XOR and Coprime AND
- Largest number less than or equal to N/2 which is coprime to N
- Finding a Non Transitive Coprime Triplet in a Range
- Length of the longest increasing subsequence such that no two adjacent elements are coprime
- Check if an array of 1s and 2s can be divided into 2 parts with equal sum
- Find reminder of array multiplication divided by n
- Minimum Cuts can be made in the Chessboard such that it is not divided into 2 parts
- Check if a large number can be divided into two or more segments of equal sum
- Program to find remainder when large number is divided by r
- Program to find remainder when large number is divided by 11

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.