字节手撕代码准备

求一个数组的所有子集

"""
初始状态：
[]
1:
[],[1]
2:在前一个基础上每个项加上2
[],[1],[2],[1,2]
3：在前一个基础上每个项加上3
[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]
"""
alist = [1, 2, 3]
result = []
result.append([])
for i in alist:
    new = []
    for j in result:
        temp = j.copy()
        temp.append(i)
        new.append(temp)
    result.extend(new)
    
print(result)

买卖股票的最佳时机

暴力求解：遍历嵌套

alist = [7,1,5,3,6,4]
i = 0
max_ans = 0
for i in range(len(alist)-1):
    out = max(alist[i+1:])
    if max_ans < out-alist[i]:
        max_ans = out-alist[i]
print(max_ans)

一次遍历

alist = [7,1,5,3,6,4]

min_price = max(alist)# min_price = alist[0]
max_profit = 0

for each in alist: # 一次遍历
    # 如果该数较最小，就作为被减数，负责就判断是否作为减数
    if each < min_price:
        min_price = each 
    else:
        if each - min_price > max_profit:
            max_profit = each - min_price
print(max_profit)

跳跃游戏

思路：尽可能到达最远位置（贪心）。
如果能到达某个位置，那一定能到达它前面的所有位置。

方法：初始化最远位置为 0，然后遍历数组，如果当前位置能到达，并且当前位置+跳数>最远位置，就更新最远位置。最后比较最远位置和数组长度。

复杂度：时间复杂度 O(n)，空间复杂度 O(1)。

alist = [3,3,1,0,1,2,0,1,0,4,2,1]
max_position = 0
for i in range(len(alist)):
    temp = i + alist[i]
    if temp > max_position and max_position>= i:
    # 最远位置且一定要能到达当前位置
        max_position = temp
if max_position+1 >= len(alist):
    print(True)
else:
    print(False)

发红包

让你设计一个微信发红包的api，你会怎么设计，不能有人领到的红包里面没钱，红包数值精确到分。
假设一共有 N 元，一共有 K 个人，则可以每个人拿到的钱为 random(N - (K - 1) * 0.01)，然后更新N，直到最后一个人就直接 N。

import random
import numpy as np

money = int(input())
person_num = int(input())

ans = []
for i in range(person_num - 1):
    given = random.uniform(0,money)
    given = np.round(given,2)
    # #用于生成一个指定范围内的随机符点数
    
    money = np.round(money,2) - np.round(given,2)
    #money = np.round(money)
    ans.append(given)
##    print(i)
##    print(given)
##    print(money)
ans.append(money)

ans2 = [str(i) for i in ans]
ans3 = ' '.join(ans2)
print(ans3)
print(sum(ans))

代码不太对，每个人得到钱的概率不同，会出现分到0元的情况

山脉数组的峰顶索引

alist = [3,4,5,1]
for i in range(1,len(alist)):
    if alist[i] > alist[i-1] and alist[i] > alist[i+1]:
        index = i
        break

print(index)

两个数组的交集

## 两个list的交集用hashmap
a = [1,2,3,4,5]
b = [3,4,5,6,7]
hashmap = {}
for each in a:
    hashmap[each] = 1
for each in b:
    if each in hashmap.keys():
        hashmap[each] = 2
ans = []
for each in hashmap.items():
    if each[1] == 2:
        ans.append(each[0])
print(ans)

两个栈实现一个队列

维护两个栈，第一个栈支持插入操作，第二个栈支持删除操作。

根据栈先进后出的特性，我们每次往第一个栈里插入元素后，第一个栈的底部元素是最后插入的元素，第一个栈的顶部元素是下一个待删除的元素。为了维护队列先进先出的特性，我们引入第二个栈，用第二个栈维护待删除的元素，在执行删除操作的时候我们首先看下第二个栈是否为空。如果为空，我们将第一个栈里的元素一个个弹出插入到第二个栈里，这样第二个栈里元素的顺序就是待删除的元素的顺序，要执行删除操作的时候我们直接弹出第二个栈的元素返回即可。

思路：思路链接
leetcode解法

“”“
实现：就以列表作为栈的底层实现，只要保证后进先出的约束就是栈。
这里只实现入队和出队两个操作。
“”“
class TwoStackOneQueue(object):
    def __init__(self):
        self.stack1 = []
        self.stack2 = []
 
    def push(self,item):
        self.stack1.append(item)
    def pop(self):
        if self.stack2:
            return self.stack2.pop()
        else:
            if self.stack1:
                while self.stack1:
                    self.stack2.append(self.stack1.pop())
                return self.stack2.pop()
            else:
                return None
a = TwoStackOneQueue()
a.push(1)
a.push(2)
a.push(3)
a.push(4)
print(a.pop())
a.push(5)
print(a.pop())
print(a.pop())

自己写的

# 两个栈实现队列
      
class Stack():
    def __init__(self):
        self.list = [] 
        
    def is_empty(self):
        return self.list == []
        
    def push(self, item):
        self.list.append(item)
        return self.list
    
    def pop(self):
        #self.list.pop()
        # self.__list.pop(0)
        return self.list.pop()

class Queue(Stack):
    def __init__(self):
        super().__init__()
        self.A = Stack()
        self.B = Stack()

    def enqueue(self, item):
        print(self.A.push(item))
        return self.A

    def dequeue(self):
        if self.B.is_empty():
            while self.A.is_empty() is False:
                self.B.push(self.A.pop())
            print(self.B.pop())
            return self.B
        else:
            print(self.B.pop())
            return self.B

queue = Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
queue.dequeue()
queue.enqueue(4)
queue.dequeue()
queue.dequeue()
queue.dequeue()

两个队列实现栈

二叉树的中序遍历（栈）

解题思路

"""
中序序列就是出栈顺序
"""
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
一直访问左节点，访问到最后一个左节点，当先值设置当前节点的右节点
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack = []
        cur = root
        res = []
        while cur or stack:
            while cur:
                stack.append(cur)
                cur = cur.left
            # 循环结束时cur是叶节点后的空节点
            cur = stack.pop()
            res.append(cur.val)
            cur = cur.right
        return res

二叉树的先序遍历（栈）

"""
先序序列就是入栈顺序
"""
# Definition for a binary tree node.
# class TreeNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
一直访问左节点，访问到最后一个左节点，当先值设置当前节点的右节点
class Solution(object):
    def inorderTraversal(self, root):
        """
        :type root: TreeNode
        :rtype: List[int]
        """
        stack = []
        cur = root
        res = []
        while cur or stack:
            while cur:
                stack.append(cur)
                res.append(cur.val)
                cur = cur.left
            # 循环结束时cur是叶节点后的空节点
            cur = stack.pop()
            cur = cur.right
        return res

二叉树的后序遍历(栈)

青蛙跳台阶

我们来分析一下：

当n等于1的时候，只需要跳一次即可，只有一种跳法，记f(1)=1

当n等于2的时候，可以先跳一级再跳一级，或者直接跳二级，共有2种跳法，记f(2)=2

当n等于3的时候，他可以从一级台阶上跳两步上来，也可以从二级台阶上跳一步上来，所以总共有f(3)=f(2)+f(1)；

同理当等于n的时候，总共有f(n)=f(n-1)+f(n-2)(这里n>2)种跳法。

递归 超时

def fabi(n):
    if n==0:
        return 1
    elif n==1:
        return 1
    elif n==2:
        return 2
    elif n>=3:
        return fabi(n-1)+fabi(n-2)
print(fabi(37))

非递归

n=37
alist = [1,1,2]
if n<=2:
    print(alist[n])
else:
    for i in range(3,n+1):
        alist.append(alist[i-1]+alist[i-2])
    print(alist[-1]%1000000007)