Open In App

Subarray whose absolute sum is closest to K

Last Updated : 11 Jul, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report

Given an array of n non-negative elements and an integer K, the task is to find the contiguous subarray whose sum of elements shows the minimum deviation from K. In other words, find the subarray whose absolute sum is closest to K. 

Example 

Input: arr[] = {1, 3, 7, 10}, K = 15
Output: 7 10
Explanation: The contiguous subarray [7, 10] shows a minimum deviation of 2 from 15.

Input: arr[] = {1, 2, 3, 4, 5, 6}, K = 6
Output: 1 2 3
Explanation: The contiguous subarray [1, 2, 3] shows a minimum deviation of 0 from 6.

[Naive Approach] Using Brute Force Method - O(n^2) time and O(1) space

The idea is to check the sum of every possible contiguous subarray and calculate its deviation from K. The subarray with the minimum deviation is the answer.

C++ 
// C++ program to find Subarray whose
// absolute sum is closest to K
#include <bits/stdc++.h>
using namespace std;

vector<int> getSubArray(vector<int>& arr, int k) {
    int n = arr.size();
    int minDev = INT_MAX;
    
    // Variables to mark the starting and
    // ending indices of resulting Subarray
    int start = -1, end = -1;
    
    // Check for all subarrays
    for (int i = 0; i < n; i++) {
        int currSum = 0;
        
        for (int j = i; j < n; j++) {
            currSum += arr[j];
            int currDev = abs(k - currSum);
            
            // If less deviation is found
            if (currDev < minDev) {
                minDev = currDev;
                start = i; 
                end = j;
            }
        }
    }
    
    vector<int> ans;
    
    for (int i=start; i<=end; i++) {
        ans.push_back(arr[i]);
    }
    
    return ans;
}

int main() {
    vector<int> arr = {1, 3, 7, 10};
    int k = 15;
    vector<int> ans = getSubArray(arr, k);

    for (auto val: ans) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}
Java 
// Java program to find Subarray whose
// absolute sum is closest to K

import java.util.*;

class GfG {
    
    // Function to get the subarray whose absolute sum is closest to K
    static int[] getSubArray(int[] arr, int k) {
        int n = arr.length;
        int minDev = Integer.MAX_VALUE;

        // Variables to mark the starting and
        // ending indices of resulting Subarray
        int start = -1, end = -1;

        // Check for all subarrays
        for (int i = 0; i < n; i++) {
            int currSum = 0;

            for (int j = i; j < n; j++) {
                currSum += arr[j];
                int currDev = Math.abs(k - currSum);

                // If less deviation is found
                if (currDev < minDev) {
                    minDev = currDev;
                    start = i;
                    end = j;
                }
            }
        }

        int[] ans = new int[end - start + 1];
        for (int i = start; i <= end; i++) {
            ans[i - start] = arr[i];
        }

        return ans;
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 7, 10};
        int k = 15;
        int[] ans = getSubArray(arr, k);

        for (int val : ans) {
            System.out.print(val + " ");
        }
        System.out.println();
    }
}
Python 
# Python program to find Subarray whose
# absolute sum is closest to K

def getSubArray(arr, k):
    n = len(arr)
    minDev = float('inf')
    
    # Variables to mark the starting and
    # ending indices of resulting Subarray
    start, end = -1, -1
    
    # Check for all subarrays
    for i in range(n):
        currSum = 0
        
        for j in range(i, n):
            currSum += arr[j]
            currDev = abs(k - currSum)
            
            # If less deviation is found
            if currDev < minDev:
                minDev = currDev
                start, end = i, j
    
    return arr[start:end+1]

if __name__ == "__main__":
    arr = [1, 3, 7, 10]
    k = 15
    ans = getSubArray(arr, k)
    
    for i in range(0, len(ans)):
        print(ans[i], end=" ")
    print()
C# 
// C# program to find Subarray whose
// absolute sum is closest to K

using System;

class GfG {

    // Function to get the subarray whose absolute sum is closest to K
    static int[] getSubArray(int[] arr, int k) {
        int n = arr.Length;
        int minDev = int.MaxValue;

        // Variables to mark the starting and
        // ending indices of resulting Subarray
        int start = -1, end = -1;

        // Check for all subarrays
        for (int i = 0; i < n; i++) {
            int currSum = 0;

            for (int j = i; j < n; j++) {
                currSum += arr[j];
                int currDev = Math.Abs(k - currSum);

                // If less deviation is found
                if (currDev < minDev) {
                    minDev = currDev;
                    start = i;
                    end = j;
                }
            }
        }

        int[] ans = new int[end - start + 1];
        for (int i = start; i <= end; i++) {
            ans[i - start] = arr[i];
        }

        return ans;
    }

    static void Main() {
        int[] arr = {1, 3, 7, 10};
        int k = 15;
        int[] ans = getSubArray(arr, k);

        foreach (int val in ans) {
            Console.Write(val + " ");
        }
        Console.WriteLine();
    }
}
JavaScript 
// JavaScript program to find Subarray whose
// absolute sum is closest to K

function getSubArray(arr, k) {
    let n = arr.length;
    let minDev = Infinity;

    // Variables to mark the starting and
    // ending indices of resulting Subarray
    let start = -1, end = -1;

    // Check for all subarrays
    for (let i = 0; i < n; i++) {
        let currSum = 0;

        for (let j = i; j < n; j++) {
            currSum += arr[j];
            let currDev = Math.abs(k - currSum);

            // If less deviation is found
            if (currDev < minDev) {
                minDev = currDev;
                start = i;
                end = j;
            }
        }
    }

    return arr.slice(start, end + 1);
}

let arr = [1, 3, 7, 10];
let k = 15;
let ans = getSubArray(arr, k);

console.log(...ans);

Output
7 10

[Efficient Approach] Using Sliding Window Method - O(n) time and O(1) space

The idea is to use the sliding window technique to efficiently find the subarray with the minimum deviation from K.

Step by step approach:

  1. Initialize two pointers, i and j, to represent the start and end of the sliding window.
  2. Calculate the sum of the current window.
  3. If the sum is less than K, expand the window by moving the j pointer.
  4. If the sum exceeds K, shrink the window by moving the i pointer.
  5. Track the subarray with the minimum deviation from K.
  6. Return the subarray with the smallest deviation. 

Note: This approach only works for array containing non-negative values.

C++ 
// C++ program to find Subarray whose
// absolute sum is closest to K
#include <bits/stdc++.h>
using namespace std;

vector<int> getSubArray(vector<int>& arr, int k) {
    int n = arr.size();
    int minDev = INT_MAX;
    int start = -1, end = -1;
    int currSum = 0, currDev = INT_MAX;
    int i = 0;

    for (int j = 0; j < n; j++) {
        currSum += arr[j];
        
        // Move i till sum is greater than k 
        while (currSum > k && i <= j) {
            currDev = abs(k - currSum);
            
            // Compare deviation at each step.
            if (currDev < minDev) {
                minDev = currDev;
                start = i;
                end = j;
            }
            currSum -= arr[i];
            i++;
        }
        
        currDev = abs(k - currSum);
        if (currDev < minDev) {
            minDev = currDev;
            start = i;
            end = j;
        }
    }
    
    vector<int> ans;
    for (int i=start; i<=end; i++) {
        ans.push_back(arr[i]);
    }
    
    return ans;
}

int main() {
    vector<int> arr = {1, 3, 7, 10};
    int k = 15;
    vector<int> ans = getSubArray(arr, k);

    for (auto val: ans) {
        cout << val << " ";
    }
    cout << endl;
    return 0;
}
Java 
// Java program to find Subarray whose
// absolute sum is closest to K

import java.util.*;

class GfG {
    
    // Function to get the subarray whose absolute sum is closest to K
    static int[] getSubArray(int[] arr, int k) {
        int n = arr.length;
        int minDev = Integer.MAX_VALUE;
        int start = -1, end = -1;
        int currSum = 0, currDev = Integer.MAX_VALUE;
        int i = 0;

        for (int j = 0; j < n; j++) {
            currSum += arr[j];

            // Move i till sum is greater than k
            while (currSum > k && i <= j) {
                currDev = Math.abs(k - currSum);

                // Compare deviation at each step.
                if (currDev < minDev) {
                    minDev = currDev;
                    start = i;
                    end = j;
                }
                currSum -= arr[i];
                i++;
            }

            currDev = Math.abs(k - currSum);
            if (currDev < minDev) {
                minDev = currDev;
                start = i;
                end = j;
            }
        }

        int[] ans = new int[end - start + 1];
        for (int x = start; x <= end; x++) {
            ans[x - start] = arr[x];
        }

        return ans;
    }

    public static void main(String[] args) {
        int[] arr = {1, 3, 7, 10};
        int k = 15;
        int[] ans = getSubArray(arr, k);

        for (int val : ans) {
            System.out.print(val + " ");
        }
        System.out.println();
    }
}
Python 
# Python program to find Subarray whose
# absolute sum is closest to K

def getSubArray(arr, k):
    n = len(arr)
    minDev = float('inf')
    start, end = -1, -1
    currSum = 0
    currDev = float('inf')
    i = 0

    for j in range(n):
        currSum += arr[j]

        # Move i till sum is greater than k
        while currSum > k and i <= j:
            currDev = abs(k - currSum)

            # Compare deviation at each step.
            if currDev < minDev:
                minDev = currDev
                start, end = i, j
            currSum -= arr[i]
            i += 1

        currDev = abs(k - currSum)
        if currDev < minDev:
            minDev = currDev
            start, end = i, j

    return arr[start:end + 1]

if __name__ == "__main__":
    arr = [1, 3, 7, 10]
    k = 15
    ans = getSubArray(arr, k)
    
    print(*ans)
C# 
// C# program to find Subarray whose
// absolute sum is closest to K

using System;

class GfG {

    // Function to get the subarray whose absolute sum is closest to K
    static int[] getSubArray(int[] arr, int k) {
        int n = arr.Length;
        int minDev = int.MaxValue;
        int start = -1, end = -1;
        int currSum = 0, currDev = int.MaxValue;
        int i = 0;

        for (int j = 0; j < n; j++) {
            currSum += arr[j];

            // Move i till sum is greater than k
            while (currSum > k && i <= j) {
                currDev = Math.Abs(k - currSum);

                // Compare deviation at each step.
                if (currDev < minDev) {
                    minDev = currDev;
                    start = i;
                    end = j;
                }
                currSum -= arr[i];
                i++;
            }

            currDev = Math.Abs(k - currSum);
            if (currDev < minDev) {
                minDev = currDev;
                start = i;
                end = j;
            }
        }

        int[] ans = new int[end - start + 1];
        for (int x = start; x <= end; x++) {
            ans[x - start] = arr[x];
        }

        return ans;
    }

    static void Main() {
        int[] arr = {1, 3, 7, 10};
        int k = 15;
        int[] ans = getSubArray(arr, k);

        foreach (int val in ans) {
            Console.Write(val + " ");
        }
        Console.WriteLine();
    }
}
JavaScript 
// JavaScript program to find Subarray whose
// absolute sum is closest to K

function getSubArray(arr, k) {
    let n = arr.length;
    let minDev = Infinity;
    let start = -1, end = -1;
    let currSum = 0, currDev = Infinity;
    let i = 0;

    for (let j = 0; j < n; j++) {
        currSum += arr[j];

        // Move i till sum is greater than k
        while (currSum > k && i <= j) {
            currDev = Math.abs(k - currSum);

            // Compare deviation at each step.
            if (currDev < minDev) {
                minDev = currDev;
                start = i;
                end = j;
            }
            currSum -= arr[i];
            i++;
        }

        currDev = Math.abs(k - currSum);
        if (currDev < minDev) {
            minDev = currDev;
            start = i;
            end = j;
        }
    }

    return arr.slice(start, end + 1);
}

let arr = [1, 3, 7, 10];
let k = 15;
let ans = getSubArray(arr, k);

console.log(...ans);

Output
7 10

Next Article
Analysis of Algorithms

J
joshi_arihant
Improve
Article Tags :
Practice Tags :

Similar Reads

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