def max_subarray(numbers):
"""Find the largest sum of any contiguous subarray."""
best_sum = 0 # or: float('-inf')
current_sum = 0
for x in numbers:
current_sum = max(0, current_sum + x)
best_sum = max(best_sum, current_sum)
return best_sum
public static int SumArray()
{
var arr = new int[]{ -2, -4, -5, -6, -7, -89, -56 };
var sum = 0;
var max = arr[0];
foreach (var item in arr)
{
sum += item;
// sum = Math.Max(sum,0); resting here will not give expected output
max = Math.Max(sum,max);
sum = Math.Max(sum,0);
}
return max;
}
var maxSequence = function(arr){
var min = 0, ans = 0, i, sum = 0;
for (i = 0; i < arr.length; ++i) {
sum += arr[i];
min = Math.min(sum, min);
ans = Math.max(ans, sum - min);
}
return ans;
}
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
int a[n];
for(int i = 0;i<n;i++){
cin>>a[i];
}
int s = 0;
int mx = INT_MIN;
for(int i =0;i<n;i++){
s+=a[i];
if(s<0){
s=0;
}
mx = max(s,mx);
}
cout<<mx;
return 0;
}
// Java program to print largest
// contiguous array sum
class GFG {
static void maxSubArraySum(int a[], int size)
{
int max_so_far = Integer.MIN_VALUE,
max_ending_here = 0,start = 0,
end = 0, s = 0;
for (int i = 0; i < size; i++)
{
max_ending_here += a[i];
if (max_so_far < max_ending_here)
{
max_so_far = max_ending_here;
start = s;
end = i;
}
if (max_ending_here < 0)
{
max_ending_here = 0;
s = i + 1;
}
}
System.out.println("Maximum contiguous sum is "
+ max_so_far);
System.out.println("Starting index " + start);
System.out.println("Ending index " + end);
}
// Driver code
public static void main(String[] args)
{
int a[] = { -2, -3, 4, -1, -2, 1, 5, -3 };
int n = a.length;
maxSubArraySum(a, n);
}
}
// This code is contributed by prerna saini
// A Divide and Conquer based Java
// A for maximum subarray sum
// problem
import java.util.*;
class GFG {
// Find the maximum possible sum in arr[]
// such that arr[m] is part of it
static int maxCrossingSum(int arr[], int l, int m,
int h)
{
// Include elements on left of mid.
int sum = 0;
int left_sum = Integer.MIN_VALUE;
for (int i = m; i >= l; i--) {
sum = sum + arr[i];
if (sum > left_sum)
left_sum = sum;
}
// Include elements on right of mid
sum = 0;
int right_sum = Integer.MIN_VALUE;
for (int i = m; i <= h; i++) {
sum = sum + arr[i];
if (sum > right_sum)
right_sum = sum;
}
// Return sum of elements on left
// and right of mid
// returning only left_sum + right_sum will fail for
// [-2, 1]
return Math.max(left_sum + right_sum - arr[m],
Math.max(left_sum, right_sum));
}
// Returns sum of maximum sum subarray
// in aa[l..h]
static int maxSubArraySum(int arr[], int l, int h)
{
//Invalid Range: low is greater than high
if (l > h)
return Integer.MIN_VALUE;
// Base Case: Only one element
if (l == h)
return arr[l];
// Find middle point
int m = (l + h) / 2;
/* Return maximum of following three
possible cases:
a) Maximum subarray sum in left half
b) Maximum subarray sum in right half
c) Maximum subarray sum such that the
subarray crosses the midpoint */
return Math.max(
Math.max(maxSubArraySum(arr, l, m-1),
maxSubArraySum(arr, m + 1, h)),
maxCrossingSum(arr, l, m, h));
}
/* Driver program to test maxSubArraySum */
public static void main(String[] args)
{
int arr[] = { 2, 3, 4, 5, 7 };
int n = arr.length;
int max_sum = maxSubArraySum(arr, 0, n - 1);
System.out.println("Maximum contiguous sum is "
+ max_sum);
}
}
// This code is contributed by Prerna Saini