1: Solve in Python

README.md

@@ -20,6 +20,7 @@ favors time.
 
 ## 🧩 Solved
 
+- [x] 1. Two Sum
 - [x] 217. Contains Duplicate
 - [x] 242. Valid Anagram
 

python3/1/a.py

@@ -0,0 +1,15 @@
+# Algorithm/technique: nested iteration
+# Time complexity:     O(n^2)
+# Auxiliary space:     O(1)
+# Optimal:             no
+
+class Solution:
+    def twoSum(self, nums: list[int], target: int) -> list[int]:
+        n = len(nums)
+
+        # enumerate does not allow the last item to be skipped without slicing,
+        # which would require linear auxiliary space.
+        for i in range(n - 1):
+            for j in range(i + 1, n):
+                if nums[i] + nums[j] == target:
+                    return [i, j]

python3/1/b.py

@@ -0,0 +1,22 @@
+# Algorithm/technique: sorting
+# Time complexity:     O(n lb n)
+# Auxiliary space:     O(n)
+# Optimal:             no
+
+class Solution:
+    def twoSum(self, nums: list[int], target: int) -> list[int]:
+        l = 0
+        r = len(nums) - 1
+        snums = sorted(nums)
+
+        while l < r:
+            total = snums[l] + snums[r]
+            if total == target:
+                res = [nums.index(snums[l]), nums.index(snums[r])]
+                if res[0] == res[1]:
+                    res[1] = nums.index(snums[r], res[0] + 1)
+                return res
+            elif total < target:
+                l += 1
+            else:
+                r -= 1

python3/1/c.py

@@ -0,0 +1,14 @@
+# Algorithm/technique: hash table
+# Time complexity:     O(n)
+# Auxiliary space:     O(n)
+# Optimal:             yes
+
+class Solution:
+    def twoSum(self, nums: list[int], target: int) -> list[int]:
+        visited = {}
+
+        for i, num in enumerate(nums):
+            diff = target - num
+            if diff in visited:
+                return [visited[diff], i]
+            visited[num] = i

python3/217/217-contains-duplicate-a.py → python3/217/a.py

@@ -1,19 +1,16 @@
-# Programming language: Python 3
-# Algorithm/technique:  nested iteration
-# Time complexity:      O(n^2)
-# Auxiliary space:      O(1)
-# Optimal:              no
-# Notes:
+# Algorithm/technique: nested iteration
+# Time complexity:     O(n^2)
+# Auxiliary space:     O(1)
+# Optimal:             no
 
 class Solution:
     def containsDuplicate(self, nums: list[int]) -> bool:
         n = len(nums)
-
         if n < 2:
             return False
 
         # enumerate does not allow the last item to be skipped without slicing,
-        # which would require O(n) auxiliary space.
+        # which would require linear auxiliary space.
         for i in range(n - 1):
             for j in range(i + 1, n):
                 if nums[i] == nums[j]:

python3/217/217-contains-duplicate-b.py → python3/217/b.py

@@ -1,9 +1,7 @@
-# Programming language: Python 3
-# Algorithm/technique:  sorting
-# Time complexity:      O(n lb n)
-# Auxiliary space:      O(1)
-# Optimal:              no
-# Notes:
+# Algorithm/technique: sorting
+# Time complexity:     O(n lb n)
+# Auxiliary space:     O(1)
+# Optimal:             no
 
 class Solution:
     def containsDuplicate(self, nums: list[int]) -> bool:

python3/217/217-contains-duplicate-c.py → python3/217/c.py

@@ -1,9 +1,7 @@
-# Programming language: Python 3
-# Algorithm/technique:  set
-# Time complexity:      O(n)
-# Auxiliary space:      O(n)
-# Optimal:              yes
-# Notes:
+# Algorithm/technique: hash table
+# Time complexity:     O(n)
+# Auxiliary space:     O(n)
+# Optimal:             yes
 
 class Solution:
     def containsDuplicate(self, nums: list[int]) -> bool:

python3/217/217-contains-duplicate-d.py → python3/217/d.py

@@ -1,9 +1,7 @@
-# Programming language: Python 3
-# Algorithm/technique:  set
-# Time complexity:      O(n)
-# Auxiliary space:      O(n)
-# Optimal:              yes
-# Notes:
+# Algorithm/technique: hash table
+# Time complexity:     O(n)
+# Auxiliary space:     O(n)
+# Optimal:             yes
 
 class Solution:
     def containsDuplicate(self, nums: list[int]) -> bool:

python3/242/a.py

@@ -0,0 +1,11 @@
+# Algorithm/technique: sorting
+# Time complexity:     O(n lb n)
+# Auxiliary space:     O(1)
+# Optimal:             no
+
+class Solution:
+    def isAnagram(self, s: str, t: str) -> bool:
+        if len(s) != len(t):
+            return False
+
+        return s.sort() == t.sort()

python3/242/242-valid-anagram-b.py → python3/242/b.py

@@ -1,9 +1,7 @@
-# Programming language: Python 3
-# Algorithm/technique:  hash table
-# Time complexity:      O(n)
-# Auxiliary space:      O(n)
-# Optimal:              yes
-# Notes:
+# Algorithm/technique: hash table
+# Time complexity:     O(n)
+# Auxiliary space:     O(n)
+# Optimal:             yes
 
 class Solution:
     def isAnagram(self, s: str, t: str) -> bool:

python3/242/242-valid-anagram-c.py → python3/242/c.py

@@ -1,9 +1,7 @@
-# Programming language: Python 3
-# Algorithm/technique:  hash table
-# Time complexity:      O(n)
-# Auxiliary space:      O(n)
-# Optimal:              yes
-# Notes:
+# Algorithm/technique: hash table
+# Time complexity:     O(n)
+# Auxiliary space:     O(n)
+# Optimal:             yes
 
 from collections import Counter