算法刷题（22年4月）

1、冒泡排序

"""
input：list=[2,1,4,3]
output：[1,2,3,4]
过程：
1、先对原list的第一个元素和第二个元素进行比较，然后小的在前，大的在后；
2、然后再比较第2个元素和第3个元素，仍然是小的在前，大的在后，这样经过第一次循环之后，原list最大的元素就处于最后了；
3、接着再循环，把原list第二大的元素置于倒数第2个元素中；
。。。
"""
def sort(list):
    for i in range(len(list)-1):
        for j in range(len(list)-1-i):
            if list[j+1]<list[j]:
				list[j],list[j+1]=list[j+1],list[j]
    return list

2、反转字符串的字母，其他符号位置不变

"""
examination：
input:s='hi_Welcome__to_____linkdoc!'
output:o_s='linkdoc!_to__Welcome_____hi'
考点：
1、split的灵活使用
2、列表的切片
3、replace方法的使用
4、.format的使用
"""
s='hi_Welcome__to_____linkdoc!'

s_deal=s.split("_")
list=[]
for item in s_deal:
    if item is not "":
        list.append(item)
o_list=list[::-1]
print(o_list)
for i in range(len(o_list)):
    o_s=s
    s=o_s.replace(list[i],f'{ {i} }')
    
print(s.format(*o_list))

3、求一列表中有多少个子集

思路：
input：list=[1,2,3,4]
1、因为空集[]也是list的子集，所以预先定义一个空集result=[[]]，
2、先遍历list，再嵌套遍历result，
想依次得到：
[]
[], [1]
[],[1],[2],[1,2]
所以是先遍历list的每一个值，然后再遍历result，用遍历的每一个的result的元素加上list的每一个值；

def getArraySubSet(originArray):
    result=[[]]
    for i in range(len(originArray)):
        for j in range(len(result)):
            result.append(result[j]+[originArray[i]])
    return result

originArray=[1,2,3,4]
getArraySubSet(originArray)

3.1 求一列表中的子集等于规定值的所有子集

def getArraySubSet(originArray,v):
    result=[[]]
    for i in range(len(originArray)):
        for j in range(len(result)):
            result.append(result[j]+[originArray[i]])
    res=[]
    for item in result:
        if sum(item)==v:
            res.append(item)
    return res
    
originArray=[1,2,3,4]
getArraySubSet(originArray,5)

4、三数求和，同时不能重复

input：list=[-4, -1, -1, 0, 1, 2]
求list中三数相加等于0的子集，同时不能有重复
output：[[-1, -1, 2], [-1, 0, 1]]

思路：

1、先对原list进行排序，然后判断list第一个数是否小于0，否则退出；
2、设置2层循环，先对list进行遍历，剩下两个数分别设置为后一个数L和倒数最后一个数R，判断三数相加是否为0，如果大于0，则最后一个数R前进1，重要的一点是判断R和R-1是否相等，如果相等则再前进1；如果小于0，则L后进1，也要判断L和L-1是否相等，如果相等则再后进1

def threeSum(nums):
    nums.sort()
    n = len(nums)
    res = []
    for i in range(n-2):
        if nums[i] > 0:break
        '''如果相邻的两个数相等，跳过,避免重复'''
        if i > 0 and nums[i] == nums[i-1]:
            continue 
        l, r = i+1, n-1
        while l < r:
            if nums[i] + nums[l] + nums[r]>0:
                r -= 1
                while l < r and nums[r-1] == nums[r]:
                    r -= 1
            elif nums[i] + nums[l] + nums[r]<0:
                l += 1
                while l < r and nums[l] == nums[l-1]:
                    l += 1    
            else:
                res.append([nums[i],nums[l],nums[r]])
                l += 1
                r -= 1
                while l < r and nums[l] == nums[l - 1]: l += 1
                while l < r and nums[r] == nums[r + 1]: r -= 1
    return res
        

if __name__ == '__main__':
    nums = [-1,0,1,2,-1,-4]
    print(threeSum(nums))
    

参考链接

5、使用梯度下降法求一元多次方程

这是一道面试真题，主要考察对梯度下降的理解、以及梯度下降与loss的关系

原题如下：
Define a function to solve the equation below. Using gradient descent method.
y = 4x^3 + 5x^2 +1; when y is 10, 20, 30. what is x?
思路：
即是求 y = 4x^3 + 5x^2 +1与10、20、30的之间的loss，
loss=4x^3 + 5x^2 +1-10，优化参数x使loss等于0，
所以再求loss的导数，规定初始值x，设定学习率即可；

def grad_find_x(y,lr):
    x=5
    for i in range(10):
        grad_y=2*(4*x**3+5*x**2+1-y)*(12*x**2+10*x)
        x=x-lr*grad_y
    return x

参考链接