Tasks Details
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
The submission is being evaluated.
medium
Find the maximal sum of any double slice.
Task Score
100%
Correctness
100%
Performance
100%
A non-empty array A consisting of N integers is given.
A triplet (X, Y, Z), such that 0 ≤ X < Y < Z < N, is called a double slice.
The sum of double slice (X, Y, Z) is the total of A[X + 1] + A[X + 2] + ... + A[Y − 1] + A[Y + 1] + A[Y + 2] + ... + A[Z − 1].
For example, array A such that:
A[0] = 3 A[1] = 2 A[2] = 6 A[3] = -1 A[4] = 4 A[5] = 5 A[6] = -1 A[7] = 2contains the following example double slices:
- double slice (0, 3, 6), sum is 2 + 6 + 4 + 5 = 17,
- double slice (0, 3, 7), sum is 2 + 6 + 4 + 5 − 1 = 16,
- double slice (3, 4, 5), sum is 0.
The goal is to find the maximal sum of any double slice.
Write a function:
def solution(A)
that, given a non-empty array A consisting of N integers, returns the maximal sum of any double slice.
For example, given:
A[0] = 3 A[1] = 2 A[2] = 6 A[3] = -1 A[4] = 4 A[5] = 5 A[6] = -1 A[7] = 2the function should return 17, because no double slice of array A has a sum of greater than 17.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [3..100,000];
- each element of array A is an integer within the range [−10,000..10,000].
Copyright 2009–2026 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Python
Time spent on task 13 minutes
Notes
not defined yet
Code: 00:26:30 UTC,
java,
autosave
Code: 00:26:40 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:26:59 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def
def solution(A):
if len(A) < 3:
return 0
left_arr = right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:27:20 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def
def solution(A):
size = len(A)
if size < 3:
return 0
left_arr = right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:27:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def
def solution(A):
size = len(A)
if size < 3:
return 0
left_arr = right_arr = [0]
arr = []
s1 = 0
for i in range(1, size-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(size-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(size-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:27:31 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def
def solution(A):
size = len(A)
if size < 3:
return 0
left_arr = right_arr = [0]
arr = []
s1 = 0
for i in range(1, size-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(size-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(size-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:27:35 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
size = len(A)
if size < 3:
return 0
left_arr = right_arr = [0]
arr = []
s1 = 0
for i in range(1, size-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(size-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(size-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:27:48 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
size = len(A)
if size < 3:
return 0
left_arr = right_arr = [0]
arr = []
s1 = 0
for i in range(1, size-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(size-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:28:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def
def solution(A):
size = len(A)
if len(A) < 3:
return 0
left_arr = right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:28:01 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def
def solution(A):
size = len(A)
if len(A) < 3:
return 0
left_arr = right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:28:09 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def
def solution(A):
if len(A) < 3:
return 0
left_arr = right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:28:16 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
if len(A) < 3:
return 0
left_arr = right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:28:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
if len(A) < 3:
return 0
left_arr =
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:28:34 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:28:51 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
size = len(A)
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:29:03 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
size = len(A) - 1
if size < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:29:14 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
size = len(A) - 1
if size < 2:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:29:57 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
size = len(A) - 1
if size < 2:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:30:05 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
size = len(A) - 1
if size < 2:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, size-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:30:20 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
size = len(A) - 1
if size < 2:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, size-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(size-1, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(size-1, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:30:31 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
# def
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:30:37 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:30:59 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:31:11 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum():
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:31:21 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum():
for i in range()
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:31:39 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, ):
for i in range()
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:31:52 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, ):
for i in range()
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:32:15 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
for i in range()
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:32:30 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
sum_
for i in range()
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:32:51 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res = 0
for i in range(start, end, step):
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:33:22 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
arr
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:33:32 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
arr
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:33:48 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res_arr = []
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append()
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:34:19 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res_arr = []
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
s1 = 0
for i in range(1, len(A)-1):
s1 = s1 + A[i]
if s1 < 0:
left_arr.append(0)
s1 = 0
continue
left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:34:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res_arr = []
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:34:41 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res_arr = []
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
compute_sum(1, )
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:35:01 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res_arr = []
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
compute_sum(1, len(A)-1, 1, )
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:35:13 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res_arr = []
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
compute_sum(1, len(A)-1, 1)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:35:31 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res_arr = []
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
left_arr = [0]
right_arr = [0]
arr = []
left_arr = compute_sum(1, len(A)-1, 1)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:35:46 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:36:15 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, arr):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1)
right_arr = compute_sum(len(A)-2, 0, -1)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
s2 = 0
for j in range(len(A)-2, 0, -1):
s2 = s2 + A[j]
if s2 < 0:
right_arr.append(0)
s2 = 0
continue
right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:36:22 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1)
right_arr = compute_sum(len(A)-2, 0, -1)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
# s2 = 0
# for j in range(len(A)-2, 0, -1):
# s2 = s2 + A[j]
# if s2 < 0:
# right_arr.append(0)
# s2 = 0
# continue
# right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:36:40 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, ):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + arr[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1)
right_arr = compute_sum(len(A)-2, 0, -1)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
# s2 = 0
# for j in range(len(A)-2, 0, -1):
# s2 = s2 + A[j]
# if s2 < 0:
# right_arr.append(0)
# s2 = 0
# continue
# right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:36:55 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
# s2 = 0
# for j in range(len(A)-2, 0, -1):
# s2 = s2 + A[j]
# if s2 < 0:
# right_arr.append(0)
# s2 = 0
# continue
# right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:36:57 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
# s2 = 0
# for j in range(len(A)-2, 0, -1):
# s2 = s2 + A[j]
# if s2 < 0:
# right_arr.append(0)
# s2 = 0
# continue
# right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:37:24 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 0, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
# s2 = 0
# for j in range(len(A)-2, 0, -1):
# s2 = s2 + A[j]
# if s2 < 0:
# right_arr.append(0)
# s2 = 0
# continue
# right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:37:28 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, -1, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
# s2 = 0
# for j in range(len(A)-2, 0, -1):
# s2 = s2 + A[j]
# if s2 < 0:
# right_arr.append(0)
# s2 = 0
# continue
# right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:37:28 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, -1, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
# s2 = 0
# for j in range(len(A)-2, 0, -1):
# s2 = s2 + A[j]
# if s2 < 0:
# right_arr.append(0)
# s2 = 0
# continue
# right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:37:33 UTC,
py,
verify,
result: Failed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
# s2 = 0
# for j in range(len(A)-2, 0, -1):
# s2 = s2 + A[j]
# if s2 < 0:
# right_arr.append(0)
# s2 = 0
# continue
# right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:37:48 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
res = 0
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
# s1 = 0
# for i in range(1, len(A)-1):
# s1 = s1 + A[i]
# if s1 < 0:
# left_arr.append(0)
# s1 = 0
# continue
# left_arr.append(s1)
# s2 = 0
# for j in range(len(A)-2, 0, -1):
# s2 = s2 + A[j]
# if s2 < 0:
# right_arr.append(0)
# s2 = 0
# continue
# right_arr.append(s2)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:38:23 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
res = 0
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:38:28 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
res = 0
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:38:32 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
res = 0
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)
Code: 00:38:34 UTC,
py,
final,
score:
100
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def compute_sum(start, end, step, A):
res_arr = [0]
res = 0
for i in range(start, end, step):
res = res + A[i]
if res < 0:
res_arr.append(0)
res = 0
continue
res_arr.append(res)
return res_arr
def solution(A):
if len(A) < 3:
return 0
arr = []
left_arr = compute_sum(1, len(A)-1, 1, A)
right_arr = compute_sum(len(A)-2, 0, -1, A)
k = 0
for i in range(len(left_arr)-2, -1, -1):
arr.append(left_arr[i] + right_arr[k])
k = k + 1
return max(arr)