Updated markdown files

Author: Zanger67/leetcode

markdowns/_1. Two Sum.md

@@ -0,0 +1,90 @@
+# 1. [Two Sum](<https://leetcode.com/problems/two-sum>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[Array](<by_topic/Array.md>), [Hash Table](<by_topic/Hash Table.md>)**
+>
+> **Acceptance Rate** : **53.036 %**
+
+------
+
+> test test test again iasdfdsaf
+
+------
+
+## Solutions
+
+- [e1 - brute force.java](<../my-submissions/e1 - brute force.java>)
+- [e1.java](<../my-submissions/e1.java>)
+- [e1.py](<../my-submissions/e1.py>)
+### Java
+#### [e1 - brute force.java](<../my-submissions/e1 - brute force.java>)
+```Java
+// Slow and O(n^2)
+// See alternative OTHER for hashmap solution
+
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        for (int i = 0; i < nums.length - 1; i++) {
+            for (int j = i+1; j < nums.length; j++) {
+                if (nums[i] + nums[j] == target) {
+                    return new int[]{i, j};
+                }
+            }
+        }
+
+        return new int[]{};
+    }
+}
+```
+
+#### [e1.java](<../my-submissions/e1.java>)
+```Java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        if (nums.length == 2) {
+            return new int[]{0, 1};
+        }
+
+        HashMap<Integer, Integer> ref = new HashMap<>();
+
+        for (int i = 0; i < nums.length; i++) {
+            if (ref.containsKey(nums[i])) {
+                return new int[]{ref.get(nums[i]), i};
+            }
+            ref.put((target - nums[i]), i);
+        }
+
+        // No solution (shouldn't occur given parameters provided)
+        return new int[]{0, 0};
+    }
+}
+```
+
+### Python
+#### [e1.py](<../my-submissions/e1.py>)
+```Python
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        if len(nums) == 2 :
+            return [0, 1]
+
+        differences = {}
+        for i in range(len(nums)) :
+            if nums[i] in differences.keys() :
+                return [i, differences.get(nums[i])]
+            differences[target - nums[i]] = i
+        return [0, 0]
+        
+```
+

markdowns/_14. Longest Common Prefix.md

@@ -0,0 +1,50 @@
+# 14. [Longest Common Prefix](<https://leetcode.com/problems/longest-common-prefix>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[String](<by_topic/String.md>), [Trie](<by_topic/Trie.md>)**
+>
+> **Acceptance Rate** : **43.195 %**
+
+------
+
+## Solutions
+
+- [e14.java](<../my-submissions/e14.java>)
+### Java
+#### [e14.java](<../my-submissions/e14.java>)
+```Java
+class Solution {
+    public String longestCommonPrefix(String[] strs) {
+        if (strs.length == 1) {
+            return strs[0];
+        }
+
+        int shortestLen = strs[0].length();
+        for (int i = 0; i < strs.length; i++) {
+            shortestLen = Math.min(strs[i].length(), shortestLen);
+        }
+
+        for (int i = 0; i < shortestLen; i++) {
+            for (int j = 1; j < strs.length; j++) {
+                if (strs[j].charAt(i) != strs[j - 1].charAt(i)) {
+                    return strs[0].substring(0,i);
+                }
+            }
+        }
+
+        return strs[0].substring(0, shortestLen);
+    }
+}
+```
+

markdowns/_2. Add Two Numbers.md

@@ -0,0 +1,104 @@
+# 2. [Add Two Numbers](<https://leetcode.com/problems/add-two-numbers>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[Linked List](<by_topic/Linked List.md>), [Math](<by_topic/Math.md>), [Recursion](<by_topic/Recursion.md>)**
+>
+> **Acceptance Rate** : **43.366 %**
+
+------
+
+## Solutions
+
+- [m2.java](<../my-submissions/m2.java>)
+### Java
+#### [m2.java](<../my-submissions/m2.java>)
+```Java
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode() {}
+ *     ListNode(int val) { this.val = val; }
+ *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+ * }
+ */
+class Solution {
+    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
+        if (l1 == null || l2 == null) {
+            return null;
+        }
+
+        ListNode output = new ListNode();
+        ListNode current = output;
+        int carry = 0;
+        while (l1 != null && l2 != null) {
+            current.val = l1.val + l2.val + carry;
+            carry = 0;
+            if (current.val >= 10) {
+                current.val -= 10;
+                carry = 1;
+            }
+
+
+            if (l1.next == null || l2.next == null) {
+                break;
+            }
+
+            current.next = new ListNode();
+            current = current.next;
+            l1 = l1.next;
+            l2 = l2.next;
+        }
+
+
+        while (l1.next != null) {
+            current.next = new ListNode();
+            current = current.next;
+            l1 = l1.next;
+
+
+            current.val = l1.val + carry;
+            carry = 0;
+            if (current.val >= 10) {
+                current.val -= 10;
+                carry = 1;
+            }
+
+        }
+
+        while (l2.next != null) {
+            current.next = new ListNode();
+            current = current.next;
+            l2 = l2.next;
+            
+            current.val = l2.val + carry;
+            carry = 0;
+            if (current.val >= 10) {
+                current.val -= 10;
+                carry = 1;
+            }
+
+        }
+
+        if (carry == 1) {
+            current.next = new ListNode(1);
+        }
+
+
+        return output;
+    }
+}
+```
+

markdowns/_3. Longest Substring Without Repeating Characters.md

@@ -0,0 +1,52 @@
+# 3. [Longest Substring Without Repeating Characters](<https://leetcode.com/problems/longest-substring-without-repeating-characters>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[Hash Table](<by_topic/Hash Table.md>), [String](<by_topic/String.md>), [Sliding Window](<by_topic/Sliding Window.md>)**
+>
+> **Acceptance Rate** : **35.039 %**
+
+------
+
+## Solutions
+
+- [m3.java](<../my-submissions/m3.java>)
+### Java
+#### [m3.java](<../my-submissions/m3.java>)
+```Java
+class Solution {
+    public int lengthOfLongestSubstring(String s) {
+        int maxSoFar = 0;
+        for (int i = 0; i < s.length() && s.length() - i > maxSoFar; i++) {
+            int counter = 0;
+            HashSet<Character> temp = new HashSet<>();
+            for (int j = i; j < s.length(); j++) {
+                if (temp.contains(s.charAt(j))) {
+                    break;
+                } else {
+                    temp.add(s.charAt(j));
+                }
+
+                counter++;
+            }
+
+            if (maxSoFar < counter) {
+                maxSoFar = counter;
+            }
+        }
+
+        return maxSoFar;
+    }
+}
+```
+

markdowns/_5. Longest Palindromic Substring.md

@@ -0,0 +1,95 @@
+# 5. [Longest Palindromic Substring](<https://leetcode.com/problems/longest-palindromic-substring>)
+
+*All prompts are owned by LeetCode. To view the prompt, click the title link above.*
+
+*[Back to top](<../README.md>)*
+
+------
+
+> *First completed : July 10, 2024*
+>
+> *Last updated : July 10, 2024*
+
+------
+
+> **Related Topics** : **[Two Pointers](<by_topic/Two Pointers.md>), [String](<by_topic/String.md>), [Dynamic Programming](<by_topic/Dynamic Programming.md>)**
+>
+> **Acceptance Rate** : **34.08 %**
+
+------
+
+> ***Version 1*** is severly inefficient since it checks each pair of indicies, reasulting in at 
+> least $O(n^2)$ runtime. On top of that, the inside of the nested loop has another for loop 
+> to check whether the substring is a palindrome. This would make the runtime increase further 
+> to a worst case leaning towards $O(n^3)$. While it does avoid redundant cases (i.e.) substrings 
+> of a length that wouldn't improve the current record, it's still a major negative.
+> 
+> </br>
+> 
+> ***Version 2*** on the other hand avoids this by starting from the centre of each potential palindrome. 
+> It iterates through the string twice, once where it assumes the centre is a single character (and thus at 
+> least a palindrome of length $n$) and again where the indices $i$ and $i+1$ are used as the centre. In effect, 
+> it's checking odd and even length palindromes. This ends up being comfortably $O(n^2)$; a much greater improvement 
+> as compared to *Version 1*.
+
+------
+
+## Solutions
+
+- [m5 v1 inefficient.py](<../my-submissions/m5 v1 inefficient.py>)
+- [m5 v2 much better.py](<../my-submissions/m5 v2 much better.py>)
+### Python
+#### [m5 v1 inefficient.py](<../my-submissions/m5 v1 inefficient.py>)
+```Python
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        longest = 0
+        longsetS = ''
+        for i in range(len(s)) :
+            for j in range(len(s) - 1, i - 1, -1) :
+                if j - i + 1 <= longest :
+                    continue
+                isPal = True
+                for k in range((j - i + 1) // 2) :
+                    if s[i + k] != s[j - k] :
+                        isPal = False
+                        break
+                if isPal :
+                    longest = j - i + 1
+                    longsetS = s[i: j+1]
+
+        return longsetS
+```
+
+#### [m5 v2 much better.py](<../my-submissions/m5 v2 much better.py>)
+```Python
+class Solution:
+    def longestPalindrome(self, s: str) -> str:
+        longest = 0
+        longsetS = ''
+        for i in range(len(s)) :
+            currOffset = 1
+            while 0 <= i - currOffset and \
+                  i + currOffset < len(s) and \
+                  s[i - currOffset] == s[i + currOffset] :
+                currOffset += 1
+            currOffset -= 1
+
+            if longest < currOffset * 2 + 1 :
+                longest = currOffset * 2 + 1
+                longsetS = s[i - currOffset : i + currOffset + 1]
+
+        for i in range(0, len(s) - 1) :
+            currOffset = 0
+            while 0 <= i - currOffset and \
+                  i + currOffset + 1 < len(s) and \
+                  s[i - currOffset] == s[i + currOffset + 1] :
+                currOffset += 1
+
+            if longest < currOffset * 2 :
+                longest = currOffset * 2
+                longsetS = s[i - currOffset + 1 : i + currOffset + 1]
+
+        return longsetS
+```
+