improved build structure

Author: Morfly

src/kotlin/BUILD

@@ -14,9 +14,9 @@ define_kt_toolchain(
 kt_jvm_library(
     name = "utils",
     srcs = [
-        "_util/Utils.kt",
+        "_util/IntArrayUtils.kt",
+        "_util/CollectionUtils.kt",
         "//sequential/shuffling/fisheryates:FisherYatesShuffle.kt",
-
     ],
     visibility = ["//:__subpackages__"]
 )

src/kotlin/_util/CollectionUtils.kt

@@ -0,0 +1,16 @@
+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 <T: Comparable<T>> Collection<T>.isSorted(): Boolean =
+    asSequence().zipWithNext { a, b -> a <= b }.all { it }

src/kotlin/_util/IntArrayUtils.kt

@@ -0,0 +1,31 @@
+package _util
+
+import sequential.shuffling.fisheryates.fisherYatesShuffle
+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 IntArray.shuffle() {
+    fisherYatesShuffle()
+}
+
+fun IntArray.exch(i: Int, j: Int) {
+    this[i] = this[j].also { this[j] = this[i] }
+}
+
+fun IntArray.isSorted(): Boolean {
+    for (i in 1..lastIndex)
+        if (this[i] < this[i - 1]) return false
+    return true
+}
+
+fun IntArray.print() {
+    println(contentToString())
+}

src/kotlin/_util/Utils.kt

@@ -0,0 +1,57 @@
+package sequential.graph
+
+
+/**
+ * Graph representation using hash table.
+ * Properties: unweighted, directed.
+ */
+private typealias GraphMap<T> = Map<T, List<T>>
+
+val socialNetwork: GraphMap<String> = mapOf(
+    "you" to listOf("tony", "steve", "nick"),
+    "tony" to listOf("clint"),
+    "steve" to listOf("phil", "clint"),
+    "nick" to listOf("thor", "natasha")
+)
+
+
+/**
+ * Graph representation using hash table.
+ * Properties: weighted, directed.
+ */
+private typealias WeightedGraphMap<T> = Map<T, Map<T, Int>>
+
+val waypoints: WeightedGraphMap<String> = mapOf(
+    "Start" to mapOf("A" to 5),
+    "A" to mapOf("B" to 4, "C" to 7),
+    "B" to mapOf("Finish" to 4),
+    "C" to mapOf("Finish" to 3)
+)
+
+
+/**
+ * Graph representation using boolean adjacency matrix.
+ * Properties: unweighted, directed/undirected. (If matrix is symmetric - undirected, otherwise - directed).
+ */
+private typealias GraphAdjMatrix = Array<BooleanArray>
+
+val graphAdjMatrix: GraphAdjMatrix = arrayOf(
+    booleanArrayOf(true, false, false, false),
+    booleanArrayOf(false, true, false, false),
+    booleanArrayOf(false, true, true, false),
+    booleanArrayOf(false, true, false, true)
+)
+
+
+/**
+ * Graph representation using int adjacency matrix.
+ * Properties: weighted, directed/undirected. (If matrix is symmetric - undirected, otherwise - directed).
+ */
+private typealias WeightedGraphAdjMatrix = Array<IntArray>
+
+val weightedGraphAdjMatrix: WeightedGraphAdjMatrix = arrayOf(
+    intArrayOf(0, 0, 1, 5),
+    intArrayOf(0, 1, 0, 0),
+    intArrayOf(0, 0, 1, 5),
+    intArrayOf(0, 0, 1, 5)
+)

src/kotlin/sequential/graph/Graph.kt

@@ -0,0 +1,33 @@
+package sequential.graph.bfs
+
+import kotlin.collections.ArrayDeque
+
+
+private typealias Graph<T> = Map<T, List<T>>
+
+private typealias Queue<T> = ArrayDeque<T>
+
+
+fun <T> Graph<T>.bfs(root: T): Collection<T> {
+    val graph = this
+
+    val explored = mutableSetOf<T>()
+    val searchQueue = Queue<T>(listOf(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)
+        }
+    }
+    
+    return explored
+}
+
+
+fun main() {
+    // TODO
+}

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

@@ -1,17 +1,24 @@
 package sequential.shuffling.fisheryates
 
-import _util.swap
+import _util.*
 import kotlin.random.Random
 
 
 fun IntArray.fisherYatesShuffle() {
     for (i in lastIndex downTo 1) {
         val j = Random.nextInt(i + 1)
-        swap(i, j)
+        exch(i, j)
     }
 }
 
 
 fun main() {
-    println("FisherYatesShuffle")
+    val array = randomIntArray(20)
+    array.sort()
+    array.print()
+
+    array.fisherYatesShuffle()
+
+    println("Shuffling is successful: ${!array.isSorted()}")
+    array.print()
 }

src/kotlin/sequential/graph/dfs/DepthFirstTraversal.kt renamed to src/kotlin/sequential/graph/dfs/iterative/DepthFirstTraversal.kt

@@ -4,5 +4,5 @@ kt_jvm_binary(
     name = "sattolo_shuffle",
     srcs = ["SattoloShuffle.kt"],
     main_class = "sequential.shuffling.sattolo.SattoloShuffleKt",
-    deps = ["//_util:utils"],
+    deps = ["//:utils"],
 )

src/kotlin/sequential/shuffling/fisheryates/FisherYatesShuffle.kt

@@ -1,17 +1,24 @@
 package sequential.shuffling.sattolo
 
-import sequential.sorting._util.swap
+import _util.*
 import kotlin.random.Random
 
 
 fun IntArray.sattoloShuffle() {
     for (i in lastIndex downTo 1) {
         val j = Random.nextInt(i)
-        swap(i, j)
+        exch(i, j)
     }
 }
 
 
 fun main() {
-    println("SattoloShuffle")
+    val array = randomIntArray(20)
+    array.sort()
+    array.print()
+
+    array.sattoloShuffle()
+
+    println("Shuffling is successful: ${!array.isSorted()}")
+    array.print()
 }

src/kotlin/sequential/shuffling/sattolo/BUILD

@@ -3,6 +3,6 @@ load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
 package(default_visibility = ["//sequential/sorting:__subpackages__"])
 
 kt_jvm_library(
-    name = "sort_analysis",
+    name = "_measurement",
     srcs = glob(["*.kt"]),
 )

src/kotlin/sequential/shuffling/sattolo/SattoloShuffle.kt

@@ -0,0 +1,8 @@
+package sequential.sorting._measurement
+
+
+interface MeasuredElements<T> {
+
+}
+
+

src/kotlin/sequential/sorting/_analysis/PartitioningFunction.kt

@@ -4,9 +4,12 @@ kt_jvm_library(
     name = "insertion_sort_lib",
     srcs = [
         "InsertionSort.kt",
-        "ranged/InsertionSort.kt",
+        "RangedInsertionSort.kt",
+    ],
+    deps = [
+        "//sequential/sorting/_measurement",
+        "//:utils",
     ],
-    deps = ["//sequential/sorting/_analysis:sort_analysis"],
     visibility = ["//visibility:public"],
 )
 
@@ -18,6 +21,6 @@ java_binary(
 
 java_binary(
     name = "insertion_sort_ranged",
-    main_class = "sequential.sorting.insertionsort.ranged.InsertionSortKt",
+    main_class = "sequential.sorting.insertionsort.RangedInsertionSortKt",
     runtime_deps = [":insertion_sort_lib"],
 )

src/kotlin/sequential/sorting/_analysis/SortAnalysis.kt

@@ -1,6 +1,6 @@
 package sequential.sorting.insertionsort
 
-import sequential.sorting._utils.exch
+import _util.*
 
 
 fun IntArray.insertionSort() {
@@ -29,5 +29,11 @@ fun IntArray.insertionSort() {
 
 
 fun main() {
-    println("InsertionSort")
+    val array = randomIntArray(size = 20)
+    array.print()
+
+    array.insertionSort()
+
+    println("Sorting is successful: ${array.isSorted()}")
+    array.print()
 }

src/kotlin/sequential/sorting/_analysis/BUILD renamed to src/kotlin/sequential/sorting/_measurement/BUILD

@@ -1,6 +1,6 @@
-package sequential.sorting.insertionsort.ranged
+package sequential.sorting.insertionsort
 
-import sequential.sorting._utils.exch
+import _util.*
 
 
 fun IntArray.insertionSort(start: Int, end: Int) {
@@ -30,5 +30,11 @@ fun IntArray.insertionSort(start: Int, end: Int) {
 
 
 fun main() {
-    
+    val array = randomIntArray(size = 20)
+    array.print()
+
+    array.insertionSort(0, array.size)
+
+    println("Sorting is successful: ${array.isSorted()}")
+    array.print()
 }

src/kotlin/sequential/sorting/_measurement/MeasuredElements.kt

@@ -2,10 +2,13 @@ load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
 
 kt_jvm_library(
     name = "quicksort_lib",
-    srcs = ["QuickSort.kt"] + glob(["partition/*.kt"]),
+    srcs = [
+        "QuickSort.kt",
+        "FunctionalQuickSort.kt",
+    ] + glob(["partition/*.kt"]),
     deps = [
         "//sequential/sorting/insertionsort:insertion_sort_lib",
-        "//sequential/sorting/_analysis:sort_analysis",
+        "//sequential/sorting/_measurement",
         "//:utils"
     ]
 )
@@ -15,3 +18,9 @@ java_binary(
     main_class = "sequential.sorting.quicksort.QuickSortKt",
     runtime_deps = [":quicksort_lib"],
 )
+
+java_binary(
+    name = "quicksort_functional",
+    main_class = "sequential.sorting.quicksort.FunctionalQuickSortKt",
+    runtime_deps = [":quicksort_lib"],
+)

src/kotlin/sequential/sorting/insertionsort/BUILD

@@ -0,0 +1,22 @@
+package sequential.sorting.quicksort
+
+import _util.*
+
+
+fun <T : Comparable<T>> List<T>.quickSort(): List<T> = when {
+    size < 2 -> toList()
+    else -> {
+        val pivot = first()
+        val (smaller, greater) = drop(1).partition { it <= pivot }
+        smaller.quickSort() + pivot + greater.quickSort()
+    }
+}
+
+
+fun main() {
+    randomList(size = 20)
+        .also(::println)
+        .run { quickSort() }
+        .also { println("Sorting is successful: ${it.isSorted()}") }
+        .also(::println)
+}