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))

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- Number of K's such that the given array can be divided into two sets satisfying the given conditions
- Possible two sets from first N natural numbers difference of sums as D
- Split N natural numbers into two sets having GCD of their sums greater than 1
- Find the sums for which an array can be divided into sub-arrays of equal sum
- Print all distinct Coprime sets possible from 1 to N
- Check if a large number can be divided into two or more segments of equal sum
- Sum of square-sums of first n natural numbers
- Check if an array of 1s and 2s can be divided into 2 parts with equal sum
- Minimum Cuts can be made in the Chessboard such that it is not divided into 2 parts
- Number of ways N can be divided into four parts to construct a rectangle
- Check if N can be divided into K consecutive elements with a sum equal to N
- Partition a set into two non-empty subsets such that the difference of subset sums is maximum
- Length of the longest increasing subsequence such that no two adjacent elements are coprime
- Largest Coprime Set Between two integers
- Check if a given number can be expressed as pair-sum of sum of first X natural numbers
- Composite XOR and Coprime AND
- Divide first N natural numbers into 3 equal sum subsets
- Count array elements that can be maximized by adding any permutation of first N natural numbers
- Count of integers up to N which are non divisors and non coprime with N
- Minimize the sum of the squares of the sum of elements of each group the array is divided into

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.