Merge commit 'f1705c5d2be4fecbe15f4f0be4a39cb1993b6653' into kotlin-trie

Author: marttp

kotlin/Bit Manipulation/HammingWeightsOfIntegers.kt

@@ -0,0 +1,16 @@
+fun hammingWeightsOfIntegers(n: Int): List<Int> {
+    return (1..n).map { countSetBits(it) }
+}
+
+fun countSetBits(n: Int): Int {
+    var x = n
+    var count = 0
+    // Count each set bit of 'x' until 'x' equals 0.
+    while (x > 0) {
+        // Increment the count if the LSB is 1.
+        count += x.and(1)
+        // Right shift 'x' to shift the next bit to the LSB position.
+        x = x.shr(1)
+    }
+    return count
+}

kotlin/Bit Manipulation/HammingWeightsOfIntegersDp.kt

@@ -0,0 +1,11 @@
+fun hammingWeightsOfIntegersDp(n: Int): List<Int> {
+    // Base case: the number of set bits in 0 is just 0. We set dp[0] to
+    // 0 by initializing the entire DP array to 0.
+    val dp = IntArray(n + 1)
+    for (x in 1..n) {
+        // 'dp[x]' is obtained using the result of 'dp[x >> 1]', plus
+        // the LSB of 'x'.
+        dp[x] = dp[x ushr 1] + (x and 1)
+    }
+    return dp.toList()
+}

kotlin/Bit Manipulation/LonelyInteger.kt

@@ -0,0 +1,11 @@
+fun lonelyInteger(nums: List<Int>): Int {
+    var res = 0
+    // XOR each element of the array so that duplicate values will
+    // cancel each other out (x ^ x == 0).
+    for (n in nums) {
+        res = res.xor(n)
+    }
+    // 'res' will store the lonely integer because it would not have
+    // been canceled out by any duplicate.
+    return res
+}

kotlin/Bit Manipulation/SwapOddAndEvenBits.kt

@@ -0,0 +1,11 @@
+fun swapOddAndEvenBits(n: Long): Long {
+    val evenMask: Long = 0x55555555   // 01010101010101010101010101010101
+    val oddMask: Long = 0xAAAAAAAA  // 10101010101010101010101010101010
+    val evenBits = n.toLong() and evenMask
+    val oddBits = n.toLong() and oddMask
+    // Shift the even bits to the left, the odd bits to the right, and 
+    // merge these shifted values together.
+    // shl - signed shift left
+    // ushr - unsigned shift right
+    return (evenBits shl 1) or (oddBits ushr 1)
+}

kotlin/Fast and Slow Pointers/HappyNumber.kt

@@ -0,0 +1,30 @@
+fun happyNumber(n: Int): Boolean {
+    var slow = n
+    var fast = n
+    while (true) {
+        slow = getNextNum(slow)
+        fast = getNextNum(getNextNum(fast))
+        if (fast == 1) {
+            return true
+        // If the fast and slow pointers meet, a cycle is detected. 
+        // Hence, 'n' is not a happy number.
+        } else if (fast == slow) {
+            return false
+        }
+    }
+}
+
+fun getNextNum(x: Int): Int {
+    var nextNum = 0
+    var num = x
+    while (num > 0) {
+        // Extract the last digit of 'x'.
+        val digit = num % 10
+        // Truncate (remove) the last digit from 'x' using floor 
+        // division.
+        num /= 10
+        // Add the square of the extracted digit to the sum.
+        nextNum += digit * digit
+    }
+    return nextNum
+}

kotlin/Fast and Slow Pointers/LinkedListLoop.kt

@@ -0,0 +1,19 @@
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int, var next: ListNode? = null)
+*/
+
+fun linkedListLoop(head: ListNode?): Boolean {
+    var slow = head
+    var fast = head
+    // Check both 'fast' and 'fast.next' to avoid null pointer
+    // exceptions when we perform 'fast.next' and 'fast.next.next'.
+    while (fast != null && fast.next != null) {
+        slow = slow!!.next
+        fast = fast.next!!.next
+        if (fast == slow) {
+            return true
+        }
+    }
+    return false
+}

kotlin/Fast and Slow Pointers/LinkedListLoopNaive.kt

@@ -0,0 +1,18 @@
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int, var next: ListNode? = null)
+*/
+
+fun linkedListLoopNaive(head: ListNode?): Boolean {
+    val visited = mutableSetOf<ListNode>()
+    var curr = head
+    while (curr != null) {
+        // Cycle detected if the current node has already been visited.
+        if (visited.contains(curr)) {
+            return true
+        }
+        visited.add(curr)
+        curr = curr.next
+    }
+    return false
+}

kotlin/Fast and Slow Pointers/LinkedListMidpoint.kt

@@ -0,0 +1,16 @@
+/*
+    Definition of ListNode:
+    data class ListNode(var value: Int, var next: ListNode? = null)
+*/
+
+fun linkedListMidpoint(head: ListNode?): ListNode? {
+    var slow = head
+    var fast = head
+    // When the fast pointer reaches the end of the list, the slow
+    // pointer will be at the midpoint of the linked list.
+    while (fast != null && fast.next != null) {
+        slow = slow!!.next
+        fast = fast.next!!.next
+    }
+    return slow
+}

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
+            }
+        }
+    }
+}