Tasks Details
elementary
1.
SqlSum
Calculate sum of elements.
Task Score
100%
Correctness
100%
Performance
Not assessed
Given a table elements with the following structure:
create table elements ( v integer not null )write an SQL query that returns the sum of the numbers in column v.
For example, given:
v --- 2 10 20 10your query should return 42.
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used SQL (PostgreSQL)
Total time used 4 minutes
Effective time used 3 minutes
Task timeline
Code: 09:24:21 UTC,
sql-postgres,
autosave
Code: 09:24:38 UTC,
sql-postgres,
autosave
Code: 09:24:39 UTC,
sql-postgres,
verify,
result: Failed
User test case 1:
insert into elements values (10); insert into elements values (37);
Analysis
expand all
Example tests
1.
2.083 s
WRONG ANSWER
function result: +----+ | 2 | | 10 | | 20 | | 10 | +----+
function result: +----+ | 2 | | 10 | | 20 | | 10 | +----+
stderr:
E assert [(2,), (10,), (20,), (10,)] == [(42,)]
At index 0 diff: (2,) != (42,)
Left contains more items, first extra item: (10,)
Full diff:
- [(2,), (10,), (20,), (10,)]
+ [(42,)]
expand all
User tests
1.
2.075 s
OK
function result: +----+ | 10 | | 37 | +----+
function result: +----+ | 10 | | 37 | +----+
Code: 09:25:09 UTC,
sql-postgres,
autosave
Code: 09:25:19 UTC,
sql-postgres,
autosave
Code: 09:25:26 UTC,
sql-postgres,
verify,
result: Failed
User test case 1:
insert into elements values (10); insert into elements values (37);
Analysis
expand all
Example tests
1.
3.026 s
WRONG ANSWER
function result: +----+ | 2 | | 10 | | 20 | | 10 | +----+
function result: +----+ | 2 | | 10 | | 20 | | 10 | +----+
stderr:
E assert [(2,), (10,), (20,), (10,)] == [(42,)]
At index 0 diff: (2,) != (42,)
Left contains more items, first extra item: (10,)
Full diff:
- [(2,), (10,), (20,), (10,)]
+ [(42,)]
expand all
User tests
1.
2.949 s
OK
function result: +----+ | 10 | | 37 | +----+
function result: +----+ | 10 | | 37 | +----+
Code: 09:25:55 UTC,
sql-postgres,
autosave
Code: 09:26:01 UTC,
sql-postgres,
verify,
result: Failed
User test case 1:
insert into elements values (10); insert into elements values (37);
Analysis
expand all
Example tests
1.
2.954 s
OK
function result: +----+ | 42 | +----+
function result: +----+ | 42 | +----+
expand all
User tests
1.
2.981 s
OK
function result: +----+ | 47 | +----+
function result: +----+ | 47 | +----+
Code: 09:26:25 UTC,
sql-postgres,
autosave
Code: 09:26:38 UTC,
sql-postgres,
verify,
result: Failed
User test case 1:
insert into elements values (10); insert into elements values (11); insert into elements values (12); insert into elements values (13);
Analysis
expand all
Example tests
1.
2.082 s
OK
function result: +----+ | 42 | +----+
function result: +----+ | 42 | +----+
expand all
User tests
1.
2.082 s
OK
function result: +----+ | 46 | +----+
function result: +----+ | 46 | +----+
Code: 09:27:33 UTC,
sql-postgres,
verify,
result: Failed
User test case 1:
insert into elements values (10); insert into elements values (11); insert into elements values (12); insert into elements values (13);
Analysis
expand all
Example tests
1.
2.079 s
OK
function result: +----+ | 42 | +----+
function result: +----+ | 42 | +----+
expand all
User tests
1.
2.931 s
OK
function result: +----+ | 46 | +----+
function result: +----+ | 46 | +----+
Code: 09:27:41 UTC,
sql-postgres,
final,
score:
100
Analysis summary
The solution obtained perfect score.
Analysis
expand all
Example tests
1.
2.111 s
OK
function result: +----+ | 42 | +----+
function result: +----+ | 42 | +----+
expand all
Correctness tests
1.
2.084 s
OK
function result: +----+ | 55 | +----+
function result: +----+ | 55 | +----+
1.
0.387 s
OK
function result: +----+ | 45 | +----+
function result: +----+ | 45 | +----+
1.
0.389 s
OK
function result: +----+ | 12 | +----+
function result: +----+ | 12 | +----+
1.
0.415 s
OK
function result: +----+ | 10 | +----+
function result: +----+ | 10 | +----+
1.
0.400 s
OK
function result: +----+ | 76 | +----+
function result: +----+ | 76 | +----+
1.
0.403 s
OK
function result: +----+ | 31 | +----+
function result: +----+ | 31 | +----+
1.
0.400 s
OK
function result: +-----+ | 167 | +-----+
function result: +-----+ | 167 | +-----+
1.
0.408 s
OK
function result: +-------+ | -1000 | +-------+
function result: +-------+ | -1000 | +-------+
1.
0.425 s
OK
function result: +-------+ | 11800 | +-------+
function result: +-------+ | 11800 | +-------+
1.
1.212 s
OK
function result: +---------+ | 1810000 | +---------+
function result: +---------+ | 1810000 | +---------+
easy
Find and correct bugs in a function that finds a value that occurs in more than half of the elements of an array.
Task Score
100%
Correctness
100%
Performance
Not assessed
A non-empty array A consisting of N integers and sorted in a non-decreasing order (i.e. A[0] ≤ A[1] ≤ ... ≤ A[N−1]) is given. The leader of this array is the value that occurs in more than half of the elements of A.
You are given an implementation of a function:
class Solution { public int solution(int[] A); }
that, given a non-empty array A consisting of N integers, sorted in a non-decreasing order, returns the leader of array A. The function should return −1 if array A does not contain a leader.
For example, given array A consisting of ten elements such that:
A[0] = 2 A[1] = 2 A[2] = 2 A[3] = 2 A[4] = 2 A[5] = 3 A[6] = 4 A[7] = 4 A[8] = 4 A[9] = 6the function should return −1, because the value that occurs most frequently in the array, 2, occurs five times, and 5 is not more than half of 10.
Given array A consisting of five elements such that:
A[0] = 1 A[1] = 1 A[2] = 1 A[3] = 1 A[4] = 50the function should return 1.
The attached code is still incorrect for some inputs. Despite the error(s), the code may produce a correct answer for the example test cases. The goal of the exercise is to find and fix the bug(s) in the implementation. You can modify at most three lines.
Assume that:
- N is an integer within the range [1..100,000];
- each element of array A is an integer within the range [0..2,147,483,647];
- array A is sorted in non-decreasing order.
In your solution, focus on correctness. The performance of your solution will not be the focus of the assessment.
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Java 8
Total time used 10 minutes
Effective time used 3 minutes
Task timeline
Code: 09:26:46 UTC,
java,
autosave
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | if (count > pos) |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
Code: 09:27:20 UTC,
java,
verify,
result: Failed
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | if (count > pos) |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
Analysis summary
No lines have been modified, therefore the final score is 0.
Analysis
Code: 09:28:05 UTC,
java,
autosave
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | - if (count > pos) |
| + if (2count > pos) | |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
Code: 09:28:09 UTC,
java,
verify,
result: Failed
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | - if (count > pos) |
| + if (2*count > pos) | |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
Analysis
Code: 09:28:34 UTC,
java,
autosave
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | - if (count > pos) |
| + if (2*count > pos) | |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
Code: 09:28:44 UTC,
java,
verify,
result: Failed
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | - if (count > pos) |
| + if (2*count > pos) | |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
User test case 1:
[0, 2, 2]
Analysis
Code: 09:29:05 UTC,
java,
autosave
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | - if (count > pos) |
| + if (2*count > n) | |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
Code: 09:29:08 UTC,
java,
verify,
result: Passed
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | - if (count > pos) |
| + if (2*count > n) | |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
User test case 1:
[0, 2, 2]
Analysis
Code: 09:35:59 UTC,
java,
autosave
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | - if (count > pos) |
| + if (2*count > n) | |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
Code: 09:36:15 UTC,
java,
verify,
result: Passed
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | - if (count > pos) |
| + if (2*count > n) | |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
User test case 1:
[0, 2, 2]
User test case 2:
[3, 4, 5, 2, 2]
User test case 3:
[1, 1, 1, 1, 2, 2, 2, 2]
User test case 4:
[1, 1, 1, 1, 1, 2, 2, 2, 2]
Analysis
expand all
User tests
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.004 s
OK
function result: -1
function result: -1
1.
0.004 s
OK
function result: -1
function result: -1
1.
0.004 s
OK
function result: 1
function result: 1
Code: 09:36:26 UTC,
java,
verify,
result: Passed
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | - if (count > pos) |
| + if (2*count > n) | |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
User test case 1:
[0, 2, 2]
User test case 2:
[3, 4, 5, 2, 2]
User test case 3:
[1, 1, 1, 1, 2, 2, 2, 2]
User test case 4:
[1, 1, 1, 1, 1, 2, 2, 2, 2]
Analysis
expand all
User tests
1.
0.004 s
OK
function result: 2
function result: 2
1.
0.004 s
OK
function result: -1
function result: -1
1.
0.004 s
OK
function result: -1
function result: -1
1.
0.004 s
OK
function result: 1
function result: 1
Code: 09:36:31 UTC,
java,
final,
score:
100
| 1 | import java.util.*; |
| 2 | class Solution { |
| 3 | int solution(int[] A) { |
| 4 | int n = A.length; |
| 5 | int[] L = new int[n + 1]; |
| 6 | L[0] = -1; |
| 7 | for (int i = 0; i < n; i++) { |
| 8 | L[i + 1] = A[i]; |
| 9 | } |
| 10 | int count = 0; |
| 11 | int pos = (n + 1) / 2; |
| 12 | int candidate = L[pos]; |
| 13 | for (int i = 1; i <= n; i++) { |
| 14 | if (L[i] == candidate) |
| 15 | count = count + 1; |
| 16 | } |
| 17 | - if (count > pos) |
| + if (2*count > n) | |
| 18 | return candidate; |
| 19 | return (-1); |
| 20 | } |
| 21 | } |
Analysis summary
The solution obtained perfect score.
Analysis
expand all
Correctness tests
1.
0.004 s
OK
2.
0.004 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
1.
0.004 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
1.
0.004 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
3.
0.004 s
OK
1.
0.008 s
OK
2.
0.004 s
OK
1.
0.152 s
OK
2.
0.124 s
OK
1.
0.024 s
OK
2.
0.324 s
OK
3.
0.156 s
OK
medium
3.
Equi
Find an index in an array such that its prefix sum equals its suffix sum.
Task Score
70%
Correctness
95%
Performance
18%
This is a demo task.
An array A consisting of N integers is given. An equilibrium index of this array is any integer P such that 0 ≤ P < N and the sum of elements of lower indices is equal to the sum of elements of higher indices, i.e.
A[0] + A[1] + ... + A[P−1] = A[P+1] + ... + A[N−2] + A[N−1].
Sum of zero elements is assumed to be equal to 0. This can happen if P = 0 or if P = N−1.
For example, consider the following array A consisting of N = 8 elements:
A[0] = -1 A[1] = 3 A[2] = -4 A[3] = 5 A[4] = 1 A[5] = -6 A[6] = 2 A[7] = 1P = 1 is an equilibrium index of this array, because:
- A[0] = −1 = A[2] + A[3] + A[4] + A[5] + A[6] + A[7]
P = 3 is an equilibrium index of this array, because:
- A[0] + A[1] + A[2] = −2 = A[4] + A[5] + A[6] + A[7]
P = 7 is also an equilibrium index, because:
- A[0] + A[1] + A[2] + A[3] + A[4] + A[5] + A[6] = 0
and there are no elements with indices greater than 7.
P = 8 is not an equilibrium index, because it does not fulfill the condition 0 ≤ P < N.
Write a function:
def solution(A)
that, given an array A consisting of N integers, returns any of its equilibrium indices. The function should return −1 if no equilibrium index exists.
For example, given array A shown above, the function may return 1, 3 or 7, as explained above.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [0..100,000];
- each element of array A is an integer within the range [−2,147,483,648..2,147,483,647].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Python
Total time used 9 minutes
Effective time used 8 minutes
Task timeline
Code: 09:29:26 UTC,
java,
autosave
Code: 09:30:22 UTC,
py,
verify,
result: Failed
Analysis
expand all
Example tests
example
Test from the task description
Test from the task description
✘
WRONG ANSWER
got -1, but equilibrium point exists, for example on position 1
got -1, but equilibrium point exists, for example on position 1
1.
0.036 s
WRONG ANSWER,
got -1, but equilibrium point exists, for example on position 1
Code: 09:31:37 UTC,
py,
autosave
Code: 09:31:37 UTC,
py,
verify,
result: Failed
Analysis
expand all
Example tests
example
Test from the task description
Test from the task description
✘
WRONG ANSWER
got 5, but it is not equilibrium point, sum[0..4]=4, sum[6..7]=3
got 5, but it is not equilibrium point, sum[0..4]=4, sum[6..7]=3
1.
0.036 s
WRONG ANSWER,
got 5, but it is not equilibrium point, sum[0..4]=4, sum[6..7]=3
Code: 09:33:42 UTC,
py,
autosave
Code: 09:33:45 UTC,
py,
autosave (has pasted lines!)
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
return(mm)
return(-1)
Lines copied from outside of the editor are highlighted with pink color.
Code: 09:33:54 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
return(mm)
return(-1)
Code: 09:34:14 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
if(sum_left==sum_right):
return i
return(-1)
Code: 09:34:26 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
if(sum_left==sum_right):
return i
return(-1)
Analysis
Code: 09:34:45 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
if(sum_left==sum_right):
return i
return(-1)
Code: 09:34:47 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
if(sum_left==sum_right):
return i
return(-1)
User test case 1:
[-1, 1, 3, 64]
Analysis
Code: 09:35:10 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
if(sum_left==sum_right):
return i
return(-1)
User test case 1:
[-1, 1, 1, -1]
Analysis
Code: 09:35:29 UTC,
py,
autosave
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
if(sum_left==sum_right):
return i
return(-1)
Code: 09:35:36 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
if(sum_left==sum_right):
return i
return(-1)
User test case 1:
[1, 1, 2, 4]
Analysis
Code: 09:37:37 UTC,
py,
verify,
result: Passed
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
if(sum_left==sum_right):
return i
return(-1)
User test case 1:
[1, 1, 2, 4]
Analysis
Code: 09:37:39 UTC,
py,
final,
score:
70
# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
def solution(A):
n=len(A)
if(n==0):
return(-1)
for i in range(n):
sum_left=0
sum_right=0
mm=0
for j in range(n):
if(mm<A[j]):
mm=A[j]
for j in range(i):
sum_left+=A[j]
for j in range(i+1,n):
sum_right+=A[j]
if(sum_left==sum_right):
return i
return(-1)
Analysis summary
The following issues have been detected: timeout errors.
Analysis
Detected time complexity:
O(N**2)
expand all
Correctness tests
1.
0.036 s
OK
2.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
6.
0.036 s
OK
7.
0.036 s
OK
8.
0.036 s
OK
9.
0.036 s
OK
1.
0.036 s
OK
2.
0.036 s
OK
3.
0.036 s
OK
4.
0.036 s
OK
5.
0.036 s
OK
6.
0.036 s
OK
7.
0.036 s
OK
8.
0.036 s
OK
9.
0.036 s
OK
10.
0.036 s
OK
11.
0.036 s
OK
12.
0.036 s
OK
13.
0.036 s
OK
14.
0.036 s
OK
15.
0.036 s
OK
16.
0.036 s
OK
17.
0.036 s
OK
18.
0.036 s
OK
19.
0.036 s
OK
20.
0.036 s
OK
21.
0.036 s
OK
22.
0.036 s
OK
23.
0.036 s
OK
24.
0.036 s
OK
25.
0.036 s
OK
26.
0.036 s
OK
27.
0.036 s
OK
1.
0.040 s
OK
expand all
Correctness/performance tests
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
expand all
Performance tests
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
1.
0.044 s
OK
large_pyramid
Large performance test, O(n^2) solutions should fail.
Large performance test, O(n^2) solutions should fail.
✘
TIMEOUT ERROR
running time: 0.320 sec., time limit: 0.192 sec.
running time: 0.320 sec., time limit: 0.192 sec.
1.
0.320 s
TIMEOUT ERROR,
running time: 0.320 sec., time limit: 0.192 sec.
huge_pyramid
Large performance test, O(n^2) solutions should fail.
Large performance test, O(n^2) solutions should fail.
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.