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
100%
Correctness
100%
Performance
100%
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 15 minutes
Notes
not defined yet
Code: 23:59:39 UTC,
java,
autosave
Code: 23:59:42 UTC,
cpp,
autosave
Code: 00:00:01 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:00:02 UTC,
cpp,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
User test case 1:
[1, 3, [1, 2, 3]]
Analysis
Code: 00:03:35 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:04:05 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
for (auto o : occurences)
{
cout << o <<
}
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:04:22 UTC,
cpp,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
User test case 1:
[1, 3, [1, 2, 3]]
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
0, 1, 3, 2, 1, 0, 0, 0, 0, 5, 1, 1, 0, 0, 0, 1, 3, 2, 1, 0, 0, 0, 1, 2, 4, 0, 0, 0,
1.
0.001 s
OK
stdout:
0, 0, 3, 2,
expand all
User tests
1.
0.001 s
OK
function result: [1, 2, 3]
function result: [1, 2, 3]
stdout:
0, 0, 2, 1, 0, 0, 1, 0, 2, 0,
Code: 00:06:16 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:06:37 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:07:02 UTC,
cpp,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
User test case 1:
[1, 3, [1, 2, 3]]
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
Ocs: 0, 1, 3, 2, 1, 0, 0, Lds: 2, Ocs: 0, 0, 5, 1, 1, 0, 0, Lds: 2, Ocs: 0, 1, 3, 2, 1, 0, 0, Lds: 2, 3, Ocs: 0, 1, 2, 4, 0, 0, 0, Lds: 2, 3,
1.
0.001 s
OK
stdout:
Ocs: 0, 0, 3, 2, Lds: 2, 3,
expand all
User tests
1.
0.001 s
OK
function result: [1, 2, 3]
function result: [1, 2, 3]
stdout:
Ocs: 0, 0, 2, 1, 0, Lds: 2, 3, Ocs: 0, 1, 0, 2, 0, Lds: 1, 2, 3,
Code: 00:08:16 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:08:35 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:08:39 UTC,
cpp,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
User test case 1:
[1, 3, [1, 2, 3]]
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
Ocs: 0, 1, 3, 2, 1, 0, 0, Ocs: 0, 0, 5, 1, 1, 0, 0, Lds: 2, Ocs: 0, 1, 3, 2, 1, 0, 0, Lds: 2, Ocs: 0, 1, 2, 4, 0, 0, 0, Lds: 2, 3, Ocs: 1, 0, 2, 3, 1, 0, 0, Lds: 2, 3,
1.
0.001 s
OK
stdout:
Ocs: 0, 0, 3, 2, Ocs: 0, 1, 1, 3, Lds: 2, 3,
expand all
User tests
1.
0.001 s
OK
function result: [1, 2, 3]
function result: [1, 2, 3]
stdout:
Ocs: 0, 0, 2, 1, 0, Ocs: 0, 1, 0, 2, 0, Lds: 2, 3, Ocs: 0, 2, -1, 1, 1, Lds: 1, 2, 3,
Code: 00:09:09 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:09:12 UTC,
cpp,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
User test case 1:
[1, 3, [1, 2, 3]]
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
Ocs: 0, 1, 3, 2, 1, 0, 0, Lds: Ocs: 0, 0, 5, 1, 1, 0, 0, Lds: 2, Ocs: 0, 1, 3, 2, 1, 0, 0, Lds: 2, Ocs: 0, 1, 2, 4, 0, 0, 0, Lds: 2, 3, Ocs: 1, 0, 2, 3, 1, 0, 0, Lds: 2, 3,
1.
0.001 s
OK
stdout:
Ocs: 0, 0, 3, 2, Lds: 2, Ocs: 0, 1, 1, 3, Lds: 2, 3,
expand all
User tests
1.
0.001 s
OK
function result: [1, 2, 3]
function result: [1, 2, 3]
stdout:
Ocs: 0, 0, 2, 1, 0, Lds: 2, Ocs: 0, 1, 0, 2, 0, Lds: 2, 3, Ocs: 0, 2, -1, 1, 1, Lds: 1, 2, 3,
Code: 00:10:55 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:11:06 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]-1] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:11:16 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:11:26 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:11:36 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
occurences[A[i+K]+1]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:11:58 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++
occurences[A[i+K]]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]-1] >= limit)
{
leaders.insert(A[i]-1);
}
if (occurences[A[i+K]+1] >= limit)
{
leaders.insert(A[i+K]+1);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:12:12 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++
occurences[A[i+K]]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:12:12 UTC,
cpp,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++
occurences[A[i+K]]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Analysis
Compile error
func.cpp: In function 'std::vector<int> solution(int, int, std::vector<int>&)':
func.cpp:65:8: error: expected ';' before 'occurences'
occurences[A[i+K]]++;
^~~~~~~~~~
Code: 00:12:23 UTC,
cpp,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++;
occurences[A[i+K]]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
User test case 1:
[1, 3, [1, 2, 3]]
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
Ocs: 0, 1, 3, 2, 1, 0, 0, Lds: Ocs: 0, 0, 5, 1, 1, 0, 0, Lds: 2, Ocs: 0, 1, 3, 2, 1, 0, 0, Lds: 2, Ocs: 0, 1, 2, 4, 0, 0, 0, Lds: 2, 3, Ocs: 0, 2, 1, 3, 1, 0, 0, Lds: 2, 3,
1.
0.001 s
OK
stdout:
Ocs: 0, 0, 3, 2, Lds: 2, Ocs: 0, 1, 1, 3, Lds: 2, 3,
expand all
User tests
1.
0.001 s
OK
function result: [2, 3]
function result: [2, 3]
stdout:
Ocs: 0, 0, 2, 1, 0, Lds: 2, Ocs: 0, 1, 0, 2, 0, Lds: 2, 3, Ocs: 0, 1, 1, 0, 1, Lds: 2, 3,
Code: 00:12:48 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++;
occurences[A[i+K]]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:12:58 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++;
occurences[A[i+K]]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:13:08 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++;
occurences[A[i+K]]++;
cout << "Ocs: ";
for (auto o : occurences)
{
cout << o << ", ";
}
cout << endl;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:13:20 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++;
occurences[A[i+K]]++;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
cout << "Lds: ";
for (auto l : leaders)
{
cout << l << ", ";
}
cout << endl;
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
Code: 00:13:25 UTC,
cpp,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++;
occurences[A[i+K]]++;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
User test case 1:
[1, 3, [1, 2, 3]]
Analysis
Code: 00:13:39 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++;
occurences[A[i+K]]++;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
User test case 1:
[1, 3, [1, 2, 3]]
Analysis
Code: 00:13:56 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++;
occurences[A[i+K]]++;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}
User test case 1:
[1, 3, [1, 2, 3]]
Analysis
Code: 00:13:59 UTC,
cpp,
final,
score:
100
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
// 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;
#include <set>
#include <algorithm>
vector<int> solution(int K, int M, vector<int> &A) {
// write your code in C++14 (g++ 6.2.0)
vector<int> occurences;
occurences.resize(M+2);
int size = A.size();
int limit = size/2 + 1;
for (int i=0; i<K; i++)
{
A[i]++;
}
set<int> examined;
for (auto a : A)
{
if (examined.find(a) != examined.end())
{
continue;
}
occurences[a] = std::count(A.begin(), A.end(), a);
examined.insert(a);
}
set<int> leaders;
for (int i = 0; i < M+2; i++)
{
if (occurences[i]>=limit)
{
leaders.insert(i);
}
}
for (int i = 0; i< size - K; i++)
{
occurences[A[i]] --;
A[i]--;
occurences[A[i]] ++;
occurences[A[i+K]]--;
A[i+K]++;
occurences[A[i+K]]++;
if (occurences[A[i]] >= limit)
{
leaders.insert(A[i]);
}
if (occurences[A[i+K]] >= limit)
{
leaders.insert(A[i+K]);
}
}
vector<int> output;
for (auto a:leaders)
{
output.push_back(a);
}
return output;
}Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(M)
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
1.
0.001 s
OK
2.
0.001 s
OK
3.
0.001 s
OK
1.
0.004 s
OK
2.
0.004 s
OK
3.
0.004 s
OK
1.
0.008 s
OK
2.
0.008 s
OK
3.
0.008 s
OK
1.
0.008 s
OK
2.
0.008 s
OK