笔试 / 实习找工 / 字节

Test machine du camp d'ingénierie frontend ByteDance

Shemol10 nov. 2025

笔试实习找工字节

QCM et problèmes de programmation. Je note à peu près les points.

QCM

Surtout structures de données et algorithmes, réseaux, et les bases html,css,js.

Structures de données et algorithmes

Retour en L1 ou L2, l'examen de structures de données et d'algos…

Des questions de tri : tri à bulles, quicksort, etc. Deux ou trois, je crois.

Une question très simple sur la complexité.

Les parcours d'arbres binaires, on dirait aussi deux ou trois questions.

Et une sur les piles.

Réseaux

Quel est le protocole de transport non fiable ?

UDP.

Il y avait aussi une question sur les messages DNS

Je me souviens seulement que l'option A disait QR=0 pour requête, QR=1 pour réponse.

html,css,js

Comment unifier margin et padding entre navigateurs ?

CSS Reset

css

* {
  margin: 0;
  padding: 0;
}

Il y a aussi Normalize.css, il paraît — à revoir plus tard.

Il y avait aussi une question CSS float : lequel est un usage incorrect

Parmi les options :

A. float:

B. float: none

C. float: left

D. float: right

Bref, A est la bonne

Comment dégager l'effondrement de hauteur d'un parent

J'ai oublié les options. Je n'ai pas encore vraiment regardé.

Clear avec un pseudo-élément ::after.
Approche moderne : display: flow-root.
Déclencher un BFC : la propriété overflow. Inconvénient : le vrai job de overflow: hidden, c'est « cacher le contenu qui dépasse ». Si tu as un menu déroulant, une ombre, une infobulle qui doivent « déborder » du parent, ils se font couper.

Parmi les pratiques, lesquelles sont une application de BFC :

BFC (Block Formatting Context), contexte de formatage de bloc.

Applications du BFC :

Nettoyer les flottants internes (la plus courante) : le parent a des enfants flottants (float: left/right), d'où l'effondrement de hauteur. Mettre sur le parent overflow: hidden; ou display: flow-root;.
Empêcher le collapse des marges verticales (Margin Collapse) : dans le flux normal, les marges verticales (margin-top et margin-bottom) de deux blocs adjacents « se plient » et fusionnent en la plus grande des deux. Envelopper l'un (ou chacun) dans un nouveau parent, et déclencher un BFC sur ce parent (par ex. overflow: hidden;).
Layout deux / trois colonnes adaptatif : une largeur fixe d'un côté, l'autre qui prend le reste ? (par ex. menu gauche float: left, contenu principal à droite qui remplit). Élément gauche float: left; (largeur fixe). Le contenu de droite déclenche un BFC (par ex. overflow: hidden; ou display: flow-root;).

Une autre façon d'interviewer : « laquelle de ces propriétés peut déclencher un BFC ? »

Quelques déclencheurs courants :

overflow: hidden; / auto; / scroll; (le hack le plus classique)
display: flow-root; (le « déclencheur de BFC » le plus moderne, sémantiquement le plus juste)
float: left; / right; (un flottant crée lui-même un BFC)
position: absolute; / fixed; (un élément en position absolue crée un BFC)
display: inline-block;
display: table-cell;
les enfants Flex/Grid (flex item / grid item)

La prochaine fois qu'un entretien montre overflow: hidden; ou display: flow-root;, s'ils servent à régler « l'effondrement de hauteur », « le collapse de marges » ou « un layout deux colonnes », c'est une application de BFC.

requestAnimationFrame en js

J'ai regardé le livre rouge JS, je n'ai pas trop pigé. Plus tard.

L'ordre d'affichage de setTimeout et Promise.then() en js

À l'exécution, js classe les tâches en trois :

Tâches sync (Synchronous Code) : le code qui s'exécute tout de suite sur la call stack
Microtâches : juste après la fin du sync courant. Les callbacks de Promise.then() et .catch() sont les microtâches les plus courantes.
Macrotâches : seulement après le sync et toutes les microtâches on en tire une de la file. Les callbacks de setTimeout() et setInterval() sont des macrotâches.

css

console.log('1. 同步代码：开始');

// 安排一个宏任务
setTimeout(() => {
  console.log('2. 宏任务：setTimeout 1');
}, 0);

// new Promise 的执行器是同步的
new Promise((resolve, reject) => {
  console.log('3. 同步代码：Promise Executor');
  
  // 在 Promise 内部安排一个宏任务
  setTimeout(() => {
    console.log('4. 宏任务：setTimeout 2 (在Promise内部)');
    resolve(); // 在这个宏任务中，Promise 状态变为 fulfilled
  }, 0);

}).then(() => {
  // 当 promise被 resolve() 时，这个 .then() 才会被放入微任务队列
  console.log('5. 微任务：Promise.then 1');
});

// 安排一个立即 resolve 的 Promise
Promise.resolve().then(() => {
  console.log('6. 微任务：Promise.then 2');
});

console.log('7. 同步代码：结束');

Exécuter console.log('1. 同步代码：开始')
Tomber sur setTimeout 1, mettre son callback dans la file des macrotâches
Tomber sur new Promise, exécuter tout de suite, en sync, sa fonction executor. Exécuter console.log('3. 同步代码：Promise Executor').
Tomber sur setTimeout 2, mettre son callback dans la file des macrotâches.
Tomber sur Promise.resolve().then(), cette Promise est resolved tout de suite, son callback .then va dans la file des microtâches.
Exécuter console.log('7. 同步代码：结束').
Vider la file des microtâches.
Prendre la première macrotâche et l'exécuter.
Rechecker la file des microtâches.
Exécuter la macrotâche suivante. Dans la même tâche, resolve() est appelé. resolve() déclenche le .then associé, et met ce callback dans la file des microtâches.
Vider la file des microtâches.

Problèmes de programmation

Le mode ACM, je ne le maîtrise pas trop encore. Faudra grind Nowcoder plus tard.

Un système d'équations, on te donne A, B, C, combien de solutions réelles

Forme :

X² + A²Y² + C = 0

Y² + Z² + B = 0

Z² + A = 0

On dirait des maths… les calculer d'abord puis discuter les cas.

Parmi les entiers à k chiffres, combien ont la somme des chiffres égale à m.

Ex. k=2, m=3, 12, 21, 30 : trois nombres dont la somme des chiffres vaut 3

python

import functools

def solve_digit_sum(k:int,m:int)->int:
	@functools.lru_cache(None)
	def count_sequences(digits:int,target_sum:int)->int:
		if target_sum < 0:
			return 0
			
		if target_sum > 9*digits:
			return 0
			
		if digits == 0:
			return 1 if target_sum==0 else 0
			
		total_ways = 0
		for d in range(10):
			total_ways += count_sequences(digits - 1,target_sum - d)
		
		return total_ways
		
		
	if k<=0:
		return 0
		
	final_count = 0
	
	for d1 in range(1,10):
		final_count += count_sequences(k-1,m-d1)
		
	return final_count

Il y avait aussi un problème qui ressemblait à :

Le « coût » est défini comme le max des poids d'arêtes sur ce chemin simple. Un graphe simple non orienté pondéré, connexe. Compter combien de paires de nœuds distincts (u, v) ont un coût minimum égal à k.

Mais ça avait l'air trop dur. Je le mets de côté pour l'instant.