updated as per your sugeestion

Author: Vipullakum007

dsa-solutions/gfg-solutions/0023-Find-triplet-with-zero-sum.md

@@ -55,8 +55,9 @@ You don't need to read input or print anything. Your task is to complete the fun
 **Expected Auxiliary Space:** O(1)
 
 ### Constraints
-- 1 ≤ N ≤ 10^5  
-- -10^3 ≤ arr[i] ≤ 10^3
+
+- $1 ≤ N ≤ 10^5$
+- $-10^3 ≤ arr[i] ≤ 10^3$
 
 ## Solution
 

dsa-solutions/gfg-solutions/0024-minimum-indexed-character.md

@@ -50,12 +50,13 @@ There are no characters that are common in "patt" and "str".
 ### Your Task
 You only need to complete the function `minIndexChar()` that returns the index of the answer in `str` or returns `-1` if no character of `patt` is present in `str`.
 
-**Expected Time Complexity:** O(N)  
-**Expected Auxiliary Space:** O(Number of distinct characters)
+**Expected Time Complexity:** $O(N)$ 
+**Expected Auxiliary Space:** $O(Number of distinct characters)$
 
 ### Constraints
-- 1 ≤ |str|,|patt| ≤ 10^5
-- 'a' ≤ str[i], patt[i] ≤ 'z'
+
+- $1 ≤ |str|,|patt| ≤ 10^5$
+- $'a' ≤ str[i], patt[i] ≤ 'z'$
 
 ## Solution
 
@@ -169,8 +170,8 @@ class Solution {
 
 ### Complexity Analysis
 
-- **Time Complexity:** O(N), where N is the length of the string `str`. We iterate through each character in `patt` and use the `find` or `indexOf` method, which runs in O(N) time.
-- **Space Complexity:** O(1), as we only use a constant amount of extra space for variables.
+- **Time Complexity:** $O(N)$, where N is the length of the string `str`. We iterate through each character in `patt` and use the `find` or `indexOf` method, which runs in $O(N)$ time.
+- **Space Complexity:** $O(1)$, as we only use a constant amount of extra space for variables.
 
 ---
 

dsa-solutions/gfg-solutions/Easy problems/bfs-of-graph.md

@@ -44,11 +44,11 @@ Starting from 0, it will go to 1 then 2, thus BFS will be 0 1 2.
 
 You don't need to read input or print anything. Your task is to complete the function `bfsOfGraph()` which takes the integer `V` denoting the number of vertices and adjacency list as input parameters and returns a list containing the BFS traversal of the graph starting from the 0th vertex from left to right.
 
-**Expected Time Complexity:** O(V + E)  
-**Expected Auxiliary Space:** O(V)
+**Expected Time Complexity:** $ O(V + E) $ 
+**Expected Auxiliary Space:** $O(V)$
 
 **Constraints**
-- 1 ≤ V, E ≤ 10^4
+- $ 1 ≤ V, E ≤ 10^4 $
 
 ## Solution
 
@@ -213,8 +213,8 @@ class Solution {
 
 The provided solutions efficiently perform a Breadth First Search (BFS) traversal of a directed graph. By starting from the 0th vertex and using a queue to manage the traversal, the algorithms ensure that all reachable vertices are visited in the correct order. The solutions operate in O(V + E) time and use O(V) space complexity, where V and E are the numbers of vertices and edges in the graph, respectively.
 
-**Time Complexity:** O(V + E)  
-**Auxiliary Space:** O(V)
+**Time Complexity:** $ O(V + E)  $
+**Auxiliary Space:** $ O(V)$
 
 ## References
 

dsa-solutions/gfg-solutions/Easy problems/reverse-a-doubly-linked-list.md

@@ -45,12 +45,12 @@ After reversing the list, elements are 196 <--> 59 <--> 122 <--> 75.
 ### Your Task
 Your task is to complete the given function `reverseDLL()`, which takes head reference as an argument and reverses the elements in-place such that the tail becomes the new head and all pointers are pointing in the right order. You need to return the new head of the reversed list.
 
-**Expected Time Complexity:** O(N)  
-**Expected Auxiliary Space:** O(1)
+**Expected Time Complexity:** $ O(N)$  
+**Expected Auxiliary Space:** $O(1)$
 
 ### Constraints
-1 ≤ number of nodes ≤ 10^4  
-0 ≤ value of nodes ≤ 10^4
+- $ 1 ≤ number of nodes ≤ 10^4 $
+- $ 0 ≤ value of nodes ≤ 10^4 $
 
 ## Solution
 
@@ -155,8 +155,8 @@ class Solution {
 
 ### Complexity Analysis
 
-- **Time Complexity:** O(N), where N is the number of elements in the doubly linked list. We traverse the entire list once.
-- **Space Complexity:** O(1), as we only use a constant amount of extra space for pointers.
+- **Time Complexity:** $ O(N),$ where N is the number of elements in the doubly linked list. We traverse the entire list once.
+- **Space Complexity:** $O(1)$, as we only use a constant amount of extra space for pointers.
 
 ---
 

dsa-solutions/gfg-solutions/Easy problems/reverse-a-linked-list.md

@@ -45,11 +45,11 @@ After reversing the list, elements are 10->9->8->7->2.
 ### Your Task
 The task is to complete the function `reverseList()` with head reference as the only argument and should return the new head after reversing the list.
 
-**Expected Time Complexity:** O(N)  
-**Expected Auxiliary Space:** O(1)
+**Expected Time Complexity:** $ O(N) $ 
+**Expected Auxiliary Space:** $ O(1) $
 
 ### Constraints
-1 ≤ N ≤ 10^4
+- $ 1 ≤ N ≤ 10^4 $
 
 ## Solution
 
@@ -178,8 +178,8 @@ function reverseList(head: ListNode | null): ListNode | null {
 
 ### Complexity Analysis
 
-- **Time Complexity:** O(N), where N is the number of nodes in the linked list. We traverse the entire list once.
-- **Space Complexity:** O(1), as we only use a constant amount of extra space for pointers.
+- **Time Complexity:** $ O(N) $, where N is the number of nodes in the linked list. We traverse the entire list once.
+- **Space Complexity:** $ O(1) $, as we only use a constant amount of extra space for pointers.
 
 ---
 

dsa-solutions/gfg-solutions/Easy problems/square-root.md

@@ -39,11 +39,11 @@ Explanation: Since 4 is a perfect square, its square root is 2.
 
 You don't need to read input or print anything. The task is to complete the function `floorSqrt()` which takes `x` as the input parameter and returns its square root. Note: Try solving the question without using the sqrt function. The value of `x` ≥ 0.
 
-**Expected Time Complexity:** O(log N)  
-**Expected Auxiliary Space:** O(1)
+**Expected Time Complexity:** $ O(log N)  $
+**Expected Auxiliary Space:** $ O(1) $
 
 **Constraints**
-- 1 ≤ x ≤ 10^7
+- $ 1 ≤ x ≤ 10^7 $
 
 ## Solution
 
@@ -187,10 +187,10 @@ class Solution {
 
 ## Complexity Analysis
 
-The provided solutions efficiently find the floor value of the square root of a given integer `x` using binary search. This approach ensures a time complexity of O(log N) and an auxiliary space complexity of O(1). The algorithms are designed to handle large values of `x` up to 10^7 efficiently without relying on built-in square root functions.
+The provided solutions efficiently find the floor value of the square root of a given integer `x` using binary search. This approach ensures a time complexity of $ O(log N) and an auxiliary space complexity of $ O(1) $. The algorithms are designed to handle large values of `x` up to 10^7 efficiently without relying on built-in square root functions.
 
-**Time Complexity:** O(log N)  
-**Auxiliary Space:** O(1)
+**Time Complexity:** $ O(log N)  $
+**Auxiliary Space:** $ O(1) $
 
 ---