Tasks Details
medium
1.
DreamTeam
Divide developers into two teams to maximize their total contribution.
Task Score
100%
Correctness
100%
Performance
100%
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:
class Solution { public int solution(int[] A, int[] B, int 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].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used Java 21
Time spent on task 17 minutes
Notes
not defined yet
Code: 10:55:04 UTC,
java,
autosave
Code: 10:58:03 UTC,
java,
autosave
Code: 11:01:17 UTC,
java,
autosave
Code: 11:01:34 UTC,
java,
autosave
Code: 11:01:50 UTC,
java,
autosave
Code: 11:02:11 UTC,
java,
autosave
Code: 11:02:40 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length()];
}
}
Code: 11:03:08 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length()];
for(int i = 0; i < A.length(); i++)
{
diffs[i] =
}
}
}
}
Code: 11:03:18 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length()];
for(int i = 0; i < A.length(); i++)
{
diffs[i] = B[i]
}
}
}
}
Code: 11:03:31 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length()];
for(int i = 0; i < A.length(); i++)
{
diffs[i] = A[i] - B[i];
}
}
}
}
Code: 11:03:50 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length()];
for(int i = 0; i < A.length(); i++)
{
diffs[i] = A[i] - B[i];
}
}
}
}
Code: 11:04:03 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length()];
for(int i = 0; i < A.length(); i++)
{
diffs[i] = A[i] - B[i];
}
Arrays.
}
}
}
Code: 11:04:27 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length()];
for(int i = 0; i < A.length(); i++)
{
diffs[i] = A[i] - B[i];
}
Arrays.parallelSort(diffs);
}
}
Code: 11:04:42 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length()];
for(int i = 0; i < A.length(); i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
}
}
Code: 11:04:52 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length()];
for(int i = 0; i < A.length(); i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for()
}
}
Code: 11:05:12 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length()];
for(int i = 0; i < A.length(); i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1;
}
}
Code: 11:05:22 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length())
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1;
}
}
Code: 11:05:32 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1;
}
}
Code: 11:05:58 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1; i >= 0; i--)
{
}
}
}
}
Code: 11:08:04 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1; i >= ; i--)
{
}
}
}
}
Code: 11:08:14 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1; i >= diffs.length-F; i--)
{
}
}
}
}
Code: 11:08:35 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1; i >= diffs.length-F; i--)
{
}
}
}
}
Code: 11:08:48 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1; i >= diffs.length-F; i--)
{
}
}
}
Code: 11:09:12 UTC,
java,
verify,
result: Failed
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1; i >= diffs.length-F; i--)
{
sum -= diffs[i];
}
return sum;
}
}
Analysis
Code: 11:10:44 UTC,
java,
autosave
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1; i >= diffs.length-F; i--)
{
sum = diffs[i];
}
return sum;
}
}
Code: 11:10:54 UTC,
java,
verify,
result: Passed
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1; i >= diffs.length-F; i--)
{
sum += diffs[i];
}
return sum;
}
}
Analysis
Code: 11:11:01 UTC,
java,
verify,
result: Passed
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1; i >= diffs.length-F; i--)
{
sum += diffs[i];
}
return sum;
}
}
Analysis
Code: 11:11:05 UTC,
java,
final,
score:
100
import java.util.*;
class Solution {
public int solution(int[] A, int[] B, int F) {
int sum = 0;
if(F == 0)
{
for(int i : B)
sum += i;
return sum;
}
if(F == A.length)
{
for(int i : A)
sum += i;
return sum;
}
for(int i : B)
sum += i;
int[] diffs = new int[A.length];
for(int i = 0; i < A.length; i++)
diffs[i] = A[i] - B[i];
Arrays.parallelSort(diffs);
for(int i = diffs.length-1; i >= diffs.length-F; i--)
{
sum += diffs[i];
}
return sum;
}
}Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N*log(N)) or O(N)
expand all
Correctness tests
1.
0.004 s
OK
2.
0.004 s
OK
3.
0.004 s
OK
4.
0.004 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
1.
0.008 s
OK
2.
0.004 s
OK
3.
0.004 s
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.008 s
OK
small_bigger_and_smaller_differences
N = 20. Some developers have small difference between A[i] and B[i].
N = 20. Some developers have small difference between A[i] and B[i].
✔
OK
1.
0.004 s
OK
2.
0.004 s
OK
3.
0.008 s
OK
expand all
Correctness/performance tests
1.
0.004 s
OK
2.
0.004 s
OK
3.
0.004 s
OK
1.
0.004 s
OK
2.
0.008 s
OK
3.
0.008 s
OK
medium_bigger_and_smaller_differences
N = 300. Some developers have small difference between A[i] and B[i].
N = 300. Some developers have small difference between A[i] and B[i].
✔
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.004 s
OK
expand all
Performance tests
1.
0.836 s
OK
2.
0.824 s
OK
3.
0.824 s
OK
1.
0.824 s
OK
2.
0.816 s
OK
3.
0.820 s
OK
large_bigger_and_smaller_differences
N = 200,000. Some developers have small difference between A[i] and B[i].
N = 200,000. Some developers have small difference between A[i] and B[i].
✔
OK
1.
0.816 s
OK
2.
0.816 s
OK
3.
0.820 s
OK
1.
0.800 s
OK
2.
0.760 s
OK
3.
0.728 s
OK