Created Custom Filter for problems I think will get me better faster

Michael Sila · Michael Sila · commit aea0b3f68074 · 2021-03-16T10:23:12.000-06:00
diff --git a/solutions/src/CountServersThatCanCommunicate.kt b/solutions/src/CountServersThatCanCommunicate.kt
@@ -0,0 +1,29 @@
+/**
+ * https://leetcode.com/problems/count-servers-that-communicate/
+ */
+class CountServersThatCanCommunicate {
+
+    fun countServers(grid: Array<IntArray>): Int {
+        val rows = mutableMapOf<Int,MutableList<Pair<Int,Int>>>()
+        val columns = mutableMapOf<Int,MutableList<Pair<Int,Int>>>()
+        val validServers = mutableSetOf<Pair<Int,Int>>()
+        for (i in grid.indices) {
+            for (j in grid[0].indices) {
+                if (grid[i][j] == 1) {
+                    rows.computeIfAbsent(i){ mutableListOf()}.add(Pair(i,j))
+                    columns.computeIfAbsent(j){ mutableListOf()}.add(Pair(i,j))
+                }
+            }
+        }
+        rows.values.filter { it.size > 1 }.forEach { validServers.addAll(it) }
+        columns.values.filter { it.size > 1 }.forEach { validServers.addAll(it) }
+
+        return validServers.size
+
+    }
+
+
+
+
+
+}
diff --git a/solutions/src/CountSortedVowelStrings.kt b/solutions/src/CountSortedVowelStrings.kt
@@ -0,0 +1,59 @@
+/**
+ * https://leetcode.com/problems/count-sorted-vowel-strings/
+ */
+class CountSortedVowelStrings {
+
+    fun countVowelStrings(n: Int): Int {
+        if (n == 1) {
+            return 5
+        }
+        val vowelMap : MutableMap<Pair<Int,Char>,Int> = mutableMapOf()
+
+        val vowels = mutableListOf('a','e','i','o','u')
+
+        vowels.forEach { vowelMap[Pair(1,it)] = 1 }
+
+        for (i in 1 until n) {
+            for (v in vowels) {
+                val current = vowelMap[Pair(i,v)]!!
+                when (v)  {
+                    'a' -> {
+                        vowelMap[Pair(i+1,'a')] = vowelMap.getOrDefault(Pair(i+1,'a'),0)+current
+                        vowelMap[Pair(i+1,'e')] = vowelMap.getOrDefault(Pair(i+1,'e'),0)+current
+                        vowelMap[Pair(i+1,'i')] = vowelMap.getOrDefault(Pair(i+1,'i'),0)+current
+                        vowelMap[Pair(i+1,'o')] = vowelMap.getOrDefault(Pair(i+1,'o'),0)+current
+                        vowelMap[Pair(i+1,'u')] = vowelMap.getOrDefault(Pair(i+1,'u'),0)+current
+                    }
+                    'e' -> {
+                        vowelMap[Pair(i+1,'e')] = vowelMap.getOrDefault(Pair(i+1,'e'),0)+current
+                        vowelMap[Pair(i+1,'i')] = vowelMap.getOrDefault(Pair(i+1,'i'),0)+current
+                        vowelMap[Pair(i+1,'o')] = vowelMap.getOrDefault(Pair(i+1,'o'),0)+current
+                        vowelMap[Pair(i+1,'u')] = vowelMap.getOrDefault(Pair(i+1,'u'),0)+current
+                    }
+                    'i' -> {
+                        vowelMap[Pair(i+1,'i')] = vowelMap.getOrDefault(Pair(i+1,'i'),0)+current
+                        vowelMap[Pair(i+1,'o')] = vowelMap.getOrDefault(Pair(i+1,'o'),0)+current
+                        vowelMap[Pair(i+1,'u')] = vowelMap.getOrDefault(Pair(i+1,'u'),0)+current
+                    }
+                    'o' -> {
+                        vowelMap[Pair(i+1,'o')] = vowelMap.getOrDefault(Pair(i+1,'o'),0)+current
+                        vowelMap[Pair(i+1,'u')] = vowelMap.getOrDefault(Pair(i+1,'u'),0)+current
+                    }
+                    'u' -> {
+                        vowelMap[Pair(i+1,'u')] = vowelMap.getOrDefault(Pair(i+1,'u'),0)+current
+                    }
+                }
+
+            }
+        }
+
+        var sum = 0
+        for (v in vowels) {
+            sum+= vowelMap[Pair(n,v)]!!
+        }
+        return sum
+
+    }
+
+
+}
diff --git a/solutions/src/DeleteNodesAndReturnForest.kt b/solutions/src/DeleteNodesAndReturnForest.kt
@@ -0,0 +1,47 @@
+class DeleteNodesAndReturnForest {
+
+    fun delNodes(root: TreeNode?, to_delete: IntArray): List<TreeNode?> {
+        val toDelete = to_delete.toSet()
+        val forestMap = mutableMapOf<Int,TreeNode>()
+        if (root != null) {
+            forestMap[root.`val`] = root
+        }
+        traverse(null,root,forestMap,toDelete,DIRECTION.NONE)
+        return forestMap.values.toList()
+    }
+
+
+    private fun traverse(parent: TreeNode?, node: TreeNode?, forest: MutableMap<Int,TreeNode>, toDelete: Set<Int>, direction: DIRECTION ) {
+        if (node == null) {
+            return
+        }
+        if (toDelete.contains(node.`val`)) {
+            if (parent != null) {
+                if (direction == DIRECTION.LEFT) {
+                    parent.left = null
+                }
+                if (direction == DIRECTION.RIGHT) {
+                    parent.right = null
+                }
+
+            }
+            if (node.left != null) {
+                forest[node.left!!.`val`] = node.left!!
+            }
+            if (node.right != null) {
+                forest[node.right!!.`val`] = node.right!!
+            }
+            forest.remove(node.`val`)
+        }
+
+        traverse(node,node.left,forest,toDelete,DIRECTION.LEFT)
+        traverse(node,node.right,forest,toDelete,DIRECTION.RIGHT)
+    }
+
+
+    private enum class DIRECTION {
+        NONE,
+        LEFT,
+        RIGHT
+    }
+}
diff --git a/solutions/src/FilterResturantsByFactors.kt b/solutions/src/FilterResturantsByFactors.kt
@@ -0,0 +1,17 @@
+/**
+ * https://leetcode.com/problems/filter-restaurants-by-vegan-friendly-price-and-distance/
+ */
+class FilterResturantsByFactors {
+
+    fun filterRestaurants(restaurants: Array<IntArray>, veganFriendly: Int, maxPrice: Int, maxDistance: Int): List<Int> {
+
+        return restaurants.filter {
+            val validPrice = it[3] <= maxPrice
+            val validDistance = it[4] <= maxDistance
+            val validVegan = veganFriendly == 0 || it[2] == 1
+            validDistance && validPrice && validVegan
+        }
+                .sortedWith(compareByDescending<IntArray> { it[1] }.thenByDescending{it[0]})
+                .map { it[0] }
+    }
+}
diff --git a/solutions/src/LowestCommonAncestorOfDeepestLeaves.kt b/solutions/src/LowestCommonAncestorOfDeepestLeaves.kt
@@ -0,0 +1,45 @@
+/**
+ * https://leetcode.com/problems/lowest-common-ancestor-of-deepest-leaves/
+ */
+class LowestCommonAncestorOfDeepestLeaves {
+
+    fun lcaDeepestLeaves(root: TreeNode?): TreeNode? {
+        if (root == null) {
+            return null
+        }
+        val traversal = traverse(root,0)
+        return traversal.first
+    }
+
+
+
+    fun traverse(node: TreeNode? , depth: Int ) : Pair<TreeNode?,Int> {
+
+        if (node == null) {
+            return Pair(null,depth)
+        }
+        if (node.left == null && node.right == null) {
+            return Pair(node,depth)
+        }
+        if (node.left == null ) {
+            return traverse(node.right!!,depth+1)
+        }
+        if (node.right == null) {
+            return traverse(node.left!!,depth+1)
+        }
+        else {
+            val rightTraverse = traverse(node.right!!,depth+1)
+            val leftTraverse = traverse(node.left!!,depth+1)
+            if (rightTraverse.second > leftTraverse.second) {
+                return rightTraverse
+            }
+            else if (leftTraverse.second > rightTraverse.second) {
+                return leftTraverse
+            }
+            else {
+                return Pair(node,leftTraverse.second)
+            }
+        }
+
+    }
+}
diff --git a/solutions/src/MinimumToAddToMakeParenthesisValid.kt b/solutions/src/MinimumToAddToMakeParenthesisValid.kt
@@ -0,0 +1,23 @@
+/**
+ * https://leetcode.com/problems/minimum-add-to-make-parentheses-valid/
+ */
+class MinimumToAddToMakeParenthesisValid {
+    fun minAddToMakeValid(S: String): Int {
+        var toAdd = 0
+        val stack = mutableListOf<Char>()
+        S.forEach {
+            if (it == '(') {
+                stack.add(0,it)
+            }
+            if (it == ')') {
+                if (stack.isEmpty() || stack.first() != '(') {
+                    toAdd++
+                }
+                else {
+                    stack.removeAt(0)
+                }
+            }
+        }
+        return toAdd+stack.size
+    }
+}
diff --git a/solutions/src/TestBed.kt b/solutions/src/TestBed.kt
@@ -5,18 +5,27 @@ import kotlin.time.measureTime
 @ExperimentalTime
 fun main(args: Array<String>) {
     println(measureTime {
-        val tester = MinimumDeletionCostToAvoidRepeatingLetters()
+        val tester = DeleteNodesAndReturnForest()
+
+
         val result = listOf(
-                tester.minCost("abaac", intArrayOf(1,2,3,4,5)),
-                tester.minCost("abc", intArrayOf(1,2,3)),
-                tester.minCost("aabaa", intArrayOf(1,2,3,4,1))
+                traverse1()
         )
         println(result)
 
     })
 
 }
 
+private fun traverse1() : List<Int> {
+    val tester = DeleteNodesAndReturnForest()
+    val root = TreeNode(1)
+    root.left = TreeNode(2)
+    root.right = TreeNode(3)
+    root.right!!.right = TreeNode(4)
+    return tester.delNodes(root, intArrayOf(1,2)).map { it!!.`val` }
+}
+
 
 
 
