目录
1.给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。找到所有在 [1, n] 范围之间没有出现在数组中的数字。
2.给定一个长度为 n 的非空整数数组，找到让数组所有元素相等的最小移动次数。每次移动可以使 n - 1 个元素增加 1。
4.给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
5.两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。
6.给定一个包含 0 和 1 的二维网格地图，其中 1 表示陆地 0 表示水域。计算这个岛屿的周长
7.冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。
8.给定一个密钥字符串S，只包含字母，数字以及 '-'（破折号）。N 个 '-' 将字符串分成了 N+1 组。
1.给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。找到所有在 [1, n] 范围之间没有出现在数组中的数字。
您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。
示例:
输入:
[4,3,2,7,8,2,3,1]
输出:
[5,6]class Solution(object):
def findDisappearedNumbers(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
res = []
for i in nums:
i=abs(i)
nums[i-1]=-abs(nums[i-1])
for i in range(len(nums)):
if nums[i]>0:
res.append(i+1)
return resclass Solution(object):
def findDisappearedNumbers(self, nums):
"""
:type nums: List[int]
:rtype: List[int]
"""
if len(nums)<=1:
return []
else:
return list (set(range (1,len(nums)+1))- set(nums))2.给定一个长度为 n 的非空整数数组，找到让数组所有元素相等的最小移动次数。每次移动可以使 n - 1 个元素增加 1。
示例:
输入:
[1,2,3]
输出:
3
解释:
只需要3次移动（注意每次移动会增加两个元素的值）：
[1,2,3] => [2,3,3] => [3,4,3] => [4,4,4]class Solution(object):
def minMoves(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
'''n-1个数同时加一，就好比每次有一个数自身减一，所以数组最后的数只能是最小值。
这样的话每个元素减去最小值求其和就是答案。'''
sum = 0
minmum = min(nums)
for i in nums:
sum += i-minmum
return sum3.假设你是一位很棒的家长，想要给你的孩子们一些小饼干。
但是，每个孩子最多只能给一块饼干。对每个孩子 i ，都有一个胃口值 gi ，这是能让孩子们满足胃口的饼干的最小尺寸；并且每块饼干 j ，都有一个尺寸 sj 。如果 sj >= gi ，我们可以将这个饼干 j 分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，并输出这个最大数值。
注意：
你可以假设胃口值为正。
一个小朋友最多只能拥有一块饼干。
示例 1:
输入: [1,2,3], [1,1]
输出: 1
解释:
你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。
虽然你有两块小饼干，由于他们的尺寸都是1，你只能让胃口值是1的孩子满足。
所以你应该输出1。
示例 2:
输入: [1,2], [1,2,3]
输出: 2
解释:
你有两个孩子和三块小饼干，2个孩子的胃口值分别是1,2。
你拥有的饼干数量和尺寸都足以让所有孩子满足。
所以你应该输出2.class Solution(object):
def findContentChildren(self, g, s):
"""
:type g: List[int]
:type s: List[int]
:rtype: int
"""
if s==[] or g==[]:
return 0
s.sort()
g.sort()
count=0
i=0
j=0
while i <=len(g)-1 and j<=len(s)-1:
if g[i]<=s[j]:
count+=1
i+=1
j+=1
else:
j+=1
return count4.给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
示例 1:
输入: "abab" 输出: True 解释: 可由子字符串 "ab" 重复两次构成。
示例 2:
输入: "aba" 输出: False
示例 3:
输入: "abcabcabcabc" 输出: True 解释: 可由子字符串 "abc" 重复四次构成。 (或者子字符串 "abcabc" 重复两次构成。)
class Solution:
def repeatedSubstringPattern(self, s: str) -> bool:
for i in range(1,len(s)//2+1):
if s[:i] * (len(s)//i) == s:
return True
return False5.两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。
给出两个整数 x 和 y，计算它们之间的汉明距离。
注意：
0 ≤ x, y < 231.
示例:
输入: x = 1, y = 4
输出: 2
解释:
1 (0 0 0 1)
4 (0 1 0 0)
↑ ↑
上面的箭头指出了对应二进制位不同的位置。
class Solution:
def hammingDistance(self, x: int, y: int) -> int:
'''
1、异或运算符（两个操作数的位中，相同则结果为0，不同则结果为1）
2、转换成二进制
3、统计1的个数
'''
return bin(x ^ y).count('1')class Solution:
def hammingDistance(self, x: int, y: int) -> int:
count = 0
deffirence = x ^ y
while deffirence != 0:
count += deffirence % 2
deffirence = deffirence >> 1
return count6.给定一个包含 0 和 1 的二维网格地图，其中 1 表示陆地 0 表示水域。计算这个岛屿的周长
网格中的格子水平和垂直方向相连（对角线方向不相连）。整个网格被水完全包围，但其中恰好有一个岛屿（或者说，一个或多个表示陆地的格子相连组成的岛屿）。
岛屿中没有“湖”（“湖” 指水域在岛屿内部且不和岛屿周围的水相连）。格子是边长为 1 的正方形。网格为长方形，且宽度和高度均不超过 100 。计算这个岛屿的周长。
示例 :
输入: [[0,1,0,0], [1,1,1,0], [0,1,0,0], [1,1,0,0]] 输出: 16 解释: 它的周长是下面图片中的 16 个黄色的边：
方法一：
class Solution:
def islandPerimeter(self, grid: List[List[int]]) -> int:
count=0
for i in range(len(grid)):
for j in range(len(grid[i])):
if grid[i][j]==1:
if i==0:
count+=1
if len(grid)!=1 and grid[i+1][j]==0:
count+=1
if i==len(grid)-1:
count+=1
if len(grid)!=1 and grid[i-1][j]==0:
count+=1
if j==0:
count+=1
if len(grid[i])!=1 and grid[i][j+1]==0:
count+=1
if j==len(grid[i])-1:
count+=1
if len(grid[i])!=1 and grid[i][j-1]==0:
count+=1
if i >=1 and i<len(grid)-1:
if grid[i-1][j]==0:
count+=1
if grid[i+1][j]==0:
count+=1
if j >=1 and j<len(grid[i])-1:
if grid[i][j-1]==0:
count+=1
if grid[i][j+1]==0:
count+=1
return count
方法二：
class Solution(object):
def islandPerimeter(self, grid):
"""
:type grid: List[List[int]]
:rtype: int
"""
newls=[[0]*(len(grid[0])+2) for i in range(len(grid)+2)]
for i in range(len(grid)):
for j in range(len(grid[0])):
newls[i+1][j+1]=grid[i][j]
count=0
for i in range(1,len(newls)-1):
for j in range(1,len(newls[0])-1):
if newls[i][j]==1:
if newls[i-1][j]==0:
count+=1
if newls[i+1][j]==0:
count+=1
if newls[i][j-1]==0:
count+=1
if newls[i][j+1]==0:
count+=1
return count7.冬季已经来临。 你的任务是设计一个有固定加热半径的供暖器向所有房屋供暖。
现在，给出位于一条水平线上的房屋和供暖器的位置，找到可以覆盖所有房屋的最小加热半径。
所以，你的输入将会是房屋和供暖器的位置。你将输出供暖器的最小加热半径。
说明:
- 给出的房屋和供暖器的数目是非负数且不会超过 25000。
- 给出的房屋和供暖器的位置均是非负数且不会超过10^9。
- 只要房屋位于供暖器的半径内(包括在边缘上)，它就可以得到供暖。
- 所有供暖器都遵循你的半径标准，加热的半径也一样。
示例 1:
输入: [1,2,3],[2] 输出: 1 解释: 仅在位置2上有一个供暖器。如果我们将加热半径设为1，那么所有房屋就都能得到供暖。
示例 2:
输入: [1,2,3,4],[1,4] 输出: 1 解释: 在位置1, 4上有两个供暖器。我们需要将加热半径设为1，这样所有房屋就都能得到供暖。
方法一：暴力法，测试未通过
class Solution:
def findRadius(self, houses: List[int], heaters: List[int]) -> int:
res=[]
for i in houses:
res.append(min([abs(j-i) for j in heaters]))
return max(res)方法二：通过，但耗时
class Solution(object):
def findRadius(self, houses, heaters):
"""
:type houses: List[int]
:type heaters: List[int]
:rtype: int
"""
houses.sort()
heaters.sort()
j=0
res=0
for i in range(len(houses)):
while j<=len(heaters)-1-1 and abs(houses[i]-heaters[j])>=abs(houses[i]-heaters[j+1]):
j+=1
res=max(res,abs(houses[i]-heaters[j]))
return res
8.给定一个密钥字符串S，只包含字母，数字以及 '-'（破折号）。N 个 '-' 将字符串分成了 N+1 组。
给定一个数字 K，重新格式化字符串，除了第一个分组以外，每个分组要包含 K 个字符，第一个分组至少要包含 1 个字符。两个分组之间用 '-'（破折号）隔开，并且将所有的小写字母转换为大写字母。
给定非空字符串 S 和数字 K，按照上面描述的规则进行格式化。
示例 1：
输入：S = "5F3Z-2e-9-w", K = 4 输出："5F3Z-2E9W" 解释：字符串 S 被分成了两个部分，每部分 4 个字符； 注意，两个额外的破折号需要删掉。
示例 2：
输入：S = "2-5g-3-J", K = 2 输出："2-5G-3J" 解释：字符串 S 被分成了 3 个部分，按照前面的规则描述，第一部分的字符可以少于给定的数量，其余部分皆为 2 个字符。
class Solution:
def licenseKeyFormatting(self, S: str, K: int) -> str:
s = S.replace('-','').upper()[::-1]
res=''
for i in range(0,len(s),K):
res+=s[i:i+K]
res+='-'
res=res[:-1]
return res[::-1]9.给定一个二进制数组， 计算其中最大连续1的个数。
示例 1:
输入: [1,1,0,1,1,1] 输出: 3 解释: 开头的两位和最后的三位都是连续1，所以最大连续1的个数是 3.
class Solution:
def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
res=0
count=0
for i in nums:
if i==1:
count+=1
res=max(res,count)
else:
count=0
return res方法二：
class Solution(object):
def findMaxConsecutiveOnes(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
nums_str = ''.join([str(x) for x in nums])
res = max([len(x) for x in nums_str.split('0')])
return res
扫一扫
1994
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
