- 5 lỗi cài đặt gây mất điểm nhiều nhất trong phỏng vấn trực tuyến gồm: (1) Tràn số nguyên 32-bit khi cộng/nhân, (2) Lệch 1 đơn vị và truy cập vượt biên mảng (Off-by-one & Out-of-bounds), (3) Giải tham chiếu con trỏ rỗng (Null Pointer), (4) Quên khôi phục trạng thái khi quay lui (Backtracking Mutation), và (5) Sửa đổi cấu trúc dữ liệu trong khi đang duyệt qua nó.
- Trong phiếu chấm điểm của Big Tech, ứng viên tự phát hiện và sửa lỗi của mình trong bước chạy tay (Dry-run) được đánh giá cao hơn hẳn ứng viên phải đợi người phỏng vấn nhắc "Dòng 18 của bạn có vấn đề đấy".
- Luôn dành 3 đến 4 phút cuối trước khi tuyên bố hoàn thành để kiểm tra code với bộ 4 test biên chuẩn: mảng 1 phần tử (\(N=1\)), toàn bộ phần tử trùng nhau, phần tử âm/bằng 0, và giá trị chạm trần \(10^9\).
- Tập thói quen viết mã phòng thủ (Defensive Coding): đặt điều kiện kiểm tra chỉ số
i + 1 < nđứng trướca[i + 1], dùngl + (r - l) / 2và ép kiểu1LLcho mọi phép nhân có nguy cơ vượt \(2 \times 10^9\).
Vì sao code trên trình duyệt phỏng vấn dễ phát sinh lỗi hơn ở nhà?
Khi luyện tập ở nhà theo lộ trình luyện LeetCode phỏng vấn Big Tech, chúng ta thường dựa dẫm vào ba chiếc "phao cứu sinh" vô hình:
- Trình biên dịch hoặc IDE gạch chân màu đỏ ngay khi bạn gõ sai tên phương thức (
size()vslengthvslen()). - Nút Run Code / Submit chạy thử hàng chục bộ test chỉ trong 1 giây và in ra chính xác đầu vào làm chương trình bị sập (
IndexOutOfBoundsExceptionhayAddressSanitizer: heap-buffer-overflow). - Tâm lý thoải mái không có ai đang nhìn chằm chằm vào con trỏ chuột của mình.
Bước vào vòng phỏng vấn trực tuyến (Live Coding), nhiều công ty tắt hoàn toàn nút biên dịch (như Google dùng trình soạn thảo văn bản thuần túy), hoặc nếu dùng CoderPad thì người phỏng vấn cũng kỳ vọng code của bạn chạy đúng ngay ở lần bấm Run đầu tiên. Do đó, việc nhận diện trước 5 cái bẫy kinh điển dưới đây sẽ giúp bạn cài đặt chuẩn xác ngay từ nhịp gõ đầu tiên.
5 lỗi code kinh điển làm ứng viên mất điểm oan và cách phòng tránh
Lỗi 1: Tràn số nguyên 32-bit có dấu (32-bit Signed Integer Overflow)
Trong C++ và Java, kiểu int chuẩn là số nguyên 32-bit có dấu nằm trong đoạn \([-2{,}147{,}483{,}648,\; 2{,}147{,}483{,}647] \approx \pm 2.14 \times 10^9\). Ba vị trí gây tràn số phổ biến nhất là:
- Tính điểm giữa trong tìm kiếm nhị phân: Viết
int mid = (low + high) / 2;sẽ bị tràn thành số âm nếulow + high > INT_MAX. Hãy luôn viếtint mid = low + (high - low) / 2;. - Cộng dồn mảng hoặc nhân hai số nguyên: Khi đề bài cho \(N = 10^5\) và \(A[i] \le 10^5\), tổng của mảng hoặc bình phương \(A[i] \times A[i]\) đạt tới \(10^{10} \gt 2 \times 10^9\). Một lỗi rất hiểm trong C++/Java là viết
long long prod = a[i] * a[i];— vì hai toán hạnga[i]đều là kiểuint, phép nhân được thực hiện trên thanh ghi 32-bit bị tràn trước khi kịp gán sang biếnlong long! Cách viết đúng bắt buộc phải ép kiểu toán hạng đầu tiên:long long prod = 1LL * a[i] * a[i];(hoặc(long) a[i] * a[i]trong Java). - Trừ hai số nguyên trong hàm so sánh (Comparator): Tuyệt đối không viết
return a - b;trong hàmComparatorcủa Java vì nếu \(a = -2 \times 10^9\) và \(b = 10^9\), hiệu \(a - b\) sẽ bị tràn số dương làm đảo lộn thứ tự sắp xếp. Hãy dùngInteger.compare(a, b).
Lỗi 2: Lệch 1 đơn vị (Off-by-one) và Truy cập vượt biên trong vòng lặp while
Khi dùng Hai con trỏ để nén mảng hoặc bỏ qua các phần tử trùng nhau, rất nhiều ứng viên viết:
// LỖI NGHIÊM TRỌNG: Khi i = n - 1, biểu thức a[i + 1] truy cập vào a[n] (Out of bounds)!
while (a[i] == a[i + 1]) {
i++;
}
Nhờ cơ chế Đánh giá ngắn mạch (Short-circuit Evaluation) của toán tử && (and), bạn bắt buộc phải đặt điều kiện kiểm tra biên ở bên trái biểu thức truy cập mảng:
// CHUẨN AN TOÀN: Nếu i + 1 >= n, vế trái bằng false nên a[i + 1] không bao giờ bị gọi
while (i + 1 < n && a[i] == a[i + 1]) {
i++;
}
Lỗi 3: Giải tham chiếu con trỏ null / nullptr / None trên Cây và Danh sách liên kết
Khi thao tác trên Danh sách liên kết (Linked List) hoặc Cây nhị phân (Binary Tree), việc gọi curr->next->next hoặc node->left->val mà chưa kiểm tra curr != nullptr && curr->next != nullptr sẽ gây sập chương trình (Segmentation Fault / NullPointerException) ngay khi gặp danh sách rỗng hoặc danh sách chỉ có 1 nút.
Mẹo phòng vệ: Luôn sử dụng một Nút giả ở đầu (Dummy Head Node) khi bài toán có khả năng làm thay đổi hoặc xóa mất nút head ban đầu của danh sách liên kết.
Lỗi 4: Quên khôi phục trạng thái (State Rollback) trong Đệ quy Quay lui và Tham chiếu đối tượng
Trong các bài toán tìm kiếm đường đi trên ma trận (như Word Search) hoặc sinh tổ hợp bằng Quay lui (Backtracking), nếu bạn truyền một mảng path hoặc đánh dấu visited[r][c] = true trước khi gọi đệ quy xuống nhánh con nhưng lại quên đặt lại visited[r][c] = false và path.pop_back() ngay sau lời gọi đệ quy, nhánh đầu tiên đi vào ngõ cụt sẽ khóa chết toàn bộ các ô trên bảng khiến các nhánh sau không thể đi qua được nữa.
Trong Python và Java, còn một biến thể rất dễ mắc là thêm trực tiếp tham chiếu danh sách đang biến đổi vào kết quả: res.append(path) thay vì sao chép bản chụp res.append(path.copy()) (hoặc new ArrayList<>(path)), dẫn đến cuối chương trình mọi danh sách trong res đều rỗng!
Lỗi 5: Sửa đổi tập hợp/bảng băm ngay trong lúc đang duyệt qua nó
Trong C++, Java và Python, nếu bạn viết vòng lặp for (int x : my_set) hoặc for k in my_dict: rồi gọi lệnh xóa my_set.erase(x) / del my_dict[k] ngay bên trong thân vòng lặp, bộ lặp (Iterator) sẽ bị vô hiệu hóa ngay lập tức và ném ra ngoại lệ ConcurrentModificationException hoặc RuntimeError: dictionary changed size during iteration. Hãy thu thập các khóa cần xóa vào một danh sách phụ hoặc dùng hàm trả về iterator tiếp theo it = my_set.erase(it).
Thực hành sửa lỗi: Bài toán nén mảng tăng dần và tính tổng bình phương
Để thấy rõ tác hại cộng hưởng của Lỗi 1 (Tràn số 32-bit) và Lỗi 2 (Lệch 1 đơn vị / Bỏ sót phần tử cuối), hãy xét bài toán thường gặp sau:
Đề bài: Cho mảng số nguyên \(A\) gồm \(N\) phần tử đã được sắp xếp không giảm (có thể chứa các giá trị lớn tới \(10^5\)). Hãy loại bỏ các phần tử trùng lặp liên tiếp để giữ lại các giá trị phân biệt, sau đó trả về (Số phần tử phân biệt K, Tổng bình phương của K phần tử đó).
Phân tích hai lỗi chí mạng nếu viết vội:
- Nếu chỉ duyệt
for (int i = 0; i < n - 1; ++i)và gom khia[i] != a[i + 1], bạn dễ dàng bỏ quên nhóm phần tử cuối cùng hoặc gặp lỗi chỉ số âmn - 1 = -1khi mảng rỗng! Cách viết chuẩn nhất bằng Hai con trỏ (Slow-Fast Pointers) là giữ con trỏ ghiwrite_idx = 1và duyệtread_idxtừ \(1\) đến \(N - 1\): mỗi khia[read_idx] != a[write_idx - 1]thì ghia[write_idx++] = a[read_idx]. - Khi tính tổng bình phương
sum_sq += 1LL * a[i] * a[i], nếu \(a[i] = 100{,}000\), tích \(a[i]^2 = 10^{10}\) vượt quá giới hạn kiểuint32-bit (\(2.14 \times 10^9\)), nên bắt buộc phải tính trên số nguyên 64-bit (long longtrong C++,longtrong Java).
Chạy tay (Dry-run) trên 3 bộ kiểm thử tiêu biểu
| Bộ kiểm thử | Mảng đầu vào \(A\) | Các phần tử sau khi khử trùng | Số phần tử \(K\) | Tổng bình phương chuẩn 64-bit | Lỗi xảy ra nếu dùng int 32-bit |
|---|---|---|---|---|---|
| Test 1 (Chuẩn) | [1, 1, 2, 2, 2, 3] |
[1, 2, 3] |
\(3\) | \(1^2 + 2^2 + 3^2 = \mathbf{14}\) | Chạy đúng vì số nhỏ |
| Test 2 (Số lớn) | [100000, 100000, 200000] |
[100000, 200000] |
\(2\) | \(10^{10} + 4 \times 10^{10} = \mathbf{50{,}000{,}000{,}000}\) | Tràn số 32-bit ra kết quả âm hoặc sai lệch! |
| Test 3 (Biên \(N=1\)) | [-5] |
[-5] |
\(1\) | \((-5)^2 = \mathbf{25}\) | Dễ bị bỏ sót nếu vòng lặp viết sai biên n - 1 |
Dưới đây là mã nguồn cài đặt an toàn bằng C++17, Python và Java 21: hàm khử trùng dùng đúng hai con trỏ ghi / đọc ở trên, tổng bình phương cộng dồn trên số nguyên 64-bit. Chạy không có đầu vào, chương trình chạy cả 3 bộ kiểm thử của bảng và in K=3 [1 2 3] sum_sq=14, K=2 [100000 200000] sum_sq=50000000000, K=1 [-5] sum_sq=25:
// Bài "nén mảng tăng dần và tính tổng bình phương" của mục "Thực hành sửa lỗi": khử trùng mảng đã sắp xếp bằng hai con
// trỏ (sửa tại chỗ), rồi tính tổng bình phương K giá trị phân biệt. In: K, các phần tử giữ lại, tổng bình phương.
// Đầu vào: N, rồi N số nguyên đã sắp xếp không giảm. Không có đầu vào thì chạy 3 bộ kiểm thử của bảng "Chạy tay".
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
int deduplicate_sorted(vector<int>& a) {
if (a.empty()) return 0; // mảng rỗng: không đụng tới a[0], cũng không có chỉ số n - 1 = -1
int write_idx = 1;
for (int read_idx = 1; read_idx < (int)a.size(); ++read_idx) {
if (a[read_idx] != a[write_idx - 1]) a[write_idx++] = a[read_idx];
}
return write_idx; // K: a[0..K-1] là các giá trị phân biệt, gồm cả nhóm cuối cùng
}
long long sum_of_squares(const vector<int>& a, int k) {
long long sum_sq = 0;
for (int i = 0; i < k; ++i) sum_sq += 1LL * a[i] * a[i]; // ép 1LL trước khi nhân, không thì tràn int 32-bit
return sum_sq;
}
string giai(vector<int> a) {
int k = deduplicate_sorted(a);
ostringstream out;
out << "K=" << k << " [";
for (int i = 0; i < k; ++i) out << (i ? " " : "") << a[i];
out << "] sum_sq=" << sum_of_squares(a, k);
return out.str();
}
int main() {
vector<vector<int>> bo_kiem;
int n;
if (!(cin >> n)) {
bo_kiem = {{1, 1, 2, 2, 2, 3}, {100000, 100000, 200000}, {-5}};
} else {
vector<int> a(n);
for (int& x : a) cin >> x;
bo_kiem.push_back(a);
}
for (const auto& a : bo_kiem) cout << giai(a) << "\n";
return 0;
}
# Bài "nén mảng tăng dần và tính tổng bình phương" của mục "Thực hành sửa lỗi": khử trùng mảng đã sắp xếp bằng hai con
# trỏ (sửa tại chỗ), rồi tính tổng bình phương K giá trị phân biệt. In: K, các phần tử giữ lại, tổng bình phương.
# Đầu vào: N, rồi N số nguyên đã sắp xếp không giảm. Không có đầu vào thì chạy 3 bộ kiểm thử của bảng "Chạy tay".
import sys
def deduplicate_sorted(a: list[int]) -> int:
if not a: # mảng rỗng: không đụng tới a[0], cũng không có chỉ số n - 1 = -1
return 0
write_idx = 1
for read_idx in range(1, len(a)):
if a[read_idx] != a[write_idx - 1]:
a[write_idx] = a[read_idx]
write_idx += 1
return write_idx # K: a[0..K-1] là các giá trị phân biệt, gồm cả nhóm cuối cùng
def sum_of_squares(a: list[int], k: int) -> int:
# Số nguyên Python không tràn; bản C++ phải viết 1LL * a[i] * a[i], bản Java (long) a[i] * a[i].
return sum(a[i] * a[i] for i in range(k))
def giai(a: list[int]) -> str:
k = deduplicate_sorted(a)
return f"K={k} [{' '.join(map(str, a[:k]))}] sum_sq={sum_of_squares(a, k)}"
def main() -> None:
data = sys.stdin.read().split()
if not data:
bo_kiem = [[1, 1, 2, 2, 2, 3], [100000, 100000, 200000], [-5]]
else:
n = int(data[0])
bo_kiem = [[int(x) for x in data[1:1 + n]]]
for a in bo_kiem:
print(giai(a))
if __name__ == "__main__":
main()
// Bài "nén mảng tăng dần và tính tổng bình phương" của mục "Thực hành sửa lỗi": khử trùng mảng đã sắp xếp bằng hai con
// trỏ (sửa tại chỗ), rồi tính tổng bình phương K giá trị phân biệt. In: K, các phần tử giữ lại, tổng bình phương.
// Đầu vào: N, rồi N số nguyên đã sắp xếp không giảm. Không có đầu vào thì chạy 3 bộ kiểm thử của bảng "Chạy tay".
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
public class Main {
static int deduplicateSorted(int[] a) {
if (a.length == 0) return 0; // mảng rỗng: không đụng tới a[0], cũng không có chỉ số n - 1 = -1
int writeIdx = 1;
for (int readIdx = 1; readIdx < a.length; readIdx++) {
if (a[readIdx] != a[writeIdx - 1]) a[writeIdx++] = a[readIdx];
}
return writeIdx; // K: a[0..K-1] là các giá trị phân biệt, gồm cả nhóm cuối cùng
}
static long sumOfSquares(int[] a, int k) {
long sumSq = 0;
for (int i = 0; i < k; i++) sumSq += (long) a[i] * a[i]; // ép (long) trước khi nhân, không thì tràn int
return sumSq;
}
static String giai(int[] a) {
int k = deduplicateSorted(a);
StringBuilder sb = new StringBuilder("K=").append(k).append(" [");
for (int i = 0; i < k; i++) sb.append(i > 0 ? " " : "").append(a[i]);
return sb.append("] sum_sq=").append(sumOfSquares(a, k)).toString();
}
public static void main(String[] args) throws IOException {
String vao = new String(System.in.readAllBytes(), StandardCharsets.UTF_8).trim();
List<int[]> boKiem = new ArrayList<>();
if (vao.isEmpty()) {
boKiem.add(new int[]{1, 1, 2, 2, 2, 3});
boKiem.add(new int[]{100000, 100000, 200000});
boKiem.add(new int[]{-5});
} else {
String[] tk = vao.split("\\s+");
int n = Integer.parseInt(tk[0]);
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = Integer.parseInt(tk[1 + i]);
boKiem.add(a);
}
StringBuilder sb = new StringBuilder();
for (int[] a : boKiem) sb.append(giai(a)).append('\n');
System.out.print(sb);
}
}
Quy trình Dry-run 3 phút cuối trước khi nói "Em đã xong"
Trong phỏng vấn thật, ngay khi gõ xong dấu ngoặc đóng } cuối cùng, đừng vội ngẩng lên nói "Em code xong rồi ạ". Hãy nói câu thần chú chuyên nghiệp sau:
"Em đã viết xong khung chính của thuật toán. Bây giờ em xin phép dành 2 phút để chạy tay (trace) qua một ví dụ nhỏ và kiểm tra các điều kiện biên trước khi chốt nhé."
Trong 2–3 phút đó, hãy rà mắt theo đúng 4 bước kiểm tra sau:
- Đọc đúng những gì code đang viết, không đọc những gì bạn nghĩ trong đầu: Ghi một dòng chú thích
// i=0, l=0, r=3, sum=0ngay bên cạnh vòng lặp và cập nhật giá trị từng biến sau mỗi dòng lệnh. - Kiểm tra dòng khởi tạo và dòng trả về: Biến đếm đã khởi tạo bằng
0chưa? Biến tìm giá trị nhỏ nhất đã khởi tạo bằngINF(chứ không phải0) chưa? Nếu dùng bảng băm, bảng băm có cần nạp trước phần tử cơ sở (nhưfreq[0] = 1) không? - Thử ngay với \(N = 1\) và mảng toàn phần tử giống nhau: Xem vòng lặp có bị chạy vô hạn (
Infinite Loopkhileftvàrightkhông tiến lại gần nhau) hay truy cậpa[1]khi mảng chỉ cóa[0]không. - Rà soát kiểu dữ liệu 64-bit: Mọi biến tích lũy tổng (
sum,ans,cost) hoặc phép nhân chỉ số đã dùnglong long/longchưa.
Luyện ngay trên Big-O Coding
Kỹ thuật dùng hai con trỏ sửa mảng tại chỗ không vượt biên và quay lui có khôi phục trạng thái trên lưới 2 chiều là bài tập rèn tính cẩn thận tốt nhất; hãy thực hành ngay với 3 bài toán dưới đây trên Big-O Coding:
Trong Python kiểu int tự động mở rộng độ dài vô hạn (Arbitrary-precision), vậy lập trình viên Python có cần lo lắng về lỗi tràn số không?
Lập trình viên Python thoát được lỗi tràn số nguyên 32-bit trong các phép cộng và nhân thông thường, nhưng lại có 3 cái bẫy riêng của Python rất hay làm rớt phỏng vấn:
- Giá trị mặc định khả biến trong tham số hàm (
def dfs(u, vis=[]):): Danh sáchvismặc định chỉ được tạo đúng 1 lần khi định nghĩa hàm và bị dùng chung qua mọi lần gọi! Luôn phải viếtvis=None. - Nhân bản danh sách 2 chiều sai cách (
grid = [[0] * m] * n): Cách viết này tạo ra \(n\) tham chiếu cùng trỏ vào một hàng duy nhất, khiến việc gángrid[0][0] = 1làm toàn bộ cột đầu tiên của mọi hàng biến thành1! Phải viết[[0] * m for _ in range(n)]. - Giới hạn độ sâu đệ quy (
RecursionError): Mặc định Python chặn đệ quy ở độ sâu \(1{,}000\); cần chủ động nhắc người phỏng vấn vềsys.setrecursionlimit()hoặc chuyển sang khử đệ quy bằng ngăn xếp.
Làm sao tránh được lỗi vòng lặp vô hạn (Infinite Loop) khi cài đặt Tìm kiếm nhị phân?
Lỗi vòng lặp vô hạn trong Tìm kiếm nhị phân xảy ra khi đoạn tìm kiếm còn đúng 2 phần tử (right == left + 1), điểm giữa mid = left + (right - left) / 2 rơi trùng vào left, và nhánh cập nhật của bạn lại là left = mid (khiến [left, right] không thu hẹp lại chút nào!). Quy tắc vàng là: nếu trong thân vòng lặp có nhánh gán left = mid (không cộng 1), thì công thức tính mid bắt buộc phải làm tròn lên: mid = left + (right - left + 1) / 2.
Nếu đang chạy tay (Dry-run) mà phát hiện ra thuật toán của mình bị thiếu một trường hợp biên thì nên xử lý thế nào?
Hãy bình tĩnh chỉ rõ ngay cho người phỏng vấn thấy: "Khi chạy thử với mảng toàn số âm, em phát hiện biến max_sum khởi tạo bằng 0 sẽ trả về 0 thay vì số âm lớn nhất. Em sẽ sửa giá trị khởi tạo thành a[0] (hoặc INT_MIN) ở dòng 4." Việc bạn tự tìm ra lỗi thông qua Dry-run chính là minh chứng sống động nhất cho kỹ năng kiểm thử phần mềm chuyên nghiệp.
Luyện LeetCode thực chiến theo pattern, giải bài trong 45 phút và mock interview cùng AI. 16 buổi online, lớp 7–12 học viên, chọn C++, Java hoặc Python.


