# Split numbers from 1 to N into two equal sum subsets

• Difficulty Level : Medium
• Last Updated : 17 Aug, 2021

Given an integer N, the task is to divide the numbers from 1 to N into two nonempty subsets such that the sum of elements in the set is equal. Print the element in the subset. If we can’t form any subset then print -1.

Examples:

Input N = 4
Output:
Size of subset 1 is: 2
Elements of the subset are: 1 4
Size of subset 2 is: 2
Elements of the subset are: 2 3
Explanation:
The first and the second set have equal sum that is 5.

Input: N = 8
Output:
Size of subset 1 is: 4
Elements of the subset are: 1 8 3 6
Size of subset 2 is: 4
Elements of the subset are: 2 7 4 5
Explanation:
The first and the second set have equal sum that is 18.

Approach: To solve the problem mentioned above we have to observe the three cases for integer N. Below are the observations:

1. Sum of First N natural numbers is odd: Solution is not possible and the answer will be -1. Because we can’t split the odd sum into 2 equal halfs.
2. Sum of First N natural numbers is even: just loop from last element to first element and take the elements in the set-1 whose value is less than the half of sum , Maintain another set-2  to store the ans which are not included in set-1.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// function to display elements``void` `display(vector<``int``> &v) {``  ``for` `(``auto` `i : v) {``    ``cout << i << ``" "``;``  ``}``  ``cout << endl;``}` `void` `FindAns(``int` `n) {` `  ``// sum of first n natural numbers``  ``int` `sum = n * (n + 1) / 2;` `  ``// two array to store two sets``  ``vector<``int``> a, b;` `  ``// if sum is odd then we can't split in two sets``  ``if` `(sum % 2 == 1) {``    ``cout << -1 << endl;``    ``return``;``  ``}``  ``else` `{``    ``int` `ans = sum / 2; ``// for dividing into two sets` `    ``// traverse from last element and include those who's values are less than or equal to ans` `    ``for` `(``int` `i = n; i >= 1; i--) {` `      ``//  if we can include in our set then take it``      ``if` `(i <= ans) {``        ``a.push_back(i);``        ``ans -= i;``      ``}``      ``//  else move it to other set``      ``else` `{``        ``b.push_back(i);``      ``}``    ``}``    ``// print the elements of first set``    ``cout << ``"Size of subset 1 is : "``;``    ``cout << a.size() << endl;``    ``cout << ``"Elements of subset are : "``;``    ``display(a);` `    ``// print the elements of second set``    ``cout << ``"Size of subset 2 is : "``;``    ``cout << b.size() << endl;``    ``cout << ``"Elements of subset are : "``;``    ``display(b);``  ``}``}` `// Driver code``int` `main() {``  ``// Given number``  ``int` `n = 8;` `  ``// function call``  ``FindAns(n);` `  ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;`` ` `class` `GFG{``    ` `// Function to print the two set``public` `static` `void` `findAns(``int` `N)``{``    ``// Base case``    ``if` `(N <= ``2``)``    ``{``        ``System.out.print(``"-1"``);``        ``return``;``    ``}` `    ``// Sum of first numbers upto N``    ``int` `value = (N * (N + ``1``)) / ``2``;``      ` `    ``// Answer don't exist``      ``if``(value&``1``)``    ``{``      ``System.out.print(``"-1"``);``      ``return``;``    ``}` `    ``// To store the first set``    ``Vector v1 = ``new` `Vector();` `    ``// To store the second set``    ``Vector v2 = ``new` `Vector();` `    ``// When N is even``    ``if` `((N & ``1``) == ``0``)``    ``{``        ``int` `turn = ``1``;``        ``int` `start = ``1``;``        ``int` `last = N;``        ``while` `(start < last)``        ``{``            ``if` `(turn == ``1``)``            ``{``                ``v1.add(start);``                ``v1.add(last);``                ``turn = ``0``;``            ``}``            ``else``            ``{``                ``v2.add(start);``                ``v2.add(last);``                ``turn = ``1``;``            ``}` `            ``// Increment start``            ``start++;` `            ``// Decrement last``            ``last--;``        ``}``    ``}` `    ``// When N is odd``    ``else``    ``{``        ` `        ``// Required sum of the subset``        ``int` `rem = value / ``2``;` `        ``// Boolean array to keep``        ``// track of used elements``        ``boolean``[] vis = ``new` `boolean``[N + ``1``];` `        ``for``(``int` `i = ``1``; i <= N; i++)``            ``vis[i] = ``false``;` `        ``vis[``0``] = ``true``;` `        ``// Iterate from N to 1``        ``for``(``int` `i = N; i >= ``1``; i--)``        ``{``            ``if` `(rem > i)``            ``{``                ``v1.add(i);``                ``vis[i] = ``true``;``                ``rem -= i;``            ``}``            ``else``            ``{``                ``v1.add(rem);``                ``vis[rem] = ``true``;``                ``break``;``            ``}``        ``}` `        ``// Assigning the unused``        ``// elements to second subset``        ``for``(``int` `i = ``1``; i <= N; i++)``        ``{``            ``if` `(!vis[i])``                ``v2.add(i);``        ``}``    ``}` `    ``// Print the elements of first set``    ``System.out.print(``"Size of subset 1 is: "``);``    ``System.out.println(v1.size());``    ``System.out.print(``"Elements of the subset are: "``);``    ` `    ``for``(Integer c : v1)    ``        ``System.out.print(c + ``" "``);``        ` `    ``System.out.println();` `    ``// Print the elements of second set``    ``System.out.print(``"Size of subset 2 is: "``);``    ``System.out.println(v2.size());``    ``System.out.print(``"Elements of the subset are: "``);``    ` `    ``for``(Integer c : v2)    ``        ``System.out.print(c + ``" "``);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given Number``    ``int` `N = ``8``;` `    ``// Function Call``    ``findAns(N);``}``}` `// This code is contributed by divyeshrabadiya07`

## Python3

 `# Python3 program for the``# above approach` `# Function to print``# the two set``def` `findAns(N):` `    ``# Base case``    ``if` `(N <``=` `2``):``        ``print` `(``"-1"``)``        ``return``   ` `    ``# Sum of first numbers upto N``    ``value ``=` `(N ``*` `(N ``+` `1``)) ``/``/` `2` `    ``# Answer don't exist``    ``if``(value & ``1``):``        ``print` `(``"-1"``)``        ``return``  ` `    ``# To store the first set``    ``v1 ``=` `[]` `    ``# To store the second set``    ``v2 ``=` `[]` `    ``# When N is even``    ``if` `(``not` `(N & ``1``)):``        ``turn ``=` `1``        ``start ``=` `1``        ``last ``=` `N``        ` `        ``while` `(start < last):``            ``if` `(turn):``                ``v1.append(start)``                ``v1.append(last)``                ``turn ``=` `0`           `            ``else``:``                ``v2.append(start)``                ``v2.append(last)``                ``turn ``=` `1` `            ``# Increment start``            ``start ``+``=` `1` `            ``# Decrement last``            ``last ``-``=` `1``    ` `    ``# When N is odd``    ``else``:` `        ``# Required sum of``        ``# the subset``        ``rem ``=` `value ``/``/` `2` `        ``# Boolean array to keep``        ``# track of used elements``        ``vis ``=` `[``False``] ``*` `(N ``+` `1``)` `        ``for` `i ``in` `range` `(``1``, N ``+` `1``):``            ``vis[i] ``=` `False` `        ``vis[``0``] ``=` `True` `        ``# Iterate from N to 1``        ``for` `i ``in` `range` `(N , ``0``, ``-``1``):``            ``if` `(rem > i):``                ``v1.append(i)``                ``vis[i] ``=` `True``                ``rem ``-``=` `i           ``            ``else``:``                ``v1.append(rem)``                ``vis[rem] ``=` `True``                ``break``           ` `        ``# Assigning the unused``        ``# elements to second subset``        ``for` `i ``in` `range` `(``1``, N ``+` `1``):``            ``if` `(``not` `vis[i]):``               ``v2.append(i)` `    ``# Print the elements of``    ``# first set``    ``print` `(``"Size of subset 1 is: "``,``           ``end ``=` `"")``    ``print` `(``len``( v1))``    ``print` `(``"Elements of the subset are: "``,``           ``end ``=` `"")``    ` `    ``for` `c ``in` `v1:``      ``print` `(c, end ``=` `" "``)` `    ``print` `()` `    ``# Print the elements of``    ``# second set``    ``print` `(``"Size of subset 2 is: "``,``           ``end ``=` `"")``    ``print``(``len``( v2))``    ``print` `(``"Elements of the subset are: "``,``           ``end ``=` `"")``    ` `    ``for` `c ``in` `v2:``       ``print` `(c, end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``  ` `    ``# Given Number``    ``N ``=` `8` `    ``# Function Call``    ``findAns(N)` `# This code is contributed by Chitranayal`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``    ` `// Function to print the two set``public` `static` `void` `findAns(``int` `N)``{``    ` `    ``// Base case``    ``if` `(N <= 2)``    ``{``        ``Console.Write(``"-1"``);``        ``return``;``    ``}` `    ``// Sum of first numbers upto N``    ``int` `value = (N * (N + 1)) / 2;``  ` `    ``// Answer don't exist``    ``if``(value&1)``    ``{``      ``Console.Write(``"-1"``);``      ``return``;``    ``}` `    ``// To store the first set``    ``List<``int``> v1 = ``new` `List<``int``>();` `    ``// To store the second set``    ``List<``int``> v2 = ``new` `List<``int``>();` `    ``// When N is even``    ``if` `((N & 1) == 0)``    ``{``        ``int` `turn = 1;``        ``int` `start = 1;``        ``int` `last = N;``        ` `        ``while` `(start < last)``        ``{``            ``if` `(turn == 1)``            ``{``                ``v1.Add(start);``                ``v1.Add(last);``                ``turn = 0;``            ``}``            ``else``            ``{``                ``v2.Add(start);``                ``v2.Add(last);``                ``turn = 1;``            ``}` `            ``// Increment start``            ``start++;` `            ``// Decrement last``            ``last--;``        ``}``    ``}` `    ``// When N is odd``    ``else``    ``{``        ` `        ``// Required sum of the subset``        ``int` `rem = value / 2;` `        ``// Boolean array to keep``        ``// track of used elements``        ``bool``[] vis = ``new` `bool``[N + 1];` `        ``for``(``int` `i = 1; i <= N; i++)``            ``vis[i] = ``false``;` `        ``vis = ``true``;` `        ``// Iterate from N to 1``        ``for``(``int` `i = N; i >= 1; i--)``        ``{``            ``if` `(rem > i)``            ``{``                ``v1.Add(i);``                ``vis[i] = ``true``;``                ``rem -= i;``            ``}``            ``else``            ``{``                ``v1.Add(rem);``                ``vis[rem] = ``true``;``                ``break``;``            ``}``        ``}` `        ``// Assigning the unused``        ``// elements to second subset``        ``for``(``int` `i = 1; i <= N; i++)``        ``{``            ``if` `(!vis[i])``                ``v2.Add(i);``        ``}``    ``}` `    ``// Print the elements of first set``    ``Console.Write(``"Size of subset 1 is: "``);``    ``Console.WriteLine(v1.Count);``    ``Console.Write(``"Elements of the subset are: "``);``    ` `    ``foreach``(``int` `c ``in` `v1)    ``        ``Console.Write(c + ``" "``);``        ` `    ``Console.WriteLine();` `    ``// Print the elements of second set``    ``Console.Write(``"Size of subset 2 is: "``);``    ``Console.WriteLine(v2.Count);``    ``Console.Write(``"Elements of the subset are: "``);``    ` `    ``foreach``(``int` `c ``in` `v2)    ``        ``Console.Write(c + ``" "``);``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given number``    ``int` `N = 8;` `    ``// Function call``    ``findAns(N);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``
Output:
```Size of subset 1 is: 4
Elements of the subset are: 1 8 3 6
Size of subset 2 is: 4
Elements of the subset are: 2 7 4 5```

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up