Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
double solution(int A[], int B[], int N);
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
double solution(vector<int> &A, vector<int> &B);
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
double solution(vector<int> &A, vector<int> &B);
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
class Solution { public double solution(int[] A, int[] B); }
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
double solution(List<int> A, List<int> B);
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
func Solution(A []int, B []int) float64
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
class Solution { public double solution(int[] A, int[] B); }
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
class Solution { public double solution(int[] A, int[] B); }
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
function solution(A, B);
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
fun solution(A: IntArray, B: IntArray): Double
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
function solution(A, B)
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Note: All arrays in this task are zero-indexed, unlike the common Lua convention. You can use #A to get the length of the array A.
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
double solution(NSMutableArray *A, NSMutableArray *B);
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
function solution(A: array of longint; B: array of longint; N: longint): double;
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
function solution($A, $B);
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
sub solution { my ($A, $B) = @_; my @A = @$A; my @B = @$B; ... }
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
def solution(A, B)
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
def solution(a, b)
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
object Solution { def solution(a: Array[Int], b: Array[Int]): Double }
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
public func solution(_ A : inout [Int], _ B : inout [Int]) -> Float64
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
function solution(A: number[], B: number[]): number;
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Two non-empty arrays A and B, each consisting of N integers, are given. Four functions are defined based on these arrays:
| F(X,K) |
= |
A[K]*X + B[K] |
| U(X) |
= |
max{ F(X,K) : 0 ≤ K < N } |
| D(X) |
= |
min{ F(X,K) : 0 ≤ K < N } |
| S(X) |
= |
U(X) − D(X) |
Write a function:
Private Function solution(A As Integer(), B As Integer()) As Double
that, given two arrays A and B consisting of N integers each, returns the minimum value of S(X) where X can be any real number.
For example, given the following arrays A and B consisting of three elements each:
A[0] = -1 B[0] = 3
A[1] = 1 B[1] = 0
A[2] = 0 B[2] = 2
the function should return 0.5 because:
| U(X) |
|
= |
|
−1*X + 3 |
|
if |
|
X ≤ 1 |
| U(X) |
|
= |
|
0*X + 2 |
|
if |
|
1 ≤ X ≤ 2 |
| U(X) |
|
= |
|
1*X + 0 |
|
if |
|
2 ≤ X |
and:
| D(X) |
|
= |
|
1*X + 0 |
|
if |
|
X ≤ 1.5 |
| D(X) |
|
= |
|
−1*X + 3 |
|
if |
|
1.5 ≤ X |
so for X = 1.5, function S(X) is equal to 0.5 and this is the minimum value of this function.
Write an efficient algorithm for the following assumptions:
- N is an integer within the range [1..100,000];
- each element of arrays A and B is an integer within the range [−1,000..1,000].
Copyright 2009–2024 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
