class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
length = len(nums)
for x in range(length):
for y in range(x+1,length):
if (nums[x] + nums[y]) == target:
return [x,y]
class Solution:
def twoSum(self , nums: List[int], target: int) -> List[int]:
num1 = list(map(lambda x: x - target/2, nums))
num2 = list(filter(lambda x: x < 0, num1))
num3 = list(filter(lambda x: x >= 0, num1))
if num3.count(0) >= 2:
return [num1.index(0) , len(num1[:num1.index(0)+1]) + num1[(num1.index(0)+1):].index(0)]
else:
for i in (num2 if len(num2) < len(num3) else num3):
if -i in (num3 if len(num2) < len(num3) else num2):
return [num1.index(i),num1.index(-i)]
break
3️⃣ 构建哈希表
python复制代码
class Solution:
def twoSum(self, nums: List[int], target: int) -> List[int]:
a = {}
for i , num in enumerate(nums):
if (target - num) in a:
return [a[target - num] , i]
a[nums[i]] = i
return []
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
res_list = [] # 用于存储结果的列表
res = None # 用于存储结果的链表
val = 0 # 用于存储当前位的和
carry = 0 # 用于存储进位的数值
current1 = l1
current2 = l2
while (current1 or current2 or carry): # 当两个链表的指针都为空 并且 进位等于0时，结束循环;
## 如果短的链表遍历完了，将其指针指向0
if not current1:
current1 = ListNode(0)
if not current2:
current2 = ListNode(0)
sum = current1.val + current2.val + carry # 计算当前位的和
val = sum % 10
carry = sum // 10
res_list.append(val)
current1 = current1.next
current2 = current2.next
for i in range(len(res_list)):
if i == 0:
res = ListNode(res_list[-1 - i])
else:
res = ListNode(res_list[-1 - i], res)
return res
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
# 初始化结果链表的头节点和当前节点
dummy_head = ListNode()
current = dummy_head
val = 0 # 用于存储当前位的和
carry = 0 # 用于存储进位的数值
current1 = l1
current2 = l2
while (current1 or current2 or carry): # 当两个链表的指针都为空 并且 进位等于0时，结束循环;
# 如果短的链表遍历完了，将其指针指向0
if not current1:
current1 = ListNode(0)
if not current2:
current2 = ListNode(0)
sum = current1.val + current2.val + carry # 计算当前位的和
val = sum % 10
carry = sum // 10
current.next = ListNode(val) # 创建新的节点，并将其作为当前节点的下一个节点
current = current.next # 将当前节点指向新节点
current1 = current1.next
current2 = current2.next
return dummy_head.next # 返回结果链表的头节点的下一个节点（第一个真正的节点）
无重复字符的最长子串
1️⃣暴力解法
从最大的子串长度开始遍历所有子串，依次判断是否满足条件，一旦满足条件退出循环，输出最长子串长度。
python复制代码
def condition(s: str) -> bool: # 判断子串是否重复，True为无重复
return len(set(s)) == len(s)
def sub_of_s(s: str, n: int) -> str: # 返回一个字符串指定长度的所有子串
return [s[i:i+n] for i in range(len(s) - n + 1)]
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
n = len(s)
result = 0
while n > 0:
for i in sub_of_s(s, n):
if condition(i):
result = n
break
n -= 1
if result != 0:
break
return result
def condition(s: str) -> bool: # 判断子串是否重复，True为无重复
return len(set(s)) == len(s)
def sub_of_s(s: str, n: int) -> str: # 返回一个字符串指定长度的所有子串
return [s[i:i+n] for i in range(len(s) - n + 1)]
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
n = len(set(s)) # 最长不重复子串长度的上界
result = 0
while n > 0:
for i in sub_of_s(s, n):
if condition(i):
result = n
break
n -= 1
if result != 0:
break
return result
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
dic = {}
res = 0
i = -1
for j in range(len(s)):
if s[j] in dic:
i = max(dic[s[j]], i) # 更新左指针 i
dic[s[j]] = j # 哈希表记录
res = max(res, j - i) # 更新结果
return res
python复制代码
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
max_length = len(set(s)) # 最长的长度
dic = {}
res = 0
i = -1
for j in range(len(s)):
if s[j] in dic:
i = max(dic[s[j]], i) # 更新左指针 i
dic[s[j]] = j # 哈希表记录
res = max(res, j - i) # 更新结果
if res == max_length:
break
return res
最长回文子串
1️⃣暴力解法
同前面一个问题中的解法一，更换一下判断条件即可，没什么可说的
python复制代码
def condition(s:str) -> bool: #判断子串是否是回文子串
return s == s[::-1]
def sub_of_s(s: str, n: int) -> str: # 返回一个字符串指定长度的所有子串
return [s[i:i+n] for i in range(len(s) - n + 1)]
class Solution:
def longestPalindrome(self, s: str) -> str:
n = len(s)
result = None
while n > 0:
for i in sub_of_s(s, n):
if condition(i):
result = i
break
n -= 1
if result != None:
break
return result
def condition(s:str) -> bool: #判断子串是否是回文子串
return s == s[::-1]
def sub_of_s(s: str, n: int) -> str: # 进行初步的筛选，并返回一个字符串指定长度的所有可能的回文子串
res = []
for i in range(len(s) - n + 1):
if s[i] == s[i+n-1]:
res.append(s[i:i+n])
return res
class Solution:
def longestPalindrome(self, s: str) -> str:
n = len(s)
result = None
while n > 0:
for i in sub_of_s(s, n):
if condition(i):
result = i
break
n -= 1
if result != None:
break
return result
