Repository: teja963/Advanced-DSA-and-CS-Theory (language: cpp)

Issue:
Typos detected in documentation
These are the typos detected by codespell tool in the documentation of the project. 

```
$ codespell -L ans ./Advanced-DSA-and-CS-Theory  --skip="*.cpp"
./Linked list/README.md:21: untill ==> until
./Linked list/README.md:53: untill ==> until
./Linked list/README.md:67: implment ==> implement
./Mathematical/README.md:8: multipe ==> multiple
./Mathematical/README.md:54: cordinate ==> coordinate
./Mathematical/README.md:61: untill ==> until
./Mathematical/README.md:94: divisble ==> divisible
./Mathematical/README.md:101: divsion ==> division
./Mathematical/README.md:107: paterns ==> patterns
./Graph/README.md:4: possiblities ==> possibilities
./Graph/README.md:24: Intiallize ==> Initialize
./Graph/README.md:38: prioritze ==> prioritize
./Graph/README.md:41: coverting ==> converting, covering, coveting
./Graph/README.md:56: possibilites ==> possibilities
./Graph/README.md:79: visulization ==> visualization
./Graph/README.md:86: possibilites ==> possibilities
./Dynamic_programming/README.md:70: probelms ==> problems
./Dynamic_programming/README.md:71: paramter ==> parameter
./Dynamic_programming/README.md:110: possiblilities ==> possibilities
./Dynamic_programming/README.md:123: Incrasing ==> Increasing
./Dynamic_programming/README.md:125: possibilites ==> possibilities
./Dynamic_programming/README.md:126: couting ==> counting
./Dynamic_programming/README.md:132: Impelmentation ==> Implementation
./Dynamic_programming/README.md:141: ques ==> quest
./Dynamic_programming/README.md:152: intialize ==> initialize
./Binary Trees/README.md:47: widht ==> width
./Binary Trees/README.md:62: Properities ==> Properties
./BackTracking/README.md:23: Permuation ==> Permutation
./BackTracking/README.md:24: possibilites ==> possibilities
./BackTracking/README.md:30: satisifies ==> satisfies
./Greedy/README.md:31: widht ==> width
./Greedy/README.md:59: occurance ==> occurrence
./Greedy/README.md:60: intializing ==> initializing
./Greedy/README.md:61: spliting ==> splitting
./Greedy/README.md:63: numberic ==> numeric
./Greedy/README.md:75: Incase ==> In case
./Searching Sorting/README.md:3: Atleast ==> At least
./Searching Sorting/README.md:6: atleast ==> at least
./Searching Sorting/README.md:11: initalize ==> initialize
./Searching Sorting/README.md:16: initialzing ==> initializing
./Searching Sorting/README.md:39: indexs ==> indexes, indices
./Searching Sorting/README.md:44: parralel ==> parallel
./Stack/README.md:23: untill ==> until
./Stack/README.md:52: direcotry ==> directory
./Stack/README.md:53: direcotry ==> directory
./Trie/README.md:2: implmentation ==> implementation
./Array/README.md:3: atmost ==> at most, almost, utmost
./Array/README.md:16: elemenst ==> elements
./Array/README.md:36: unqiue ==> unique
./Array/README.md:64: satisifying ==> satisfying
./Array/Easy Ques/Readme.md:34: Alogrithm ==> Algorithm
./Samsung R & D/SWC_3RDJULY.txt:16: contraints ==> constraints
./Matrix/README.md:31: Filp ==> Flip
./Matrix/README.md:32: fliping ==> flipping
./Bit Manipulation/README.md:36: wihtout ==> without
./Bit Manipulation/README.md:59: geting ==> getting
./Bit Manipulation/README.md:88: charcters ==> characters
./Bit Manipulation/README.md:91: Couting ==> Counting
./String/README.md:18: Permuation ==> Permutation
./String/README.md:26: repeates ==> repeats
./String/README.md:33: similiarly ==> similarly
./String/README.md:36: swaping ==> swapping
./String/README.md:49: Permuation ==> Permutation
./String/README.md:59: charcters ==> characters
./String/README.md:67: parantheses ==> parentheses
./String/README.md:83: releated ==> related
./Prefix sum/README.md:7: atleast ==> at least
./Prefix sum/README.md:8: continous ==> continuous
./Prefix sum/README.md:12: continous ==> continuous
./Prefix sum/README.md:12: incase ==> in case

```


Discussion / hints:

Fix patch:
diff --git a/Array/Easy Ques/Readme.md b/Array/Easy Ques/Readme.md
index c040876..99fe7d3 100644
--- a/Array/Easy Ques/Readme.md
+++ b/Array/Easy Ques/Readme.md
@@ -31,7 +31,7 @@
 
 # Standard
 <pre>
-  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Array/Easy%20Ques/kadanes_algo.cpp">Kadanes Alogrithm</a></b>
+  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Array/Easy%20Ques/kadanes_algo.cpp">Kadanes Algorithm</a></b>
    Make a parallel array as ans array then update as:
         sum=0   ans = INT_MIN
         a: [ 1 -5  4  9  8 -10 6]
diff --git a/Array/README.md b/Array/README.md
index 900d7e7..e5370f1 100644
--- a/Array/README.md
+++ b/Array/README.md
@@ -1,6 +1,6 @@
 # Efficient Approaches
   <pre>
-  <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Array/19.%20Buying%20selling%20share%20atmost%20twice.cpp">Buying and selling atmost twice</a></b>: Need to update
+  <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Array/19.%20Buying%20selling%20share%20atmost%20twice.cpp">Buying and selling at most twice</a></b>: Need to update
      Initializing variable valley-peak approach
 	   
 		                80
@@ -13,7 +13,7 @@
 		       \ /
 		        8 
   
-  <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Array/25.%20Min%20swaps%20required%20k%20elements%20together.cpp">Min swaps required to bring K elemenst together</a></b>
+  <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Array/25.%20Min%20swaps%20required%20k%20elements%20together.cpp">Min swaps required to bring K elements together</a></b>
   
   <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Array/37.%20Max%20sum%20path.cpp">Maximum sum path</a></b>
         arr1: i sum1
@@ -33,7 +33,7 @@
        need to traverse only (n1+n2)/2 elements 
 
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Array/50.%20k-difference%20pairs.cpp">K difference pairs</a></b>
-  	In this k is >= 0, so always need to check (x + k) present or not only unqiue pairs means
+  	In this k is >= 0, so always need to check (x + k) present or not only unique pairs means
   	no need to consider duplicate elements so use map or set
   	and check k = 0 case, [1, 1, 1, 1] only 1 single pair so k == 0 and x.second > 1: ans++	
   	
@@ -61,7 +61,7 @@
   	apply above problem base logic
   	
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Array/63.%20Non-decreasing%20array.cpp">Non Decreasing array</a></b>
-  	Update not satisifying element based on prev elements value, only one time, if more than that return false
+  	Update not satisfying element based on prev elements value, only one time, if more than that return false
   	
   <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Array/16.%20Max%20product%20subarray.cpp">Max product subarray</a></b>
   Use cases for -ve and +ve elements
diff --git a/BackTracking/README.md b/BackTracking/README.md
index cafe305..faac86c 100644
--- a/BackTracking/README.md
+++ b/BackTracking/README.md
@@ -20,14 +20,14 @@
 	   		fun(s.substr(i+1))
 	   		pop
 	   		
-  <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/BackTracking/7.%20Permuation%20with%20spaces.cpp">Permuation with spaces</a></b>
-  just create all possibilites with space include or not condition
+  <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/BackTracking/7.%20Permuation%20with%20spaces.cpp">Permutation with spaces</a></b>
+  just create all possibilities with space include or not condition
   for edge case(last character) push it without space 
   
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/BackTracking/6.%20Array%20Partition.cpp">Array Partition</a></b>
   to get absolute diff between any pair of elements we need to sort
   check start and start + k -1, is basic condition
-  if it satisifies go to fun(start+1)
+  if it satisfies go to fun(start+1)
   
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/BackTracking/9.%20Largest%20number%20in%20k%20swaps.cpp">Largest num in k swaps</a></b>
   find all possibilities (by decr k) and get the max, for every combination recursively 
diff --git a/Binary Trees/README.md b/Binary Trees/README.md
index cc3cee2..dba73ff 100644
--- a/Binary Trees/README.md
+++ b/Binary Trees/README.md
@@ -44,7 +44,7 @@
                 5  | 6 7 |  8
                 |  |  |  |  |
    
-  <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Binary%20Trees/54.%20Maximum%20width%20of%20Binary%20Tree.cpp">Maximum widht of BT</a></b>
+  <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Binary%20Trees/54.%20Maximum%20width%20of%20Binary%20Tree.cpp">Maximum width of BT</a></b>
    Use parent, left_child, right_child index concept add index parameter in the queue
    i - parent
    2 * i + 1 - left_child
@@ -59,7 +59,7 @@
           l          m-1  m  m+1          h                  root.left= (l, m-1)
     arr:  1   2   3   4   5   6   7   8   9                  root.right= (m+1, h)
     
-* Properities:
+* Properties:
    <b>Inorder traversal of BST gives sorted order</b> 
    <b>Application:</b><b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Binary%20Trees/36.%20Check%20BST.cpp">Check BST</a></b>: implement false conditions
                       <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Binary%20Trees/43.%20find%20mode%20in%20BST.cpp">Mode in BST</a></b>
diff --git a/Bit Manipulation/README.md b/Bit Manipulation/README.md
index fd2282b..e8540f1 100644
--- a/Bit Manipulation/README.md
+++ b/Bit Manipulation/README.md
@@ -33,7 +33,7 @@
          get all the odd one's by n&0x55555555;
          shift the positions and add
     
-   **<b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Bit%20Manipulation/8.%20divide%202%20integers%20wihtout%20mul%20div%20modoperation.cpp">Divide 2 integer wihtout any division, multiplication, mod O(log a)</a></b>**
+   **<b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Bit%20Manipulation/8.%20divide%202%20integers%20wihtout%20mul%20div%20modoperation.cpp">Divide 2 integer without any division, multiplication, mod O(log a)</a></b>**
 	       we can know that every number is can be written as power of 2
 	       a = 10    b = 3    ans= 3
 	       1 0 1 0     tmp=0
@@ -56,7 +56,7 @@
       
    <b><a href="https://github.com/teja963/DSA-and-MYSQL/blob/master/Bit%20Manipulation/12.%20Single%20Number%203.cpp">Single Number 3</a></b>
       [1, 2, 1, 3, 2, 5]    find xor of all = tmp
-      for geting last set bit of tmp = tmp & -tmp   //for grouping purpose (01)
+      for getting last set bit of tmp = tmp & -tmp   //for grouping purpose (01)
                           00        10
       1:  001          -------------------
       2:  000             1     |   2
@@ -85,10 +85,10 @@
 	//bitmap  = [num1,  num2, num3 , num4 , num5 , num6]  -- val |= (1<<(ch-'a'))
        Output: 16
      
-       Use bitmap for checking common charcters for 
+       Use bitmap for checking common characters for 
        and check (bitmap[i] & bitmap[j] == 0) ,if common characters present it won't be zero
        
-   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Bit%20Manipulation/14.%20Counting%20Bits.cpp">Couting bits</a></b>
+   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Bit%20Manipulation/14.%20Counting%20Bits.cpp">Counting bits</a></b>
    	we need to find no.of bits in O(1)
    	1. make use of previously calculated thing ans[i] = ans[i / 2]
    	2. Even and odd status helps us update, finally ans[i] = ans[i / 2] + i % 2
diff --git a/Dynamic_programming/README.md b/Dynamic_programming/README.md
index d32a0b0..1e04cd2 100644
--- a/Dynamic_programming/README.md
+++ b/Dynamic_programming/README.md
@@ -67,8 +67,8 @@
     		if prev < nums[idx]: take = 1 + fun(nums, idx+1, nums[idx])
     		return max(take, not_take)
   
-    Imp condition :                                                                        For russian dolls probelms convert into LIS by fixing one parameter inreasing
-         dp[n] = {1}                                                                       after getting variable paramter find LIS 
+    Imp condition :                                                                        For russian dolls problems convert into LIS by fixing one parameter inreasing
+         dp[n] = {1}                                                                       after getting variable parameter find LIS 
         if( a[j] < a[i] )                                              
         {
           dp[i] = max ( dp[i], dp[j] + 1)
@@ -107,7 +107,7 @@
    p1   p2   p3   p4 
    _    _    _    _     _     _     _     _ 
    di possible after pi
-   so for d1 we have 2*n - 1 possiblilities
+   so for d1 we have 2*n - 1 possibilities
    so for d2 we have p1 d1 p2 fixed so we have 2*n - 3 possibilities ...........
    for p1 to pn we have n!ways
    so n! * (1 * 3* 5 * ...2n-1)
@@ -120,16 +120,16 @@
 	  2 1 2 3 4 5
 	  3 1 3 6 10 15 
 	  
-  <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Dynamic_programming/34.%20Longest%20Increasing%20path%20in%20a%20matrix.cpp">Longest Incrasing Path in a matrix</a></b>     <img alt= "Grid Image" src="https://github.com/teja963/Advanced-DSA/blob/master/Dynamic_programming/images/grid1.jpg">
+  <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Dynamic_programming/34.%20Longest%20Increasing%20path%20in%20a%20matrix.cpp">Longest Increasing Path in a matrix</a></b>     <img alt= "Grid Image" src="https://github.com/teja963/Advanced-DSA/blob/master/Dynamic_programming/images/grid1.jpg">
   we don't know where to start so we traverse all the nodes                     make recursive block diagrams for each cell and possibilities
-  implement base case and all possibilites
-  dp[i][j] = max({left, right, up, down}) + 1 - for couting this step
+  implement base case and all possibilities
+  dp[i][j] = max({left, right, up, down}) + 1 - for counting this step
   
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Dynamic_programming/38.%20Number%20of%20ways.cpp">Number of ways</a></b>
   	dp[i] = dp[i-1] + dp[i-4]
   </pre>
 
-# Recurrsion -> DP Impelmentation
+# Recurrsion -> DP Implementation
   <pre>
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Dynamic_programming/1.%20coin%20problem.cpp">Coin Problem</a></b>: if dp[0] = 1;
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Dynamic_programming/2.%20knapsack%200-1.cpp">Knapsack</a></b>: N == 0, W == 0, fill with zeros, we need to consider or not cases
@@ -138,7 +138,7 @@
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Dynamic_programming/8.%20subset%20equal%20partition.cpp">Subset equal partition</a></b>: We need to consider or not cases
   </pre>
   
-# Pattern Finding ques
+# Pattern Finding quest
   <pre>
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Dynamic_programming/9.%20frnds%20paring.cpp">Friends pairing</a></b>: check this pattern
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Dynamic_programming/15.%20Painting%20the%20fence.cpp">Painting the fence</a></b>: Pattern
@@ -149,5 +149,5 @@
   if min assign INT_MAX
   if max assign INT_MIN
   else assign zero
-     At last based on question intialize the frst row and frst col base conditions 
+     At last based on question initialize the frst row and frst col base conditions 
   </pre>
diff --git a/Graph/README.md b/Graph/README.md
index a704cdd..b78749b 100644
--- a/Graph/README.md
+++ b/Graph/README.md
@@ -1,7 +1,7 @@
 # Graph
   <pre>
   <b><a href="https://github.com/teja963/DSA-and-MYSQL/blob/master/Graph/1.%20Steps%20by%20Knight.cpp">Steps by Knight</a></b>     Application:<b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/18.%20Shortest%20path%20in%20matrix.cpp">Shortest Path in matrix</a></b>   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/23.%20Rotten%20Oranges.cpp">Rotten Oranges</a></b>   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/27.%20Min%20Cost%20Path.cpp">Minimum cost path</a></b>
-  Use bfs approach by making all possiblities frst
+  Use bfs approach by making all possibilities frst
   dp intiliaze -1, if we moved to that mark it as 0
   
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/5.%20Biconnected%20Graph.cpp">Biconnected graph</a></b>: If we remove 1 vertices it can't disconnected
@@ -21,7 +21,7 @@
   
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/17.%20Implementing%20Dijkstra%20Algorithm.cpp">Dijkstra Algorithm</a></b>     <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/13.%20Network%20Delay%20time.cpp">Network Delay time</a></b> Bellman ford:<b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/24.%20Negative%20weight%20cycle.cpp">Negative weight cycle</a></b>
                                Dijkstra's algo application                                                    make a distance vector and update it for all nodes
-                               Intiallize all the signal to INT_MAX, and start with given node as 0,          except starting node, and check again for detecting
+                               Initialize all the signal to INT_MAX, and start with given node as 0,          except starting node, and check again for detecting
                                Use bfs approach and updated all nodes signal
                                
   <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Graph/*21.%20Critical%20connections%20in%20a%20network.cpp">Critical connections in a network</a></b>
@@ -35,10 +35,10 @@
   update the boundaries while traversing
   
   <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Graph/31.%20Swim%20in%20Rain%20Water.cpp">Swim in Rain water</a></b>
-  Bfs approach, we need to prioritze the choosing path as min value
+  Bfs approach, we need to prioritize the choosing path as min value
   
   <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Graph/32.%20Snakes%20and%20Ladders.cpp">Snakes and ladders</a></b>
-  bfs approach, with the help of map get the cell value(coverting into 1d array) 
+  bfs approach, with the help of map get the cell value(converting into 1d array) 
   
   <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Graph/34.%20Min%20moves%20to%20move%20a%20box%20to%20target%20location.cpp">Min moves to move target to given position</a></b>
   bfs approach, keep track of box w.r.t to player && check player can reach to opp direction of box move
@@ -53,7 +53,7 @@
   </pre>
 # Theory
   <pre>
-  <b>Topological Sorting</b>: It should be DAG, there will be many possibilites find indeg choose which is least
+  <b>Topological Sorting</b>: It should be DAG, there will be many possibilities find indeg choose which is least
   So for implementation use DFS + stack   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/15.%20Topological%20sort.cpp">Topological sort</a></b> **Application:** <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/20.%20Alien%20Dictionary.cpp">Alien dictionary</a></b>       <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/26.%20Prerequisites%20tasks.cpp">Prerequisites tasks</a></b>   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Graph/22.%20course%20schedule.cpp">Course schedule</a></b>
                                          We are getting indeg and relationship from the given strings
                                          and used bfs approach for finding topological sort
@@ -76,12 +76,12 @@
    
   <b>Strongly Connected graph</b>If every vertices can reach all other vertices then it is SCC. Every single node is SCC. If we reverse edge direction
   in Directed graph, the property doesn't change. 
-  In dfs approach make a visulization of passing and marking nodes for better
+  In dfs approach make a visualization of passing and marking nodes for better
   </pre>
   
 # Approaches
   <pre>
   <a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Graph/33.%20Shortest%20Bridge.cpp">Shortest Bridge</a>
   When source and destination given use bfs, by using question condition
-  when we want to search all possibilites or source known use dfs(stopping criteria ht as base)
+  when we want to search all possibilities or source known use dfs(stopping criteria ht as base)
   </pre>
diff --git a/Greedy/README.md b/Greedy/README.md
index 7103cd1..7e89abb 100644
--- a/Greedy/README.md
+++ b/Greedy/README.md
@@ -28,7 +28,7 @@
            If we get the pair skip one iteration otherwise //implementation imp
            
   <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Greedy/9.%20Gas%20Station.cpp">Gas Station</a></b>
-  <img widht="800" height="400" src="https://github.com/teja963/DSA-and-MYSQL/blob/master/Greedy/images/gas.png">
+  <img width="800" height="400" src="https://github.com/teja963/DSA-and-MYSQL/blob/master/Greedy/images/gas.png">
         sum+= gas[i]- cost[i] 
      if sum <0: //then it can't be starting bcz of empty tank
           ans = i +1 //next one
@@ -56,11 +56,11 @@
    Kadane's prefix algorithm model
   
   <b><a href="https://leetcode.com/problems/partition-labels/">Question</a></b>                  <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Greedy/17.%20Partition%20labels.cpp">Partition labels</a></b>
-   Find the last element occurance of character
-   and use <b>maxi - prev</b>   , intializing to maxi 0, and prev -1
-   if <b>maxi == i</b>   condition for spliting, the we can update 
+   Find the last element occurrence of character
+   and use <b>maxi - prev</b>   , initializing to maxi 0, and prev -1
+   if <b>maxi == i</b>   condition for splitting, the we can update 
    
-  <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Greedy/18.%20Smallest%20string%20with%20given%20numeric%20value.cpp">Smallest string with given numberic value</a></b>
+  <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Greedy/18.%20Smallest%20string%20with%20given%20numeric%20value.cpp">Smallest string with given numeric value</a></b>
    First fill with a's and update string from rightend to leftend
    ans[--n] += min(25,k);
    
@@ -72,7 +72,7 @@
    
 # NOTE:
   <pre>                                                                  j      i
-  1. Incase of [frst, second] use greedy by sorting
+  1. In case of [frst, second] use greedy by sorting
                min no.of platforms/(ending time)         -----
                min no.of rooms for meeting/(ending time)     |_ _ _    if end[j] > start[i] :  ans++
                min things/                                   |
diff --git a/Linked list/README.md b/Linked list/README.md
index fe5b927..bde18c5 100644
--- a/Linked list/README.md
+++ b/Linked list/README.md
@@ -18,7 +18,7 @@
             fixed size and made the changes using reverse function
             
   <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Linked%20list/11.%20Intersection%20point%20LL.cpp">Intersection point</a></b> or <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Linked%20list/32.%20Polynomial%20%20addition.cpp">Polynomial addition</a></b>
-      Just traverse untill the last nodes of LL, at end point interchange(same reason for polynomial addition) 
+      Just traverse until the last nodes of LL, at end point interchange(same reason for polynomial addition) 
       their path for getting equal distance from intersection node(for getting missed powers addition)
       
   <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Linked%20list/29.%20Linkedlist%20cycle%202.cpp">Cycle detect and find intersection</a></b>
@@ -50,7 +50,7 @@
   
   **<b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Linked%20list/33.%20Count%20triplets%20in%20SLL.cpp">Count triplets in SLL in O(N*N) and space O(N)</a></b>**
     Use map for storing each value for each iteration
-    for SLL we can't traverse back of the list untill it was reversed so
+    for SLL we can't traverse back of the list until it was reversed so
     1 2 3    x=6
     for i=head to i:
        for j=i->next to j:
@@ -64,7 +64,7 @@
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Linked%20list/36.%20swap%20kth%20nodes%20from%20ends.cpp">Swap kth nodes from ends</a></b>
     <b>check min(k, n - k + 1)</b>
     make prev_node a from frst and prev_node b from end
-    make a connection diagram and implment 
+    make a connection diagram and implement 
   </pre>
 # Methods
   <pre>
diff --git a/Mathematical/README.md b/Mathematical/README.md
index 202396b..eba5315 100644
--- a/Mathematical/README.md
+++ b/Mathematical/README.md
@@ -5,7 +5,7 @@
   	just modify a[i] = n * (a[a[i]] % n) + a[i] % n
   	so while traversing a[i] = a[i] / n
   	
-  <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/mathematical/14.%20Check%20binary%20is%20multiple%20of%203.cpp">Check given binary number is multipe of 3 or not</a></b>
+  <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/mathematical/14.%20Check%20binary%20is%20multiple%20of%203.cpp">Check given binary number is multiple of 3 or not</a></b>
         ans: Count odd 1's and even 1's diff between odd 1's and even 1's is multiple of 3
         
   <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/mathematical/16.%20Final%20destination.cpp">Find destination</a></b>
@@ -51,14 +51,14 @@
     <img width="315" align="center" alt="rectanglesOverlap" src="https://user-images.githubusercontent.com/69209797/137142430-6a4ba481-20e6-4a05-b49a-9c6518a8a89d.png">
 
     Conditions for overlap:
-       1. if l1 == r1 or l2 == r2 (any cordinate matches) the line can't have +ve overlap
+       1. if l1 == r1 or l2 == r2 (any coordinate matches) the line can't have +ve overlap
        2. if l1.x >= r2.x or l2.x >= r1.x // if it is on left side
        3. if r1.y >= l2.y or r2.y >= l1.y // if one rect is above other
        
 
   <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Mathematical/25.%20Cows%20of%20foo%20land.cpp">Finding fibonacci num in log(n) </a></b>
      <img width="315" align="center" src="https://github.com/teja963/DSA_All_Models/blob/master/Mathematical/images/fibonacci.png">
-     1. Recursively divide the given term and multiply the matrix untill we get 1 for n //n/2
+     1. Recursively divide the given term and multiply the matrix until we get 1 for n //n/2
      2. Atlast if we get 1 then need to multiply once again and return the term
          _        _     _     _  n
         |Fn+1  Fn  |   |1     1|
@@ -91,20 +91,20 @@
    <b><a href="https://github.com/teja963/DSA-and-MYSQL/blob/master/Mathematical/33.%20Pair%20of%20Songs%20with%20duration%20divisible%20by%2060.cpp">Pair of songs duration is % 60</a></b>  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Mathematical/37.%20Grouping%20of%20numbers.java">Grouping of numbers</a></b>
    mod 60 means its always lie between [0,59] so consider array            Same as % K concept, make a remainder array
    else add its compliement v[60-rem]                                      check for non-divisible case like max(rem[low], rem[high), low = 1, high = k-1
-   update v[rem]++;                                                        check for all elements divisble case(k, 2k, 3k, ...)
+   update v[rem]++;                                                        check for all elements divisible case(k, 2k, 3k, ...)
          																   check for (i == k / i) case
          																   
    <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Mathematical/38.%20Maximum%20sum%20LCM.java">Maximum sum LCM</a></b>
    As the LCM of all the numbers is N. So all the numbers must be the divisors of N and all the numbers are distinct so answer must be the sum of all the divisors of N.
    
    <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Mathematical/39.%20Max%20points%20in%20a%20line.cpp">Max points in a line</a></b>
-   key points: divsion/zero case,
+   key points: division/zero case,
    use: <b>atan()</b> function for slope
   </pre>
 # NOTE:
   <pre>
   1. Next greater number problem use next premuation for simple approach
-  2. For given number see paterns from given input to usage of dp or fibonacci series
+  2. For given number see patterns from given input to usage of dp or fibonacci series
   3. Factorial of given values in array, store the fact values by providing size of max limit <b>O(max(array)+ N)</b>
   4. Check given num is power of smtg apply log on both sides get condition to check
      for 2: return n > 0 && __builtin_popcount(n) == 1;
diff --git a/Matrix/README.md b/Matrix/README.md
index fa79ce6..2cdbcfa 100644
--- a/Matrix/README.md
+++ b/Matrix/README.md
@@ -28,8 +28,8 @@
    now check their corresponding matrix[row1][column] and matrxi[row2][column] is 1
    
   <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Matrix/13.%20Compute%20Matrix.cpp">Compute matrix</a></b>See the pattern(reverse dynamic)
-  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Matrix/14.%20Filp%20columns%20for%20max%20no.of%20equal%20rows.cpp">Filp columns for max no.of equal rows</a></b>
-   After fliping it becomes equal rows means:- its compliment right
+  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Matrix/14.%20Filp%20columns%20for%20max%20no.of%20equal%20rows.cpp">Flip columns for max no.of equal rows</a></b>
+   After flipping it becomes equal rows means:- its compliment right
    use string(for row elements)keep tracking those freq and its compliment
     
    </pre> 
diff --git a/Prefix sum/README.md b/Prefix sum/README.md
index 7e345f8..1364daf 100644
--- a/Prefix sum/README.md
+++ b/Prefix sum/README.md
@@ -4,11 +4,11 @@
 </pre>
 # Subarray Concepts
 <pre>
-  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Prefix%20sum/2.%20continous%20subarr%20size%20atleast%202%20multiple%20of%20k.cpp">Continuous subarray size atleast 2</a></b>: Need to update
-  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Prefix%20sum/3.%20max%20length%20continous%20subarr%20with%20equal%200%201.cpp">Max len of continous subarray</a></b>
+  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Prefix%20sum/2.%20continous%20subarr%20size%20atleast%202%20multiple%20of%20k.cpp">Continuous subarray size at least 2</a></b>: Need to update
+  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Prefix%20sum/3.%20max%20length%20continous%20subarr%20with%20equal%200%201.cpp">Max len of continuous subarray</a></b>
 </pre>
 # NOTE:  
 <pre>
-  1. For continous sub-array questions if we need to find the length of particular problem or anything, make use of map for efficient approach, incase of len use index usage 
+  1. For continuous sub-array questions if we need to find the length of particular problem or anything, make use of map for efficient approach, in case of len use index usage 
 </pre>
 
diff --git a/Samsung R & D/SWC_3RDJULY.txt b/Samsung R & D/SWC_3RDJULY.txt
index 84dce5d..87c415b 100644
--- a/Samsung R & D/SWC_3RDJULY.txt
+++ b/Samsung R & D/SWC_3RDJULY.txt
@@ -13,7 +13,7 @@ distance of marathon: D
 Total Health: H
 5 lines each if 3 space separated integers decnoting paces.
 
-contraints:
+constraints:
 3 <= D <= 40
 10 <= H <= 100
 3 <= minutes <= 6
diff --git a/Searching Sorting/README.md b/Searching Sorting/README.md
index fecf5b0..09c519d 100644
--- a/Searching Sorting/README.md
+++ b/Searching Sorting/README.md
@@ -1,19 +1,19 @@
 # Applications
   <pre>
-  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Searching%20Sorting/15.%20atleast%20trailing%20zeros.cpp">Atleast N trailing zeros in O(log N)</a></b>
+  <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Searching%20Sorting/15.%20atleast%20trailing%20zeros.cpp">At least N trailing zeros in O(log N)</a></b>
    log n means binary search with l = 0 and h = 5*n
    high = mid
-   low = mid+1(atleast)
+   low = mid+1(at least)
    so return low
    
   <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Searching%20Sorting/17.%20merging%20overlap%20intervals.cpp">Merging Overlap intervals</a></b>  and <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/Searching%20Sorting/18.%20Merging%20overlap%20intervals%202.cpp">Merging Overlap intervals 2</a></b>
      
-      start  end  //initalize
+      start  end  //initialize
      Q1. [[1,2],[1,3],[2,5]]     update end if end >= intervals[i][0]  //merging intervals case
      Q2. 
          1. push intervals less than range
          2. for merging intervals into single interval 
-             within this range compare each element and update( initialzing start,end = newInterval)
+             within this range compare each element and update( initializing start,end = newInterval)
              intervals[i][0] <= newInterval[1]:
              
 		                         [1,5] - newInterval
@@ -36,12 +36,12 @@
   
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Searching%20Sorting/29.%20Min%20Swaps%20to%20sort.cpp">Minimum swaps to sort</a></b>
   make parallel view of input and result
-  find pattern for swapping to which element by storing indexs
+  find pattern for swapping to which element by storing indexes
    </pre>
    
 # STL
   <pre>
-   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Searching%20Sorting/32.%20Max%20index%20difference.cpp">Max index difference</a></b>: Just search elements which are Arr[i] <= Arr[j] by making parralel view
+   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Searching%20Sorting/32.%20Max%20index%20difference.cpp">Max index difference</a></b>: Just search elements which are Arr[i] <= Arr[j] by making parallel view
    Make a parallel array if you want to search for greater elements instead of searching all logic 
  
   accumulate(a,a+n,sum) //find sum of all elements within range, we can modify it
diff --git a/Stack/README.md b/Stack/README.md
index 3efa47e..6dc1363 100644
--- a/Stack/README.md
+++ b/Stack/README.md
@@ -20,7 +20,7 @@
            s1: 1 2 3 4 5
     <b><a href="https://github.com/teja963/DSA-and-MYSQL/blob/master/Stack/8.%20Next%20greater%20element.cpp">Next greater Element</a></b>
     Traverse from right to left and keep storing the each and every elements in the stack
-    when arriving element is greater than s.top(), then pop all the elements untill that condition
+    when arriving element is greater than s.top(), then pop all the elements until that condition
           
     <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/Stack/13.%20Max%20rectangle%20in%20histogram.cpp">Max Rectangle area in Histogram</a></b>
                               _ _         _ _
@@ -49,8 +49,8 @@
     <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/Stack/17.%20Simplify%20Path.cpp">Simplify Path</a></b>
     	Store /content//
     	push string between /  and / in the stack
-    	if string is "." current direcotry
-    	if string is ".." parent direcotry so pop current
+    	if string is "." current directory
+    	if string is ".." parent directory so pop current
     	otherwise push in the stack
   </pre>
     
diff --git a/String/README.md b/String/README.md
index db09f69..fe3047d 100644
--- a/String/README.md
+++ b/String/README.md
@@ -15,7 +15,7 @@
                                                 
         Apply Kadane's algo for finding max sum subarray
         
-   <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/String/13.%20Next%20permutation.cpp">Next Permuation</a></b>
+   <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/String/13.%20Next%20permutation.cpp">Next Permutation</a></b>
           <img alt="Gif" width="550" height="200" src="https://github.com/teja963/DSA_All_Models/blob/master/String/images/31_Next_Permutation.gif">
           
    <b>Imp:</b> <b><a href="https://github.com/teja963/DSA_All_Models/blob/master/String/18.%20Vowels%20of%20all%20substrings.cpp">Vowels of all substrings</a></b>        <b>Application:</b> <b><a href="https://www.hackerrank.com/challenges/the-minion-game/problem?isFullScreen=true">Minion game question</a></b>     <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/String/18.%20Minion%20Game.py">Solution</a></b>    <b><a href="https://github.com/teja963/Advanced-DSA-and-CS-Theory/blob/master/String/3.%20Count%20no%20of%20subarrays.java">Count no.of subarrays</a></b>
@@ -23,17 +23,17 @@
           a ab abe abea                        ith is vowel
           b be bea                                 |
           e ea                               left / \ right                                          not include, nums greater than K, multiple times
-          a                                  (i+1)     (n - i) times it repeates in substring        so make count = 0, after each iteration of num greater than k
+          a                                  (i+1)     (n - i) times it repeats in substring        so make count = 0, after each iteration of num greater than k
                                        ending with     starting with
                                      ith character      ith character substring
           
    <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/String/34.%20Exactly%20one%20swap.cpp">Exactly one swap</a></b>
      i
    g e e k                if we take g (egek, eegk ,keeg)
-                          similiarly if we take frst e(geek, gkee)
+                          similarly if we take frst e(geek, gkee)
    for ith character we know (n - i -1)swaps are possible among those we need to reduce duplicate cases
    so if we swap e with e, then it can't be distnict string so use map to update frequencies 
-   m[s[i]]--;   **it will remove duplicate characters swaping**
+   m[s[i]]--;   **it will remove duplicate characters swapping**
    ans += (n - i - 1 - m[s[i]])
    
    <b><a href="https://github.com/teja963/DSA-and-MYSQL/blob/master/String/25.%20Next%20Highest%20Palindrome.cpp">Next Highest Palindrome in O(N Log N)</a></b>
@@ -46,7 +46,7 @@
      prefix = a[0];
      while traversing array of strings update prefix
      
-   <b><a href="https://github.com/teja963/DSA-and-MYSQL/blob/master/Sliding%20Window/4.%20Count%20anagrams.cpp">Count Anagram</a></b> or <b><a href="https://github.com/teja963/DSA-and-MYSQL/blob/master/String/29.Permutation%20in%20String.cpp">Permuation in string</a></b>
+   <b><a href="https://github.com/teja963/DSA-and-MYSQL/blob/master/Sliding%20Window/4.%20Count%20anagrams.cpp">Count Anagram</a></b> or <b><a href="https://github.com/teja963/DSA-and-MYSQL/blob/master/String/29.Permutation%20in%20String.cpp">Permutation in string</a></b>
     Same concept application of anagrams
     If s1's pemutation is present in s2, if permutations equal means sort(s1) == sort(s2)
     In Simple way without sorting use map m1 == m2, then permutation of s1 is present in s2
@@ -56,7 +56,7 @@
    2 strings are special equivalent such that s1 == s2,
    s1: abcd     s2: adcb
    we can make any no.of swaps of even or odd characters to check its equal means,
-   odd characters and even charcters are same so, convert every string to 
+   odd characters and even characters are same so, convert every string to 
    s: sort (odd_characters) + sort ( even_characters)
    
    <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/String/35.%20Transform%20string.cpp">Transform string</a></b>
@@ -64,7 +64,7 @@
    <b>Best method for both strings has same characters using subtraction irrespective of order</b>
    traverse from end of string
    
-   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/String/36.%20Longest%20Valid%20Parantheses.cpp">Longest Valid parantheses</a></b>
+   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/String/36.%20Longest%20Valid%20Parantheses.cpp">Longest Valid parentheses</a></b>
    Go from left to right and keep count of open and close, if gng to rgt side, close increases is invalid so make (open, close) = 0
    similarly gng from right to left, open value increases make both 0
    
@@ -80,7 +80,7 @@
    <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/String/39.%20Word%20pattern.cpp">Word Pattern</a></b>
    	check case pattern.size > s.size and s.size > pattern.size	
   </pre>
-# Palindrome releated
+# Palindrome related
   <pre>
   <b><a href="https://github.com/teja963/Advanced-DSA/blob/master/String/37.%20Minimum%20characters%20to%20be%20added%20at%20front%20to%20make%20it%20palindrome.java">Min characters to be added at front to make it palindrome</a></b>
   <b>Imp concept</b>: In palindrome if we take any character u will get mini palindrome
diff --git a/Trie/README.md b/Trie/README.md
index fa99a2f..5609850 100644
--- a/Trie/README.md
+++ b/Trie/README.md
@@ -1,4 +1,4 @@
 # All Trie Implementation
-   How to insert into trie and search implmentation Contains Children (for storing char values in nodes) and leaf(checking for end of the string by bool) 
+   How to insert into trie and search implementation Contains Children (for storing char values in nodes) and leaf(checking for end of the string by bool) 
     
   <a href="https://github.com/teja963/DSA_All_Models/blob/master/Trie/1_insert_and_search.cpp" >1.Insert and Search</a>


Test patch: