Merge pull request ByteByteGoHq#12 from marttp/kotlin-hashmap-set

Kotlin chapter 2 - Hash Maps and Sets

Author: Destiny-02

kotlin/Hash Maps and Sets/GeometricSequenceTriplets.kt

@@ -0,0 +1,25 @@
+fun geometricSequenceTriplets(nums: List<Int>, r: Int): Int {
+    // leftMap and rightMap will use 'getOrDefault' to ensure the default value of 0 is returned when
+    // accessing a key that doesn’t exist in the hash map. This effectively sets
+    // the default frequency of all elements to 0.
+    val leftMap = mutableMapOf<Int, Int>()
+    val rightMap = mutableMapOf<Int, Int>()
+    var count = 0
+    // Populate 'rightMap' with the frequency of each element in the array.
+    for (x in nums) {
+        rightMap[x] = rightMap.getOrDefault(x, 0) + 1
+    }
+    // Search for geometric triplets that have x as the center.
+    for (x in nums) {
+        // Decrement the frequency of x in 'rightMap' since x is now being
+        // processed and is no longer to the right.
+        rightMap[x] = rightMap.getOrDefault(x, 0) - 1
+        if (x % r == 0) {
+            count += leftMap.getOrDefault(x / r, 0) * rightMap.getOrDefault(x * r, 0)
+        }
+        // Increment the frequency of x in 'leftMap' since it'll be a part of the
+        // left side of the array once we iterate to the next value of x.
+        leftMap[x] = leftMap.getOrDefault(x, 0) + 1
+    }
+    return count
+}

kotlin/Hash Maps and Sets/LongestChainOfConsecutiveNumbers.kt

@@ -0,0 +1,22 @@
+fun longestChainOfConsecutiveNumbers(nums: List<Int>): Int {
+    if (nums.isEmpty()) {
+        return 0
+    }
+    val numSet = nums.toSet()
+    var longestChain = 0
+    for (num in numSet) {
+        // If the current number is the smallest number in its chain, search for
+        // the length of its chain.
+        if (num - 1 !in numSet) {
+            var currentNum = num
+            var currentChain = 1
+            // Continue to find the next consecutive numbers in the chain.
+            while (currentNum + 1 in numSet) {
+                currentNum++
+                currentChain++
+            }
+            longestChain = maxOf(longestChain, currentChain)
+        }
+    }
+    return longestChain
+}

kotlin/Hash Maps and Sets/LongestChainOfConsecutiveNumbersBruteForce.kt

@@ -0,0 +1,18 @@
+fun longestChainOfConsecutiveNumbersBruteForce(nums: List<Int>): Int {
+    if (nums.isEmpty()) {
+        return 0
+    }
+    var longestChain = 0
+    // Look for chains of consecutive numbers that start from each number.
+    for (num in nums) {
+        var currentNum = num
+        var currentChain = 1
+        // Continue to find the next consecutive numbers in the chain.
+        while (currentNum + 1 in nums) {
+            currentNum++
+            currentChain++
+        }
+        longestChain = maxOf(longestChain, currentChain)
+    }
+    return longestChain
+}

kotlin/Hash Maps and Sets/PairSumUnSortedTwoPass.kt

@@ -0,0 +1,16 @@
+fun pairSumUnsortedTwoPass(nums: List<Int>, target: Int): List<Int> {
+    val numMap = mutableMapOf<Int, Int>()
+    // First pass: Populate the hash map with each number and its 
+    // index.
+    for ((i, num) in nums.withIndex()) {
+        numMap[num] = i
+    }
+    // Second pass: Check for each number's complement in the hash map.
+    for ((i, num) in nums.withIndex()) {
+        val complement = target - num
+        if (complement in numMap && numMap[complement] != i) {
+            return listOf(i, numMap[complement]!!)
+        }
+    }
+    return emptyList()
+}

kotlin/Hash Maps and Sets/PairSumUnsorted.kt

@@ -0,0 +1,10 @@
+fun pairSumUnsorted(nums: List<Int>, target: Int): List<Int> {
+    val hashmap = mutableMapOf<Int, Int>()
+    for ((i, x) in nums.withIndex()) {
+        if (target - x in hashmap) {
+            return listOf(hashmap[target - x]!!, i)
+        }
+        hashmap[x] = i
+    }
+    return emptyList()
+}

kotlin/Hash Maps and Sets/VerifySudokuBoard.kt

@@ -0,0 +1,41 @@
+fun verifySudokuBoard(board: List<List<Int>>): Boolean {
+    // Create hash sets for each row, column, and subgrid to keep
+    // track of numbers previously seen on any given row, column, or
+    // subgrid.
+    val rowSets: List<HashSet<Int>> = List(9) {
+        hashSetOf()
+    }
+    val colSets: List<HashSet<Int>> = List(9) {
+        hashSetOf()
+    }
+    val subgridSets: List<List<HashSet<Int>>> = List(3) {
+        List(3) {
+            hashSetOf()
+        }
+    }
+    for (r in 0 until 9) {
+        for (c in 0 until 9) {
+            val num = board[r][c]
+            if (num == 0) {
+                continue
+            }
+            // Check if 'num' has been seen in the current row,
+            // column, or subgrid.
+            if (rowSets[r].contains(num)) {
+                return false
+            }
+            if (colSets[c].contains(num)) {
+                return false
+            }
+            if (subgridSets[r / 3][c / 3].contains(num)) {
+                return false
+            }
+            // If we passed the above checks, mark this value as seen 
+            // by adding it to its corresponding hash sets.
+            rowSets[r].add(num)
+            colSets[c].add(num)
+            subgridSets[r / 3][c / 3].add(num)
+        }
+    }
+    return true
+}

kotlin/Hash Maps and Sets/ZeroStriping.kt

@@ -0,0 +1,57 @@
+fun zeroStriping(matrix: MutableList<MutableList<Int>>) {
+    if (matrix.isEmpty() || matrix[0].isEmpty()) {
+        return
+    }
+    val m = matrix.size
+    val n = matrix[0].size
+    // Check if the first row initially contains a zero.
+    var firstRowHasZero = false
+    for (c in 0 until n) {
+        if (matrix[0][c] == 0) {
+            firstRowHasZero = true
+            break
+        }
+    }
+    // Check if the first column initially contains a zero.
+    var firstColHasZero = false
+    for (r in 0 until m) {
+        if (matrix[r][0] == 0) {
+            firstColHasZero = true
+            break
+        }
+    }
+    // Use the first row and column as markers. If an element in the 
+    // submatrix is zero, mark its corresponding row and column in the 
+    // first row and column as 0.
+    for (r in 1 until m) {
+        for (c in 1 until n) {
+            if (matrix[r][c] == 0) {
+                matrix[0][c] = 0
+                matrix[r][0] = 0
+            }
+        }
+    }
+    // Update the submatrix using the markers in the first row and 
+    // column.
+    for (r in 1 until m) {
+        for (c in 1 until n) {
+            if (matrix[0][c] == 0 || matrix[r][0] == 0) {
+                matrix[r][c] = 0
+            }
+        }
+    }
+    // If the first row had a zero initially, set all elements in the 
+    // first row to zero.
+    if (firstRowHasZero) {
+        for (c in 0 until n) {
+            matrix[0][c] = 0
+        }
+    }
+    // If the first column had a zero initially, set all elements in 
+    // the first column to zero.
+    if (firstColHasZero) {
+        for (r in 0 until m) {
+            matrix[r][0] = 0
+        }
+    }
+}

kotlin/Hash Maps and Sets/ZeroStripingHashSets.kt

@@ -0,0 +1,29 @@
+fun zeroStripingHashSets(matrix: MutableList<MutableList<Int>>) {
+    if (matrix.isEmpty() || matrix[0].isEmpty()) {
+        return
+    }
+    val m = matrix.size
+    val n = matrix[0].size
+    val zeroRows = hashSetOf<Int>()
+    val zeroCols = hashSetOf<Int>()
+    // Pass 1: Traverse through the matrix to identify the rows and
+    // columns containing zeros and store their indexes in the 
+    // appropriate hash sets.
+    for (r in 0 until m) {
+        for (c in 0 until n) {
+            if (matrix[r][c] == 0) {
+                zeroRows.add(r)
+                zeroCols.add(c)
+            }
+        }
+    }
+    // Pass 2: Set any cell in the matrix to zero if its row index is 
+    // in 'zero_rows' or its column index is in 'zero_cols'.
+    for (r in 0 until m) {
+        for (c in 0 until n) {
+            if (r in zeroRows || c in zeroCols) {
+                matrix[r][c] = 0
+            }
+        }
+    }
+}