Merge branch 'main' of https://github.com/contextlab/leetcode-solutions into main

Author: paxtonfitzpatrick

problems/1509/katie.md

@@ -0,0 +1,18 @@
+Every optimal move is going to consist of moving an extreme value to the center, so you can just take the range of 4 potential subsets starting with index 0, 1, 2, or 3 all of length `len(nums)-3`
+
+```
+class Solution(object):
+    def minDifference(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        if len(nums) <=4:
+            return 0
+        nums.sort()
+        best = nums[-1] - nums[3]
+        for x in range(3):
+            best = min(best, nums[-4+x] - nums[x])
+        return best
+```
+<img width="604" alt="Screen Shot 2024-07-04 at 4 17 17 PM" src="https://github.com/KatieONell/leetcode-solutions/assets/12962290/e691f187-1c77-4ce2-92f4-0056bce4762a">

problems/2181/katie.md

@@ -0,0 +1,36 @@
+# [Problem 2181: Merge Nodes In Between Zeros](https://leetcode.com/problems/merge-nodes-in-between-zeros/description/)
+
+## Initial thoughts (stream-of-consciousness)
+Essentially I want to hang on to each zero node, and progressively check the next nodes. Every node that isn't zero, the sum should be added to the OG node and then should be dropped out of the list by making a new link between the OG node and the nextnext node. 
+When we get to another 0, we want to repeat this process.
+
+## Refining the problem
+The final 0 is annoying... I'll add a statement where if the next.next is None, then break out of the loop
+
+## Attempted solution(s)
+```
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution(object):
+    def mergeNodes(self, head):
+        """
+        :type head: Optional[ListNode]
+        :rtype: Optional[ListNode]
+        """
+        node = head
+        while node.next != None:
+            if node.next.val != 0:
+                node.val += node.next.val
+                node.next = node.next.next
+            else:
+                if node.next.next == None:
+                    node.next = None
+                    break
+                node = node.next
+        return head
+```
+<img width="479" alt="Screen Shot 2024-07-04 at 4 44 32 PM" src="https://github.com/KatieONell/leetcode-solutions/assets/12962290/1864b9ab-f280-431e-88c8-f118c64f03b4">
+

problems/350/katie.md

@@ -0,0 +1,22 @@
+# [Problem 350: Intersection of Two Arrays II](https://leetcode.com/problems/intersection-of-two-arrays-ii/description/)
+
+## Initial thoughts (stream-of-consciousness)
+first order of business is figuring out which elements are present in both; second is getting the number of times
+
+## Refining the problem
+
+## Attempted solution(s)
+```
+class Solution(object):
+    def intersect(self, nums1, nums2):
+        """
+        :type nums1: List[int]
+        :type nums2: List[int]
+        :rtype: List[int]
+        """
+        intersection = []
+        for x in set(nums1).intersection(set(nums2)):
+            intersection.extend([x]*min(nums1.count(x), nums2.count(x)))
+        return intersection
+```
+<img width="611" alt="Screen Shot 2024-07-04 at 4 27 44 PM" src="https://github.com/KatieONell/leetcode-solutions/assets/12962290/eda945af-174a-4b98-b6b2-0332b9db4fd6">