Merge branch 'master' into new-branch

Author: appgurueu

en/Ciphers/caesar_cipher.md

@@ -38,4 +38,8 @@ Let us say we are sending a secret message to a friend.
 
 ## Implementation
 
+* [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/ciphers/caesar_cipher.cpp)
+* [JavaScript](https://github.com/TheAlgorithms/JavaScript/blob/master/Ciphers/CaesarCipher.js)
+* [PHP](https://github.com/TheAlgorithms/PHP/blob/master/Ciphers/CaesarCipher.php)
 * [Python](https://github.com/TheAlgorithms/Python/blob/master/ciphers/caesar_cipher.py)
+

en/Ciphers/vigenere_cipher.md

@@ -65,5 +65,9 @@ Decryption is similar to encryption (except for the subtraction operation).
 ## Implementations
 
 - [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/ciphers/vigenere_cipher.cpp)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
+- [C#](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Encoders/VigenereEncoder.cs)
+- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/Vigenere.java)
 - [JavaScript](https://github.com/TheAlgorithms/JavaScript/blob/master/Ciphers/VigenereCipher.js)
+- [Julia](https://github.com/TheAlgorithms/Julia/blob/main/src/cipher/vigenere.jl)
+- [Python](https://github.com/TheAlgorithms/Python/blob/master/ciphers/vigenere_cipher.py)
+- [Rust](https://github.com/TheAlgorithms/Rust/blob/master/src/ciphers/vigenere.rs)

en/Dynamic Programming/Coin Change.md

@@ -49,7 +49,17 @@ Let's say we have 3 coin types `[1,2,3]` and we want to change for `7` cents. So
 So the final answer is **8**. 8 ways to make change of 7 cents using all coin types. `{{1,1,1,1,1,1,1}, {1,1,1,1,1,2}, {1,1,1,2,2}, {1,2,2,2}, {1,1,1,1,3}, {1,3,3}, {2,2,3}, {1,1,2,3}}`
 
 #### Code Implementation Link
-[Python](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/coin_change.py)
+- [JavaScript](https://github.com/TheAlgorithms/JavaScript/blob/master/Dynamic-Programming/CoinChange.js)
+- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/coin_change.cpp)
+- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/CoinChange.java)
+- [Go](https://github.com/TheAlgorithms/Go/blob/master/dynamic/coinchange.go)
+- [Rust](https://github.com/TheAlgorithms/Rust/blob/master/src/dynamic_programming/coin_change.rs)
+- [Dart](https://github.com/TheAlgorithms/Dart/blob/master/dynamic_programming/coin_change.dart)
+- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/dynamic_programming/coin_change.rb)
+- [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/DynamicProgramming/CoinChange.scala)
+- [Julia](https://github.com/TheAlgorithms/Julia/blob/main/src/dynamic_programming/coin_change.jl)
+- [Lua](https://github.com/TheAlgorithms/Lua/blob/main/src/misc/coin_change.lua)
+- [C#](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Problems/DynamicProgramming/CoinChange/DynamicCoinChangeSolver.cs)
 
 #### Video Explanation
 [Total Unique Ways To Make Change by Back To Back SWE](https://www.youtube.com/watch?v=DJ4a7cmjZY0)

en/Search Algorithms/Floyd Cycle Detection Algorithm to Find Duplicate Number.md

@@ -1,38 +1,77 @@
-# Floyd Cycle Detection Algorithm to find duplicate number in an array
+# Floyd Cycle Detection Algorithm to find duplicate numbers in an array
 
 ## Problem Statement
 
 Given an array of integers containing `n + 1` integers, where each integer is in the range `[1, n]` inclusive. If there is only one duplicate number in the input array, this algorithm returns the duplicate number without modifying the original array, otherwise, it returns -1.
 
 ## Approach
+- We can imagine the array `arr` as a directed graph where each element is a node. `arr[i]` is the index of the node to which the i-th node points.
+- For example, given the `arr = [1, 3, 4, 2, 3]`, we can represent `arr` as the following <br></br>
+![image](images/graph_1.png)
 
-- Use the function `f(x) = arr[x]` to construct the sequence: 
-`arr[0]`, `arr[arr[0]]`, `arr[arr[arr[0]]]`, `arr[arr[arr[arr[0]]]]`, etc....
-- Each new element in the sequence is an element in `arr[]` at the index of the previous element.
-- Starting from `x = arr[0]`, it will produce a linked list with a cycle.
-- The cycle appears because `arr[]` contains duplicate elements(at least one). The duplicate value is an entrance to the cycle. 
+- Since there are duplicates in `arr`, a cycle exists in the directed graph as there is a path from node 3 to itself, `3 -> 2 -> 4 -> 3`.
+- The problem now becomes finding the entrance node to the cycle (3 in this case). 
+- We can use the Floyd Cycle Detection Algorithm (also known as the "Hare and Tortoise algorithm") to detect the entrance of the cycle.
+- The idea of the algorithm is to maintain two pointers, `hare` and `tortoise` that iterate the array at different "speeds" (just like the fable). The details are as follows:
 
+### The procedure
+- Using two pointers `hare` and `tortoise`.
+- Initiate `hare = tortoise = arr[0]`.
+- For every next step until `hare == tortoise` again, assign `hare = arr[arr[hare]]` and `tortoise = arr[tortoise]` (`hare` "jumps" 2 steps while `tortoise` "jumps" one step).
+- At this point, `hare == tortoise`, reset `tortoise = arr[0]` while keeping the value of `hare` in the above procedure.
+- For every next step until `hare == tortoise` again, assign `hare = arr[hare]` and `tortoise = arr[tortoise]` (this time `hare` only "jumps" one step).
+- When `tortoise == hare`, the entrance of the cycle is found, hence `hare` and `tortoise` represent the value of the duplicated element.
+- Return `tortoise` (also possible to return `hare`)
+  
 ## Time Complexity
 
-O(n)
+`O(n)`
 
 ## Space Complexity
 
-O(1) 
+`O(1)`, since we only use two extra variables as pointers.
 
-## Example
+## Example with step-by-step explanation
+![image](images/graph_2.png)
 
 ```
-arr = [3, 4, 8, 5, 9, 1, 2, 6, 7, 4]  
+arr = [3, 4, 8, 5, 9, 1, 2, 6, 7, 4]
 
-return value = 4
+hare = tortoise = arr[0] = 3
+
+1st step:
+  - hare = arr[arr[3]] = arr[5] = 1
+  - tortoise = arr[3] = 5
+2nd step:
+  - hare = arr[arr[1]] = arr[4] = 9
+  - tortoise = arr[5] = 1
+3rd step:
+  - hare = arr[arr[9]] = arr[4] = 9
+  - tortoise = arr[1] = 4
+4th step:
+  - hare = arr[arr[9]] = 9
+  - tortoise = arr[4] = 9
+
+tortoise = arr[0] = 3
+
+1st step:
+  - hare = arr[9] = 4
+  - tortoise = arr[3] = 5
+2nd step:
+  - hare = arr[4] = 9
+  - tortoise = arr[5] = 1
+3rd step:
+  - hare = arr[9] = 4
+  - tortoise = arr[1] = 4
+
+return tortoise = 4
 ```
 
 ## Code Implementation Links
 
 - [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/floyd_cycle_detection_algo.cpp)
 - [C](https://github.com/TheAlgorithms/C/blob/master/searching/floyd_cycle_detection_algorithm.c)
-
 #### Video Explanation
 
-[YouTube video explaining the Floyd Cycle Detection algorithm](https://www.youtube.com/watch?v=B6smdk7pZ14)
+- [YouTube video explaining the Floyd Cycle Detection algorithm](https://www.youtube.com/watch?v=B6smdk7pZ14)
+- [Another Youtube video](https://www.youtube.com/watch?v=PvrxZaH_eZ4&t=1s)

en/Search Algorithms/images/graph_1.png

@@ -51,6 +51,7 @@ takes extra space to sort numbers.
 - [Assembly](https://github.com/TheAlgorithms/AArch64_Assembly/blob/main/sorters/radix_sort.s)
 - [C](https://github.com/TheAlgorithms/C/blob/master/sorting/radix_sort.c)
 - [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/radix_sort.cpp)
+- [C#](https://github.com/TheAlgorithms/C-Sharp/tree/master/Algorithms/Sorters/Integer/RadixSorter.cs)
 - [Dart](https://github.com/TheAlgorithms/Dart/blob/master/sort/radix_sort.dart)
 - [Go](https://github.com/TheAlgorithms/Go/blob/master/sort/radixsort.go)
 - [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/RadixSort.java)
@@ -61,6 +62,7 @@ takes extra space to sort numbers.
 - [R](https://github.com/TheAlgorithms/R/blob/master/sorting_algorithms/radix_sort.r)
 - [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/sorting/radix_sort.rb)
 - [Rust](https://github.com/TheAlgorithms/Rust/blob/master/src/sorting/radix_sort.rs)
+- [Zig](https://github.com/TheAlgorithms/Zig/blob/main/sort/radixSort.zig)
 
 #### Video Explanation