Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Split first N natural numbers into two sets with minimum absolute difference of their sums

  • Difficulty Level : Medium
  • Last Updated : 26 Apr, 2021

Given an integer N, split the first N natural numbers into two sets such that the absolute difference between their sum is minimum. The task is to print the minimum absolute difference that can be obtained.

Examples:

Input: N = 5
Output: 1
Explanation:
Split the first N (= 5) natural numbers into sets {1, 2, 5} (sum = 8) and {3, 4} (sum = 7).
Therefore, the required output is 1.

Input: N = 6
Output: 1

Naive Approach: This problem can be solved using the Greedy technique. Follow the steps below to solve the problem:

  • Initialize two variables, say sumSet1 and sumSet2 to store the sum of the elements from the two sets.
  • Traverse first N natural numbers from N to 1. For every number, check if the current sum of elements in set1 is less than or equal to the sum of elements in set2. If found to be true, add the currently traversed number into set1 and update sumSet1.
  • Otherwise, add the value of the current natural number to set2 and update sumSet2.
  • Finally, print abs(sumSet1 – sumSet2) as the required answer.

Below is the implementation of the above approach:

C++14




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to split the first N
// natural numbers into two sets
// having minimum absolute
// difference of their sums
int minAbsDiff(int N)
{
    // Stores the sum of
    // elements of set1
    int sumSet1 = 0;
 
    // Stores the sum of
    // elements of set2
    int sumSet2 = 0;
 
    // Traverse first N
    // natural numbers
    for (int i = N; i > 0; i--) {
 
        // Check if sum of elements of
        // set1 is less than or equal
        // to sum of elements of set2
        if (sumSet1 <= sumSet2) {
            sumSet1 += i;
        }
        else {
            sumSet2 += i;
        }
    }
    return abs(sumSet1 - sumSet2);
}
 
// Driver Code
int main()
{
    int N = 6;
    cout << minAbsDiff(N);
}
Java



// Java program to implement
// the above approach
import java.io.*;
  
class GFG{
     
// Function to split the first N
// natural numbers into two sets
// having minimum absolute
// difference of their sums
static int minAbsDiff(int N)
{
     
    // Stores the sum of
    // elements of set1
    int sumSet1 = 0;
  
    // Stores the sum of
    // elements of set2
    int sumSet2 = 0;
  
    // Traverse first N
    // natural numbers
    for(int i = N; i > 0; i--)
    {
         
        // Check if sum of elements of
        // set1 is less than or equal
        // to sum of elements of set2
        if (sumSet1 <= sumSet2)
        {
            sumSet1 += i;
        }
        else
        {
            sumSet2 += i;
        }
    }
    return Math.abs(sumSet1 - sumSet2);
}
 
// Driver code
public static void main (String[] args)
{
    int N = 6;
     
    System.out.println(minAbsDiff(N));
}
}
 
// This code is contributed by offbeat
Python3



# Python3 program to implement
# the above approach
 
# Function to split the first N
# natural numbers into two sets
# having minimum absolute
# difference of their sums
def minAbsDiff(N):
     
    # Stores the sum of
    # elements of set1
    sumSet1 = 0
 
    # Stores the sum of
    # elements of set2
    sumSet2 = 0
 
    # Traverse first N
    # natural numbers
    for i in reversed(range(N + 1)):
         
        # Check if sum of elements of
        # set1 is less than or equal
        # to sum of elements of set2
        if sumSet1 <= sumSet2:
           sumSet1 = sumSet1 + i
        else:
           sumSet2 = sumSet2 + i
       
    return abs(sumSet1 - sumSet2)
 
# Driver Code
N = 6
 
print(minAbsDiff(N))
 
# This code is contributed by sallagondaavinashreddy7
C#



// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Function to split the first N
// natural numbers into two sets
// having minimum absolute
// difference of their sums
static int minAbsDiff(int N)
{
     
    // Stores the sum of
    // elements of set1
    int sumSet1 = 0;
  
    // Stores the sum of
    // elements of set2
    int sumSet2 = 0;
  
    // Traverse first N
    // natural numbers
    for(int i = N; i > 0; i--)
    {
         
        // Check if sum of elements of
        // set1 is less than or equal
        // to sum of elements of set2
        if (sumSet1 <= sumSet2)
        {
            sumSet1 += i;
        }
        else
        {
            sumSet2 += i;
        }
    }
    return Math.Abs(sumSet1 - sumSet2);
}
 
// Driver code
static void Main()
{
    int N = 6;
     
    Console.Write(minAbsDiff(N));
}
}
 
// This code is contributed by divyeshrabadiya07
Javascript



<script>
 
// Javascript program to implement
// the above approach
 
// Function to split the first N
// natural numbers into two sets
// having minimum absolute
// difference of their sums
function minAbsDiff(N)
{
     
    // Stores the sum of
    // elements of set1
    var sumSet1 = 0;
 
    // Stores the sum of
    // elements of set2
    var sumSet2 = 0;
 
    // Traverse first N
    // natural numbers
    for(i = N; i > 0; i--)
    {
         
        // Check if sum of elements of
        // set1 is less than or equal
        // to sum of elements of set2
        if (sumSet1 <= sumSet2)
        {
            sumSet1 += i;
        }
        else
        {
            sumSet2 += i;
        }
    }
    return Math.abs(sumSet1 - sumSet2);
}
 
// Driver code
var N = 6;
 
document.write(minAbsDiff(N));
 
// This code is contributed by umadevi9616
 
</script>
Output
1
Time Complexity: O(N)
Auxiliary Space: O(1)
Efficient Approach: To optimize the above approach the idea is based on the following observations:
Splitting any 4 consecutive integers into 2 sets gives the minimum absolute difference of their sum equal to 0.
Mathematical proof:
Considering 4 consecutive integers {a1, a2, a3, a4}
a4 = a3 + 1
a1=a2  – 1
=> a4 + a1 = a3 + 1 + a2  – 1
=> a4 + a1 = a2 + a3
Follow the steps below to solve the problem:
  • If N % 4 == 0 or N % 4 == 3, then print 0.
  • Otherwise, print 1.
Below is the implementation of the above approach:
C++



// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to split the first N
// natural numbers into two sets
// having minimum absolute
// difference of their sums
int minAbsDiff(int N)
{
    if (N % 4 == 0 || N % 4 == 3) {
        return 0;
    }
    return 1;
}
 
// Driver Code
int main()
{
    int N = 6;
    cout << minAbsDiff(N);
}
Java



// Java program to implement
// the above approach
import java.io.*;
import java.util.*;
 
class GFG{
     
// Function to split the first N
// natural numbers into two sets
// having minimum absolute
// difference of their sums
static int minAbsDiff(int N)
{
    if (N % 4 == 0 || N % 4 == 3)
    {
        return 0;
    }
    return 1;
}
 
// Driver Code
public static void main (String[] args)
{
    int N = 6;
     
    System.out.println(minAbsDiff(N));
}
}
 
// This code is contributed by sallagondaavinashreddy7
Python3



# Python3 program to implement
# the above approach
 
# Function to split the first N
# natural numbers into two sets
# having minimum absolute
# difference of their sums
def minAbsDiff(N):
     
    if (N % 4 == 0 or N % 4 == 3):
        return 0
         
    return 1
 
# Driver Code
N = 6
 
print(minAbsDiff(N))
 
# This code is contributed by sallagondaavinashreddy7
C#



// C# program to implement
// the above approach
using System;
class GFG{
     
// Function to split the first N
// natural numbers into two sets
// having minimum absolute
// difference of their sums
static int minAbsDiff(int N)
{
  if (N % 4 == 0 ||
      N % 4 == 3)
  {
    return 0;
  }
  return 1;
}
 
// Driver Code
public static void Main(String[] args)
{
  int N = 6;
  Console.WriteLine(minAbsDiff(N));
}
}
 
// This code is contributed by 29AjayKumar
Javascript



<script>
// javascript program to implement
// the above approach   
// Function to split the first N
    // natural numbers into two sets
    // having minimum absolute
    // difference of their sums
    function minAbsDiff(N) {
        if (N % 4 == 0 || N % 4 == 3) {
            return 0;
        }
        return 1;
    }
 
    // Driver Code
     
        var N = 6;
 
        document.write(minAbsDiff(N));
 
// This code contributed by gauravrajput1
</script>
Output
1
Time Complexity: O(1)
Auxiliary Space: O(1)

My Personal Notes
arrow_drop_up
Next

Natural Numbers
Recommended Articles
Page :
Split squares of first N natural numbers into two sets with minimum absolute difference of their sums
02, Dec 20
Split N natural numbers into two sets having GCD of their sums greater than 1
06, May 20
First N natural can be divided into two sets with given difference and co-prime sums
18, Apr 18
Possible two sets from first N natural numbers difference of sums as D
13, Apr 18
Split first N natural numbers into two subsequences with non-coprime sums
22, Dec 20
Partition first N natural number into two sets such that their sum is not coprime
28, Jun 19
Minimum length of a rod that can be split into N equal parts that can further be split into given number of equal parts
16, May 21
Split N powers of 2 into two subsets such that their difference of sum is minimum
07, May 20
Split array into two subarrays such that difference of their sum is minimum
02, Sep 20
Sum of square-sums of first n natural numbers
22, May 18
Split array into K subarrays with minimum sum of absolute difference between adjacent elements
21, Dec 20
Arrange first N natural numbers such that absolute difference between all adjacent elements > 1
24, Jan 19
Partition the array into two odd length groups with minimized absolute difference between their median
26, Feb 20
Split a given array into K subarrays minimizing the difference between their maximum and minimum
20, Jun 20
Count ways to split array into two subsets having difference between their sum equal to K
09, Jun 21
Minimize sum of numbers required to convert an array into a permutation of first N natural numbers
14, Jun 21
Split an array containing N elements into K sets of distinct elements
31, May 20
Minimum groups to split Array such that their each pair value difference and position difference are same
30, Jun 21
Find the number of sub arrays in the permutation of first N natural numbers such that their median is M
10, Apr 19
Check if product of first N natural numbers is divisible by their sum
12, Apr 19
Modify sequence of first N natural numbers to a given array by replacing pairs with their GCD
02, Dec 20
Generate a sequence from first X natural numbers which adds up to S on raising 2 to the power of their lowest set bits
03, Jan 21
Place first N natural numbers at indices not equal to their values in an array
24, Jan 21
Count ways to split array into pair of subsets with difference between their sum equal to K
10, Feb 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
hemanthswarna1506
@hemanthswarna1506
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!