Tasks Details
hard
Given an array, find all its elements that can become a leader, after increasing by 1 all of the numbers in some segment of a given length.
Task Score
55%
Correctness
100%
Performance
0%
Integers K, M and a non-empty array A consisting of N integers, not bigger than M, are given.
The leader of the array is a value that occurs in more than half of the elements of the array, and the segment of the array is a sequence of consecutive elements of the array.
You can modify A by choosing exactly one segment of length K and increasing by 1 every element within that segment.
The goal is to find all of the numbers that may become a leader after performing exactly one array modification as described above.
Write a function:
vector<int> solution(int K, int M, vector<int> &A);
that, given integers K and M and an array A consisting of N integers, returns an array of all numbers that can become a leader, after increasing by 1 every element of exactly one segment of A of length K. The returned array should be sorted in ascending order, and if there is no number that can become a leader, you should return an empty array. Moreover, if there are multiple ways of choosing a segment to turn some number into a leader, then this particular number should appear in an output array only once.
For example, given integers K = 3, M = 5 and the following array A:
A[0] = 2 A[1] = 1 A[2] = 3 A[3] = 1 A[4] = 2 A[5] = 2 A[6] = 3the function should return [2, 3]. If we choose segment A[1], A[2], A[3] then we get the following array A:
A[0] = 2 A[1] = 2 A[2] = 4 A[3] = 2 A[4] = 2 A[5] = 2 A[6] = 3and 2 is the leader of this array. If we choose A[3], A[4], A[5] then A will appear as follows:
A[0] = 2 A[1] = 1 A[2] = 3 A[3] = 2 A[4] = 3 A[5] = 3 A[6] = 3and 3 will be the leader.
And, for example, given integers K = 4, M = 2 and the following array:
A[0] = 1 A[1] = 2 A[2] = 2 A[3] = 1 A[4] = 2the function should return [2, 3], because choosing a segment A[0], A[1], A[2], A[3] and A[1], A[2], A[3], A[4] turns 2 and 3 into the leaders, respectively.
Write an efficient algorithm for the following assumptions:
- N and M are integers within the range [1..100,000];
- K is an integer within the range [1..N];
- each element of array A is an integer within the range [1..M].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used C++
Time spent on task 107 minutes
Notes
not defined yet
Code: 09:41:08 UTC,
java,
autosave
Code: 09:41:17 UTC,
cpp,
autosave
Code: 09:47:54 UTC,
cpp,
autosave
Code: 09:48:18 UTC,
cpp,
autosave
Code: 09:49:20 UTC,
java,
autosave
Code: 09:49:34 UTC,
c,
autosave
Code: 09:49:45 UTC,
cpp,
autosave
Code: 09:54:37 UTC,
cpp,
autosave
Code: 09:55:07 UTC,
cpp,
autosave
Code: 09:55:38 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
re
}
Code: 09:55:48 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
return result;
}
Code: 09:56:14 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
auto cur_it
return result;
}
Code: 09:56:39 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
auto cur_it = A.begin();
while (cur_it + K != )
return result;
}
Code: 09:56:58 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
auto cur_it = A.begin();
auto a_end = A.end();
while (cur_it + K != )
return result;
}
Code: 09:57:13 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
auto cur_it = A.begin();
auto a_end = A.end();
for ()
return result;
}
Code: 09:57:30 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
auto a_end = A.end();
for (auto it = A.begin(); )
return result;
}
Code: 09:57:40 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < )
return result;
}
Code: 09:57:52 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:02:39 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:03:14 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:03:25 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader() {
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:03:56 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
for (auto val: vec) {
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:04:07 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
map
for (auto val: vec) {
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:04:21 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
// map
for (auto val: vec) {
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got [] expected [2, 3]
1.
0.001 s
WRONG ANSWER,
got [] expected [2, 3]
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
Code: 10:04:37 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
map
for (auto val: vec) {
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:04:47 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
map<int, >
for (auto val: vec) {
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:04:57 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
vector
for (auto val: vec) {
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:05:12 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
unordered_map<int, int>
for (auto val: vec) {
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:05:42 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
unordered_map<int, int> repetitions;
for (auto val: vec) {
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:06:53 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
unordered_map<int, int> repetitions;
for (auto val: vec) {
if
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:07:23 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
if (reps.find(val) == reps.end()) {
} else {
}
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:07:43 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
void determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
auto search_res = reps.find(val)
if (reps.find(val) == reps.end()) {
} else {
}
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:08:04 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
auto search_res = reps.find(val)
if (reps.find(val) == reps.end()) {
search_res
} else {
}
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:08:14 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
auto search_res = reps.find(val)
if (search_res == reps.end()) {
search_res
} else {
}
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:09:50 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
re
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:10:01 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
reps[]
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:10:11 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
auto search_res = reps.find(val)
if (search_res == reps.end()) {
} else {
}
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:10:24 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
auto search_res = reps.find(val)
if (search_res == reps.end()) {
reps[]
} else {
}
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:10:34 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
auto search_res = reps.find(val)
if (search_res == reps.end()) {
reps[val] = 1;
} else {
}
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:11:04 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
auto search_res = reps.find(val)
if (search_res == reps.end()) {
reps[val] = 1;
} else {
reps[val]++;
}
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:11:35 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:11:45 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:17:26 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
au
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:17:56 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pait))
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:18:07 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int>){
});
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:18:37 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int>){
return
});
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:19:00 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, ){
return
});
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:19:28 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:19:55 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int> determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:20:54 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
i determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:21:04 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:21:35 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second)
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:21:49 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:22:08 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
}
return result;
}
Code: 10:22:36 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, []())
}
return result;
}
Code: 10:22:46 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val))
}
return result;
}
Code: 10:22:53 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
}
return result;
}
Code: 10:23:04 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
}
return result;
}
Code: 10:23:14 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> result;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
}
return result;
}
Code: 10:23:25 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
}
return result;
}
Code: 10:23:37 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
if ()
}
return result;
}
Code: 10:23:48 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
if (determineLeader())
}
return result;
}
Code: 10:24:05 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
if (determineLeader(A) != -1)
res_set
}
return result;
}
Code: 10:24:27 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
if (determineLeader(A) != -1)
res_set.insert()
}
return result;
}
Code: 10:24:39 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader =
if (determineLeader(A) != -1)
res_set.insert()
}
return result;
}
Code: 10:24:53 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
return result;
}
Code: 10:25:09 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result()
return result;
}
Code: 10:25:39 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begi)
return result;
}
Code: 10:25:52 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:26:00 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
// #include <algorithm>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Analysis
Compile error
func.cpp: In function 'int determineLeader(const std::vector<int>&)':
func.cpp:8:5: error: 'unordered_map' was not declared in this scope
unordered_map<int, int> reps;
^~~~~~~~~~~~~
func.cpp:8:19: error: expected primary-expression before 'int'
unordered_map<int, int> reps;
^~~
func.cpp:16:9: error: 'reps' was not declared in this scope
reps[val]++;
^~~~
func.cpp:19:31: error: 'reps' was not declared in this scope
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
^~~~
func.cpp:21:6: error: 'max_element' was not declared in this scope
});
^
func.cpp: In function 'std::vector<int> solution(int, int, std::vector<int>&)':
func.cpp:32:5: error: 'set' was not declared in this scope
set<int> res_set;
^~~
func.cpp:32:9: error: expected primary-expression before 'int'
set<int> res_set;
^~~
func.cpp:37:10: error: 'for_each' was not declared in this scope
});
^
func.cpp:40:13: error: 'res_set' was not declared in this scope
res_set.insert(leader);
^~~~~~~
func.cpp:43:24: error: 'res_set' was not declared in this scope
vector<int> result(res_set.begin(), res_set.end());
^~~~~~~
Code: 10:26:22 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
#include <unordered_map>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:26:45 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
#include <unordered_map>
#include <set>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:26:56 UTC,
cpp,
autosave
// you can use includes, for example:
// #include <algorithm>
#include <unordered_map>
#include <unordered_set>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:27:25 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:27:37 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:27:37 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got [] expected [2, 3]
1.
0.001 s
WRONG ANSWER,
got [] expected [2, 3]
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
Code: 10:28:31 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:28:41 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:28:53 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
cout << leader << endl;
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:28:58 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
cout << leader << endl;
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got [] expected [2, 3]
stdout:
-1 -1 -1 -1
1.
0.001 s
WRONG ANSWER,
got [] expected [2, 3]
stdout:
-1
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
Code: 10:29:13 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size())
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:29:25 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got [3, 2] expected [2, 3]
1.
0.001 s
WRONG ANSWER,
got [2] expected [2, 3]
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
Code: 10:30:12 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sor
return result;
}
Code: 10:30:25 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Code: 10:30:26 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Analysis
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
Code: 10:30:55 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Code: 10:31:08 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " " << endl;
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Code: 10:31:09 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " " << endl;
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2 1 3 2 4 1 5 2 2 3 3 2
1.
0.001 s
WRONG ANSWER,
got [2] expected [2, 3]
stdout:
1 2 2 1
expand all
User tests
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
stdout:
2 1 3 2 4 1 5 2 2 3 3 2
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
Code: 10:31:25 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Code: 10:31:26 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K < A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2 1 3 2 4 1 5 2 2 3 3 2
1.
0.001 s
WRONG ANSWER,
got [2] expected [2, 3]
stdout:
1 2 2 1
expand all
User tests
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
stdout:
2 1 3 2 4 1 5 2 2 3 3 2
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
Code: 10:31:55 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Code: 10:31:57 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got [2, 3, 4] expected [2, 3]
stdout:
2 1 3 2 4 1 5 2 2 3 3 2 4 3 3
1.
0.001 s
OK
stdout:
1 2 2 1 3 3 2 2
expand all
User tests
1.
0.001 s
OK
function result: [2, 3, 4]
function result: [2, 3, 4]
stdout:
2 1 3 2 4 1 5 2 2 3 3 2 4 3 3
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
Code: 10:32:33 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Code: 10:32:58 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
vector<int>
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Code: 10:33:23 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Code: 10:33:34 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
for_each(it, it + K, [](int& val) {
// cout << val << " ";
val--;
});
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Code: 10:33:42 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
for_each(it, it + K, [](int& val) {
// cout << val << " ";
val--;
});
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Code: 10:33:45 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
for_each(it, it + K, [](int& val) {
// cout << val << " ";
val--;
});
}
vector<int> result(res_set.begin(), res_set.end());
sort(result.begin(), result.end());
return result;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2 1 3 1 3 1 3 1 2 1 2 2 2 2 3
1.
0.001 s
OK
stdout:
1 2 2 1 2 2 1 2
expand all
User tests
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
stdout:
2 1 3 1 3 1 3 1 2 1 2 2 2 2 3
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
Code: 10:44:23 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
unordered_set<int> res_set;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
for_each(it, it + K, [](int& val) {
// cout << val << " ";
val--;
});
}
vector<int> result(res_set.begin(), res_set.end());
return result;
}
Code: 10:44:38 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1)
res_set.insert(leader);
for_each(it, it + K, [](int& val) {
// cout << val << " ";
val--;
});
}
return result;
}
Code: 10:44:51 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1 && )
res_set.insert(leader);
for_each(it, it + K, [](int& val) {
// cout << val << " ";
val--;
});
}
return result;
}
Code: 10:45:21 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
cout << val << " ";
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1 && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
// cout << val << " ";
val--;
});
}
return result;
}
Code: 10:45:32 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
// auto search_res = reps.find(val)
// if (search_res == reps.end()) {
// reps[val] = 1;
// } else {
// reps[val]++;
// }
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1 && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:45:58 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1 && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:49:08 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1 && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:49:25 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1 && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:49:28 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1 && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
Compile error
func.cpp: In function 'int determineLeader(const std::vector<int>&)':
func.cpp:22:24: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
if (max_it->second >= vec.size() / 2)
~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
func.cpp: In function 'std::vector<int> solution(int, int, std::vector<int>&)':
func.cpp:38:36: error: 'class std::vector<int>' has no member named 'find'; did you mean 'end'?
if (leader != -1 && result.find(leader) == result.end())
^~~~
Code: 10:50:11 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<int, unint> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1 && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:50:21 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1 && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:51:01 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
if (leader != -1 && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:51:12 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
if (leader != -1 && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:52:02 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
if (leader != -1) && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:52:14 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
if (leader != -1) {
result.find(leader) == result.end())
result.push_back(leader);
}
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:52:38 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
if (leader != -1) {
for (auto val: result) {
}
result.find(leader) == result.end())
result.push_back(leader);
}
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:52:51 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
if (leader != -1) {
for (auto val: result) {
}
result.find(leader) == result.end())
result.push_back(leader);
}
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:53:22 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
if (leader != -1) && result.find(leader) == result.end())
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:53:41 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
if (leader != -1 && any_of(result.begin(), result.end()))
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:53:55 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
if (leader != -1 && any_of(result.begin(), result.end(), [](const int& val)))
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:54:05 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
if (leader != -1 && any_of(result.begin(), result.end(), [leader](const int& val)))
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:54:19 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
if (leader != -1 && any_of(result.begin(), result.end(), [leader](const int& val){
}))
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:54:33 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
bool leader_already_found
if (leader != -1 && any_of(result.begin(), result.end(), [leader](const int& val){
}))
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:54:55 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
unsigned int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader
});
if (leader != -1 && leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
Compile error
func.cpp: In lambda function:
func.cpp:39:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
return val == leader
~~~~^~~~~~~~~
func.cpp:39:23: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
func.cpp:40:9: error: expected ';' before '}' token
});
^
func.cpp: In function 'std::vector<int> solution(int, int, std::vector<int>&)':
func.cpp:41:20: warning: comparison between signed and unsigned integer expressions [-Wsign-compare]
if (leader != -1 && leader_found)
~~~~~~~^~~~~
Code: 10:55:15 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
unsigned int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader
});
if (leader != -1 && leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:55:19 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader
});
if (leader != -1 && leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
Compile error
func.cpp: In lambda function:
func.cpp:40:9: error: expected ';' before '}' token
});
^
Code: 10:55:28 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
cout << endl;
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got [] expected [2, 3]
stdout:
1.
0.001 s
WRONG ANSWER,
got [] expected [2, 3]
stdout:
expand all
User tests
1.
0.001 s
OK
function result: []
function result: []
stdout:
1.
0.001 s
OK
function result: []
function result: []
stdout:
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
Code: 10:55:48 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:55:50 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got [] expected [2, 3]
1.
0.001 s
WRONG ANSWER,
got [] expected [2, 3]
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
Code: 10:56:01 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
Code: 10:56:21 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:56:31 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:56:56 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:56:59 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [2]
function result: [2]
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
Code: 10:57:15 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:57:23 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [6]
function result: [6]
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
User test case 4:
[5, 5, [5, 5, 5, 5, 5, 5, 5]]
Code: 10:57:43 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:57:59 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:58:14 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 10:58:14 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = -1;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
User test case 4:
[5, 5, [5, 5, 5, 5, 5, 5, 5]]
User test case 5:
[3, 5, [1, 1, 1, 3, 3, 3]]
Code: 11:04:08 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = ;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:04:18 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int result = max_it->second >= vec.size() / 2 ? ;
if (max_it->second >= vec.size() / 2)
result = max_it->first;
return result;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:04:33 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second >= vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
User test case 4:
[5, 5, [5, 5, 5, 5, 5, 5, 5]]
User test case 5:
[3, 5, [1, 1, 1, 3, 3, 3]]
Code: 11:05:43 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second >= vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:08:42 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:08:51 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
User test case 4:
[5, 5, [5, 5, 5, 5, 5, 5, 5]]
User test case 5:
[3, 5, [1, 1, 1, 3, 3, 3]]
Code: 11:09:26 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:09:36 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:09:48 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:10:24 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:10:54 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:11:04 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:11:28 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:11:42 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
// int result = max_it->second >= vec.size() / 2 ? max_it->first : -1;
// if (max_it->second >= vec.size() / 2)
// result = max_it->first;
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
User test case 4:
[5, 5, [5, 5, 5, 5, 5, 5, 5]]
User test case 5:
[3, 5, [1, 1, 1, 3, 3]]
Code: 11:12:31 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
// you can write to stdout for debugging purposes, e.g.
// cout << "this is a debug message" << endl;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:13:12 UTC,
cpp,
autosave
// you can use includes, for example:
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:13:22 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Analysis
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
User test case 4:
[5, 5, [5, 5, 5, 5, 5, 5, 5]]
User test case 5:
[3, 5, [1, 1, 1, 3, 3]]
Code: 11:20:15 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return result;
}
Code: 11:20:27 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
sort(result.begin(), result.end());
return result;
}
Code: 11:20:36 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
sort(result.begin(), result.end());
return result;
}
Code: 11:20:53 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
sort(result.begin(), result.end());
return result;
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [6]
function result: [6]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
User test case 4:
[5, 5, [5, 5, 5, 5, 5, 5, 5]]
User test case 5:
[3, 5, [1, 1, 1, 3, 3]]
User test case 6:
[3, 5, [3, 2, 2, 1, 3, 1, 2]]
Code: 11:21:25 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#i
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
vector<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
sort(result.begin(), result.end());
return result;
}
Code: 11:21:35 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
sort(result.begin(), result.end());
return result;
}
Code: 11:21:45 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
//sort(result.begin(), result.end());
return (result.begin(), result.end());
}
Code: 11:21:45 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
//sort(result.begin(), result.end());
return (result.begin(), result.end());
}
Analysis
Compile error
func.cpp: In function 'std::vector<int> solution(int, int, std::vector<int>&)':
func.cpp:33:20: error: 'class std::set<int>' has no member named 'push_back'
result.push_back(leader);
^~~~~~~~~
func.cpp:41:27: error: could not convert '(((void)result.std::set<_Key, _Compare, _Alloc>::begin<int, std::less<int>, std::allocator<int> >()), result.std::set<_Key, _Compare, _Alloc>::end<int, std::less<int>, std::allocator<int> >())' from 'std::set<int>::iterator {aka std::_Rb_tree_const_iterator<int>}' to 'std::vector<int>'
return (result.begin(), result.end());
~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~
Code: 11:21:53 UTC,
cpp,
verify,
result: Failed
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
return val == leader;
});
if (leader != -1 && !leader_found)
result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
//sort(result.begin(), result.end());
return vector<int>(result.begin(), result.end());
}
Analysis
Compile error
func.cpp: In function 'std::vector<int> solution(int, int, std::vector<int>&)':
func.cpp:33:20: error: 'class std::set<int>' has no member named 'push_back'
result.push_back(leader);
^~~~~~~~~
Code: 11:22:05 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
// bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
// return val == leader;
// });
// if (leader != -1 && !leader_found)
// result.push_back(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
//sort(result.begin(), result.end());
return vector<int>(result.begin(), result.end());
}
Code: 11:22:29 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
// bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
// return val == leader;
// });
// if (leader != -1 && !leader_found)
// result.push_back(leader);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
//sort(result.begin(), result.end());
return vector<int>(result.begin(), result.end());
}
Code: 11:22:29 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
// bool leader_found = any_of(result.begin(), result.end(), [leader](const int& val){
// return val == leader;
// });
// if (leader != -1 && !leader_found)
// result.push_back(leader);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
//sort(result.begin(), result.end());
return vector<int>(result.begin(), result.end());
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [6]
function result: [6]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
User test case 4:
[5, 5, [5, 5, 5, 5, 5, 5, 5]]
User test case 5:
[3, 5, [1, 1, 1, 3, 3]]
User test case 6:
[3, 5, [3, 2, 2, 1, 3, 1, 2]]
Code: 11:23:01 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
//sort(result.begin(), result.end());
return vector<int>(result.begin(), result.end());
}
Code: 11:23:11 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Code: 11:25:12 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec, ve) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Code: 11:25:30 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec, vector<int>::iterator) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Code: 11:25:55 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec, vector<int>::iterator cur, ) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Code: 11:26:12 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec, ) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Code: 11:26:25 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec, ) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Code: 11:26:56 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec, vector<) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Code: 11:27:03 UTC,
cpp,
autosave
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Code: 11:27:04 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [6]
function result: [6]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
User test case 4:
[5, 5, [5, 5, 5, 5, 5, 5, 5]]
User test case 5:
[3, 5, [1, 1, 1, 3, 3]]
User test case 6:
[3, 5, [3, 2, 2, 1, 3, 1, 2]]
Code: 11:27:11 UTC,
cpp,
verify,
result: Passed
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [6]
function result: [6]
1.
0.001 s
OK
function result: [2]
function result: [2]
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
User test case 1:
[3, 5, [2, 1, 3, 1, 2, 2, 3]]
User test case 2:
[1, 10, [1]]
User test case 3:
[5, 5, [1, 1, 1, 1, 1, 1, 1]]
User test case 4:
[5, 5, [5, 5, 5, 5, 5, 5, 5]]
User test case 5:
[3, 5, [1, 1, 1, 3, 3]]
User test case 6:
[3, 5, [3, 2, 2, 1, 3, 1, 2]]
Code: 11:27:17 UTC,
cpp,
final,
score:
55
// you can use includes, for example:
#include <algorithm>
#include <unordered_map>
#include <set>
using namespace std;
int determineLeader(const vector<int>& vec) {
unordered_map<unsigned int, unsigned int> reps;
for (auto val: vec) {
reps[val]++;
}
auto max_it = max_element(reps.begin(), reps.end(), [](pair<int, int> left, pair<int, int> right){
return left.second < right.second;
});
return max_it->second > vec.size() / 2 ? max_it->first : -1;
}
vector<int> solution(int K, int M, vector<int> &A) {
set<int> result;
for (auto it = A.begin(); it + K <= A.end(); it++) {
for_each(it, it + K, [](int& val) {
val++;
});
int leader = determineLeader(A);
if (leader != -1)
result.insert(leader);
for_each(it, it + K, [](int& val) {
val--;
});
}
return vector<int>(result.begin(), result.end());
}
Analysis summary
The following issues have been detected: timeout errors.
Analysis
Detected time complexity:
O(N*(N+M)) or O(N**2)
expand all
Correctness tests
1.
0.001 s
OK
2.
0.001 s
OK
3.
0.001 s
OK
4.
0.001 s
OK
5.
0.001 s
OK
6.
0.001 s
OK
1.
0.001 s
OK
2.
0.001 s
OK
3.
0.001 s
OK
4.
0.001 s
OK
1.
0.001 s
OK
2.
0.001 s
OK
1.
0.001 s
OK
2.
0.001 s
OK
1.
0.001 s
OK
2.
0.001 s
OK
3.
0.001 s
OK
expand all
Performance tests
medium_tests1
medium tests (N = 10000, M = 100)
medium tests (N = 10000, M = 100)
✘
TIMEOUT ERROR
running time: 1.024 sec., time limit: 0.100 sec.
running time: 1.024 sec., time limit: 0.100 sec.
1.
1.024 s
TIMEOUT ERROR,
running time: 1.024 sec., time limit: 0.100 sec.
2.
1.668 s
TIMEOUT ERROR,
running time: 1.668 sec., time limit: 0.100 sec.
3.
1.268 s
TIMEOUT ERROR,
running time: 1.268 sec., time limit: 0.100 sec.
medium_tests2
medium tests(N >= 20000, M=30000)
medium tests(N >= 20000, M=30000)
✘
TIMEOUT ERROR
Killed. Hard limit reached: 6.000 sec.
Killed. Hard limit reached: 6.000 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
2.388 s
TIMEOUT ERROR,
running time: 2.388 sec., time limit: 0.100 sec.
3.
2.672 s
TIMEOUT ERROR,
running time: 2.672 sec., time limit: 0.100 sec.
1.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
3.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.
1.
0.008 s
OK
2.
6.000 s
TIMEOUT ERROR,
Killed. Hard limit reached: 6.000 sec.