github網址：https://github.com/yflfly
1、面試題39. 數組中出現次數超過一半的數字
數組中有一個數字出現的次數超過數組長度的一半，請找出這個數字。
你可以假設數組是非空的，並且給定的數組總是存在多數元素。
示例 1:
輸入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
輸出: 2
class Solution:
def majorityElement(self, nums: List[int]) -> int:
dict1 = {}
for each in nums:
if each not in dict1:
dict1[each] = 1
else:
dict1[each] += 1
length = len(nums)//2
for each in dict1:
if dict1[each] > length:
return each
2、面試題50. 第一個只出現一次的字符
在字符串 s 中找出第一個只出現一次的字符。如果沒有，返回一個單空格。
示例:
s = "abaccdeff"
返回 "b"
s = ""
返回 " "
class Solution:
def firstUniqChar(self, s: str) -> str:
d1 = {}
for each in s:
if each not in d1:
d1[each] = 1
else:
d1[each] += 1
for key in s:
if d1[key] == 1:
return key
return ' '
3、面試題15. 二進制中1的個數
請實現一個函數，輸入一個整數，輸出該數二進制表示中 1 的個數。例如，把 9 表示成二進制是 1001，有 2 位是 1。因此，如果輸入 9，則該函數輸出 2。
示例 1：
輸入：00000000000000000000000000001011
輸出：3
解釋：輸入的二進制串 00000000000000000000000000001011 中，共有三位爲 '1'。
示例 2：
輸入：00000000000000000000000010000000
輸出：1
解釋：輸入的二進制串 00000000000000000000000010000000 中，共有一位爲 '1'。
示例 3：
輸入：11111111111111111111111111111101
輸出：31
解釋：輸入的二進制串 11111111111111111111111111111101 中，共有 31 位爲 '1'。
class Solution:
def hammingWeight(self, n: int) -> int:
return list(str(bin(n))).count('1')
4、面試題18. 刪除鏈表的節點
給定單向鏈表的頭指針和一個要刪除的節點的值，定義一個函數刪除該節點。
返回刪除後的鏈表的頭節點。
注意：此題對比原題有改動
示例 1:
輸入: head = [4,5,1,9], val = 5
輸出: [4,1,9]
解釋: 給定你鏈表中值爲 5 的第二個節點，那麼在調用了你的函數之後，該鏈表應變爲 4 -> 1 -> 9.
示例 2:
輸入: head = [4,5,1,9], val = 1
輸出: [4,5,9]
解釋: 給定你鏈表中值爲 1 的第三個節點，那麼在調用了你的函數之後，該鏈表應變爲 4 -> 5 -> 9.
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def deleteNode(self, head: ListNode, val: int) -> ListNode:
pre = head
if head.val == val:
return head.next
while pre.next:
if pre.next.val == val:
pre.next = pre.next.next
else:
pre = pre.next
return head
5、面試題11. 旋轉數組的最小數字
把一個數組最開始的若干個元素搬到數組的末尾，我們稱之爲數組的旋轉。輸入一個遞增排序的數組的一個旋轉，輸出旋轉數組的最小元素。例如，數組 [3,4,5,1,2] 爲 [1,2,3,4,5] 的一個旋轉，該數組的最小值爲1。
示例 1：
輸入：[3,4,5,1,2]
輸出：1
示例 2：
輸入：[2,2,2,0,1]
輸出：0
# 自己的代碼
class Solution:
def minArray(self, numbers: List[int]) -> int:
return min(numbers)
# 大神的代碼：二分查找
class Solution:
def minArray(self, numbers: List[int]) -> int:
if not numbers: return
start, end = 0, len(numbers) - 1
while start < end:
middle = (start + end) // 2
if numbers[middle] > numbers[end]: start = middle + 1
elif numbers[middle] < numbers[end]: end = middle
# 其實這個end-=1很巧妙，因爲相等的時候我們無法判斷要往哪個方向縮小
# 所以索性就縮小numbers的長度。
else: end -= 1
return numbers[start]
6、
'''
21. 合併兩個有序鏈表
將兩個升序鏈表合併爲一個新的升序鏈表並返回。新鏈表是通過拼接給定的兩個鏈表的所有節點組成的。
示例：
輸入：1->2->4, 1->3->4
輸出：1->1->2->3->4->4
22
'''
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
result_node = ListNode(0)
node = result_node
head1 = l1
head2 = l2
while (head1 and head2):
if head1.val < head2.val:
node.next = head1
head1 = head1.next
node = node.next
else:
node.next = head2
head2 = head2.next
node = node.next
while head1:
node.next = head1
head1 = head1.next
node = node.next
while head2:
node.next = head2
head2 = head2.next
node = node.next
return result_node.next
7、'''
290. 單詞規律
給定一種規律 pattern 和一個字符串 str ，判斷 str 是否遵循相同的規律。
這裏的 遵循 指完全匹配，例如， pattern 裏的每個字母和字符串 str 中的每個非空單詞之間存在着雙向連接的對應規律。
示例1:
輸入: pattern = "abba", str = "dog cat cat dog"
輸出: true
示例 2:
輸入:pattern = "abba", str = "dog cat cat fish"
輸出: false
示例 3:
輸入: pattern = "aaaa", str = "dog cat cat dog"
輸出: false
示例 4:
輸入: pattern = "abba", str = "dog dog dog dog"
輸出: false
說明:
你可以假設 pattern 只包含小寫字母， str 包含了由單個空格分隔的小寫字母。
'''
class Solution:
def wordPattern(self, pattern: str, str: str) -> bool:
l1 = list(pattern)
l2 = str.split()
dict1 = {}
if len(l1) != len(l2):
return False
for i in range(len(l1)):
if l1[i] not in dict1:
dict1[l1[i]] = l2[i]
else:
if dict1[l1[i]] != l2[i]:
return False
if len(list(set(dict1.values()))) != len(dict1.values()):
return False
return True
8、'''
219. 存在重複元素 II
給定一個整數數組和一個整數 k，判斷數組中是否存在兩個不同的索引 i 和 j，使得 nums [i] = nums [j]，並且 i 和 j 的差的 絕對值 至多爲 k。
示例 1:
輸入: nums = [1,2,3,1], k = 3
輸出: true
示例 2:
輸入: nums = [1,0,1,1], k = 1
輸出: true
示例 3:
輸入: nums = [1,2,3,1,2,3], k = 2
輸出: false
'''
# 下面代碼會報超出時間限制
class Solution:
def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
for i in range(len(nums)):
for m in range(k):
if i+m+1 < len(nums):
if nums[i] == nums[i+m+1]:
return True
return False
# 下面的代碼通過，for循環使用的少可以減少運行時間
class Solution:
def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
dict1 = {}
for i in range(len(nums)):
if nums[i] in dict1:
if i-dict1[nums[i]] <= k:
return True
dict1[nums[i]] = i
return False
9、# coding:utf-8
'''
面試題 01.05. 一次編輯
字符串有三種編輯操作:插入一個字符、刪除一個字符或者替換一個字符。 給定兩個字符串，編寫一個函數判定它們是否只需要一次(或者零次)編輯。
示例 1:
輸入:
first = "pale"
second = "ple"
輸出: True
示例 2:
輸入:
first = "pales"
second = "pal"
輸出: False
'''
class Solution:
def oneEditAway(self, first: str, second: str) -> bool:
if abs(len(list(first))-len(list(second))) > 1:
return False
flag = 0
if len(list(first)) == len(list(second)):
for i in range(len(first)):
if first[i] != second[i]:
flag += 1
if flag > 1:
return False
return True
else:
min_ = first if len(first) == min(len(first),len(second)) else second
max_ = first if min_== second else second
linshi = min_
if max_.find(min_) != -1:
return True
for j in range(len(max_)):
if linshi[j] != max_[j]:
flag += 1
linshi = linshi[:j]+max_[j]+linshi[j:]
if flag > 1:
return False
return True
10、
'''
203. 移除鏈表元素
刪除鏈表中等於給定值 val 的所有節點。
示例:
輸入: 1->2->6->3->4->5->6, val = 6
輸出: 1->2->3->4->5
'''
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def removeElements(self, head: ListNode, val: int) -> ListNode:
cur_1 = ListNode(0)
cur = cur_1
while head:
if head.val == val:
head = head.next
else:
cur.next = ListNode(head.val)
cur = cur.next
head = head.next
return cur_1.next
11、
'''
441. 排列硬幣
1、你總共有 n 枚硬幣，你需要將它們擺成一個階梯形狀，第 k 行就必須正好有 k 枚硬幣。
給定一個數字 n，找出可形成完整階梯行的總行數。
n 是一個非負整數，並且在32位有符號整型的範圍內。
示例 1:
n = 5
硬幣可排列成以下幾行:
¤
¤ ¤
¤ ¤
因爲第三行不完整，所以返回2.
示例 2:
n = 8
硬幣可排列成以下幾行:
¤
¤ ¤
¤ ¤ ¤
¤ ¤
因爲第四行不完整，所以返回3.
代碼如下所示：
'''
from math import sqrt, floor
class Solution:
def arrangeCoins(self, n: int) -> int:
return floor(sqrt(1/4+2*n)-1/2)
12、
'''
面試題53 - II. 0～n-1中缺失的數字
一個長度爲n-1的遞增排序數組中的所有數字都是唯一的，並且每個數字都在範圍0～n-1之內。在範圍0～n-1內的n個數字中有且只有一個數字不在該數組中，請找出這個數字。
示例 1:
輸入: [0,1,3]
輸出: 2
示例 2:
輸入: [0,1,2,3,4,5,6,7,9]
輸出: 8
'''
class Solution:
def missingNumber(self, nums: List[int]) -> int:
list1 = [i for i in range(len(nums)+1)]
return sum(list1)-sum(nums)
13、
'''
2. 兩數相加
給出兩個 非空 的鏈表用來表示兩個非負的整數。其中，它們各自的位數是按照 逆序 的方式存儲的，並且它們的每個節點只能存儲 一位 數字。
如果，我們將這兩個數相加起來，則會返回一個新的鏈表來表示它們的和。
您可以假設除了數字 0 之外，這兩個數都不會以 0 開頭。
示例：
輸入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
輸出：7 -> 0 -> 8
原因：342 + 465 = 807
'''
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
list1 = []
list2 = []
l1_ = l1
l2_ = l2
while l1_:
list1.append(l1_.val)
l1_ = l1_.next
while l2_:
list2.append(l2_.val)
l2_ = l2_.next
int1 = 0
for i in range(len(list1)-1,-1,-1):
int1 += list1[i] *10**i
int2 = 0
for i in range(len(list2)-1,-1,-1):
int2 += list2[i] *10**i
c = int1 + int2
c_list = list(str(c))
cur_ = ListNode(0)
cur = cur_
for i in range(len(c_list) - 1, -1, -1):
linshi = ListNode(0)
linshi.val = int(c_list[i])
cur.next = linshi
cur = cur.next
return cur_.next
'''
17. 電話號碼的字母組合
給定一個僅包含數字 2-9 的字符串，返回所有它能表示的字母組合。
給出數字到字母的映射如下（與電話按鍵相同）。注意 1 不對應任何字母。
示例:
輸入："23"
輸出：["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
'''
class Solution:
def letterCombinations(self, digits: str) -> List[str]:
dict1 = {'2': 'abc', '3': 'def', '4': 'ghi', '5': 'jkl', '6': 'mno', '7': 'pqrs', '8': 'tuv', '9': 'wxyz'}
if len(digits) == 0:
return []
if len(digits) == 1:
return list(dict1[digits[0]])
res = self.letterCombinations(digits[1:])
res_zuhe = []
for i in res:
for j in dict1[digits[0]]:
res_zuhe.append(j+i)
return res_zuhe
'''
面試題56 - I. 數組中數字出現的次數
一個整型數組 nums 裏除兩個數字之外，其他數字都出現了兩次。請寫程序找出這兩個只出現一次的數字。要求時間複雜度是O(n)，空間複雜度是O(1)。
示例 1：
輸入：nums = [4,1,4,6]
輸出：[1,6] 或 [6,1]
示例 2：
輸入：nums = [1,2,10,4,1,4,3,3]
輸出：[2,10] 或 [10,2]
'''
class Solution:
def singleNumbers(self, nums: List[int]) -> List[int]:
dict1 = {}
for each in nums:
if each not in dict1:
dict1[each] = 1
else:
dict1[each] += 1
list1 = []
for each in dict1:
if dict1[each] == 1:
list1.append(each)
return list1
'''
88. 合併兩個有序數組
給你兩個有序整數數組 nums1 和 nums2，請你將 nums2 合併到 nums1 中，使 nums1 成爲一個有序數組。
說明:
初始化 nums1 和 nums2 的元素數量分別爲 m 和 n 。
你可以假設 nums1 有足夠的空間（空間大小大於或等於 m + n）來保存 nums2 中的元素。
示例:
輸入:
nums1 = [1,2,3,0,0,0], m = 3
nums2 = [2,5,6], n = 3
輸出: [1,2,2,3,5,6]
'''
class Solution:
def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
"""
Do not return anything, modify nums1 in-place instead.
"""
for i in range(len(nums2)):
nums1[i + m] = nums2[i]
nums1 = nums1.sort()
# 下面的方法也可以實現功能，但是提交不通過，本題是要不改變nums1的前提下通過，且不需要return語句
def merge(nums1, m, nums2, n):
"""
Do not return anything, modify nums1 in-place instead.
"""
nums1 = nums1[:m]
for i in range(len(nums2)):
# print(nums1)
for j in range(len(nums1)):
if nums2[i] == 'False':
continue
if nums2[i] <= nums1[j]:
nums1.insert(j, nums2[i])
nums2[i] = 'False'
break
if nums2[i] != 'False':
nums1.append(nums2[i])
return nums1
'''
15. 三數之和
給你一個包含 n 個整數的數組 nums，判斷 nums 中是否存在三個元素 a，b，c ，使得 a + b + c = 0 ？請你找出所有滿足條件且不重複的三元組。
注意：答案中不可以包含重複的三元組。
示例：
給定數組 nums = [-1, 0, 1, 2, -1, -4]，
滿足要求的三元組集合爲：
[
[-1, 0, 1],
[-1, -1, 2]
]
'''
class Solution:
def threeSum(self, nums: List[int]) -> List[List[int]]:
result = []
if len(nums) < 3:
return []
nums.sort()
n = len(nums)
for i in range(len(nums) - 2):
if nums[i] > 0:
break
left, right = i + 1, n - 1
if i > 0 and nums[i] == nums[i - 1]:
continue
while left < right:
s = nums[i] + nums[left] + nums[right]
if s < 0:
left += 1
while left < right and nums[left] == nums[left - 1]:
left += 1
elif s > 0:
right = right - 1
while left < right and nums[right] == nums[right + 1]:
right = right - 1
else:
result.append([nums[i], nums[left], nums[right]])
left += 1
right = right -1
while left < right and nums[left] == nums[left - 1]:
left += 1
while left < right and nums[right] == nums[right + 1]:
right = right - 1
return result
'''
709. 轉換成小寫字母
實現函數 ToLowerCase()，該函數接收一個字符串參數 str，並將該字符串中的大寫字母轉換成小寫字母，之後返回新的字符串。
示例 1：
輸入: "Hello"
輸出: "hello"
示例 2：
輸入: "here"
輸出: "here"
示例 3：
輸入: "LOVELY"
輸出: "lovely"
'''
class Solution:
def toLowerCase(self, str: str) -> str:
return str.lower()
# coding:utf-8
'''
面試題 17.07. 嬰兒名字
每年，政府都會公佈一萬個最常見的嬰兒名字和它們出現的頻率，也就是同名嬰兒的數量。有些名字有多種拼法，例如，John 和 Jon 本質上是相同的名字，但被當成了兩個名字公佈出來。給定兩個列表，一個是名字及對應的頻率，另一個是本質相同的名字對。設計一個算法打印出每個真實名字的實際頻率。注意，如果 John 和 Jon 是相同的，並且 Jon 和 Johnny 相同，則 John 與 Johnny 也相同，即它們有傳遞和對稱性。
在結果列表中，選擇字典序最小的名字作爲真實名字。
示例：
輸入：names = ["John(15)","Jon(12)","Chris(13)","Kris(4)","Christopher(19)"], synonyms = ["(Jon,John)","(John,Johnny)","(Chris,Kris)","(Chris,Christopher)"]
輸出：["John(27)","Chris(36)"]
'''
import collections
def trulyMostPopular(names, synonyms):
list1 = []
for each in synonyms:
a, b = each[1:-1].split(',')
if list1 == []:
list1.append([a, b])
else:
tag = 0
for i in range(len(list1)):
if a in list1[i]:
list1[i].append(b)
tag = 1
break
elif b in list1[i]:
list1[i].append(a)
tag = 1
break
if tag == 0:
list1.append([a, b])
dict1 = collections.OrderedDict()
dict_res = collections.OrderedDict()
for elem in names:
str1, num1 = elem.split('(')[0], int(elem.split('(')[-1].split(')')[0])
dict1[str1] = num1
for each in list1:
tag = ''
for i in range(len(each)):
if not dict_res:
if each[i] in dict1:
dict_res[each[i]] = dict1[each[i]]
tag = each[i]
else:
if tag != '':
if each[i] in dict1:
dict_res[tag] += dict1[each[i]]
else:
if each[i] in dict1:
dict_res[each[i]] = dict1[each[i]]
tag = each[i]
list_res = []
for key in dict_res.keys():
list_res.append(key + '(' + str(dict_res[key]) + ')')
return list_res
names = ["John(15)", "Jon(12)", "Chris(13)", "Kris(4)", "Christopher(19)"]
synonyms = ["(Jon,John)", "(John,Johnny)", "(Chris,Kris)", "(Chris,Christopher)"]
trulyMostPopular(names, synonyms)
# coding:utf-8
'''
41. 缺失的第一個正數
給你一個未排序的整數數組，請你找出其中沒有出現的最小的正整數。
示例 1:
輸入: [1,2,0]
輸出: 3
示例 2:
輸入: [3,4,-1,1]
輸出: 2
示例 3:
輸入: [7,8,9,11,12]
輸出: 1
'''
class Solution:
def firstMissingPositive(self, nums: List[int]) -> int:
nums.sort()
if not nums:
return 1
for i in range(1, len(nums)+1):
if i not in nums:
return i
return len(nums)+1
# coding:utf-8
'''
3. 無重複字符的最長子串
給定一個字符串，請你找出其中不含有重複字符的 最長子串 的長度。
示例 1:
輸入: "abcabcbb"
輸出: 3
解釋: 因爲無重複字符的最長子串是 "abc"，所以其長度爲 3。
示例 2:
輸入: "bbbbb"
輸出: 1
解釋: 因爲無重複字符的最長子串是 "b"，所以其長度爲 1。
示例 3:
輸入: "pwwkew"
輸出: 3
解釋: 因爲無重複字符的最長子串是 "wke"，所以其長度爲 3。
請注意，你的答案必須是 子串 的長度，"pwke" 是一個子序列，不是子串。
'''
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
if len(s) == 0:
return 0
if len(list(set(list(s)))) == 1:
return 1
dict1 = {}
for i in range(len(s)):
str1 = s[i]
tag = 0
for j in range(i + 1, len(s)):
if s[j] not in str1:
str1 = str1 + s[j]
else:
if str1 not in dict1:
dict1[str1] = len(str1)
tag = 1
break
if tag == 0:
dict1[str1] = len(str1)
list1 = dict1.values()
max1 = 0
for each in list1:
if each > max1:
max1 = each
return max1
'''
1410. HTML 實體解析器
「HTML 實體解析器」 是一種特殊的解析器，它將 HTML 代碼作爲輸入，並用字符本身替換掉所有這些特殊的字符實體。
HTML 裏這些特殊字符和它們對應的字符實體包括：
雙引號：字符實體爲 " ，對應的字符是 " 。
單引號：字符實體爲 ' ，對應的字符是 ' 。
與符號：字符實體爲 & ，對應對的字符是 & 。
大於號：字符實體爲 > ，對應的字符是 > 。
小於號：字符實體爲 < ，對應的字符是 < 。
斜線號：字符實體爲 ⁄ ，對應的字符是 / 。
給你輸入字符串 text ，請你實現一個 HTML 實體解析器，返回解析器解析後的結果。
示例 1：
輸入：text = "& is an HTML entity but &ambassador; is not."
輸出："& is an HTML entity but &ambassador; is not."
解釋：解析器把字符實體 & 用 & 替換
示例 2：
輸入：text = "and I quote: "...""
輸出："and I quote: \"...\""
示例 3：
輸入：text = "Stay home! Practice on Leetcode :)"
輸出："Stay home! Practice on Leetcode :)"
示例 4：
輸入：text = "x > y && x < y is always false"
輸出："x > y && x < y is always false"
示例 5：
輸入：text = "leetcode.com⁄problemset⁄all"
輸出："leetcode.com/problemset/all"
'''
class Solution:
def entityParser(self, text: str) -> str:
dict1 = {'"': '\"', ''': "\'", '>': '>', '<': '<', '⁄': '/', '&': '&'}
for key in dict1:
text = text.replace(key, dict1[key])
return text
'''
1408. 數組中的字符串匹配
給你一個字符串數組 words ，數組中的每個字符串都可以看作是一個單詞。請你按 任意 順序返回 words 中是其他單詞的子字符串的所有單詞。
如果你可以刪除 words[j] 最左側和/或最右側的若干字符得到 word[i] ，那麼字符串 words[i] 就是 words[j] 的一個子字符串。
示例 1：
輸入：words = ["mass","as","hero","superhero"]
輸出：["as","hero"]
解釋："as" 是 "mass" 的子字符串，"hero" 是 "superhero" 的子字符串。
["hero","as"] 也是有效的答案。
示例 2：
輸入：words = ["leetcode","et","code"]
輸出：["et","code"]
解釋："et" 和 "code" 都是 "leetcode" 的子字符串。
示例 3：
輸入：words = ["blue","green","bu"]
輸出：[]
'''
class Solution:
def stringMatching(self, words: List[str]) -> List[str]:
list1 = []
for each in words:
for each2 in words:
if each != each2 and each in each2:
list1.append(each)
break
return list1
# coding:utf-8
''' 嘗試ing
722. 刪除註釋
給一個 C++ 程序，刪除程序中的註釋。這個程序source是一個數組，其中source[i]表示第i行源碼。 這表示每行源碼由\n分隔。
在 C++ 中有兩種註釋風格，行內註釋和塊註釋。
字符串// 表示行註釋，表示//和其右側的其餘字符應該被忽略。
字符串/* 表示一個塊註釋，它表示直到*/的下一個（非重疊）出現的所有字符都應該被忽略。（閱讀順序爲從左到右）非重疊是指，字符串/*/並沒有結束塊註釋，因爲註釋的結尾與開頭相重疊。
第一個有效註釋優先於其他註釋：如果字符串//出現在塊註釋中會被忽略。 同樣，如果字符串/*出現在行或塊註釋中也會被忽略。
如果一行在刪除註釋之後變爲空字符串，那麼不要輸出該行。即，答案列表中的每個字符串都是非空的。
樣例中沒有控制字符，單引號或雙引號字符。比如，source = "string s = "/* Not a comment. */";" 不會出現在測試樣例裏。（此外，沒有其他內容（如定義或宏）會干擾註釋。）
我們保證每一個塊註釋最終都會被閉合， 所以在行或塊註釋之外的/*總是開始新的註釋。
最後，隱式換行符可以通過塊註釋刪除。 有關詳細信息，請參閱下面的示例。
從源代碼中刪除註釋後，需要以相同的格式返回源代碼。
示例 1:
輸入:
source = ["/*Test program */", "int main()", "{ ", " // variable declaration ", "int a, b, c;", "/* This is a test", " multiline ", " comment for ", " testing */", "a = b + c;", "}"]
示例代碼可以編排成這樣:
/*Test program */
int main()
{
// variable declaration
int a, b, c;
/* This is a test
multiline
comment for
testing */
a = b + c;
}
輸出: ["int main()","{ "," ","int a, b, c;","a = b + c;","}"]
編排後:
int main()
{
int a, b, c;
a = b + c;
}
解釋:
第 1 行和第 6-9 行的字符串 /* 表示塊註釋。第 4 行的字符串 // 表示行註釋。
示例 2:
輸入:
source = ["a/*comment", "line", "more_comment*/b"]
輸出: ["ab"]
解釋: 原始的 source 字符串是 "a/*comment\nline\nmore_comment*/b", 其中我們用粗體顯示了換行符。刪除註釋後，隱含的換行符被刪除，留下字符串 "ab" 用換行符分隔成數組時就是 ["ab"].
'''
def removeComments(source):
list1 = []
tag = 0
for each in source:
if each.find('//') != -1 and tag == 0:
if each.find('//') < each.find('/*'):
list1.append(each.split('//')[0])
continue
if each.find('/*') == -1:
list1.append(each.split('//')[0])
continue
if each.find('/*') != -1 and each.find('*/') != -1:
if each.split('/*')[0]+each.split('*/')[-1]:
list1.append(each.split('/*')[0]+each.split('*/')[-1])
continue
if each.find('/*') != -1:
tag = 1
if each.split('/*')[0]:
list1.append(each.split('/*')[0])
continue
if each.find('*/') != -1:
tag = 0
if each.split('*/')[-1]:
list1[-1] = list1[-1]+each.split('*/')[-1]
continue
if tag == 1:
continue
list1.append(each)
return list1
# source = ["/*Test program */", "int main()", "{ ", " // variable declaration ", "int a, b, c;", "/* This is a test"," multiline ", " comment for ", " testing */", "a = b + c;", "}"]
# source = ["a/*comment", "line", "more_comment*/b"]
source = ["void func(int k) {", "// this function does nothing /*", " k = k*2/4;", " k = k/2;*/", "}"]
# ["void func(int k) {"," k = k*2/4;"," k = k/2;*/","}"]
print(removeComments(source))
# coding:utf-8
'''
53. 最大子序和
給定一個整數數組 nums ，找到一個具有最大和的連續子數組（子數組最少包含一個元素），返回其最大和。
示例:
輸入: [-2,1,-3,4,-1,2,1,-5,4],
輸出: 6
解釋: 連續子數組 [4,-1,2,1] 的和最大，爲 6。
'''
class Solution:
def maxSubArray(self, nums: List[int]) -> int:
maxSum = tempSum = nums[0]
for num in nums[1:]:
tempSum = max(num, num + tempSum)
maxSum = max(maxSum, tempSum)
return maxSum
# coding:utf-8
'''
819. 最常見的單詞
給定一個段落 (paragraph) 和一個禁用單詞列表 (banned)。返回出現次數最多，同時不在禁用列表中的單詞。
題目保證至少有一個詞不在禁用列表中，而且答案唯一。
禁用列表中的單詞用小寫字母表示，不含標點符號。段落中的單詞不區分大小寫。答案都是小寫字母。
示例：
輸入:
paragraph = "Bob hit a ball, the hit BALL flew far after it was hit."
banned = ["hit"]
輸出: "ball"
解釋:
"hit" 出現了3次，但它是一個禁用的單詞。
"ball" 出現了2次 (同時沒有其他單詞出現2次)，所以它是段落裏出現次數最多的，且不在禁用列表中的單詞。
注意，所有這些單詞在段落裏不區分大小寫，標點符號需要忽略（即使是緊挨着單詞也忽略， 比如 "ball,"），
"hit"不是最終的答案，雖然它出現次數更多，但它在禁用單詞列表中。
'''
class Solution:
def mostCommonWord(self, paragraph: str, banned: List[str]) -> str:
dict1 = {}
L = paragraph.replace(',', ' ').replace('.', '').replace('!', '').replace('?', '').replace(';', '').replace("'",'').lower()
for each in L.split():
linshi = each.lower()
if linshi not in banned:
if linshi not in dict1.keys():
dict1[linshi] = 1
else:
dict1[linshi] += 1
max1 = 0
flag = ''
for key in dict1.keys():
if dict1[key] > max1:
max1 = dict1[key]
flag = key
return flag
'''
680. 驗證迴文字符串 Ⅱ
給定一個非空字符串 s，最多刪除一個字符。判斷是否能成爲迴文字符串。
示例 1:
輸入: "aba"
輸出: True
示例 2:
輸入: "abca"
輸出: True
解釋: 你可以刪除c字符。
'''
class Solution:
def validPalindrome(self, s):
if s == s[::-1]:
return True
l, r = 0, len(s) - 1
while l < r:
if s[l] == s[r]:
l, r = l + 1, r - 1
else:
a = s[l + 1: r + 1]
b = s[l:r]
return a == a[::-1] or b == b[::-1]
'''
66. 加一
給定一個由整數組成的非空數組所表示的非負整數，在該數的基礎上加一。
最高位數字存放在數組的首位， 數組中每個元素只存儲單個數字。
你可以假設除了整數 0 之外，這個整數不會以零開頭。
示例 1:
輸入: [1,2,3]
輸出: [1,2,4]
解釋: 輸入數組表示數字 123。
示例 2:
輸入: [4,3,2,1]
輸出: [4,3,2,2]
解釋: 輸入數組表示數字 4321。
'''
class Solution:
def plusOne(self, digits: List[int]) -> List[int]:
str1 = ''
for each in digits:
str1 = str1 + str(each)
str2 = str(int(str1) + 1)
return [int(e) for e in str2]
# coding:utf-8
'''
1433. 檢查一個字符串是否可以打破另一個字符串
給你兩個字符串 s1 和 s2 ，它們長度相等，請你檢查是否存在一個 s1 的排列可以打破 s2 的一個排列，或者是否存在一個 s2 的排列可以打破 s1 的一個排列。
字符串 x 可以打破字符串 y （兩者長度都爲 n ）需滿足對於所有 i（在 0 到 n - 1 之間）都有 x[i] >= y[i]（字典序意義下的順序）。
示例 1：
輸入：s1 = "abc", s2 = "xya"
輸出：true
解釋："ayx" 是 s2="xya" 的一個排列，"abc" 是字符串 s1="abc" 的一個排列，且 "ayx" 可以打破 "abc" 。
示例 2：
輸入：s1 = "abe", s2 = "acd"
輸出：false
解釋：s1="abe" 的所有排列包括："abe"，"aeb"，"bae"，"bea"，"eab" 和 "eba" ，s2="acd" 的所有排列包括："acd"，"adc"，"cad"，"cda"，"dac" 和 "dca"。然而沒有任何 s1 的排列可以打破 s2 的排列。也沒有 s2 的排列能打破 s1 的排列。
示例 3：
輸入：s1 = "leetcodee", s2 = "interview"
輸出：true
'''
class Solution:
def checkIfCanBreak(self, s1: str, s2: str) -> bool:
s1_list, s2_list = sorted(list(s1)), sorted(list(s2))
s1_count, s2_count, same = 0, 0, 0
for i in range(len(s1_list)):
a, b = s1_list[i], s2_list[i]
if a > b:
s1_count += 1
elif a < b:
s2_count += 1
else:
same += 1
if s1_count == 0 or s2_count == 0:
return True
else:
return False
# coding:utf-8
'''
657. 機器人能否返回原點
在二維平面上，有一個機器人從原點 (0, 0) 開始。給出它的移動順序，判斷這個機器人在完成移動後是否在 (0, 0) 處結束。
移動順序由字符串表示。字符 move[i] 表示其第 i 次移動。機器人的有效動作有 R（右），L（左），U（上）和 D（下）。如果機器人在完成所有動作後返回原點，則返回 true。否則，返回 false。
注意：機器人“面朝”的方向無關緊要。 “R” 將始終使機器人向右移動一次，“L” 將始終向左移動等。此外，假設每次移動機器人的移動幅度相同。
示例 1:
輸入: "UD"
輸出: true
解釋：機器人向上移動一次，然後向下移動一次。所有動作都具有相同的幅度，因此它最終回到它開始的原點。因此，我們返回 true。
示例 2:
輸入: "LL"
輸出: false
解釋：機器人向左移動兩次。它最終位於原點的左側，距原點有兩次 “移動” 的距離。我們返回 false，因爲它在移動結束時沒有返回原點。
'''
class Solution:
def judgeCircle(self, moves: str) -> bool:
list1 = [0, 0]
for each in moves:
if each == 'R':
list1[0] += 1
elif each == 'L':
list1[0] = list1[0]-1
elif each == 'U':
list1[1] += 1
else:
list1[1] = list1[1]-1
if list1[0] == 0 and list1[1] == 0:
return True
else:
return False
# coding:utf-8
'''
38. 外觀數列
「外觀數列」是一個整數序列，從數字 1 開始，序列中的每一項都是對前一項的描述。前五項如下：
1. 1
2. 11
3. 21
4. 1211
5. 111221
1 被讀作 "one 1" ("一個一") , 即 11。
11 被讀作 "two 1s" ("兩個一"）, 即 21。
21 被讀作 "one 2", "one 1" （"一個二" , "一個一") , 即 1211。
給定一個正整數 n（1 ≤ n ≤ 30），輸出外觀數列的第 n 項。
注意：整數序列中的每一項將表示爲一個字符串。
示例 1:
輸入: 1
輸出: "1"
解釋：這是一個基本樣例。
示例 2:
輸入: 4
輸出: "1211"
解釋：當 n = 3 時，序列是 "21"，其中我們有 "2" 和 "1" 兩組，"2" 可以讀作 "12"，也就是出現頻次 = 1 而 值 = 2；類似 "1" 可以讀作 "11"。所以答案是 "12" 和 "11" 組合在一起，也就是 "1211"。
'''
class Solution:
def countAndSay(self, n: int) -> str:
pre = ''
res = ''
for i in range(n):
if i == 0:
pre = '1'
res = '1'
continue
if i == 1:
pre = '11'
res = '11'
continue
count = 1
res = ''
num = pre[0]
for j in range(1, len(pre), 1):
if pre[j] == num:
count += 1
else:
res = res + str(count) + num
num = pre[j]
count = 1
res = res + str(count) + num
pre = res
return res
'''
67. 二進制求和
給你兩個二進制字符串，返回它們的和（用二進制表示）。
輸入爲 非空 字符串且只包含數字 1 和 0。
示例 1:
輸入: a = "11", b = "1"
輸出: "100"
示例 2:
輸入: a = "1010", b = "1011"
輸出: "10101"
'''
class Solution:
def addBinary(self, a: str, b: str) -> str:
num = int(a, 2) + int(b, 2)
ans = bin(num)
return ans[2:]
# coding:utf-8
'''
572. 另一個樹的子樹
給定兩個非空二叉樹 s 和 t，檢驗 s 中是否包含和 t 具有相同結構和節點值的子樹。s 的一個子樹包括 s 的一個節點和這個節點的所有子孫。s 也可以看做它自身的一棵子樹。
示例 1:
給定的樹 s:
3
/ \
4 5
/ \
1 2
給定的樹 t：
4
/ \
1 2
返回 true，因爲 t 與 s 的一個子樹擁有相同的結構和節點值。
示例 2:
給定的樹 s：
3
/ \
4 5
/ \
1 2
/
0
給定的樹 t：
4
/ \
1 2
返回 false。
'''
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def isSubtree(self, s: TreeNode, t: TreeNode) -> bool:
s_1 = "".join(self.postorder(s))
t_1 = "".join(self.postorder(t))
print(s_1)
print(t_1)
if t_1.find(s_1) != -1:
return True
else:
return False
def postorder(self, root, ans=[]):
if root.left and root.left !='null':
self.postorder(root.left, ans)
if root.right and root.right !='null':
self.postorder(root.right, ans)
ans.append(str(root.val))
return ans
# 別人的解法
class Solution:
def isSubtree(self, s: TreeNode, t: TreeNode) -> bool:
return str(s).find(str(t)) != -1
# coding:utf-8
'''
面試題58 - II. 左旋轉字符串
字符串的左旋轉操作是把字符串前面的若干個字符轉移到字符串的尾部。請定義一個函數實現字符串左旋轉操作的功能。比如，輸入字符串"abcdefg"和數字2，該函數將返回左旋轉兩位得到的結果"cdefgab"。
示例 1：
輸入: s = "abcdefg", k = 2
輸出: "cdefgab"
示例 2：
輸入: s = "lrloseumgh", k = 6
輸出: "umghlrlose"
'''
class Solution:
def reverseLeftWords(self, s: str, n: int) -> str:
return s[n:] + s[:n]
# coding:utf-8
'''
1221. 分割平衡字符串
在一個「平衡字符串」中，'L' 和 'R' 字符的數量是相同的。
給出一個平衡字符串 s，請你將它分割成儘可能多的平衡字符串。
返回可以通過分割得到的平衡字符串的最大數量。
示例 1：
輸入：s = "RLRRLLRLRL"
輸出：4
解釋：s 可以分割爲 "RL", "RRLL", "RL", "RL", 每個子字符串中都包含相同數量的 'L' 和 'R'。
示例 2：
輸入：s = "RLLLLRRRLR"
輸出：3
解釋：s 可以分割爲 "RL", "LLLRRR", "LR", 每個子字符串中都包含相同數量的 'L' 和 'R'。
示例 3：
輸入：s = "LLLLRRRR"
輸出：1
解釋：s 只能保持原樣 "LLLLRRRR".
'''
class Solution:
def balancedStringSplit(self, s: str) -> int:
r_count = 0
l_count = 0
all_count = 0
for each in s:
if each == 'R':
r_count += 1
elif each == 'L':
l_count += 1
if r_count == l_count:
all_count += 1
r_count = 0
l_count = 0
return all_count
# coding:utf-8
'''
804. 唯一摩爾斯密碼詞
難度
簡單
114
國際摩爾斯密碼定義一種標準編碼方式，將每個字母對應於一個由一系列點和短線組成的字符串， 比如: "a" 對應 ".-", "b" 對應 "-...", "c" 對應 "-.-.", 等等。
爲了方便，所有26個英文字母對應摩爾斯密碼錶如下：
[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
給定一個單詞列表，每個單詞可以寫成每個字母對應摩爾斯密碼的組合。例如，"cab" 可以寫成 "-.-..--..."，(即 "-.-." + "-..." + ".-"字符串的結合)。我們將這樣一個連接過程稱作單詞翻譯。
返回我們可以獲得所有詞不同單詞翻譯的數量。
例如:
輸入: words = ["gin", "zen", "gig", "msg"]
輸出: 2
解釋:
各單詞翻譯如下:
"gin" -> "--...-."
"zen" -> "--...-."
"gig" -> "--...--."
"msg" -> "--...--."
共有 2 種不同翻譯, "--...-." 和 "--...--.".
'''
import collections
class Solution:
def uniqueMorseRepresentations(self, words: List[str]) -> int:
dict1 = collections.OrderedDict()
list1 = [chr(i) for i in range(97, 123)]
list2 = [".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....", "..", ".---", "-.-", ".-..", "--", "-.", "---",".--.", "--.-", ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--.."]
for i in range(len(list1)):
dict1[list1[i]] = list2[i]
res = []
for each in words:
str1 = ''
for e in each:
str1 = str1 + dict1[e]
res.append(str1)
return len(list(set(res)))
# coding:utf-8
'''
551. 學生出勤記錄 I
給定一個字符串來代表一個學生的出勤記錄，這個記錄僅包含以下三個字符：
'A' : Absent，缺勤
'L' : Late，遲到
'P' : Present，到場
如果一個學生的出勤記錄中不超過一個'A'(缺勤)並且不超過兩個連續的'L'(遲到),那麼這個學生會被獎賞。
你需要根據這個學生的出勤記錄判斷他是否會被獎賞。
示例 1:
輸入: "PPALLP"
輸出: True
示例 2:
輸入: "PPALLL"
輸出: False
'''
class Solution:
def checkRecord(self, s: str) -> bool:
if s.count('A') > 1:
return False
if s.find('LLL') != -1:
return False
else:
return True
# coding:utf-8
'''
50. Pow(x, n)
實現 pow(x, n) ，即計算 x 的 n 次冪函數。
示例 1:
輸入: 2.00000, 10
輸出: 1024.00000
示例 2:
輸入: 2.10000, 3
輸出: 9.26100
示例 3:
輸入: 2.00000, -2
輸出: 0.25000
解釋: 2-2 = 1/22 = 1/4 = 0.25
'''
class Solution:
def fenzhi_pow(self, x1, n1):
if n1 == 1:
return x1
if n1 % 2 == 0:
half = self.fenzhi_pow(x1, n1 // 2)
return half * half
else:
half = self.fenzhi_pow(x1, n1 // 2)
return half * half * x1
def myPow(self, x: float, n: int) -> float:
if n == 0:
return 1.0
if n < 0:
n = -n
x = 1 / x
return self.fenzhi_pow(x, n)
# coding:utf-8
'''
1394. 找出數組中的幸運數
在整數數組中，如果一個整數的出現頻次和它的數值大小相等，我們就稱這個整數爲「幸運數」。
給你一個整數數組 arr，請你從中找出並返回一個幸運數。
如果數組中存在多個幸運數，只需返回 最大 的那個。
如果數組中不含幸運數，則返回 -1 。
示例 1：
輸入：arr = [2,2,3,4]
輸出：2
解釋：數組中唯一的幸運數是 2 ，因爲數值 2 的出現頻次也是 2 。
示例 2：
輸入：arr = [1,2,2,3,3,3]
輸出：3
解釋：1、2 以及 3 都是幸運數，只需要返回其中最大的 3 。
示例 3：
輸入：arr = [2,2,2,3,3]
輸出：-1
解釋：數組中不存在幸運數。
示例 4：
輸入：arr = [5]
輸出：-1
示例 5：
輸入：arr = [7,7,7,7,7,7,7]
輸出：7
'''
class Solution:
def findLucky(self, arr: List[int]) -> int:
dict1 = {}
for each in arr:
if str(each) not in dict1:
dict1[str(each)] = 1
else:
dict1[str(each)] += 1
res = []
for key in dict1:
if int(key) == dict1[key]:
res.append(int(key))
if not res:
return -1
return sorted(res)[-1]
# coding:utf-8
'''
136. 只出現一次的數字
給定一個非空整數數組，除了某個元素只出現一次以外，其餘每個元素均出現兩次。找出那個只出現了一次的元素。
說明：
你的算法應該具有線性時間複雜度。 你可以不使用額外空間來實現嗎？
示例 1:
輸入: [2,2,1]
輸出: 1
示例 2:
輸入: [4,1,2,1,2]
輸出: 4
'''
class Solution(object):
def singleNumber(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
nums.sort()
for i in range(0, len(nums) - 1, 2):
if nums[i] != nums[i + 1]:
return nums[i]
return nums[-1]
# coding:utf-8
'''
917. 僅僅反轉字母
給定一個字符串 S，返回 “反轉後的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置發生反轉。
示例 1：
輸入："ab-cd"
輸出："dc-ba"
示例 2：
輸入："a-bC-dEf-ghIj"
輸出："j-Ih-gfE-dCba"
示例 3：
輸入："Test1ng-Leet=code-Q!"
輸出："Qedo1ct-eeLg=ntse-T!"
'''
import re
class Solution:
def reverseOnlyLetters(self, S: str) -> str:
result = ''.join(re.findall(r'[A-Za-z]', S))
list1 = []
for each in S:
if each.isalpha():
list1.append('')
else:
list1.append(each)
tag = 0
for i in range(len(list1)):
e = list1[i]
if not e:
tag += 1
list1[i] = result[-tag]
return ''.join(list1)
# coding:utf-8
'''
1436. 旅行終點站
給你一份旅遊線路圖，該線路圖中的旅行線路用數組 paths 表示，其中 paths[i] = [cityAi, cityBi] 表示該線路將會從 cityAi 直接前往 cityBi 。請你找出這次旅行的終點站，即沒有任何可以通往其他城市的線路的城市。
題目數據保證線路圖會形成一條不存在循環的線路，因此只會有一個旅行終點站。
示例 1：
輸入：paths = [["London","New York"],["New York","Lima"],["Lima","Sao Paulo"]]
輸出："Sao Paulo"
解釋：從 "London" 出發，最後抵達終點站 "Sao Paulo" 。本次旅行的路線是 "London" -> "New York" -> "Lima" -> "Sao Paulo" 。
示例 2：
輸入：paths = [["B","C"],["D","B"],["C","A"]]
輸出："A"
解釋：所有可能的線路是：
"D" -> "B" -> "C" -> "A".
"B" -> "C" -> "A".
"C" -> "A".
"A".
顯然，旅行終點站是 "A" 。
示例 3：
輸入：paths = [["A","Z"]]
輸出："Z"
'''
class Solution:
def destCity(self, paths: List[List[str]]) -> str:
dict1 = {}
for each in paths:
for e in each:
if e not in dict1:
dict1[e] = 1
else:
dict1[e] += 1
list1 = []
for key in dict1:
if dict1[key] == 1:
list1.append(key)
for each in paths:
if each[-1] in list1:
return each[-1]
'''
1455. 檢查單詞是否爲句中其他單詞的前綴
給你一個字符串 sentence 作爲句子並指定檢索詞爲 searchWord ，其中句子由若干用 單個空格 分隔的單詞組成。
請你檢查檢索詞 searchWord 是否爲句子 sentence 中任意單詞的前綴。
如果 searchWord 是某一個單詞的前綴，則返回句子 sentence 中該單詞所對應的下標（下標從 1 開始）。
如果 searchWord 是多個單詞的前綴，則返回匹配的第一個單詞的下標（最小下標）。
如果 searchWord 不是任何單詞的前綴，則返回 -1 。
字符串 S 的 「前綴」是 S 的任何前導連續子字符串。
示例 1：
輸入：sentence = "i love eating burger", searchWord = "burg"
輸出：4
解釋："burg" 是 "burger" 的前綴，而 "burger" 是句子中第 4 個單詞。
示例 2：
輸入：sentence = "this problem is an easy problem", searchWord = "pro"
輸出：2
解釋："pro" 是 "problem" 的前綴，而 "problem" 是句子中第 2 個也是第 6 個單詞，但是應該返回最小下標 2 。
示例 3：
輸入：sentence = "i am tired", searchWord = "you"
輸出：-1
解釋："you" 不是句子中任何單詞的前綴。
示例 4：
輸入：sentence = "i use triple pillow", searchWord = "pill"
輸出：4
示例 5：
輸入：sentence = "hello from the other side", searchWord = "they"
輸出：-1
'''
class Solution:
def isPrefixOfWord(self, sentence: str, searchWord: str) -> int:
list1 = sentence.split()
for each in list1:
if each.startswith(searchWord):
return list1.index(each) + 1
return -1
'''
面試題67. 把字符串轉換成整數
寫一個函數 StrToInt，實現把字符串轉換成整數這個功能。不能使用 atoi 或者其他類似的庫函數。
首先，該函數會根據需要丟棄無用的開頭空格字符，直到尋找到第一個非空格的字符爲止。
當我們尋找到的第一個非空字符爲正或者負號時，則將該符號與之後面儘可能多的連續數字組合起來，作爲該整數的正負號；假如第一個非空字符是數字，則直接將其與之後連續的數字字符組合起來，形成整數。
該字符串除了有效的整數部分之後也可能會存在多餘的字符，這些字符可以被忽略，它們對於函數不應該造成影響。
注意：假如該字符串中的第一個非空格字符不是一個有效整數字符、字符串爲空或字符串僅包含空白字符時，則你的函數不需要進行轉換。
在任何情況下，若函數不能進行有效的轉換時，請返回 0。
說明：
假設我們的環境只能存儲 32 位大小的有符號整數，那麼其數值範圍爲 [−231, 231 − 1]。如果數值超過這個範圍，請返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。
示例 1:
輸入: "42"
輸出: 42
示例 2:
輸入: " -42"
輸出: -42
解釋: 第一個非空白字符爲 '-', 它是一個負號。
我們儘可能將負號與後面所有連續出現的數字組合起來，最後得到 -42 。
示例 3:
輸入: "4193 with words"
輸出: 4193
解釋: 轉換截止於數字 '3' ，因爲它的下一個字符不爲數字。
示例 4:
輸入: "words and 987"
輸出: 0
解釋: 第一個非空字符是 'w', 但它不是數字或正、負號。
因此無法執行有效的轉換。
示例 5:
輸入: "-91283472332"
輸出: -2147483648
解釋: 數字 "-91283472332" 超過 32 位有符號整數範圍。
因此返回 INT_MIN (−231) 。
'''
class Solution:
def strToInt(self, str: str) -> int:
if not str:
return 0
import re
return max(-(1 << 31), min((1 << 31) - 1, int(*re.findall('^\s*[+-]?\d+', str))))
'''
1163. 按字典序排在最後的子串
給你一個字符串 s，找出它的所有子串並按字典序排列，返回排在最後的那個子串。
示例 1：
輸入："abab"
輸出："bab"
解釋：我們可以找出 7 個子串 ["a", "ab", "aba", "abab", "b", "ba", "bab"]。按字典序排在最後的子串是 "bab"。
示例 2：
輸入："leetcode"
輸出："tcode"
'''
class Solution:
def lastSubstring(self, s: str) -> str:
return max(s[i:] for i in range(len(s)))
def lastSubstring(s: str) -> str:
list1 = []
for i in range(len(s)):
list1.append(s[i:])
print(list1)
print(max(list1))
return max(s[i:] for i in range(len(s)))
lastSubstring('abab')
'''
1202. 交換字符串中的元素
給你一個字符串 s，以及該字符串中的一些「索引對」數組 pairs，其中 pairs[i] = [a, b] 表示字符串中的兩個索引（編號從 0 開始）。
你可以 任意多次交換 在 pairs 中任意一對索引處的字符。
返回在經過若干次交換後，s 可以變成的按字典序最小的字符串。
示例 1:
輸入：s = "dcab", pairs = [[0,3],[1,2]]
輸出："bacd"
解釋：
交換 s[0] 和 s[3], s = "bcad"
交換 s[1] 和 s[2], s = "bacd"
示例 2：
輸入：s = "dcab", pairs = [[0,3],[1,2],[0,2]]
輸出："abcd"
解釋：
交換 s[0] 和 s[3], s = "bcad"
交換 s[0] 和 s[2], s = "acbd"
交換 s[1] 和 s[2], s = "abcd"
示例 3：
輸入：s = "cba", pairs = [[0,1],[1,2]]
輸出："abc"
解釋：
交換 s[0] 和 s[1], s = "bca"
交換 s[1] 和 s[2], s = "bac"
交換 s[0] 和 s[1], s = "abc"
'''
def smallestStringWithSwaps(s, pairs):
s = list(s)
for each in pairs:
s[each[0]], s[each[1]] = s[each[1]], s[each[0]]
return ''.join(s)
s = "dcab"
pairs = [[0,3],[1,2],[0,2]]
print(smallestStringWithSwaps(s, pairs))
# coding:utf-8
'''
1071. 字符串的最大公因子
對於字符串 S 和 T，只有在 S = T + ... + T（T 與自身連接 1 次或多次）時，我們才認定 “T 能除盡 S”。
返回最長字符串 X，要求滿足 X 能除盡 str1 且 X 能除盡 str2。
示例 1：
輸入：str1 = "ABCABC", str2 = "ABC"
輸出："ABC"
示例 2：
輸入：str1 = "ABABAB", str2 = "ABAB"
輸出："AB"
示例 3：
輸入：str1 = "LEET", str2 = "CODE"
輸出：""
'''
import math
class Solution:
def gcdOfStrings(self, str1: str, str2: str) -> str:
candidate_len = math.gcd(len(str1), len(str2))
candidate = str1[: candidate_len]
if str1 + str2 == str2 + str1:
return candidate
return ''
# coding:utf-8
'''
744. 尋找比目標字母大的最小字母
給你一個排序後的字符列表 letters ，列表中只包含小寫英文字母。另給出一個目標字母 target，請你尋找在這一有序列表裏比目標字母大的最小字母。
在比較時，字母是依序循環出現的。舉個例子：
如果目標字母 target = 'z' 並且字符列表爲 letters = ['a', 'b']，則答案返回 'a'
示例：
輸入:
letters = ["c", "f", "j"]
target = "a"
輸出: "c"
輸入:
letters = ["c", "f", "j"]
target = "c"
輸出: "f"
輸入:
letters = ["c", "f", "j"]
target = "d"
輸出: "f"
輸入:
letters = ["c", "f", "j"]
target = "g"
輸出: "j"
輸入:
letters = ["c", "f", "j"]
target = "j"
輸出: "c"
輸入:
letters = ["c", "f", "j"]
target = "k"
輸出: "c"
'''
class Solution:
def nextGreatestLetter(self, letters: List[str], target: str) -> str:
list1 = [ord(each) for each in letters]
for each in list1:
if each > ord(target):
return chr(each)
return letters[0]
# coding:utf-8
'''
1446. 連續字符
給你一個字符串 s ，字符串的「能量」定義爲：只包含一種字符的最長非空子字符串的長度。
請你返回字符串的能量。
示例 1：
輸入：s = "leetcode"
輸出：2
解釋：子字符串 "ee" 長度爲 2 ，只包含字符 'e' 。
示例 2：
輸入：s = "abbcccddddeeeeedcba"
輸出：5
解釋：子字符串 "eeeee" 長度爲 5 ，只包含字符 'e' 。
示例 3：
輸入：s = "triplepillooooow"
輸出：5
示例 4：
輸入：s = "hooraaaaaaaaaaay"
輸出：11
示例 5：
輸入：s = "tourist"
輸出：1
'''
def maxPower(s):
if not s:
return 0
if len(s) == 1:
return 1
list1 = []
j = 0
tag = 0
for i in range(len(s)):
# print(s[j], s[i],list1)
if s[i] == s[j]:
tag += 1
else:
list1.append(tag)
tag = 1
j = i
if i == len(s)-1 and s[i]==s[j]:
list1.append(tag)
return max(list1)
s = 'ccc'
print(maxPower(s))
# coding:utf-8
'''
443. 壓縮字符串
給定一組字符，使用原地算法將其壓縮。
壓縮後的長度必須始終小於或等於原數組長度。
數組的每個元素應該是長度爲1 的字符（不是 int 整數類型）。
在完成原地修改輸入數組後，返回數組的新長度。
進階：
你能否僅使用O(1) 空間解決問題？
示例 1：
輸入：
["a","a","b","b","c","c","c"]
輸出：
返回6，輸入數組的前6個字符應該是：["a","2","b","2","c","3"]
說明：
"aa"被"a2"替代。"bb"被"b2"替代。"ccc"被"c3"替代。
示例 2：
輸入：
["a"]
輸出：
返回1，輸入數組的前1個字符應該是：["a"]
說明：
沒有任何字符串被替代。
示例 3：
輸入：
["a","b","b","b","b","b","b","b","b","b","b","b","b"]
輸出：
返回4，輸入數組的前4個字符應該是：["a","b","1","2"]。
說明：
由於字符"a"不重複，所以不會被壓縮。"bbbbbbbbbbbb"被“b12”替代。
注意每個數字在數組中都有它自己的位置。
'''
def compress(chars) -> int:
if not chars:
return []
if len(chars) == 1:
return chars
list1 = []
j = 0
tag = 0
for i in range(len(chars)):
if chars[i] == chars[j]:
tag += 1
else:
if tag == 1:
list1.append(chars[i - 1])
else:
list1.append(chars[i - 1] + str(tag))
tag = 1
j = i
if i == len(chars) - 1 and chars[i] == chars[j]:
if tag == 1:
list1.append(chars[i - 1])
else:
list1.append(chars[i - 1] + str(tag))
return len(list(''.join(list1)))
class Solution(object):
def compress(self, chars):
anchor = write = 0
for read, c in enumerate(chars):
if read + 1 == len(chars) or chars[read + 1] != c:
chars[write] = chars[anchor]
write += 1
if read > anchor:
for digit in str(read - anchor + 1):
chars[write] = digit
write += 1
anchor = read + 1
return write
# coding:utf-8
'''
599. 兩個列表的最小索引總和
假設Andy和Doris想在晚餐時選擇一家餐廳，並且他們都有一個表示最喜愛餐廳的列表，每個餐廳的名字用字符串表示。
你需要幫助他們用最少的索引和找出他們共同喜愛的餐廳。 如果答案不止一個，則輸出所有答案並且不考慮順序。 你可以假設總是存在一個答案。
示例 1:
輸入:
["Shogun", "Tapioca Express", "Burger King", "KFC"]
["Piatti", "The Grill at Torrey Pines", "Hungry Hunter Steakhouse", "Shogun"]
輸出: ["Shogun"]
解釋: 他們唯一共同喜愛的餐廳是“Shogun”。
示例 2:
輸入:
["Shogun", "Tapioca Express", "Burger King", "KFC"]
["KFC", "Shogun", "Burger King"]
輸出: ["Shogun"]
解釋: 他們共同喜愛且具有最小索引和的餐廳是“Shogun”，它有最小的索引和1(0+1)。
'''
class Solution:
def findRestaurant(self, list1: List[str], list2: List[str]) -> List[str]:
dict1 = {}
for i in range(len(list1)):
for j in range(len(list2)):
if list1[i] == list2[j]:
dict1[list1[i]] = i+j
list3 = []
for key in dict1:
list3.append(dict1[key])
max_ = min(list3)
res = []
for key in dict1:
if dict1[key] == max_:
res.append(key)
return res
62、
'''
237. 刪除鏈表中的節點
請編寫一個函數，使其可以刪除某個鏈表中給定的（非末尾）節點，你將只被給定要求被刪除的節點。
現有一個鏈表 -- head = [4,5,1,9]，它可以表示爲:
4 --->5--->1--->9
示例 1:
輸入: head = [4,5,1,9], node = 5
輸出: [4,1,9]
解釋: 給定你鏈表中值爲 5 的第二個節點，那麼在調用了你的函數之後，該鏈表應變爲 4 -> 1 -> 9.
示例 2:
輸入: head = [4,5,1,9], node = 1
輸出: [4,5,9]
解釋: 給定你鏈表中值爲 1 的第三個節點，那麼在調用了你的函數之後，該鏈表應變爲 4 -> 5 -> 9.
說明:
鏈表至少包含兩個節點。
鏈表中所有節點的值都是唯一的。
給定的節點爲非末尾節點並且一定是鏈表中的一個有效節點。
不要從你的函數中返回任何結果。
'''
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def deleteNode(self, node):
"""
:type node: ListNode
:rtype: void Do not return anything, modify node in-place instead.
"""
node.val = node.next.val
node.next = node.next.next
63、
'''
206. 反轉鏈表
反轉一個單鏈表。
示例:
輸入: 1->2->3->4->5->NULL
輸出: 5->4->3->2->1->NULL
進階:
你可以迭代或遞歸地反轉鏈表。你能否用兩種方法解決這道題？
'''
# Definition for singly-linked list.
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
list1 = []
while head:
list1.insert(0, head.val)
head = head.next
pre = ListNode(0)
node_start = pre
for i in range(len(list1)):
node_start.val = list1[i]
if i != len(list1)-1:
node_start.next = ListNode(0)
else:
node_start.next = None
return pre
class Solution(object):
def reverseList(self, head):
pre = None
curr = head
while curr:
temp = curr.next
curr.next = pre
pre = curr
curr = temp
return pre
64、234. 迴文鏈表
請判斷一個鏈表是否爲迴文鏈表。
示例 1:
輸入: 1->2
輸出: false
示例 2:
輸入: 1->2->2->1
輸出: true
進階：
你能否用 O(n) 時間複雜度和 O(1) 空間複雜度解決此題？
class ListNode:
def __init__(self, x):
self.val = x
self.next = None
class Solution:
def isPalindrome(self, head: ListNode) -> bool:
list1 = []
while head:
list1.append(head.val)
head = head.next
str1 = ''.join(list1)
str2 = ''.join(list1.reverse())
if str1 == str2:
return True
else:
return False
65、125. 驗證迴文串
給定一個字符串，驗證它是否是迴文串，只考慮字母和數字字符，可以忽略字母的大小寫。
說明：本題中，我們將空字符串定義爲有效的迴文串。
示例 1:
輸入: "A man, a plan, a canal: Panama"
輸出: true
示例 2:
輸入: "race a car"
輸出: false
def isPalindrome(s):
str1 = ''
for each in s:
if each.isalpha() or each.isdigit():
str1 = str1 + str(each.lower())
list1 = list(str1)
list1.reverse()
str2 = ''.join(list1)
if str1 == str2:
return True
else:
return False
66、面試題 02.05. 鏈表求和
給定兩個用鏈表表示的整數，每個節點包含一個數位。
這些數位是反向存放的，也就是個位排在鏈表首部。
編寫函數對這兩個整數求和，並用鏈表形式返回結果。
示例：
輸入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295
輸出：2 -> 1 -> 9，即912
進階：假設這些數位是正向存放的，請再做一遍。
示例：
輸入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295
輸出：9 -> 1 -> 2，即912
class Solution:
def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
head = ListNode(0)
node = head
remaining = 0
while l1 or l2:
if l1 == None:
node.next = l2
l1 = ListNode(0)
if l2 == None:
node.next = l1
l2 = ListNode(0)
remaining += l1.val + l2.val
node.next = ListNode(remaining % 10)
remaining = remaining // 10
node = node.next
l1 = l1.next
l2 = l2.next
if remaining:
node.next = ListNode(remaining)
return head.next
67、605. 種花問題
假設你有一個很長的花壇，一部分地塊種植了花，另一部分卻沒有。可是，花卉不能種植在相鄰的地塊上，它們會爭奪水源，兩者都會死去。
給定一個花壇（表示爲一個數組包含0和1，其中0表示沒種植花，1表示種植了花），和一個數 n 。能否在不打破種植規則的情況下種入 n 朵花？能則返回True，不能則返回False。
示例 1:
輸入: flowerbed = [1,0,0,0,1], n = 1
輸出: True
示例 2:
輸入: flowerbed = [1,0,0,0,1], n = 2
輸出: False
注意:
數組內已種好的花不會違反種植規則。
輸入的數組長度範圍爲 [1, 20000]。
n 是非負整數，且不會超過輸入數組的大小。
class Solution:
def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:
flowerbed = [0] + flowerbed
flowerbed = flowerbed + [0]
for i in range(1, len(flowerbed) - 1):
if flowerbed[i - 1] == 0 and flowerbed[i] == 0 and flowerbed[i + 1] == 0:
n = n - 1
flowerbed[i] = 1
return n <= 0
68、1431. 擁有最多糖果的孩子
給你一個數組 candies 和一個整數 extraCandies ，其中 candies[i] 代表第 i 個孩子擁有的糖果數目。
對每一個孩子，檢查是否存在一種方案，將額外的 extraCandies 個糖果分配給孩子們之後，此孩子有 最多 的糖果。注意，允許有多個孩子同時擁有 最多 的糖果數目。
示例 1：
輸入：candies = [2,3,5,1,3], extraCandies = 3
輸出：[true,true,true,false,true]
解釋：
孩子 1 有 2 個糖果，如果他得到所有額外的糖果（3個），那麼他總共有 5 個糖果，他將成爲擁有最多糖果的孩子。
孩子 2 有 3 個糖果，如果他得到至少 2 個額外糖果，那麼他將成爲擁有最多糖果的孩子。
孩子 3 有 5 個糖果，他已經是擁有最多糖果的孩子。
孩子 4 有 1 個糖果，即使他得到所有額外的糖果，他也只有 4 個糖果，無法成爲擁有糖果最多的孩子。
孩子 5 有 3 個糖果，如果他得到至少 2 個額外糖果，那麼他將成爲擁有最多糖果的孩子。
示例 2：
輸入：candies = [4,2,1,1,2], extraCandies = 1
輸出：[true,false,false,false,false]
解釋：只有 1 個額外糖果，所以不管額外糖果給誰，只有孩子 1 可以成爲擁有糖果最多的孩子。
示例 3：
輸入：candies = [12,1,12], extraCandies = 10
輸出：[true,false,true]
class Solution:
def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]:
list1 = []
max_ = max(candies)
for each in candies:
if each + extraCandies >= max_:
list1.append(True)
else:
list1.append(False)
return list1
69、944. 刪列造序
給定由 N 個小寫字母字符串組成的數組 A，其中每個字符串長度相等。
你需要選出一組要刪掉的列 D，對 A 執行刪除操作，使 A 中剩餘的每一列都是 非降序 排列的，然後請你返回 D.length 的最小可能值。
刪除 操作的定義是：選出一組要刪掉的列，刪去 A 中對應列中的所有字符，形式上，第 n 列爲 [A[0][n], A[1][n], ..., A[A.length-1][n]]）。（可以參見 刪除操作範例）
示例 1：
輸入：["cba", "daf", "ghi"]
輸出：1
解釋：
當選擇 D = {1}，刪除後 A 的列爲：["c","d","g"] 和 ["a","f","i"]，均爲非降序排列。
若選擇 D = {}，那麼 A 的列 ["b","a","h"] 就不是非降序排列了。
示例 2：
輸入：["a", "b"]
輸出：0
解釋：D = {}
示例 3：
輸入：["zyx", "wvu", "tsr"]
輸出：3
解釋：D = {0, 1, 2}
class Solution:
def minDeletionSize(self, A: List[str]) -> int:
list1 = []
for i in range(len(A[0])):
linshi = []
for j in range(len(A)):
linshi.append(A[j][i])
list1.append(linshi)
count = 0
for each in list1:
linshi = [x for x in each]
each.sort()
if linshi != each:
count += 1
return count
70、984. 不含 AAA 或 BBB 的字符串
給定兩個整數 A 和 B，返回任意字符串 S，要求滿足：
S 的長度爲 A + B，且正好包含 A 個 'a' 字母與 B 個 'b' 字母；
子串 'aaa' 沒有出現在 S 中；
子串 'bbb' 沒有出現在 S 中。
示例 1：
輸入：A = 1, B = 2
輸出："abb"
解釋："abb", "bab" 和 "bba" 都是正確答案。
示例 2：
輸入：A = 4, B = 1
輸出："aabaa"
class Solution:
def strWithout3a3b(self, A: int, B: int) -> str:
if A == B:
return "ab" * A
ans = ""
la = A
lb = B
while la > 0 and lb > 0:
if la > lb:
ans += "aab"
la -= 2
lb -= 1
elif la < lb:
ans += "bba"
la -= 1
lb -= 2
else:
if A > B:
ans += "ab" * la
else:
ans += "ba" * la
la = 0
lb = 0
if A > B:
ans += "a" * la + "b" * lb
else:
ans += "b" * lb + "a" * la
return ans
71、 21. 合併兩個有序鏈表
date:2020.4.22
將兩個升序鏈表合併爲一個新的升序鏈表並返回。新鏈表是通過拼接給定的兩個鏈表的所有節點組成的。
示例：
輸入：1->2->4, 1->3->4
輸出：1->1->2->3->4->4
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
result_node = ListNode(0)
node = result_node
head1 = l1
head2 = l2
while (head1 and head2):
if head1.val < head2.val:
node.next = head1
head1 = head1.next
node = node.next
else:
node.next = head2
head2 = head2.next
node = node.next
while head1:
node.next = head1
head1 = head1.next
node = node.next
while head2:
node.next = head2
head2 = head2.next
node = node.next
return result_node.next
72、 面試題50. 第一個只出現一次的字符
date:2020.4.21
數組中有一個數字出現的次數超過數組長度的一半，請找出這個數字。
你可以假設數組是非空的，並且給定的數組總是存在多數元素。
示例 1:
輸入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
輸出: 2
代碼如下所示：
class Solution:
def majorityElement(self, nums: List[int]) -> int:
dict1 = {}
for each in nums:
if each not in dict1:
dict1[each] = 1
else:
dict1[each] += 1
length = len(nums)//2
for each in dict1:
if dict1[each] > length:
return each
73、 面試題50. 第一個只出現一次的字符
date:2020.4.20
在字符串 s 中找出第一個只出現一次的字符。如果沒有，返回一個單空格。
示例:
s = "abaccdeff"
返回 "b"
s = ""
返回 " "
代碼如下所示：
class Solution:
def firstUniqChar(self, s: str) -> str:
d1 = {}
for each in s:
if each not in d1:
d1[each] = 1
else:
d1[each] += 1
for key in s:
if d1[key] == 1:
return key
return ' '
74、 面試題15. 二進制中1的個數
date:2020.4.20
請實現一個函數，輸入一個整數，輸出該數二進制表示中 1 的個數。例如，把 9 表示成二進制是 1001，有 2 位是 1。因此，如果輸入 9，則該函數輸出 2。
示例 1：
輸入：00000000000000000000000000001011
輸出：3
解釋：輸入的二進制串 00000000000000000000000000001011 中，共有三位爲 '1'。
示例 2：
輸入：00000000000000000000000010000000
輸出：1
解釋：輸入的二進制串 00000000000000000000000010000000 中，共有一位爲 '1'。
示例 3：
輸入：11111111111111111111111111111101
輸出：31
解釋：輸入的二進制串 11111111111111111111111111111101 中，共有 31 位爲 '1'。
代碼如下所示：
class Solution:
def hammingWeight(self, n: int) -> int:
return list(str(bin(n))).count('1')
75、 面試題18. 刪除鏈表的節點
date:2020.4.17
給定單向鏈表的頭指針和一個要刪除的節點的值，定義一個函數刪除該節點。
返回刪除後的鏈表的頭節點。
注意：此題對比原題有改動
示例 1:
輸入: head = [4,5,1,9], val = 5
輸出: [4,1,9]
解釋: 給定你鏈表中值爲 5 的第二個節點，那麼在調用了你的函數之後，該鏈表應變爲 4 -> 1 -> 9.
示例 2:
輸入: head = [4,5,1,9], val = 1
輸出: [4,5,9]
解釋: 給定你鏈表中值爲 1 的第三個節點，那麼在調用了你的函數之後，該鏈表應變爲 4 -> 5 -> 9.
代碼如下：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def deleteNode(self, head: ListNode, val: int) -> ListNode:
pre = head
if head.val == val:
return head.next
while pre.next:
if pre.next.val == val:
pre.next = pre.next.next
else:
pre = pre.next
return head
76、 面試題11. 旋轉數組的最小數字
date:2020.4.16
把一個數組最開始的若干個元素搬到數組的末尾，我們稱之爲數組的旋轉。輸入一個遞增排序的數組的一個旋轉，輸出旋轉數組的最小元素。例如，數組 [3,4,5,1,2] 爲 [1,2,3,4,5] 的一個旋轉，該數組的最小值爲1。
示例 1：
輸入：[3,4,5,1,2]
輸出：1
示例 2：
輸入：[2,2,2,0,1]
輸出：0
代碼如下所示：
# 自己的代碼
class Solution:
def minArray(self, numbers: List[int]) -> int:
return min(numbers)
# 大神的代碼：二分查找
class Solution:
def minArray(self, numbers: List[int]) -> int:
if not numbers: return
start, end = 0, len(numbers) - 1
while start < end:
middle = (start + end) // 2
if numbers[middle] > numbers[end]: start = middle + 1
elif numbers[middle] < numbers[end]: end = middle
# 其實這個end-=1很巧妙，因爲相等的時候我們無法判斷要往哪個方向縮小
# 所以索性就縮小numbers的長度。
else: end -= 1
return numbers[start]
77、 面試題10- II. 青蛙跳臺階問題
date:2020.4.15
一隻青蛙一次可以跳上1級臺階，也可以跳上2級臺階。求該青蛙跳上一個 n 級的臺階總共有多少種跳法。
答案需要取模 1e9+7（1000000007），如計算初始結果爲：1000000008，請返回 1。
示例 1：
輸入：n = 2
輸出：2
示例 2：
輸入：n = 7
輸出：21
提示：
0 <= n <= 100
代買如下：
class Solution:
def numWays(self, n: int) -> int:
a, b = 1, 1
for _ in range(n):
a, b = b, a + b
return a % 1000000007
78、 面試題09. 用兩個棧實現隊列
date:2020.4.15
用兩個棧實現一個隊列。隊列的聲明如下，請實現它的兩個函數 appendTail 和 deleteHead ，分別完成在隊列尾部插入整數和在隊列頭部刪除整數的功能。(若隊列中沒有元素，deleteHead 操作返回 -1 )
示例 1：
輸入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
輸出：[null,null,3,-1]
示例 2：
輸入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
輸出：[null,-1,null,null,5,2]
代碼如下：
class CQueue:
def __init__(self):
self.A, self.B = [],[]
def appendTail(self, value: int) -> None:
self.A.append(value)
def deleteHead(self) -> int:
if self.B:
return self.B.pop()
if not self.A:
return -1
while self.A:
self.B.append(self.A.pop())
return self.B.pop()
# Your CQueue object will be instantiated and called as such:
# obj = CQueue()
# obj.appendTail(value)
# param_2 = obj.deleteHead()
79、 面試題06. 從尾到頭打印鏈表
date:2020.4.14
輸入某二叉樹的前序遍歷和中序遍歷的結果，請重建該二叉樹。假設輸入的前序遍歷和中序遍歷的結果中都不含重複的數字。
例如，給出
前序遍歷 preorder = [3,9,20,15,7]
中序遍歷 inorder = [9,3,15,20,7]
返回如下的二叉樹：
3
/ \
9 20
/ \
15 7
代碼如下所示：
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
if not preorder:
return None
loc = inorder.index(preorder[0])
root = TreeNode(preorder[0])
root.left = self.buildTree(preorder[1:loc+1],inorder[:loc])
root.right = self.buildTree(preorder[loc+1:],inorder[loc+1:])
return root
80、 面試題06. 從尾到頭打印鏈表
date:2020.4.13
輸入一個鏈表的頭節點，從尾到頭反過來返回每個節點的值（用數組返回）。
示例 1：
輸入：head = [1,3,2] 輸出：[2,3,1]
代碼如下所示：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def reversePrint(self, head: ListNode) -> List[int]:
list1 = []
while head:
list1.insert(0,head.val)
head = head.next
return list1
81、 面試題05. 替換空格
date:2020.4.13
請實現一個函數，把字符串 s 中的每個空格替換成"%20"。
示例 1：
輸入：s = "We are happy."
輸出："We%20are%20happy."
代碼如下所示：
class Solution:
def replaceSpace(self, s: str) -> str:
return '%20'.join(s.split(" "))
82、 面試題04. 二維數組中的查找
date:2020.4.13
在一個 n * m 的二維數組中，每一行都按照從左到右遞增的順序排序，每一列都按照從上到下遞增的順序排序。請完成一個函數，輸入這樣的一個二維數組和一個整數，判斷數組中是否含有該整數。
示例:
現有矩陣 matrix 如下：
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
給定 target = 5，返回 true。
給定 target = 20，返回 false。
代碼如下所示：
class Solution:
def findNumberIn2DArray(self, matrix: List[List[int]], target: int) -> bool:
for i in range(len(matrix)):
for j in range(len(matrix[i])):
if matrix[i][j] == target:
return True
return False
83、 面試題10- I. 斐波那契數列
date:2020.4.13
寫一個函數，輸入 n ，求斐波那契（Fibonacci）數列的第 n 項。斐波那契數列的定義如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契數列由 0 和 1 開始，之後的斐波那契數就是由之前的兩數相加而得出。
答案需要取模 1e9+7（1000000007），如計算初始結果爲：1000000008，請返回 1。
示例 1：
輸入：n = 2
輸出：1
示例 2：
輸入：n = 5
輸出：5
代碼如下：
# 函數遞歸調用 會出現時間超時問題
class Solution(object):
def fib(self, n):
"""
:type n: int
:rtype: int
"""
if n < 2:
return n
else:
return self.fib(n - 1) + self.fib(n - 2)
# 下面的方法不會出現時間超時問題
class Solution(object):
def fib(self, n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a % 1000000007
84、 151. 翻轉字符串裏的單詞
date:2020.4.10
給定一個字符串，逐個翻轉字符串中的每個單詞。
示例 1：
輸入: "the sky is blue"
輸出: "blue is sky the"
示例 2：
輸入: " hello world! "
輸出: "world! hello"
解釋: 輸入字符串可以在前面或者後面包含多餘的空格，但是反轉後的字符不能包括。
示例 3：
輸入: "a good example"
輸出: "example good a"
解釋: 如果兩個單詞間有多餘的空格，將反轉後單詞間的空格減少到只含一個。
代碼如下：
class Solution(object):
def reverseWords(self, s):
"""
:type s: str
:rtype: str
"""
list1 = [each for each in s.split() if each != '']
str1 = ''
for each in list1:
if str1 != '':
str1 = each+' '+str1
else:
str1 = each
return str1
85、 13. 機器人的運動範圍
地上有一個m行n列的方格，從座標 [0,0] 到座標 [m-1,n-1] 。一個機器人從座標 [0, 0] 的格子開始移動，它每次可以向左、右、上、下移動一格（不能移動到方格外），也不能進入行座標和列座標的數位之和大於k的格子。例如，當k爲18時，機器人能夠進入方格 [35, 37] ，因爲3+5+3+7=18。但它不能進入方格 [35, 38]，因爲3+5+3+8=19。請問該機器人能夠到達多少個格子？
示例 1：
輸入：m = 2, n = 3, k = 1
輸出：3
示例 1：
輸入：m = 3, n = 1, k = 0
輸出：1
提示：
1 <= n,m <= 100
0 <= k <= 20
代碼如下所示：
# 深度優先搜索
class Solution(object):
def movingCount(self, m, n, k):
"""
:type m: int
:type n: int
:type k: int
:rtype: int
"""
def dfs(m, n, i, j, k, grid):
if i < 0 or j < 0 or i == m or j == n or i % 10 + i // 10 + j % 10 + j // 10 > k or grid[i][j] == 1:
return
grid[i][j] = 1
dfs(m, n, i + 1, j, k, grid)
dfs(m, n, i, j - 1, k, grid)
dfs(m, n, i, j + 1, k, grid)
dfs(m, n, i - 1, j, k, grid)
grid = [[0 for _ in range(n)] for _ in range(m)]
dfs(m, n, 0, 0, k, grid)
return sum([sum(i) for i in grid])
86、 面試題 01.07. 旋轉矩陣
給你一幅由 N × N 矩陣表示的圖像，其中每個像素的大小爲 4 字節。請你設計一種算法，將圖像旋轉 90 度。
不佔用額外內存空間能否做到？
示例 1:
給定 matrix =
[
[1,2,3],
[4,5,6],
[7,8,9]
],
原地旋轉輸入矩陣，使其變爲:
[
[7,4,1],
[8,5,2],
[9,6,3]
]
示例 2:
給定 matrix =
[
[ 5, 1, 9,11],
[ 2, 4, 8,10],
[13, 3, 6, 7],
[15,14,12,16]
],
原地旋轉輸入矩陣，使其變爲:
[
[15,13, 2, 5],
[14, 3, 4, 1],
[12, 6, 8, 9],
[16, 7,10,11]
]
代碼如下：
class Solution(object):
def rotate(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: None Do not return anything, modify matrix in-place instead.
"""
list1 = []
for i in range(len(matrix[0])):
str1 = []
for j in range(len(matrix)):
str1.insert(0,matrix[j][i])
list1.append(str1)
for i in range(len(list1)):
matrix[i] = list1[i]
87、 面試題 02.03. 刪除中間節點
實現一種算法，刪除單向鏈表中間的某個節點（除了第一個和最後一個節點，不一定是中間節點），假定你只能訪問該節點。
示例：
輸入：單向鏈表a->b->c->d->e->f中的節點c
結果：不返回任何數據，但該鏈表變爲a->b->d->e->f
代碼：
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def deleteNode(self, node):
"""
:type node: ListNode
:rtype: void Do not return anything, modify node in-place instead.
"""
if node.next:
node.val = node.next.val
if node.next.next:
node.next = node.next.next
else:
node.next = None
88、找不同
給定兩個字符串 s 和 t，它們只包含小寫字母。
字符串 t 由字符串 s 隨機重排，然後在隨機位置添加一個字母。
請找出在 t 中被添加的字母。
示例:
輸入：
s = "abcd"
t = "abcde"
輸出：
e
解釋：
'e' 是那個被添加的字母。
代碼：
class Solution:
def findTheDifference(self, s: str, t: str) -> str:
s_list = sorted(list(s))
t_list = sorted(list(t))
for i in range(len(t_list)):
if len(s_list) == i:
return t_list[i]
elif t_list[i] != s_list[i]:
return t_list[i]
89、字符串中的第一個唯一字符
給定一個字符串，找到它的第一個不重複的字符，並返回它的索引。如果不存在，則返回 -1。
案例:
s = "leetcode"
返回 0.
s = "loveleetcode",
返回 2.
代碼：
class Solution:
def firstUniqChar(self, s: str) -> int:
import collections
dicr_1 = collections.OrderedDict()
for i in range(len(s)):
if s[i] not in dicr_1:
dicr_1[s[i]] = 1
else:
dicr_1[s[i]] += 1
for key in dicr_1:
if dicr_1[key] == 1:
return s.index(key)
return -1
90、缺失數字
給定一個包含 0, 1, 2, ..., n 中 n 個數的序列，找出 0 .. n 中沒有出現在序列中的那個數。
示例 1:
輸入: [3,0,1]
輸出: 2
示例 2:
輸入: [9,6,4,2,3,5,7,0,1]
輸出: 8
代碼：
class Solution:
def missingNumber(self, nums: List[int]) -> int:
nums = sorted(nums)
for i in range(len(nums)):
if i != nums[i]:
return i
return len(nums)
91、醜數
編寫一個程序判斷給定的數是否爲醜數。
醜數就是隻包含質因數 2, 3, 5 的正整數。
示例 1:
輸入: 6
輸出: true
解釋: 6 = 2 × 3
示例 2:
輸入: 8
輸出: true
解釋: 8 = 2 × 2 × 2
示例 3:
輸入: 14
輸出: false
解釋: 14 不是醜數，因爲它包含了另外一個質因數 7。
說明：
1 是醜數。
輸入不會超過 32 位有符號整數的範圍: [−231, 231 − 1]。
代碼：
class Solution:
def isUgly(self, num: int) -> bool:
if num == 1:
return True
if num <= 0:
return False
while num != 1:
if num %2 == 0:
num = num//2
elif num%3 == 0:
num = num//3
elif num%5==0:
num = num//5
else:
return False
return True
92、有效的字母異位詞
給定兩個字符串 s 和 t ，編寫一個函數來判斷 t 是否是 s 的字母異位詞。
示例 1:
輸入: s = "anagram", t = "nagaram"
輸出: true
示例 2:
輸入: s = "rat", t = "car"
輸出: false
說明:
你可以假設字符串只包含小寫字母。
進階:
如果輸入字符串包含 unicode 字符怎麼辦？你能否調整你的解法來應對這種情況？
解題思路：
字母異位詞是指由相同的字母按照不同的順序組成的單詞，根據此含義，那麼這兩個單詞的長度也一定相等，所以我們就可以先將兩個單詞按照字母的大小進行排序，然後比較兩個單詞對應位置上的字母是否相等
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
s_list = sorted(list(s))
t_list = sorted(list(t))
if s_list == t_list:
return True
else:
return False
93、2的冪
給定一個整數，編寫一個函數來判斷它是否是 2 的冪次方。
示例 1:
輸入: 1
輸出: true
解釋: 20 = 1
示例 2:
輸入: 16
輸出: true
解釋: 24 = 16
示例 3:
輸入: 218
輸出: false
class Solution:
def isPowerOfTwo(self, n: int) -> bool:
if n <= 0:
return False
if n == 1:
return True
elif str(n)[-1] not in ['2','4','6','8']:
return False
else:
while n > 1:
if n%2 == 0:
n //=2
else:
return False
return True
94、計數質數
統計所有小於非負整數 n 的質數的數量。
示例:
輸入: 10 輸出: 4 解釋: 小於 10 的質數一共有 4 個, 它們是 2, 3, 5, 7 。
# 代碼：
class Solution:
def countPrimes(self, n: int) -> int:
if n == 1 or n == 0 or n== 2:
return 0
list1 = list(range(1,n))
list1[0] = 0
for i in range(2,n):
if list1[i-1] != 0:
for j in range(i*2,n,i):
list1[j-1] = 0
return len(list1)-list1.count(0)
# 思路：
# 厄拉多賽篩法
95、打家劫舍
你是一個專業的小偷，計劃偷竊沿街的房屋。每間房內都藏有一定的現金，影響你偷竊的唯一制約因素就是相鄰的房屋裝有相互連通的防盜系統，如果兩間相鄰的房屋在同一晚上被小偷闖入，系統會自動報警。
給定一個代表每個房屋存放金額的非負整數數組，計算你在不觸動警報裝置的情況下，能夠偷竊到的最高金額。
示例 1:
輸入: [1,2,3,1]
輸出: 4
解釋: 偷竊 1 號房屋 (金額 = 1) ，然後偷竊 3 號房屋 (金額 = 3)。
偷竊到的最高金額 = 1 + 3 = 4 。
示例 2:
輸入: [2,7,9,3,1]
輸出: 12
解釋: 偷竊 1 號房屋 (金額 = 2), 偷竊 3 號房屋 (金額 = 9)，接着偷竊 5 號房屋 (金額 = 1)。
偷竊到的最高金額 = 2 + 9 + 1 = 12 。
# 代碼：
class Solution:
def rob(self, nums: List[int]) -> int:
n1,n2 = 0,0
for each in nums:
n2,n1 = max(n1+each,n2),n2
return n2
# 解題思路：
# 這是一個動態規劃問題
96、錯誤的集合
集合 S 包含從1到 n 的整數。不幸的是，因爲數據錯誤，導致集合裏面某一個元素複製了成了集合裏面的另外一個元素的值，導致集合丟失了一個整數並且有一個元素重複。
給定一個數組 nums 代表了集合 S 發生錯誤後的結果。你的任務是首先尋找到重複出現的整數，再找到丟失的整數，將它們以數組的形式返回。
示例 1:
輸入: nums = [1,2,2,4]
輸出: [2,3]
注意:
給定數組的長度範圍是 [2, 10000]。
給定的數組是無序的。
class Solution:
def findErrorNums(self, nums: List[int]) -> List[int]:
cuowu = sum(nums)-sum(set(nums))
linshi = range(1,len(nums)+1)
zhengque = sum(linshi)-sum(set(nums))
return [cuowu,zhengque]
97、旋轉數組
給定一個數組，將數組中的元素向右移動 k 個位置，其中 k 是非負數。
示例 1:
輸入: [1,2,3,4,5,6,7] 和 k = 3
輸出: [5,6,7,1,2,3,4]
解釋:
向右旋轉 1 步: [7,1,2,3,4,5,6]
向右旋轉 2 步: [6,7,1,2,3,4,5]
向右旋轉 3 步: [5,6,7,1,2,3,4]
示例 2:
輸入: [-1,-100,3,99] 和 k = 2
輸出: [3,99,-1,-100]
解釋:
向右旋轉 1 步: [99,-1,-100,3]
向右旋轉 2 步: [3,99,-1,-100]
說明:
儘可能想出更多的解決方案，至少有三種不同的方法可以解決這個問題。
要求使用空間複雜度爲 O(1) 的 原地 算法。
class Solution:
def rotate(self, nums: List[int], k: int) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
for i in range(k):
x = nums.pop()
nums.insert(0,x)
98、排列硬幣
你總共有 n 枚硬幣，你需要將它們擺成一個階梯形狀，第 k 行就必須正好有 k 枚硬幣。
給定一個數字 n，找出可形成完整階梯行的總行數。
n 是一個非負整數，並且在32位有符號整型的範圍內。
示例 1:
n = 5
硬幣可排列成以下幾行:
¤
¤ ¤
¤ ¤
因爲第三行不完整，所以返回2.
示例 2:
n = 8
硬幣可排列成以下幾行:
¤
¤ ¤
¤ ¤ ¤
¤ ¤
因爲第四行不完整，所以返回3.
from math import sqrt, floor
class Solution:
def arrangeCoins(self, n: int) -> int:
return floor(sqrt(1/4+2*n)-1/2)
99、快樂數
編寫一個算法來判斷一個數是不是“快樂數”。
一個“快樂數”定義爲：對於一個正整數，每一次將該數替換爲它每個位置上的數字的平方和，然後重複這個過程直到這個數變爲 1，也可能是無限循環但始終變不到 1。如果可以變爲 1，那麼這個數就是快樂數。
示例:
輸入: 19
輸出: true
解釋:
12 + 92 = 82
82 + 22 = 68
62 + 82 = 100
12 + 02 + 02 = 1
class Solution:
def isHappy(self, n: int) -> bool:
list1 = []
while n!= 1:
n = sum([int(i)**2 for i in str(n)])
if n not in list1:
list1.append(n)
else:
return False
return True
100、同構字符串
給定兩個字符串 s 和 t，判斷它們是否是同構的。
如果 s 中的字符可以被替換得到 t ，那麼這兩個字符串是同構的。
所有出現的字符都必須用另一個字符替換，同時保留字符的順序。兩個字符不能映射到同一個字符上，但字符可以映射自己本身。
示例 1:
輸入: s = "egg", t = "add"
輸出: true
示例 2:
輸入: s = "foo", t = "bar"
輸出: false
示例 3:
輸入: s = "paper", t = "title"
輸出: true
說明:
你可以假設 s 和 t 具有相同的長度。
class Solution:
def isIsomorphic(self, s: str, t: str) -> bool:
dict1 = {}
list1 = []
for i in range(len(t)):
if s[i] not in dict1:
if t[i]not in list1:
dict1[s[i]] = t[i]
list1.append(t[i])
else:
return False
else:
if dict1[s[i]] != t[i]:
return False
return True
不斷在更新，希望也喜歡算法的你一起努力