字节测开手撕代码

1. 编写一个函数，以字符串作为输入，反转该字符串中的元音字母。（leetcode 345）

s= 'leetcode'
s = list(s)
yuanyin = ['a','e','i','o','u']
j = 0
index = []
for i in range(len(s)):
    if s[i] in yuanyin:
        index.append(i)
#print(index)
n = len(index) - 1
while j <= n//2:
    s[index[j]],s[index[-1-j]] = s[index[-1-j]],s[index[j]]
    j = j+1
print(''.join(s))

输出

leotcede

2. 跳跃游戏 II 解题报告（leetcode 45）

找到自己当前能到达的几个位置中，跳到哪个位置，下一步能跳得最远，然后我们当前就跳到那个位置上，给下一步跳跃留下最好得结果
cur表示当前能到达得最远位置，pre表示上一次能到达的最远的位置

class Solution(object):
	def jump(self,nums):
		reach = 0
		cur = 0
		N = len(nums)
		count = 0
		pos = 0
		while cur <N-1:
			count += 1
			pre = cur
			while pos <= pre:
			cur = max(cur,pos+nums[pos])
			pos += 1
		return count 

3. 合并区间

给出一个区间的集合，清合并所有重叠的区间
输入：[[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间[1,3]和[2,6]重叠，将它们合并为[1,6]

class Solution(object):
	def merge(self,intervals):
		intervals = list(sorted(intervals))
		low = intervals[0][0]
		high = intervals[0][1]
		for i in range(1,len(intervals)):
			if high >=intervals[i][0]:
				if high < intervals[i][1]
				high = intervals[i][1]
			else:
				res.append([low,high])
				low = intervals[i][0]
				high = intervals[i][1]
		res.append([low,high])
		return res						

4.单词搜索（leetcode 79）

board =
[
[‘A’,‘B’,‘C’,‘E’],
[‘S’,‘F’,‘C’,‘S’],
[‘A’,‘D’,‘E’,‘E’]
]
给定 word = “ABCCED”, 返回 true
给定 word = “SEE”, 返回 true
给定 word = “ABCB”, 返回 false

class Solution:
	direction = [(1,0),(0,-1),(-1,0),(0,1)]
	def exist(self,board,word)
		if len(board) == 0:
			return False
		rows = len(board)
		cols = len(board[0])
		marked = [[False for _ in range(cols)] for _ in range(rows)]
		for row in range(rows):
			for col in range(cols):
			if self._search(row,col,board,word,0,marked):
				return True
		return False
	def _search(self,i,j,board,word,index,marked):
		if index == len(word)-1:
		return board[i][j] == word[index]
		if board[i][j] =True:
		

5.输入一个整数，输出所有连续的可组成这个整数的序列

s = 15
for i in range(1,i//2+1):
	sum1 = i
	for j in range(i+1,s//2+2):
		sum1 =sum1+j
		if sum1 == s:
			a = list(range(i:j+1))
			print(a)

6. 字符串括号匹配个数（栈，动态规划）

状态定义：dp[i][j]表示s[i]到s[j]的最少添加的括号数
初始化：单独一个字符，dp[i][j]=1，因为一个字符必定要添加一个括号
状态转移方程：循环遍历区间长度（区间长度m从1到n），每次考虑[i,j]内的区间（i从0开始，j=i+m）
如果s[i]和s[j]匹配，那么dp[i][j] = dp[i+1][j-1]，即括号里面部分需要添加二等最少括号
如果对区间[i,j]内的区间进行遍历分割，如果有更小的值，就采用更小的值，即dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j])

def match (a,b):
    if a == '[' and b == ']':
    	return True
    if a == '(' and b == ')':
    	return True
    return False
def kuohao(s):
    n = len(s)
    dp =[[0]*n for _ in range(n)]
    for i in range(n):
    	dp[i][i] = 1
    for m in range(1,n+1):
    	for i in range(n-m):
    	    j = i + m
    	    dp[i][j] = float('inf')
    	    if match(s[i],s[j]):
    	        dp[i][j] = dp[i+1][j-1]
    	    for k in range(i,j):
    	        dp[i][j] = min(dp[i][j],dp[i][k]+dp[k+1][j])
    return dp[0][n-1]