resolved dependencies

Author: Morfly

src/kotlin/BUILD

@@ -1,4 +1,4 @@
-load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "define_kt_toolchain")
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "define_kt_toolchain", "kt_jvm_library")
 
 JVM_VERSION = "1.6"
 
@@ -10,3 +10,13 @@ define_kt_toolchain(
     jvm_target = JVM_VERSION,
     language_version = KOTLIN_VERSION,
 )
+
+kt_jvm_library(
+    name = "utils",
+    srcs = [
+        "_util/Utils.kt",
+        "//sequential/shuffling/fisheryates:FisherYatesShuffle.kt",
+
+    ],
+    visibility = ["//:__subpackages__"]
+)

src/kotlin/_util/BUILD

@@ -0,0 +1,12 @@
+package _util
+
+import sequential.shuffling.fisheryates.fisherYatesShuffle
+
+
+fun IntArray.shuffle() {
+    fisherYatesShuffle()
+}
+
+fun IntArray.swap(i: Int, j: Int) {
+    this[i] = this[j].also { this[j] = this[i] }
+}

src/kotlin/_util/Stub.kt

@@ -1,5 +1,6 @@
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
+
 rules_kotlin_version = "legacy-1.3.0"
 rules_kotlin_sha = "4fd769fb0db5d3c6240df8a9500515775101964eebdf85a3f9f0511130885fde"
 

src/kotlin/_util/Utils.kt

@@ -0,0 +1,18 @@
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library", "kt_jvm_binary")
+
+exports_files(
+    ["FisherYatesShuffle.kt"],
+    visibility = ["//:__pkg__"]
+)
+
+kt_jvm_library(
+    name = "fisheryates_shuffle_lib",
+    srcs = ["FisherYatesShuffle.kt"],
+    deps = ["//:utils"],
+)
+
+java_binary(
+    name = "fisheryates_shuffle",
+    main_class = "sequential.shuffling.fisheryates.FisherYatesShuffleKt",
+    runtime_deps = [":fisheryates_shuffle_lib"],
+)

src/kotlin/kotlin.bzl

@@ -0,0 +1,17 @@
+package sequential.shuffling.fisheryates
+
+import _util.swap
+import kotlin.random.Random
+
+
+fun IntArray.fisherYatesShuffle() {
+    for (i in lastIndex downTo 1) {
+        val j = Random.nextInt(i + 1)
+        swap(i, j)
+    }
+}
+
+
+fun main() {
+    println("FisherYatesShuffle")
+}

src/kotlin/sequential/shuffling/fisheryates/BUILD

@@ -0,0 +1,2 @@
+# Fisher Yates Modern Shuffling
+...

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

@@ -0,0 +1,8 @@
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_binary")
+
+kt_jvm_binary(
+    name = "sattolo_shuffle",
+    srcs = ["SattoloShuffle.kt"],
+    main_class = "sequential.shuffling.sattolo.SattoloShuffleKt",
+    deps = ["//_util:utils"],
+)

src/kotlin/sequential/shuffling/fisheryates/README.md

@@ -0,0 +1,17 @@
+package sequential.shuffling.sattolo
+
+import sequential.sorting._util.swap
+import kotlin.random.Random
+
+
+fun IntArray.sattoloShuffle() {
+    for (i in lastIndex downTo 1) {
+        val j = Random.nextInt(i)
+        swap(i, j)
+    }
+}
+
+
+fun main() {
+    println("SattoloShuffle")
+}

src/kotlin/sequential/shuffling/sattolo/BUILD

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

src/kotlin/sequential/sorting/_utils/SortUtils.kt renamed to src/kotlin/sequential/shuffling/sattolo/README.md

@@ -0,0 +1,3 @@
+package sequential.sorting._analysis
+
+typealias PartitioningFunction = IntArray.(start: Int, end: Int) -> Int

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

@@ -0,0 +1,6 @@
+package sequential.sorting._utils
+
+
+fun IntArray.exch(i: Int, j: Int) {
+    this[i] = this[j].also { this[j] = this[i] }
+}

src/kotlin/sequential/sorting/_analysis/BUILD

@@ -0,0 +1,23 @@
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
+
+kt_jvm_library(
+    name = "insertion_sort_lib",
+    srcs = [
+        "InsertionSort.kt",
+        "ranged/InsertionSort.kt",
+    ],
+    deps = ["//sequential/sorting/_analysis:sort_analysis"],
+    visibility = ["//visibility:public"],
+)
+
+java_binary(
+    name = "insertion_sort",
+    main_class = "sequential.sorting.insertionsort.InsertionSortKt",
+    runtime_deps = [":insertion_sort_lib"],
+)
+
+java_binary(
+    name = "insertion_sort_ranged",
+    main_class = "sequential.sorting.insertionsort.ranged.InsertionSortKt",
+    runtime_deps = [":insertion_sort_lib"],
+)

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

@@ -0,0 +1,33 @@
+package sequential.sorting.insertionsort
+
+import sequential.sorting._utils.exch
+
+
+fun IntArray.insertionSort() {
+
+    // Setting sentinel
+    var exchanges = 0
+    for (i in lastIndex downTo 1) {
+        if (this[i] < this[i - 1]) {
+            exch(i, i - 1)
+            exchanges++
+        }
+    }
+    if (exchanges == 0) return
+
+    // Actual insertion sort
+    for (i in 2..lastIndex) {
+        var j = i
+        val arri = this[i]
+        while (arri < this[j - 1]) {
+            this[j] = this[j - 1]
+            j--
+        }
+        this[j] = arri
+    }
+}
+
+
+fun main() {
+    println("InsertionSort")
+}

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

@@ -0,0 +1,34 @@
+package sequential.sorting.insertionsort.ranged
+
+import sequential.sorting._utils.exch
+
+
+fun IntArray.insertionSort(start: Int, end: Int) {
+    if (end - start < 1) return
+
+    // Setting sentinel
+    var exchanges = 0
+    for (i in end - 1 downTo start + 1) {
+        if (this[i] < this[i - 1]) {
+            exch(i, i - 1)
+            exchanges++
+        }
+    }
+    if (exchanges == 0) return
+
+    // Actual insertion sort
+    for (i in (start + 2) until end) {
+        var j = i
+        val arri = this[i]
+        while (arri < this[j - 1]) {
+            this[j] = this[j - 1]
+            j--
+        }
+        this[j] = arri
+    }
+}
+
+
+fun main() {
+    
+}

src/kotlin/sequential/sorting/insertionsort/BUILD

@@ -1,8 +1,17 @@
-load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_binary")
+load("@io_bazel_rules_kotlin//kotlin:kotlin.bzl", "kt_jvm_library")
 
-kt_jvm_binary(
+kt_jvm_library(
+    name = "quicksort_lib",
+    srcs = ["QuickSort.kt"] + glob(["partition/*.kt"]),
+    deps = [
+        "//sequential/sorting/insertionsort:insertion_sort_lib",
+        "//sequential/sorting/_analysis:sort_analysis",
+        "//:utils"
+    ]
+)
+
+java_binary(
     name = "quicksort",
-    srcs = ["QuickSort.kt"],
     main_class = "sequential.sorting.quicksort.QuickSortKt",
-    deps = ["//_util:utils"],
+    runtime_deps = [":quicksort_lib"],
 )

src/kotlin/sequential/sorting/insertionsort/InsertionSort.kt

@@ -1,13 +1,57 @@
 package sequential.sorting.quicksort
 
-import _util.testFun
+import sequential.sorting.insertionsort.ranged.insertionSort
+import sequential.sorting.quicksort.partition.lomutoPartition
+import sequential.sorting.quicksort.partition.hoarePartition
+import _util.shuffle
 
 
+/**
+ * Minimum threshold for which quick sort algorithm will be applied. Otherwise, insertion sort will be used.
+ */
+private const val INSERTION_SORT_THRESHOLD = 47
+
+
+/**
+ * In-place quick sort for the given array.
+ */
 fun IntArray.quickSort() {
-    // TODO
+    shuffle()
+    quickSort(0, size)
 }
 
+/**
+ * In-place quick sort for the given range.
+ *
+ * It is possible to partition an array by the following algorithms:
+ * [hoarePartition], [lomutoPartition].
+ *
+ * @param start start of the sorting range inclusive.
+ * @param end end of the sorting range exclusive.
+ */
+private fun IntArray.quickSort(start: Int, end: Int) {
+    if (end - start < 2) return
+
+    if (end - start <= INSERTION_SORT_THRESHOLD) {
+        insertionSort(start, end)
+        return
+    }
+
+    val pivot = partition(start, end)
+    quickSort(start, pivot)
+    quickSort(pivot + 1, end)
+}
+
+
+/**
+ * Currently selected partitioning algorithm which is used in [quickSort].
+ * Can be [lomutoPartition] or [hoarePartition].
+ */
+var partition: PartitioningFunction = IntArray::hoarePartition
+
+typealias PartitioningFunction = IntArray.(start: Int, end: Int) -> Int
+
 
 fun main() {
-    println("Hey main + ${testFun()}")
+    println("QuickSort")
 }

src/kotlin/sequential/sorting/insertionsort/README.md

@@ -0,0 +1,28 @@
+package sequential.sorting.quicksort.partition
+
+import sequential.sorting._utils.exch
+
+
+/**
+ * Partitioning algorithm for quick sort introduced by Tony Hoare.
+ */
+fun IntArray.hoarePartition(start: Int, end: Int): Int {
+    val pivotPosition = (start + end - 1) / 2
+    exch(pivotPosition, start)
+
+    val pivot = this[start]
+    var i = start
+    var j = end
+    while (true) {
+        do i++
+        while (i < end && this[i] < pivot)
+
+        do j--
+        while (this[j] > pivot)
+
+        if (i >= j) break
+        exch(i, j)
+    }
+    exch(start, j)
+    return j
+}

src/kotlin/sequential/sorting/insertionsort/ranged/InsertionSort.kt

@@ -0,0 +1,19 @@
+package sequential.sorting.quicksort.partition
+
+import sequential.sorting._utils.exch
+
+
+/**
+ * Partitioning algorithm for quick sort introduced by Nico Lomuto.
+ */
+fun IntArray.lomutoPartition(start: Int, end: Int): Int {
+    val pivot = this[end - 1]
+    var i = start
+    for (j in start until end) {
+        if (this[j] < pivot) {
+            exch(i++, j)
+        }
+    }
+    exch(i, end - 1)
+    return i
+}