Fix documentation typos

Author: sudheerj

README.md

@@ -97,7 +97,7 @@ List of Programs related to data structures and algorithms
 
 | No. | Name                |                                                                    Source                                                                     | Playground                                                                                                                                                                        |                                                                    Documentation                                                                     | Level  |       Pattern       |
 | :-: | :------------------ | :-------------------------------------------------------------------------------------------------------------------------------------------: | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------: | :----: | :-----------------: |
-|  1  | Sum of two integers |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/1.twoSum/twoSum.js)        | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/1.twoSum/twoSum.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/1.twoSum/twoSum.md)        | Medium |  Bitwise opeations  |
+|  1  | Sum of two integers |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/1.twoSum/twoSum.js)        | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/1.twoSum/twoSum.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/1.twoSum/twoSum.md)        | Medium |  Bitwise operations  |
 |  2  | Number of 1 Bits    | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/2.numberOf1Bits/numberOf1Bits.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/2.numberOf1Bits/numberOf1Bits.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/2.numberOf1Bits/numberOf1Bits.md) |  Easy  |  Brian Kernighans   |
 |  3  | Counting Bits       |  [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/3.countingBits/countingBits.js)  | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/3.countingBits/countingBits.js)   |  [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/3.countingBits/countingBits.md)  |  Easy  | Dynamic programming |
 |  4  | Missing number      | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/4.missingNumber/missingNumber.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/4.missingNumber/missingNumber.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/binary/4.missingNumber/missingNumber.js) |  Easy  |     Bitwise XOR     |
@@ -188,7 +188,7 @@ List of Programs related to data structures and algorithms
 
    4. Number of Islands: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/graph/numberOfIslands.js)
 
-   5. Longest consequtive sequence: [JavaScript](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/graph/longestConsecutiveSequence.js)
+   5. Longest consecutive sequence: [JavaScript](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/graph/longestConsecutiveSequence.js)
 
    6. Alien dictionary: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/graph/alienDictionary.js)
 

src/java1/algorithms/array/containerWithMostWater/ContainerWithMostWater.md

@@ -31,7 +31,7 @@ This problem is solved with the help of two pointer technique on opposite ends.
 
 8. Repeat steps 4-7 until all the elements traversed.
 
-9. Return the maximum capcity of the container.
+9. Return the maximum capacity of the container.
 
 **Time and Space complexity:**
 This algorithm has a time complexity of `O(n)`, where `n` is the number of elements. This is because the left or right pointer moved towards the other until they meet in each iteration, the elements are traversed once. 

src/java1/algorithms/array/maxSumCircularSubarray/MaxSumCircularSubarray.md

@@ -29,7 +29,7 @@ This problem is solved with the help of Kadane's algorithm(dynamic programming t
 
 5. Iterate over an input array to calculate the maximum value.
 
-6. Calculate the maximum and minimum sum at each element positon. The minimum sum is required to derive maximum value incase of cirucular subarray contains maximum value.
+6. Calculate the maximum and minimum sum at each element positon. The minimum sum is required to derive maximum value incase of circular subarray contains maximum value.
 
 7. Find the total sum of all the numbers and store it in
 

src/java1/algorithms/array/minimumRotatedSortedarray/minimumRotatedSortedarray.md

@@ -38,6 +38,6 @@ This problem is solved with the help of binary search technique. Since it is a r
 
 **Time and Space complexity:**
 
-This algorithm has a time complexity of `O(log n)`, where `n` is the number of elements. This is because we divide the array into two subarray each time and find the minimum element in the correct subarray using binary search alogorithm. 
+This algorithm has a time complexity of `O(log n)`, where `n` is the number of elements. This is because we divide the array into two subarray each time and find the minimum element in the correct subarray using binary search algorithm. 
 
 Here, we don't use any additional datastructure other than the result variable. Hence, the space complexity will be O(1).

src/java1/algorithms/array/minimumSizeSubarraySum/MinimumSizeSubarraySum.md

@@ -25,7 +25,7 @@ This problem is solved with the help of sliding window approach without using an
 
 5. Calculate the total value by adding array value at respective right pointer.
 
-6. If the total value is greather or equal to target, find the minimum of subarray sum and shrink the current window total and left pointer value. This step need to be repeated until there are no subarray exists to meet the target criteria.
+6. If the total value is greater or equal to target, find the minimum of subarray sum and shrink the current window total and left pointer value. This step need to be repeated until there are no subarray exists to meet the target criteria.
 
 7. Increment the right pointer to find the next subarray.
 

src/java1/algorithms/array/rotateArray/RotateArray.md

@@ -21,9 +21,9 @@ This problem is solved with the help of two pointers, which is used to reverse s
 
 3. Create a helper function to reverse elements of an array using swap operation with the help left and right pointers(i.e, `left` and `right`). The left pointer needs to be incremented and right pointer needs to decremented for each iteration.
 
-4. Invoke reversal operation for entire array of elements(i.e, from the beggining to end of an array).
+4. Invoke reversal operation for entire array of elements(i.e, from the beginning to end of an array).
 
-5. Invoke reversal operation for first `n` number of elements(i.e, from the beggining to n-1).
+5. Invoke reversal operation for first `n` number of elements(i.e, from the beginning to n-1).
 
 6. Invoke reversal operation for remaining number of elements(i.e, from `n-1` to end of an array).
 

src/java1/algorithms/array/searchRotatedSortedArray/SearchRotatedSortedArray.md

@@ -35,6 +35,6 @@ This problem is solved with the help of binary search technique. Since it is a r
 
 **Time and Space complexity:**
 
-This algorithm has a time complexity of `O(log n)`, where `n` is the number of elements. This is because we divide the array into two subarrays each time and find the index of target element using binary search alogorithm. 
+This algorithm has a time complexity of `O(log n)`, where `n` is the number of elements. This is because we divide the array into two subarrays each time and find the index of target element using binary search algorithm. 
 
 Here, we don't use any additional datastructure other than two left pointer variables. Hence, the space complexity will be O(1).

src/java1/algorithms/array/sortColors/SortColors.md

@@ -30,11 +30,11 @@ This problem is solved with the help of **two pointers** technique. It is also k
 
 5. If the current character is equals to 2, swap the character values at right pointer and index pointer. Also, decrement the right pointer. 
 
-6. If the chracter is neither `0` or `2`, then just increment the index pointer.
+6. If the character is neither `0` or `2`, then just increment the index pointer.
 
 7. Repeat steps 4–6 until the index pointer reaches the end of the array.
 
-8. Return the updated in-place array where chracters are sorted.
+8. Return the updated in-place array where characters are sorted.
 
 **Time and Space complexity:**
 This algorithm takes a time complexity of `O(n)` because we are traversing the array only once. Also, it requires space complexity of `O(1)` because we are updating the array in-place without using an additional data structure.

src/java1/algorithms/binary/countingBits/CountingBits.md

@@ -17,15 +17,15 @@ This problem is solved with the help of **dynamic programming** technique where
 
 2. Initialize the `ans` array with a length of `num+1` where each element assigned to zero by default. This array indicates the number of `1`s in each element from `0` to `num`. 
 
-3. Initialize the offset(`offset`) variable to 1. This is because the first offset with power of 2 is 1(i.e, 2 power 0). In this problem, you can find pattern that offset is multiplyed by 2 when the index value is power of 2.
+3. Initialize the offset(`offset`) variable to 1. This is because the first offset with power of 2 is 1(i.e, 2 power 0). In this problem, you can find pattern that offset is multiplied by 2 when the index value is power of 2.
 
 4. Iterate over each element upto `num` to find the counting bits.
 
-5. The offset should be updated to the index variable(`i`) once the offset multipled by 2 is equal to index variable.
+5. The offset should be updated to the index variable(`i`) once the offset multiplied by 2 is equal to index variable.
 
-6. If the condition in step5 fails, the number of 1's for current number is caluclated by adding the number of 1's in previous power of 2 index variable with 1.
+6. If the condition in step5 fails, the number of 1's for current number is calculated by adding the number of 1's in previous power of 2 index variable with 1.
 
-7. Repeat 5-6 steps to caculate the number of set bits for each element.
+7. Repeat 5-6 steps to calculate the number of set bits for each element.
 
 8. Return the `ans` array which holds number of set bits upto input number.
 

src/java1/algorithms/binary/numberOf1Bits/NumberOf1Bits.md

@@ -21,7 +21,7 @@ This problem is solved with the help of **Brian Kernighans** technique. The main
 
 3. Iterate the number until it became zero. 
 
-4. Update the number by multiplying the number itself with number which is substracted by 1. It helps to invert the right most bit everytime.
+4. Update the number by multiplying the number itself with number which is subtracted by 1. It helps to invert the right most bit everytime.
 
 5. Update the counter by one for each iteration.
 

src/java1/algorithms/binary/reverseBits/ReverseBits.md

@@ -11,7 +11,7 @@ Input: num = 8
 Output: 268435456
 
 **Algorithmic Steps:**
-This problem is solved with the help of **Bitwise operations**. The main intution of this algorithm is to retrieve each bit individually from least significant bit to the most significant bit and place that bit in the reversed position of a new number. As a result, the least signicant bits moved to most significant bit side and vice-versa. The algorithmic approach can be summarized as follows: 
+This problem is solved with the help of **Bitwise operations**. The main intution of this algorithm is to retrieve each bit individually from least significant bit to the most significant bit and place that bit in the reversed position of a new number. As a result, the least significant bits moved to most significant bit side and vice-versa. The algorithmic approach can be summarized as follows: 
 
 1. Get the number `num` as input parameter.
 

src/java1/algorithms/binary/twoSum/TwoSum.md

@@ -15,7 +15,7 @@ This problem is solved with the help of **bitwise operators** technique. The add
 
 1. Get the two numbers `a` and `b` as input parameters.
 
-2. Iterate the bitwise opeations until `b` is not zero. 
+2. Iterate the bitwise operations until `b` is not zero. 
 
 3. Calculate the carry of the two numbers using Bitwise AND operation. Also, shift the carry to the left 1. The can be store in a `temp` variable.
 

src/java1/algorithms/graph/AlienDictionary.java

@@ -4,7 +4,7 @@
 
 public class AlienDictionary {
 
-    //BFS(Topological sorting through Kahn's alogirthm):- TC: O(m*n) SC:O(m*n)
+    //BFS(Topological sorting through Kahn's algorithm):- TC: O(m*n) SC:O(m*n)
     private static String alienOrder(String[] words) {
         if(words == null || words.length == 0) return null;
 

src/java1/algorithms/hashmap/twoSum/TwoSum.md

@@ -8,7 +8,7 @@ This problem is solved in a one pass with the help of HashMap data structure. Th
 
 4. Iterate over the input array using index pointer until the end of the array. 
 
-5. Find the complement by substracting the target and current number. If the complement already exists in the map, return the indices of complement and current number as output.
+5. Find the complement by subtracting the target and current number. If the complement already exists in the map, return the indices of complement and current number as output.
 
 6. If the complement doesn't exist in our indexMap, just add the current number and its index to the map.
 

src/java1/algorithms/interval/meetingRooms/meetingRooms.md

@@ -23,7 +23,7 @@ This problem is solved with the help of greedy approach. The algorithmic approac
 
     **Note:** Remember that the main idea behind this solution is to verify that each meeting ends before the next meeting starts.
 
-3. If the start time is less than the end time of the previous interval, then there is an overlap between the intervals. In this case, a person cannot attend all meetings. So you need to return `false` immeidately.
+3. If the start time is less than the end time of the previous interval, then there is an overlap between the intervals. In this case, a person cannot attend all meetings. So you need to return `false` immediately.
 
 4. If the start time is greater than the previous interval's end time, then there is no overlap between the intervals. In this case, you need to proceed with next set of intervals to find any overlap between the meetings. 
 

src/java1/algorithms/interval/nonOverlappingIntervals/NonOverlappingIntervals.md

@@ -3,7 +3,7 @@ This problem is solved with the help of greedy approach. The algorithmic approac
 
 1. First, sort the list of intervals based on their start times. This step helps to keep the overlapping intervals next to each other in the list.
 
-2. Initialize a minimum removal of intervals varaible `minRemove` to 0, which is used to hold the minimum number of intervals to be removed to make non-overlapping intervals. 
+2. Initialize a minimum removal of intervals variable `minRemove` to 0, which is used to hold the minimum number of intervals to be removed to make non-overlapping intervals. 
 
 3. Initialize previous end value of an interval `prevEnd` with first interval end value. i.e, Here, first interval is considered as non-overlapping interval by default.
 

src/java1/algorithms/matrix/WordSearch.java

@@ -20,7 +20,7 @@ private static boolean dfs(char[][] board, String word, int r, int c, int curr)
         // If the entire word has been found in the board
         if(word.length() == curr) return true;
 
-        // Verfiy out of bounds or mismatched letter
+        // Verify out of bounds or mismatched letter
         if(r < 0 || r >= board.length || c<0 || c >= board[0].length || board[r][c] != word.charAt(curr) || board[r][c] == '*') return false;
 
         //Mark the current word as visited

src/java1/algorithms/stack/dailyTemperatures/DailyTemperatures.md

@@ -7,9 +7,9 @@ This problem is solved with the help of monotonic decreasing stack. The algorith
 
 3. Iterate over the input array using an iteration variable `currDay`(from 0 to length of array).
 
-4. For each iteration, create nested iteration to shrink the stack until the stack is not empty and current temparature is greater than previous day temperation.
+4. For each iteration, create nested iteration to shrink the stack until the stack is not empty and current temperature is greater than previous day temperation.
 
-5. As part of the nested iteration, the top element of stack needs to be poped-out and number of days(current day index - previous day index) to wait for warmer temparature stores in previous day's index.
+5. As part of the nested iteration, the top element of stack needs to be poped-out and number of days(current day index - previous day index) to wait for warmer temperature stores in previous day's index.
 
 6. If the current day temperature is less than previous day, the respective current day index is stored in the stack.
 

src/java1/algorithms/stack/numberOfPeopleSeeInQueue/NumberOfPeopleSeeInQueue.md

@@ -3,7 +3,7 @@ This problem is solved with the help of monotonic decreasing stack. The algorith
 
 1. Initialize the length variable which indicates number of people in the queue.
 
-2. Initialize a `visiblityCount` array with the same length of input `heights` array, filled with zeros.
+2. Initialize a `visibilityCount` array with the same length of input `heights` array, filled with zeros.
 
 3. Initialize a monotonic stack named `stack` which stores the heights of persons.
 
@@ -16,7 +16,7 @@ to the current person.
 
 6. Add the current taller person height to the stack.
 
-7. Return the visiblity count array which indicate number of persions of visible at each position.
+7. Return the visibility count array which indicate number of persions of visible at each position.
 
 **Time and Space complexity:**
 This algorithm has a time complexity of O(n), where n is the number of people a person can see. This is because we are iterating the array only once. However, each element performs multiple comparisons along with pop operations from the stack until a higher height is found. In the worst, each element will be pushed and popped from the stack once, leads to time complexity of O(n). So the overall time complexity is O(n).

src/java1/algorithms/strings/encodeDecodeStrings/EncodeDecodeStrings.md

@@ -31,7 +31,7 @@ This problem is solved with the help of basic string and array built-in operatio
 
 4. Create a temporary variable(`j`) which is assigned to index variable.
 
-5. Skip the prefix related to each string's length until the character reaches special(`#`) symbol. The number of characters ignored are indicated by incremental value of `j`. The next character position(`j+1`) indicates the beggining of a string.
+5. Skip the prefix related to each string's length until the character reaches special(`#`) symbol. The number of characters ignored are indicated by incremental value of `j`. The next character position(`j+1`) indicates the beginning of a string.
 
 6. Calculate the word length followed by substring using the index variables.