diff --git a/dsa-solutions/gfg-solutions/Easy problems/square-root.md b/dsa-solutions/gfg-solutions/Easy problems/square-root.md
index c249e2811..47f866b73 100644
--- a/dsa-solutions/gfg-solutions/Easy problems/square-root.md	
+++ b/dsa-solutions/gfg-solutions/Easy problems/square-root.md	
@@ -1,193 +1,194 @@
----
-id: square-root
-title: Square Root
-sidebar_label: Square-Root
-tags:
-  - Math
-  - Binary Search
-description: "This document provides solutions to the problem of finding the Square Root of an integer."
----
-
-## Problem
-
-Given an integer `x`, find the square root of `x`. If `x` is not a perfect square, then return the floor value of √x.
-
-### Examples
-
-**Example 1:**
-
-```
-Input: x = 5
-Output: 2
-Explanation: Since 5 is not a perfect square, the floor of the square root of 5 is 2.
-```
-
-**Example 2:**
-
-```
-Input: x = 4
-Output: 2
-Explanation: Since 4 is a perfect square, its square root is 2.
-```
-
-### Your Task
-
-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)$
-
-**Constraints**
-
-- `1 ≤ x ≤ 10^7`
-
-## Solution
-
-### Intuition & Approach
-
-To find the square root of a number without using the built-in `sqrt` function, we can use binary search. This approach leverages the fact that the square root of `x` must lie between `0` and `x`. By repeatedly narrowing down the range using binary search, we can efficiently find the floor value of the square root.
-
-### Implementation
-
-<Tabs>
-  <TabItem value="python" label="Python">
-
-```python
-class Solution:
-    def floorSqrt(self, x: int) -> int:
-        if x == 0 or x == 1:
-            return x
-        start, end = 1, x
-        ans = 0
-        while start <= end:
-            mid = (start + end) // 2
-            if mid * mid == x:
-                return mid
-            if mid * mid < x:
-                start = mid + 1
-                ans = mid
-            else:
-                end = mid - 1
-        return ans
-```
-
-  </TabItem>
-  <TabItem value="java" label="Java">
-
-```java
-class Solution {
-    long floorSqrt(long x) {
-        if (x == 0 || x == 1) {
-            return x;
-        }
-        long start = 1, end = x, ans = 0;
-        while (start <= end) {
-            long mid = (start + end) / 2;
-            if (mid * mid == x) {
-                return mid;
-            }
-            if (mid * mid < x) {
-                start = mid + 1;
-                ans = mid;
-            } else {
-                end = mid - 1;
-            }
-        }
-        return ans;
-    }
-}
-```
-
-  </TabItem>
-  <TabItem value="cpp" label="C++">
-
-```cpp
-class Solution {
-public:
-    long long int floorSqrt(long long int x) {
-        if (x == 0 || x == 1)
-            return x;
-        long long int start = 1, end = x, ans = 0;
-        while (start <= end) {
-            long long int mid = (start + end) / 2;
-            if (mid * mid == x)
-                return mid;
-            if (mid * mid < x) {
-                start = mid + 1;
-                ans = mid;
-            } else {
-                end = mid - 1;
-            }
-        }
-        return ans;
-    }
-};
-```
-
-  </TabItem>
-  <TabItem value="javascript" label="JavaScript">
-
-```javascript
-class Solution {
-  floorSqrt(x) {
-    if (x === 0 || x === 1) {
-      return x;
-    }
-    let start = 1,
-      end = x,
-      ans = 0;
-    while (start <= end) {
-      let mid = Math.floor((start + end) / 2);
-      if (mid * mid === x) {
-        return mid;
-      }
-      if (mid * mid < x) {
-        start = mid + 1;
-        ans = mid;
-      } else {
-        end = mid - 1;
-      }
-    }
-    return ans;
-  }
-}
-```
-
-  </TabItem>
-  <TabItem value="typescript" label="TypeScript">
-
-```typescript
-class Solution {
-  floorSqrt(x: number): number {
-    if (x === 0 || x === 1) {
-      return x;
-    }
-    let start = 1,
-      end = x,
-      ans = 0;
-    while (start <= end) {
-      let mid = Math.floor((start + end) / 2);
-      if (mid * mid === x) {
-        return mid;
-      }
-      if (mid * mid < x) {
-        start = mid + 1;
-        ans = mid;
-      } else {
-        end = mid - 1;
-      }
-    }
-    return ans;
-  }
-}
-```
-
-  </TabItem>
-</Tabs>
-
-## 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.
-
-**Time Complexity:** $O(log N)$
-**Auxiliary Space:** $O(1)$
+---
+---
+id: square-root
+title: Square Root
+sidebar_label: Square-Root
+tags:
+  - Math
+  - Binary Search
+description: "This document provides solutions to the problem of finding the Square Root of an integer."
+---
+
+## Problem
+
+Given an integer `x`, find the square root of `x`. If `x` is not a perfect square, then return the floor value of √x.
+
+### Examples
+
+**Example 1:**
+
+```
+Input: x = 5
+Output: 2
+Explanation: Since 5 is not a perfect square, the floor of the square root of 5 is 2.
+```
+
+**Example 2:**
+
+```
+Input: x = 4
+Output: 2
+Explanation: Since 4 is a perfect square, its square root is 2.
+```
+
+### Your Task
+
+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)$
+
+**Constraints**
+
+- `1 ≤ x ≤ 10^7`
+
+## Solution
+
+### Intuition & Approach
+
+To find the square root of a number without using the built-in `sqrt` function, we can use binary search. This approach leverages the fact that the square root of `x` must lie between `0` and `x`. By repeatedly narrowing down the range using binary search, we can efficiently find the floor value of the square root.
+
+### Implementation
+
+<Tabs>
+  <TabItem value="python" label="Python">
+
+```python
+class Solution:
+    def floorSqrt(self, x: int) -> int:
+        if x == 0 or x == 1:
+            return x
+        start, end = 1, x
+        ans = 0
+        while start <= end:
+            mid = (start + end) // 2
+            if mid * mid == x:
+                return mid
+            if mid * mid < x:
+                start = mid + 1
+                ans = mid
+            else:
+                end = mid - 1
+        return ans
+```
+
+  </TabItem>
+  <TabItem value="java" label="Java">
+
+```java
+class Solution {
+    long floorSqrt(long x) {
+        if (x == 0 || x == 1) {
+            return x;
+        }
+        long start = 1, end = x, ans = 0;
+        while (start <= end) {
+            long mid = (start + end) / 2;
+            if (mid * mid == x) {
+                return mid;
+            }
+            if (mid * mid < x) {
+                start = mid + 1;
+                ans = mid;
+            } else {
+                end = mid - 1;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+  </TabItem>
+  <TabItem value="cpp" label="C++">
+
+```cpp
+class Solution {
+public:
+    long long int floorSqrt(long long int x) {
+        if (x == 0 || x == 1)
+            return x;
+        long long int start = 1, end = x, ans = 0;
+        while (start <= end) {
+            long long int mid = (start + end) / 2;
+            if (mid * mid == x)
+                return mid;
+            if (mid * mid < x) {
+                start = mid + 1;
+                ans = mid;
+            } else {
+                end = mid - 1;
+            }
+        }
+        return ans;
+    }
+};
+```
+
+  </TabItem>
+  <TabItem value="javascript" label="JavaScript">
+
+```javascript
+class Solution {
+  floorSqrt(x) {
+    if (x === 0 || x === 1) {
+      return x;
+    }
+    let start = 1,
+      end = x,
+      ans = 0;
+    while (start <= end) {
+      let mid = Math.floor((start + end) / 2);
+      if (mid * mid === x) {
+        return mid;
+      }
+      if (mid * mid < x) {
+        start = mid + 1;
+        ans = mid;
+      } else {
+        end = mid - 1;
+      }
+    }
+    return ans;
+  }
+}
+```
+
+  </TabItem>
+  <TabItem value="typescript" label="TypeScript">
+
+```typescript
+class Solution {
+  floorSqrt(x: number): number {
+    if (x === 0 || x === 1) {
+      return x;
+    }
+    let start = 1,
+      end = x,
+      ans = 0;
+    while (start <= end) {
+      let mid = Math.floor((start + end) / 2);
+      if (mid * mid === x) {
+        return mid;
+      }
+      if (mid * mid < x) {
+        start = mid + 1;
+        ans = mid;
+      } else {
+        end = mid - 1;
+      }
+    }
+    return ans;
+  }
+}
+```
+
+  </TabItem>
+</Tabs>
+
+## 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.
+
+**Time Complexity:** $O(log N)$
+**Auxiliary Space:** $O(1)$
\ No newline at end of file
diff --git a/dsa-solutions/lc-solutions/0100-0199/0138-copy-list-with-random-pointer.md b/dsa-solutions/lc-solutions/0100-0199/0138-copy-list-with-random-pointer.md
index af38b51f5..39b957a96 100644
--- a/dsa-solutions/lc-solutions/0100-0199/0138-copy-list-with-random-pointer.md
+++ b/dsa-solutions/lc-solutions/0100-0199/0138-copy-list-with-random-pointer.md
@@ -6,8 +6,7 @@ tags:
   - Java
   - Python
   - C++
-  - JavaScript
-  
+  - JavaScript  
 description: "This is a solution to the Copy List with Random Pointer problem on LeetCode."
 ---
 
@@ -37,13 +36,16 @@ Output: [[7,null],[13,0],[11,4],[10,2],[1,0]]
 ```
 Input: head = [[1,1],[2,1]]
 Output: [[1,1],[2,1]]
-
 ```
 
----
+### Constraints:
 
-## Solution for Copy List with Random Pointer
+- The number of nodes in the list is in the range [0, 1000].
+- `-10000 <= Node.val <= 10000`
+- Node.random is null or is pointing to some node in the linked list.
+---
 
+##  Approach to Solve the Copy List with Random Pointer Problem
 
 ### Understand the Problem:
 
diff --git a/dsa-solutions/lc-solutions/1100-1199/1100-find-k-length-substrings-with-no-repeated-characters.md b/dsa-solutions/lc-solutions/1100-1199/1100-find-k-length-substrings-with-no-repeated-characters.md
new file mode 100644
index 000000000..e69de29bb