docs: remove implementation sections

Author: vil02

Diff for: en/Basic Math/Average_Mean.md

@@ -57,11 +57,6 @@ If we properly consider significant digits: `sum / count = 23`
 
 Return the value of 22.<u>857142</u> or `23`.
 
-## Implementation
-
--   [Python](https://github.com/TheAlgorithms/Python/blob/master/maths/average_mean.py)
--   [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/maths/average_mean.rb)
-
 ## Video URL
 
 -   [Mean on Khan Academy](https://www.khanacademy.org/math/ap-statistics/summarizing-quantitative-data-ap/measuring-center-quantitative/v/mean-median-and-mode)

Diff for: en/Basic Math/Fibonacci_Numbers.md

@@ -55,21 +55,6 @@ Calculate matrix^8
 ### Step 5
 F(8)=21
 
-## Implementation
-
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/math/fibonacci.cpp)
-- [Elixir](https://github.com/TheAlgorithms/Elixir/blob/master/lib/dynamic_programming/fibonacci.ex)
-- [F#](https://github.com/TheAlgorithms/F-Sharp/blob/main/Algorithms/Math/Fibonacci.fs)
-- [Go](https://github.com/TheAlgorithms/Go/blob/master/dynamic/fibonacci.go)
-- [Haskell](https://github.com/TheAlgorithms/Haskell/blob/master/src/Maths/Fibonacci.hs)
-- [JavaScript](https://github.com/TheAlgorithms/Javascript/blob/master/Maths/Fibonacci.js)
-- [PHP](https://github.com/TheAlgorithms/PHP/blob/master/Maths/Fibonacci.php)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/maths/fibonacci.py)
-- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/maths/fibonacci.rb)
-- [Rust](https://github.com/TheAlgorithms/Rust/blob/master/src/dynamic_programming/fibonacci.rs)
-- [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/Mathematics/Fibonacci.scala)
-- [Swift](https://github.com/TheAlgorithms/Swift/blob/master/recursion/fibonacci.swift)
-
 ## Video URL
 
 - [Youtube](https://www.youtube.com/watch?v=EEb6JP3NXBI)

Diff for: en/Basic Math/Find the maximum number.md

@@ -98,10 +98,6 @@ Get the last value out of the list by using predefined last method.
 
 Return the value 70.
 
-## Implementation
-
-- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/maths/find_max.rb)
-
 # Source
 
 - [GeeksForGeeks](https://www.geeksforgeeks.org/c-program-find-largest-element-array/)

Diff for: en/Ciphers/caesar_cipher.md

@@ -35,11 +35,3 @@ Let us say we are sending a secret message to a friend.
 * The second letter is `h`. The letter 6 letters away is `n`. Our message is now `Zn`
 * We continue like that until the end. Our final message is: `Znk Igkygx iovnkx oy g lat yahyzozazout iovnkx.`
 * Decryption is the same way, except instead of going to the right in the alphabet, we go backwards.
-
-## 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)
-

Diff for: en/Ciphers/hill_cipher.md

@@ -54,10 +54,6 @@ So we will get the encrypted text as **POH**.
     [21 12 8]     [7]       [539]     [19]
 ```
 
-## Implementations
-
-[**Python**](https://github.com/TheAlgorithms/Python/blob/master/ciphers/hill_cipher.py)
-
 ## Video Explanation
 
 [Video explanation of the Hill Cipher](https://www.youtube.com/watch?v=6T46sgty4Mk)

Diff for: en/Ciphers/playfair-cipher.md

@@ -117,10 +117,6 @@ So we will get the encrypted text as **gatlmzclrqxa**.
 ```
 So we will get the encrypted text as **instrumentsx**.
 
-## Implementations
-
-- [**Python**](https://github.com/TheAlgorithms/Python/blob/master/ciphers/playfair_cipher.py)
-
 ## Video Explanation
 
 - [**Video explanation of the Playfair Cipher algorithm**](https://www.youtube.com/watch?v=UURjVI5cw4g)

Diff for: en/Ciphers/rsa_cipher.md

@@ -153,10 +153,3 @@ Enter your Private Key: 23
 PlainText:  51
 
 ```
-
-## Implementations
-
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/ciphers/rsa_cipher.py)
-- [GoLang](https://github.com/TheAlgorithms/Go/blob/master/cipher/rsa/rsa.go)
-- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/RSA.java)
-- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/ciphers/rsa.rb)

Diff for: en/Ciphers/vigenere_cipher.md

@@ -61,13 +61,3 @@ Decryption is similar to encryption (except for the subtraction operation).
     - [Index of coincidence](https://en.wikipedia.org/wiki/Index_of_coincidence)
 3. Once the key length is found, [frequency analysis](https://en.wikipedia.org/wiki/Frequency_analysis) can be used to find the key and hence crack the cipher.
 4. Therefore, this cipher should not be used to encrypt any important data.
-
-## Implementations
-
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/ciphers/vigenere_cipher.cpp)
-- [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)

Diff for: en/Data Structures/Graph/Bellman-Ford.md

@@ -88,13 +88,6 @@ O(V^2)
 	E                1				A->B->E = -1 + 2
 ```
 
-#### Code Implementation Links
-
-- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/BellmanFord.java)
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/dynamic_programming/bellman_ford.cpp)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/graphs/bellman_ford.py)
-- [C](https://github.com/TheAlgorithms/C/blob/master/data_structures/graphs/bellman_ford.c)
-
 #### Video Explanation
 
 [A video explaining the Bellman-Ford Algorithm](https://www.youtube.com/watch?v=hxMWBBCpR6A)

Diff for: en/Data Structures/Linked Lists/Circular Linked List.md

@@ -64,12 +64,6 @@ public void insertHead(int data)
 }
  ```
 
-## Code Implementation Links
-
-- [JavaScript](https://github.com/TheAlgorithms/JavaScript/blob/master/Data-Structures/Linked-List/SinglyCircularLinkedList.js)
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/cll/cll.cpp)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/circular_linked_list.py)
-
 ## Video Explanation
 
 [Video explanation on YouTube](https://youtu.be/HMkdlu5sP4A)

Diff for: en/Data Structures/Linked Lists/Doubly Linked List.md

@@ -100,14 +100,6 @@ class LinkedList {
 
 ![Tracing of algorithm](https://www.geeksforgeeks.org/wp-content/uploads/gq/2014/03/DLL_add_middle1.png)
 
-## Code Implementation Links
-
-- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/DoublyLinkedList.java)
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/doubly_linked_list.cpp)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/doubly_linked_list.py)
-- [Go](https://github.com/TheAlgorithms/Go/blob/master/data-structures/linked-list/double-linkedlist.go)
-- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/data_structures/linked_lists/double_list.rb)
-
 ## Video Explanation
 
 [A CS50 video explaining the Doubly Linked List Data Structure](https://www.youtube.com/watch?v=FHMPswJDCvU)

Diff for: en/Data Structures/Linked Lists/Singly Linked List.md

@@ -37,12 +37,6 @@ class LinkedList {
 }
  ```
 
-## Code Implementation Links
-
-- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/lists/SinglyLinkedList.java)
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/data_structures/linked_list.cpp)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/data_structures/linked_list/singly_linked_list.py)
-
 ## Video Explanation
 
 [A CS50 video explaining the Linked List Data Structure](https://www.youtube.com/watch?v=5nsKtQuT6E8)

Diff for: en/Data Structures/Probablistic/BloomFilter.md

@@ -117,12 +117,6 @@ Notice that this does not match either the result of `foo` or `bar`, however bec
 
 The probability of false positives increases with the probability of hash collisions within the filter. However, you can optimize the number of collisions if you have some sense of the cardinality of your set ahead of time. You can do this by optimizing `k` and `M`, `M` should be ~ 8-10 bits per expected item, and `k` should be `(M/n) * ln2`.
 
-## Examples
-
-Implementations of the Bloom Filter are available for:
-
-* [C#](https://github.com/TheAlgorithms/C-Sharp/blob/master/DataStructures/Probabilistic/BloomFilter.cs)
-
 ## Video Explainer
 
 [Video Explainer by Narendra L](https://www.youtube.com/watch?v=Bay3X9PAX5k)

Diff for: en/Dynamic Programming/Coin Change.md

@@ -48,18 +48,5 @@ 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
-- [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)

Diff for: en/Dynamic Programming/Kadane's Algorithm.md

@@ -106,12 +106,6 @@ largest_sum = max(5, 6) = 6
 
 ```Hence the output will be 6```
 
-
-
-### Code Implementation Links
-
-- [Python](https://github.com/TheAlgorithms/Python/blob/252df0a149502143a14e7283424d40b785dd451c/maths/kadanes.py)
-
 ### Video Explanation Link
 
 - [Kadane's Algorithm to Maximum Sum Subarray Problem](https://www.youtube.com/watch?v=86CQq3pKSUw)

Diff for: en/Dynamic Programming/Longest Common Subsequence.md

@@ -69,12 +69,6 @@ B 0 0 1 2 3
 ```
 So the length of LCS is `dp[4][4] = 3`.
 
-#### Code Implementation Links
-
-- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/dynamicprogramming/LongestCommonSubsequence.java)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/dynamic_programming/longest_common_subsequence.py)
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Dynamic%20Programming/Longest%20Common%20Subsequence.cpp)
-
 #### Video Explanation
 
 [Video explanation by Tushar Roy](https://youtu.be/NnD96abizww)

Diff for: en/Greedy Algorithms/Fractional Knapsack.md

@@ -35,12 +35,6 @@ We won't be able to make more money by combining diverse things.
 
 ```
 
-#### Code Implementation Links
-
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/greedy_algorithms/knapsack.cpp)
-- [Python](https://github.com/TheAlgorithms/Python/tree/master/knapsack)
-- [C-Sharp](https://github.com/TheAlgorithms/C-Sharp/tree/master/Algorithms/Knapsack)
-
 #### Video Explanation
 
 [A CS50 video explaining the Greedy Algorithm](https://www.youtube.com/watch?v=Ou9OA0yQCYA)

Diff for: en/Image Processing/Harris Detector.md

@@ -13,10 +13,6 @@ Given image $I$, $n\times n$ size Gaussian Kernel $G_{n\times n}$,
 3. Compute the response function $R$, where $R=AB-C^2-k(A+B)$
 4. Classify all points in $R​$.
 
-## Code Implementation Links
-
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/computer_vision/harriscorner.py)
-
 ## Reference
 
 C. Harris and M. Stephens, “A Combined Corner and Edge Detector,” in *Proceedings of the Alvey Vision Conference 1988*, Manchester, 1988, pp. 23.1-23.6.

Diff for: en/Search Algorithms/Binary Search.md

@@ -38,14 +38,6 @@ target = 9
 A simple Binary Search implementation may return -1 as 9 is not present in the array. A more complex one would return the index at which 9 would have to be inserted, which would be `-8` (last position in the array (7) plus one (7+1), negated)`.
 ```
 
-#### Code Implementation Links
-
-- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/BinarySearch.java)
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/binary_search.cpp)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/searches/binary_search.py)
-- [C-Sharp](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Search/BinarySearcher.cs)
-- [C](https://github.com/TheAlgorithms/C/blob/master/searching/binary_search.c)
-
 #### Video Explanation
 
 [A CS50 video explaining the Binary Search Algorithm](https://www.youtube.com/watch?v=5xlIPT1FRcA)

Diff for: en/Search Algorithms/Exponential Search.md

@@ -53,9 +53,3 @@ Let's take a look at this comparison with a less theoretical example. Imagine we
 
 - The Binary Search start from the middle of the array and arrive to the 4th position after many iterations
 - The Exponential Search arrive at the 4th index after only 2 iterations
-
-#### Code Implementation Links
-
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/exponential_search.cpp)
-- [C](https://github.com/TheAlgorithms/C/blob/master/searching/exponential_search.c)
-- [JavaScript](https://github.com/TheAlgorithms/Javascript/blob/master/Search/ExponentialSearch.js)

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

@@ -67,10 +67,6 @@ tortoise = arr[0] = 3
 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)

Diff for: en/Search Algorithms/Linear Search.md

@@ -33,13 +33,6 @@ target = 6
 Linear Search should return -1 as 6 is not present in the array
 ```
 
-#### Code Implementation Links
-
-- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/LinearSearch.java)
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/search/linear_search.cpp)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/searches/linear_search.py)
-- [C](https://github.com/TheAlgorithms/C/blob/master/searching/linear_search.c)
-
 #### Video Explanation
 
 [A CS50 video explaining the Linear Search Algorithm](https://www.youtube.com/watch?v=CX2CYIJLwfg)

Diff for: en/Selection Algorithms/Find Second Largest Element.md

@@ -65,10 +65,6 @@ True : b = arr[6] (b = 25)
 Now we get the value 25 in the variable "b", which is the second highest value in the array.
 ```
 
-#### Code Implementation Links
-
-[JavaScript](https://github.com/TheAlgorithms/JavaScript/blob/master/Sorts/FindSecondLargestElement.js)
-
 #### Video Explanation
 
 [Video explaining 2 approaches](https://www.youtube.com/watch?v=Mv8jhYQEbkA)

Diff for: en/Selection Algorithms/Quick Select.md

@@ -41,13 +41,6 @@ Let's say k = 4. ie. We have to find 4th smallest element.
 4. As position of '7' is 4th (ie. k). Thus we will simply return 7
 ```
 
-### Code Implementation Links
-
-- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/QuickSelect.java)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/searches/quick_select.py)
-- [Go](https://github.com/TheAlgorithms/Go/blob/master/search/selectk.go)
-- [JavaScript](https://github.com/TheAlgorithms/JavaScript/blob/master/Data-Structures/Array/QuickSelect.js)
-
 ### Helpful Video Links
 
 [Video explaining how to find the Kth smallest/largest element in varying complexities](https://youtu.be/hGK_5n81drs)

Diff for: en/Sorting Algorithms/Bubble Sort.md

@@ -79,34 +79,6 @@ Indexes: 0   1   2   3
 Since there are no swaps in above steps, it means the array is sorted and we can stop here.
 ```
 
-#### Code Implementation Links
-
-- [Assembly](https://github.com/TheAlgorithms/AArch64_Assembly/blob/main/sorters/bubble_sort.s)
-- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/bubble_sort.c)
-- [C#](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Sorters/Comparison/BubbleSorter.cs)
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bubble_sort.cpp)
-- [Dart](https://github.com/TheAlgorithms/Dart/blob/master/sort/bubble_Sort.dart)
-- [Elixir](https://github.com/TheAlgorithms/Elixir/blob/master/lib/sorting/bubble_sort.ex)
-- [Elm](https://github.com/TheAlgorithms/Elm/blob/master/src/Sorting/BubbleSort.elm)
-- [F#](https://github.com/TheAlgorithms/F-Sharp/blob/main/Algorithms/Sort/Bubble_Sort.fs)
-- [Go](https://github.com/TheAlgorithms/Go/blob/master/sort/bubblesort.go)
-- [Haskell](https://github.com/TheAlgorithms/Haskell/blob/master/src/Sorts/BubbleSort.hs)
-- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/BubbleSort.java)
-- [Javascript](https://github.com/TheAlgorithms/JavaScript/blob/master/Sorts/BubbleSort.js)
-- [Julia](https://github.com/TheAlgorithms/Julia/blob/main/src/sorts/bubble_sort.jl)
-- [Kotlin](https://github.com/TheAlgorithms/Kotlin/blob/master/src/main/kotlin/sort/BubbleSort.kt)
-- [Lua](https://github.com/TheAlgorithms/Lua/blob/main/src/sorting/bubblesort.lua)
-- [Matlab](https://github.com/TheAlgorithms/MATLAB-Octave/blob/master/algorithms/sorting/bubble_sort.m)
-- [PHP](https://github.com/TheAlgorithms/PHP/blob/master/Sorting/BubbleSort.php)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
-- [R](https://github.com/TheAlgorithms/R/blob/master/sorting_algorithms/bubble_sort.r)
-- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/sorting/bubble_sort.rb)
-- [Rust](https://github.com/TheAlgorithms/Rust/blob/master/src/sorting/bubble_sort.rs)
-- [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/Sort/BubbleSort.scala)
-- [Solidity](https://github.com/TheAlgorithms/Solidity/blob/main/src/Sorts/BubbleSort.sol)
-- [Swift](https://github.com/TheAlgorithms/Swift/blob/master/sorts/BubbleSort.swift)
-- [TypeScript](https://github.com/TheAlgorithms/TypeScript/blob/master/sorts/bubble_sort.ts)
-
 #### Video Explanation
 
 [A video explaining the Bubble Sort Algorithm](https://www.youtube.com/watch?v=Jdtq5uKz-w4)

Diff for: en/Sorting Algorithms/Counting Sort.md

@@ -41,22 +41,6 @@ countingSort(array, size)
     decrease count of each element restored by 1
 ```
 
-#### Code Implementation Links
-
-- [Assembly](https://github.com/TheAlgorithms/AArch64_Assembly/blob/main/sorters/counting_sort.s)
-- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/counting_sort.c)
-- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/counting_sort.cpp)
-- [Dart](https://github.com/TheAlgorithms/Dart/blob/master/sort/count_sort.dart)
-- [Go](https://github.com/TheAlgorithms/Go/blob/master/sort/countingsort.go)
-- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/CountingSort.java)
-- [JavaScript](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/CountingSort.js)
-- [Julia](https://github.com/TheAlgorithms/Julia/blob/main/src/sorts/counting_sort.jl)
-- [Matlab](https://github.com/TheAlgorithms/MATLAB-Octave/blob/master/algorithms/sorting/counting_sort.m)
-- [PHP](https://github.com/TheAlgorithms/PHP/blob/master/Sorting/CountSort.php)
-- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/counting_sort.py)
-- [R](https://github.com/TheAlgorithms/R/blob/master/sorting_algorithms/counting_sort.r)
-- [Rust](https://github.com/TheAlgorithms/Rust/blob/master/src/sorting/counting_sort.rs)
-
 #### Video Explanation
 
 [A video explaining the Counting Sort Algorithm](https://www.youtube.com/watch?v=7zuGmKfUt7s)