docs: remove implementation sections

TheAlgorithms · Apr 4, 2024 · f6fa18e · f6fa18e
1 parent fe77013
commit f6fa18e
Show file tree

Hide file tree

Showing 103 changed files with 0 additions and 905 deletions.
diff --git a/en/Basic Math/Average_Mean.md b/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 --git a/en/Basic Math/Fibonacci_Numbers.md b/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 --git a/en/Basic Math/Find the maximum number.md b/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 --git a/en/Ciphers/caesar_cipher.md b/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 --git a/en/Ciphers/hill_cipher.md b/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 --git a/en/Ciphers/playfair-cipher.md b/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 --git a/en/Ciphers/rsa_cipher.md b/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 --git a/en/Ciphers/vigenere_cipher.md b/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 --git a/en/Data Structures/Graph/Bellman-Ford.md b/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 --git a/en/Data Structures/Linked Lists/Circular Linked List.md b/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 --git a/en/Data Structures/Linked Lists/Doubly Linked List.md b/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 --git a/en/Data Structures/Linked Lists/Singly Linked List.md b/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 --git a/en/Data Structures/Probablistic/BloomFilter.md b/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 --git a/en/Dynamic Programming/Coin Change.md b/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 --git a/en/Dynamic Programming/Kadane's Algorithm.md b/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 --git a/en/Dynamic Programming/Longest Common Subsequence.md b/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 --git a/en/Greedy Algorithms/Fractional Knapsack.md b/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 --git a/en/Image Processing/Harris Detector.md b/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 --git a/en/Search Algorithms/Binary Search.md b/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 --git a/en/Search Algorithms/Exponential Search.md b/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 --git a/en/Search Algorithms/Floyd Cycle Detection Algorithm to Find Duplicate Number.md b/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 --git a/en/Search Algorithms/Linear Search.md b/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 --git a/en/Selection Algorithms/Find Second Largest Element.md b/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 --git a/en/Selection Algorithms/Quick Select.md b/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 --git a/en/Sorting Algorithms/Bubble Sort.md b/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 --git a/en/Sorting Algorithms/Counting Sort.md b/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)