You can take a look at my solution(written in C# though):

public static int[] solution(int N, int[] A)
    {
        // write your code in C# with .NET 2.0
        var counters = new int[N];
        var defaultValueToInitialize = 0;
        var maxElement = 0;


        //initializing the counters values, without increasing the N+1 actions
        foreach (var num in A)
        {
            if (num == N + 1)
            {
                defaultValueToInitialize = maxElement;
                counters = new int[N];
            }
            else
            {
                counters[num - 1]++;
                if (counters[num - 1] + defaultValueToInitialize > maxElement)
                    maxElement = counters[num - 1] + defaultValueToInitialize;
            }

        }

        //adding the increased default value to each cell

        for (int i = 0; i < counters.Length; i++)
        {
            counters[i] += defaultValueToInitialize;
        }

        return counters;
    }

Check this one (python, get’s 100 score):

The secret is not to update all the counters every time you get the instruction to bump them all up to a new minimum value. This incurs an operation involving every counter on every occasion, and is the difference between a ~60% score and a 100% score.

Instead, avoid this hit by keeping track of the current minimum and maximum values; using and updating them for each counter you visit.

Then, after all the instructions are processed, because there may be counters which haven’t been touched with their own personal update since the last update-all instruction, pass over the counters themselves and ensure they are at the minimum value.

def solution(N, A):
    res = [0] * N
    max_val = 0
    last_update = 0
    n1 = N+1
    for i in A:
        if i < n1:
            if res[i-1] < last_update:
                res[i-1] = last_update

            res[i-1]+=1

            if res[i-1] > max_val:
                max_val = res[i-1]
        else:
            last_update = max_val

    for i in xrange(len(res)):
        if res[i] < last_update:
            res[i] = last_update

    return res

http://codility.com/demo/results/demoF3AMPT-FVN/

Consider this 100/100 solution in Ruby:

# Algorithm:
#
# * Maintain a maximum value.
# * For each `increase(X)` command update respective counter.
# * For each `max_counter` command save the current max as `set_max` for later use.
# * Once the loop is over, make an adjustment pass to set all values less than `set_max` to `set_max`.
def solution(n, commands)
  max = set_max = 0
  counters = Array.new(n, 0)

  commands.each do |cmd|
    if cmd <= n
      # This is an `increase(X)` command.
      value = [counters[cmd - 1], set_max].max + 1
      counters[cmd - 1] = value
      max = [value, max].max
    else
      # This is a `max_counter` command.
      # Just update `set_max`.
      set_max = max
    end
  end

  # Finalize -- set counters less than `set_max` to `set_max`.
  counters.map! {|value| [value, set_max].max}

  # Result.
  counters
end

#--------------------------------------- Tests

def test
  sets = []
  sets << ["1", [1], 1, [1]]
  sets << ["sample", [3, 2, 2, 4, 2], 5, [3, 4, 4, 6, 1, 4, 4]]

  sets.each do |name, expected, n, commands|
    out = solution(n, commands)
    raise "FAILURE at test #{name.inspect}: #{out.inspect} != #{expected.inspect}" if out != expected
  end

  puts "SUCCESS: All tests passed"
end

My python version only scores 66 points as it’s a little too slow for the later tests.

def solution(N, A):
    counters = [0 for x in range(N)]
    for elem in A:
        if elem > N:
            cmax = max(counters)
            counters = [cmax for x in range(N)]
        else:
            counters[elem-1] += 1
    return counters

100/100 solution in C

struct Results 
solution(int N, int A[], int M) 
{
    struct Results result;
    int *cnts = calloc(N, sizeof(int));
    int i = 0, maxcnt = 0, j = 0, lastcnt = 0;
    for (i = 0; i < M; i++) {
        if (A[i] <= N && A[i] >= 1) {
            if (cnts[A[i] - 1] < lastcnt)
                cnts[A[i] - 1] = lastcnt + 1;
            else
                cnts[A[i] - 1] += 1;
            if (cnts[A[i] - 1] > maxcnt)
                maxcnt = cnts[A[i] - 1];
        }
        if (A[i] == N + 1)
                lastcnt = maxcnt;
    }
    for (j = 0; j < N; j++) {
            if (cnts[j] < lastcnt)
                cnts[j] = lastcnt;
    }
    result.C = cnts;
    result.L = N;
    return result;
}

MaxCounters solution in C

struct Results solution(int N, int A[], int M) {
    struct Results result;
    // write your code in C90
    int i,k=0,max_v=0;
    
    result.C =(int*)(malloc(N*sizeof(int)));
    result.L = N;   
    memset(result.C, 0, N*sizeof(int));  

    for(i=0;i<M;i++)
    {      
        if (A[i] > N)    
            max_v=k;
        else
        {
            if(result.C[A[i]-1] < max_v)
                result.C[A[i]-1]=max_v;
            
            result.C[A[i]-1]+=1; 
            
            if(result.C[A[i]-1] > k)
                k=result.C[A[i]-1];
        }   
    }

    for(i=0;i<N;i++)
    {
        if(result.C[i] < max_v)
            result.C[i]=max_v;
    }
                    
    return result;
}

Javascript 100/100

function solution(N, A) {
    
    var j, len = A.length, lastBase = 0, max = 0, 
        counters = [], n1 = N+1;

    for(j=0; j<N; j+=1){
        counters[j]=0; //initArray
    }
    
    for(j=0; j < len; j+=1){
        if(A[j]<n1){
            if(counters[A[j]-1] < lastBase) {
                counters[A[j]-1] = lastBase;
            }
            counters[A[j]-1] += 1;
            if(max < counters[A[j]-1]) {
                max = counters[A[j]-1];
            }
        } else {
            lastBase = max;
        }
    }
    
    for(j=0; j<N; j+=1){
        if(counters[j] < lastBase) {
            counters[j] = lastBase;
        }
    }
    
    return counters;
    
}

This is a modified version of @jacoor’s solution with slightly more idiomatic python and variable names and if statement conditions more closely reflecting the problem description.

def fast_solution(N, A):
    counters = [0] * N
    max_counter = 0
    last_update = 0

    for K,X in enumerate(A): # O(M)
        if 1 <= X <= N:
            counters[X-1] = max(counters[X-1], last_update)
            counters[X-1] += 1
            max_counter = max(counters[X-1], max_counter)
        elif A[K] == (N + 1):
            last_update = max_counter

    for i in xrange(N): # O(N)
        counters[i] = max(counters[i], last_update)

    return counters

https://codility.com/demo/results/demo6KPS7K-87N/

Javascript 100/100

function solution(N, A) {
    var max = 0,
        offset = 0,
        counters = Array.apply(null, Array(N)).map(function () {return 0;});
        
    A.forEach(function (d) {
        if (d === N + 1) {
            offset = max;
        }
        else {
            counters[d-1] = Math.max(offset + 1, counters[d-1] + 1);
            max = Math.max(counters[d-1], max);
        }
    });
    
    counters.map(function (d, i) {
        if (d < offset) {
            counters[i] = offset;
        }
    });
    
    return counters;
}

Java solution:

public int[] solution(int N, int[] A) {
    // write your code in Java SE 8
    int[] counter = new int[N];
    int maxCounter = 0;
    int pos;
    int last_max=0;
    for (int i = 0; i < A.length; i++) {
        if (A[i] <= N) {
            pos = A[i];

            if (counter[pos - 1] < last_max)
                counter[pos - 1] = last_max;
            counter[pos - 1] += 1;

            if (maxCounter < counter[pos - 1])
                maxCounter = counter[pos - 1];
        }
        else{
            last_max=maxCounter;
        }
    }

    for (int i = 0; i < counter.length; i++) {
        if (counter[i] < last_max)
            counter[i] = last_max;
    }
    return counter;
}

C++ 100/100

The key is to IGNORE the sample iteration in the problem, it will lead you to a O(m*n) time complexity solution.

vector<int> solution(int N, vector<int> &A) {
// write your code in C++11

    vector<int> counters(N,0);
    
    int last_reset = 0, max_count = 0;
    
    for( unsigned int a=0; a < A.size(); ++a)
    {
         int current_int = A.at (a);
         
         if (current_int == (N+1))
         {
            last_reset = max_count;
         }
         else
         {
            unsigned int counter_index = current_int - 1;
             
            if ( counters.at (counter_index) < last_reset)
                counters.at (counter_index) = last_reset + 1;
            else
                ++counters.at (counter_index);
            if ( counters.at (counter_index) > max_count)
                max_count = counters.at (counter_index);
         }
            
    }
    for( unsigned int n=0; n < counters.size(); ++n)
    {
        if ( counters.at (n) < last_reset)
            counters.at (n) = last_reset;
    }
    return counters;

}

C# – a 100/100 solution

public int[] solution(int N, int[] A) {
    // write your code in C# 6.0 with .NET 4.5 (Mono)
    int[] counter = new int[N];
    int maxValue = 0;
    int minValue = 0;
    for(int i=0;i<A.Length;i++)
    {
        //less than or equal to length N
        if(A[i] <= N)
        {
            if(counter[A[i] - 1] < minValue)
            {
                counter[A[i] - 1] = minValue;
            }
            counter[A[i] - 1] += 1;
            if(counter[A[i] - 1] > maxValue)
            {
                maxValue = counter[A[i] - 1];
            }
        }
        else if(A[i] == N+1)
        {
            minValue = maxValue;
        }
    }
    for(int j=0;j<counter.Length;j++)
    {
        if(counter[j] < minValue)
        {
            counter[j] = minValue;
        }
    }
    return counter;
}

here is the shortest solution in Python:

def solution(N, A):
    out = [0 for _ in range(N)]
    for ele in A:
        if ele<=N: out[ele-1] += 1
        else: out = [max(out) for i in range(len(out))]           
    return out

Python 100%

The following solution is simpler and easy to understand from the previous solutions in python where you can use set() to add a possible maximum number each time you find a new possible one. And after that when A[i] is equal to N + 1 you update counters with the max number found in the set and reset it again since the old max would be smaller than the coming ones and not needed. So the line where we clear the set is very important to pass all performance tests

Detected time complexity is:
O(N + M)

def solution(N, A):
    
    counters = [0] * N
    max_numbers = set()
    
    for i in range(0, len(A)):

        if 1 <= A[i] <= N:

            index = A[i]-1
            counters[index] += 1
            max_numbers.add(counters[A[i]-1])

        elif A[i] == N + 1 and len(max_numbers) > 0:

            counters = [max(max_numbers)] * N
            max_numbers.clear()

    return counters

100% solution with Python–what helped was to keep track of the max in each iteration instead of calculating it each time N+1 appeared

def solution(N, A):
    counters = [0] * N
    all_max = list(set(A))
    if len(all_max) == 1 and all_max[0] == N + 1:
        return counters

    the_max = 0
    for i in A:
        if i == N + 1:
            counters = [the_max] * N
        elif i > N + 1:
            continue
        else:
            counters[i-1] += 1
            if counters[i-1] > the_max:
                the_max = counters[i-1]
    return counters

Python

from collections import Counter


def solution(N, A):
    stop = [i for i in range(len(A)) if A[i] > N]
    old = val = 0
    for s in stop:
        o = A[old:s]
        if o:
            val += max(Counter(o).values())
        old = s + 1
    c = [val] * N
    start = 0 if not stop else stop[-1] + 1
    for i in A[start:]:
        c[i-1] += 1
    return c