feat: Java，python for azl397985856#1-en

Author: azl397985856

problems/1.two-sum.en.md

@@ -29,7 +29,9 @@ The easiest solution to come up with is Brute Force. We could write two for-loop
 
 ## Code
 
-- Support Language: JS
+- Support Language: JS,C++,Java,Python
+
+Javascript Code:
 
 ```js
 /**
@@ -49,6 +51,55 @@ const twoSum = function (nums, target) {
 };
 ```
 
+C++ Code:
+
+```cpp
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+        unordered_map<int, int> hashtable;
+        for (int i = 0; i < nums.size(); ++i) {
+            auto it = hashtable.find(target - nums[i]);
+            if (it != hashtable.end()) {
+                return {it->second, i};
+            }
+            hashtable[nums[i]] = i;
+        }
+        return {};
+    }
+};
+```
+
+Java Code:
+
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> hashtable = new HashMap<Integer, Integer>();
+        for (int i = 0; i < nums.length; ++i) {
+            if (hashtable.containsKey(target - nums[i])) {
+                return new int[]{hashtable.get(target - nums[i]), i};
+            }
+            hashtable.put(nums[i], i);
+        }
+        return new int[0];
+    }
+}
+```
+
+Python Code:
+
+```py
+class Solution:
+    def twoSum(self, nums: List[int], target: int) -> List[int]:
+        hashtable = dict()
+        for i, num in enumerate(nums):
+            if target - num in hashtable:
+                return [hashtable[target - num], i]
+            hashtable[nums[i]] = i
+        return []
+```
+
 **_Complexity Anlysis_**
 
 - _Time Complexity_: O(N)