标签：codility
Task description
You are given N counters, initially set to 0, and you have two possible operations on them:
increase(X) counter X is increased by 1,
max counter all counters are set to the maximum value of any counter.
A non-empty zero-indexed array A of M integers is given. This array represents consecutive operations:
if A[K] = X, such that 1 ≤ X ≤ N, then operation K is increase(X),
if A[K] = N + 1 then operation K is max counter.
For example, given integer N = 5 and array A such that:
A[0] = 3 A[1] = 4 A[2] = 4 A[3] = 6 A[4] = 1 A[5] = 4 A[6] = 4
the values of the counters after each consecutive operation will be:
(0, 0, 1, 0, 0) (0, 0, 1, 1, 0) (0, 0, 1, 2, 0) (2, 2, 2, 2, 2) (3, 2, 2, 2, 2) (3, 2, 2, 3, 2) (3, 2, 2, 4, 2)
The goal is to calculate the value of every counter after all operations.
Assume that the following declarations are given:
struct Results {
int * C;
int L;
};
Write a function:
struct Results solution(int N, int A[], int M);
that, given an integer N and a non-empty zero-indexed array A consisting of M integers, returns a sequence of integers representing the values of the counters.
The sequence should be returned as:
a structure Results (in C), or
a vector of integers (in C++), or
a record Results (in Pascal), or
an array of integers (in any other programming language).
For example, given:
A[0] = 3 A[1] = 4 A[2] = 4 A[3] = 6 A[4] = 1 A[5] = 4 A[6] = 4
the function should return [3, 2, 2, 4, 2], as explained above.
Assume that:
N and M are integers within the range [1..100,000];
each element of array A is an integer within the range [1..N + 1].
Complexity:
expected worst-case time complexity is O(N+M);
expected worst-case space complexity is O(N), beyond input storage (not counting the storage required for input arguments).
Elements of input arrays can be modified.
Solution C:-1
struct Results solution(int N, int A[], int M)
{
struct Results result;
result.C = (int*)malloc(N*sizeof(int));
result.L = N;
int i = 0;
int* ptr = result.C;
int size = sizeof(int)*N;
memset(ptr, 0 , size );
int max = 0;
int resetValue = 0;
for( i = 0; i < M; i++ )
{
if( A[i] == N+1 )
{
resetValue = max;
}
else
{
int position = A[i]-1;
if( ptr[position] < resetValue )
{
ptr[position] = resetValue+1;
}
else
{
ptr[position]++;
}
if(ptr[position] > max )
{
max = ptr[position];
}
}
}
for( i = 0; i < N;i++ )
{
if( ptr[i] < resetValue )
{
ptr[i] = resetValue;
}
}
return result;
}Calculate the values of counters,布布扣,bubuko.com
Calculate the values of counters
标签：codility
原文地址：http://randywang.blog.51cto.com/4247710/1435473
