# Problem

## Statement

Given an integer array `nums`

, find the contiguous subarray (containing at least one number) which has the largest sum and return *its sum*.

A **subarray** is a **contiguous** part of an array.

**Example 1:**

```
Input: nums = [-2,1,-3,4,-1,2,1,-5,4]
Output: 6
Explanation: [4,-1,2,1] has the largest sum = 6.
```

**Example 2:**

```
Input: nums = [1]
Output: 1
```

**Example 3:**

```
Input: nums = [5,4,-1,7,8]
Output: 23
```

**Constraints:**

`1 <= nums.length <= 105`

`104 <= nums[i] <= 104`

**Follow up:** If you have figured out the `O(n)`

solution, try coding another solution using the **divide and conquer** approach, which is more subtle.

## Link

# Solution Link

# Explanation

## Approach

**Kandane’s algorithm**

A) Lets’ consider taking a number that would always be the least number in the entire number system. This is because I want to make sure my first max number is greater than this least number.

B) Let’s take a number to store the sum of the elements traversed in the array.

### Algorithm

- Initialise a variable “sum” with 0 to store the sum of contiguous numbers of the array.
- Initialize a variable maxSum and store value which is the least in every case.
Loop through each element of the array

- Add the element with the sum of previous numbers.
- If sum is greater than the maxSum then update the maxSum value with num.
Also check if the sum is less than 0 set it to 0 again.

**Now why is this required?**There’s no point in storing a number less than 0 because we only have to check the greatest number among the negative numbers because if we keep adding negative numbers it becomes the opposite of greatest number.

## JavaScript Code Implementation

```
/**
* @param {number[]} nums
* @return {number}
*/
var maxSubArray = function(a) {
let maxSum = -(Math.pow(2, 53) - 1); // A
let sum = 0;
for(let i = 0; i< a.length; i++) {
sum += a[i];
if(sum > maxSum) {
maxSum = sum;
}
if(sum < 0) {
sum = 0;
}
}
return maxSum;
};
```

Now I urge you to read the code and do a dry run in your mind to understand it fully.

## Conclusion

You have to keep practising these three variant of this problem to fully understand this and explain this in a real interview

- Return the indices of the contiguous array.
- Return the sub-array.

If you like the content do drop me follow on Twitter learn these concepts with easy.