Desde las vacaciones de invierno, he estado invirtiendo en algunos puestos de prácticas de algoritmo. Como es un algoritmo, el problema del "código de desgarro manual" debe ser indispensable para las grandes empresas. Me temo que lo olvidaré, así que lo he grabado. El objetivo es entrevistar a 8 empresas, y ahora hemos entrevistado a Samsung, Huawei, Kuaishou, Sangfor, ByteDance y Samsung no tiene preguntas de código.
Samsung
Comparando el agua, no hay problema de código.
Huawei
Es relativamente simple y examina un problema de secuencia de Fibonacci. La entrevista es relativamente simple y solo se prueba una pregunta de algoritmo.
class Solution:
def fib(self, n: int) -> int:
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a
trabajador rápido
Ya me he enfrentado a ambos lados, y el resultado no es claro. Se han probado un total de 4 preguntas de código en ambos lados, y solo recuerdo tres.
1. Lea la imagen de un archivo y luego genere el resultado como una matriz.
import cv2
img_BGR = cv2.imread(path)
img = cv2.cvtColor(img_BGR, cv2.COLOR_BGR2RGB)
#返回的结果是numpy类型，转为list就可以了
print(img.tolist())2. Cómo juzgar que dos árboles binarios son exactamente iguales y que el valor del nodo también es el mismo.
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def isSameTree(self, p: TreeNode, q: TreeNode) -> bool:
if not p and not q:
return True
if not p or not q:
return False
#递归
return p.val==q.val and self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)
#迭代
res_p,res_q = [],[]
def helper(root,res):
queue = collections.deque()
queue.append(root)
while queue:
item = queue.popleft()
if item:
res.append(item.val)
queue.append(item.left)
queue.append(item.right)
else:
res.append('null')
helper(p,res_p)
helper(q,res_q)
return res_p==res_q3. Encuentre la longitud de subcadena más larga sin caracteres repetidos en una cadena.
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
if not s:
return 0
res = 1
for i in range(len(s)):
tmp = set()
tmp.add(s[i])
for j in range(i+1,len(s)):
if s[j] not in tmp:
tmp.add(s[j])
else:
break
res = max(res,len(tmp))
return res
k = -1
res = 0
c_dict = {}
for i, c in enumerate(s):
#如果出现重复的元素且下标是大于k
#更新k，更新c的下标
if c in c_dict and c_dict[c] > k:
k = c_dict[c]
c_dict[c] = i
#如果没有出现重复的元素，直接给字典添加并且计算更新res的长度
else:
c_dict[c] = i
res = max(res, i-k)
return res
Convencido
-
Hable sobre la diferencia entre SVM y regresión logística y los principios subyacentes.
-
Hable sobre los principios, ventajas y desventajas de RNN y LSTM
-
Hable sobre la función de pérdida que ha utilizado, el papel de la función de optimización
-
Hábleme de los optimizadores que ha utilizado, SGD y Adam. ¿Cuál es el principio subyacente de los dos?
-
¿Por qué CNN es más rápido que RNN?
-
¿Qué logran los detalles de CNN?
-
Hablando de su proyecto, en términos de antecedentes y aplicación, y específicamente en términos de entrada, salida y función objetiva. No debería hablar de los detalles al principio.
-
Hable sobre Python: el principio de intercambiar dos variables en una línea de código, generador y rendimiento
-
¿Cuál es la diferencia entre la regularización L1 y la regularización L2? ¿Por qué L2 es mejor y cuáles son las mejoras en L1?
-
Este es el final de los dos lados, siento que mi comida está abrochada y derramo lágrimas de base débil; en resumen, es la capa inferior, el problema de la capa inferior, ¡la base es una lástima! ! ! Muchas preguntas fueron respondidas vagamente;
Byte batiendo
Por un lado: hablando de un proyecto o un trabajo, hablé de un trabajo en el que estoy trabajando, y pregunté con más detalle, lo hablé durante más de 30 minutos y luego escribí el código. Relativamente simple: la subcadena más larga sin caracteres repetidos.
Escribí el Método 3 durante la entrevista. El entrevistador me pidió que pensara en cómo optimizarlo. La versión optimizada son las dos primeras. El segundo uso de doble puntero + tabla hash es más interesante y puede acelerar la eficiencia.
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
#滑动窗口
#维护一个窗口，必须保证每种元素只出现了一次
res = 0
win = []
for char in s:
#如果字符不在窗口，那就他添加字符
if char not in win:
win.append(char)
#如果字符在窗口里，那就截取第一次出现字符之后作为新的窗口
#并将当前的元素添加进去
else:
win = win[win.index(char)+1:]
win.append(char)
#更新窗口的大小
res = max(res,len(win))
return res
#hash+双指针
dic = defaultdict(int)
res = 0
index = -1
#维护一个字典，key是字符，value是下标
for j in range(len(s)):
#如果当前字符在字典中的话，那就更新下标，将左指针向右移动
if s[j] in dic:
index =max(dic[s[j]],index)
#更新字典
dic[s[j]] = j
#更新子字符串的长度
res = max(res,j-index)
return res
#滑动窗口的模板
res = 0
left,right = 0,0
size = len(s)
counter = collections.Counter()
while right<size:
counter[s[right]]+=1
#当出现频次最高的字符频次大于1的时候，那就更新字典、移动左指针
while counter.most_common(1)[0][1]>1:
counter[s[left]]-=1
left+=1
res = max(res,right-left+1)
right+=1
return resInacabado ... Continuamente actualizado