788. 旋轉數字
我們稱一個數 X 為好數, 如果它的每位數字逐個地被旋轉 180 度后，我們仍可以得到一個有效的，且和 X 不同的數。要求每位數字都要被旋轉。
如果一個數的每位數字被旋轉以后仍然還是一個數字， 則這個數是有效的。0, 1, 和 8 被旋轉后仍然是它們自己；2 和 5 可以互相旋轉成對方（在這種情況下，它們以不同的方向旋轉，換句話說，2 和 5 互為鏡像）；6 和 9 同理，除了這些以外其他的數字旋轉以后都不再是有效的數字。
現在我們有一個正整數 N, 計算從 1 到 N 中有多少個數 X 是好數？
示例：
輸入: 10
輸出: 4
解釋:
在[1, 10]中有四個好數： 2, 5, 6, 9。
注意 1 和 10 不是好數, 因為他們在旋轉之后不變。
class Solution(object):
def rotatedDigits(self, N):
"""
:type N: int
:rtype: int
"""
count = 0
f = False
for i in range(1,N+1):
for c in str(i):
if c in '347':
f = False
break
if c in '2569':
f = True
if f:
count += 1
f = False
return count
804. 唯一摩爾斯密碼詞
國際摩爾斯密碼定義一種標准編碼方式，將每個字母對應於一個由一系列點和短線組成的字符串， 比如: "a" 對應 ".-", "b" 對應 "-...", "c" 對應 "-.-.", 等等。
為了方便，所有26個英文字母對應摩爾斯密碼表如下：
[".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
給定一個單詞列表，每個單詞可以寫成每個字母對應摩爾斯密碼的組合。例如，"cab" 可以寫成 "-.-..--..."，(即 "-.-." + ".-" + "-..." 字符串的結合)。我們將這樣一個連接過程稱作單詞翻譯。
返回我們可以獲得所有詞不同單詞翻譯的數量。
例如:
輸入: words = ["gin", "zen", "gig", "msg"]
輸出: 2
解釋:
各單詞翻譯如下:
"gin" -> "--...-."
"zen" -> "--...-."
"gig" -> "--...--."
"msg" -> "--...--."
共有 2 種不同翻譯, "--...-." 和 "--...--.".
class Solution(object):
def uniqueMorseRepresentations(self, words):
"""
:type words: List[str]
:rtype: int
"""
table = {'a':".-",'b':"-...",'c':"-.-.",'d':"-..",'e':".",
'f':"..-.",'g':"--.",'h':"....",'i':"..",'j':".---",
'k':"-.-",'l':".-..",'m':"--",'n':"-.",'o':"---",
'p':".--.",'q':"--.-",'r':".-.",'s':"...",'t':"-",
'u':"..-",'v':"...-",'w':".--",'x':"-..-",'y':"-.--",
'z':"--.."}
res = set()
for w in words:
s = ''
for c in w:
s += table[c]
res.add(s)
return len(res)
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(object):
def mostCommonWord(self, paragraph, banned):
"""
:type paragraph: str
:type banned: List[str]
:rtype: str
"""
d = {}
for c in string.punctuation:
paragraph = paragraph.replace(c," ")
for w in paragraph.split():
w = w.lower()
d[w] = d.get(w,0) + 1
l = sorted(d.items(),key=lambda x:x[1],reverse=True)
for k,v in l:
if k not in banned:
return k
824. 山羊拉丁文
給定一個由空格分割單詞的句子 S。每個單詞只包含大寫或小寫字母。
我們要將句子轉換為 “Goat Latin”（一種類似於 豬拉丁文 - Pig Latin 的虛構語言）。
山羊拉丁文的規則如下：
如果單詞以元音開頭（a, e, i, o, u），在單詞后添加"ma"。
例如，單詞"apple"變為"applema"。
如果單詞以輔音字母開頭（即非元音字母），移除第一個字符並將它放到末尾，之后再添加"ma"。
例如，單詞"goat"變為"oatgma"。
根據單詞在句子中的索引，在單詞最后添加與索引相同數量的字母'a'，索引從1開始。
例如，在第一個單詞后添加"a"，在第二個單詞后添加"aa"，以此類推。
返回將 S 轉換為山羊拉丁文后的句子。
示例 1:
輸入: "I speak Goat Latin"
輸出: "Imaa peaksmaaa oatGmaaaa atinLmaaaaa"
示例 2:
輸入: "The quick brown fox jumped over the lazy dog"
輸出: "heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa"
class Solution(object):
def toGoatLatin(self, S):
"""
:type S: str
:rtype: str
"""
vowels = 'aeiou'
res = []
for i,w in enumerate(S.split()):
c = w[0]
if c.lower() in vowels:
w += 'ma'
else:
w = w[1:] + c + 'ma'
w = w + 'a' * (i+1)
res.append(w)
return ' '.join(res)
859. 親密字符串
給定兩個由小寫字母構成的字符串 A 和 B ，只要我們可以通過交換 A 中的兩個字母得到與 B 相等的結果，就返回 true ；否則返回 false 。
示例 1：
輸入： A = "ab", B = "ba"
輸出： true
示例 2：
輸入： A = "ab", B = "ab"
輸出： false
示例 3:
輸入： A = "aa", B = "aa"
輸出： true
示例 4：
輸入： A = "aaaaaaabc", B = "aaaaaaacb"
輸出： true
示例 5：
輸入： A = "", B = "aa"
輸出： false
class Solution(object):
def buddyStrings(self, A, B):
"""
:type A: str
:type B: str
:rtype: bool
"""
if len(A)<2 or len(A)!=len(B):
return False
if A == B and len(A)>len(set(A)):
return True
count = 0
for i in range(len(A)):
if A[i] != B[i]:
if count == 0:
swap = [A[i],B[i]]
count += 1
elif count == 1 and A[i] == swap[1] and B[i] == swap[0]:
count += 1
else:
return False
if count == 2:
return True
else:
return False
893. 特殊等價字符串組
你將得到一個字符串數組 A。
每次移動都可以交換 S 的任意兩個偶數下標的字符或任意兩個奇數下標的字符。
如果經過任意次數的移動，S == T，那么兩個字符串 S 和 T 是 特殊等價 的。
例如，S = "zzxy" 和 T = "xyzz" 是一對特殊等價字符串，因為可以先交換 S[0] 和 S[2]，然后交換 S[1] 和 S[3]，使得 "zzxy" -> "xzzy" -> "xyzz" 。
現在規定，A 的 一組特殊等價字符串 就是 A 的一個同時滿足下述條件的非空子集：
該組中的每一對字符串都是 特殊等價 的
該組字符串已經涵蓋了該類別中的所有特殊等價字符串，容量達到理論上的最大值（也就是說，如果一個字符串不在該組中，那么這個字符串就 不會 與該組內任何字符串特殊等價）
返回 A 中特殊等價字符串組的數量。
示例 1：
輸入：["abcd","cdab","cbad","xyzz","zzxy","zzyx"]
輸出：3
解釋：
其中一組為 ["abcd", "cdab", "cbad"]，因為它們是成對的特殊等價字符串，且沒有其他字符串與這些字符串特殊等價。
另外兩組分別是 ["xyzz", "zzxy"] 和 ["zzyx"]。特別需要注意的是，"zzxy" 不與 "zzyx" 特殊等價。
示例 2：
輸入：["abc","acb","bac","bca","cab","cba"]
輸出：3
解釋：3 組 ["abc","cba"]，["acb","bca"]，["bac","cab"]
class Solution(object):
def numSpecialEquivGroups(self, A):
"""
:type A: List[str]
:rtype: int
"""
return len({(''.join(sorted(str[::2]) +sorted(str[1::2]))) for str in A})
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!"
class Solution(object):
def reverseOnlyLetters(self, S):
"""
:type S: str
:rtype: str
"""
p,q = 0,len(S)-1
s = list(S)
while p < q:
if not s[p].isalpha():
p += 1
elif not s[q].isalpha():
q -= 1
else:
s[p],s[q] = s[q],s[p]
p += 1
q -= 1
return ''.join(s)
925. 長按鍵入
你的朋友正在使用鍵盤輸入他的名字 name。偶爾，在鍵入字符 c 時，按鍵可能會被長按，而字符可能被輸入 1 次或多次。
你將會檢查鍵盤輸入的字符 typed。如果它對應的可能是你的朋友的名字（其中一些字符可能被長按），那么就返回 True。
示例 1：
輸入：name = "alex", typed = "aaleex"
輸出：true
解釋：'alex' 中的 'a' 和 'e' 被長按。
示例 2：
輸入：name = "saeed", typed = "ssaaedd"
輸出：false
解釋：'e' 一定需要被鍵入兩次，但在 typed 的輸出中不是這樣。
示例 3：
輸入：name = "leelee", typed = "lleeelee"
輸出：true
示例 4：
輸入：name = "laiden", typed = "laiden"
輸出：true
解釋：長按名字中的字符並不是必要的。
class Solution(object):
def isLongPressedName(self, name, typed):
"""
:type name: str
:type typed: str
:rtype: bool
"""
p=q=0
while p<len(name) and q<len(typed):
if name[p] == typed[q]:
p+=1
q+=1
else:
if q>0 and typed[q] == typed[q-1]:
q+=1
else:
return False
if p<len(name):
return False
if q<len(typed) and len(set(typed[q:]))>1:
return False
else:
return True
929. 獨特的電子郵件地址
每封電子郵件都由一個本地名稱和一個域名組成，以 @ 符號分隔。
例如，在 alice@leetcode.com中， alice 是本地名稱，而 leetcode.com 是域名。
除了小寫字母，這些電子郵件還可能包含 '.' 或 '+'。
如果在電子郵件地址的本地名稱部分中的某些字符之間添加句點（'.'），則發往那里的郵件將會轉發到本地名稱中沒有點的同一地址。例如，"alice.z@leetcode.com” 和 “alicez@leetcode.com” 會轉發到同一電子郵件地址。 （請注意，此規則不適用於域名。）
如果在本地名稱中添加加號（'+'），則會忽略第一個加號后面的所有內容。這允許過濾某些電子郵件，例如 m.y+name@email.com 將轉發到 my@email.com。 （同樣，此規則不適用於域名。）
可以同時使用這兩個規則。
給定電子郵件列表 emails，我們會向列表中的每個地址發送一封電子郵件。實際收到郵件的不同地址有多少？
示例：
輸入：["test.email+alex@leetcode.com","test.e.mail+bob.cathy@leetcode.com","testemail+david@lee.tcode.com"]
輸出：2
解釋：實際收到郵件的是 "testemail@leetcode.com" 和 "testemail@lee.tcode.com"。
class Solution(object):
def numUniqueEmails(self, emails):
"""
:type emails: List[str]
:rtype: int
"""
email_set = set()
for i in range(len(emails)):
email_pre,email_suf = emails[i].split('@')
if '+' in email_pre:
email_pre = email_pre[:email_pre.index('+')]
email_pre = email_pre.replace('.','')
email_set.add(email_pre+'@'+email_suf)
return len(email_set)
937. 重新排列日志文件
你有一個日志數組 logs。每條日志都是以空格分隔的字串。
對於每條日志，其第一個字為字母與數字混合的 標識符 ，除標識符之外的所有字為這一條日志的 內容 。
除標識符之外，所有字均由小寫字母組成的，稱為 字母日志
除標識符之外，所有字均由數字組成的，稱為 數字日志
題目所用數據保證每個日志在其標識符后面至少有一個字。
請按下述規則將日志重新排序：
所有 字母日志 都排在 數字日志 之前。
字母日志 在內容不同時，忽略標識符后，按內容字母順序排序；在內容相同時，按標識符排序；
數字日志 應該按原來的順序排列。
返回日志的最終順序。
示例 ：
輸入：["a1 9 2 3 1","g1 act car","zo4 4 7","ab1 off key dog","a8 act zoo"]
輸出：["g1 act car","a8 act zoo","ab1 off key dog","a1 9 2 3 1","zo4 4 7"]
class Solution(object):
def reorderLogFiles(self, logs):
"""
:type logs: List[str]
:rtype: List[str]
"""
return sorted(logs, key=self.getKey)
def getKey(self, ele):
sign, content = ele.split(' ', 1)
return (0, content, sign) if content[0].isalpha() else (1,)
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"
輸出：""
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 ''
1108. IP 地址無效化
給你一個有效的 IPv4 地址 address，返回這個 IP 地址的無效化版本。
所謂無效化 IP 地址，其實就是用 "[.]" 代替了每個 "."。
示例 1：
輸入：address = "1.1.1.1"
輸出："1[.]1[.]1[.]1"
示例 2：
輸入：address = "255.100.50.0"
輸出："255[.]100[.]50[.]0"
class Solution:
def defangIPaddr(self, address: str) -> str:
return address.replace('.','[.]')
1170. 比較字符串最小字母出現頻次
我們來定義一個函數 f(s)，其中傳入參數 s 是一個非空字符串；該函數的功能是統計 s 中（按字典序比較）最小字母的出現頻次。
例如，若 s = "dcce"，那么 f(s) = 2，因為最小的字母是 "c"，它出現了 2 次。
現在，給你兩個字符串數組待查表 queries 和詞匯表 words，請你返回一個整數數組 answer 作為答案，其中每個 answer[i] 是滿足 f(queries[i]) < f(W) 的詞的數目，W 是詞匯表 words 中的詞。
示例 1：
輸入：queries = ["cbd"], words = ["zaaaz"]
輸出：[1]
解釋：查詢 f("cbd") = 1，而 f("zaaaz") = 3 所以 f("cbd") < f("zaaaz")。
示例 2：
輸入：queries = ["bbb","cc"], words = ["a","aa","aaa","aaaa"]
輸出：[1,2]
解釋：第一個查詢 f("bbb") < f("aaaa")，第二個查詢 f("aaa") 和 f("aaaa") 都 > f("cc")。
class Solution:
def numSmallerByFrequency(self, queries: List[str], words: List[str]) -> List[int]:
wf = [self.f(w) for w in words]
res = []
for w in queries:
tmp = self.f(w)
wf.append(tmp)
wf = sorted(wf,reverse=True)
r = wf.index(tmp)
res.append(r)
wf.remove(tmp)
return res
def f(self,s):
return s.count(min(s))
1189. “氣球” 的最大數量
給你一個字符串 text，你需要使用 text 中的字母來拼湊盡可能多的單詞 "balloon"（氣球）。
字符串 text 中的每個字母最多只能被使用一次。請你返回最多可以拼湊出多少個單詞 "balloon"。
示例 1：
輸入：text = "nlaebolko"
輸出：1
示例 2：
輸入：text = "loonbalxballpoon"
輸出：2
示例 3：
輸入：text = "leetcode"
輸出：0
class Solution:
def maxNumberOfBalloons(self, text: str) -> int:
d = {'a':1, 'b':1, 'l':2, 'n':1, 'o':2}
l = [text.count(c)//d[c] for c in 'ablno']
return min(l)
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:
res = 0
balance = 0
for c in s:
if balance == 0:
tmp = c
res += 1
if c == tmp:
balance += 1
else:
balance -= 1
return res
1309. 解碼字母到整數映射
給你一個字符串 s，它由數字（'0' - '9'）和 '#' 組成。我們希望按下述規則將 s 映射為一些小寫英文字符：
字符（'a' - 'i'）分別用（'1' - '9'）表示。
字符（'j' - 'z'）分別用（'10#' - '26#'）表示。
返回映射之后形成的新字符串。
題目數據保證映射始終唯一。
示例 1：
輸入：s = "10#11#12"
輸出："jkab"
解釋："j" -> "10#" , "k" -> "11#" , "a" -> "1" , "b" -> "2".
示例 2：
輸入：s = "1326#"
輸出："acz"
示例 3：
輸入：s = "25#"
輸出："y"
示例 4：
輸入：s = "12345678910#11#12#13#14#15#16#17#18#19#20#21#22#23#24#25#26#"
輸出："abcdefghijklmnopqrstuvwxyz"
class Solution:
def freqAlphabets(self, s: str) -> str:
d = {}
for i in range(1,27):
if i < 10:
d[str(i)] = chr(i+96)
else:
d[str(i)+'#'] = chr(i+96)
res = ''
p = 0
while p<len(s):
if p+2<len(s) and s[p+2] == '#':
res += d[s[p:p+3]]
p += 3
else:
res += d[s[p]]
p += 1
return res
1332. 刪除回文子序列
給你一個字符串 s，它僅由字母 'a' 和 'b' 組成。每一次刪除操作都可以從 s 中刪除一個回文 子序列。
返回刪除給定字符串中所有字符（字符串為空）的最小刪除次數。
「子序列」定義：如果一個字符串可以通過刪除原字符串某些字符而不改變原字符順序得到，那么這個字符串就是原字符串的一個子序列。
「回文」定義：如果一個字符串向后和向前讀是一致的，那么這個字符串就是一個回文。
示例 1：
輸入：s = "ababa"
輸出：1
解釋：字符串本身就是回文序列，只需要刪除一次。
示例 2：
輸入：s = "abb"
輸出：2
解釋："abb" -> "bb" -> "".
先刪除回文子序列 "a"，然后再刪除 "bb"。
示例 3：
輸入：s = "baabb"
輸出：2
解釋："baabb" -> "b" -> "".
先刪除回文子序列 "baab"，然后再刪除 "b"。
示例 4：
輸入：s = ""
輸出：0
class Solution:
def removePalindromeSub(self, s: str) -> int:
if not s:
return 0
return 1 if s==s[::-1] else 2
1370. 上升下降字符串
給你一個字符串 s ，請你根據下面的算法重新構造字符串：
從 s 中選出 最小 的字符，將它 接在 結果字符串的后面。
從 s 剩余字符中選出 最小 的字符，且該字符比上一個添加的字符大，將它 接在 結果字符串后面。
重復步驟 2 ，直到你沒法從 s 中選擇字符。
從 s 中選出 最大 的字符，將它 接在 結果字符串的后面。
從 s 剩余字符中選出 最大 的字符，且該字符比上一個添加的字符小，將它 接在 結果字符串后面。
重復步驟 5 ，直到你沒法從 s 中選擇字符。
重復步驟 1 到 6 ，直到 s 中所有字符都已經被選過。
在任何一步中，如果最小或者最大字符不止一個 ，你可以選擇其中任意一個，並將其添加到結果字符串。
請你返回將 s 中字符重新排序后的 結果字符串 。
示例 1：
輸入：s = "aaaabbbbcccc"
輸出："abccbaabccba"
解釋：第一輪的步驟 1，2，3 后，結果字符串為 result = "abc"
第一輪的步驟 4，5，6 后，結果字符串為 result = "abccba"
第一輪結束，現在 s = "aabbcc" ，我們再次回到步驟 1
第二輪的步驟 1，2，3 后，結果字符串為 result = "abccbaabc"
第二輪的步驟 4，5，6 后，結果字符串為 result = "abccbaabccba"
示例 2：
輸入：s = "rat"
輸出："art"
解釋：單詞 "rat" 在上述算法重排序以后變成 "art"
示例 3：
輸入：s = "leetcode"
輸出："cdelotee"
示例 4：
輸入：s = "ggggggg"
輸出："ggggggg"
示例 5：
輸入：s = "spo"
輸出："ops"
class Solution:
def sortString(self, s: str) -> str:
str_counter = collections.Counter(s)
result = []
flag = False
while str_counter:
keys = list(str_counter.keys())
keys.sort(reverse=flag)
flag = not flag
result.append(''.join(keys))
str_counter -= collections.Counter(keys)
return ''.join(result)
1374. 生成每種字符都是奇數個的字符串
給你一個整數 n，請你返回一個含 n 個字符的字符串，其中每種字符在該字符串中都恰好出現 奇數次 。
返回的字符串必須只含小寫英文字母。如果存在多個滿足題目要求的字符串，則返回其中任意一個即可。
示例 1：
輸入：n = 4
輸出："pppz"
解釋："pppz" 是一個滿足題目要求的字符串，因為 'p' 出現 3 次，且 'z' 出現 1 次。當然，還有很多其他字符串也滿足題目要求，比如："ohhh" 和 "love"。
示例 2：
輸入：n = 2
輸出："xy"
解釋："xy" 是一個滿足題目要求的字符串，因為 'x' 和 'y' 各出現 1 次。當然，還有很多其他字符串也滿足題目要求，比如："ag" 和 "ur"。
示例 3：
輸入：n = 7
輸出："holasss"
class Solution:
def generateTheString(self, n: int) -> str:
if n%2==0:
return 'a'*(n-1)+'b'
else:
return 'a'*n
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]:
res = set()
for i in range(len(words)):
for j in range(len(words)):
if i!=j and words[i] in words[j]:
res.add(words[i])
return list(res)
1417. 重新格式化字符串
給你一個混合了數字和字母的字符串 s，其中的字母均為小寫英文字母。
請你將該字符串重新格式化，使得任意兩個相鄰字符的類型都不同。也就是說，字母后面應該跟着數字，而數字后面應該跟着字母。
請你返回 重新格式化后 的字符串；如果無法按要求重新格式化，則返回一個 空字符串 。
示例 1：
輸入：s = "a0b1c2"
輸出："0a1b2c"
解釋："0a1b2c" 中任意兩個相鄰字符的類型都不同。 "a0b1c2", "0a1b2c", "0c2a1b" 也是滿足題目要求的答案。
示例 2：
輸入：s = "leetcode"
輸出：""
解釋："leetcode" 中只有字母，所以無法滿足重新格式化的條件。
示例 3：
輸入：s = "1229857369"
輸出：""
解釋："1229857369" 中只有數字，所以無法滿足重新格式化的條件。
示例 4：
輸入：s = "covid2019"
輸出："c2o0v1i9d"
示例 5：
輸入：s = "ab123"
輸出："1a2b3"
class Solution:
def reformat(self, s: str) -> str:
if not s:
return ''
letters = []
nums = []
res = ''
for c in s:
if c.isalpha():
letters.append(c)
else:
nums.append(c)
if abs(len(letters)-len(nums))>1:
return ''
res = ''.join([i + j for i,j in zip(letters,nums)])
if len(letters)<len(nums):
return nums[-1] + res
elif len(letters)>len(nums):
return res + letters[-1]
else:
return res
1422. 分割字符串的最大得分
給你一個由若干 0 和 1 組成的字符串 s ，請你計算並返回將該字符串分割成兩個 非空 子字符串（即 左 子字符串和 右 子字符串）所能獲得的最大得分。
「分割字符串的得分」為 左 子字符串中 0 的數量加上 右 子字符串中 1 的數量。
示例 1：
輸入：s = "011101"
輸出：5
解釋：
將字符串 s 划分為兩個非空子字符串的可行方案有：
左子字符串 = "0" 且 右子字符串 = "11101"，得分 = 1 + 4 = 5
左子字符串 = "01" 且 右子字符串 = "1101"，得分 = 1 + 3 = 4
左子字符串 = "011" 且 右子字符串 = "101"，得分 = 1 + 2 = 3
左子字符串 = "0111" 且 右子字符串 = "01"，得分 = 1 + 1 = 2
左子字符串 = "01110" 且 右子字符串 = "1"，得分 = 2 + 1 = 3
示例 2：
輸入：s = "00111"
輸出：5
解釋：當 左子字符串 = "00" 且 右子字符串 = "111" 時，我們得到最大得分 = 2 + 3 = 5
示例 3：
輸入：s = "1111"
輸出：3
class Solution:
def maxScore(self, s: str) -> int:
res = 0
for i in range(1,len(s)):
l = s[:i]
r = s[i:]
score = l.count('0') + r.count('1')
if score > res:
res = score
return res
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:
s = {c1 for c1,c2 in paths}
for c1,c2 in paths:
if c2 not in s:
return c2
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
class Solution:
def maxPower(self, s: str) -> int:
if not s:
return 0
old = s[0]
count = 1
ans = 1
for c in s[1:]:
if c!=old:
old = c
ans = max(ans,count)
count = 1
else:
count += 1
ans = max(ans,count)
return ans
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:
for i,w in enumerate(sentence.split()):
if w.startswith(searchWord):
return i+1
else:
return -1
1496. 判斷路徑是否相交
給你一個字符串 path，其中 path[i] 的值可以是 'N'、'S'、'E' 或者 'W'，分別表示向北、向南、向東、向西移動一個單位。
機器人從二維平面上的原點 (0, 0) 處開始出發，按 path 所指示的路徑行走。
如果路徑在任何位置上出現相交的情況，也就是走到之前已經走過的位置，請返回 True ；否則，返回 False 。
示例 1：
輸入：path = "NES"
輸出：false
解釋：該路徑沒有在任何位置相交。
示例 2：
輸入：path = "NESWW"
輸出：true
解釋：該路徑經過原點兩次。
class Solution:
def isPathCrossing(self, path: str) -> bool:
s = set()
coor = (0, 0)
s.add(coor)
for p in path:
if p == 'N':
x, y = 0, 1
elif p == 'S':
x, y = 0, -1
elif p == 'E':
x, y = 1, 0
else:
x, y = -1, 0
coor = (coor[0] + x, coor[1] + y)
if coor in s:
return True
s.add(coor)
else:
return False
1507. 轉變日期格式
給你一個字符串 date ，它的格式為 Day Month Year ，其中：
Day 是集合 {"1st", "2nd", "3rd", "4th", ..., "30th", "31st"} 中的一個元素。
Month 是集合 {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"} 中的一個元素。
Year 的范圍在 [1900, 2100] 之間。
請你將字符串轉變為 YYYY-MM-DD 的格式，其中：
YYYY 表示 4 位的年份。
MM 表示 2 位的月份。
DD 表示 2 位的天數。
示例 1：
輸入：date = "20th Oct 2052"
輸出："2052-10-20"
示例 2：
輸入：date = "6th Jun 1933"
輸出："1933-06-06"
示例 3：
輸入：date = "26th May 1960"
輸出："1960-05-26"
class Solution:
def reformatDate(self, date: str) -> str:
month_w2n = {"Jan":'01', "Feb":'02', "Mar":'03', "Apr":'04', "May":'05', "Jun":'06', "Jul":'07', "Aug":'08', "Sep":'09', "Oct":'10', "Nov":'11', "Dec":'12'}
d, m, y = date.split()
day = d[:-2]
month = month_w2n[m]
return '{}-{}-{:0>2d}'.format(y,month,int(day))
1544. 整理字符串
給你一個由大小寫英文字母組成的字符串 s 。
一個整理好的字符串中，兩個相鄰字符 s[i] 和 s[i + 1] 不會同時滿足下述條件：
0 <= i <= s.length - 2
s[i] 是小寫字符，但 s[i + 1] 是相同的大寫字符；反之亦然 。
請你將字符串整理好，每次你都可以從字符串中選出滿足上述條件的 兩個相鄰 字符並刪除，直到字符串整理好為止。
請返回整理好的 字符串 。題目保證在給出的約束條件下，測試樣例對應的答案是唯一的。
注意：空字符串也屬於整理好的字符串，盡管其中沒有任何字符。
示例 1：
輸入：s = "leEeetcode"
輸出："leetcode"
解釋：無論你第一次選的是 i = 1 還是 i = 2，都會使 "leEeetcode" 縮減為 "leetcode" 。
示例 2：
輸入：s = "abBAcC"
輸出：""
解釋：存在多種不同情況，但所有的情況都會導致相同的結果。例如：
"abBAcC" --> "aAcC" --> "cC" --> ""
"abBAcC" --> "abBA" --> "aA" --> ""
示例 3：
輸入：s = "s"
輸出："s"
class Solution:
def makeGood(self, s: str) -> str:
stack = []
for i in s:
if stack and ((ord(stack[-1])-32) == ord(i) or (ord(stack[-1])+32) == ord(i)):
stack.pop()
else:
stack.append(i)
return ''.join(stack)
來源：力扣（LeetCode）
鏈接：https://leetcode-cn.com/problems/rotated-digits
著作權歸領扣網絡所有。商業轉載請聯系官方授權，非商業轉載請注明出處。