目录
303.区域检索-数组不可变 range-sum-query-immutable
242.有效的字母异位词 valid-anagram
"""
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的一个字母异位词。
示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false
说明:
你可以假设字符串只包含小写字母。
进阶:
如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
"""
def isAnagram(s: str, t: str) -> bool:
if len(s) != len(t):
return False
chars = set(s)
for char in chars:
if s.count(char) != t.count(char):
return False
return True
def isAnagram2(s: str, t: str) -> bool:
from collections import Counter
return Counter(s) == Counter(t)
def isAnagram3(s: str, t: str) -> bool:
if not len(s) == len(t):
return False
sHash = tHash = 1
sCount = [0] * 26
tCount = [0] * 26
p1 = 2903
p2 = 29947
for i in range(0, len(s)):
sCount[ord(s[i]) - ord('a')] += 1
tCount[ord(t[i]) - ord('a')] += 1
for i in range(0, 26):
sHash = sHash * p1 + sCount[i]
tHash = tHash * p1 + tCount[i]
p1 *= p2
return sHash == tHash
def isAnagram4(s: str, t: str) -> bool:
if len(s) != len(t):
return False
dic = dict()
for i in s:
if i in dic:
dic[i] += 1
else:
dic[i] = 1
for i in t:
if i in dic:
dic[i] -= 1
else:
dic[i] = -1
for i in dic:
if dic[i] != 0:
return False
return True
s = "anagram"
t = "nagaram"
a = isAnagram(s, t)
print(a)
258.各位相加 add-digits
"""
给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。
示例:
输入: 38
输出: 2
解释: 各位相加的过程为：3 + 8 = 11, 1 + 1 = 2。 由于 2 是一位数，所以返回 2。
进阶:
你可以不使用循环或者递归，且在 O(1) 时间复杂度内解决这个问题吗？
"""
def addDigits(num: int) -> int:
while num > 9:
num = eval('+'.join(list(str(num))))
return num
def addDigits2(num: int) -> int:
"""
n = 100a + 10b + c
= 99a + 9b + (a + b + c) , 设(a + b + c) = 10d + e
= 99a + 9b + 9d + d + e , d+e最小为1
可以看出来结果就是n%9, 但是当n是9的倍数就不成立了
所以先从n中取出1作为最小结果再对9取余
n = (n - 1) + 1, 对n-1拆分
= [99a + 9b + (a + b + c)] + 1 , 设(a + b + c) = 10d + e
= [99a + 9b + 9d + d + e] + 1 , d+e最小为1
结果就是(n-1)%9+1
"""
if num < 10:
return num
return 1 + (num - 1) % 9
class Solution:
def addDigits3(self, num: int) -> int:
"""递归"""
sum = 0
if not num:
return sum
while num:
sum += num % 10
num = num // 10
if sum > 9:
return self.addDigits(sum)
return sum
b = addDigits(38822222)
print(b)
263.丑数 ugly-number
"""
编写一个程序判断给定的数是否为丑数。
丑数就是只包含质因数 2, 3, 5 的正整数。
示例 1:
输入: 6
输出: true
解释: 6 = 2 × 3
示例 2:
输入: 8
输出: true
解释: 8 = 2 × 2 × 2
示例 3:
输入: 14
输出
解释: 14 不是丑数，因为它包含了另外一个质因数 7。
说明：
1 是丑数。
输入不会超过 32 位有符号整数的范围: [−2^31, 2^31 − 1]。
"""
def isUgly(num: int) -> bool:
if num <= 0:
return False
while num % 2 == 0 or num % 3 == 0 or num % 5 == 0:
if num % 2 == 0:
num /= 2
if num % 3 == 0:
num /= 3
if num % 5 == 0:
num /= 5
if num == 1:
return True
return False
b = isUgly(5)
print(b)
268.缺失数字 missing-number
"""
给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。
示例 1:
输入: [3,0,1]
输出: 2
示例 2:
输入: [9,6,4,2,3,5,7,0,1]
输出: 8
说明:
你的算法应具有线性时间复杂度。你能否仅使用额外常数空间来实现?
"""
def missingNumber(nums):
n = len(nums)
s = n*(n+1)//2
return s - sum(nums)
a = [9, 6, 4, 2, 3, 5, 7, 0, 1]
b = missingNumber(a)
print(b)
278.第一个错误版本 first-bad-version
"""
你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。
假设你有 n 个版本 [1, 2, ..., n]，你想找出导致之后所有版本出错的第一个错误的版本。
你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version 是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。
示例:
给定 n = 5，并且 version = 4 是第一个错误的版本。
调用 isBadVersion(3) -> false
调用 isBadVersion(5) -> true
调用 isBadVersion(4) -> true
所以，4 是第一个错误的版本。
"""
# The isBadVersion API is already defined for you.
# @param version, an integer
# @return a bool
def isBadVersion(version):
return version > 26
def firstBadVersion(n):
"""
[0000000|0011111]
[0000000|0011|111]
[0000000|00|11|111]
[0000000|00|1|1|111]
"""
low = 1
high = n
while low < high:
mid = low + (high - low) // 2
if isBadVersion(mid):
high = mid
else:
low = mid + 1
return low
a = firstBadVersion(40)
print(a)
283.移动零 move-zeroes
"""
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
说明:
必须在原数组上操作，不能拷贝额外的数组。
尽量减少操作次数。
"""
def moveZeroes(nums):
"""
如果不是0，就按顺序移到列表前面
"""
i = j = 0
for i in range(len(nums)):
if nums[i] != 0:
nums[j], nums[i] = nums[i], nums[j]
j += 1
a = [0, 1, 0, 3, 12]
moveZeroes(a)
print(a)
290.单词模式 word-pattern
"""
给定一种 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 包含了由单个空格分隔的小写字母。
"""
def wordPattern(pattern: str, str: str) -> bool:
p = [i for i in pattern]
s = str.split(' ')
if len(pattern) != len(s):
return False
if len(set(p)) != len(set(s)):
return False
z = zip(p, s)
if len(set(z)) == len(set(p)):
return True
else:
return False
def wordPattern2(pattern: str, str: str) -> bool:
d1, d2 = {}, {}
for i, v in enumerate(pattern):
d1[v] = d1.get(v, []) + [i]
for i, v in enumerate(str.split()):
d2[v] = d2.get(v, []) + [i]
return list(d1.values()) == list(d2.values())
def wordPattern3(pattern: str, str: str) -> bool:
str = str.split()
a = zip(pattern, str)
return len(pattern) == len(str) and len(set(a)) == len(set(pattern)) == len(set(str))
a = wordPattern(pattern="abba", str="dog cat dog cat")
print(a)
292.Nim游戏 nim-game
"""
你和你的朋友，两个人一起玩 Nim游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。
你们是聪明人，每一步都是最优解。 编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。
示例:
输入: 4
输出: false
解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛；
因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。
"""
def canWinNim(n: int) -> bool:
return n % 4 != 0
303.区域检索-数组不可变 range-sum-query-immutable
'''
给定一个整数数组 nums，求出数组从索引 i 到 j (i ≤ j) 范围内元素的总和，包含 i, j 两点。
示例：
给定 nums = [-2, 0, 3, -5, 2, -1]，求和函数为 sumRange()
sumRange(0, 2) -> 1
sumRange(2, 5) -> -1
sumRange(0, 5) -> -3
说明:
你可以假设数组不可变。
会多次调用 sumRange 方法。
'''
class NumArray2(object):
def __init__(self, nums):
"""
initialize your data structure here.
:type nums: List[int]
"""
self.dp = [0] * (len(nums) + 1)
for i in range(0, len(nums)):
self.dp[i + 1] = self.dp[i] + nums[i]
def sumRange(self, i, j):
"""
sum of elements nums[i..j], inclusive.
:type i: int
:type j: int
:rtype: int
"""
return self.dp[j + 1] - self.dp[i]
class NumArray:
def __init__(self, nums):
self.nums = nums
def sumRange(self, i: int, j: int) -> int:
return sum(self.nums[i:j+1])
# Your NumArray object will be instantiated and called as such:
nums = [-2, 0, 3, -5, 2, -1]
obj = NumArray(nums)
param_1 = obj.sumRange(2, 3)
print(param_1)
326.3的幂 power-of-three
'''
给定一个整数，写一个函数来判断它是否是 3 的幂次方。
示例 1:
输入: 27
输出: true
示例 2:
输入: 0
输出: false
示例 3:
输入: 9
输出: true
示例 4:
输入: 45
输出: false
进阶：
你能不使用循环或者递归来完成本题吗？
'''
def isPowerOfThree(n: int):
if n > 0:
return (1162261467 % n) == 0
else:
return False
print(isPowerOfThree(27))
339
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
