Python力扣 两数之和

ling830

第一个力扣题，通过。
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案，并且你不能使用两次相同的元素。

你可以按任意顺序返回答案。



示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]


提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

1. class Solution:
   
2.     def twoSum(self, nums: List[int], target: int) -> List[int]:
   
3.        from typing import List
   
4. 
   
5. class Solution:
   
6.     def twoSum(self, nums: List[int], target: int) -> List[int]:
   
7.         # 注意：这里必须缩进（通常是4个或8个空格）
   
8.         hashmap = {}
   
9.         for i, num in enumerate(nums):
   
10.             complement = target - num
    
11.             if complement in hashmap:
    
12.                 return [hashmap[complement], i]
    
13.             hashmap[num] = i
    
14.         # 函数结束，返回一个空列表作为兜底
    
15.         return []
    
16. 
    
17. # 这里空一行，下面的 if 必须完全顶格（最左边），不能有空格
    
18. if __name__ == '__main__':
    
19.     # 实例化
    
20.     sol = Solution()
    
21.     # 测试数据
    
22.     nums = [2, 7, 11, 15]
    
23.     target = 9
    
24.     # 调用并打印
    
25.     result = sol.twoSum(nums, target)
    
26.     print(f"最终结果: {result}")

复制代码

进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

1. from typing import List
   
2. 
   
3. class Solution:
   
4.     def twoSum(self, nums: List[int], target: int) -> List[int]:
   
5.         # 创建账本 (哈希表)
   
6.         hashmap = {}
   
7.         
   
8.         for i, num in enumerate(nums):
   
9.             # 算出需要的那个“另一半”
   
10.             complement = target - num
    
11.             
    
12.             # 直接翻账本，看另一半是不是已经在里面了
    
13.             if complement in hashmap:
    
14.                 # 找到了，返回[旧人下标, 新人下标]
    
15.                 return [hashmap[complement], i]
    
16.             
    
17.             # 没找到，就把自己的值和下标存进账本
    
18.             hashmap[num] = i
    
19.             
    
20.         return []
    
21. 
    
22. if __name__ == '__main__':
    
23.     sol = Solution()
    
24.     # 模拟测试：数据量大时，这个算法的优势极明显
    
25.     test_nums = [2, 7, 11, 15]
    
26.     test_target = 9
    
27.     print(f"&#10024; 质控匹配结果（下标）: {sol.twoSum(test_nums, test_target)}")

复制代码

FishC

你的代码有几个关键错误，我来帮你修正。力扣第一题“两数之和”最简单的解法是用哈希表，正确写法如下：

1. 
   
2. from typing import List
   
3. 
   
4. class Solution:
   
5.     def twoSum(self, nums: List[int], target: int) -> List[int]:
   
6.         hashmap = {}
   
7.         for i, num in enumerate(nums):
   
8.             complement = target - num
   
9.             if complement in hashmap:
   
10.                 return [hashmap[complement], i]
    
11.             hashmap[num] = i
    
12.         return []
    

复制代码

主要问题：

• 重复定义了两次 class Solution，只保留一个。
• 导入 List 应放在文件开头。
• 哈希表存储错误：应该是 hashmap[num] = i，不是 hashmap = i。
• 返回时应该是 return [hashmap[complement], i]（注意补全下标）。
• 最后兜底返回 return [] 而不是 return 。
  

测试部分也要修正：

1. 
   
2. if __name__ == '__main__':
   
3.     sol = Solution()
   
4.     nums = [2, 7, 11, 15]
   
5.     target = 9
   
6.     result = sol.twoSum(nums, target)
   
7.     print(f"最终结果: {result}")
   

复制代码

这个经典题的核心思路是：用字典记录已经遍历过的数字及其下标，对每个新数字，检查目标差值是否在字典里。如果找到，立即返回两个下标。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

ling830

给你一个整数 x ，如果 x 是一个回文整数，返回 true ；否则，返回 false 。

回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

例如，121 是回文，而 123 不是。


示例 1：

输入：x = 121
输出：true
示例 2：

输入：x = -121
输出：false
解释：从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3：

输入：x = 10
输出：false
解释：从右向左读, 为 01 。因此它不是一个回文数。


提示：

-231 <= x <= 231 - 1

1. class Solution:
   
2.     def isPalindrome(self, x: int) -> bool:
   
3.         # 1. 负数肯定不是回文
   
4.         if x < 0:
   
5.             return False
   
6.         
   
7.         # 2. 将数字转为字符串
   
8.         s = str(x)
   
9.         
   
10.         # 3. 对比原字符串和反转后的字符串
    
11.         return s == s[::-1]
    
12. 
    
13. # --- 下面这部分代码必须“靠边站”（顶格） ---
    
14. if __name__ == '__main__':
    
15.     sol = Solution()
    
16.     test_x = 121
    
17.     print(f"数字 {test_x} 是回文吗？{sol.isPalindrome(test_x)}")

复制代码

进阶：你能不将整数转为字符串来解决这个问题吗？

1. class Solution:
   
2.     def isPalindrome(self, x: int) -> bool:
   
3.         # 1. 特殊情况排除：
   
4.         # 负数不是回文（如 -121）
   
5.         # 最后一位是 0 但本身不是 0 的数不是回文（如 10, 100）
   
6.         if x < 0 or (x % 10 == 0 and x != 0):
   
7.             return False
   
8. 
   
9.         reverted_number = 0
   
10.         # 2. 核心循环：只翻转数字的一半
    
11.         while x > reverted_number:
    
12.             # 每次取 x 的最后一位，加到翻转数字的末尾
    
13.             reverted_number = reverted_number * 10 + x % 10
    
14.             # x 去掉最后一位
    
15.             x //= 10
    
16. 
    
17.         # 3. 结果判断：
    
18.         # 如果是偶数位（如1221），x == reverted_number (12 == 12)
    
19.         # 如果是奇数位（如121），x == reverted_number // 10 (1 == 12//10)
    
20.         return x == reverted_number or x == reverted_number // 10
    
21. 
    
22. # --- 本地测试 ---
    
23. if __name__ == '__main__':
    
24.     sol = Solution()
    
25.     print(f"12321 是回文吗？{sol.isPalindrome(12321)}") # True
    
26.     print(f"123 是回文吗？{sol.isPalindrome(123)}")     # False

复制代码

FishC

ling830 发表于 2026-05-10 14:18
给你一个整数 x ，如果 x 是一个回文整数，返回 true  ...

好的，回文数判断有简单高效的方法。这里给出两种常见解法，推荐使用字符串反转的第一种，代码最简洁：

1. 
   
2. class Solution:
   
3.     def isPalindrome(self, x: int) -> bool:
   
4.         # 负数直接返回 False（负号破坏了对称性）
   
5.         if x < 0:
   
6.             return False
   
7.         # 将整数转为字符串，反转后比较
   
8.         return str(x) == str(x)[::-1]
   

复制代码

如果面试要求不借助字符串，可用数学方法只反转一半数字：

1. 
   
2. class Solution:
   
3.     def isPalindrome(self, x: int) -> bool:
   
4.         # 负数和末位为0的正数（除0本身）不是回文
   
5.         if x < 0 or (x % 10 == 0 and x != 0):
   
6.             return False
   
7.         reverted = 0
   
8.         while x > reverted:
   
9.             reverted = reverted * 10 + x % 10
   
10.             x //= 10
    
11.         # 偶数位时 x == reverted；奇数位时去掉中间一位再比较
    
12.         return x == reverted or x == reverted // 10
    

复制代码

核心思路：正负判断 + 利用反转后的字符串与原字符串比较；或反转整数的一半后与另一半比较。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。