Hello there! In this unit, we're presenting an exciting coding lesson that demonstrates the performance efficiencies offered by HashMap in Kotlin. We'll address a list-based problem that requires an optimal choice to minimize the size of our list. Excited? So am I! Let's dive in.

In this unit's task, we'll manipulate a list of integers. You are tasked with constructing a Kotlin function named minimalMaxBlock(). This function should accept a list as input and compute an intriguing property related to contiguous blocks within the list.

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

For example, consider the list listOf(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 listOf(1), listOf(3, 1, 4, 4, 4, 1), listOf(5), with the longest containing 6 elements. If we instead remove all instances of 1, the new remaining blocks would be listOf(2, 2, 3), listOf(4, 4, 4), listOf(2, 5), the longest of which contains 3 elements. Thus, the function should return 1 in this case, as it leads to a minimally maximal block length.

A straightforward way to tackle this problem is through a brute-force method. Test each possible value in the list by removing it and checking the resulting sub-list sizes. This approach involves iteratively stepping through the list for every possible value.

fun minimalMaxBlockBruteforce(list: List<Int>): Int {
    var minMaxBlockSize = Int.MAX_VALUE
    var minNum = -1

    val uniqueElements = list.toSet()

    for (num in uniqueElements) {  // Avoid duplicates
        val indices = mutableListOf<Int>()
        for (i in list.indices) {
            if (list[i] == num) {
                indices.add(i)
            }
        }
        indices.add(0, -1)
        indices.add(list.size)

        var maxBlockSize = 0
        for (i in 1 until indices.size) {
            maxBlockSize = maxOf(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²) due to two nested loops: the outer loop cycling through each potential k value and the inner loop going over the list for each k value.

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