feat: add solutions to lc problem: No.1218

No.1218.Longest Arithmetic Subsequence of Given Difference

Author: maolonglong

solution/1200-1299/1218.Longest Arithmetic Subsequence of Given Difference/README.md

@@ -56,15 +56,68 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def longestSubsequence(self, arr: List[int], difference: int) -> int:
+        dp, ans = defaultdict(int), 1
+        for num in arr:
+            dp[num] = dp[num - difference] + 1
+            ans = max(ans, dp[num])
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public int longestSubsequence(int[] arr, int difference) {
+        Map<Integer, Integer> dp = new HashMap<>();
+        int ans = 1;
+        for (int num : arr) {
+            dp.put(num, dp.getOrDefault(num - difference, 0) + 1);
+            ans = Math.max(ans, dp.get(num));
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int longestSubsequence(vector<int>& arr, int difference) {
+        unordered_map<int, int> dp;
+        int ans = 1;
+        for (int num : arr) {
+            dp[num] = dp[num - difference] + 1;
+            ans = max(ans, dp[num]);
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func longestSubsequence(arr []int, difference int) int {
+	dp, ans := make(map[int]int), 1
+	for _, num := range arr {
+		dp[num] = dp[num-difference] + 1
+		ans = max(ans, dp[num])
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/1200-1299/1218.Longest Arithmetic Subsequence of Given Difference/README_EN.md

@@ -78,13 +78,66 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def longestSubsequence(self, arr: List[int], difference: int) -> int:
+        dp, ans = defaultdict(int), 1
+        for num in arr:
+            dp[num] = dp[num - difference] + 1
+            ans = max(ans, dp[num])
+        return ans
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public int longestSubsequence(int[] arr, int difference) {
+        Map<Integer, Integer> dp = new HashMap<>();
+        int ans = 1;
+        for (int num : arr) {
+            dp.put(num, dp.getOrDefault(num - difference, 0) + 1);
+            ans = Math.max(ans, dp.get(num));
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int longestSubsequence(vector<int>& arr, int difference) {
+        unordered_map<int, int> dp;
+        int ans = 1;
+        for (int num : arr) {
+            dp[num] = dp[num - difference] + 1;
+            ans = max(ans, dp[num]);
+        }
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func longestSubsequence(arr []int, difference int) int {
+	dp, ans := make(map[int]int), 1
+	for _, num := range arr {
+		dp[num] = dp[num-difference] + 1
+		ans = max(ans, dp[num])
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
 ```
 
 ### **...**

solution/1200-1299/1218.Longest Arithmetic Subsequence of Given Difference/Solution.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int longestSubsequence(vector<int>& arr, int difference) {
+        unordered_map<int, int> dp;
+        int ans = 1;
+        for (int num : arr) {
+            dp[num] = dp[num - difference] + 1;
+            ans = max(ans, dp[num]);
+        }
+        return ans;
+    }
+};

solution/1200-1299/1218.Longest Arithmetic Subsequence of Given Difference/Solution.go

@@ -0,0 +1,15 @@
+func longestSubsequence(arr []int, difference int) int {
+	dp, ans := make(map[int]int), 1
+	for _, num := range arr {
+		dp[num] = dp[num-difference] + 1
+		ans = max(ans, dp[num])
+	}
+	return ans
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}

solution/1200-1299/1218.Longest Arithmetic Subsequence of Given Difference/Solution.java

@@ -0,0 +1,11 @@
+class Solution {
+    public int longestSubsequence(int[] arr, int difference) {
+        Map<Integer, Integer> dp = new HashMap<>();
+        int ans = 1;
+        for (int num : arr) {
+            dp.put(num, dp.getOrDefault(num - difference, 0) + 1);
+            ans = Math.max(ans, dp.get(num));
+        }
+        return ans;
+    }
+}

solution/1200-1299/1218.Longest Arithmetic Subsequence of Given Difference/Solution.py

@@ -0,0 +1,7 @@
+class Solution:
+    def longestSubsequence(self, arr: List[int], difference: int) -> int:
+        dp, ans = defaultdict(int), 1
+        for num in arr:
+            dp[num] = dp[num - difference] + 1
+            ans = max(ans, dp[num])
+        return ans