diff --git a/README.md b/README.md
index 4364cb0..82383e4 100644
--- a/README.md
+++ b/README.md
@@ -1,19 +1,19 @@
-# Grind75 Solutions & Resources: JavaScript
+# Grind75 Solutions: JavaScript
 
-As I work through this list I figure I would make a GitHub repo with my solutions along with articles and videos that relate to the problems that I've found helpful. 
+Grind75 Solutions in JavaScript with comments explaining my thought process and the code, links to the original problem, the instructions, and some test cases
 
 ## The problems
-1. [Two Sum](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/twosum-1.md)
-2. Valid Parentheses
-3. Merge Two Sorted Lists
-4. Best Time to Buy and Sell Stock
-5. Valid Palindrome
-6. Invert Binary Tree
-7. Valid Anagram
-8. Binary Search
-9. Flood Fill
-10. Maximum Subarray
-11. Lowest Common Ancestor of a Binary Search Tree
+1. [Two Sum](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/1-2sum.js)
+2. [Valid Parentheses](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/20-validParentheses.js)
+3. [Merge Two Sorted Lists](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/21-mergeTwoSortedLists.js)
+4. [Best Time to Buy and Sell Stock](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/121-bestTimeToSellAndBuyStock.js)
+5. [Valid Palindrome](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/125-validPalindrome.js)
+6. [Invert Binary Tree](https://github.com/20jasper/codewars-and-leetcode/blob/47634f23a4ea9a45a9bcf43c8a16eb516f2f9949/LeetCode/226-invertBinaryTree.js)
+7. [Valid Anagram](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/242-validAnagram.js)
+8. [Binary Search](https://github.com/20jasper/codewars-and-leetcode/blob/47634f23a4ea9a45a9bcf43c8a16eb516f2f9949/LeetCode/704-binarySearch.js)
+9. [Flood Fill](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/733-floodFill.js)
+10. [Maximum Subarray](https://github.com/20jasper/codewars-and-leetcode/blob/a6ba1fa2a4a8cab3bcef31ac5e6cff4187be7b43/LeetCode/53-maximumSubarray.js)
+11. [Lowest Common Ancestor of a Binary Search Tree](https://github.com/20jasper/codewars-and-leetcode/blob/70e7232f81/LeetCode/235-lowestCommonAncestorOfABinarySearchTree.js)
 12. Balanced Binary Tree
 13. Linked List Cycle
 14. Implement Queue using Stacks
@@ -28,26 +28,26 @@ As I work through this list I figure I would make a GitHub repo with my solution
 23. Diameter of Binary Tree
 24. Middle of the Linked List
 25. Maximum Depth of Binary Tree
-26. Contains Duplicate
+26. [Contains Duplicate](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/217-containsDuplicate.js)
 27. Insert Interval
 28. 01 Matrix
 29. K Closest Points to Origin
-30. Longest Substring Without Repeating Characters
-31. 3Sum
+30. [Longest Substring Without Repeating Characters](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/3-longestSubstringWithoutRepeatingCharacters.js)
+31. [3Sum](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/15-3sum.js)
 32. Binary Tree Level Order Traversal
 33. Clone Graph
 34. Evaluate Reverse Polish Notation
 35. Course Schedule
 36. Implement Trie (Prefix Tree)
 37. Coin Change
-38. Product of Array Except Self
+38. [Product of Array Except Self](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/238-productOfArrayExceptSelf.js)
 39. Validate Binary Search Tree
-40. Number of Islands
+40. [Number of Islands](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/200-numberOfIslands.js)
 41. Rotting Oranges
 42. Search in Rotated Sorted Array
 43. Combination Sum
 44. Permutations
-45. Merge Intervals
+45. [Merge Intervals](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/56-mergeIntervals.js)
 46. Lowest Common Ancestor of a Binary Tree
 47. Time Based Key-Value Store
 48. Accounts Merge
@@ -55,13 +55,13 @@ As I work through this list I figure I would make a GitHub repo with my solution
 50. Word Break
 51. Partition Equal Subset Sum
 52. String to Integer (atoi)
-53. Spiral Matrix
+53. [Spiral Matrix](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/54-spiralMatrix.js)
 54. Subsets
 55. Binary Tree Right Side View
 56. Longest Palindromic Substring
 57. Unique Paths
 58. Construct Binary Tree from Preorder and Inorder Traversal
-59. Container With Most Water
+59. [Container With Most Water](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/11-containerWithMostWater.js)
 60. Letter Combinations of a Phone Number
 61. Word Search
 62. Find All Anagrams in a String
@@ -71,7 +71,7 @@ As I work through this list I figure I would make a GitHub repo with my solution
 66. Kth Smallest Element in a BST
 67. Minimum Window Substring
 68. Serialize and Deserialize Binary Tree
-69. Trapping Rain Water
+69. [Trapping Rain Water](https://github.com/20jasper/codewars-and-leetcode/blob/main/LeetCode/42-trappingRainWater.js)
 70. Find Median from Data Stream
 71. Word Ladder
 72. Basic Calculator
@@ -79,49 +79,6 @@ As I work through this list I figure I would make a GitHub repo with my solution
 74. Merge k Sorted Lists
 75. Largest Rectangle in Histogram
 
-
-## Data Structures
-In order to practice with similar data structures I'll be placing each problem in the categories below, along with some similar problems nested below to help practice with those data structures.
-
-### Array
-1. [Two Sum](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/twosum-1.md)
-
-### Hash Table
-1. [Two Sum](https://github.com/curtisbarnard/leetcode-grind75-javascript/blob/main/easy/twosum-1.md)
-
-## Algorithm Patterns
-Within the problems above there are several patterns that often occur. I plan to categorize each problem such that if you are having problem with a particular pattern you can look for other similar problems that use the same pattern.
-
-### Sliding Window
-
-### Two Pointers
-
-### Fast & Slow Pointers
-
-### Merge Intervals
-
-### Cyclic Sort
-
-### In-place Reversal of Linked List
-
-### Tree Breadth First Search
-
-### Tree Depth First Search
-
-### Two Heaps
-
-### Subsets
-
-### Modified Binary Search
-
-### Top K Elements
-
-### K-Way Merge
-
-### Topological Sort
-
-
-
 ## Attribution
 - The original Grind 75 list can be found [here](https://www.techinterviewhandbook.org/grind75)
-- The original list of patterns was sourced from [here](https://hackernoon.com/14-patterns-to-ace-any-coding-interview-question-c5bb3357f6ed)
+- The original markdown file can be found [here](https://github.com/curtisbarnard/leetcode-grind75-javascript)
diff --git a/easy/twosum-1.md b/easy/twosum-1.md
deleted file mode 100644
index 396890a..0000000
--- a/easy/twosum-1.md
+++ /dev/null
@@ -1,69 +0,0 @@
-# Two Sum
-
-Page on leetcode: https://leetcode.com/problems/two-sum/
-
-## Problem Statement
-
-Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
-You may assume that each input would have exactly one solution, and you may not use the same element twice.
-You can return the answer in any order.
-**Follow-up:** Can you come up with an algorithm that is less than O(n2) time complexity?
-
-### Constraints
-
-- 2 <= nums.length <= 104
-- -109 <= nums[i] <= 109
-- -109 <= target <= 109
-- Only one valid answer exists.
-
-### Example
-
-Input: nums = [2,7,11,15], target = 9
-Output: [0,1]
-Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
-
-## Solution
-
-### Pseudocode
-
-1. Shift first element from array store in var
-2. loop thru array
-3. check var + num[i] === target
-4. If not successful shift next element and repeat
-
-### Initial Solution
-
-This solution has a time complexity O(n<sup>2</sup>)
-
-```javascript
-var twoSum = function (nums, target) {
-  const initialLength = nums.length;
-  for (let i = 0; i < initialLength; i++) {
-    let testNum = nums.shift();
-    for (let j = 0; j < nums.length; j++) {
-      if (testNum + nums[j] === target) {
-        return [i, i + j + 1];
-      }
-    }
-  }
-};
-```
-
-### Optimized Solution
-
-Using a map (hash map) reduces the time complexity to O(n). Here is a good video with an explanation: https://www.youtube.com/watch?v=KLlXCFG5TnA
-
-```javascript
-var twoSum = function (nums, target) {
-  const map = new Map();
-  for (let i = 0; i < nums.length; i++) {
-    const n = nums[i];
-    if (map.has(target - n)) {
-      return [map.get(target - n), i];
-    } else {
-      map.set(n, i);
-    }
-  }
-  return [];
-};
-```
