Find a maximum sum of a compact subsequence of array elements.
Sign up for our newsletter:
Information about upcoming challenges, solutions and lessons directly in your inbox.
Social:
请写一个函数
int solution(int A[], int N);
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
int solution(vector<int> &A);
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
int solution(vector<int> &A);
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
class Solution { public int solution(int[] A); }
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
int solution(List<int> A);
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
func Solution(A []int) int
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
class Solution { public int solution(int[] A); }
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
class Solution { public int solution(int[] A); }
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
function solution(A);
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
fun solution(A: IntArray): Int
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
function solution(A)
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
int solution(NSMutableArray *A);
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
function solution(A: array of longint; N: longint): longint;
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
function solution($A);
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
sub solution { my (@A) = @_; ... }
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
def solution(A)
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
def solution(a)
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
object Solution { def solution(a: Array[Int]): Int }
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
public func solution(_ A : inout [Int]) -> Int
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
function solution(A: number[]): number;
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
请写一个函数
Private Function solution(A As Integer()) As Integer
对于给定的序列 S, 返回它的最大子序列之和。
一个序列S的子序列是指在该序列S中拥有连续的数组下标的元素所组成的序列。
例如, 对于给定的序列
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0我们可以得到下面的子序列:
[2,−6,4,0] [3,2,−6,4,0] [2] [3,2,−6] [−6,4] [](空的子序列)
以及其他的子序列. 子序列 [] 被称为空的子序列, 因为其中不包含任何的元素。 下面的序列则不是给定序列的子序列S:
[3,−6,0], [1], [3,2,−6,0]
最大的子序列之和是指一个序列中所有非空的子序列的元素的总和的最大值. 用更精确的方式来表示:
max(S[p] + S[p+1] + ... + S[q] {其中p, q都是整数 并且} p<q p<q)
对于上面的序列 S, 最大的子序列之和为
5 = S[0] + S[1]
假定:
- N 是 [1..1,000,000] 内的 整数;
- 数组 A 每个元素是取值范围 [−1,000,000..1,000,000] 内的 整数 ;
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
int solution(int A[], int N);
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
int solution(vector<int> &A);
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
int solution(vector<int> &A);
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
class Solution { public int solution(int[] A); }
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
int solution(List<int> A);
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
func Solution(A []int) int
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
class Solution { public int solution(int[] A); }
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
class Solution { public int solution(int[] A); }
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
function solution(A);
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
fun solution(A: IntArray): Int
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
function solution(A)
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
Note: All arrays in this task are zero-indexed, unlike the common Lua convention. You can use #A to get the length of the array A.
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
int solution(NSMutableArray *A);
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
function solution(A: array of longint; N: longint): longint;
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
function solution($A);
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
sub solution { my (@A) = @_; ... }
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
def solution(A)
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
def solution(a)
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
object Solution { def solution(a: Array[Int]): Int }
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
public func solution(_ A : inout [Int]) -> Int
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
function solution(A: number[]): number;
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
A non-empty array A consisting of N integers is given. A pair of integers (P, Q), such that 0 ≤ P ≤ Q < N, is called a slice of array A. The sum of a slice (P, Q) is the total of A[P] + A[P+1] + ... + A[Q].
Write a function:
Private Function solution(A As Integer()) As Integer
that, given an array A consisting of N integers, returns the maximum sum of any slice of A.
For example, given array A such that:
A[0] = 3 A[1] = 2 A[2] = -6 A[3] = 4 A[4] = 0the function should return 5 because:
- (3, 4) is a slice of A that has sum 4,
- (2, 2) is a slice of A that has sum −6,
- (0, 1) is a slice of A that has sum 5,
- no other slice of A has sum greater than (0, 1).
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..1,000,000];
- each element of array A is an integer within the range [−1,000,000..1,000,000];
- the result will be an integer within the range [−2,147,483,648..2,147,483,647].
Information about upcoming challenges, solutions and lessons directly in your inbox.