Given an even number **N**, the task is to split all **N** powers of 2 into two sets such that the difference of their sum is minimum.

**Examples:**

Input:n = 4Output:6Explanation:

Here n = 4 which means we have 2^{1}, 2^{2}, 2^{3}, 2^{4}. The most optimal way to divide it into two groups with equal element is 2^{4}+ 2^{1}in one group and 2^{2}+ 2^{3}in another group giving a minimum possible difference of 6.

Input:n = 8Output:30Explanation:

Here n = 8 which means we have 2^{1}, 2^{2}, 2^{3}, 2^{4}, 2^{5}, 2^{6}, 2^{7}, 2^{8}. The most optimal way to divide it into two groups with equal element is 2^{8}+ 2^{1}+ 2^{2}+ 2^{3}in one group and 2^{4}+ 2^{5}+ 2^{6}+ 2^{7}in another group giving a minimum possible difference of 30.

**Approach:** To solve the problem mentioned above we have to follow the steps given below:

- In the first group add the largest element that is
**2**.^{N} - After adding the first number in one group, add
**N/2 – 1**more elements to this group, where the elements has to start from the least power of two or from the beginning of the sequence.**For example**: if N = 4 then add 2^{4}to the first group and add**N/2 – 1**, i.e. 1 more element to this group which is the least which means is 2^{1}. - The remaining element of the sequence forms the elements of the second group.
- Calculate the sum for both the groups and then find the absolute difference between the groups which will eventually be the minimum.

Below is the implementation of the above approach:

## C++

`// C++ program to find the minimum` `// difference possible by splitting` `// all powers of 2 up to N into two ` `// sets of equal size ` `#include<bits/stdc++.h>` `using` `namespace` `std;` ` ` `void` `MinDiff(` `int` `n)` `{` ` ` ` ` `// Store the largest` ` ` `int` `val = ` `pow` `(2, n);` ` ` ` ` `// Form two separate groups` ` ` `int` `sep = n / 2;` ` ` ` ` `// Initialize the sum ` ` ` `// for two groups as 0` ` ` `int` `grp1 = 0;` ` ` `int` `grp2 = 0;` ` ` ` ` `// Insert 2 ^ n in the` ` ` `// first group` ` ` `grp1 = grp1 + val;` ` ` ` ` `// Calculate the sum of` ` ` `// least n / 2 -1 elements` ` ` `// added to the first set ` ` ` `for` `(` `int` `i = 1; i < sep; i++)` ` ` `grp1 = grp1 + ` `pow` `(2, i);` ` ` ` ` `// Sum of remaining` ` ` `// n / 2 - 1 elements` ` ` `for` `(` `int` `i = sep; i < n; i++)` ` ` `grp2 = grp2 + ` `pow` `(2, i);` ` ` ` ` `// Min Difference between` ` ` `// the two groups` ` ` `cout << (` `abs` `(grp1 - grp2));` `} ` ` ` `// Driver code` `int` `main()` `{` ` ` `int` `n = 4;` ` ` `MinDiff(n); ` `}` ` ` `// This code is contributed by Bhupendra_Singh` |

## Java

`// Java program to find the minimum ` `// difference possible by splitting ` `// all powers of 2 up to N into two ` `// sets of equal size ` `import` `java.lang.Math; ` ` ` `class` `GFG{ ` ` ` `public` `static` `void` `MinDiff(` `int` `n) ` `{ ` ` ` ` ` `// Store the largest ` ` ` `int` `val = (` `int` `)Math.pow(` `2` `, n); ` ` ` ` ` `// Form two separate groups ` ` ` `int` `sep = n / ` `2` `; ` ` ` ` ` `// Initialize the sum ` ` ` `// for two groups as 0 ` ` ` `int` `grp1 = ` `0` `; ` ` ` `int` `grp2 = ` `0` `; ` ` ` ` ` `// Insert 2 ^ n in the ` ` ` `// first group ` ` ` `grp1 = grp1 + val; ` ` ` ` ` `// Calculate the sum of ` ` ` `// least n / 2 -1 elements ` ` ` `// added to the first set ` ` ` `for` `(` `int` `i = ` `1` `; i < sep; i++) ` ` ` `grp1 = grp1 + (` `int` `)Math.pow(` `2` `, i); ` ` ` ` ` `// Sum of remaining ` ` ` `// n / 2 - 1 elements ` ` ` `for` `(` `int` `i = sep; i < n; i++) ` ` ` `grp2 = grp2 + (` `int` `)Math.pow(` `2` `, i); ` ` ` ` ` `// Min difference between ` ` ` `// the two groups ` ` ` `System.out.println(Math.abs(grp1 - grp2)); ` `} ` ` ` `// Driver Code ` `public` `static` `void` `main(String args[]) ` `{ ` ` ` `int` `n = ` `4` `; ` ` ` ` ` `MinDiff(n); ` `} ` `} ` ` ` `// This code is contributed by grand_master` |

## Python3

`# Python3 program to find the minimum` `# difference possible by splitting` `# all powers of 2 up to N into two ` `# sets of equal size ` ` ` `def` `MinDiff(n):` ` ` ` ` `# Store the largest` ` ` `val ` `=` `2` `*` `*` `n` ` ` ` ` `# Form two separate groups` ` ` `sep ` `=` `n ` `/` `/` `2` ` ` ` ` `# Initialize the sum ` ` ` `# for two groups as 0` ` ` `grp1 ` `=` `0` ` ` `grp2 ` `=` `0` ` ` ` ` `# Insert 2 ^ n in the` ` ` `# first group` ` ` `grp1 ` `=` `grp1 ` `+` `val` ` ` ` ` `# Calculate the sum of` ` ` `# least n / 2 -1 elements` ` ` `# added to the first set ` ` ` `for` `i ` `in` `range` `(` `1` `, sep):` ` ` `grp1 ` `=` `grp1 ` `+` `2` `*` `*` `i` ` ` ` ` ` ` `# sum of remaining` ` ` `# n / 2 - 1 elements` ` ` `for` `i ` `in` `range` `(sep, n):` ` ` `grp2 ` `=` `grp2 ` `+` `2` `*` `*` `i` ` ` ` ` `# Min Difference between` ` ` `# the two groups` ` ` `print` `(` `abs` `(grp1 ` `-` `grp2)) ` ` ` `# Driver code` `if` `__name__` `=` `=` `'__main__'` `:` ` ` `n ` `=` `4` ` ` `MinDiff(n)` |

## C#

`// C# program to find the minimum ` `// difference possible by splitting ` `// all powers of 2 up to N into two ` `// sets of equal size ` `using` `System;` `class` `GFG{ ` ` ` `public` `static` `void` `MinDiff(` `int` `n) ` `{ ` ` ` ` ` `// Store the largest ` ` ` `int` `val = (` `int` `)Math.Pow(2, n); ` ` ` ` ` `// Form two separate groups ` ` ` `int` `sep = n / 2; ` ` ` ` ` `// Initialize the sum ` ` ` `// for two groups as 0 ` ` ` `int` `grp1 = 0; ` ` ` `int` `grp2 = 0; ` ` ` ` ` `// Insert 2 ^ n in the ` ` ` `// first group ` ` ` `grp1 = grp1 + val; ` ` ` ` ` `// Calculate the sum of ` ` ` `// least n / 2 -1 elements ` ` ` `// added to the first set ` ` ` `for` `(` `int` `i = 1; i < sep; i++) ` ` ` `grp1 = grp1 + (` `int` `)Math.Pow(2, i); ` ` ` ` ` `// Sum of remaining ` ` ` `// n / 2 - 1 elements ` ` ` `for` `(` `int` `i = sep; i < n; i++) ` ` ` `grp2 = grp2 + (` `int` `)Math.Pow(2, i); ` ` ` ` ` `// Min difference between ` ` ` `// the two groups ` ` ` `Console.Write(Math.Abs(grp1 - grp2)); ` `} ` ` ` `// Driver Code ` `public` `static` `void` `Main() ` `{ ` ` ` `int` `n = 4; ` ` ` ` ` `MinDiff(n); ` `} ` `} ` ` ` `// This code is contributed by Akanksha_Rai` |

**Output:**

6

**Time complexity:*** O(N)***Auxiliary Space:*** O(1)*