Merge branch 'main' into directory_writer

Author: uncomfyhalomacro

src/searches/binary_search.jl

@@ -67,15 +67,14 @@ function binary_search(
 ) where {T<:Real}
     if (r >= l)
         mid = Int(ceil(l + (r - l) / 2))
-        # println(mid)
         if (arr[mid] == x)
-            return "Element present at index $mid"
+            return mid
         elseif (arr[mid] > x)
             binary_search(arr, l, mid - 1, x)
         else
             binary_search(arr, mid + 1, r, x)
         end
     else
-        return "Element not present in array"
+        return -1
     end
 end

src/searches/exponential_search.jl

@@ -19,7 +19,7 @@ Contributed By:- [Ash](https://github.com/ashwani-rathee)
 function exponential_search(arr::AbstractArray{T,1}, x::T) where {T<:Real}
     n = size(arr)[1]
     if (arr[1] == x)
-        return "Element present at index 1"
+        return 1
     end
 
     i = 1

src/searches/interpolation_search.jl

@@ -46,13 +46,13 @@ function interpolation_search(
     if (r >= l && x >= arr[l] && x <= arr[r])
         mid = Int(ceil(l + (((x - arr[l]) * (r - l)) / (arr[r] - arr[l]))))
         if (arr[mid] == x)
-            return "Element present at index $mid"
+            return mid
         elseif (arr[mid] > x)
             interpolation_search(arr, l, mid - 1, x)
         else
             interpolation_search(arr, mid + 1, r, x)
         end
     else
-        return "Element not present in array"
+        return -1
     end
 end

src/sorts/heap_sort.jl

@@ -28,6 +28,9 @@ After the largest element has been extracted, the tree is updated to maintain th
   Contributed By:- [Frank Schmitt](https://github.com/frankschmitt)
 """
 function heap_sort!(arr::Vector{T}, gt = >, N::Int = length(arr)) where {T}
+    if isempty(arr)
+        return
+    end 
     n = N
     i = div(n, 2)
     t = -1

test/cipher.jl

@@ -10,10 +10,15 @@ using TheAlgorithms.Cipher
     end
 
     @testset "Cipher: caesar" begin
-        input = "stealth"
-        @test caesar(0, input) == "stealth"
-        input = "ghsozhv"
-        @test caesar(90, input) == "stealth"
+        @test caesar(0, "stealth") == "stealth"
+        @test caesar(90, "ghsozhv") == "stealth"
+
+        @test caesar(1, "ABC") == "BCD"
+        @test caesar(-1, "BCD") == "ABC"
+
+        @test caesar(2, "f(x)") == "h(z)"
+
+        @test caesar(5, 'a') == 'f'
 
         # rot = 13
         # s = "abcdefghijklmnopqrstuvwxyz"

test/math.jl

@@ -4,8 +4,8 @@ using TheAlgorithms.Math
         @test abs_val(-100) == 100
         @test abs_val(0) == 0
         @test abs(123.1) == 123.1
-        @test (-1000 == abs_val(-1000)) == false
-        @test (1000 == abs_val(1000)) == true
+        @test abs_val(-1000) == 1000
+        @test abs_val(1000) == 1000
 
         @test abs_max([1, 3, 4]) == 4
         @test abs_max([-3, 1, 2]) == -3

test/searches.jl

@@ -16,45 +16,58 @@ using TheAlgorithms.Searches
             # Second method used for exponential search
             arr = [1, 2, 3, 4, 13, 15, 20]
             # The next three values used are the result of the while-loop inside `exponential search`
-            @test binary_search(arr, 4, 7, 4) == "Element present at index 4"
-            @test binary_search(arr, 4, 7, 10) == "Element not present in array"
+            @test binary_search(arr, 4, 7, 4) == 4
+            @test binary_search(arr, 4, 7, 20) == 7
+            @test binary_search(arr, 4, 7, 10) == -1
+            @test binary_search(arr, 4, 7, 21) == -1
         end
     end
 
     @testset "Searches: Linear" begin
-        array = [1, 3, 4, 7, 8, 11]
-        linear_search(array, 3)
-        linear_search(array, 8)
-        linear_search(array, 12)
+        array = [1, 30, 4, 70, 8, 11]
+        @test linear_search(array, 1) == 1
+        @test linear_search(array, 30) == 2
+        @test linear_search(array, 8) == 5
+        @test linear_search(array, 11) == 6
+        @test linear_search(array, 12) == -1
+        @test linear_search(array, 10) == -1
+        @test linear_search(array, 0) == -1
     end
 
     @testset "Searches: Exponential" begin
         arr = [1, 2, 3, 4, 13, 15, 20]
-        x = 4
-        n = size(arr)[1]
-        l = 1
-        r = n
-        @test exponential_search(arr, 1) == "Element present at index 1"
-        @test exponential_search(arr, x) == "Element present at index 4"
-        @test exponential_search(arr, 100) == "Element not present in array"
+        @test exponential_search(arr, 1) == 1
+        @test exponential_search(arr, 4) == 4
+        @test exponential_search(arr, 20) == 7
+        @test exponential_search(arr, 5) == -1
+        @test exponential_search(arr, 100) == -1
     end
 
     @testset "Searches: Interpolation" begin
         arr = [1, 2, 3, 4, 13, 15, 20]
-        x = 15
-        n = size(arr)[1]
         l = 1
-        r = n
+        r = size(arr)[1]
 
-        interpolation_search(arr, l, r, x)
+        @test interpolation_search(arr, l, r, 1) == 1
+        @test interpolation_search(arr, l, r, 2) == 2
+        @test interpolation_search(arr, l, r, 3) == 3
+        @test interpolation_search(arr, l, r, 4) == 4
+        @test interpolation_search(arr, l, r, 13) == 5
+        @test interpolation_search(arr, l, r, 15) == 6
+        @test interpolation_search(arr, l, r, 20) == 7
+        @test interpolation_search(arr, l, r, 5) == -1
+        @test interpolation_search(arr, l, r, 14) == -1
+        @test interpolation_search(arr, l, r, 19) == -1
+        @test interpolation_search(arr, l, r, 0) == -1
+        @test interpolation_search(arr, l, r, 1000) == -1
     end
 
     @testset "Searches: Jump" begin
-        arr = [1, 2, 3, 31, 4, 13]
-        x = 31
-        jump = 2 # optimum is sqroot(n)
-        n = size(arr)[1]
-
-        jump_search(arr, x, jump)
+        arr = [1, 2, 3, 4, 13, 31]
+        @test jump_search(arr, 31, 1) == 6
+        @test jump_search(arr, 13, 3) == 5
+        @test jump_search(arr, 3, 5) == 3
+        @test jump_search(arr, 1, 3) == 1
+        @test jump_search(arr, 10000, 3) == -1
     end
 end

test/sorts.jl

@@ -1,22 +1,41 @@
 using TheAlgorithms.Sorts
 
 @testset "Sorts" begin
-    sorts = [
-        bogo_sort!
-        bubble_sort!
-        bucket_sort!
-        counting_sort!
-        exchange_sort!
-        heap_sort!
-        insertion_sort!
-        merge_sort!
-        quick_sort!
-        selection_sort!
-    ]
+    @testset "bogo_sort" begin        
+        x = [3, 1, 4, 2]
+        bogo_sort!(x)
+        @test x == [1, 2, 3, 4]
+    end
+
+    @testset "deterministic sorts" begin
+        sorts = [
+            bubble_sort!
+            bucket_sort!
+            counting_sort!
+            exchange_sort!
+            heap_sort!
+            insertion_sort!
+            merge_sort!
+            quick_sort!
+            selection_sort!
+        ]
+
+        for f in sorts
+            x = [3, 5, 1, 4, 2]
+            f(x)
+            @test x == [1, 2, 3, 4, 5]
+
+            y = [5, 2, 2, 2, 1, 5, 2, 34, 6, 4, 3, 2, 1, 2, 3, 4, 10, 1]
+            f(y)
+            @test y == [1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 4, 4, 5, 5, 6, 10, 34]
+
+            z = []
+            f(z)
+            @test z == []
 
-    for f in sorts
-        x = [3, 5, 1, 4, 2]
-        f(x)
-        @test x == [1, 2, 3, 4, 5]
+            s = [1]
+            f(s)
+            @test s == [1]
+        end
     end
 end