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.
insert into elements values (10); insert into elements values (37);
function result: +----+ | 2 | | 10 | | 20 | | 10 | +----+
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,)]
function result: +----+ | 10 | | 37 | +----+
insert into elements values (10); insert into elements values (37);
function result: +----+ | 2 | | 10 | | 20 | | 10 | +----+
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,)]
function result: +----+ | 10 | | 37 | +----+
insert into elements values (10); insert into elements values (37);
function result: +----+ | 42 | +----+
function result: +----+ | 47 | +----+
insert into elements values (10); insert into elements values (11); insert into elements values (12); insert into elements values (13);
function result: +----+ | 42 | +----+
function result: +----+ | 46 | +----+
insert into elements values (10); insert into elements values (11); insert into elements values (12); insert into elements values (13);
function result: +----+ | 42 | +----+
function result: +----+ | 46 | +----+
The solution obtained perfect score.
function result: +----+ | 42 | +----+
function result: +----+ | 55 | +----+
function result: +----+ | 45 | +----+
function result: +----+ | 12 | +----+
function result: +----+ | 10 | +----+
function result: +----+ | 76 | +----+
function result: +----+ | 31 | +----+
function result: +-----+ | 167 | +-----+
function result: +-------+ | -1000 | +-------+
function result: +-------+ | 11800 | +-------+
function result: +---------+ | 1810000 | +---------+
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.
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 | } |
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 | } |
No lines have been modified, therefore the final score is 0.
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 | } |
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 | } |
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 | } |
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 | } |
[0, 2, 2]
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 | } |
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 | } |
[0, 2, 2]
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 | } |
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 | } |
[0, 2, 2]
[3, 4, 5, 2, 2]
[1, 1, 1, 1, 2, 2, 2, 2]
[1, 1, 1, 1, 1, 2, 2, 2, 2]
function result: 2
function result: -1
function result: -1
function result: 1
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 | } |
[0, 2, 2]
[3, 4, 5, 2, 2]
[1, 1, 1, 1, 2, 2, 2, 2]
[1, 1, 1, 1, 1, 2, 2, 2, 2]
function result: 2
function result: -1
function result: -1
function result: 1
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 | } |
The solution obtained perfect score.
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].
Test from the task description
got -1, but equilibrium point exists, for example on position 1
Test from the task description
got 5, but it is not equilibrium point, sum[0..4]=4, sum[6..7]=3
# 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)
# 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)
# 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)
# 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)
# 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)
# 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)
[-1, 1, 3, 64]
# 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)
[-1, 1, 1, -1]
# 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)
# 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)
[1, 1, 2, 4]
# 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)
[1, 1, 2, 4]
# 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)
The following issues have been detected: timeout errors.
Large performance test, O(n^2) solutions should fail.
running time: 0.320 sec., time limit: 0.192 sec.
Large performance test, O(n^2) solutions should fail.
Killed. Hard limit reached: 6.000 sec.