# Smallest sum contiguous subarray

• Difficulty Level : Easy
• Last Updated : 19 May, 2021

Given an array containing n integers. The problem is to find the sum of the elements of the contiguous subarray having the smallest(minimum) sum.
Examples:

```Input : arr[] = {3, -4, 2, -3, -1, 7, -5}
Output : -6
Subarray is {-4, 2, -3, -1} = -6

Input : arr = {2, 6, 8, 1, 4}
Output : 1```

Naive Approach: Consider all the contiguous subarrays of different sizes and find their sum. The subarray having the smallest(minimum) sum is the required answer.
Efficient Approach: It is a variation to the problem of finding the largest sum contiguous subarray based on the idea of Kadane’s algorithm.
Algorithm:

```smallestSumSubarr(arr, n)
Initialize min_ending_here = INT_MAX
Initialize min_so_far = INT_MAX

for i = 0 to n-1
if min_ending_here > 0
min_ending_here = arr[i]
else
min_ending_here += arr[i]
min_so_far = min(min_so_far, min_ending_here)

return min_so_far```

## C++

 `// C++ implementation to find the smallest sum``// contiguous subarray``#include ` `using` `namespace` `std;` `// function to find the smallest sum contiguous subarray``int` `smallestSumSubarr(``int` `arr[], ``int` `n)``{``    ``// to store the minimum value that is ending``    ``// up to the current index``    ``int` `min_ending_here = INT_MAX;``    ` `    ``// to store the minimum value encountered so far``    ``int` `min_so_far = INT_MAX;``    ` `    ``// traverse the array elements``    ``for` `(``int` `i=0; i 0, then it could not possibly``        ``// contribute to the minimum sum further``        ``if` `(min_ending_here > 0)``            ``min_ending_here = arr[i];``        ` `        ``// else add the value arr[i] to min_ending_here   ``        ``else``            ``min_ending_here += arr[i];``        ` `        ``// update min_so_far``        ``min_so_far = min(min_so_far, min_ending_here);           ``    ``}``    ` `    ``// required smallest sum contiguous subarray value``    ``return` `min_so_far;``}`  `// Driver program to test above``int` `main()``{``    ``int` `arr[] = {3, -4, 2, -3, -1, 7, -5};``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``cout << ``"Smallest sum: "``         ``<< smallestSumSubarr(arr, n);``    ``return` `0;    ``}`

## Java

 `// Java implementation to find the smallest sum``// contiguous subarray``class` `GFG {``    ` `    ``// function to find the smallest sum contiguous``    ``// subarray``    ``static` `int` `smallestSumSubarr(``int` `arr[], ``int` `n)``    ``{``        ` `        ``// to store the minimum value that is``        ``// ending up to the current index``        ``int` `min_ending_here = ``2147483647``;``        ` `        ``// to store the minimum value encountered``        ``// so far``        ``int` `min_so_far = ``2147483647``;``        ` `        ``// traverse the array elements``        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{``            ` `            ``// if min_ending_here > 0, then it could``            ``// not possibly contribute to the``            ``// minimum sum further``            ``if` `(min_ending_here > ``0``)``                ``min_ending_here = arr[i];``            ` `            ``// else add the value arr[i] to``            ``// min_ending_here``            ``else``                ``min_ending_here += arr[i];``            ` `            ``// update min_so_far``            ``min_so_far = Math.min(min_so_far,``                                   ``min_ending_here);        ``        ``}``        ` `        ``// required smallest sum contiguous``        ``// subarray value``        ``return` `min_so_far;``    ``}``    ` `    ``// Driver method``    ``public` `static` `void` `main(String[] args)``    ``{``        ` `        ``int` `arr[] = {``3``, -``4``, ``2``, -``3``, -``1``, ``7``, -``5``};``        ``int` `n = arr.length;``        ` `        ``System.out.print(``"Smallest sum: "``                ``+ smallestSumSubarr(arr, n));``    ``}``}` `// This code is contributed by Anant Agarwal.`

## Python

 `# Python program to find the smallest sum``# contiguous subarray``import` `sys` `# function to find the smallest sum``# contiguous subarray``def` `smallestSumSubarr(arr, n):``    ``# to store the minimum value that is ending``    ``# up to the current index``    ``min_ending_here ``=` `sys.maxsize``    ` `    ``# to store the minimum value encountered so far``    ``min_so_far ``=` `sys.maxsize``    ` `    ``# traverse the array elements``    ``for` `i ``in` `range``(n):``        ``# if min_ending_here > 0, then it could not possibly``        ``# contribute to the minimum sum further``        ``if` `(min_ending_here > ``0``):``            ``min_ending_here ``=` `arr[i]``        ` `        ``# else add the value arr[i] to min_ending_here``        ``else``:``            ``min_ending_here ``+``=` `arr[i]``         ` `        ``# update min_so_far``        ``min_so_far ``=` `min``(min_so_far, min_ending_here)``    ` `    ``# required smallest sum contiguous subarray value``    ``return` `min_so_far``    ` `# Driver code``arr ``=` `[``3``, ``-``4``, ``2``, ``-``3``, ``-``1``, ``7``, ``-``5``]``n ``=` `len``(arr)``print` `"Smallest sum: "``, smallestSumSubarr(arr, n)` `# This code is contributed by Sachin Bisht`

## C#

 `// C# implementation to find the``// smallest sum contiguous subarray``using` `System;` `class` `GFG {` `    ``// function to find the smallest sum``    ``// contiguous subarray``    ``static` `int` `smallestSumSubarr(``int``[] arr, ``int` `n)``    ``{``        ``// to store the minimum value that is``        ``// ending up to the current index``        ``int` `min_ending_here = 2147483647;` `        ``// to store the minimum value encountered``        ``// so far``        ``int` `min_so_far = 2147483647;` `        ``// traverse the array elements``        ``for` `(``int` `i = 0; i < n; i++) {` `            ``// if min_ending_here > 0, then it could``            ``// not possibly contribute to the``            ``// minimum sum further``            ``if` `(min_ending_here > 0)``                ``min_ending_here = arr[i];` `            ``// else add the value arr[i] to``            ``// min_ending_here``            ``else``                ``min_ending_here += arr[i];` `            ``// update min_so_far``            ``min_so_far = Math.Min(min_so_far,``                                ``min_ending_here);``        ``}` `        ``// required smallest sum contiguous``        ``// subarray value``        ``return` `min_so_far;``    ``}` `    ``// Driver method``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] arr = { 3, -4, 2, -3, -1, 7, -5 };``        ``int` `n = arr.Length;` `        ``Console.Write(``"Smallest sum: "` `+``             ``smallestSumSubarr(arr, n));``    ``}``}` `// This code is contributed by Sam007`

## PHP

 ` 0,``        ``// then it could not possibly``        ``// contribute to the minimum``        ``// sum further``        ``if` `(``\$min_ending_here` `> 0)``            ``\$min_ending_here` `= ``\$arr``[``\$i``];``        ` `        ``// else add the value arr[i]``        ``// to min_ending_here``        ``else``            ``\$min_ending_here` `+= ``\$arr``[``\$i``];``        ` `        ``// update min_so_far``        ``\$min_so_far` `= min(``\$min_so_far``,``                     ``\$min_ending_here``);        ``    ``}``    ` `    ``// required smallest sum``    ``// contiguous subarray value``    ``return` `\$min_so_far``;``}`  `    ``// Driver Code``    ``\$arr` `= ``array``(3, -4, 2, -3, -1, 7, -5);``    ``\$n` `= ``count``(``\$arr``) ;``    ``echo` `"Smallest sum: "``         ``.smallestSumSubarr(``\$arr``, ``\$n``);` `// This code is contributed by Sam007``?>`

## Javascript

 ``

Output:

`Smallest sum: -6`

Time Complexity: O(n)
This article is contributed by Ayush Jauhari. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.