坚持刷题的第三周，Python音频面试题

最新推荐文章于 2024-09-27 10:11:28 发布

前端收割机

最新推荐文章于 2024-09-27 10:11:28 发布

阅读量748

点赞数 14

分类专栏： 2024年程序员学习文章标签： python 音视频开发语言

本文链接：https://blog.csdn.net/m0_60452141/article/details/137980320

版权

2024年程序员学习专栏收录该内容

330 篇文章 2 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Python全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Python知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024c （备注Python）

正文

示例 1：

输入：s = “abcdefg”, k = 2

输出：“bacdfeg”

示例 2：

输入：s = “abcd”, k = 2

输出：“bacd”

提示：

1 <= s.length <= 104

s 仅由小写英文组成

1 <= k <= 104

4.有效字母的异位

5.验证回文串

题解

–

1.左转字符串||

我们可以直到字符串其实也是一种数组的形式，我们呢可以用字符串的直接切片来写这个题，所以我对昨天的代码进行了一个简单的优化，昨天好像是超越20多，今天是超越了80，内存也提高了很多！！！

接下来我们可以直接看代码！！！

2.数组形式的整数加法

本题最简单最方便的方法就是直接把数组里面的数给转化为整数，然后在相加k，再把相加后的结果给放到数组中，这样就直接返回接过来，但是这个效率是十分低的。

第二种方法就是使用模拟法，我们先把k转化为数组然后对位相加，相加后

这个也是字符串相乘的一个基础解题法！！！

3.反转字符串 II

本题在python中我觉得有一个很方便的一个办法，就是range中的第三个参数，每次循环多少个步长，本题可知每次走2k个步长就可以直接使用这个range的步长参数，走2k让前k个数反转。

4.有效字母的异位

这题我有点投机取巧，用了python中的count这个函数，我建议大家还是很少用就少用，自己去写一个计数方法。

5.验证回文串

这个就是一个简单的双指针，我就不多解释了，直接上代码！！

代码

–

1.左转字符串||

class Solution:

def reverseLeftWords(self, s: str, n: int) -> str:

string = s[n:]+s[:n]

return string

#本代码在python实现是非常简单的

2.数组形式的整数加法

class Solution:

def addToArrayForm(self, num: List[int], k: int) -> List[int]:

res = 0

for i in range(len(num)):

res = res+(10**i)*num[len(num)-i-1]

return [int(i) for i in str(res+k)]

3.反转字符串 II

class Solution:

def reverseStr(self, s: str, k: int) -> str:

ss = [i for i in s]

n=len(s)

for i in range(0,n,2*k):

ss[i:i+k]=ss[i:i+k][::-1]

return “”.join(ss)

4.有效字母的异位

class Solution(object):

def isAnagram(self, s, t):

“”"

:type s: str

:type t: str

:rtype: bool

“”"

dic1={c:s.count© for c in set(s)}

dic2={d:t.count(d) for d in set(t)}

if dic1==dic2:

return True

else:return False

5.验证回文串

class Solution(object):

def isPalindrome(self, s):

“”"

:type s: str

:rtype: bool

“”"

if 1<=len(s) <=2*10**5:

c = ‘’

for i in s:

if i.isalpha():

c += i.lower()

elif i.isalnum():

c += i

n = len©//2

for i in range(n):

if c[i] != c[len©-i-1]:

return False

else:

return True

总结

–

欠着！！！！

2021-10-28

==========

题目

–

1.2的幂

给你一个整数 n，请你判断该整数是否是 2 的幂次方。如果是，返回 true ；否则，返回 false 。

如果存在一个整数 x 使得 n == 2x ，则认为 n 是 2 的幂次方。

示例 1：

输入：n = 1

输出：true

解释：20 = 1

示例 2：

输入：n = 16

输出：true

解释：24 = 16

示例 3：

输入：n = 3

输出：false

示例 4：

输入：n = 4

输出：true

示例 5：

输入：n = 5

输出：false

提示：

-231 <= n <= 231 - 1

2.全排列

给定一个不含重复数字的数组 nums ，返回其所有可能的全排列。你可以按任意顺序返回答案。

示例 1：

输入：nums = [1,2,3]

输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

示例 2：

输入：nums = [0,1]

输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]

输出：[[1]]

提示：

1 <= nums.length <= 6

-10 <= nums[i] <= 10

nums 中的所有整数互不相同

3.全排列||

给定一个可包含重复数字的序列 nums ，按任意顺序返回所有不重复的全排列。

示例 1：

输入：nums = [1,1,2]

输出：

[[1,1,2],

[1,2,1],

[2,1,1]]

示例 2：

输入：nums = [1,2,3]

输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

4.组合两个表

5.重新排序得到 2 的幂

给定正整数 N ，我们按任何顺序（包括原始顺序）将数字重新排序，注意其前导数字不能为零。

如果我们可以通过上述方式得到 2 的幂，返回 true；否则，返回 false。

示例 1：

输入：1

输出：true

示例 2：

输入：10

输出：false

示例 3：

输入：16

输出：true

示例 4：

输入：24

输出：false

示例 5：

输入：46

输出：true

题解

–

1.2的幂

这个题我们直接可以用与运算来写出如果n&（n-1）==0返回true就证明这是是2的幂数，明天我可能就会更新一些运算符的使用，有一些运算符在写踢的时候是很方便的，还要注意一点这个是要大于0的！

2.全排列

本题就是一个简单的回溯加剪枝，我们在回溯的条件上添加一个剪枝，判断每一个排序中是否已经有了该元素，如果有了就直接跳过此次循环，每次回溯的终止条件就是子元素的长度是否等于给定的长度，我们来借鉴一下官方的图：

看图是能比较好理解的，如果大家懂了这个图的原理，还有回溯的原理就可以直接下手本题了！！

3.全排列||

本题是上一题的一个进阶问题，本题多出了两个条件，给的数组里面的元素是可以重复的，但是排序的结果是不能重复的。

我们还是用回溯加剪枝，我们还需要把每个重复的元素给经行一个标记，我们可以创建一个新的全为0等长的列表，然后判断如果有重复的，则对应新列表重复的下标转化为1，在回溯的时候判断，如果新列表的哪个下标为1就直接跳过此次循环，这样就去重了一些，然后回溯在进行排序。

4.组合两个表

本题考的就是两个表的如何合并，在MySQL中我们可以先用outer join合并这两个表，然后在在合并的表中进行查询，这个是一个基本的思路，我最后测试了一下效率不是很高但是没有什么问题。

5.重新排序得到 2 的幂

本题是今天的每日一题，本题有一种解法就是用回溯加对2幂数经行判断，我最开始写的几道题就是为这个题做铺垫，但是呢我并没有用那种方法去写嘿嘿嘿嘿，我看到了一个新的思路。就是我们可以把2的31个幂数列举出来，然后在给这些幂函数转化为二进制的数，并放在列表中，我们也把目标数转化为二进制数放在列表中，然后经行a和b两个数组进行对比如果相等就返回true，反之返回false。

6.买股票的最佳时机

代码

–

1.2的幂

class Solution:

def isPowerOfTwo(self, n: int) -> bool:

return n>0 and n&(n-1)== 0

2.全排列

class Solution:

def permute(self, nums: List[int]) -> List[List[int]]:

res = []

def trace (nums,path):

if len(path) == len(nums):

res.append(list(path))

return

for i in nums:

if i in path:

continue

path.append(i)

trace(nums,path)

path.pop()

trace(nums,[])

return res

3.全排列||

class Solution:

def permuteUnique(self, nums: List[int]) -> List[List[int]]:

nums.sort()

res = []

check =[0 for i in range(len(nums))]

def trace (nums,path,check):

if len(path) == len(nums):

res.append(list(path))

return

for i in range(len(nums)):

if check[i] == 1:

continue

if i>0 and nums[i]==nums[i-1] and check[i-1] ==0:

continue

check[i]=1

trace(nums,path+[nums[i]],

check)

check[i]=0

trace(nums,[],check)

return res

class Solution1:

def permuteUnique(self, nums: List[int]) -> List[List[int]]:

nums.sort()

res = []

check = [0 for i in range(len(nums))]

def backtrack(sol, nums, check):

if len(sol) == len(nums):

res.append(list(sol))

return

for i in range(len(nums)):

if check[i] == 1:

continue

if i > 0 and nums[i] == nums[i-1] and check[i-1] == 0:

continue

check[i] = 1

backtrack(sol+[nums[i]], nums, check)

check[i] = 0

backtrack([], nums, check)

return res

4.组合两个表

select FirstName, LastName, City, State

from Person left join Address

on Person.PersonId = Address.PersonId

;

5.重新排序得到 2 的幂

class Solution:

def reorderedPowerOf2(self, n: int) -> bool:

def check(targ: int, num: int) -> bool:

a = [0 for _ in range(10)]

b = [0 for _ in range(10)]

while targ:

x = targ % 10

a[x] += 1

targ //= 10

while num:

x = num % 10

b[x] += 1

num //= 10

return a == b

for i in range(31):

targ = 2 ** i

if check(targ, n) == True:

return True

return False

6.买卖股票的最佳时机

class Solution:

def maxProfit(self, prices: List[int]) -> int:

n = len(prices)

if n == 0: return 0 # 边界条件

dp = [0] * n

minprice = prices[0]

for i in range(1, n):

minprice = min(minprice, prices[i])

dp[i] = max(dp[i - 1], prices[i] - minprice)

return dp[-1]

总结

2021-10-29

==========

路径交叉

给你一个整数数组 distance 。

从 X-Y 平面上的点 (0,0) 开始，先向北移动 distance[0] 米，然后向西移动 distance[1] 米，向南移动 distance[2] 米，向东移动 distance[3] 米，持续移动。也就是说，每次移动后你的方位会发生逆时针变化。

判断你所经过的路径是否相交。如果相交，返回 true ；否则，返回 false 。

题解

–

本题看似是一个hard的一个难度，但是如果我们弄懂了它的原理这个就是一个esay的题，本题难就难在这个题他是比较偏向数学分类较多一些，它分为好几种情况相交，我把这些相交的情况都给写在本子上了，大家可以看看！！！

草稿：

我上面如果画的不清楚大家也可以去看看官方的图，其实原理都是一样的！！！

代码

–

class Solution:

def isSelfCrossing(self, distance: List[int]) -> bool:

n = len(distance)

for i in range(3, n):

if (distance[i - 1] <= distance[i - 3]

and distance[i] >= distance[i - 2]):

return True

if (i >= 4 and distance[i - 1] == distance[i - 3]

and distance[i - 2] <= distance[i] + distance[i - 4]):

return True

if (i >= 5 and distance[i - 2] >= distance[i - 4]

and distance[i] >= distance[i - 2] - distance[i - 4]

and distance[i - 3] >= distance[i - 5]

and distance[i - 3] >= distance[i - 1]

and distance[i - 3] <= distance[i - 5] + distance[i - 1]):

return True

return False

括号生成

数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且有效的括号组合。

有效括号组合需满足：左括号必须以正确的顺序闭合。

示例 1：

输入：n = 3

输出：[“((()))”,“(()())”,“(())()”,“()(())”,“()()()”]

示例 2：

输入：n = 1

输出：[“()”]

题解

–

本题就是变了一个样子的回溯题，本题有几个剪枝的条件，第一：左括号剩的数要大于右括号。第二：左右括号都为0的时候才能结束。

然后我们对这个进行回溯剪枝，并把每一次生成的序列放在列表中，回溯结束则返回列表！

本题主要就是掌握回溯，如果回溯没有掌握好的话，大家可以去csdn上面找一些大佬们的介绍！

代码

–

class Solution:

def generateParenthesis(self, n: int) -> List[str]:

res =“”

chect =[]

def trace(res,r,z,n):

if r == n and z == n:

chect.append(res)

return

if z < r:

return

if z < n:

trace(res+“(”,r,z+1,n)

if r<n:

trace(res+“)”,r+1,z,n)

trace(res,0,0,n)

return chect

组合

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按任何顺序返回答案。

示例 1：

输入：n = 4, k = 2

输出：

[

[2,4],

[3,4],

[2,3],

[1,2],

[1,3],

[1,4],

]

示例 2：

输入：n = 1, k = 1

输出：[[1]]

提示：

1 <= n <= 20

1 <= k <= n

题解

–

本题也是非常经典的一个题，我最开始是把1到n所有的数给转化为列表然后在回溯，然后我就给他写在本子上了

然后我发现我这个有点复杂了，所以我看了一些大佬们的题解，我觉得他们的是真简单然后我就采用他们的方式来写的，

代码

–

class Solution:

def combine(self, n: int, k: int) -> List[List[int]]:

res = []

def bracktrace(path,i):

if len(path) == k:

res.append(path)

return

for j in range(i,n+1) :

bracktrace(path+[j],j+1)

bracktrace([],1)

return res

字符串转换整数 (atoi)

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。

函数 myAtoi(string s) 的算法如下：

读入字符串并丢弃无用的前导空格

检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。确定最终结果是负数还是正数。如果两者都不存在，则假定结果为正。

读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。

将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。

如果整数数超过 32 位有符号整数范围 [−231, 231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。

返回整数作为最终结果。

注意：

本题中的空白字符只包括空格字符 ’ ’ 。

除前导空格或数字后的其余字符串外，请勿忽略任何其他字符。

这个有很多方法，这个看起来很复杂，其实很简单，最麻烦的是你判断范围时候，你的代码会很多，不注意一些变量的使用导致错误。

我是用的re，也是有点取巧的成分。

class Solution(object):

def myAtoi(self, s):

“”"

:type s: str

:rtype: int

“”"

import re

pattern = r"[\s]*[±]?[\d]+"

match = re.match(pattern, s)

if match:

res = int(match.group(0))

if res > 2 ** 31 - 1:

res = 2 ** 31 -1

if res < - 2 ** 31:

res = - 2 ** 31

else:

res = 0

return res

实现strStr（）

这个题我开始没有理解题意然后一直卡着，我就看了下面大佬们的解题思路，而且也学到了新的一种方法————滑块。这个方法做这个题是十分简单的，可能以后写项目的也会用这个办法，反正学到就是赚到，嘿嘿。话不多说，直接上代码。

class Solution(object):

def strStr(self, haystack, needle):

“”"

:type haystack: str

:type needle: str

:rtype: int

“”"

if needle == ‘’ or haystack == 0:

return 0

if len(haystack)>=len(needle):

right = len(haystack)

i = 0

n = len(needle)

while i<right:

if haystack[i:n] == needle:

return i

n += 1

i += 1

else:

return -1

2021-10-30

==========

只出现一次的数字 III

给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。找出只出现一次的那两个元素。你可以按任意顺序返回答案。

进阶：你的算法应该具有线性时间复杂度。你能否仅使用常数空间复杂度来实现？

示例 1：

输入：nums = [1,2,1,3,2,5]

输出：[3,5]

解释：[5, 3] 也是有效的答案。

示例 2：

输入：nums = [-1,0]

输出：[-1,0]

示例 3：

输入：nums = [0,1]

输出：[1,0]

提示：

2 <= nums.length <= 3 * 104

-231 <= nums[i] <= 231 - 1

除两个只出现一次的整数外，nums 中的其他数字都出现两次

题解

–

本题就是用一个哈希表来简单的使用，把每个不同的元素都放在哈希表中，然后直接使用一个循环，循环nums数组里面的元素，如果多余的话直接加一就可以，最后返回等于的元素就是我们想要的元素。

代码

–

class Solution:

def singleNumber(self, nums: List[int]) -> List[int]:

dit = {}

res =[]

for i in set(nums):

dit[i] = 0

for i in nums:

dit[i]+=1

for i in dit:

if dit[i] == 1:

res.append(i)

return res

增量元素之间的最大差值

给你一个下标从 0 开始的整数数组 nums ，该数组的大小为 n ，请你计算 nums[j] - nums[i] 能求得的最大差值，其中 0 <= i < j < n 且 nums[i] < nums[j] 。

返回最大差值。如果不存在满足要求的 i 和 j ，返回 -1 。

示例 1：

输入：nums = [7,1,5,4]

输出：4

解释：

最大差值出现在 i = 1 且 j = 2 时，nums[j] - nums[i] = 5 - 1 = 4 。

注意，尽管 i = 1 且 j = 0 时，nums[j] - nums[i] = 7 - 1 = 6 > 4 ，但 i > j 不满足题面要求，所以 6 不是有效的答案。

示例 2：

输入：nums = [9,4,3,2]

输出：-1

解释：

不存在同时满足 i < j 和 nums[i] < nums[j] 这两个条件的 i, j 组合。

示例 3：

输入：nums = [1,5,2,10]

输出：9

解释：

最大差值出现在 i = 0 且 j = 3 时，nums[j] - nums[i] = 10 - 1 = 9 。

题解

–

本题最核心的就是i<j所以这个是一个顺序比较，我们可以直接使用不同的位数相减然后返回max这样就可以直接找出最大值，本题是力扣和字节的一个周赛题，大家也可以来试一试！！！

代码

–

class Solution:

def maximumDifference(self, nums: List[int]) -> int:

ans = -1

for i in range(1, len(nums)):

ans = max(ans, nums[i] -min(nums[0:i]))

return ans if ans > 0 else -1

网格游戏

给你一个下标从 0 开始的二维数组 grid ，数组大小为 2 x n ，其中 grid[r][c] 表示矩阵中 (r, c) 位置上的点数。现在有两个机器人正在矩阵上参与一场游戏。

两个机器人初始位置都是 (0, 0) ，目标位置是 (1, n-1) 。每个机器人只会向右 ((r, c) 到 (r, c + 1)) 或向下 ((r, c) 到 (r + 1, c)) 。

游戏开始，第一个机器人从 (0, 0) 移动到 (1, n-1) ，并收集路径上单元格的全部点数。对于路径上所有单元格 (r, c) ，途经后 grid[r][c] 会重置为 0 。然后，第二个机器人从 (0, 0) 移动到 (1, n-1) ，同样收集路径上单元的全部点数。注意，它们的路径可能会存在相交的部分。

第一个机器人想要打击竞争对手，使第二个机器人收集到的点数最小化。与此相对，第二个机器人想要最大化自己收集到的点数。两个机器人都发挥出自己的最佳水平的前提下，返回第二个机器人收集到的点数。

示例 1：

输入：grid = [[2,5,4],[1,5,1]]

输出：4

解释：第一个机器人的最佳路径如红色所示，第二个机器人的最佳路径如蓝色所示。

第一个机器人访问过的单元格将会重置为 0 。

第二个机器人将会收集到 0 + 0 + 4 + 0 = 4 个点。

示例 2：

输入：grid = [[3,3,1],[8,5,2]]

输出：4

解释：第一个机器人的最佳路径如红色所示，第二个机器人的最佳路径如蓝色所示。

第一个机器人访问过的单元格将会重置为 0 。

第二个机器人将会收集到 0 + 3 + 1 + 0 = 4 个点。

示例 3：

输入：grid = [[1,3,1,15],[1,3,3,1]]

输出：7

解释：第一个机器人的最佳路径如红色所示，第二个机器人的最佳路径如蓝色所示。

第一个机器人访问过的单元格将会重置为 0 。

第二个机器人将会收集到 0 + 1 + 3 + 3 + 0 = 7 个点。

提示：

grid.length == 2

n == grid[r].length

1 <= n <= 5 * 104

1 <= grid[r][c] <= 105

题解

–

本题建议参考官方题解，我这个我也是半懂半不懂得。

代码

–

class Solution:

def gridGame(self, grid: List[List[int]]) -> int:

pre,suf = [0],[0]

n = len(grid[0])

for i in range(n):

pre.append(pre[-1] + grid[1][i])

for i in range(n - 1,-1,-1):

suf.append(suf[-1] + grid[0][i])

suf.reverse()

ans = float(‘inf’)

for i in range(n):

#左侧剩余分数

lleft = pre[i]

右侧剩余分数

rleft = suf[i + 1]

ans = min(ans,max(lleft,rleft))

return ans

题目

–

题解

–

代码

–

题目

–

题解

–

代码

–

2021-10-31

==========

最长递增子序列

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

示例 1：

输入：nums = [10,9,2,5,3,7,101,18]

输出：4

解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。

示例 2：

输入：nums = [0,1,0,3,2,3]

输出：4

示例 3：

输入：nums = [7,7,7,7,7,7,7]

输出：1

题解

–

因为今天学了基础的dp所以我就拿这个最经典的题来练练手，我们直接开始这个题解正题吧。

本题可以有很多种解法，贪心加二分，dp等，我是用的dp，我们可以先写一个递归，终止条件就是循环达到最后一个元素就返回，在递归里面判断是否有后面的数大于前面的数，有的话就直接加一，然后返回最大的那个长度。

本题还有数学归纳法，我直接把两种算法代码发在下面。

代码

–

1.dp

最后

Python崛起并且风靡，因为优点多、应用领域广、被大牛们认可。学习 Python 门槛很低，但它的晋级路线很多，通过它你能进入机器学习、数据挖掘、大数据，CS等更加高级的领域。Python可以做网络应用，可以做科学计算，数据分析，可以做网络爬虫，可以做机器学习、自然语言处理、可以写游戏、可以做桌面应用…Python可以做的很多，你需要学好基础，再选择明确的方向。这里给大家分享一份全套的 Python 学习资料，给那些想学习 Python 的小伙伴们一点帮助！