Performance of Array.reduce

Question

I was trying out the Codility MaxCounter question:

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.

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].

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.

Here is my solution, for which i used the reduce method. It scores 40% on performance. Can anyone see where the performance issue is here? I'm assuming perhaps it is the reduce speed itself thats the problem and that in order to increase this score i would need to convert this to for loops, but this just feels like a really ugly way to use modern javascript in this context.

Hopefully one of you will point out something non JS related about this solution that will not indicate that reduce is the issue and instead indicate that im an idiot (I will deal with the ramifications of this over a cold beer)

function maxCounter(N, A) {
    let maxCounter = 0
    const NArray = new Array(N).fill(0)

    const results = A.reduce((acc, current) => {
        if (current === N + 1) return new Array(N).fill(maxCounter)
        const out = acc.map((element, index) => {
            if (index + 1 === current){
                const newValue = element + 1
                if (newValue > maxCounter) maxCounter = newValue
                return newValue
            } else {
                return element
            }
        })
        return out
    }
    , NArray)
    return results
}

const results = maxCounter(5, [1,4,2,5,2,6,2])
console.log({results})

Answer 1

You could introduce a min value, which is set if all values have to be set to the max value, but this does happen only if the value is incremented, then the min value is used for update or at the end to give all items at least the min value.

function maxCounter(n, a) {
    var min = 0,
        max = 0,
        result = [],
        i;

    for (i of a) {
        if (--i === n) {
            min = max;
            continue;
        }
        if (!result[i] || result[i] < min) result[i] = min;
        if (++result[i] > max) max = result[i];
    }

    for (i = 0; i < n; i++) {
        if (!result[i] || result[i] < min) result[i] = min;
    }

    return result;
}

console.log(...maxCounter(5, [3, 4, 4, 6, 1, 4, 4]));
console.log(...maxCounter(5, [1, 4, 2, 5, 2, 6, 2]));