Test results - Codility

Tasks Details

medium

1. DreamTeam

Divide developers into two teams to maximize their total contribution.

Task Score

66%

Correctness

100%

Performance

27%

A company has employed N developers (numbered from 0 to N−1) and wants to divide them into two teams. The first is a front-end team with F developers. The second is a back-end team with N−F developers. If the K-th developer is assigned to the front-end team then their contribution is A[K], and if they are assigned to the back-end team then their contribution is B[K]. What is the maximum sum of contributions the company can achieve?

Write a function:

def solution(A, B, F)

that, given two arrays A, B (consisting of N integers each) and the integer F, returns the maximum sum of contributions the company can achieve.

Examples:

1. Given A = [4, 2, 1], B = [2, 5, 3] and F = 2, the function should return 10. There should be two front-end developers and one back-end developer. The 0th and 2nd developers should be assigned to the front-end team (with contributions 4 and 1) and the 1st developer should be assigned to the back-end team (with contribution 5).

2. Given A = [7, 1, 4, 4], B = [5, 3, 4, 3] and F = 2, the function should return 18. The 0th and 3rd developers should be assigned to the front-end team and the 1st and 2nd developers should be assigned to the back-end team.

3. Given A = [5, 5, 5], B = [5, 5, 5] and F = 1, the function should return 15. The 0th developer can be assigned to the front-end team and the 1st and 2nd developers can be assigned to the back-end team.

Write an efficient algorithm for the following assumptions:

N is an integer within the range [1..200,000];

arrays A and B have equal lengths;

each element of array A is an integer within the range [0..1,000];

F is an integer within the range [0..N].

Solution

Programming language used Python

Time spent on task 54 minutes

Notes

not defined yet

Code: 16:01:38 UTC, java, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

// you can also use imports, for example:
// import java.util.*;

// you can write to stdout for debugging purposes, e.g.
// System.out.println("this is a debug message");

class Solution {
    public int solution(int[] A, int[] B, int F) {
        // write your code in Java SE 8
    }
}

Code: 16:01:44 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    # write your code in Python 3.6
    pass

Code: 16:07:39 UTC, py, autosave

show code in pop-up

1 2 3 4 5

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):

Code: 16:08:24 UTC, py, autosave

show code in pop-up

1 2 3 4 5

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    skil

Code: 16:08:45 UTC, py, autosave

show code in pop-up

1 2 3 4 5

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = zip

Code: 16:10:47 UTC, py, autosave

show code in pop-up

1 2 3 4 5

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = zip(

Code: 16:10:57 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = zip(A, B)

Code: 16:18:06 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = zip(A, B)
    for

Code: 16:18:36 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0]

Code: 16:18:46 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1]

Code: 16:19:00 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]

Code: 16:19:19 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    while

Code: 16:19:39 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    while f_counter

Code: 16:19:51 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    while f_counter < F:

Code: 16:20:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    while f_counter < F:
        next

Code: 16:20:37 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    while f_counter < F:
        next_

Code: 16:21:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    while f_counter < F:
        next_f = f_b_diff.index(max(

Code: 16:21:15 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))

Code: 16:21:25 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))

Code: 16:21:35 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))

Code: 16:22:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))

Code: 16:22:22 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)

Code: 16:22:34 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        f_b_diff

Code: 16:22:46 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]

Code: 16:23:12 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers =

Code: 16:24:18 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set

Code: 16:24:47 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers

Code: 16:24:57 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers

Code: 16:25:18 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contr = 0

Code: 16:25:35 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for

Code: 16:25:45 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for i in

Code: 16:26:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for i in range(len(A)):

Code: 16:26:32 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]

Code: 16:27:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_cotribution += B[i]
    return comp_contribution

Code: 16:27:04 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - [skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_cotribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.048 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 143, in <module>
    main()
  File "exec.py", line 84, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 7
    f_counter = 0
            ^
SyntaxError: invalid syntax

▶

example2
Second example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.044 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 143, in <module>
    main()
  File "exec.py", line 84, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 7
    f_counter = 0
            ^
SyntaxError: invalid syntax

▶

example3
Third example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.044 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 143, in <module>
    main()
  File "exec.py", line 84, in main
    sol = __import__('solution')
  File "/tmp/solution.py", line 7
    f_counter = 0
            ^
SyntaxError: invalid syntax

Code: 16:27:39 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_cotribution += B[i]
    return comp_contribution

Code: 16:27:40 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_cotribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 143, in <module>
    main()
  File "exec.py", line 105, in main
    result = solution( A, B, F )
  File "/tmp/solution.py", line 20, in solution
    comp_cotribution += B[i]
UnboundLocalError: local variable 'comp_cotribution' referenced before assignment

▶

example2
Second example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 143, in <module>
    main()
  File "exec.py", line 105, in main
    result = solution( A, B, F )
  File "/tmp/solution.py", line 20, in solution
    comp_cotribution += B[i]
UnboundLocalError: local variable 'comp_cotribution' referenced before assignment

▶

example3
Third example test.

✘

RUNTIME ERROR
tested program terminated with exit code 1

0.040 s

RUNTIME ERROR, tested program terminated with exit code 1

stderr:

Traceback (most recent call last):
  File "exec.py", line 143, in <module>
    main()
  File "exec.py", line 105, in main
    result = solution( A, B, F )
  File "/tmp/solution.py", line 20, in solution
    comp_cotribution += B[i]
UnboundLocalError: local variable 'comp_cotribution' referenced before assignment

Code: 16:27:57 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 8 expected 10

0.044 s

WRONG ANSWER, got 8 expected 10

▶

example2
Second example test.

✘

WRONG ANSWER
got 14 expected 18

0.044 s

WRONG ANSWER, got 14 expected 18

▶

example3
Third example test.

✔

0.040 s

Code: 16:28:26 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Code: 16:28:32 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 8 expected 10

0.036 s

WRONG ANSWER, got 8 expected 10

stdout:

[2, -3, -2]

▶

example2
Second example test.

✘

WRONG ANSWER
got 14 expected 18

0.036 s

WRONG ANSWER, got 14 expected 18

stdout:

[2, -2, 0, 1]

▶

example3
Third example test.

✔

0.036 s

stdout:

[0, 0, 0]

Code: 16:28:56 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Code: 16:29:04 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 8 expected 10

0.048 s

WRONG ANSWER, got 8 expected 10

stdout:

[2, -3, -2]
{0, 1}

▶

example2
Second example test.

✘

WRONG ANSWER
got 14 expected 18

0.048 s

WRONG ANSWER, got 14 expected 18

stdout:

[2, -2, 0, 1]
{0, 2}

▶

example3
Third example test.

✔

0.048 s

stdout:

[0, 0, 0]
{0}

Code: 16:29:31 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Code: 16:29:45 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 8 expected 10

0.048 s

WRONG ANSWER, got 8 expected 10

stdout:

[2, -3, -2]
0 [-3, -2]
1 [-3]
{0, 1}

▶

example2
Second example test.

✘

WRONG ANSWER
got 14 expected 18

0.052 s

WRONG ANSWER, got 14 expected 18

stdout:

[2, -2, 0, 1]
0 [-2, 0, 1]
2 [-2, 0]
{0, 2}

▶

example3
Third example test.

✔

0.048 s

stdout:

[0, 0, 0]
0 [0, 0]
{0}

Code: 16:30:31 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")

def solution(A, B, F):
    
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Code: 16:30:47 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
local_neg_inf
def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Code: 16:31:07 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
local_neg_inf = -1001
def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        del f_b_diff[next_f]
        print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Code: 16:31:20 UTC, py, verify, result: Failed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
local_neg_inf = -1001
def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        f_b_diff[next_f] = local_neg_inf
        print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in b_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✘

WRONG ANSWER
got 7 expected 10

0.044 s

WRONG ANSWER, got 7 expected 10

stdout:

[2, -3, -2]
0 [-1001, -3, -2]
2 [-1001, -3, -1001]
{0, 2}

▶

example2
Second example test.

✘

WRONG ANSWER
got 13 expected 18

0.044 s

WRONG ANSWER, got 13 expected 18

stdout:

[2, -2, 0, 1]
0 [-1001, -2, 0, 1]
3 [-1001, -2, 0, -1001]
{0, 3}

▶

example3
Third example test.

✔

0.040 s

stdout:

[0, 0, 0]
0 [-1001, 0, 0]
{0}

Code: 16:32:02 UTC, py, autosave

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
local_neg_inf = -1001
def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        f_b_diff[next_f] = local_neg_inf
        print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in _programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Code: 16:32:04 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
local_neg_inf = -1001
def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        f_b_diff[next_f] = local_neg_inf
        print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in f_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

stdout:

[2, -3, -2]
0 [-1001, -3, -2]
2 [-1001, -3, -1001]
{0, 2}

▶

example2
Second example test.

✔

0.040 s

stdout:

[2, -2, 0, 1]
0 [-1001, -2, 0, 1]
3 [-1001, -2, 0, -1001]
{0, 3}

▶

example3
Third example test.

✔

0.036 s

stdout:

[0, 0, 0]
0 [-1001, 0, 0]
{0}

Code: 16:32:13 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
local_neg_inf = -1001
def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    #print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        f_b_diff[next_f] = local_neg_inf
        print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    #print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in f_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.044 s

stdout:

0 [-1001, -3, -2]
2 [-1001, -3, -1001]

▶

example2
Second example test.

✔

0.044 s

stdout:

0 [-1001, -2, 0, 1]
3 [-1001, -2, 0, -1001]

▶

example3
Third example test.

✔

0.040 s

stdout:

0 [-1001, 0, 0]

Code: 16:32:21 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
local_neg_inf = -1001
def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    #print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        f_b_diff[next_f] = local_neg_inf
        #print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    #print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in f_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.044 s

▶

example2
Second example test.

✔

0.044 s

▶

example3
Third example test.

✔

0.044 s

Code: 16:42:45 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
local_neg_inf = -1001
def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    #print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        f_b_diff[next_f] = local_neg_inf
        #print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    #print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in f_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.044 s

▶

example2
Second example test.

✔

0.044 s

▶

example3
Third example test.

✔

0.044 s

expand all User tests

▶

test_data1

✔

0.044 s

OK
function result: 12

▶

test_data2

✔

0.044 s

OK
function result: 18

▶

test_data3

✔

0.040 s

OK
function result: 24

▶

test_data4

✔

0.044 s

OK
function result: 3

▶

test_data5

✔

0.044 s

OK
function result: 4

▶

test_data6

✔

0.044 s

OK
function result: 10

User test case 1:

[[7, 8, 9], [1, 2, 3], 1]

User test case 2:

[[7, 8, 9], [1, 2, 3], 2]

User test case 3:

[[7, 8, 9], [1, 2, 3], 3]

User test case 4:

[[3], [4], 1]

User test case 5:

[[4], [3], 1]

User test case 6:

[[3, 4], [5, 7], 1]

Code: 16:55:12 UTC, py, verify, result: Passed

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
local_neg_inf = -1001
def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    #print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        f_b_diff[next_f] = local_neg_inf
        #print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    #print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in f_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis

expand all Example tests

▶

example1
First example test.

✔

0.036 s

▶

example2
Second example test.

✔

0.036 s

▶

example3
Third example test.

✔

0.036 s

expand all User tests

▶

test_data1

✔

0.036 s

OK
function result: 12

▶

test_data2

✔

0.036 s

OK
function result: 18

▶

test_data3

✔

0.036 s

OK
function result: 24

▶

test_data4

✔

0.036 s

OK
function result: 3

▶

test_data5

✔

0.036 s

OK
function result: 4

▶

test_data6

✔

0.036 s

OK
function result: 10

User test case 1:

[[7, 8, 9], [1, 2, 3], 1]

User test case 2:

[[7, 8, 9], [1, 2, 3], 2]

User test case 3:

[[7, 8, 9], [1, 2, 3], 3]

User test case 4:

[[3], [4], 1]

User test case 5:

[[4], [3], 1]

User test case 6:

[[3, 4], [5, 7], 1]

Code: 16:55:15 UTC, py, final, score: 66

show code in pop-up

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

# you can write to stdout for debugging purposes, e.g.
# print("this is a debug message")
local_neg_inf = -1001
def solution(A, B, F):
    f_b_skills = list(zip(A, B))
    f_b_diff = [skill[0] - skill[1] for skill in f_b_skills]
    #print(f_b_diff)
    f_counter = 0
    f_programmers = set()
    while f_counter < F:
        next_f = f_b_diff.index(max(f_b_diff))
        f_programmers.add(next_f)
        f_b_diff[next_f] = local_neg_inf
        #print(next_f, f_b_diff)
        f_counter += 1
    b_programmers = set([i for i in range(len(B))]) - f_programmers
    #print(f_programmers)
    comp_contribution = 0
    for i in range(len(A)):
        if i in f_programmers:
            comp_contribution += A[i]
        else:
            comp_contribution += B[i]
    return comp_contribution

Analysis summary

The following issues have been detected: timeout errors.

Analysis

Detected time complexity:

O(N*F)

expand all Example tests

▶

example1
First example test.

✔

0.040 s

▶

example2
Second example test.

✔

0.040 s

▶

example3
Third example test.

✔

0.044 s

expand all Correctness tests

▶

one_developer
N = 1.

✔

0.040 s

0.044 s

▶

small_simple
N = 6, 7. Two small simple tests.

✔

0.040 s

▶

small_random
N = 20. Small random tests.

✔

0.044 s

0.040 s

▶

small_A_always_bigger
N = 20. A[i] > B[i].

✔

0.040 s

0.036 s

0.044 s

▶

small_bigger_and_smaller_differences
N = 20. Some developers have small difference between A[i] and B[i].

✔

0.040 s

expand all Correctness/performance tests

▶

medium_random
N = 300. Medium random tests.

✔

0.044 s

0.040 s

0.048 s

▶

medium_A_always_bigger
N = 300. A[i] > B[i].

✔

0.048 s

0.044 s

0.040 s

▶

medium_bigger_and_smaller_differences
N = 300. Some developers have small difference between A[i] and B[i].

✔

0.044 s

0.040 s

expand all Performance tests

▶

large_random
N = 200,000. Large random tests.

✘

TIMEOUT ERROR
Killed. Hard limit reached: 8.000 sec.

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.

▶

large_A_always_bigger
N = 200,000. A[i] > B[i].

✘

TIMEOUT ERROR
Killed. Hard limit reached: 8.000 sec.

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.

▶

large_bigger_and_smaller_differences
N = 200,000. Some developers have small difference between A[i] and B[i].

✘

TIMEOUT ERROR
Killed. Hard limit reached: 8.000 sec.

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.

▶

max_tests
N is maximal, upper corner cases.

✘

TIMEOUT ERROR
Killed. Hard limit reached: 8.000 sec.

0.600 s

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.

8.000 s

TIMEOUT ERROR, Killed. Hard limit reached: 8.000 sec.