Merge branch 'animator:main' into raj

Author: RajKhanke

CONTRIBUTING.md

@@ -23,7 +23,7 @@ The list of topics for which we are looking for content are provided below along
 - Interacting with Databases - [Link](https://github.com/animator/learn-python/tree/main/contrib/database)  
 - Web Scrapping - [Link](https://github.com/animator/learn-python/tree/main/contrib/web-scrapping)  
 - API Development - [Link](https://github.com/animator/learn-python/tree/main/contrib/api-development)  
-- Data Structures & Algorithms - [Link](https://github.com/animator/learn-python/tree/main/contrib/ds-algorithms)  
+- Data Structures & Algorithms - [Link](https://github.com/animator/learn-python/tree/main/contrib/ds-algorithms)  **(Not accepting)**
 - Python Mini Projects - [Link](https://github.com/animator/learn-python/tree/main/contrib/mini-projects)  **(Not accepting)**
 - Python Question Bank - [Link](https://github.com/animator/learn-python/tree/main/contrib/question-bank)  **(Not accepting)**
 

README.md

@@ -1,9 +1,5 @@
 [![Discord Server Invite](https://img.shields.io/badge/DISCORD-JOIN%20SERVER-5663F7?style=for-the-badge&logo=discord&logoColor=white)](https://bit.ly/heyfoss)
 
-This project is participating in GSSoC 2024.
-
-![gssoc-logo](https://github.com/foss42/awesome-generative-ai-apis/assets/1382619/670b651a-15d7-4869-a4d1-6613df09fa37)
-
 Contributors should go through the [Contributing Guide](https://github.com/animator/learn-python/blob/main/CONTRIBUTING.md) to learn how you can contribute to the project.
 
 ![Learn Python 3 Logo](images/learn-python.png)

contrib/ds-algorithms/dynamic-programming.md

@@ -234,3 +234,220 @@ print("Length of lis is", lis(arr))
 ## Complexity Analysis
 - **Time Complexity**: O(n * n) for both approaches, where n is the length of the array.
 - **Space Complexity**: O(n * n) for the memoization table in Top-Down Approach, O(n) in Bottom-Up Approach.
+
+# 5. String Edit Distance 
+
+The String Edit Distance algorithm calculates the minimum number of operations (insertions, deletions, or substitutions) required to convert one string into another.
+
+**Algorithm Overview:**
+- **Base Cases:** If one string is empty, the edit distance is the length of the other string.
+- **Memoization:** Store the results of previously computed edit distances to avoid redundant computations.
+- **Recurrence Relation:** Compute the edit distance by considering insertion, deletion, and substitution operations.
+  
+## String Edit Distance Code in Python (Top-Down Approach with Memoization)
+```python
+def edit_distance(str1, str2, memo={}):
+    m, n = len(str1), len(str2)
+    if (m, n) in memo:
+        return memo[(m, n)]
+    if m == 0:
+        return n
+    if n == 0:
+        return m
+    if str1[m - 1] == str2[n - 1]:
+        memo[(m, n)] = edit_distance(str1[:m-1], str2[:n-1], memo)
+    else:
+        memo[(m, n)] = 1 + min(edit_distance(str1, str2[:n-1], memo),     # Insert
+                               edit_distance(str1[:m-1], str2, memo),     # Remove
+                               edit_distance(str1[:m-1], str2[:n-1], memo)) # Replace
+    return memo[(m, n)]
+
+str1 = "sunday"
+str2 = "saturday"
+print(f"Edit Distance between '{str1}' and '{str2}' is {edit_distance(str1, str2)}.")
+```
+
+#### Output
+```
+Edit Distance between 'sunday' and 'saturday' is 3.
+```
+
+## String Edit Distance Code in Python (Bottom-Up Approach)
+```python
+def edit_distance(str1, str2):
+    m, n = len(str1), len(str2)
+    dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
+
+    for i in range(m + 1):
+        for j in range(n + 1):
+            if i == 0:
+                dp[i][j] = j
+            elif j == 0:
+                dp[i][j] = i
+            elif str1[i - 1] == str2[j - 1]:
+                dp[i][j] = dp[i - 1][j - 1]
+            else:
+                dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])
+
+    return dp[m][n]
+
+str1 = "sunday"
+str2 = "saturday"
+print(f"Edit Distance between '{str1}' and '{str2}' is {edit_distance(str1, str2)}.")
+```
+
+#### Output
+```
+Edit Distance between 'sunday' and 'saturday' is 3.
+```
+
+## **Complexity Analysis:**
+- **Time Complexity:** O(m * n) where m and n are the lengths of string 1 and string 2 respectively
+- **Space Complexity:** O(m * n) for both top-down and bottom-up approaches
+
+
+# 6. Matrix Chain Multiplication
+
+The Matrix Chain Multiplication finds the optimal way to multiply a sequence of matrices to minimize the number of scalar multiplications.
+
+**Algorithm Overview:**
+- **Base Cases:** The cost of multiplying one matrix is zero.
+- **Memoization:** Store the results of previously computed matrix chain orders to avoid redundant computations.
+- **Recurrence Relation:** Compute the optimal cost by splitting the product at different points and choosing the minimum cost.
+  
+## Matrix Chain Multiplication Code in Python (Top-Down Approach with Memoization)
+```python
+def matrix_chain_order(p, memo={}):
+    n = len(p) - 1
+    def compute_cost(i, j):
+        if (i, j) in memo:
+            return memo[(i, j)]
+        if i == j:
+            return 0
+        memo[(i, j)] = float('inf')
+        for k in range(i, j):
+            q = compute_cost(i, k) + compute_cost(k + 1, j) + p[i - 1] * p[k] * p[j]
+            if q < memo[(i, j)]:
+                memo[(i, j)] = q
+        return memo[(i, j)]
+    return compute_cost(1, n)
+
+p = [1, 2, 3, 4]
+print(f"Minimum number of multiplications is {matrix_chain_order(p)}.")
+```
+
+#### Output
+```
+Minimum number of multiplications is 18.
+```
+
+
+## Matrix Chain Multiplication Code in Python (Bottom-Up Approach)
+```python
+def matrix_chain_order(p):
+    n = len(p) - 1
+    m = [[0 for _ in range(n)] for _ in range(n)]
+
+    for L in range(2, n + 1):
+        for i in range(n - L + 1):
+            j = i + L - 1
+            m[i][j] = float('inf')
+            for k in range(i, j):
+                q = m[i][k] + m[k + 1][j] + p[i] * p[k + 1] * p[j + 1]
+                if q < m[i][j]:
+                    m[i][j] = q
+
+    return m[0][n - 1]
+
+p = [1, 2, 3, 4]
+print(f"Minimum number of multiplications is {matrix_chain_order(p)}.")
+```
+
+#### Output
+```
+Minimum number of multiplications is 18.
+```
+
+## **Complexity Analysis:**
+- **Time Complexity:** O(n^3) where n is the number of matrices in the chain. For an `array p` of dimensions representing the matrices such that the `i-th matrix` has dimensions `p[i-1] x p[i]`, n is `len(p) - 1`
+- **Space Complexity:**  O(n^2) for both top-down and bottom-up approaches
+
+# 7. Optimal Binary Search Tree
+
+The Matrix Chain Multiplication finds the optimal way to multiply a sequence of matrices to minimize the number of scalar multiplications.
+
+**Algorithm Overview:**
+- **Base Cases:** The cost of a single key is its frequency.
+- **Memoization:** Store the results of previously computed subproblems to avoid redundant computations.
+- **Recurrence Relation:** Compute the optimal cost by trying each key as the root and choosing the minimum cost.
+  
+## Optimal Binary Search Tree Code in Python (Top-Down Approach with Memoization)
+
+```python
+def optimal_bst(keys, freq, memo={}):
+    n = len(keys)
+    def compute_cost(i, j):
+        if (i, j) in memo:
+            return memo[(i, j)]
+        if i > j:
+            return 0
+        if i == j:
+            return freq[i]
+        memo[(i, j)] = float('inf')
+        total_freq = sum(freq[i:j+1])
+        for r in range(i, j + 1):
+            cost = (compute_cost(i, r - 1) + 
+                    compute_cost(r + 1, j) + 
+                    total_freq)
+            if cost < memo[(i, j)]:
+                memo[(i, j)] = cost
+        return memo[(i, j)]
+    return compute_cost(0, n - 1)
+
+keys = [10, 12, 20]
+freq = [34, 8, 50]
+print(f"Cost of Optimal BST is {optimal_bst(keys, freq)}.")
+```
+
+#### Output
+```
+Cost of Optimal BST is 142.
+```
+
+## Optimal Binary Search Tree Code in Python (Bottom-Up Approach)
+
+```python
+def optimal_bst(keys, freq):
+    n = len(keys)
+    cost = [[0 for x in range(n)] for y in range(n)]
+
+    for i in range(n):
+        cost[i][i] = freq[i]
+
+    for L in range(2, n + 1):
+        for i in range(n - L + 1):
+            j = i + L - 1
+            cost[i][j] = float('inf')
+            total_freq = sum(freq[i:j+1])
+            for r in range(i, j + 1):
+                c = (cost[i][r - 1] if r > i else 0) + \
+                    (cost[r + 1][j] if r < j else 0) + \
+                    total_freq
+                if c < cost[i][j]:
+                    cost[i][j] = c
+
+    return cost[0][n - 1]
+
+keys = [10, 12, 20]
+freq = [34, 8, 50]
+print(f"Cost of Optimal BST is {optimal_bst(keys, freq)}.")
+```
+
+#### Output
+```
+Cost of Optimal BST is 142.
+```
+
+### Complexity Analysis
+- **Time Complexity**: O(n^3) where n is the number of keys in the binary search tree.
+- **Space Complexity**: O(n^2) for both top-down and bottom-up approaches

contrib/ds-algorithms/images/binarytree.png

@@ -22,3 +22,4 @@
 - [AVL Trees](avl-trees.md)
 - [Splay Trees](splay-trees.md)
 - [Dijkstra's Algorithm](dijkstra.md)
+- [Tree Traversals](tree-traversal.md)

contrib/ds-algorithms/images/inorder-traversal.png

@@ -561,3 +561,58 @@ print("Sorted string:", sorted_str)
 ### Complexity Analysis
  - **Time Complexity:** O(n+k) for all cases.No matter how the elements are placed in the array, the algorithm goes through n+k times
  - **Space Complexity:** O(max). Larger the range of elements, larger is the space complexity.
+
+
+## 9. Cyclic Sort
+
+### Theory
+Cyclic Sort is an in-place sorting algorithm that is useful for sorting arrays where the elements are in a known range (e.g., 1 to N). The key idea behind the algorithm is that each number should be placed at its correct index. If we find a number that is not at its correct index, we swap it with the number at its correct index. This process is repeated until every number is at its correct index.
+
+### Algorithm
+- Iterate over the array from the start to the end.
+- For each element, check if it is at its correct index.
+- If it is not at its correct index, swap it with the element at its correct index.
+- Continue this process until the element at the current index is in its correct position. Move to the next index and repeat the process until the end of the array is reached.
+
+### Steps
+- Start with the first element.
+- Check if it is at the correct index (i.e., if arr[i] == i + 1).
+- If it is not, swap it with the element at the index arr[i] - 1.
+- Repeat step 2 for the current element until it is at the correct index.
+- Move to the next element and repeat the process.
+
+### Code
+
+```python
+def cyclic_sort(nums):
+    i = 0
+    while i < len(nums):
+        correct_index = nums[i] - 1
+        if nums[i] != nums[correct_index]:
+            nums[i], nums[correct_index] = nums[correct_index], nums[i]  # Swap
+        else:
+            i += 1
+    return nums
+```
+
+### Example
+```
+arr = [3, 1, 5, 4, 2]
+sorted_arr = cyclic_sort(arr)
+print(sorted_arr)
+  ```
+### Output
+```
+[1, 2, 3, 4, 5]
+```
+
+### Complexity Analysis
+**Time Complexity:** 
+
+The time complexity of Cyclic Sort is **O(n)**.
+This is because in each cycle, each element is either placed in its correct position or a swap is made. Since each element is swapped at most once, the total number of swaps (and hence the total number of operations) is linear in the number of elements.
+
+**Space Complexity:** 
+
+The space complexity of Cyclic Sort is **O(1)**. 
+This is because the algorithm only requires a constant amount of additional space beyond the input array.