Tasks Details
medium
In how many ways can you split a kingdom into two parts, so that the parts contain equal number of gold mines?
Task Score
100%
Correctness
100%
Performance
100%
An old king wants to divide his kingdom between his two sons. He is well known for his justness and wisdom, and he plans to make a good use of both of these attributes while dividing his kingdom.
The kingdom is administratively split into square boroughs that form an N × M grid. Some of the boroughs contain gold mines. The king knows that his sons do not care as much about the land as they do about gold, so he wants both parts of the kingdom to contain exactly the same number of mines. Moreover, he wants to split the kingdom with either a horizontal or a vertical line that goes along the borders of the boroughs (splitting no borough into two parts).
The goal is to count how many ways he can split the kingdom.
Write a function:
int solution(int N, int M, vector<int> &X, vector<int> &Y);
that, given two arrays of K integers X and Y, denoting coordinates of boroughs containing the gold mines, will compute the number of fair divisions of the kingdom.
For example, given N = 5, M = 5, X = [0, 4, 2, 0] and Y = [0, 0, 1, 4], the function should return 3. The king can divide his land in three different ways shown on the picture below.
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..100,000];
- each element of array X is an integer within the range [0..N-1];
- each element of array Y is an integer within the range [0..M-1].
Copyright 2009–2025 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.
Solution
Programming language used C++
Time spent on task 47 minutes
Notes
not defined yet
Code: 22:40:13 UTC,
java,
autosave
Code: 22:40:16 UTC,
cpp,
autosave
Code: 22:41:30 UTC,
cpp,
autosave
Code: 22:41: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// write your code in C++14 (g++ 6.2.0)
if (X.size() != Y.size())
return 0;
}
Code: 22:41:59 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
if (X.size() != Y.size())
return 0;
}
Code: 22:42: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;
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
}
Code: 22:42:33 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
}
Code: 22:42: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;
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
}
Code: 22:42: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;
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
//
if (K % 2)
return 0;
}
Code: 22:43:21 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this
if (K % 2)
return 0;
}
Code: 22:43:41 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
}
Code: 22:44: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
for (int i=0;i<K;i++)
{
}
}
Code: 22:44: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;
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
}
}
Code: 22:44: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts
}
}
Code: 22:44:51 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
}
Code: 22:45: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
}
Code: 22:45: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcount
}
}
Code: 22:45: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcount[Y[i]]++;
}
}
Code: 22:46: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcount[Y[i]]++;
}
for (int i=0;i<N;i++)
{
}
}
Code: 22:46:20 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcount[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << f
}
}
Code: 22:46: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcount[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << flush;
}
}
Code: 22:47: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcount[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", ""
}
}
Code: 22:47:15 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcount[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
}
Code: 22:47:15 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcount[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
}
Analysis
Compile error
func.cpp: In function 'int solution(int, int, std::vector<int>&, std::vector<int>&)':
func.cpp:28:9: error: 'colcount' was not declared in this scope
colcount[Y[i]]++;
^~~~~~~~
func.cpp:39:1: warning: control reaches end of non-void function [-Wreturn-type]
}
^
Code: 22:47:28 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcounts[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got 11000880 expected 3
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
Code: 22:47:38 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcounts[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got 0 expected 3
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
Code: 22:47: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcounts[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
co
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:47:53 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
vector<int> colcounts(N,0);
for (int i=0;i<K;i++)
{
colcounts[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got 0 expected 3
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
Code: 22:48:31 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row
vector<int> rowcounts(N,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
for (int i=0;i<K;i++)
{
colcounts[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:48: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
rowcounts[X[i]]++;
}
for (int i=0;i<K;i++)
{
colcounts[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:49:18 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if 8
}
for (int i=0;i<K;i++)
{
colcounts[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:49: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
for (int i=0;i<K;i++)
{
colcounts[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:49:47 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got 0 expected 3
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
Code: 22:50: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;
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:50:29 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
for (int i=0;i<rowcounts.size();i++)
{
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:50: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;
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:51: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:51:11 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got 0 expected 3
stdout:
2, 2, 3, 3, 4, 2, 3, 3, 3, 4,
Code: 22:51: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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:51: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;
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
ways =
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Code: 22:52:09 UTC,
cpp,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
ways ++;
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
ways ++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return 0;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got 0 expected 3
stdout:
2, 2, 3, 3, 4, 2, 3, 3, 3, 4,
Code: 22:52:16 UTC,
cpp,
verify,
result: Failed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
ways ++;
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
ways ++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
WRONG ANSWER,
got 10 expected 3
stdout:
2, 2, 3, 3, 4, 2, 3, 3, 3, 4,
Code: 22:52:36 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
ways ++;
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
ways ++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:53:03 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] == divisor)
ways ++;
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
ways ++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:53:13 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] == divisor)
ways ++;
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
ways ++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:53:37 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
ways++;
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
ways ++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:53:43 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
ways++;
}
for (int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 2, 3, 0, 1, 2, 3, 0, 0, 1,
Code: 22:54:03 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:54:12 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 2, 3, 0, 1, 2, 3, 0, 0, 1,
Code: 22:54:45 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 2, 3, 0, 1, 2, 3, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 3
function result: 3
stdout:
1, 2, 3, 0, 1, 1, 3, 0, 0, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
Code: 22:55:05 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:55:18 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
if (rowcounts[i] == divisor)
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:55:33 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
// 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 solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
if (rowcounts[i] == divisor)
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
if (colcounts[i] == divisor)
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 2, 3, 0, 1, 2, 3, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 2, 3, 0, 1, 1, 3, 0, 0, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
Code: 22:55:53 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;
int
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
if (rowcounts[i] == divisor)
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
if (colcounts[i] == divisor)
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:56:23 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
// 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 calculateCounts(vector<int> &sum,int divisor)
{
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
if (rowcounts[i] == divisor)
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
if (colcounts[i] == divisor)
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:56:39 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;
int calculateCounts(vector<int> &sum,int divisor)
{
for (int i=0;i<sum.size();i++)
{
}
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
if (rowcounts[i] == divisor)
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
if (colcounts[i] == divisor)
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:57:09 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
// 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 calculateCounts(vector<int> &sum,int divisor)
{
for (int i=0;i<sum.size();i++)
{
sum[i]+= sum[i-1];
if (sum[i] > divisor)
break;
if (sum[i])
}
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
if (rowcounts[i] == divisor)
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
if (colcounts[i] == divisor)
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:57:30 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778
// 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 calculateCounts(vector<int> &sum,int divisor)
{
int ways = 0;
for (int i=0;i<sum.size();i++)
{
sum[i]+= sum[i-1];
if (sum[i] > divisor)
break;
if (sum[i] == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
if (rowcounts[i] == divisor)
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
if (colcounts[i] == divisor)
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:57:43 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;
int calculateCounts(vector<int> &sum,int divisor)
{
int ways = 0;
for (int i=0;i<sum.size();i++)
{
if (i > 0)
sum[i]+= sum[i-1];
if (sum[i] > divisor)
break;
if (sum[i] == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
if (rowcounts[i] == divisor)
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
if (colcounts[i] == divisor)
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:58:13 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;
int calculateCounts(vector<int> &sum,int divisor)
{
int ways = 0;
for (int i=0;i<sum.size();i++)
{
if (i > 0)
sum[i]+= sum[i-1];
if (sum[i] > divisor)
break;
if (sum[i] == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways +=
for (unsigned int i=0;i<rowcounts.size();i++)
{
if (i > 0)
rowcounts[i] += rowcounts[i-1];
if (rowcounts[i] > divisor)
break;
if (rowcounts[i] == divisor)
ways++;
}
for (unsigned int i=0;i<colcounts.size();i++)
{
if (i > 0)
colcounts[i] += colcounts[i-1];
if (colcounts[i] > divisor)
break;
if (colcounts[i] == divisor)
ways++;
}
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:58:23 UTC,
cpp,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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 calculateCounts(vector<int> &sum,int divisor)
{
int ways = 0;
for (int i=0;i<sum.size();i++)
{
if (i > 0)
sum[i]+= sum[i-1];
if (sum[i] > divisor)
break;
if (sum[i] == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 2, 3, 0, 1, 2, 3, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 2, 3, 0, 1, 1, 3, 0, 0, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
Code: 22:58:39 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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 calculateCounts(vector<int> &sum,int divisor)
{
int ways = 0;
for (unsigned int i=0;i<sum.size();i++)
{
if (i > 0)
sum[i]+= sum[i-1];
if (sum[i] > divisor)
break;
if (sum[i] == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:59:03 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
// 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 calculateCounts(vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
if (i > 0)
sum[i]+= sum[i-1];
if (sum[i] > divisor)
break;
if (sum[i] == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:59:15 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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 calculateCounts(vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (sum[i] > divisor)
break;
if (sum[i] == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:59:32 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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 calculateCounts(vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:59:45 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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 calculateCounts(cvector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 22:59:48 UTC,
cpp,
verify,
result: Failed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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 calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
Compile error
func.cpp: In function 'int calculateCounts(const std::vector<int>&, int)':
func.cpp:16:12: error: expected '(' before 'currentSum'
if currentSum > divisor)
^~~~~~~~~~
Code: 22:59:57 UTC,
cpp,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
// 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 calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 1, 1, 0, 1, 1, 2, 0, 0, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
Code: 23:00:32 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
// 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;
#inc
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:00:53 UTC,
cpp,
autosave
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 <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:00:59 UTC,
cpp,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 1, 1, 0, 1, 1, 2, 0, 0, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
Code: 23:01:47 UTC,
cpp,
verify,
result: Passed
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 1, 1, 0, 1, 1, 2, 0, 0, 1,
1.
0.001 s
OK
function result: 4
function result: 4
stdout:
2, 1, 0, 0, 0, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
Code: 23:02:11 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:02:21 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:02:38 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:03:07 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:03:37 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexit
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:03:48 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:04:08 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
//
if (currentSum > divisor)
break;
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:04:32 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// still inside
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:05:02 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line to
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:05:16 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:05:26 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:05:30 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 1, 1, 0, 1, 1, 2, 0, 0, 1,
1.
0.001 s
OK
function result: 4
function result: 4
stdout:
2, 1, 0, 0, 0, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
Code: 23:05:40 UTC,
cpp,
verify,
result: Passed
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Analysis
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
Code: 23:06:30 UTC,
cpp,
verify,
result: Passed
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
1.
0.001 s
OK
function result: 4
function result: 4
1.
0.001 s
OK
function result: 1
function result: 1
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
User test case 3:
[5, 1, [0, 0], [4, 0]]
Code: 23:07:19 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:07:21 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 1, 1, 0, 1, 1, 2, 0, 0, 1,
1.
0.001 s
OK
function result: 4
function result: 4
stdout:
2, 1, 0, 0, 0, 1,
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
2, 0, 0, 0, 0, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
User test case 3:
[5, 1, [0, 0], [4, 0]]
Code: 23:07:46 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 1, 1, 0, 1, 1, 2, 0, 0, 1,
1.
0.001 s
OK
function result: 4
function result: 4
stdout:
2, 1, 0, 0, 0, 1,
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
2, 0, 0, 0, 0, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
User test case 3:
[5, 1, [0, 0], [0, 4]]
Code: 23:08:04 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 1, 1, 0, 1, 1, 2, 0, 0, 1,
1.
0.001 s
OK
function result: 4
function result: 4
stdout:
2, 1, 0, 0, 0, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
Code: 23:08:11 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:08:13 UTC,
cpp,
verify,
result: Passed
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Analysis
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
Code: 23:09:44 UTC,
cpp,
verify,
result: Passed
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
1.
0.001 s
OK
function result: 4
function result: 4
1.
0.001 s
OK
function result: 4
function result: 4
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
User test case 3:
[5, 5, [0, 1, 3, 4], [0, 1, 3, 4]]
Code: 23:09:53 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Code: 23:09:54 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 1, 1, 0, 1, 1, 2, 0, 0, 1,
1.
0.001 s
OK
function result: 4
function result: 4
stdout:
2, 1, 0, 0, 0, 1,
1.
0.001 s
OK
function result: 4
function result: 4
stdout:
1, 1, 0, 1, 1, 1, 1, 0, 1, 1,
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
User test case 3:
[5, 5, [0, 1, 3, 4], [0, 1, 3, 4]]
Code: 23:10:47 UTC,
cpp,
verify,
result: Passed
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
for (int i=0;i<N;i++)
{
cout << rowcounts[i] << ", " << flush;
}
cout << endl << endl;
for (int i=0;i<M;i++)
{
cout << colcounts[i] << ", " << flush;
}
return ways;
}
Analysis
expand all
Example tests
1.
0.001 s
OK
stdout:
2, 0, 1, 0, 1, 2, 1, 0, 0, 1,
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
stdout:
1, 1, 1, 0, 1, 1, 2, 0, 0, 1,
1.
0.001 s
OK
function result: 4
function result: 4
stdout:
2, 1, 0, 0, 0, 1,
1.
0.001 s
OK
function result: 4
function result: 4
stdout:
1, 1, 0, 1, 1, 1, 1, 0, 1, 1,
1.
0.001 s
OK
function result: 0
function result: 0
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
User test case 3:
[5, 5, [0, 1, 3, 4], [0, 1, 3, 4]]
User test case 4:
[5, 5, [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
Code: 23:10:54 UTC,
cpp,
autosave
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:11:26 UTC,
cpp,
verify,
result: Passed
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Analysis
User test case 1:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
User test case 3:
[5, 5, [0, 1, 3, 4], [0, 1, 3, 4]]
User test case 4:
[5, 5, [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
User test case 5:
[8, 8, [1, 2, 3, 4], [1, 2, 3, 4]]
Code: 23:11:52 UTC,
cpp,
verify,
result: Passed
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
1.
0.001 s
OK
function result: 4
function result: 4
1.
0.001 s
OK
function result: 4
function result: 4
1.
0.001 s
OK
function result: 0
function result: 0
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:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
User test case 3:
[5, 5, [0, 1, 3, 4], [0, 1, 3, 4]]
User test case 4:
[5, 5, [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
User test case 5:
[8, 8, [1, 2, 3, 4], [1, 2, 3, 4]]
User test case 6:
[5, 5, [1, 2, 3, 4], [1, 2, 3, 4]]
Code: 23:12:40 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
#include <iostream>
#include <vector>
using namespace std;
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:13:11 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
#include <iostream>
#include <vector>
using namespace std;
// Calculates sums until given index on a row or a column and
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:13:37 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455
#include <iostream>
#include <vector>
using namespace std;
// Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:14:30 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
#include <iostream>
#include <vector>
using namespace std;
// Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:14:41 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556
#include <iostream>
#include <vector>
using namespace std;
// Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
/**
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:14:50 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657
#include <iostream>
#include <vector>
using namespace std;
//
/**
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:15:15 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758
#include <iostream>
#include <vector>
using namespace std;
//
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:15:28 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
#include <iostream>
#include <vector>
using namespace std;
//
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
*
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:15:43 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
#include <iostream>
#include <vector>
using namespace std;
//
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in]
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:15:56 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
#include <iostream>
#include <vector>
using namespace std;
//
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] sum
int calculateCounts(const vector<int> &sum,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:16:07 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
#include <iostream>
#include <vector>
using namespace std;
//
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] sum
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += sum[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:16:26 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
#include <iostream>
#include <vector>
using namespace std;
//
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:16:36 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960
#include <iostream>
#include <vector>
using namespace std;
//
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:17:06 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061
#include <iostream>
#include <vector>
using namespace std;
//
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair di
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:17:36 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
#include <iostream>
#include <vector>
using namespace std;
//
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:17:47 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:18:00 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/**
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:18:30 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** Ho
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:18:45 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** How many ways can the King split the kingdom.
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:18:59 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom.
*
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:19:29 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom.
* Assumes X and Y size
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:19:40 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom.
* Assumes X and Y must be pairs.
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:19:53 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom.
* Assumes X and Y must be pairs and no duplicates.
*
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:20:18 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom.
* Finds and calculates a fair dividing Assumes X and Y must be pairs and no duplicates.
*
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:20:48 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only beAssumes X and Y must be pairs and no duplicates.
*
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:21:06 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines Assumes X and Y must be pairs and no duplicates.
*
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:21:36 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Assumes X and Y must be pairs and no duplicates.
*
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:21:49 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided Assumes X and Y must be pairs and no duplicates.
*
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:22:04 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided Assumes X and Y must be pairs and no duplicates.
*
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:22:34 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines given with X and Y variables.Assumes X and Y must be pairs and no duplicates.
*
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:22:44 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines given with X and Y variable.
* - Assumes X and Y must be pairs and no duplicates.
*
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:22:56 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:23:07 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* @param[in] N
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:23:18 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* @param[in] N Row count of a
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:23:43 UTC,
cpp,
autosave
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in]
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:24:14 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines
* @param[in] Y Y coordinates of the goldmines.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:24:26 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines.
* @param[in] Y Y coordinates of the goldmines.
* @return
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:24:46 UTC,
cpp,
autosave
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines.
* @param[in] Y Y coordinates of the goldmines.
* @return Number of ways that goldmines can be split equally between two childrens.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:25:10 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* - Assumes gold mines can't be shared.
* -
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines.
* @param[in] Y Y coordinates of the goldmines.
* @return Number of ways that goldmines can be split equally between two childrens.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:25:32 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* - Assumes gold mines can't be shared.
* - Assumes only gold mines matter; land does not.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines.
* @param[in] Y Y coordinates of the goldmines.
* @return Number of ways that goldmines can be split equally between two childrens.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:25:43 UTC,
cpp,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* - Assumes gold mines can't be shared.
* - Assumes only gold mines matter; land does not.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines.
* @param[in] Y Y coordinates of the goldmines.
* @return Number of ways that goldmines can be split equally between two childrens.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Analysis
Compile error
func.cpp: In function 'int calculateCounts(const std::vector<int>&, int)':
func.cpp:19:29: error: 'sum' was not declared in this scope
for (unsigned int i=0;i<sum.size();i++)
^~~
Code: 23:25:58 UTC,
cpp,
verify,
result: Failed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<sum.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* - Assumes gold mines can't be shared.
* - Assumes only gold mines matter; land does not.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines.
* @param[in] Y Y coordinates of the goldmines.
* @return Number of ways that goldmines can be split equally between two childrens.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Analysis
Compile error
func.cpp: In function 'int calculateCounts(const std::vector<int>&, int)':
func.cpp:19:29: error: 'sum' was not declared in this scope
for (unsigned int i=0;i<sum.size();i++)
^~~
Code: 23:26:05 UTC,
cpp,
autosave
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<counts.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* - Assumes gold mines can't be shared.
* - Assumes only gold mines matter; land does not.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines.
* @param[in] Y Y coordinates of the goldmines.
* @return Number of ways that goldmines can be split equally between two childrens.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Code: 23:26:06 UTC,
cpp,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<counts.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* - Assumes gold mines can't be shared.
* - Assumes only gold mines matter; land does not.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines.
* @param[in] Y Y coordinates of the goldmines.
* @return Number of ways that goldmines can be split equally between two childrens.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
1.
0.001 s
OK
function result: 4
function result: 4
1.
0.001 s
OK
function result: 4
function result: 4
1.
0.001 s
OK
function result: 0
function result: 0
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:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
User test case 3:
[5, 5, [0, 1, 3, 4], [0, 1, 3, 4]]
User test case 4:
[5, 5, [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
User test case 5:
[8, 8, [1, 2, 3, 4], [1, 2, 3, 4]]
User test case 6:
[5, 5, [1, 2, 3, 4], [1, 2, 3, 4]]
Code: 23:26:27 UTC,
cpp,
verify,
result: Passed
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<counts.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* - Assumes gold mines can't be shared.
* - Assumes only gold mines matter; land does not.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines.
* @param[in] Y Y coordinates of the goldmines.
* @return Number of ways that goldmines can be split equally between two childrens.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}
Analysis
expand all
User tests
1.
0.001 s
OK
function result: 1
function result: 1
1.
0.001 s
OK
function result: 4
function result: 4
1.
0.001 s
OK
function result: 4
function result: 4
1.
0.001 s
OK
function result: 0
function result: 0
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:
[5, 5, [1, 4, 2, 0], [1, 0, 1, 4]]
User test case 2:
[1, 5, [0, 0], [0, 4]]
User test case 3:
[5, 5, [0, 1, 3, 4], [0, 1, 3, 4]]
User test case 4:
[5, 5, [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]
User test case 5:
[8, 8, [1, 2, 3, 4], [1, 2, 3, 4]]
User test case 6:
[5, 5, [1, 2, 3, 4], [1, 2, 3, 4]]
Code: 23:26:31 UTC,
cpp,
final,
score:
100
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475
#include <iostream>
#include <vector>
using namespace std;
/**
* Calculate Counts of a Row or Column
* Calculates sums until given index on a row or a column and returns number of ways to divide on that set of rows or columns.
*
* @param[in] counts row/columns gold mine counts
* @param[in] divisor fair division line
* @return number of ways division possible using this set
*/
int calculateCounts(const vector<int> &counts,int divisor)
{
int ways = 0;
int currentSum = 0;
for (unsigned int i=0;i<counts.size();i++)
{
currentSum += counts[i];
// Moved to an unfair line ? just break this loop
if (currentSum > divisor)
break;
// if still in a fair line than we could count this line as a way to divide the kingdom.
if (currentSum == divisor)
ways++;
}
return ways;
}
/** This function calculates how many ways can the King split the kingdom for his two children.
* Finds ways to divide a kindgom for the king.
* - Kingdom can only be split using vertical and horizontal lines goes along the borders.
* - Each divided part must contain same amount of gold mines.
* - Assumes X and Y must be pairs and no duplicates.
* - Assumes gold mines can't be shared.
* - Assumes only gold mines matter; land does not.
* @param[in] N Row count of the Kingdom
* @param[in] M Column count of the Kingdom
* @param[in] X X coordinates of the goldmines.
* @param[in] Y Y coordinates of the goldmines.
* @return Number of ways that goldmines can be split equally between two childrens.
*/
int solution(int N, int M, vector<int> &X, vector<int> &Y) {
// Just some sanity checks
// cordinates must be pairs.
if (X.size() != Y.size())
return 0;
int K = X.size();
// Gold mines must be divisable by two if we want this to be fair.
if (K % 2)
return 0;
// Count number of gold mines in a row and in a column
vector<int> rowcounts(N,0);
vector<int> colcounts(M,0);
// If we sort the X/Y coordinate pairs before this loop; solution can be realized inside this single for loop. I didn't implement this solution just because it might break max allowed time complexity.
for (int i=0;i<K;i++)
{
if (X[i] < N) // Check if coordinate is inside the kingdom
rowcounts[X[i]]++;
if (Y[i] < M)
colcounts[Y[i]]++;
}
int ways = 0;
int divisor = K / 2;
ways = calculateCounts(rowcounts,divisor);
ways += calculateCounts(colcounts,divisor);
return ways;
}Analysis summary
The solution obtained perfect score.
Analysis
Detected time complexity:
O(N+M+K)
expand all
Correctness tests
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
3.
0.001 s
OK
4.
0.001 s
OK
1.
0.001 s
OK
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
7.
0.001 s
OK
8.
0.001 s
OK
9.
0.001 s
OK
10.
0.001 s
OK
11.
0.001 s
OK
12.
0.001 s
OK
13.
0.001 s
OK
14.
0.001 s
OK
1.
0.001 s
OK
2.
0.001 s
OK
1.
0.001 s
OK
expand all
Performance tests
1.
0.001 s
OK
2.
0.001 s
OK
3.
0.012 s
OK
1.
0.001 s
OK
2.
0.004 s
OK
1.
0.001 s
OK
2.
0.016 s
OK
1.
0.001 s
OK