Merge branch 'main' into directory_writer

uncomfyhalomacro · web-flow · commit 7712892bd891 · 2023-10-26T18:21:11.000+08:00
diff --git a/.gitpod.dockerfile b/.gitpod.dockerfile
@@ -1,4 +1,4 @@
-FROM gitpod/workspace-base:2023-10-04-18-52-46
+FROM gitpod/workspace-base:2023-10-19-14-24-02
 
 ENV JULIA_TMP="julia_tmp.tar.gz"
 
diff --git a/src/basic/difference_arr.jl b/src/basic/difference_arr.jl
@@ -11,9 +11,12 @@
     - print array after any numbers of changes                - O(N)
 
 # Functions
-    - create_diff_arr(original::Array{T}) - Create difference array for array 'original'
-    - calculate_arr(diff_arr::Array{T}) - Create a original array from the given difference array
-    - add_to_arr(diff_arr::Array{T}, l::Int, r::Int, x::Number) - Add x to all elements with index from [l, r]
+    - create_diff_arr(original::Array{<:Number})
+        * Create difference array for array 'original'
+    - calculate_arr(diff_arr::Array{<:Number})
+        * Recreate the original array from the given difference array
+    - add_to_arr(diff_arr::Array{<:Number}, l::Int, r::Int, x::Number)
+        * Add x to all elements with index from [l, r]
 
 
 # Contributed by: [Nikola Mircic](https://github.com/Nikola-Mircic)
@@ -25,7 +28,7 @@ module DifferenceArray
 function create_diff_arr(original::Array{T}) where {T<:Number}
     n = length(original)
 
-    diff_arr = Array(original)
+    diff_arr = copy(original)
 
     for i in 2:n
         diff_arr[i] = original[i] - original[i-1]
@@ -40,7 +43,7 @@ end
 function calculate_arr(diff_arr::Array{T}) where {T<:Number}
     n = length(diff_arr)
 
-    arr = Array(diff_arr)
+    arr = copy(diff_arr)
 
     for i in 2:n
         arr[i] = diff_arr[i] + arr[i-1]
@@ -51,7 +54,7 @@ end
 
 # Add x to all elements with index from [l, r]
 # Parameters:
-#   - dif_arr - a difference array of the array you want to change
+#   - diff_arr - a difference array of the array you want to change
 #   - l - leftmost index of the affected range
 #   - r - rightmost index of the affected range
 #   - x - a value to be added to all elements from a given range
diff --git a/src/basic/prefix_sum.jl b/src/basic/prefix_sum.jl
@@ -1,5 +1,32 @@
+"""
+    prefix_sum(arr::Vector{<:Number})
+
+# Brief
+Given an input array of numbers, return an array of the sum of each "prefix" of the input array i.e.
+the 1st element, 1st + 2nd element, 1st + 2nd + 3rd, etc.
+
+This functionality is available in base Julia as `cumsum`.
+
+# Arguments
+- `arr`: an array of numbers
+
+# Examples
+```julia
+julia> prefix_sum([1, 2, 3])
+3-element Vector{Int64}:
+ 1
+ 3
+ 6
+
+julia> prefix_sum([0.0, 10.0, π])
+3-element Vector{Float64}:
+  0.0
+ 10.0
+ 13.141592653589793
+```
+"""
 function prefix_sum(arr::Vector{T}) where {T<:Number}
-    pre = []
+    pre = T[]
     preans = zero(T)
     for i in arr
         preans += i
diff --git a/src/graph/bfs.jl b/src/graph/bfs.jl
@@ -23,14 +23,21 @@ TheAlgorithms.Graph.bfs(graph, 4)
 
 # output
 
-4 1 2 5 3 6
+6-element Vector{Int64}:
+ 4
+ 1
+ 2
+ 5
+ 3
+ 6
 ```
 
 Contributed by: [Yannick Brenning](https://github.com/ybrenning)
 """
 function bfs(graph::Vector{Vector{Int}}, source::Int = 1)
     # Use a boolean "visited" array to avoid processing a vertex more than once
     visited = [false for _ in 1:length(graph)]
+    result = Vector{Int}()
 
     queue = Queue{Int}()
     enqueue!(queue, source)
@@ -39,7 +46,7 @@ function bfs(graph::Vector{Vector{Int}}, source::Int = 1)
 
     while length(queue) > 0
         curr_v = dequeue!(queue)
-        print(curr_v, " ")
+        push!(result, curr_v)
 
         # Add every unvisited target to the end of the queue
         for i in 1:length(graph[curr_v])
@@ -50,5 +57,5 @@ function bfs(graph::Vector{Vector{Int}}, source::Int = 1)
         end
     end
 
-    return print("\n")
+    return result
 end
diff --git a/src/graph/dfs.jl b/src/graph/dfs.jl
@@ -23,14 +23,21 @@ dfs(graph, 6)
 
 # output
 
-6 5 2 4 3 1
+6-element Vector{Int64}:
+ 6
+ 5
+ 2
+ 4
+ 3
+ 1
 ```
 
 Contributed by: [Yannick Brenning](https://github.com/ybrenning)
 """
 function dfs(graph::Vector{Vector{Int}}, source::Int = 1)
     # Use a boolean "visited" array to avoid processing a vertex more than once
     visited = [false for _ in 1:length(graph)]
+    result = Vector{Int}()
 
     stack = Stack{Int}()
     push!(stack, source)
@@ -39,7 +46,7 @@ function dfs(graph::Vector{Vector{Int}}, source::Int = 1)
 
     while length(stack) > 0
         curr_v = pop!(stack)
-        print(curr_v, " ")
+        push!(result, curr_v)
 
         # Add every unvisited target to the top of the stack
         for i in 1:length(graph[curr_v])
@@ -49,6 +56,5 @@ function dfs(graph::Vector{Vector{Int}}, source::Int = 1)
             end
         end
     end
-
-    return print("\n")
+    return result
 end
diff --git a/src/longest_increasing_subsequence/binary_search.jl b/src/longest_increasing_subsequence/binary_search.jl
@@ -1,5 +1,5 @@
 """
-    lis(arr::Array{Int}, ::Val{:bs})
+    lis(arr::Array{<:Integer}, ::Val{:bs})
 
 # Arguments:
 - `arr`: sequence of integers
@@ -23,12 +23,12 @@ https://cp-algorithms.com/sequences/longest_increasing_subsequence.html
 - [Igor Malheiros](https://github.com/igormalheiros)
 """
 
-function lis(arr::Array{Int}, ::Val{:bs})
+function lis(arr::Array{T}, ::Val{:bs}) where T <: Integer
     len = length(arr)
-    memo = ones(Int, len)
+    memo = ones(T, len)
     p = ones(Int, len)
 
-    lis_arr = Int[]
+    lis_arr = T[]
 
     len == 0 && return lis_arr # if `arr` is empty
 
@@ -48,12 +48,10 @@ function lis(arr::Array{Int}, ::Val{:bs})
     last_pos = lis_len
     for i in len:-1:1
         if p[i] == last_pos
-            push!(lis_arr, arr[i])
+            pushfirst!(lis_arr, arr[i])
             last_pos -= 1
         end
     end
 
-    reverse!(lis_arr)
-
     return lis_arr
 end
diff --git a/src/longest_increasing_subsequence/dynamic_programming.jl b/src/longest_increasing_subsequence/dynamic_programming.jl
@@ -1,5 +1,5 @@
 """
-    lis(arr::Array{Int}, ::Val{:dp})
+    lis(arr::Array{<:Integer}, ::Val{:dp})
 
 # Arguments:
 - `arr`: sequence of integers
@@ -23,12 +23,12 @@ https://cp-algorithms.com/sequences/longest_increasing_subsequence.html
 - [Igor Malheiros](https://github.com/igormalheiros)
 """
 
-function lis(arr::Array{Int}, ::Val{:dp})
+function lis(arr::Array{T}, ::Val{:dp}) where T <: Integer
     len = length(arr)
     memo = ones(Int, len)
     p = zeros(Int, len)
 
-    lis_arr = Int[]
+    lis_arr = T[]
 
     len == 0 && return lis_arr # if arr is empty
 
@@ -51,11 +51,9 @@ function lis(arr::Array{Int}, ::Val{:dp})
 
     # Restoring
     while lis_pos != 0
-        push!(lis_arr, arr[lis_pos])
+        pushfirst!(lis_arr, arr[lis_pos])
         lis_pos = p[lis_pos]
     end
 
-    reverse!(lis_arr)
-
     return lis_arr
 end
diff --git a/src/matrix/determinant.jl b/src/matrix/determinant.jl
@@ -16,7 +16,7 @@ Determinant of triangualar matrices is the product of their diagonal entries. He
 function determinant(mat)
     n, m = size(mat)
     if n != m
-        DomainError(mat, "The matrix should be a square matrix.")
+        throw(DomainError(mat, "The matrix should be a square matrix."))
     end
     L, U = lu_decompose(mat)
     l_prod = prod([L[i, i] for i in 1:n])
diff --git a/src/project_euler/ProjectEuler.jl b/src/project_euler/ProjectEuler.jl
@@ -19,6 +19,7 @@ export problem_011
 export problem_012
 export problem_013
 export problem_014
+export problem_015
 
 include("../math/divisors.jl")
 include("../math/sieve_of_eratosthenes.jl")
@@ -36,5 +37,6 @@ include("problem_011.jl")
 include("problem_012.jl")
 include("problem_013.jl")
 include("problem_014.jl")
+include("problem_015.jl")
 
 end
diff --git a/src/project_euler/problem_010.jl b/src/project_euler/problem_010.jl
@@ -23,5 +23,5 @@ Contributed by: [Praneeth Jain](https://www.github.com/PraneethJain)
 """
 function problem_010(n::Int)
     n < 1 && throw(DomainError("n must be a natural number"))
-    return reduce(+, eratosthenes(Int64(n)), init=Int64(0))
+    return reduce(+, eratosthenes(Int64(n)), init = Int64(0))
 end
diff --git a/src/project_euler/problem_015.jl b/src/project_euler/problem_015.jl
@@ -0,0 +1,36 @@
+"""
+    Lattice Paths
+
+Starting in the top left corner of a grid, and only being able to move to the 
+right and down, there are exactly 6 routes to the bottom right corner. How many
+such routes are there through a 20 x 20 grid?
+grid?
+
+# Input parameters:
+- `n` : number of rows in the grid
+- `m` : number of columns in the grid
+
+# Examples/Tests:
+```julia
+problem_015(2, 2)       # returns 6
+problem_015(5, 3)       # returns 56
+problem_015(20, 20)     # returns 137846528820
+problem_015(0, 5)       # throws DomainError
+problem_015(-3, 0)      # throws DomainError
+```
+
+# Reference
+- https://projecteuler.net/problem=15
+
+Contributed by: [Praneeth Jain](https://www.github.com/PraneethJain)
+"""
+function problem_015(n::T, m::T) where {T<:Integer}
+    #=
+    The path is a combination of rights and downs, with a total of n + m operations
+    We need to count the number of such combinations of n rights and m downs
+    This is equivalent to finding the binomial coefficient (n+m, m) or (n+m, n)
+    Note that both of them are equivalent
+    =#
+    (n <= 1 || m <= 1) && throw(DomainError("n and m must be greater than 1"))
+    return binomial(BigInt(n + m), BigInt(n))
+end
diff --git a/test/basic.jl b/test/basic.jl
@@ -4,6 +4,9 @@ using TheAlgorithms.Basic
     @testset "Basic: prefix_sum" begin
         @test Basic.prefix_sum([1, 1, 1]) == [1, 2, 3]
         @test Basic.prefix_sum([1, 2, 3]) == [1, 3, 6]
+        @test Basic.prefix_sum(BigInt[]) == BigInt[]
+        @test Basic.prefix_sum([0., 0., 0.]) == [0., 0., 0.]
+        @test Basic.prefix_sum([1 + 2im, 2 - 3im]) == [1 + 2im, 3 - 1im]
     end
 
     @testset "Basic: DifferenceArray" begin
diff --git a/test/graph.jl b/test/graph.jl
@@ -41,4 +41,32 @@ using TheAlgorithms.Graph
 
         @test_throws ErrorException bellman_ford(negative_edge_cycle, 1)
     end
+
+    @testset "bfs" begin
+        graph = [
+            [2, 3, 6],
+            [3, 4],
+            [4],
+            [1, 2, 5],
+            [2],
+            [1, 5]
+        ]
+
+        @test bfs(graph, 4) == [4, 1, 2, 5, 3, 6]
+        @test bfs(graph) == [1, 2, 3, 6, 4, 5]
+    end
+
+    @testset "dfs" begin
+        graph = [
+            [2, 3, 6],
+            [3, 4],
+            [4],
+            [1, 2, 5],
+            [2],
+            [1, 5]
+        ]
+
+        @test dfs(graph, 6) == [6, 5, 2, 4, 3, 1]
+        @test dfs(graph) == [1, 6, 5, 3, 4, 2]
+    end
 end
diff --git a/test/longest_increasing_subsequence.jl b/test/longest_increasing_subsequence.jl
@@ -19,6 +19,12 @@ using TheAlgorithms.LongSubSeq
         # two possible results:
         @test lis([3, 4, -1, 5, 8, 2, 3, 12, 7, 9, 10], Val(:dp)) in
               [[-1, 2, 3, 7, 9, 10], [3, 4, 5, 8, 9, 10]]
+        # Boolean array
+        @test lis([true, false, false, true], Val(:dp)) == [false, true]
+        # other Integer subtypes
+        for T in [UInt128, UInt16, UInt32, UInt64, UInt8, BigInt, Int128, Int16, Int32, Int64, Int8]
+            @test lis(T[3, 10, 2, 1, 20], Val(:dp)) == T[3, 10, 20]
+        end
     end
 
     @testset "LIS: Binary Search approach!" begin
@@ -39,5 +45,11 @@ using TheAlgorithms.LongSubSeq
         # two possible results:
         @test lis([3, 4, -1, 5, 8, 2, 3, 12, 7, 9, 10], Val(:bs)) in
               [[-1, 2, 3, 7, 9, 10], [3, 4, 5, 8, 9, 10]]
+        # Boolean array
+        @test lis([true, false, false, true], Val(:bs)) == [false, true]
+        # other Integer subtypes
+        for T in [UInt128, UInt16, UInt32, UInt64, UInt8, BigInt, Int128, Int16, Int32, Int64, Int8]
+            @test lis(T[3, 10, 2, 1, 20], Val(:bs)) == T[3, 10, 20]
+        end
     end
 end
diff --git a/test/matrix.jl b/test/matrix.jl
@@ -9,6 +9,9 @@ using TheAlgorithms.MatrixAlgo
         @test determinant(M1) == det(M1)
         @test round(determinant(M2), digits = 4) == round(det(M2), digits = 4)
         @test round(determinant(M3), digits = 4) == round(det(M3), digits = 4)
+
+        @test_throws DomainError determinant([1 2])
+        @test_throws DomainError determinant([1 2; 3 4; 5 6])
     end
 
     @testset "Matrix: LU Decompose" begin
@@ -79,5 +82,8 @@ using TheAlgorithms.MatrixAlgo
             Float64[1 0 0; 0 1 0; -0 -0 1],
             atol = 1e-5,
         )
+
+        @test gauss_jordan([0.0 1.0 5.0; 1.0 -2.0 -3.0]) ==
+              [1.0 0.0 7.0; 0.0 1.0 5.0]
     end
 end
diff --git a/test/project_euler.jl b/test/project_euler.jl
diff --git a/test/searches.jl b/test/searches.jl
diff --git a/test/strings.jl b/test/strings.jl

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-FROM gitpod/workspace-base:2023-10-04-18-52-46`
	`1`	`+FROM gitpod/workspace-base:2023-10-19-14-24-02`
`2`	`2`
`3`	`3`	`ENV JULIA_TMP="julia_tmp.tar.gz"`
`4`	`4`