diff --git a/Binary Search - Leetcode 704/Binary Search - Leetcode 704.py b/Binary Search - Leetcode 704/Binary Search - Leetcode 704.py
index 12a81b5..5133116 100644
--- a/Binary Search - Leetcode 704/Binary Search - Leetcode 704.py	
+++ b/Binary Search - Leetcode 704/Binary Search - Leetcode 704.py	
@@ -1,19 +1,21 @@
-class Solution:
-    def search(self, nums: List[int], target: int) -> int:
-        left = 0
-        right = len(nums) - 1
 
-        while left <= right:
-            middle = (right + left) // 2
+def search(nums, target) -> int:
+    left = 0
+    right = len(nums) - 1
 
-            if nums[middle] == target:
-                return middle
-            elif nums[middle] > target:
-                right = middle - 1
-            else:
-                left = middle + 1
+    while left <= right:
+        middle = (right + left) // 2
 
-        return -1
+        if nums[middle] == target:
+            return middle
+        elif nums[middle] > target:
+            right = middle - 1
+        else:
+            left = middle + 1
+
+    return -1
+
+print(search([-1, 0, 3, 5, 9, 12], 9))
 
 # Time Complexity: O(log(n))
 # Space Complexity: O(1)
diff --git a/Binary Search - Leetcode 704/tempCodeRunnerFile.py b/Binary Search - Leetcode 704/tempCodeRunnerFile.py
new file mode 100644
index 0000000..5485a2c
--- /dev/null
+++ b/Binary Search - Leetcode 704/tempCodeRunnerFile.py	
@@ -0,0 +1 @@
+List
\ No newline at end of file
diff --git a/Fibonacci Number - Leetcode 509/Fibonacci Number - Leetcode 509.py b/Fibonacci Number - Leetcode 509/Fibonacci Number - Leetcode 509.py
index e082c70..19a0aba 100644
--- a/Fibonacci Number - Leetcode 509/Fibonacci Number - Leetcode 509.py	
+++ b/Fibonacci Number - Leetcode 509/Fibonacci Number - Leetcode 509.py	
@@ -2,70 +2,72 @@
 
 # Time: O(2^n)
 # Space: O(n)
-class Solution:
-    def fib(self, n: int) -> int:
-        if n == 0:
-            return 0
-        elif n == 1:
-            return 1
-        else:
-            return self.fib(n-1) + self.fib(n-2)
+
+def fib(n: int) -> int:
+    if n == 0:
+        return 0
+    elif n == 1:
+        return 1
+    else:
+        return fib(n-1) + fib(n-2)
 
 
 # Top Down Memoized
 
 # Time: O(n)
 # Space: O(n)
-class Solution:
-    def fib(self, n: int) -> int:
-        memo = {0:0, 1:1}
 
-        def f(x):
-            if x in memo:
-                return memo[x]
-            else:
-                memo[x] = f(x-1) + f(x-2)
-                return memo[x]
-        
-        return f(n)
+def fib2(n: int) -> int:
+    memo = {0:0, 1:1}
+
+    def f(x):
+        if x in memo:
+            return memo[x]
+        else:
+            memo[x] = f(x-1) + f(x-2)
+            return memo[x]
+    
+    return f(n)
 
 
 # Bottom Up Tabulation
 
 # Time: O(n)
 # Space: O(n)
-class Solution:
-    def fib(self, n: int) -> int:
-        if n == 0:
-            return 0
-        if n == 1:
-            return 1
 
-        dp = [0] * (n+1)
-        dp[0] = 0
-        dp[1] = 1
+def fib3(n: int) -> int:
+    if n == 0:
+        return 0
+    if n == 1:
+        return 1
+
+    dp = [0] * (n+1)
+    dp[0] = 0
+    dp[1] = 1
 
-        for i in range(2, n+1):
-            dp[i] = dp[i-2] + dp[i-1]
+    for i in range(2, n+1):
+        dp[i] = dp[i-2] + dp[i-1]
 
-        return dp[n]
+    return dp[n]
 
 
 # Bottom Up Constant Space
 
 # Time: O(n)
 # Space: O(1)
-class Solution:
-    def fib(self, n: int) -> int:
-        if n == 0:
-            return 0
-        if n == 1:
-            return 1
-
-        prev = 0
-        cur = 1
-
-        for i in range(2, n+1):
-            prev, cur = cur, prev+cur
-        
-        return cur
+
+def fib4(n: int) -> int:
+    if n == 0:
+        return 0
+    if n == 1:
+        return 1
+
+    prev = 0
+    cur = 1
+
+    for i in range(2, n+1):
+        prev, cur = cur, prev+cur
+    
+    return cur
+
+print(fib4(10))
diff --git a/Roman to Integer - Leetcode 13/Roman to Integer - Leetcode 13.py b/Roman to Integer - Leetcode 13/Roman to Integer - Leetcode 13.py
index b4e0f48..272e2c2 100644
--- a/Roman to Integer - Leetcode 13/Roman to Integer - Leetcode 13.py	
+++ b/Roman to Integer - Leetcode 13/Roman to Integer - Leetcode 13.py	
@@ -1,18 +1,21 @@
-class Solution:
-    def romanToInt(self, s: str) -> int:
-        d = {'I': 1, 'V':5, 'X':10, 'L':50, 'C':100, 'D': 500, 'M':1000}
-        summ = 0
-        n = len(s)
-        i = 0
-        
-        while i < n:
-            if i < n - 1 and d[s[i]] < d[s[i+1]]:
-                summ += d[s[i+1]] - d[s[i]]
-                i += 2
-            else:
-                summ += d[s[i]]
-                i += 1
-        
-        return summ
-        # Time: O(n)
-        # Space: O(1)
+
+def romanToInt(s) -> int:
+    d = {'I': 1, 'V':5, 'X':10, 'L':50, 'C':100, 'D': 500, 'M':1000}
+    summ = 0
+    n = len(s)
+    i = 0
+    
+    while i < n:
+        if i < n - 1 and d[s[i]] < d[s[i+1]]:
+            summ += d[s[i+1]] - d[s[i]]
+            i += 2
+        else:
+            summ += d[s[i]]
+            i += 1
+    
+    return summ
+    # Time: O(n)
+    # Space: O(1)
+
+print(romanToInt("MCMXCIV"))
+
diff --git a/Subsets - Leetcode 78/Subsets - Leetcode 78.py b/Subsets - Leetcode 78/Subsets - Leetcode 78.py
index 0739377..38567d9 100644
--- a/Subsets - Leetcode 78/Subsets - Leetcode 78.py	
+++ b/Subsets - Leetcode 78/Subsets - Leetcode 78.py	
@@ -1,23 +1,25 @@
-class Solution:
-    def subsets(self, nums: List[int]) -> List[List[int]]:
-        n = len(nums)
-        res, sol = [], []
 
-        def backtrack(i):
-            if i == n:
-                res.append(sol[:])
-                return
+def subsets(nums):
+    n = len(nums)
+    res, sol = [], []
 
-            # Don't pick nums[i]
-            backtrack(i + 1)
+    def backtrack(i):
+        if i == n:
+            res.append(sol[:])
+            return
 
-            # Pick nums[i]
-            sol.append(nums[i])
-            backtrack(i + 1)
-            sol.pop()
+        # Don't pick nums[i]
+        backtrack(i + 1)
+        # Pick nums[i]
+        sol.append(nums[i])
+        backtrack(i + 1)
+        sol.pop()
 
-        backtrack(0)
-        return res
+    backtrack(0)
+    return res
+
+print(subsets([1, 2, 3]))
 
 # Time Complexity: O(2^n)
 # Space Complexity: O(n)
+