diff --git a/SORTING/EASY/SELECTION SORT.MD b/SORTING/EASY/SELECTION SORT.MD
new file mode 100644
index 00000000..edfcae5c
--- /dev/null
+++ b/SORTING/EASY/SELECTION SORT.MD	
@@ -0,0 +1,307 @@
+# INTRODUCTION OF SELECTION SORT
+
+Selection sort is a simple sorting algorithm that works by repeatedly finding the minimum element from the unsorted portion of a list and swapping it with the first unsorted element. This process continues until the entire list is sorted. Selection sort has a time complexity of O(n^2) and is not suitable for large lists. It is often used for educational purposes to understand the concept of sorting algorithms.
+
+# OVERVIEW OF SELECTION SORT
+
+Selection sort begins by considering the entire array as the unsorted region. In each iteration, the algorithm finds the minimum element in the unsorted region and swaps it with the first element of the unsorted region. This effectively expands the sorted region and shrinks the unsorted region. The process is repeated until the entire array is sorted. Although its time complexity is O(n^2), making it less efficient for large datasets, selection sort's simplicity and ease of understanding make it a viable option for small-scale sorting tasks.
+
+**Example:**
+
+Consider the array `[64, 25, 12, 22, 11]`. Here's how selection sort would work:
+
+**Pass 1:**
+
+- Find the smallest element (11) and swap it with the first element: `[11, 25, 12, 22, 64]`
+- Now, the first element is sorted.
+
+**Pass 2:**
+
+- Find the smallest element among the remaining unsorted elements (12) and swap it with the second element: `[11, 12, 25, 22, 64]`
+- The first two elements are now sorted.
+
+**Pass 3:**
+
+- Find the smallest element among the remaining unsorted elements (22) and swap it with the third element: `[11, 12, 22, 25, 64]`
+
+**Pass 4:**
+
+- Find the smallest element among the remaining unsorted elements (25) and swap it with the fourth element: `[11, 12, 22, 25, 64]`
+
+**Pass 5:**
+
+- Now, the entire array is sorted: `[11, 12, 22, 25, 64]`
+
+# CODE
+
+### PYTHON
+
+```python
+#  Copyrights to venkys.io
+#  For more information, visit venkys.io
+#  time complexity = O(n^2),
+#  space complexity = O(1).
+
+def selectionSort(arr):
+    n = len(arr)
+    
+    # Traverse through all array elements
+    for i in range(n):
+        # Find the minimum element in the unsorted part of the array
+        min_idx = i
+        for j in range(i + 1, n):
+            if arr[j] < arr[min_idx]:
+                min_idx = j
+        
+        # Swap the found minimum element with the first element
+        arr[i], arr[min_idx] = arr[min_idx], arr[i]
+
+# Input array from the user
+try:
+    data = list(map(int, input("Enter the elements of the array separated by space: ").split()))
+
+    # Call the selectionSort function to sort the array
+    selectionSort(data)
+
+    # Display the sorted array
+    print('Sorted Array in Ascending Order:')
+    print(data)
+#The error handling is included to handle cases where the user enters non-integer values.
+except ValueError:
+    print("Please enter valid integers for array elements.")
+```
+
+## STEP BY STEP EXPLANATION
+
+Below is a step-by-step explanation of the code provided:
+
+1. The code begins with the definition of the selection 
+2. Sort function, which takes an array as input and performs the selection sort algorithm on it.
+3. The selection Sort function starts by getting the length of the array.
+4. It then iterates through each element of the array using a for loop. The variable 'i' represents the current index of the element being considered in the unsorted portion of the array.
+5. Inside the outer loop, another loop is used to find the index of the minimum element in the unsorted portion of the array. The variable 'j' represents the index being compared with the current minimum index.
+6. If the element at index 'j' is found to be smaller than the element at the current minimum index, the minimum index is updated to 'j'.
+7. After finding the minimum element in the unsorted portion of the array, the code swaps it with the first element of the unsorted portion. This effectively expands the sorted region and shrinks the unsorted region.
+8. The process of finding the minimum element and swapping it with the first element of the unsorted region continues until the entire array is sorted.
+9. The main part of the code handles user input and calls the selection Sort function to sort the array.
+10. It prompts the user to enter the size of the array and then takes input for each element of the array.
+11. It then calls the selection Sort function, passing the input array as an argument.
+12. Finally, it displays the sorted array in ascending order by iterating through the elements of the array and printing them.
+
+*Please note that the code provided is in different programming languages (Python, Java, and C++), but the logic and steps for the selection sort algorithm remain the same across the languages.*
+
+### JAVA
+
+```java
+
+// Copyrights to venkys.io
+// For more information, visit venkys.io
+// time complexity = O(n^2),
+// space complexity = O(1).
+
+import java.util.Scanner;
+
+public class SelectionSort {
+    public static void selectionSort(int[] arr) {
+        int n = arr.length;
+        // Traverse through all array elements
+        for (int i = 0; i < n; i++) {
+            // Find the minimum element in the unsorted part of the array
+            int minIdx = i;
+            for (int j = i + 1; j < n; j++) {
+                if (arr[j] < arr[minIdx]) {
+                    minIdx = j;
+                }
+            }
+            // Swap the found minimum element with the first element
+            int temp = arr[i];
+            arr[i] = arr[minIdx];
+            arr[minIdx] = temp;
+        }
+    }
+// Input array from the user
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        try {
+            System.out.print("Enter the size of the array: ");
+            int size = scanner.nextInt();
+            int[] data = new int[size];
+
+            for (int i = 0; i < size; i++) {
+                System.out.print("Enter element " + (i + 1) + ": ");
+                data[i] = scanner.nextInt();
+            }
+
+            // Call the selectionSort method to sort the array
+            selectionSort(data);
+
+            // Display the sorted array
+            System.out.println("Sorted Array in Ascending Order:");
+            for (int element : data) {
+                System.out.print(element + " ");
+            }
+
+// The error handling is included to handle cases where the user enters non-integer values.
+        } catch (java.util.InputMismatchException e) {
+            System.out.println("Please enter valid integers for array elements.");
+        }
+    }
+}
+```
+
+## STEP BY STEP EXPLANATION
+
+1. The code starts by importing the necessary packages and defining the Selection Sort class.
+2. The selection Sort method is defined, which takes an integer array as input and performs the selection sort algorithm on it. The time complexity of the algorithm is O(n^2), and the space complexity is O(1).
+3. Inside the selection Sort method, the array length is stored in the variable n.
+4. The outer loop iterates through each element of the array from index 0 to n-1. This loop represents the sorted part of the array.
+5. Inside the outer loop, the minimum value is searched for in the unsorted part of the array. The variable min Idx is used to keep track of the index of the minimum value.
+6. The inner loop starts from index i+1 and iterates through the remaining unsorted elements. If an element smaller than the current minimum is found, the min Idx is updated.
+7. After finding the minimum value, it is swapped with the first element of the unsorted part. This brings the minimum value to its correct position in the sorted part of the array.
+8. The sorted array is printed after the outer loop completes. The elements are displayed in ascending order.
+9. The main method is defined to get input from the user and call the selection Sort method. It starts by creating a Scanner object to read input.
+10. The user is prompted to enter the size of the array. Then, an array of that size is created.
+11. The user is prompted to enter each element of the array, and the values are stored in the data array.
+12. The selection Sort method is called with the data array as an argument to sort the array.
+13. Finally, the sorted array is displayed to the user.
+14. Error handling is included to handle cases where the user enters non-integer values.
+
+### C++
+
+```cpp
+
+//   Copyrights to venkys.io
+//   For more information, visit venkys.io
+//   time complexity = O(n^2),
+//   space complexity = O(1).
+
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+void selectionSort(vector<int>& arr) {
+    int n = arr.size();
+    // Traverse through all array elements
+    for (int i = 0; i < n; i++) {
+      // Find the minimum element in the unsorted part of the array
+        int minIdx = i;
+        for (int j = i + 1; j < n; j++) {
+            if (arr[j] < arr[minIdx]) {
+                minIdx = j;
+            }
+        }
+        // Swap the found minimum element with the first element
+        swap(arr[i], arr[minIdx]);
+    }
+}
+// Input array from the user
+int main() {
+    try {
+        cout << "Enter the size of the array: ";
+        int size;
+        cin >> size;
+
+        vector<int> data(size);
+
+        for (int i = 0; i < size; i++) {
+            cout << "Enter element " << (i + 1) << ": ";
+            cin >> data[i];
+        }
+
+        // Call the selectionSort function to sort the array
+        selectionSort(data);
+
+        // Display the sorted array
+        cout << "Sorted Array in Ascending Order:" << endl;
+        for (int element : data) {
+            cout << element << " ";
+        }
+
+    } catch (const exception& e) {
+        cout << "Please enter valid integers for array elements." << endl;
+    }
+
+    return 0;
+}
+```
+
+## STEP BY STEP EXPLANATION
+
+1. The Selection Sort class is defined at the beginning of the code along with the import of the required packages.
+2. The selection Sort method is defined; it applies the selection sort algorithm to an integer array as input. The algorithm has an O(n^2) time complexity and an O(1) space complexity.
+3. The array length is kept in the variable n within the selection Sort method.
+4. The array's elements are iterated through from index 0 to n-1 in the outer loop. The sorted portion of the array is represented by this loop.
+5. The unsorted portion of the array is searched for the minimum value inside the outer loop. The index of the lowest value is tracked using the variable min Idx.
+6. 
+7. Iterating through the remaining unsorted elements, the inner loop begins at index i+1. The minIdx is changed if an element is discovered that is smaller than the existing minimum.
+8. The minimum value is found and then swapped with the unsorted part's first element. This moves the lowest value in the array's sorted portion to its proper location.
+9. Following the completion of the outer loop, the sorted array is printed. In increasing order, the elements are shown.
+10. The main method's definition calls the selection Sort function after receiving user input. To read input, a Scanner object must first be created.
+11. A prompt asking for the array's size is displayed to the user. After that, an array of that size is made.
+12. Each element of the array is entered by the user, and the values are saved in the data array.
+13. To sort the array, the selection Sort method is called and the data array is sent as an argument.
+14. The user is finally presented with the sorted array.
+15. To manage situations when the user submits non-integer values, error handling is included.
+
+## TEST CASES
+
+### EXAMPLE 1:
+
+**Input :**
+
+Enter the elements of the array separated by space:
+
+**Output :**
+
+    Sorted Array in Ascending Order:  []
+
+**Explanation :**
+
+The selection sort algorithm should handle edge cases such as an empty array. Since there are no elements to sort, the output should be an empty array.
+
+### EXAMPLE 2 :
+
+**Input :**
+
+Enter the elements of the array separated by space: 4 2 7 1 9
+
+**Output :**
+
+    Sorted Array in Ascending Order:
+    [1, 2, 4, 7, 9]
+
+**Explanation :**
+
+The selection sort algorithm selects the minimum element in each iteration and swaps it with the first unsorted element. After the first iteration, the smallest element (1) is in its correct position. This process repeats until the array is sorted.
+
+### EXAMPLE 3:
+
+**Input :**
+
+Enter the elements of the array separated by space: 5 2 8 2 5
+
+**Output :**
+
+    Sorted Array in Ascending Order:
+        [2, 2, 5, 5, 8]
+
+**Explanation :**
+
+Selection sort handles arrays with duplicate values. The algorithm selects the minimum element, and in case of duplicates, it preserves their relative order.
+
+# TIME AND SPACE COMPLEXITY
+
+The time complexity of the Selection Sort algorithm is `O(n^2)`, where 'n' is the number of elements in the array. This is because, in the worst-case scenario, for each element in the array, it needs to traverse the entire remaining unsorted portion of the array to find the minimum element and then perform a swap.
+
+The space complexity of the Selection Sort algorithm is `O(1)` This is because the algorithm only requires a constant amount of extra space to store variables like loop counters, indices, and temporary variables for swapping elements. The space required does not depend on the size of the input array, making it an "in-place" sorting algorithm.
+
+# REAL-WORLD APPLICATION FOR SELECTION SORT
+
+Selection sort, despite its inefficiency for large datasets, can still be useful in certain scenarios. One common real-world application is in situations where memory usage is a concern. Since selection sort only requires a constant amount of additional memory, it can be advantageous in environments with limited resources.
+
+Another application of selection sort is in sorting small lists or arrays where simplicity and ease of implementation are more important than efficiency. For example, selection sort can be used in sorting a deck of cards or a small list of names.
+
+Overall, while selection sort may not be the most efficient sorting algorithm for large-scale tasks, it still has practical applications in specific contexts where simplicity and limited memory usage are prioritized.
\ No newline at end of file
diff --git a/SORTING/MEDIUM/COUNTING SORT.MD b/SORTING/MEDIUM/COUNTING SORT.MD
new file mode 100644
index 00000000..992feb89
--- /dev/null
+++ b/SORTING/MEDIUM/COUNTING SORT.MD	
@@ -0,0 +1,372 @@
+# **COUNTING SORT**
+
+In this article, we will explore the counting sort algorithm, its importance, and applications. We will provide a step-by-step explanation of how counting sort works and present an example to illustrate its effectiveness.
+
+# **Introduction**
+
+Counting Sort is an efficient, non-comparative sorting algorithm that is used to sort integers or objects with a small range of key values. It works by counting the number of elements with distinct key values (often called "counting" the occurrences) and then using this information to determine the final sorted order of the elements. Counting Sort is particularly effective when the range of possible input values is known in advance.
+
+# **Overview of Counting Sort Algorithm**
+
+Counting sort is a non-comparative integer sorting algorithm that sorts elements based on their frequencies. It works by counting the occurrences of each element and using that information to determine their positions in the sorted output.
+
+## **Counting Sort Algorithm**
+
+The algorithm assumes that each element in the list is an integer between a minimum and maximum value. It creates a count array with a size equal to the range of values in the input list, and then iterates through the input list, incrementing the count array at the index corresponding to each element. Finally, it iterates through the count array and outputs the sorted list.
+
+here is an example of counting sort with a step-by-step explanation:
+
+**Step 1: Create a count array**
+
+The count array will have one element for each possible value in the input array. In this example, the input array is `[5, 3, 2, 1, 4]`, so the count array will have six elements, one for each value from 0 to 5.
+
+The count array will have six elements, one for each value from 0 to 5:
+
+`count_array = [0, 0, 0, 0, 0, 0]`
+
+**Step 2: Initialize the count array**
+
+Set all of the elements in the count array to 0.
+
+`count_array = [0, 0, 0, 0, 0, 0]`
+
+**Step 3: Iterate through the input array and increment the corresponding element in the count array for each value that we encounter**
+
+For each element in the input array, increment the corresponding element in the count array. In this example, we will increment the first element in the count array because the first element in the input array is 5. We will then increment the second element in the count array because the second element in the input array is 3, and so on.
+
+For each element in the input array, increment the corresponding element in the count array:
+
+`count_array = [1, 1, 1, 1, 1, 0]`
+
+**Step 4: Iterate through the count array and place the elements in the input array in their correct sorted positions based on their counts**
+
+Starting at the beginning of the input array, place each element in the input array at the position indicated by the corresponding element in the count array. For example, we will place the first element in the input array at position 5 because the first element in the count array is 5. We will then place the second element in the input array at position 3 because the second element in the count array is 3, and so on.
+
+`sorted_array = [5, 3, 2, 1, 4]`
+
+# **CODE**
+
+### PYTHON
+
+```python
+# Copyrights to venkys.io
+# For more information, visit venkys.io
+# time Complexity : O(n+k).
+# Space Complexity :O(n+k).
+
+def counting_sort(arr):
+    # Find the maximum and minimum elements in the array
+    max_num = max(arr)
+    min_num = min(arr)
+
+    # Create an array to store counts of each element
+    count = [0] * (max_num - min_num + 1)
+
+    # Count the occurrences of each element in the input array
+    for num in arr:
+        count[num - min_num] += 1
+
+    # Modify the count array to store cumulative counts
+    for i in range(1, len(count)):
+        count[i] += count[i - 1]
+
+    # Create an output array to store the sorted elements
+    output = [0] * len(arr)
+
+    # Place the elements in their sorted order in the output array
+    for num in reversed(arr):
+        output[count[num - min_num] - 1] = num
+        count[num - min_num] -= 1
+
+    return output
+
+# Get array elements from the user
+arr = list(map(int, input("Enter the elements of the array separated by space: ").split()))
+
+# Perform counting sort
+sorted_arr = counting_sort(arr)
+
+# Display the sorted array
+print("Sorted Array:", sorted_arr)
+```
+
+## Step-by-Step Explanation of the Code
+
+1. Define the function counting_sort that takes an array arr as input.
+2. Find the maximum and minimum elements in the array using the max() and min() functions, respectively.
+3. Create an array count of size (max_num - min_num + 1) to store the counts of each element.
+4. Initialize all elements of count to 0.
+5. Iterate through the array arr and increment the corresponding count in count.
+6. Modify the count array to store the cumulative counts.
+7. Create an output array output of the same size as arr to store the sorted elements.
+8. Iterate through the array arr in reverse order.
+9. Place each element in its sorted position in the output array.
+10. Decrement the count of the element in count after placing it in the output array.
+11. Return the output array as the sorted array.
+12. Get the array elements from the user.
+13. Call the counting_sort function with the input array.
+14. Print the sorted array.
+
+### JAVA
+
+```java
+
+// Copyrights to venkys.io
+// For more information, visit venkys.io
+// time Complexity :O(n+k)
+// Space Complexity :O(n+k)
+
+import java.util.Scanner;
+
+public class CountingSort {
+    // Function to perform counting sort
+    static void countingSort(int[] arr, int[] output, int max, int min) {
+        // Create an array to store counts of each element
+        int range = max - min + 1;
+        int[] count = new int[range];
+
+        // Count the occurrences of each element in the input array
+        for (int num : arr) {
+            count[num - min]++;
+        }
+
+        // Modify the count array to store cumulative counts
+        for (int i = 1; i < range; i++) {
+            count[i] += count[i - 1];
+        }
+
+        // Place the elements in their sorted order in the output array
+        for (int i = arr.length - 1; i >= 0; i--) {
+            output[count[arr[i] - min] - 1] = arr[i];
+            count[arr[i] - min]--;
+        }
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        // Get the size of the array from the user
+        System.out.print("Enter the size of the array: ");
+        int n = scanner.nextInt();
+
+        int[] arr = new int[n];
+        int[] output = new int[n];
+
+        // Get array elements from the user
+        System.out.print("Enter the elements of the array: ");
+        for (int i = 0; i < n; i++) {
+            arr[i] = scanner.nextInt();
+        }
+
+        // Find the maximum and minimum elements in the array
+        int max = Integer.MIN_VALUE;
+        int min = Integer.MAX_VALUE;
+        for (int num : arr) {
+            max = Math.max(max, num);
+            min = Math.min(min, num);
+        }
+
+        // Perform counting sort
+        countingSort(arr, output, max, min);
+
+        // Display the sorted array
+        System.out.print("Sorted Array: ");
+        for (int num : output) {
+            System.out.print(num + " ");
+        }
+    }
+}
+
+```
+
+## Step-by-Step Explanation of the Code
+
+1. Define a method called countingSort that takes in an array arr, an output array output, the maximum value max, and the minimum value min.
+2. Calculate the range of the array by subtracting the minimum value from the maximum value and adding 1.
+3. Create an array called count to store the counts of each element in the input array.
+4. Iterate through the input array and increment the count of each element in the count array.
+5. Modify the count array to store the cumulative counts.
+6. Place the elements in their sorted order in the output array by iterating through the input array in reverse order and using the count array to determine the correct position.
+7. In the main method, create a Scanner object to read user input.
+8. Prompt the user to enter the size of the array and store it in the variable n.
+9. Create arrays arr and output with size n.
+10. Prompt the user to enter the elements of the array and store them in the arr array.
+11. Find the maximum and minimum elements in the arr array.
+12. Call the countingSort method to sort the arr array and store the sorted result in the output array.
+13. Print the sorted array.
+
+### C++
+
+```cpp
+// Copyrights to venkys.io
+// For more information, visit venkys.io
+// time Complexity : O(n+k).
+// Space Complexity : O(n+k).
+
+#include<iostream>
+using namespace std;
+
+// Function to perform counting sort
+void countingSort(int max, int n, int arr[], int output[]) {
+    // Create an array to store counts of each element
+    int count[max + 1];
+
+    // Initialize count array elements to zero
+    for (int i = 0; i <= max; i++) {
+        count[i] = 0;
+    }
+
+    // Count the occurrences of each element in the input array
+    for (int j = 0; j < n; j++) {
+        count[arr[j]] += 1;
+    }
+
+    // Modify the count array to store cumulative counts
+    for (int i = 1; i <= max; i++) {
+        count[i] += count[i - 1];
+    }
+
+    // Place the elements in their sorted order in the output array
+    for (int i = n - 1; i >= 0; i--) {
+        output[count[arr[i]] - 1] = arr[i];
+        count[arr[i]]--;
+    }
+}
+
+// Function to find the maximum element in the input array
+int findMax(int arr[], int n) {
+    int maxele = arr[0];
+    for (int i = 0; i < n; i++) {
+        if (arr[i] > maxele) {
+            maxele = arr[i];
+        }
+    }
+    return maxele;
+}
+
+int main() {
+    int n;
+    
+    // Get the size of the array from the user
+    cout << "Enter the size of the array: ";
+    cin >> n;
+
+    int arr[n];
+
+    // Get array elements from the user
+    cout << "Enter the elements of the array: ";
+    for (int i = 0; i < n; i++) {
+        cin >> arr[i];
+    }
+
+    // Find the maximum element in the array
+    int max = findMax(arr, n);
+
+    // Create an array to store the sorted output
+    int output[n];
+
+    // Perform counting sort
+    countingSort(max, n, arr, output);
+
+    // Display the sorted array
+    cout << "Sorted Array: ";
+    for (int i = 0; i < n; i++) {
+        cout << output[i] << " ";
+    }
+
+    return 0;
+}
+```
+
+# Step-by-Step Explanation of the Code
+
+Here is a step-by-step explanation of the above code:
+
+1. The code begins with the inclusion of necessary libraries and namespaces.
+2. The countingSort() function is defined to perform the counting sort algorithm. It takes in four parameters: max (the maximum element in the array), n (the size of the array), arr[] (the input array), and output[] (the array to store the sorted output).
+3. Inside the countingSort() function, an array count[] of size max + 1 is created to store the counts of each element. All elements of count[] are initialized to zero.
+4. The occurrences of each element in the input array arr[] are counted and stored in count[].
+5. The count[] array is modified to store cumulative counts. This step ensures that the elements are placed in their sorted order.
+6. The elements are placed in their sorted order in the output[] array by iterating through the input array in reverse order.
+7. The findMax() function is defined to find the maximum element in the input array. It takes in two parameters: arr[] (the input array) and n (the size of the array). It returns the maximum element.
+8. In the main() function, the size of the array n is obtained from the user.
+9. The elements of the array arr[] are obtained from the user.
+10. The maximum element in the array is found using the findMax() function.
+11. An array output[] of size n is created to store the sorted output.
+12. The counting sort algorithm is performed using the countingSort() function.
+13. The sorted array is displayed to the user.
+
+This code implements the counting sort algorithm to sort an array of integers in ascending order.
+
+# test cases
+
+### example 1 :
+
+**Input :**
+
+Enter the elements of the array separated by space :  0
+
+**Output :**
+
+    Sorted Array :  0 
+
+### example 2 :
+
+**Input :**
+
+Enter the elements of the array separated by space:  9 5 2 7 9 1 5
+
+**Output :**
+
+    Sorted Array :  [1, 2, 5, 5, 7, 9, 9]
+
+**Explanation:**
+
+We'll apply Counting Sort on the input array [9, 5, 2, 7, 9, 1, 5]. In addition to the cumulative counting array, which is [1, 2, 4, 4, 4, 6, 6, 7, 7, 9], the counting array is [1, 1, 2, 0, 0, 2, 0, 1, 0, 2]. What is intended is that the sorted array will be [1, 2, 5, 5, 7, 9, 9]. 
+
+### example 3 :
+
+**Input :**
+
+Enter the elements of the array separated by space: 10 8 63 12 0 3
+
+**Output :**
+
+    Sorted Array : [0, 3, 8, 10, 12, 63]
+
+**Explanation :** 
+
+The counting array for the input array 10 8 63 12 0 3 is [1, 1, 0, 0, 1, 1, ], and the cumulative counting array is [0, 3, 8, 10, 12, 63]. The sorted array is [0, 3, 8, 10, 12, 63], which corresponds to the expected output.
+
+# **Time and Space Complexity Analysis**
+
+Counting Sort has a time complexity of `O(n+k)` and a space complexity of `O(n+k).` Where n is the number of elements in the input array and k is the range of the values in the input array. This makes it efficient and a great choice for sorting large amounts of data.
+
+n the worst case, when the range of values (k) is much larger than the number of elements (n), the space complexity can be dominated by the **count** array
+
+# **real-time applications**
+
+Counting Sort is a simple and efficient sorting algorithm that is well-suited for specific real-time applications where certain conditions are met. Its effectiveness is primarily dependent on the range of input values. Here are some real-time applications where Counting Sort can be useful:
+
+1. **Integer Sorting with Small Range:**
+Counting Sort is most efficient when the range of input values is relatively small compared to the number of elements. It can be used in applications where you need to sort integers with a limited range, such as sorting grades (e.g., A, B, C, D, F) or ages (e.g., 0-100) in educational systems.
+2. **Radix Sort Implementation:**
+Counting Sort is a key component of the Radix Sort algorithm. Radix Sort is used in real-time applications, particularly when sorting large datasets with integer keys, such as sorting records in databases or managing network traffic based on IP addresses.
+3. **Data Preprocessing for Histograms:**
+Counting Sort is useful for preparing data for histogram generation, which is commonly used in data analysis and visualization. It can efficiently count the occurrences of data points within a specific range or category.
+4. **Digital Signal Processing (DSP):**
+In real-time DSP applications, you may need to sort data points within a predefined range, such as audio signal amplitudes or pixel values in image processing. Counting Sort can be applied to efficiently process and sort this type of data.
+5. **Parallel Processing and GPU Computing:**
+Counting Sort can be easily parallelized, making it suitable for GPU (Graphics Processing Unit) computing. In real-time applications like image processing, GPU-accelerated Counting Sort can significantly speed up the sorting process.
+6. **Efficient Sorting in Limited Memory Environments:**
+Counting Sort can be valuable in real-time systems with limited memory resources, such as embedded systems, IoT devices, or microcontrollers. Its memory-efficient nature can be advantageous in such contexts.
+7. **Color Sorting in Computer Vision:**
+In computer vision applications, colors are often represented as RGB or HSV values. Counting Sort can be applied to sort colors by their individual components (e.g., sorting by hue) or other numeric properties.
+8. **Resource Scheduling in Real-Time Operating Systems (RTOS):**
+In RTOS environments, tasks or processes can be sorted based on their priority levels or execution times using Counting Sort. This aids in efficient task scheduling.
+9. **Data Streaming and Packet Sorting:**
+In network packet processing, data streams can be sorted by packet attributes like source IP address or packet size. Counting Sort can help optimize the handling of incoming data packets.
+10. **Sorting Events or Timestamps:**
+Counting Sort can be used to sort events or timestamps in various real-time applications, such as log file analysis, event-driven systems, and financial trading platforms.
+
+Remember that Counting Sort's suitability depends on the specific requirements of your real-time application, and it may not be the best choice for all sorting scenarios. It excels when you have a limited range of integer values to sort and can be an excellent choice in the right context.
\ No newline at end of file
diff --git a/STRINGS/EASY/REVERSE STRING.MD b/STRINGS/EASY/REVERSE STRING.MD
new file mode 100644
index 00000000..1a7f3689
--- /dev/null
+++ b/STRINGS/EASY/REVERSE STRING.MD	
@@ -0,0 +1,198 @@
+# **Reverse String**
+
+In programming, reversing a string means changing the order of its characters. For instance, "olleH" would be the result of reversing the string "Hello". In many programming languages, reversing a string is a common task that can be applied to a variety of problems.
+
+## **Introduction to Reverse String**
+
+Reversing a string can be done in a variety of ways, from basic iterative processes to advanced methods. The programming language being used and the demands of the particular challenge may influence the solution that is selected.
+
+One of the main concepts in programming that may help in the development of problem-solving abilities is the ability to reverse a string.
+
+Reversing a string can be done easily by iterating through the characters and appending them to a new string in the opposite order. Depending on the programming language, either a loop or an integrated string manipulation method can be used to do this. Recursion is an alternative strategy in which the function calls itself to reverse the original string's substrings. Both approaches are capable of producing the intended outcome and are implementable in accordance with the particular needs of the current problem.
+
+## **Overview of Reverse String**
+
+Reversing a string involves changing the order of its characters. It is a common task in programming and can be useful in solving various problems. There are multiple approaches to reverse a string, including iterative methods and recursion. The chosen method depends on the programming language and the specific problem requirements. Reversing a string is a fundamental concept in programming and helps in developing problem-solving skills.
+
+## **Code**
+
+### PYTHON
+
+```python
+
+# Copyrights to venkys.io
+#  For more information, visit venkys.io
+# Write a function that reverses a string. The input string is given as an array of characters s.
+# time Complexity :O(n/2),
+# Space Complexity :O(1)
+
+# Example 1:
+
+# Input: s = ["h","e","l","l","o"]
+# Output: ["o","l","l","e","h"]
+
+# Example 2:
+
+# Input: s = ["H","a","n","n","a","h"]
+# Output: ["h","a","n","n","a","H"]
+
+# Function to reverse a string
+def reverse_string(input_string):
+    # Using slicing to reverse the string
+    reversed_string = input_string[::-1]
+    return reversed_string
+
+# Getting user input
+user_input = input()
+
+# Reversing the user input using the reverse_string function
+result = reverse_string(user_input)
+
+# Displaying the reversed string
+print(result)
+
+```
+
+### Step-by-Step Explanation
+
+1. The code begins with the definition of a function called reverse_string, which takes an input string as a parameter.
+2. Inside the function, the input string is reversed using slicing. The syntax input_string[::-1] reverses the string by accessing its elements in reverse order. The reversed string is stored in the variable reversed_string.
+3. The function then returns the reversed string.
+4. Next, the code prompts the user to enter a string by using the input() function. The user's input is stored in the variable user_input.
+5. The reverse_string function is called with user_input as the argument, and the result is stored in the variable result.
+6. Finally, the code displays the reversed string by printing "Reversed String:" followed by the value of result.
+
+This code demonstrates how to reverse a string by modifying the input array in-place, without using any additional memory.
+
+### JAVA
+
+```java
+// Copyrights to venkys.io
+// For more information, visit - venkys.io
+// time Complexity :O(n/2),
+// Space Complexity :O(1)
+
+// Example 1:
+
+// Input: s = ["h","e","l","l","o"]
+// Output: ["o","l","l","e","h"]
+
+import java.util.Scanner;
+
+public class ReverseString {
+    // Function to reverse a string
+    public static String reverseString(String inputString) {
+        // Using StringBuilder to efficiently reverse the string
+        StringBuilder reversedString = new StringBuilder(inputString);
+        reversedString.reverse();
+        return reversedString.toString();
+    }
+
+    public static void main(String[] args) {
+        // Getting user input
+        Scanner scanner = new Scanner(System.in);
+        String userInput = scanner.nextLine();
+
+        // Reversing the user input using the reverseString function
+        String result = reverseString(userInput);
+
+        // Displaying the reversed string
+        System.out.println(result);
+    }
+}
+```
+
+### Step-by-Step Explanation
+
+1. The code defines a class named "ReverseString".
+2. Inside the "ReverseString" class, there is a function named "reverseString" that takes an input String as a parameter and returns a reversed string.
+3. The function uses a StringBuilder to efficiently reverse the inputString. It initializes a StringBuilder object with the inputString and then calls the reverse() method on it. The reversed string is then converted back to a regular string using the toString() method of the StringBuilder class.
+4. The main() method is where the program execution starts. It prompts the user to enter a string and reads the input using the Scanner class.
+5. The main() method calls the reverseString() function, passing the user input as an argument, and stores the result in a variable named "result".
+6. Finally, the program displays the reversed string by printing the "Reversed String: " followed by the value of the "result" variable.
+7. The code ends with a closing curly brace for the "ReverseString" 
+
+### C++
+
+```cpp
+// Copyrights to venkys.io
+// For more information, visit venkys.io
+// time Complexity :O(n/2),
+// Space Complexity :O(1)
+
+// Input: s = ["H","a","n","n","a","h"]
+// Output: ["h","a","n","n","a","H"]
+
+#include <iostream>
+#include <string>
+
+using namespace std;
+
+// Function to reverse a string
+void Reverse(const string& inputString) {
+    // Loop through the characters in reverse order and print them
+    for (int i = inputString.length() - 1; i >= 0; i--) {
+        cout << inputString[i];
+    }
+    cout << endl;  // Print a newline after reversing the string
+}
+
+int main() {
+    string userString;
+
+    // Get input from the user
+    getline(cin, userString);
+
+    // Output the original string and its length
+    cout << userString << endl;
+    
+
+    // Reverse the string using the Reverse function
+    Reverse(userString);
+
+    return 0;
+}
+```
+
+### **Step-by-Step Explanation**
+
+1. The code starts with the necessary header files and includes the iostream and string libraries.
+2. The Reverse function is defined, which takes a constant reference to a string as input.
+3. Inside the Reverse function, a for loop is used to iterate through the characters of the input string in reverse order. The loop starts from the last character (inputString.length() - 1) and goes till the first character (0).
+4. Within the loop, each character of the input string is printed.
+5. After the loop, a newline is printed to separate the reversed string from the rest of the output.
+6. In the main function, a string variable userString is declared to store user input.
+7. The user is prompted to enter a string using the cout statement.
+8. The getline function is used to read the input string from the user and store it in the userString variable.
+9. The original string is printed using the cout statement.
+10. The Reverse function is called with the userString as the argument to reverse the string.
+11. Finally, the program returns 0 to indicate successful execution.
+
+
+# **Time And Space Complexity Analysis**
+
+The time complexity of the reverseString  function is O(n/2), where n is the length of the input array. This is because the function iterates through half of the array, swapping the characters at opposite ends. The constant factor of 1/2 is ignored in Big O notation.
+
+## 
+
+The space complexity of the reverseString function is O(1) because it uses only a constant amount of extra memory. The input array is modified in-place, without requiring any additional data structures.
+
+Overall, the time complexity and space complexity of the code are both considered to be optimal.
+
+# **Real-World Applications of Reverse String**
+
+The ability to reverse a string has various real-world applications in programming. Here are some examples:
+
+1. **Text Manipulation**: Reversing a string can be useful for tasks like text encryption, where reversing the characters can provide a form of obfuscation or scrambling.
+2. **Palindrome Detection**: Palindromes are words, phrases, or numbers that read the same backward as forward. Reversing a string and comparing it to the original string can help identify palindromes.
+3. **String Processing**: In certain scenarios, reversing a string can help in processing and analyzing textual data. For example, in natural language processing, reversing the order of words in a sentence can be used as a technique for data augmentation or language modeling.
+4. **User Interface**: Reversing a string can also be utilized in user interface elements, such as displaying text in a mirror or flipped orientation.
+5. **String Parsing**: In some cases, reversing a string can assist in parsing and extracting specific information. For instance, reversing a URL can help identify its top-level domain or extract meaningful components from a complex string.
+
+## Test Cases
+
+- Input: "hello"
+  Output: "olleh"
+
+- Input: "Hannah"
+  Output: "hannaH"
diff --git a/STRINGS/HARD/REGULAR EXPRESSSION MATCHING.MD b/STRINGS/HARD/REGULAR EXPRESSSION MATCHING.MD
new file mode 100644
index 00000000..81fcb04d
--- /dev/null
+++ b/STRINGS/HARD/REGULAR EXPRESSSION MATCHING.MD	
@@ -0,0 +1,336 @@
+# INTRODUCTION TO REGULAR EXPRESSION MATCHING
+
+Regular expression matching (often referred to as regex or regexp matching) is a powerful and flexible way to search, match, and manipulate text based on patterns. A regular expression is a sequence of characters that defines a search pattern. These patterns can include a variety of elements, such as literals, metacharacters, and quantifiers, allowing for complex and flexible text matching..
+
+# OVERVIEW OF REGULAR EXPRESSION MATCHING
+
+The Regular Expression Matching problem involves determining if a given string matches a specified pattern defined by a regular expression. This problem is commonly encountered in string matching, text processing, and pattern recognition tasks. The regular expression specifies a set of rules that the input string must follow for a match to occur.
+
+Given two strings **S** and **P** where **S** consists of only lowercase English alphabets while **P** consists of lowercase English alphabets as well as special characters ‘**.’** and ‘***’,** the task is to implement a function to test regular expression such that:
+
+- `'.'` Matches any single character.
+- `'*'` Matches zero or more of the preceding element.
+
+### **Here's an example to illustrate the Regular Expression Matching problem:**
+
+Let's consider the regular expression **`a*b`**:
+
+- **`a*`**: Zero or more occurrences of the character 'a'.
+- **`b`**: The character 'b'.
+
+Now, suppose we have the following strings:
+
+1. Input: **`"b"`**
+    - Does **`"b"`** match the pattern **`a*b`**?
+    - No, because there are no 'a' characters before 'b'.
+2. Input: **`"aaab"`**
+    - Does **`"aaab"`** match the pattern **`a*b`**?
+    - Yes, because there are zero or more 'a' characters followed by 'b'.
+    - 
+
+This problem can be solved using dynamic programming or recursion with memoization. The idea is to build a table or use memoization to store the results of subproblems, avoiding redundant computations.
+
+# CODE
+
+### PYTHON
+
+```python
+# Copyrights to venkys.io
+# For more information, visit venkys.io
+# time Complexity :   O(m * n),
+# Space Complexity :  O(m * n),
+
+def is_match(user_s, user_p):
+    # Initialize a 2D table to store results of subproblems
+    dp = [[False] * (len(user_p) + 1) for _ in range(len(user_s) + 1)]
+
+    # Empty pattern matches empty string
+    dp[0][0] = True
+
+    # Handle patterns with '*' at the beginning
+    for j in range(1, len(user_p) + 1):
+        if user_p[j - 1] == '*':
+            dp[0][j] = dp[0][j - 2]
+
+    # Build the table using dynamic programming
+    for i in range(1, len(user_s) + 1):
+        for j in range(1, len(user_p) + 1):
+            if user_p[j - 1] == user_s[i - 1] or user_p[j - 1] == '.':
+                dp[i][j] = dp[i - 1][j - 1]
+            elif user_p[j - 1] == '*':
+                dp[i][j] = dp[i][j - 2] or (dp[i - 1][j] if user_s[i - 1] == user_p[j - 2] or user_p[j - 2] == '.' else False)
+
+    return dp[len(user_s)][len(user_p)]
+
+if __name__ == "__main__":
+    # Get input from the user
+    user_s = input()
+    user_p = input()
+
+    # Test the function with user input
+    result = is_match(user_s, user_p)
+
+    # Display the result
+    print(result)
+```
+
+## Step-by-Step Explanation of the Code
+
+1. The code defines a function is_match that takes two parameters: user_s (the user's input string) and user_p (the user's input pattern).
+2. It initializes a 2D table, dp, with dimensions (len(user_s) + 1) x (len(user_p) + 1). This table will store the results of subproblems.
+3. It sets dp[0][0] to True, indicating that an empty pattern matches an empty string.
+4. It handles patterns with '*' at the beginning by setting dp[0][j] to dp[0][j - 2] if user_p[j - 1] == '*'.
+5. It builds the table using dynamic programming. It iterates through user_s and user_p to fill in the table.
+6. If user_p[j - 1] matches user_s[i - 1] or user_p[j - 1] is '.', it sets dp[i][j] to dp[i - 1][j - 1].
+7. If user_p[j - 1] is '*', it sets dp[i][j] to dp[i][j - 2] or (dp[i - 1][j] if user_s[i - 1] == user_p[j - 2] or user_p[j - 2] == '.' else False).
+8. Finally, it returns dp[len(user_s)][len(user_p)], which represents whether the entire string matches the pattern.
+9. The code also includes a main block that prompts the user to enter a string and a pattern. It tests the is_match function with the user's input and prints the result.
+
+### JAVA
+
+```java
+// Copyrights to venkys.io
+// For more information, visit venkys.io
+// time Complexity :   O(m * n),
+// Space Complexity :  O(m * n),
+
+import java.util.Scanner;
+
+public class RegularExpressionMatching {
+    public static boolean isMatch(String s, String p) {
+        // Initialize a 2D table to store results of subproblems
+        boolean[][] dp = new boolean[s.length() + 1][p.length() + 1];
+
+        // Empty pattern matches empty string
+        dp[0][0] = true;
+
+        // Handle patterns with '*' at the beginning
+        for (int j = 1; j <= p.length(); j++) {
+            if (p.charAt(j - 1) == '*') {
+                dp[0][j] = dp[0][j - 2];
+            }
+        }
+
+        // Build the table using dynamic programming
+        for (int i = 1; i <= s.length(); i++) {
+            for (int j = 1; j <= p.length(); j++) {
+                if (p.charAt(j - 1) == s.charAt(i - 1) || p.charAt(j - 1) == '.') {
+                    dp[i][j] = dp[i - 1][j - 1];
+                } else if (p.charAt(j - 1) == '*') {
+                    dp[i][j] = dp[i][j - 2] || (dp[i - 1][j] && (s.charAt(i - 1) == p.charAt(j - 2) || p.charAt(j - 2) == '.'));
+                }
+            }
+        }
+
+        return dp[s.length()][p.length()];
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        // Get user input for the string
+        // System.out.print("Enter a string: ");
+        String userString = scanner.nextLine();
+
+        // Get user input for the pattern
+        // System.out.print("Enter a pattern: ");
+        String userPattern = scanner.nextLine();
+
+        // Test the function with user input
+        boolean result = isMatch(userString, userPattern);
+
+        // Display the result
+        System.out.println(result);
+    }
+}
+
+```
+
+## Step-by-Step Explanation of the Code
+
+1. Import the required libraries and classes. In this case, we are importing the Scanner class from the java.util package.
+2. Define a public class named RegularExpressionMatching.
+3. Create a static method named isMatch that takes two parameters: s (representing the input string) and p (representing the pattern to match against).
+4. Initialize a 2D table named dp (dynamic programming) with dimensions s.length() + 1 and p.length() + 1. This table will store the results of subproblems.
+5. Set the value of dp[0][0] to true, as an empty pattern matches an empty string.
+6. Handle patterns with '*' at the beginning. Iterate through the characters of the pattern. If the current character is '*', set dp[0][j] to dp[0][j - 2].
+7. Build the table using dynamic programming. Iterate through the characters of the string and pattern. For each character, check the following conditions:
+    - If the current pattern character is equal to the current string character or it is '.', set dp[i][j] to dp[i - 1][j - 1].
+    - If the current pattern character is '*', set dp[i][j] to dp[i][j - 2] (considering the '*' as zero occurrence) or check if the previous character in the pattern matches the current character in the string (s.charAt(i - 1) == p.charAt(j - 2)) or the previous character in the pattern is '.' (p.charAt(j - 2) == '.'), and if so, set dp[i][j] to dp[i - 1][j].
+8. Return the value of dp[s.length()][p.length()], which represents whether the entire string matches the pattern.
+9. Define a main method. Create a Scanner object named scanner to read user input.
+10. Prompt the user to enter a string and store the input in the userString variable.
+11. Prompt the user to enter a pattern and store the input in the userPattern variable.
+12. Call the isMatch method with userString and userPattern as arguments and store the result in the result variable.
+13. Print the value of result, which represents whether the string matches the pattern.
+
+## 
+
+### c++
+
+```cpp
+// Copyrights to venkys.io
+// For more information, visit venkys.io
+// time Complexity :   O(m * n),
+// Space Complexity :  O(m * n),
+
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+bool isMatch(const string& s, const string& p) {
+    // Initialize a 2D table to store results of subproblems
+    vector<vector<bool>> dp(s.length() + 1, vector<bool>(p.length() + 1, false));
+
+    // Empty pattern matches empty string
+    dp[0][0] = true;
+
+    // Handle patterns with '*' at the beginning
+    for (int j = 1; j <= p.length(); j++) {
+        if (p[j - 1] == '*') {
+            dp[0][j] = dp[0][j - 2];
+        }
+    }
+
+    // Build the table using dynamic programming
+    for (int i = 1; i <= s.length(); i++) {
+        for (int j = 1; j <= p.length(); j++) {
+            if (p[j - 1] == s[i - 1] || p[j - 1] == '.') {
+                dp[i][j] = dp[i - 1][j - 1];
+            } else if (p[j - 1] == '*') {
+                dp[i][j] = dp[i][j - 2] || (dp[i - 1][j] && (s[i - 1] == p[j - 2] || p[j - 2] == '.'));
+            }
+        }
+    }
+
+    return dp[s.length()][p.length()];
+}
+
+int main() {
+    // Get input from the user
+    string userString, userPattern;
+    // cout << "Enter a string: ";
+    getline(cin, userString);
+    // cout << "Enter a pattern: ";
+    getline(cin, userPattern);
+
+    // Test the function with user input
+    bool result = isMatch(userString, userPattern);
+
+    // Display the result
+    cout << result << endl;
+
+    return 0;
+}
+```
+
+## Step-by-Step Explanation of the Code
+
+1. Import necessary libraries: The code begins by importing the required libraries, including iostream and vector. These libraries will be used for input/output operations and for creating dynamic arrays.
+2. Define the isMatch function: The isMatch function takes two input parameters, s and p, which represent the given string and pattern, respectively. It returns a boolean value indicating whether the string matches the pattern.
+3. Initialize the dynamic programming table: A 2D vector, dp, is initialized to store the results of subproblems. The dimensions of the table are set to s.length() + 1 and p.length() + 1, and all values are initially set to false.
+4. Handle empty pattern and empty string case: The table entry dp[0][0] is set to true since an empty pattern matches an empty string.
+5. Handle patterns with '*' at the beginning: A loop iterates through each character of the pattern starting from the second character. If the current character is '*', the table entry dp[0][j] is set to the value of dp[0][j - 2]. This accounts for the case where '*' matches zero occurrences of the preceding character.
+6. Build the table using dynamic programming: Nested loops iterate through each character of the string and pattern. If the current characters match or if the pattern character is '.', the table entry dp[i][j] is set to the value of dp[i - 1][j - 1]. If the pattern character is '*', the table entry dp[i][j] is set to the result of logical OR operations between dp[i][j - 2] and (dp[i - 1][j] && (s[i - 1] == p[j - 2] || p[j - 2] == '.')). This accounts for the case where '*' matches zero or more occurrences of the preceding character.
+7. Return the result: The function returns the final value of dp[s.length()][p.length()].
+8. Main function: The main function prompts the user to enter a string and a pattern. It then calls the isMatch function with the user input as arguments. The resulting boolean value is stored in the result variable.
+9. Display the result: Finally, the result is displayed by outputting the value of result.
+
+# TEST CASES
+
+### Example 1 :
+
+**Input :**
+
+Enter a string: "abb"
+
+Enter a pattern: "a.*"
+
+**Output :**
+
+          True
+
+**Explanation :**
+
+replace **.** with b then p becomes ab* now replace * with one preceeding character hence p becomes abb.
+
+### Example 2 :
+
+**Input :**
+
+Enter a string: aaaaaa
+
+Enter a pattern: aaaa
+
+**Output :** 
+
+    False
+
+**Explanation :**
+
+ " aaaa" does not match the entire string "aaaaaa".
+
+### 
+
+### Example 3 :
+
+**Input :**
+
+Enter a string: apple123
+
+Enter a pattern: "[^0-9]+
+
+**Output :** 
+
+           False
+
+**Explanation :**
+
+The regular expression "[^0-9]+" matches sequences without digits, but "apple123" contains numeric characters.
+
+# TIME AND SPACE COMPLEXITY :
+
+The time complexity is `O(m * n)`, where m is the length of the input string **s**, and n is the length of the pattern string **p**. This is because there is a nested loop iterating through the lengths of both strings.
+
+1. The outer loop runs for **m + 1** iterations.
+2. The inner loop runs for **n + 1** iterations.
+
+Each iteration involves constant-time operations, so the overall time complexity is O(m * n).
+
+The space complexity is also `O(m * n)` due to the space used by the 2D table .
+
+1. The table has dimensions **(m + 1) x (n + 1)**, where **m** is the length of string **s**, and **n** is the length of pattern **p**.
+2. Each entry in the table stores a boolean value.
+
+Therefore, the space complexity is O(m * n).
+
+## 
+
+# REAL-WORLD APPLICATION FOR REGULAR EXPRESSION MATCHING
+
+Regular expression matching has numerous real-world applications across various domains due to its ability to define and search for complex patterns in text data. Here are some common real-world applications :
+
+1. **Text Search and Validation:**
+    - **Search Engines:** Search engines use regular expressions to match user queries against a vast amount of text data efficiently.
+    - **Text Editors and IDEs:** Text editors and integrated development environments (IDEs) often provide find-and-replace functionality using regular expressions.
+2. **Data Validation and Extraction:**
+    - **Form Validation:** Regular expressions are commonly used to validate user input in forms, such as email addresses, phone numbers, or ZIP codes.
+    - **Log Analysis:** Regular expressions help extract specific information from log files, enabling analysis and troubleshooting.
+3. **String Manipulation and Parsing:**
+    - **Data Cleaning:** Regular expressions are employed to clean and preprocess textual data by removing or replacing specific patterns.
+    - **URL Parsing:** Regular expressions can be used to parse and extract components from URLs, such as extracting the domain or parameters.
+4. **Lexical Analysis and Compilers:**
+    - **Programming Languages:** Regular expressions play a vital role in lexical analysis, where they are used to define tokens in the source code of programming languages.
+    - **Compiler Construction:** Regular expressions are part of the toolkit used in the construction of compilers for parsing and tokenizing code.
+5. **Natural Language Processing (NLP):**
+    - **Named Entity Recognition:** Regular expressions can be used to define patterns for identifying named entities (e.g., names, locations) in text data.
+    - **Text Pattern Matching:** In NLP tasks, regular expressions are applied to match specific linguistic patterns or structures.
+6. **Network Security:**
+    - **Intrusion Detection Systems (IDS):** Regular expressions are used to define patterns of known attack signatures or suspicious network activities in security systems.
+    - **Log Analysis for Security:** Regular expressions aid in extracting relevant information from security logs for analysis and threat detection.
+7. **Web Scraping and Data Extraction:**
+    - **Web Scraping:** Regular expressions are utilized to extract specific data patterns from HTML or other markup languages.
+    - **Data Extraction from Documents:** Regular expressions can be employed to extract structured information from documents in various formats.
+8. **Configuration File Parsing:**
+    - **Parsing Configuration Files:** Regular expressions are used to parse and extract information from configuration files in software applications.
diff --git a/STRINGS/MEDIUM/WORD BREAK.MD b/STRINGS/MEDIUM/WORD BREAK.MD
new file mode 100644
index 00000000..56251eda
--- /dev/null
+++ b/STRINGS/MEDIUM/WORD BREAK.MD	
@@ -0,0 +1,311 @@
+# WORDBREAK PROBLEM
+
+The Word Break Problem is a common problem in computer science and natural language processing. It involves determining if a given string can be segmented into a space-separated sequence of valid words from a dictionary.
+
+# INTRODUCTION OF THE WORD BREAK PROBLEM
+
+The Word Break Problem is a classic dynamic programming problem in computer science. It involves determining whether a given string can be segmented into a space-separated sequence of one or more words, using a given dictionary of words. In other words, the problem is about breaking a string into valid words from a predefined set of words.
+
+# OVERVIEW OF THE WORD BREAK PROBLEM
+
+To solve the Word Break Problem, dynamic programming techniques are commonly employed. The idea is to break down the problem into smaller subproblems and use the solutions of those subproblems to build the solution for the original problem. By efficiently storing and reusing the computed results, dynamic programming algorithms can provide an optimal solution.
+
+Here are the key points of the problem:
+
+**Input:**
+
+- A string s.
+- A dictionary of words wordDict.
+
+**Output:**
+
+- True if s can be segmented into words from wordDict, False otherwise.
+
+### **example:**
+
+**Input:**
+
+- s = "applepie"
+- wordDict = `["apple", "pie", "pen", "pineapple"]`
+
+**Output:**
+
+True
+
+**Explanation:**
+
+There are two valid ways to segment "applepie" into words from the dictionary:
+
+1. "apple pie" - Both "apple" and "pie" are present in the dictionary.
+2. "applepie" - Both "app" and "lepie" are not present in the dictionary, but "applepie" itself is present as a single word in the dictionary.
+
+Therefore, the output is True since at least one valid segmentation exists.
+
+# CODE
+
+### PYTHON
+
+```python
+# Copyrights to venkys.io
+ # For more information, visit venkys.io
+ # Time Complexity:  O(2^n).
+# The space complexity: O(n).
+
+def wordBreak(user_string, user_words):
+    # Create a list to store whether the substring up to index i can be segmented
+    d = [False] * len(user_string)
+
+    for i in range(len(user_string)):
+        for w in user_words:
+            # Check if the current substring is equal to a word and the preceding substring is breakable
+            if w == user_string[i - len(w) + 1:i + 1] and (d[i - len(w)] or i - len(w) == -1):
+                # Mark the current substring as breakable
+                d[i] = True
+
+    return d[-1]
+
+if __name__ == "__main__":
+    # Get user input for the string
+    user_string = input()
+
+    # Get user input for the list of words
+    user_words = input().split()
+
+    # Check if the string can be segmented using the provided words
+    result = wordBreak(user_string, user_words)
+
+    # Display the result
+    if result:
+        print("true")
+    else:
+        print("false")
+
+```
+
+## Step-by-Step Explanation of the Code
+
+1.  the wordBreak function which takes two parameters: user_string and user_words.
+2. Inside the wordBreak function, a list d is created to store whether the substring up to index i can be segmented.
+3. The code then iterates through each index of the user_string using a for loop.
+4. For each index, another loop is used to iterate through each word in the user_words.
+5. The code checks if the current substring is equal to a word and if the preceding substring is breakable.
+6. If both conditions are met, the current substring is marked as breakable by setting the corresponding element in d to True.
+7. Finally, the function returns the last element of d, which indicates whether the entire string can be segmented using the provided words.
+8. Outside the wordBreak function, the code checks if the script is being run directly and prompts the user to enter a string and a list of words.
+9. The wordBreak function is called with the user-provided string and words, and the result is stored in the result variable.
+10. The code then prints the result, indicating whether the true or false  .
+
+This code implements a dynamic programming approach to solve the word break problem, which determines whether a given string can be segmented into words from a provided list.
+
+### JAVA
+
+```java
+/* Copyrights to venkys.io
+  For more information, visit - venky.io
+  Time Complexity:  O(2^n).
+  The space complexity: O(n). */
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Scanner;
+
+public class WordBreak {
+
+    static boolean wordBreak(String s, ArrayList<String> words) {
+        // Create a HashSet for faster word lookup
+        HashSet<String> set = new HashSet<>(words);
+
+        // Dynamic programming array to store if substring up to index i can be segmented
+        boolean[] dp = new boolean[s.length() + 1];
+        dp[0] = true;  // Empty string is always breakable
+
+        for (int i = 1; i <= s.length(); i++) {
+            for (int j = 0; j < i; j++) {
+                // Check if the current substring is equal to a word and the preceding substring is breakable
+                if (dp[j] && set.contains(s.substring(j, i))) {
+                    dp[i] = true;
+                    break;
+                }
+            }
+        }
+
+        return dp[s.length()];
+    }
+
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+
+        // Get user input for the string
+        // System.out.print("Enter a string: ");
+        String userString = scanner.nextLine();
+
+        // Get user input for the list of words
+        // System.out.print("Enter a list of words separated by spaces: ");
+        String[] userWordsArray = scanner.nextLine().split(" ");
+        ArrayList<String> userWords = new ArrayList<>();
+        for (String word : userWordsArray) {
+            userWords.add(word);
+        }
+
+        // Check if the string can be segmented using the provided words
+        if (wordBreak(userString, userWords)) {
+            System.out.println("true");
+        } else {
+            System.out.println("false");
+        }
+    }
+}
+```
+
+## Step-by-Step Explanation of the Code
+
+1. Import required libraries: The code begins by importing the necessary libraries, including ArrayList, HashSet, and Scanner.
+2. Define the wordBreak function: This function takes a string s and an ArrayList of words as parameters. It checks whether the string s can be segmented into words from the provided list. The function returns a boolean value indicating whether the string can be segmented.
+3. Create a HashSet for faster word lookup: A HashSet named set is created to store the words from the provided list. This allows for efficient word lookup during the segmentation process.
+4. Initialize the dynamic programming array: An array dp of boolean values is initialized to store whether a substring up to index i can be segmented. The array is initialized with false values, except for dp[0] which is set to true to indicate that the empty string is always breakable.
+5. Perform dynamic programming: Two nested loops are used to iterate through the string s. The outer loop iterates from 1 to the length of s, representing the end index of the current substring. The inner loop iterates from 0 to the current index, representing the start index of the current substring.
+6. Check if the current substring is breakable: For each substring, the code checks if the preceding substring is breakable (dp[j] is true) and if the current substring is a word present in the HashSet set. If both conditions are met, the dp[i] value is set to true and the loop breaks.
+7. Return the result: Finally, the function returns the value of dp[s.length()], which represents whether the entire string s can be segmented into words.
+8. Implement the main function: The main function is responsible for getting user input and calling the wordBreak function. It prompts the user to enter a string and a list of words separated by spaces. It then converts the user input into an ArrayList and passes it to the wordBreak function.
+9. Print the result: Based on the return value of the wordBreak function, either "TRUE" or "FALSE" is printed to indicate whether the string can be segmented or not.
+
+### C++
+
+```cpp
+// Copyrights to venkys.io
+// For more information, visit venkys.io
+// time Complexity : O(2^n).
+// The space complexity: O(n)..
+
+#include <iostream>
+#include <vector>
+#include <unordered_set>
+#include <sstream>
+
+using namespace std;
+
+bool wordBreak(const string& s, const vector<string>& words) {
+    unordered_set<string> wordSet(words.begin(), words.end());
+
+// Dynamic programming array to store if substring up to index i can be segmented
+    vector<bool> dp(s.length() + 1, false);
+    dp[0] = true;  // Empty string is always breakable
+
+    for (int i = 1; i <= s.length(); i++) {
+        for (int j = 0; j < i; j++) {
+// Check if the current substring is equal to a word and the preceding substring is breakable
+            if (dp[j] && wordSet.count(s.substr(j, i - j))) {
+                dp[i] = true;
+                break;
+            }
+        }
+    }
+
+    return dp[s.length()];
+}
+
+// Get user input for the string
+int main() {
+    string userString;
+    // cout << "Enter a string: ";
+    getline(cin, userString);
+
+			// Get user input for the list of words
+    // cout << "Enter a list of words separated by spaces: ";
+    string word;
+    vector<string> userWords;
+    getline(cin, word);
+    stringstream ss(word);
+    while (ss >> word) {
+        userWords.push_back(word);
+    }
+// Check if the string can be segmented using the provided words
+    if (wordBreak(userString, userWords)) {
+        cout << "true" << endl;
+    } else {
+        cout << "false" << endl;
+    }
+
+    return 0;
+}
+```
+
+## Step-by-Step Explanation of the Code
+
+1. The code begins with the necessary includes for input/output operations, vectors, unordered sets, and string manipulation.
+2. The wordBreak function takes in a string s and a vector of strings words as parameters. It returns a boolean value indicating whether the string s can be broken into words from the words vector.
+3. Inside the wordBreak function, an unordered set called wordSet is created from the words vector. This set will be used to quickly check if a word is present in the words vector.
+4. A vector of booleans called dp is created with a size of s.length() + 1. This vector will be used for dynamic programming to store the breakability of substrings of s.
+5. The first element of the dp vector is set to true because an empty string is always breakable.
+6. Two nested loops are used to iterate through all possible substrings of s. The outer loop iterates over the lengths of the substrings, and the inner loop iterates over the starting positions of the substrings.
+7. For each substring s.substr(j, i - j), the code checks if the substring is present in the wordSet and if the substring starting from position j is breakable (i.e., dp[j] is true).
+8. If both conditions are satisfied, the dp value for the current position i is set to true and the inner loop is exited.
+9. After the loops, the final value of dp[s.length()] represents whether the entire string s can be broken into words from the words vector.
+10. In the main function, the user is prompted to enter a string and a list of words separated by spaces.
+11. The input string and words are stored in variables userString and userWords, respectively.
+12. The wordBreak function is called with userString and userWords as arguments, and the result is printed as "TRUE" or "FALSE" accordingly.
+13. The program ends with a return statement.
+
+## Time Cases :
+
+### EXAMPLE 1 :
+
+**Input :** 
+
+  Enter a string: applepenapple
+
+Enter a list of words separated by spaces: apple pen
+
+**Output :**
+
+      true 
+
+**Explanation:**
+
+The string "applepenapple" can be segmented into "apple", "pen", and "apple," all of which are present in the dictionary.
+
+### EXAMPLE 2 :
+
+**Input :**
+
+ Enter a string :  “ “
+
+Enter a list of words separated by spaces: word break test
+
+**Output :**
+
+                true
+
+**Explanation:**
+
+### EXAMPLE 3 :
+
+**Input :**
+
+Enter a string:  catsandog
+
+Enter a list of words separated by spaces: cats", "dog", "sand", "and", "cat
+
+**Output :**
+
+             False
+
+**Explanation:**
+
+It's not possible to break the string "catsandog" into valid words from the dictionary.
+
+# TIME AND SPACE COMPLEXITY
+The time and space complexity of the provided code for the Word Break Problem can be analyzed as follows:
+
+- **Time Complexity:** The code consists of two nested loops. The outer loop iterates through the characters of the input string, and the inner loop iterates through the words in the provided word list. Therefore, the time complexity can be approximated as `O(n * m),` where n is the length of the input string and m is the number of words in the word list.
+- **Space Complexity:** The code uses a boolean list d to store the intermediate results of whether substrings can be segmented into words. The size of the d list is equal to the length of the input string. Therefore, the space complexity is `O(n),` where n is the length of the input string.
+
+# REAL-WORLD APPLICATION FOR WORDBREAK PROBLEM
+
+The Word Break Problem has several real-world applications in computer science and natural language processing. Here are a few examples:
+
+1. **Spell Checking:** In text editors or word processors, the Word Break Problem can be used to check the spelling of words by breaking the input text into individual words and comparing them against a dictionary of valid words. This helps identify and correct spelling mistakes.
+2. **Search Engines**: Search engines use the Word Break Problem to process user queries and match them with relevant documents. By breaking down the query into individual words and matching them against indexed words, search engines can retrieve accurate search results.
+3. **Sentiment Analysis:** The Word Break Problem is used in sentiment analysis tasks, where the goal is to determine the sentiment or emotion associated with a given text. By breaking down the text into words and analyzing the sentiment of each word, sentiment analysis models can classify the overall sentiment of the text.
+4. **Machine Translation:** In machine translation systems, the Word Break Problem is crucial for breaking down sentences in the source language into individual words and then translating them into the target language. This helps maintain the correct word order and structure during the translation process.
+5. **Text Segmentation:** Text segmentation is an important task in natural language processing, where the goal is to divide a given text into meaningful segments, such as sentences or paragraphs. The Word Break Problem can be used to segment the text by breaking it into individual words and then grouping them based on punctuation or other criteria.