better

Author: JustAnotherSoftwareDeveloper

solutions/src/CourseScheduleTwo.kt

@@ -0,0 +1,43 @@
+/**
+ * https://leetcode.com/problems/course-schedule-ii/
+ */
+class CourseScheduleTwo {
+    fun findOrder(numCourses: Int, prerequisites: Array<IntArray>): IntArray {
+        val courePrereqs = (0 until numCourses).map { Pair(it, mutableSetOf<Int>()) }.toMap().toMutableMap()
+        val courseToListOfCoursesThatNeedIt = (0 until numCourses).map { Pair(it, mutableSetOf<Int>()) }.toMap().toMutableMap()
+        prerequisites.forEach { desc ->
+            val prereqList = mutableListOf<Int>()
+            for(i in 1 until desc.size) {
+                prereqList.add(desc[i])
+                courseToListOfCoursesThatNeedIt.computeIfAbsent(desc[i]) { mutableSetOf()}.add(desc[0])
+            }
+            courePrereqs.computeIfAbsent(desc[0]) { mutableSetOf()}.addAll(prereqList)
+        }
+        val availableCourses = courePrereqs.filter { it.value.isEmpty() }.map { it.key }.toMutableList()
+        availableCourses.forEach{
+            courePrereqs.remove(it)
+        }
+        val courseSchedule = mutableListOf<Int>()
+        val visited = availableCourses.toMutableSet()
+        while (availableCourses.isNotEmpty()) {
+            val current = availableCourses.removeAt(0)
+            courseSchedule.add(current)
+            val toQueue = mutableListOf<Int>()
+            courseToListOfCoursesThatNeedIt.getOrDefault(current, mutableSetOf()).forEach {
+                val preReqSet = courePrereqs[it]!!
+                preReqSet.remove(current)
+                if (preReqSet.isEmpty()) {
+                    courePrereqs.remove(it)
+                    toQueue.add(it)
+
+                }
+            }
+            availableCourses.addAll(toQueue)
+
+        }
+        return if (courseSchedule.size != numCourses) intArrayOf() else courseSchedule.toIntArray()
+
+
+
+    }
+}

solutions/src/LargestNumber.kt

@@ -0,0 +1,20 @@
+/**
+ * https://leetcode.com/problems/largest-number/
+ */
+class LargestNumber {
+    fun largestNumber(nums: IntArray) : String {
+        if (nums.isEmpty()) {
+            return ""
+        }
+        if (nums.all { it == 0 }) {
+            return "0"
+        }
+        val strCompare = Comparator<String> { o1, o2 ->
+            var s1 = o1+o2
+            var s2 = o2+o1
+            s2.compareTo(s1)
+        }
+        return nums.map  { it.toString() } .sortedWith(strCompare).joinToString(separator = "")
+
+    }
+}

solutions/src/LowestCommonAncestorOfBinaryTree.kt

@@ -0,0 +1,35 @@
+/**
+ * https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/
+ */
+class LowestCommonAncestorOfBinaryTree {
+    fun lowestCommonAncestor(root: TreeNode?, p: TreeNode? , q: TreeNode?) : TreeNode? {
+        return findAncestor(root!!,p!!.`val`,q!!.`val`)
+    }
+
+    private fun findAncestor(node: TreeNode, t1: Int, t2: Int) : TreeNode {
+        val t1ExistsLeft = binarySearch(node.left,t1)
+        val t2ExistsLeft = binarySearch(node.left,t2)
+        val t1ExistsRight = binarySearch(node.right,t1)
+        val t2ExistsRight = binarySearch(node.right,t2)
+        if (t1ExistsLeft && t2ExistsLeft) {
+            return findAncestor(node.left!!,t1,t2)
+        }
+        else if (t2ExistsRight && t1ExistsRight) {
+            return findAncestor(node.right!!,t1,t2)
+        }
+        else {
+            return node
+        }
+    }
+    private fun binarySearch(node: TreeNode?, target: Int) : Boolean {
+        if (node == null) {
+            return false
+        }
+        if (node.`val` == target) {
+            return true
+        }
+        else {
+            return binarySearch(node.left,target) || binarySearch(node.right,target)
+        }
+    }
+}

solutions/src/Power.kt

@@ -0,0 +1,12 @@
+/**
+ * https://leetcode.com/problems/powx-n/
+ */
+class Power {
+    fun myPow(x: Double, n: Int): Double {
+        if (n == 0) return 1.0
+        if (n < 0) {
+            return 1 / x * myPow(1 / x, -(n + 1))
+        }
+        return if (n % 2 == 0) myPow(x * x, n / 2) else x * myPow(x * x, n / 2)
+    }
+}

solutions/src/SparseArrays.kt

@@ -0,0 +1,11 @@
+/**
+ * https://www.hackerrank.com/challenges/sparse-arrays/problem
+ */
+class SparseArrays {
+    fun matchingStrings(strings: Array<String>, queries: Array<String>): Array<Int> {
+        val stringsByOccurance = strings.groupingBy { it }.eachCount()
+        return queries.map { stringsByOccurance[it] ?: 0 }.toTypedArray()
+
+    }
+
+}

solutions/src/SumRootToLeafNumbers.kt

@@ -0,0 +1,34 @@
+/**
+ * https://leetcode.com/problems/sum-root-to-leaf-numbers/
+ */
+class SumRootToLeafNumbers {
+    fun sumNumbers(root: TreeNode?) : Int {
+        if (root == null) {
+            return 0
+        }
+        val queue= mutableListOf(QueueItem(root,root.`val`.toString()))
+        val finishedStrings = mutableListOf<String>()
+        while (queue.isNotEmpty()) {
+            val current = queue.removeAt(0)
+            val currentNode = current.node
+            val currentStr = current.str
+            if (currentNode.left == null && currentNode.right == null) {
+                finishedStrings.add(currentStr)
+            }
+            else {
+                val toQueue = mutableListOf<QueueItem>()
+                if (currentNode.left != null) {
+                    toQueue.add(QueueItem(currentNode.left!!,currentStr+currentNode.left!!.`val`))
+                }
+                if (currentNode.right != null) {
+                    toQueue.add(QueueItem(currentNode.right!!,currentStr+currentNode.right!!.`val`))
+                }
+                queue.addAll(toQueue)
+            }
+
+        }
+        return finishedStrings.map { it.toInt() }.sum()
+    }
+
+    private class QueueItem(val node: TreeNode, val str: String)
+}

solutions/src/TestBed.kt

@@ -1,14 +1,16 @@
+import kotlin.time.ExperimentalTime
 import kotlin.time.measureTime
 
 
+@ExperimentalTime
 fun main(args: Array<String>) {
     println(measureTime {
-        val tester =  OutOfBoundsPaths()
+        val tester = CourseScheduleTwo()
         val results = listOf(
-                tester.findPaths(1,3,3,0,1)
+                tester.findOrder(2, arrayOf(intArrayOf(1,0)))
 
         )
-        println(results.map { it })
+        println(results.map { it.toList() })
     })
 
 }