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

*chevron_right*

*filter_none*

## 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
- Number of K's such that the given array can be divided into two sets satisfying the given conditions
- 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
- Difference between Sum of Cubes and Sum of First N Natural Numbers
- 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
- Find remainder of array multiplication divided by n
- Check if an array of 1s and 2s can be divided into 2 parts with equal sum
- Minimize the sum of the squares of the sum of elements of each group the array is divided into
- Count of distinct remainders when N is divided by all the numbers from the range [1, N]

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.