Robinhood

您好！
本帖隐藏的内容需要积分高于 100 才可浏览
您当前积分为 0。
使用VIP即刻解锁阅读权限或查看其他获取积分的方式

游客，您好！
本帖隐藏的内容需要积分高于 100 才可浏览
您当前积分为 0。
VIP即刻解锁阅读权限 或 查看其他获取积分的方式
Unlock interview details and practice with AI
Curated Interview Questions from Top Companies

您好！
本帖隐藏的内容需要积分高于 100 才可浏览
您当前积分为 0。
使用VIP即刻解锁阅读权限或查看其他获取积分的方式

游客，您好！
本帖隐藏的内容需要积分高于 100 才可浏览
您当前积分为 0。
VIP即刻解锁阅读权限 或 查看其他获取积分的方式
Unlock interview details and practice with AI
Curated Interview Questions from Top Companies

robinhood ? 是那个股票软件么？

请问楼主这个是电面啊

请问楼主这个是电面吗？

可以解释下题意吗？

请问能解释下这个题意吗？
只比较a[i] 和 a[i-1] 吗 还是怎么得？

1. # coding: utf-8
   
2. """
   
3. [url]https://www.codenong.com/cs106206059/[/url]
   
4. 
   
5. Given a stream of incoming "buy" and "sell" orders (as lists of limit price,
   
6. quantity, and side, like ["155", "3", "buy"]),
   
7. determine the total quantity (or number of "shares") executed.
   
8. 
   
9. A "buy" order can be executed if there is a corresponding "sell" order with a
   
10. price that is less than or equal to the price of the "buy" order.
    
11. Similarly, a "sell" order can be executed if there is a corresponding
    
12. "buy" order with a price that is greater than or equal to the price of
    
13. the "sell" order. It is possible that an order does not execute
    
14. immediately if it isn't paired to a counterparty. In that case,
    
15. you should keep track of that order and execute it at a later
    
16. time when a pairing order is found. You should ensure that
    
17. orders are filled immediately at the best possible price.
    
18. That is, an order should be executed when it is processed,
    
19. if possible. Further, "buy" orders should execute at the
    
20. lowest possible price and "sell" orders at the highest possible
    
21. price at the time the order is handled.
    
22. 
    
23. Note that orders can be partially executed.
    
24. 
    
25. 
    
26. 
    
27. --- Sample Input ---
    
28. 
    
29. orders = [
    
30. ['150', '5', 'buy'], # Order A
    
31. ['190', '1', 'sell'], # Order B
    
32. ['200', '1', 'sell'], # Order C
    
33. ['100', '9', 'buy'], # Order D
    
34. ['140', '8', 'sell'], # Order E
    
35. ['210', '4', 'buy'], # Order F
    
36. ]
    
37. 
    
38. Sample Output
    
39. 9
    
40. 
    
41. 思路：这题老实讲，不难，只是题目意思理解费劲，解题关键是用两个priorityqueue，一个用来存buy的最大，一个用来存sell的最小。
    
42. 
    
43. 然后扫描，update 两个pq；
    
44. """
    
45. 
    
46. 
    
47. import heapq
    
48. 
    
49. 
    
50. class Solution:
    
51. 
    
52.     def __init__(self):
    
53.         self.buy = []
    
54.         self.sell = []
    
55.         self.count = 0
    
56. 
    
57.     def put_order(self, order):
    
58.         price, quantity, side = order
    
59.         price = int(price)
    
60.         quantity = int(quantity)
    
61.         if side == 'buy':
    
62.             # max-heap
    
63.             heapq.heappush(self.buy, (-price, price, quantity))
    
64.         elif side == 'sell':
    
65.             # min-heap
    
66.             heapq.heappush(self.sell, (price, price, quantity))
    
67.         
    
68.         self.fulfill()
    
69. 
    
70.     def stream(self, orders):
    
71.         for order in orders:
    
72.             self.put_order(order)
    
73. 
    
74.     def fulfill(self):
    
75.         while self.buy and self.sell:
    
76.             b_key, b_price, b_quantity = self.buy[0]
    
77.             s_key, s_price, s_quantity = self.sell[0]
    
78.             if b_price >= s_price:
    
79.                 heapq.heappop(self.buy)
    
80.                 heapq.heappop(self.sell)
    
81.                 if b_quantity < s_quantity:
    
82.                     heapq.heappush(self.sell, (s_key, s_price, s_quantity - b_quantity))
    
83.                 elif b_quantity > s_quantity:
    
84.                     heapq.heappush(self.buy, (b_key, b_price, b_quantity - s_quantity))
    
85.                 self.count += min(s_quantity, b_quantity)
    
86.             else:
    
87.                 break
    
88. 
    
89. 
    
90. import unittest
    
91. 
    
92. class Test(unittest.TestCase):
    
93. 
    
94.     def test_1(self):
    
95.         sol = Solution()
    
96.         orders = [
    
97.             ['150', '5', 'buy'], # Order A
    
98.             ['190', '1', 'sell'], # Order B
    
99.             ['200', '1', 'sell'], # Order C
    
100.             ['100', '9', 'buy'], # Order D
     
101.             ['140', '8', 'sell'], # Order E
     
102.             ['210', '4', 'buy'], # Order F
     
103.         ]
     
104.         sol.stream(orders)
     
105.         print(sol.count)
     
106.         self.assertEqual(sol.count, 9)
     
107. 
     
108.     def test_2(self):
     
109.         sol = Solution()
     
110.         orders = [
     
111.             ['150', '5', 'buy'], # Order A
     
112.             ['190', '1', 'sell'], # Order B
     
113.             ['200', '1', 'sell'], # Order C
     
114.             ['100', '9', 'buy'], # Order D
     
115.             ['140', '8', 'sell'], # Order E
     
116.             ['210', '100', 'buy'], # Order F
     
117.         ]
     
118.         sol.stream(orders)
     
119.         print(sol.count)
     
120.         self.assertEqual(sol.count, 10)
     
121. 
     
122.     def test_3(self):
     
123.         sol = Solution()
     
124.         orders = [
     
125.             ['210', '100', 'buy'], # Order F
     
126.             ['190', '1', 'sell'], # Order B
     
127.             ['200', '1', 'sell'], # Order C
     
128.             ['100', '9', 'buy'], # Order D
     
129.             ['140', '8', 'sell'], # Order E
     
130.             ['150', '5', 'buy'], # Order A
     
131.         ]
     
132.         sol.stream(orders)
     
133.         print(sol.count)
     
134.         self.assertEqual(sol.count, 10)
     
135. 
     
136.     def test_4(self):
     
137.         sol = Solution()
     
138.         orders = [
     
139.             ("150", "10", "buy"),
     
140.             ("165", "7", "sell"),
     
141.             ("168", "3", "buy"),
     
142.             ("155", "5", "sell"),
     
143.             ("166", "8", "buy")
     
144.         ]
     
145.         sol.stream(orders)
     
146.         print(sol.count)
     
147.         self.assertEqual(sol.count, 11)
     
148. 
     
149. if __name__=="__main__":
     
150.     unittest.main(verbosity=2)
     

复制代码

应该是比较a[i] 和 a[i-1]