Hello there! In this unit, we're offering an engaging coding lesson that highlights the performance efficiencies offered by the utilization of Map in JavaScript. We'll address a list-based problem that requires us to make an optimal choice to minimize the size of our list. Excited? So am I! Let's get started.

In this unit's task, we'll manipulate a list of integers. You are required to construct a JavaScript function titled minimalMaxBlock(). This function should accept an array as an input and compute an intriguing property related to contiguous blocks within the array.

More specifically, you must select a particular integer, k, from the array. Once you've selected k, the function should remove all occurrences of k from the array, thereby splitting it into several contiguous blocks or remaining sub-arrays. A unique feature of k is that it is chosen such that the maximum length among these blocks is minimized.

For instance, consider the list [1, 2, 2, 3, 1, 4, 4, 4, 1, 2, 5]. If we eliminate all instances of 2 (our k), the remaining blocks would be [1], [3, 1, 4, 4, 4, 1], [5], with the longest containing 6 elements. Now, if we instead remove all instances of 1, the new remaining blocks would be [2, 2, 3], [4, 4, 4], [2, 5], the longest of which contains 3 elements. As such, the function should return 1 in this case, as it leads to a minimally maximal block length.

An initial way to approach this problem can be through a brute force method. Each possible value in the array could be tested in turn by removing it from the array and then checking the resulting sub-array sizes. This approach entails iteratively stepping through the array for each possible value in the array.

function minimalMaxBlockBruteforce(array) {
    let minMaxBlockSize = Number.MAX_VALUE; // Largest positive number in JavaScript, approximately 1.79E+308
    let minNum = -1;

    const uniqueElements = new Set(array);

    uniqueElements.forEach(num => {  // Avoid duplicates.
        const indices = [];
        for (let i = 0; i < array.length; ++i) {
            if (array[i] === num) {
                indices.push(i);
            }
        }
        indices.unshift(-1); // Insert -1 at first index
        indices.push(array.length);

        let maxBlockSize = 0;
        for (let i = 1; i < indices.length; ++i) {
            maxBlockSize = Math.max(maxBlockSize, indices[i] - indices[i - 1] - 1);
        }

        if (maxBlockSize < minMaxBlockSize) {
            minMaxBlockSize = maxBlockSize;
            minNum = num;
        }
    });

    return minNum;
}

This method has a time complexity of O(n^2), as it involves two nested loops: the outer loop cycling through each potential k value and the inner loop sweeping through the array for each of these k values.

However, this approach becomes increasingly inefficient as the size n of the array grows, due to its quadratic time complexity. For larger arrays or multiple invocations, the computation time can noticeably increase, demonstrating the need for a more efficient solution.