add 203 solution

Author: BrianRuizy

203 - Remove Linked List Elements.md

@@ -0,0 +1,74 @@
+# Remove Linked List Elements
+
+Difficulty: easy
+Done: Yes
+Last edited: February 27, 2022 1:25 AM
+Link: https://leetcode.com/problems/remove-linked-list-elements/
+Topic: linked list
+
+## Problem
+
+Given the `head` of a linked list and an integer `val`, remove all the nodes of the linked list that has `Node.val == val`, and return *the new head*.
+
+```
+Input: head = [1,2,6,3,4,5,6], val = 6
+Output: [1,2,3,4,5]
+```
+
+## Solution
+
+Similar to linked list reversal using two pointer iterative approach. Whenever the current node in traversals value is equivalent to our target, we point the `previous` node to the `current.next` node. Else, we will continue our traversal. Hereby shifting the previous pointer and current pointer iteratively.
+
+There’s a caveat, however, whenever the first node of our list is our target —or repeated. Because previous remains undefined. Therefore we need to check if previous is defined beforehand.
+
+## Whiteboard
+
+![With target value equal to 6](images/203-1.png)
+
+With target value equal to 6
+
+![Problem becomes trickier when target exist as first (or consecutively) node(s)](images/%203-2.png)
+
+Problem becomes trickier when target exist as first (or consecutively) node(s)
+
+## Code
+
+```python
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+class Solution:
+    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
+        
+        # for empty list
+        if head is None:
+            return None
+        
+        current = head
+        previous = None
+            
+        while current is not None:
+                            
+            if current.val == val: 
+                
+                if previous is None:
+                    # this will happen when target exist at first node 
+                    # or consectuive first (n) nodes
+                    head = head.next
+                    current = head
+                
+                if previous: 
+                    previous.next = current.next
+                    current.next = None
+                    current = previous.next
+                
+            # else keep traversing
+            else: 
+                previous = current
+                current = current.next
+                
+            
+        return head
+```

217 - Contains Duplicates.md

@@ -10,14 +10,14 @@ Given an integer array `nums`, return `true` if any value appears **at least
 
 ## Solution
 
-Naive solution would be to loop trhough all elements in array and comparing to the rest of the elements in the array, to see if *i* matches *j.* This would result in a O(N^2) solution since we are using performing N times for loop inside N time for loop. 
+Naive solution would be to loop through all elements in array and comparing to the rest of the elements in the array, to see if *i* matches *j.* This would result in a O(N^2) solution since we are using performing N times for loop inside N time for loop. 
 
 A better approach would be to run through the array just once, and using additional space to copy over traversed elements to a data structure. If *i* is already in our data structure we raise flag and break, without having to finish traversing all elements, since we only need 1 duplicate. 
 
 ## Code
 
 ```python
-class Solution:
+class Solution:  
     def containsDuplicate(self, nums: List[int]) -> bool:
         d = set()
         duplicates = False