update

Author: Chanda-Abdul

✅ Pattern 02: Two Pointers.md

@@ -106,9 +106,9 @@ pair_with_targetsum([3, 3], 6)//[0, 1]
 ## Remove Duplicates (easy)
 https://leetcode.com/problems/remove-duplicates-from-sorted-array/
 
-> Given an array of sorted numbers, <b>remove all duplicates</b> from it. You should <b>not use any extra space</b>; after removing the duplicates in-place return the length of the subarray that has no duplicate in it.
+> Given an array of sorted numbers, <b>remove all duplicates</b> from it. You should <b>not use any extra space</b>; after removing the duplicates </i>in-place</i> return the length of the subarray that has no duplicate in it.
 
-In this problem, we need to remove the duplicates in-place such that the resultant length of the array remains sorted. As the input array is sorted, therefore, one way to do this is to shift the elements left whenever we encounter duplicates. In other words, we will keep one pointer for iterating the array and one pointer for placing the next non-duplicate number. So our algorithm will be to iterate the array and whenever we see a non-duplicate number we move it next to the last non-duplicate number we’ve seen.
+In this problem, we need to remove the duplicates </i>in-place</i> such that the resultant length of the array remains sorted. As the input array is sorted, therefore, one way to do this is to shift the elements left whenever we encounter duplicates. In other words, we will keep one pointer for iterating the array and one pointer for placing the next non-duplicate number. So our algorithm will be to iterate the array and whenever we see a non-duplicate number we move it next to the last non-duplicate number we’ve seen.
 
 * Assume the input is sorted
 ````js
@@ -141,7 +141,7 @@ removeDuplicates([2, 2, 2, 11])//2, The first two elements after removing the du
 ### Remove Element
 https://leetcode.com/problems/remove-element/
 
-> Given an unsorted array of numbers and a target `key`, remove all instances of `key` in-place and return the new length of the array.
+> Given an unsorted array of numbers and a target `key`, remove all instances of `key` </i>in-place</i> and return the new length of the array.
 
 ````js
 function removeElement(arr, key) {
@@ -388,7 +388,7 @@ tripletWithSmallerSum ([], 0)//0
 tripletWithSmallerSum ([0], 0)//0
 ````
 - Sorting the array will take `O(N * logN)`. The `searchPair()` will take `O(N)`. So, overall `searchTriplets()` will take `O(N * logN + N^2)`, which is asymptotically equivalent to `O(N^2)`.
-- The space complexity of the above algorithm will be `O(N)` which is required for sorting if we are not using an in-place sorting algorithm.
+- The space complexity of the above algorithm will be `O(N)` which is required for sorting if we are not using an </i>in-place</i> sorting algorithm.
 
 > Write a function to return the list of all such triplets instead of the count. How will the time complexity change in this case?
 
@@ -471,7 +471,7 @@ findSubarrays([10, 5, 2, 6], 100)//The 8 subarrays that have product less than 1
 ## Dutch National Flag Problem (medium)
 https://leetcode.com/problems/sort-colors/
 
-> Given an array containing `0`s, `1`s and `2`s, sort the array in-place. You should treat numbers of the array as objects, hence, we can’t count `0`s, `1`s, and `2`s to recreate the array.
+> Given an array containing `0`s, `1`s and `2`s, sort the array </i>in-place</i>. You should treat numbers of the array as objects, hence, we can’t count `0`s, `1`s, and `2`s to recreate the array.
 
 The flag of the Netherlands consists of three colors: red, white and blue; and since our input array also consists of three different numbers that is why it is called <b>Dutch National Flag problem</b>.
 

✅ Pattern 03: Fast & Slow pointers.md

@@ -223,7 +223,7 @@ https://leetcode.com/problems/happy-number/
 
 Any number will be called a <b>happy number</b> if, after repeatedly replacing it with a number equal to the <b>sum of the square of all of its digits, leads us to number `1`</b>. All other <b>(not-happy)</b> numbers will never reach `1`. Instead, they will be stuck in a cycle of numbers which does not include `1`.
 
-The process, defined above, to find out if a number is a <b>happy number</b> or not, always ends in a cycle. If the number is a <b>happy number</b>, the process will be stuck in a cycle on number ‘1,’ and if the number is not a <b>happy number</b> then the process will be stuck in a cycle with a set of numbers. As we saw in Example-2 while determining if ‘12’ is a <b>happy number</b> or not, our process will get stuck in a cycle with the following numbers: `89 -> 145 -> 42 -> 20 -> 4 -> 16 -> 37 -> 58 -> 89`
+The process, defined above, to find out if a number is a <b>happy number</b> or not, always ends in a cycle. If the number is a <b>happy number</b>, the process will be stuck in a cycle on number `1`, and if the number is not a <b>happy number</b> then the process will be stuck in a cycle with a set of numbers. As we saw in Example-2 while determining if `12` is a <b>happy number</b> or not, our process will get stuck in a cycle with the following numbers: `89 -> 145 -> 42 -> 20 -> 4 -> 16 -> 37 -> 58 -> 89`
 
 We saw in the <b>LinkedList Cycle</b> problem that we can use the <b>Fast & Slow</b> pointers method to find a cycle among a set of elements. As we have described above, each number will definitely have a cycle. Therefore, we will use the same <i>fast</i> & <i>slow pointer</i> strategy to find the cycle and once the cycle is found, we will see if the cycle is stuck on number `1` to find out if the number is happy or not.
 
@@ -281,7 +281,7 @@ function findSquareSum(num) {
 11. 1² + 6² = 1 + 36 = 37
 12. 3² + 7² = 9 + 49 = 58
 13. 5² + 8²= 25 + 64 = 89
-Step ‘13’ leads us back to step ‘5’ as the number becomes equal to ‘89’, this means that we can never reach `1`, therefore, ‘12’ is not a <b>happy number</b>.
+Step `13` leads us back to step `5` as the number becomes equal to `89’, this means that we can never reach `1`, therefore, `12` is not a <b>happy number</b>.
 
 `findHappyNumber(19)//true`
 
@@ -298,8 +298,8 @@ Step ‘13’ leads us back to step ‘5’ as the number becomes equal to ‘89
 - The time complexity of the algorithm is difficult to determine. However we know the fact that all <b>unhappy number</b>s eventually get stuck in the cycle: 4 -> 16 -> 37 -> 58 -> 89 -> 145 -> 42 -> 20 -> 4
 
 This sequence behavior tells us two things:
-1. If the number `N` is less than or equal to 1000, then we reach the cycle or `1` in at most 1001 steps.
-2. For `N > 1000`, suppose the number has `M` digits and the next number is `N1`. From the above Wikipedia link, we know that the sum of the squares of the digits of `N` is at most 9²M, or `81M`(this will happen when all digits of `N` are `9`).
+1. If the number `N` is less than or equal to `1000`, then we reach the cycle or `1` in at most `1001` steps.
+2. For `N > 1000`, suppose the number has `M` digits and the next number is `N1`. From the above Wikipedia link, we know that the sum of the squares of the digits of `N` is at most `9²M`, or `81M`(this will happen when all digits of `N` are `9`).
 
 This means:
 1. `N1 < 81M`
@@ -458,9 +458,9 @@ console.log(`Is palindrome: ${isPalindromicLinkedList(head)}`)
 https://leetcode.com/problems/reorder-list/
 
 
-> Given the head of a Singly <b>LinkedList</b>, write a method to modify the <b>LinkedList</b> such that the <b>nodes from the second half of the <b>LinkedList</b> are inserted alternately to the nodes from the first half in reverse order</b>. So if the <b>LinkedList</b> has nodes 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> null, your method should return 1 -> 6 -> 2 -> 5 -> 3 -> 4 -> null.
+> Given the head of a Singly <b>LinkedList</b>, write a method to modify the <b>LinkedList</b> such that the <b>nodes from the second half of the <b>LinkedList</b> are inserted alternately to the nodes from the first half in reverse order</b>. So if the <b>LinkedList</b> has nodes `1 -> 2 -> 3 -> 4 -> 5 -> 6 -> null`, your method should return `1 -> 6 -> 2 -> 5 -> 3 -> 4 -> null`.
 >
-> Your algorithm should not use any extra space and the input <b>LinkedList</b> should be modified in-place.
+> Your algorithm should not use any extra space and the input <b>LinkedList</b> should be modified </i>in-place</i>.
 
 ### Example 1:
 ````
@@ -561,7 +561,7 @@ head.printList()
 ## 🌟 Cycle in a Circular Array (hard)
 https://leetcode.com/problems/circular-array-loop/
 
-We are given an array containing positive and negative numbers. Suppose the array contains a number ‘M’ at a particular index. Now, if ‘M’ is positive we will move forward ‘M’ indices and if ‘M’ is negative move backwards ‘M’ indices. You should assume that the <b>array is circular</b> which means two things:
+We are given an array containing positive and negative numbers. Suppose the array contains a number `M` at a particular index. Now, if `M` is positive we will move forward `M` indices and if `M` is negative move backwards `M` indices. You should assume that the <b>array is circular</b> which means two things:
 1. If, while moving forward, we reach the end of the array, we will jump to the first element to continue the movement.
 2. If, while moving backward, we reach the beginning of the array, we will jump to the last element to continue the movement.
 Write a method to determine <b>if the array has a cycle</b>. The cycle should have more than one element and should follow one direction which means the cycle should not contain both forward and backward movements.

✅ Pattern 06: In-place Reversal of a LinkedList.md

@@ -1,8 +1,8 @@
 # Pattern 6: In-place Reversal of a LinkedList
 
-In a lot of problems, we are asked to reverse the links between a set of nodes of a <b>LinkedList</b>. Often, the constraint is that we need to do this in-place, i.e., using the existing node objects and without using extra memory.
+In a lot of problems, we are asked to reverse the links between a set of nodes of a <b>LinkedList</b>. Often, the constraint is that we need to do this </i>in-place</i>, i.e., using the existing node objects and without using extra memory.
 
-<b>In-place Reversal of a LinkedList pattern</b> describes an efficient way to solve the above problem.
+<b></i>in-place</i> Reversal of a LinkedList pattern</b> describes an efficient way to solve the above problem.
 
 ## Reverse a LinkedList (easy)
 https://leetcode.com/problems/reverse-linked-list/
@@ -62,14 +62,14 @@ console.log(`Nodes of original LinkedList are: ${head.printList()}`)
 console.log(`Nodes of reversed LinkedList are: ${reverse(head).printList()}`)
 ````
 
-- The time complexity of our algorithm will be `O(N)` where `N` is the total number of nodes in the <b>LinkedList</b>.
+- The time complexity of our algorithm will be `O(N)` where `N’` is the total number of nodes in the <b>LinkedList</b>.
 - We only used constant space, therefore, the space complexity of our algorithm is `O(1)`.
 
 ## Reverse a Sub-list (medium)
 https://leetcode.com/problems/reverse-linked-list-ii/
 > Given the head of a <b>LinkedList</b> and two positions `p` and `q`, reverse the <b>LinkedList</b> from position `p` to `q`.
 
-The problem follows the <b>In-place Reversal</b> of a <b>LinkedList</b> pattern. We can use a similar approach as discussed in <b>Reverse a LinkedList</b>. Here are the steps we need to follow:
+The problem follows the <b></i>in-place</i> Reversal</b> of a <b>LinkedList</b> pattern. We can use a similar approach as discussed in <b>Reverse a LinkedList</b>. Here are the steps we need to follow:
 1. Skip the first `p-1` nodes, to reach the node at position `p`.
 2. Remember the node at position `p-1` to be used later to connect with the reversed sub-list.
 3. Next, reverse the nodes from `p` to `q` using the same approach discussed in <b>Reverse a LinkedList</b>.
@@ -187,7 +187,7 @@ https://leetcode.com/problems/reverse-nodes-in-k-group/
 > Given the head of a <b>LinkedList</b> and a number ‘k’, <b>reverse every ‘k’ sized sub-list</b> starting from the head.
 > If, in the end, you are left with a sub-list with less than ‘k’ elements, reverse it too.
 
-The problem follows the <b>In-place Reversal of a LinkedList</b> pattern and is quite similar to <b>Reverse a Sub-list</b>. The only difference is that we have to reverse all the sub-lists. We can use the same approach, starting with the first sub-list (i.e. `p=1, q=k`) and keep reversing all the sublists of size ‘k’.
+The problem follows the <b></i>in-place</i> Reversal of a LinkedList</b> pattern and is quite similar to <b>Reverse a Sub-list</b>. The only difference is that we have to reverse all the sub-lists. We can use the same approach, starting with the first sub-list (i.e. `p=1, q=k`) and keep reversing all the sublists of size ‘k’.
 
 ````js
 class Node {
@@ -275,7 +275,7 @@ console.log(`Nodes of reversed LinkedList are: ${reverseEveryKElements(head, 3).
 > 
 > If, in the end, you are left with a sub-list with less than `K` elements, reverse it too.
 
-The problem follows the <b>In-place Reversal of a LinkedList</b> pattern and is quite similar to <b>Reverse every K-element Sub-list</b>. The only difference is that we have to skip `K` alternating elements. We can follow a similar approach, and in each iteration after reversing `K` elements, we will skip the next `K` elements.
+The problem follows the <b></i>in-place</i> Reversal of a LinkedList</b> pattern and is quite similar to <b>Reverse every K-element Sub-list</b>. The only difference is that we have to skip `K` alternating elements. We can follow a similar approach, and in each iteration after reversing `K` elements, we will skip the next `K` elements.
 
 ````class Node {
   constructor(value, next = null) {
@@ -359,7 +359,7 @@ process.stdout.write('Nodes of reversed LinkedList are: ');
 result.printList();
 ````
 
-- The time complexity of our algorithm will be `O(N)`where  `N` is the total number of nodes in the <b>LinkedList</b>.
+- The time complexity of our algorithm will be `O(N)`where  `N’` is the total number of nodes in the <b>LinkedList</b>.
 - We only used constant space, therefore, the space complexity of our algorithm is `O(1)`.
 ## 🌟 Rotate a LinkedList (medium)
 https://leetcode.com/problems/rotate-list/
@@ -433,5 +433,5 @@ head.next.next.next.next.next = new Node(6)
 console.log(`Nodes of original LinkedList are: ${head.getList()}`)
 console.log(`Nodes of rotated LinkedList are: ${rotate(head, 3).getList()}`)
 ````
-- The time complexity of our algorithm will be `O(N)` where `N` is the total number of nodes in the <b>LinkedList</b>.
+- The time complexity of our algorithm will be `O(N)` where `N’` is the total number of nodes in the <b>LinkedList</b>.
 - We only used constant space, therefore, the space complexity of our algorithm is `O(1)`.