5713. 字符串中不同整数的数目
给你一个字符串 word ,该字符串由数字和小写英文字母组成。
请你用空格替换每个不是数字的字符。例如,“a123bc34d8ef34” 将会变成 " 123 34 8 34" 。注意,剩下的这些整数间至少要用一个空格隔开:“123”、“34”、“8” 和 “34” 。
返回对 word 完成替换后形成的 不同 整数的数目。
如果两个整数的 不含前导零 的十进制表示不同,则认为这两个整数也不同。
示例 1:
输入:word = “a123bc34d8ef34”
输出:3
解释:不同的整数有 “123”、“34” 和 “8” 。注意,“34” 只计数一次。
示例 2:
输入:word = “leet1234code234”
输出:2
示例 3:
输入:word = “a1b01c001”
输出:1
解释:“1”、“01” 和 “001” 视为同一个整数的十进制表示,因为在比较十进制值时会忽略前导零的存在。
提示:
-
1 <= word.length <= 1000
-
word 由数字和小写英文字母组成
class Solution:
def numDifferentIntegers(self, word: str) -> int:
count = 0
tmp = ""
numSet = set()
for x in word:
if x.isdigit():
tmp += x
else:
if tmp and int(tmp) not in numSet:
count += 1
numSet.add(int(tmp))
tmp = ""
if tmp and int(tmp) not in numSet:
count += 1
numSet.add(int(tmp))
return count
1806. 还原排列的最少操作步数
给你一个偶数 n ,已知存在一个长度为 n 的排列 perm ,其中 perm[i] == i (下标 从 0 开始 计数)。
一步操作中,你将创建一个新数组 arr ,对于每个 i :
如果 i % 2 == 0 ,那么 arr[i] = perm[i / 2]
如果 i % 2 == 1 ,那么 arr[i] = perm[n / 2 + (i - 1) / 2]
然后将 arr 赋值 给 perm 。
要想使 perm 回到排列初始值,至少需要执行多少步操作?返回最小的 非零 操作步数。
示例 1:
输入:n = 2
输出:1
解释:最初,perm = [0,1]
第 1 步操作后,perm = [0,1]
所以,仅需执行 1 步操作
示例 2:
输入:n = 4
输出:2
解释:最初,perm = [0,1,2,3]
第 1 步操作后,perm = [0,2,1,3]
第 2 步操作后,perm = [0,1,2,3]
所以,仅需执行 2 步操作
示例 3:
输入:n = 6
输出:4
提示:
-
2 <= n <= 1000
-
n 是一个偶数
class Solution:
def reinitializePermutation(self, n: int) -> int:
perm = [i for i in range(n)]
arr = [i for i in range(n)]
lastArr = arr.copy()
res = 0
while True:
for i in range(len(arr)):
if i % 2 == 0:
arr[i] = lastArr[i // 2]
else:
arr[i] = lastArr[n // 2 + (i - 1) // 2]
res += 1
lastArr = arr.copy()
if perm == arr:
return res
5714. 替换字符串中的括号内容
给你一个字符串 s ,它包含一些括号对,每个括号中包含一个 非空 的键。
比方说,字符串 “(name)is(age)yearsold” 中,有 两个 括号对,分别包含键 “name” 和 “age” 。
你知道许多键对应的值,这些关系由二维字符串数组 knowledge 表示,其中 knowledge[i] = [keyi, valuei] ,表示键 keyi 对应的值为 valuei 。
你需要替换 所有 的括号对。当你替换一个括号对,且它包含的键为 keyi 时,你需要:
将 keyi 和括号用对应的值 valuei 替换。
如果从 knowledge 中无法得知某个键对应的值,你需要将 keyi 和括号用问号 “?” 替换(不需要引号)。
knowledge 中每个键最多只会出现一次。s 中不会有嵌套的括号。
请你返回替换 所有 括号对后的结果字符串。
示例 1:
输入:s = “(name)is(age)yearsold”, knowledge = [[“name”,“bob”],[“age”,“two”]]
输出:“bobistwoyearsold”
解释:
键 “name” 对应的值为 “bob” ,所以将 “(name)” 替换为 “bob” 。
键 “age” 对应的值为 “two” ,所以将 “(age)” 替换为 “two” 。
示例 2:
输入:s = “hi(name)”, knowledge = [[“a”,“b”]]
输出:“hi?”
解释:由于不知道键 “name” 对应的值,所以用 “?” 替换 “(name)” 。
示例 3:
输入:s = “(a)(a)(a)aaa”, knowledge = [[“a”,“yes”]]
输出:“yesyesyesaaa”
解释:相同的键在 s 中可能会出现多次。
键 “a” 对应的值为 “yes” ,所以将所有的 “(a)” 替换为 “yes” 。
注意,不在括号里的 “a” 不需要被替换。
示例 4:
输入:s = “(a)(b)”, knowledge = [[“a”,“b”],[“b”,“a”]]
输出:“ba”
提示:
-
1 <= s.length <= 105
-
0 <= knowledge.length <= 105
-
knowledge[i].length == 2
-
1 <= keyi.length, valuei.length <= 10
-
s 只包含小写英文字母和圆括号 ‘(’ 和 ‘)’ 。
-
s 中每一个左圆括号 ‘(’ 都有对应的右圆括号 ‘)’ 。
-
s 中每对括号内的键都不会为空。
-
s 中不会有嵌套括号对。
-
keyi 和 valuei 只包含小写英文字母。
-
knowledge 中的 keyi 不会重复。
class Solution:
def evaluate(self, s: str, knowledge: List[List[str]]) -> str:
dic = collections.defaultdict(str)
for k in knowledge:
dic[k[0]] = k[1]
key = ""
flag = False
res = ""
for i, x in enumerate(list(s)):
if x == '(':
flag = True
elif x == ')':
flag = False
if key in dic:
res += dic[key]
else:
res += '?'
key = ""
elif flag:
key += x
else:
res += x
return res
5716. 好因子的最大数目
给你一个正整数 primeFactors 。你需要构造一个正整数 n ,它满足以下条件:
n 质因数(质因数需要考虑重复的情况)的数目 不超过 primeFactors 个。
n 好因子的数目最大化。如果 n 的一个因子可以被 n 的每一个质因数整除,我们称这个因子是 好因子 。比方说,如果 n = 12 ,那么它的质因数为 [2,2,3] ,那么 6 和 12 是好因子,但 3 和 4 不是。
请你返回 n 的好因子的数目。由于答案可能会很大,请返回答案对 109 + 7 取余 的结果。
请注意,一个质数的定义是大于 1 ,且不能被分解为两个小于该数的自然数相乘。一个数 n 的质因子是将 n 分解为若干个质因子,且它们的乘积为 n 。
示例 1:
输入:primeFactors = 5
输出:6
解释:200 是一个可行的 n 。
它有 5 个质因子:[2,2,2,5,5] ,且有 6 个好因子:[10,20,40,50,100,200] 。
不存在别的 n 有至多 5 个质因子,且同时有更多的好因子。
示例 2:
输入:primeFactors = 8
输出:18
提示:
1 <= primeFactors <= 109
已知:
- a1, a2, a3, …… an 是质数
- a1^b1 + a2^b2 + …… + an^bn = sum;
- b1 + b2 + …… + bn = n; 其中n已知
求:
好因子个数,比如有 3 个 2, 2 个 5,那么好因子个数就相当于在 3个2 里取出3种情况(1个2, 2个2, 3个2),在 2个5 里取出2种情况(1个5,2个5),相乘即可,即好因子个数 = 3 * 2 = 6
上面这种算法其实就是 好因子个数 = b1 * b2 * …… * bn 的最大值
那么求好因子个数的最大值就是求:
- 已知 b1 + b2 + …… + bn = n
- 求 b1 * b2 * …… * bn 的最大值
然后就发现这是一道原题 --> 343. 整数拆分
需要注意的是幂次太大会溢出需要取模,因此在快速幂里取模 --> 50. Pow(x, n)
class Solution:
def maxNiceDivisors(self, primeFactors: int) -> int:
tmp = 10**9+7
def myPow(x, n):
if n == 0:
return 1
half = myPow(x, n//2)
if n % 2 == 0:
return half * half % tmp
else:
return half * half * x % tmp
if primeFactors <= 3:
return primeFactors
quotient, remainder = primeFactors//3, primeFactors%3
if remainder == 0:
return myPow(3, quotient) % tmp
elif remainder == 1:
return myPow(3, quotient-1)*4 % tmp
else:
return myPow(3, quotient)*2 % tmp