Maximum subarray
Ninjas has been given an array. He wants to find a subarray such that the sum of all elements in the subarray is maximum.

Subarray 'A' is greater than sub-array 'B' if sum(A) sum(B). If two sub-array have the same maximum sum, then output the subarray that has a larger length.

A subarray means a contiguous part of an array. For example, In 'arr' = [1, 2, 3, 4], [1, 2], [2, 3, 4] are the contiguous subarry but [1, 3, 4] is not a subarray.

Note:

More than one sub-array can have a maximum sum, in that case, output any.

Input Format:

The first line contains an integer 'T' which denotes the number of test cases or queries to be run. The first line of each test case contains a single integer ‘N’ denoting the size of the array. The second line of each test case contains ‘N’ space-separated integers denoting the elements of the array.

Output Format:

For each case, If the returned subarray is correct then print 1, else print 0. The output of each test case will be printed in a separate line.

Note:

You do not need to input or print anything, and it has already been taken care of. Just implement the given function.

Constraints:

1

Question

Maximum subarray

Ninjas has been given an array. He wants to find a subarray such that the sum of all elements in the subarray is maximum.

Subarray 'A' is greater than sub-array 'B' if sum(A) > sum(B). If two sub-array have the same maximum sum, then output the subarray that has a larger length.

A subarray means a contiguous part of an array. For example, In 'arr' = [1, 2, 3, 4], [1, 2], [2, 3, 4] are the contiguous subarry but [1, 3, 4] is not a subarray.

Note:

More than one sub-array can have a maximum sum, in that case, output any.

Input Format:

The first line contains an integer 'T' which denotes the number of test cases or queries to be run.

The first line of each test case contains a single integer ‘N’ denoting the size of the array.

The second line of each test case contains ‘N’ space-separated integers denoting the elements of the array.

Output Format:

For each case, If the returned subarray is correct then print 1, else print 0.

The output of each test case will be printed in a separate line.

Note:

You do not need to input or print anything, and it has already been taken care of. Just implement the given function.

Constraints:

1 <= T <= 5
1 <= N <= 1000
-99 <= |arr| <= 99

Time limit: 1 sec.

Accepted Answer

Brute Force Approach

Our Brute force approach will figure out all the possible combinations possible. To find a subarray, we need to know both the starting point and the ending out of the array. We can make a loop that would iterate through the array. During each iteration, we will make another nested loop inside which will take all possible combinations where the starting index will be the pointer of the parent loop and the endpoint will be the pointer of the current loop. We can take a few variables which would be updated whenever we get a new subarray with a larger sum.

Algorithm:

Declare a variable ‘maxSum’ and initialize it as ‘minimum integer’
Declare and initialize two variables as ‘start’ and ‘end’ and initialize them as ‘0’ and ‘-1’ respectively.
Run a loop ‘i’ = 0 to ‘N’ traversing all the elements
- Declare a local variable as ‘localSum’ and initialize it as ‘0’
- Run a loop ‘j’ = ‘i’ to N
  - Add the current element to the ‘localSum’
  - If the ‘localSum’ is greater than the ‘maxSum’
    - ‘maxSum’ = ‘localSum’
    - ‘start’ = ‘i’
    - ‘end’ = ‘j
  - If the 'localSum' is equal to the ‘maxSum’ and the difference between ‘end’ and ‘start’ is less than the difference between ‘j’ and ‘i’
    - ‘start’ = ‘i’
    - ‘end’ = ‘j’
Return the part of the array starting from ‘start’ and ending at ‘end’.

Space Complexity: O(n)Explanation:

O(N), where N is the size of the array.

We need a final array to store the result maximum subarray.

Time Complexity: O(n^2)Explanation:

O(N ^ 2) where N is the length of the array.

We iterate through the array to fixed our starting point and for every starting point, we make a loop that will consider all the possible ending points.Therefore we are doing N + (N - 1) + (N - 2) + ..+ 1 = (N * ( N + 1)) / 2 iterations. So our Time Complexity is O(N ^ 2).

Python (3.5)

'''

    Time Complexity: O(N^2)

    Space Complexity: O(N)



    Where N is the total number of elements of the array.

'''



def maximumSumSubarray(n, arr):

	

	# Declare a variable maxSum and initialize it as minimum integer

	maxSum = -1 *(10 ** 9)

	

	# Declare and initialize two variables as start and end and initialize them as 0 and -1 respectively.

	start = 0

	end = -1

	

	# Run a loop i = 0 to N traversing all the elements

	for i in range(0, n):



		# Declare a local variable as localSum and initialize it as 0

		localSum = 0

		

		for j in range(i, n):

			

			# Add the current element to the 'localSum' 

			localSum = localSum + arr[j]

			

			# If the 'localSum is greater than the 'maxSum' update all variables

			if ( localSum > maxSum ):

				

				maxSum = localSum

				start = i

				end = j

				

			elif( localSum == maxSum ):

				if( end - start < j - i ):

					start = i

					end = j

					

	ans = []

	

	for i in range(start, end + 1):

		ans.append(arr[i])

		

	return ans

C++ (g++ 5.4)

/*

    Time Complexity: O(N ^ 2)

    Space Complexity: O(N)



    Where 'N' is the total number of elements of the array.

*/





vector maximumsumSubarray(vector &arr , int n)

{

	// Declare a variable 'maxSum' and initialize it as minimum integer

    	int maxSum = INT_MIN;

	

	// Declare and initialize two variables as 'start' and 'end' and initialize them as 0 and -1 respectively.

	int start = 0;

	int end = -1;

	

	// Run a loop i = 0 to N traversing all the elements

	for( int i = 0; i < n; i++)

	{

	

		// Declare a local variable as 'localSum' and initialize it as 0

		int localSum = 0;

		for( int j = i; j < n; j++)

		{

			// Add the current element to the 'localSum'

			localSum = localSum + arr[j];

			

			// If the 'localSum' is greater than the 'maxSum' update all variables

			if ( localSum > maxSum )

			{

				maxSum = localSum;

				start = i;

				end = j;

			}

			else if( localSum == maxSum )

			{

				if( end-start < j - i )

				{

					start = i;

					end = j;

				}

			}

		}

	}

	

	vector ans;



	for(int i = start; i <= end; i++)

	{

		ans.push_back(arr[i]);

	}

	

	return ans;

}

Java (SE 1.8)


/*
	Time Complexity: O(N^2)
	Space Complexity: O(N)
	
	Where N is the total number of elements of the array.
*/

import java.util.ArrayList;

public class Solution {
	public static ArrayList maximumsumSubarray(int n, int arr[]) {

		// Declare a variable maxSum and initialize it as minimum integer
		int maxSum = Integer.MIN_VALUE;

		// Declare and initialize two variables as start and end and initialize them as
		// 0 and -1 respectively.
		int start = 0;
		int end = -1;

		// Run a loop i = 0 to N traversing all the elements
		for (int i = 0; i < n; i++) {

			// Declare a local variable as localSum and initialize it as 0
			int localSum = 0;
			for (int j = i; j < n; j++) {
				// Add the current element to the localSum
				localSum = localSum + arr[j];

				// If the localSum is greater than the maxSum
				// update all variables
				if (localSum > maxSum) {
					maxSum = localSum;
					start = i;
					end = j;
				} else if (localSum == maxSum) {
					if (end - start < j - i) {
						start = i;
						end = j;
					}
				}
			}
		}

		ArrayList ans = new ArrayList<>();
		for (int i = start; i <= end; i++) {
			ans.add(arr[i]);
		}

		return ans;
	}

}

Accepted Answer

Dynamic Programming

As we know that we cannot have a negative-sum, we can simply maintain two variables as maximum and local sum where we would add every element to local sum. If our local sum exceeds our maximum sum, we shall update our maximum sum and even note down the index. If in any case, our local sum becomes negative, then it’s better to not consider any elements only and we would again start from the next index with local sum as 0.

Algorithm:

Declare a variable ‘maxSum’ and initialize it with ‘minimum integer’
Declare a variable ‘localSum’ and initialize it with ‘0’
Declare 3 counter variables as ‘start’ , ‘end’ , ‘newStart’ as 0, 0, 0
Run a loop from i = 0 to N
- Add a current element to ‘localSum’
- If 'localSum' is greater than 'maxSum'
  - Update ‘maxSum’ with 'localSum', update start with ‘newStart’ and end with loop counter ‘i’
- If 'localSum' is equal to ‘maxSum’ and the difference between ‘end’ and ‘start’ is less than the difference between ‘newStart’ and ‘i’
  - Update start with ‘newStart’ and end with ‘i’
- If 'localSum' is below ‘0’
  - Update ‘localSum’ as 0 and set ‘newStart' as ‘i’ + 1
Return the part of the array starting from ‘start’ and ending at ‘end’

Space Complexity: O(n)Explanation:

O(N), where N is the size of the array.

We need a final array to store the result maximum subarray.

Time Complexity: O(n)Explanation:

O(N), where N is the length of the array.

As we are traveling the entire array only once, so time complexity is O(N)

Java (SE 1.8)


/*
	Time Complexity: O(N)
	Space Complexity: O(N)
	
	Where N is the total number of elements of the array.
*/

import java.util.ArrayList;

public class Solution {
	public static ArrayList maximumsumSubarray(int n, int arr[]) {

		// Declare a variable maxSum and initialize it as minimum integer
		int maxSum = Integer.MIN_VALUE;

		// Declare a variable localSum and initialize it as 0
		int localSum = 0;

		// Declare and initialize three variables as start,end and newStart and
		// initialize them as 0, 0, 0 respectively.
		int start = 0;
		int end = 0;
		int newStart = 0;

		// Run a loop i = 0 to N traversing all the elements
		for (int i = 0; i < n; i++) {
			// Add the current element to the localSum
			localSum = localSum + arr[i];

			// If the localSum is greater than the maxSum update all variables
			if (localSum > maxSum) {
				maxSum = localSum;
				start = newStart;
				end = i;
			} else if (localSum == maxSum) {
				if (end - start < i - newStart) {
					start = newStart;
					end = i;
				}
			}
			if (localSum < 0) {
				localSum = 0;
				newStart = i + 1;
			}
		}

		ArrayList ans= new ArrayList<>();
		for (int i = start; i <= end; i++) {
			ans.add(arr[i]);
		}

		return ans;

	}
}

C++ (g++ 5.4)

/*

    Time Complexity: O(N)

    Space Complexity: O(N)



    Where N is the total number of elements of the array.

*/





vector maximumsumSubarray(vector &arr , int n)

{



	// Declare a variable 'maxSum' and initialize it as minimum integer

        int maxSum = INT_MIN;

    

        // Declare a variable 'localSum' and initialize it as 0

        int localSum = 0;

	

	// Declare and initialize three variables as 'start', 'end' and 'newStart' and initialize them as 0, 0, 0 respectively.

	int start = 0;

	int end = 0;

	int newStart = 0;

	

	// Run a loop i = 0 to 'N' traversing all the elements

	for( int i = 0; i < n; i++)

	{

		// Add the current element to the localSum

		localSum = localSum + arr[i];

		

		// If the 'localSum' is greater than the maxSum update all variables

		if ( localSum > maxSum )

		{

			maxSum = localSum;

			start = newStart;

			end = i;

		}

		else if( localSum == maxSum )

		{

			if( end-start < i - newStart )

			{

				start = newStart;

				end = i;

			}

		}

		if (localSum < 0)

            {

                localSum = 0;

                newStart = i + 1;

            }

	}

	

	

	vector ans;



	for(int i = start; i <= end; i++)

	{

		ans.push_back(arr[i]);

	}

	

	return ans;

}

Python (3.5)

'''

    Time Complexity: O(N)

    Space Complexity: O(N)



    Where N is the total number of elements of the array.

'''



def maximumSumSubarray(n, arr):

	

	# Declare a variable maxSum and initialize it as minimum integer

	maxSum = -1 * (10 ** 9)

	

	# Declare a variable localSum and initialize it as 0

	localSum = 0

	

	# Declare and initialize three variables as start,end and newStart and initialize them as 0, 0, 0 respectively.

	

	start = 0

	end = 0

	newStart = 0

	

	# Run a loop i = 0 to N traversing all the elements.



	for i in range(0, n):

		

		# Add the current element to the â€˜localSumâ€™

		 

		localSum = localSum + arr[i]

		

		# If the â€˜localSumâ€™ is greater than the â€˜maxSumâ€™ update all variables

		if ( localSum > maxSum ):

			

			maxSum = localSum

			start = newStart

			end = i

			

		elif( localSum == maxSum ):

			if( end-start < i-newStart ):

				start = newStart

				end = i



		if (localSum < 0):

			localSum = 0

			newStart = i + 1

			

	ans = []

	for i in range(start, end + 1):

		

		ans.append(arr[i])

		

	return ans

Ninjas has been given an array. He wants to find a subarray such that the sum of all elements in the subarray is maximum.

Subarray 'A' is greater than sub-array 'B' if sum(A) > sum(B). If two sub-array have the same maximum sum, then output the subarray that has a larger length.

A subarray means a contiguous part of an array. For example, In 'arr' = [1, 2, 3, 4], [1, 2], [2, 3, 4] are the contiguous subarry but [1, 3, 4] is not a subarray.

Note:

Input Format:

Output Format:

Note:

Constraints:

Top Bounteous x Accolite Software Developer interview questions & answers

Popular interview questions of Software Developer

Top HR questions asked in Bounteous x Accolite Software Developer