Phỏng vấn

Tổng hợp lỗi code hay mắc khi phỏng vấn trực tuyến: 5 cái bẫy làm rớt oan và Checklist Dry-run

Trong môi trường phỏng vấn trực tuyến trên CoderPad, HackerRank hay Google Docs, bạn không có sự trợ giúp của trình gỡ lỗi từng dòng (Debugger) hay gợi ý cú pháp thông minh từ IDE. Rất nhiều ứng viên tìm ra thuật toán tối ưu chỉ trong 10 phút đầu nhưng lại đánh rơi tấm vé đi tiếp vì những lỗi cài đặt kinh điển như tràn số nguyên 32-bit, truy cập vượt biên mảng hay quên khôi phục trạng thái đệ quy.

Ý chính
  • 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ước a[i + 1], dùng l + (r - l) / 2 và ép kiểu 1LL cho 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:

  1. 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() vs length vs len()).
  2. 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 (IndexOutOfBoundsException hay AddressSanitizer: heap-buffer-overflow).
  3. 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ếu low + high > INT_MAX. Hãy luôn viết int 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ạng a[i] đều là kiểu int, 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ến long 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àm Comparator củ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ùng Integer.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++;
}
5 Lỗi Code Kinh Điển Làm Mất Điểm Trong Phỏng vấn Trực tuyến & Cách Phòng Tránh Danh sách kiểm tra (Dry-Run Checklist) trong 3 phút cuối trước khi nói "Em đã hoàn thành" Mẫu code chứa 3 bẫy ngầm thường gặp // LỖI 1: Tràn số 32-bit khi nhân / cộng int mid = (l + r) / 2; int prod = a[i] * a[i]; // a[i] = 10^5! // LỖI 2: Quên kiểm tra chỉ số biên while (a[l] == a[l + 1]) l++; // l+1 == N! // LỖI 3: Không khôi phục trạng thái lui vis[u] = true; dfs(v); // thiếu vis[u]=false Bản sửa an toàn chuẩn Production // SỬA 1: Chống tràn mid và ép kiểu 64-bit int mid = l + (r - l) / 2; long long prod = 1LL * a[i] * a[i]; // SỬA 2: Đặt điều kiện biên l + 1 < n trước while (l + 1 < n && a[l] == a[l + 1]) l++; // SỬA 3: Đối xứng đánh dấu và tháo dấu vis[u] = true; dfs(v); vis[u] = false;
Checklist Săn Bug Trước Khi Nộp 3 cặp lỗi sai vs cách sửa an toàn 1. Tràn số nguyên 32-bit (Overflow) Sai : int s = a * b; mid = (l + r) / 2; Đúng: long long s = 1LL * a * b; int mid = l + (r - l) / 2; 2. Lệch 1 đơn vị & Vượt biên (Off-by-one) Sai : while (a[i] == a[i+1]) i++; Đúng: while (i + 1 < n && a[i] == a[i+1]) 3. Bộ 4 Test Biên Dry-run Bắt Buộc • Mảng 1 phần tử (N = 1) và 2 phần tử • Toàn bộ phần tử trùng nhau hoặc âm • Giá trị cực đại (10^9) kiểm tra 64-bit
Hình 1: Đối chiếu trực tiếp các đoạn code chứa 3 bẫy ngầm (tràn số 32-bit, vượt biên mảng, quên tháo dấu đệ quy) với bản sửa an toàn chuẩn Production.

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:

  1. Nếu chỉ duyệt for (int i = 0; i < n - 1; ++i) và gom khi a[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ố âm n - 1 = -1 khi mảng rỗng! Cách viết chuẩn nhất bằng Hai con trỏ (Slow-Fast Pointers) là giữ con trỏ ghi write_idx = 1 và duyệt read_idx từ \(1\) đến \(N - 1\): mỗi khi a[read_idx] != a[write_idx - 1] thì ghi a[write_idx++] = a[read_idx].
  2. 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ểu int 32-bit (\(2.14 \times 10^9\)), nên bắt buộc phải tính trên số nguyên 64-bit (long long trong C++, long trong 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;
}

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:

  1. Đọ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=0 ngay 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.
  2. Kiểm tra dòng khởi tạo và dòng trả về: Biến đếm đã khởi tạo bằng 0 chưa? Biến tìm giá trị nhỏ nhất đã khởi tạo bằng INF (chứ không phải 0) 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?
  3. 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 Loop khi left và right không tiến lại gần nhau) hay truy cập a[1] khi mảng chỉ có a[0] không.
  4. 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ùng long long / long chư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:

  1. Giá trị mặc định khả biến trong tham số hàm (def dfs(u, vis=[]):): Danh sách vis mặ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ết vis=None.
  2. 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án grid[0][0] = 1 làm toàn bộ cột đầu tiên của mọi hàng biến thành 1! Phải viết [[0] * m for _ in range(n)].
  3. 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.

Muốn học bài bản cùng giảng viên?

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.

Xem Khóa LeetCode

Nguồn tham khảo

Chia sẻ: Facebook LinkedIn
Nhắn Zalo tư vấnZalo Gọi 0937 401 483