minor fixes

Author: Morfly

src/kotlin/_util/CollectionUtils.kt

@@ -1,16 +1,15 @@
 package _util
 
-import sequential.shuffling.fisheryates.fisherYatesShuffle
 import kotlin.random.Random
 
 
 private const val MAX_LIST_VALUE = 999
 private const val LIST_SIZE = 50
 
-fun randomList(size: Int = LIST_SIZE, range: IntRange = 0..MAX_LIST_VALUE) = 
-    List(size) { 
-        Random.nextInt(range.first, range.last + 1) 
+fun randomList(size: Int = LIST_SIZE, range: IntRange = 0..MAX_LIST_VALUE) =
+    List(size) {
+        Random.nextInt(range.first, range.last + 1)
     }
 
-fun <T: Comparable<T>> Collection<T>.isSorted(): Boolean =
+fun <T : Comparable<T>> Collection<T>.isSorted(): Boolean =
     asSequence().zipWithNext { a, b -> a <= b }.all { it }

src/kotlin/_util/IntArrayUtils.kt

@@ -7,9 +7,9 @@ import kotlin.random.Random
 private const val MAX_ARRAY_VALUE = 999
 private const val ARRAY_SIZE = 50
 
-fun randomIntArray(size: Int = ARRAY_SIZE, range: IntRange = 0..MAX_ARRAY_VALUE) = 
-    IntArray(size) { 
-        Random.nextInt(range.first, range.last + 1) 
+fun randomIntArray(size: Int = ARRAY_SIZE, range: IntRange = 0..MAX_ARRAY_VALUE) =
+    IntArray(size) {
+        Random.nextInt(range.first, range.last + 1)
     }
 
 fun IntArray.shuffle() {

src/kotlin/sequential/graph/bfs/BreadthFirstTraversal.kt

@@ -11,17 +11,15 @@ private typealias Queue<T> = ArrayDeque<T>
 fun <T> Graph<T>.bfs(root: T): Collection<T> {
     val graph = this
 
-    val explored = mutableSetOf<T>()
+    val explored = linkedSetOf<T>()
     val searchQueue = Queue<T>()
 
-    searchQueue.addLast(root)
+    searchQueue += root
     while (searchQueue.isNotEmpty()) {
         val node = searchQueue.removeFirst()
-        explored.add(node)
-
-        val successors = graph[node].orEmpty()
-        for (succ in successors) {
-            if (succ !in explored) searchQueue.addLast(succ)
+        if (node !in explored) {
+            explored += node
+            searchQueue += graph[node].orEmpty()
         }
     }
 
@@ -30,5 +28,14 @@ fun <T> Graph<T>.bfs(root: T): Collection<T> {
 
 
 fun main() {
-    // TODO
+    val socialNetwork: Graph<String> = mapOf(
+        "you" to listOf("tony", "steve", "nick"),
+        "tony" to listOf("clint"),
+        "nick" to listOf("thor", "natasha"),
+        "steve" to listOf("phil", "clint")
+    )
+
+    println(
+        socialNetwork.bfs("you")
+    )
 }

src/kotlin/sequential/graph/dfs/IterativeDepthFirstTraversal.kt

@@ -8,20 +8,18 @@ private typealias Graph<T> = Map<T, List<T>>
 private typealias Stack<T> = ArrayDeque<T>
 
 
-fun <T> Graph<T>.iterativeDfs(root: T): Collection<T> {
+fun <T> Graph<T>.dfs(root: T): Collection<T> {
     val graph = this
 
     val explored = mutableSetOf<T>()
-    val stack = Stack<T>()
-
-    stack.addLast(root)
-    while (stack.isNotEmpty()) {
-        val node = stack.removeLast()
-        explored.add(node)
-
-        val successors = graph[node].orEmpty()
-        for (succ in successors) {
-            if (succ !in explored) stack.addLast(succ)
+    val searchStack = Stack<T>()
+
+    searchStack.addLast(root)
+    while (searchStack.isNotEmpty()) {
+        val node = searchStack.removeLast()
+        if (node !in explored) {
+            explored += node
+            searchStack += graph[node].orEmpty()
         }
     }
 

src/kotlin/sequential/graph/dijkstra/Dijkstra.kt

@@ -19,33 +19,41 @@ private val INFINITY = Double.POSITIVE_INFINITY
 fun <T> Graph<T>.dijkstra(root: T, target: T): Collection<T> {
     val graph = this
 
-    val costs = graph.getValue(root).toMutableMap()
+    val costs = graph[root].orEmpty().toMutableMap()
     val explored = mutableSetOf<T>()
-    val parents = graph.getValue(root).mapValues { root }.toMutableMap()
+    val parents = graph[root].orEmpty().mapValues { root }.toMutableMap()
 
-    var node = costs.smallestCostNode(explored)
+    var node = costs.minCostNode(explored)
     while (node != null) {
         val nodeCost = costs[node]!!
-        val successors = graph[node].orEmpty()
 
+        val successors = graph[node].orEmpty()
         for ((succ, edgeWeight) in successors) {
             if (nodeCost + edgeWeight < costs[succ] ?: INFINITY) {
                 costs[succ] = nodeCost + edgeWeight
                 parents[succ] = node
             }
         }
-
-        explored.add(node)
-        node = costs.smallestCostNode(explored)
+        explored += node
+        node = costs.minCostNode(explored)
     }
 
     return pathToNode(target, parents)
 }
 
-private fun <T> Map<T, Double>.smallestCostNode(explored: Collection<T>): T? = asSequence()
-        .filter { (node, _) -> node !in explored }
-        .minBy { (_, cost) -> cost }
-        ?.key
+private fun <T> Map<T, Double>.minCostNode(explored: Collection<T>): T? {
+    val costs = this
+
+    var minCostNode: T? = null
+    var minCost = INFINITY
+    for ((node, cost) in costs) {
+        if (node !in explored && cost < minCost) {
+            minCostNode = node
+            minCost = cost
+        }
+    }
+    return minCostNode
+}
 
 /**
  * Build path from root to target node.
@@ -56,23 +64,22 @@ private fun <T> pathToNode(target: T, parents: Map<T, T>): List<T> {
     val path = mutableListOf<T>()
     var node: T? = target
     while (node != null) {
-        path.add(node)
+        path += node
         node = parents[node]
     }
     return path.reversed()
 }
 
 
 fun main() {
-
     val waypoints: Graph<String> = mapOf(
-            "Start" to mapOf("A" to 5.0),
-            "A" to mapOf("B" to 4.0, "C" to 7.0),
-            "B" to mapOf("Finish" to 4.0),
-            "C" to mapOf("Finish" to 3.0)
+        "Start" to mapOf("A" to 5.0),
+        "A" to mapOf("B" to 7.0, "C" to 4.0),
+        "B" to mapOf("Finish" to 4.0),
+        "C" to mapOf("Finish" to 3.0)
     )
 
     println(
-            waypoints.dijkstra("Start", "Finish")
+        waypoints.dijkstra("Start", "Finish")
     )
 }

src/python/sequential/graph/bfs/breadth_first_traversal.py

@@ -28,9 +28,7 @@ def main():
         "bob": ["anuj", "peggy"],
     }
 
-    print(
-        bfs(graph, "you")
-    )
+    print(bfs(graph, "you"))
 
 if __name__ == "__main__":
     main()