亚麻VO面经

亚麻社招VO面试，前10分钟问了最近

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

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

SCUZ_CODE_1        ]

好奇没有bq吗

请问是sde几啊？

francislau 发表于 2022-05-27 08:17:43
请问是sde几啊？

2/3吧，工作好几年了。

第一题要是不让using extra space确实会比较难和容易出错啊

题不难啊

匿名用户 发表于 2022-05-28 07:16:47
题不难啊

说不上很难。时间紧凑下就比较难完成呢。

第二题解法
写下这80+行代码，这个时间是比较紧张的

1. from typing import Optional
   
2. 
   
3. 
   
4. class ListNode:
   
5.     def __init__(self, val=0, next=None):
   
6.         self.val = val
   
7.         self.next = next
   
8. 
   
9. 
   
10. def num_to_reverse_list(num: int) -> Optional[ListNode]:
    
11.     l = []
    
12.     while num > 0:
    
13.         l.append(num % 10)
    
14.         num = num // 10
    
15.     virtual_head = ListNode(0)
    
16.     last_node = virtual_head
    
17.     for e in l:
    
18.         last_node.next = ListNode(e, None)
    
19.         last_node = last_node.next
    
20.     return virtual_head.next
    
21. 
    
22. 
    
23. # 如果知道谁大谁小那就很简单，但是因为是数字倒序存入单链表，因此直接比较大小
    
24. # 转为其他数据结构：可以考虑先转列表；python中整数不限制位数，也可以直接转为整数计算
    
25. # 二进制可以通过补码，将减法转换为加法 https://zhuanlan.zhihu.com/p/21258170
    
26. def minus_list(l1_node: Optional[ListNode], l2_node: Optional[ListNode]) -> Optional[ListNode]:
    
27.     # l1-l2不停借位，如果借不到了，就给l2对应位数+1
    
28.     result_virtual_node = ListNode(0)
    
29.     result_pointer_node = result_virtual_node
    
30. 
    
31.     cover_virtual_node = ListNode(0)
    
32.     cover_pointer_node = cover_virtual_node
    
33.     borrow = 0
    
34. 
    
35.     while l1_node and l2_node:
    
36.         sub = l1_node.val - l2_node.val - borrow
    
37.         if sub >= 0:
    
38.             borrow = 0
    
39.             result_pointer_node.next = ListNode(sub)
    
40.             result_pointer_node = result_pointer_node.next
    
41.         else:
    
42.             borrow = 1
    
43.             result_pointer_node.next = ListNode(sub + 10)
    
44.             result_pointer_node = result_pointer_node.next
    
45.         cover_pointer_node.next = ListNode(0)
    
46.         cover_pointer_node = cover_pointer_node.next
    
47.         l1_node = l1_node.next
    
48.         l2_node = l2_node.next
    
49. 
    
50.     if not l1_node:
    
51.         while l2_node:
    
52.             cover_pointer_node.next = ListNode(l2_node.val + borrow)
    
53.             cover_pointer_node = cover_pointer_node.next
    
54.             l2_node = l2_node.next
    
55.             borrow = 0
    
56.         if borrow:
    
57.             cover_pointer_node.next = ListNode(1)
    
58.             cover_pointer_node = cover_pointer_node.next
    
59.             borrow = 0
    
60.     if cover_pointer_node.val != 0:
    
61.         return minus_list(cover_virtual_node.next, result_virtual_node.next)
    
62. 
    
63.     return result_virtual_node.next
    
64. 
    
65. 
    
66. def reverse_node_to_num(node: Optional[ListNode]) -> int:
    
67.     num = 0
    
68.     i = 0
    
69.     while node:
    
70.         num += 10 ** i * node.val
    
71.         node = node.next
    
72.         i += 1
    
73.     return num
    
74. 
    
75. 
    
76. if __name__ == '__main__':
    
77.     print(reverse_node_to_num(minus_list(num_to_reverse_list(142), num_to_reverse_list(137))))
    
78.     print(reverse_node_to_num(minus_list(num_to_reverse_list(137), num_to_reverse_list(142))))
    
79. 
    
80.     print(reverse_node_to_num(minus_list(num_to_reverse_list(42), num_to_reverse_list(137))))
    
81.     print(reverse_node_to_num(minus_list(num_to_reverse_list(137), num_to_reverse_list(42))))

复制代码

boomjoe1991 发表于 2022-5-29 00:42
说不上很难。时间紧凑下就比较难完成呢。

那倒是 第二个有点麻烦，赶时间的话 有些紧张的

Explosive 发表于 2022-05-28 10:19:18
第二题解法
写下这80+行代码，这个时间是比较紧张的from typing import Optional

Hackerrank 上有原题