- Không bao giờ gõ code ngay ở phút đầu tiên: Đề bài trong phỏng vấn trực tiếp thường được lược giản chủ đích để xem ứng viên có thói quen thu thập yêu cầu kỹ thuật (requirements gathering) trước khi thiết kế hay không.
- Khung phân bổ 45 phút gồm 5 pha rõ ràng: (1) Làm rõ đề và ràng buộc (\(0\text{--}5\) phút), (2) Đề xuất hướng giải từ cơ sở đến tối ưu và chốt độ phức tạp (\(5\text{--}12\) phút), (3) Viết mã nguồn có cấu trúc và giải thích theo khối ý nghĩa (\(12\text{--}30\) phút), (4) Chủ động chạy tay từng dòng với bộ dữ liệu nhỏ (\(30\text{--}38\) phút), (5) Tổng kết độ phức tạp và kiểm tra ca biên (\(38\text{--}45\) phút).
- Nói thành tiếng luồng suy nghĩ (Think Out Loud): Giao tiếp trong lúc code không phải là đọc to từng cú pháp
for (int i = 0...), mà là nêu mục đích bất biến của khối lệnh sắp viết và lý do chọn cấu trúc dữ liệu đó. - Chủ động tự tìm lỗi bằng bảng chạy tay (Dry Run): Phát hiện và tự sửa lỗi lệch chỉ số (off-by-one) hoặc ca biên trước khi người phỏng vấn phải nhắc là điểm cộng rất lớn về tính cẩn trọng kỹ thuật.
Bốn tiêu chí chấm điểm trong buổi phỏng vấn Live Coding
Theo trang Coding interview rubrics của Tech Interview Handbook (tổng hợp tiêu chí chấm của các công ty công nghệ lớn), phiếu đánh giá của người phỏng vấn sau buổi Live Coding thường xoay quanh bốn nhóm tín hiệu cụ thể (trang How We Hire của Google chỉ nói mọi ứng viên được chấm theo cùng một bộ tiêu chí rõ ràng và được hỏi câu hỏi mở về cách giải quyết vấn đề):
- Tư duy giải thuật và phân tích (Analytical & Problem Solving): Ứng viên có biết đặt câu hỏi làm rõ miền dữ liệu đầu vào không? Có nhận diện được giải pháp cơ sở (brute force), chỉ ra điểm nghẽn chi phí và dẫn dắt tự nhiên sang giải pháp tối ưu hơn kèm phân tích đánh đổi thời gian - bộ nhớ (time-space trade-off) hay không?
- Năng lực lập trình (Coding): Ứng viên có chuyển hóa được thuật toán đã thống nhất thành mã nguồn sạch, đặt tên biến rõ nghĩa, chia tách các bước logic mạch lạc và làm chủ thư viện chuẩn của ngôn ngữ đã chọn hay không?
- Kiểm thử và xác minh (Verification & Testing): Sau khi viết xong dòng code cuối, ứng viên có vội vàng tuyên bố "Đã xong" hay chủ động lấy một ví dụ cụ thể để chạy tay từng dòng (dry run), đồng thời kiểm tra các ca biên như mảng rỗng, số âm, số \(0\), tràn số nguyên?
- Giao tiếp kỹ thuật (Communication): Ứng viên có trình bày suy nghĩ rõ ràng, lắng nghe gợi ý của người phỏng vấn như một người đồng nghiệp đang cùng thiết kế hệ thống hay im lặng suốt 20 phút?
nums = [1, 2, 3, 4]).Khung 5 bước trình bày lời giải qua bài toán minh họa cụ thể
Để thấy cách áp dụng khung 5 bước một cách thực chất thay vì lý thuyết chung chung, ta đặt tình huống người phỏng vấn đưa ra đề bài kinh điển:
Đề bài: "Cho một mảng số nguyên
numsgồm \(n\) phần tử. Hãy trả về mảnganssao choans[i]bằng tích của tất cả các phần tử trongnumsngoại trừnums[i]."
Bước 1: Làm rõ đề bài và chốt các ràng buộc (Phút \(0 \to 5\))
Ngay khi nhận đề, đừng vội viết vòng lặp. Hãy dành \(3\text{--}5\) phút đầu tiên để xác nhận lại ví dụ và đặt \(3\text{--}4\) câu hỏi ngắn gọn làm rõ biên giới bài toán:
- Câu hỏi 1 (Về phép toán bị hạn chế): "Tôi có được phép tính tích toàn bộ mảng rồi chia cho từng phần tử
nums[i]không, hay đề bài yêu cầu không sử dụng phép chia?" \(\to\) Người phỏng vấn thường xác nhận: Không được dùng phép chia (/), và mảng có thể chứa số0. - Câu hỏi 2 (Về kích thước và miền giá trị): "Kích thước mảng \(n\) nằm trong khoảng nào và tích các phần tử có vượt quá giới hạn số nguyên 32-bit có dấu không?" \(\to\) Xác nhận \(2 \le n \le 10^5\), các phần tử từ \(-30\) đến \(30\), và tích mọi tiền tố/hậu tố đều vừa trong kiểu số nguyên chuẩn.
- Câu hỏi 3 (Về yêu cầu độ phức tạp): "Với \(n = 10^5\), mục tiêu của chúng ta là thời gian \(O(n)\), và liệu có yêu cầu tối ưu bộ nhớ phụ về \(O(1)\) (không tính mảng kết quả trả về) không?"
Bước 2: Trình bày hướng giải từ cơ sở đến tối ưu (Phút \(5 \to 12\))
Sau khi chốt xong ràng buộc, hãy tóm tắt nhanh lộ trình tối ưu trong \(3\text{--}5\) phút trước khi chạm vào bàn phím:
- Nêu nhanh giải pháp vét cạn (Baseline): Với mỗi vị trí \(i\), duyệt toàn bộ các chỉ số \(j \ne i\) để nhân dồn. Cách này tốn thời gian \(O(n^2)\) và với \(n = 10^5\) sẽ cần \(10^{10}\) phép nhân (quá chậm).
- Chỉ ra phép tính trùng lặp để dẫn sang \(O(n)\) thời gian: Nhận xét rằng tích mọi phần tử trừ
nums[i]chính là tích của hai nửa tách biệt quanh \(i\): \[\text{ans}[i] = \underbrace{\big(\text{nums}[0] \times \dots \times \text{nums}[i-1]\big)}_{\text{Tích tiền tố trước } i} \;\times\; \underbrace{\big(\text{nums}[i+1] \times \dots \times \text{nums}[n-1]\big)}_{\text{Tích hậu tố sau } i}\] Tương tự kỹ thuật mảng cộng dồn, nếu tạo hai mảng phụpref[n]vàsuff[n], ta tính xong trong \(O(n)\) thời gian nhưng tốn \(O(n)\) bộ nhớ phụ. - Đề xuất tối ưu bộ nhớ phụ xuống \(O(1)\): Thay vì cấp phát hai mảng
prefvàsuff, ta tận dụng ngay mảng kết quảans:- Lượt 1 (Trái sang phải): Ghi trực tiếp tích tiền tố của các phần tử đứng trước \(i\) vào
ans[i]. - Lượt 2 (Phải sang trái): Duy trì một biến đơn lẻ
suffix_prod = 1nhân dồn các phần tử từ cuối mảng về đầu, vừa đi vừa nhânans[i] *= suffix_prod.
- Lượt 1 (Trái sang phải): Ghi trực tiếp tích tiền tố của các phần tử đứng trước \(i\) vào
- Xin xác nhận trước khi code: "Cách tiếp cận 2 lượt quét đạt \(O(n)\) thời gian và \(O(1)\) bộ nhớ phụ. Bạn có đồng ý để tôi bắt đầu cài đặt phương án này không?"
| Bước tiến hóa tư duy | Độ phức tạp thời gian | Bộ nhớ phụ (ngoài mảng trả về) | Nhận xét của người phỏng vấn |
|---|---|---|---|
| 1. Hai vòng lặp lồng nhau | \(O(n^2)\) | \(O(1)\) | Chỉ chấp nhận làm điểm xuất phát (trong \(30\) giây đầu). |
2. Hai mảng pref[] và suff[] |
\(O(n)\) | \(O(n)\) | Giải pháp tốt, chứng minh hiểu rõ cấu trúc tiền tố - hậu tố. |
3. Tận dụng mảng ans[] + biến suffix |
\(O(n)\) | \(O(1)\) | Giải pháp điểm tối đa: tối ưu cả thời gian lẫn không gian. |
Bước 3: Viết mã nguồn sạch và thuyết minh theo khối (Phút \(12 \to 30\))
Khi viết code, hãy tuân thủ 3 nguyên tắc:
- Đặt tên biến phản ánh đúng vai trò (
prefix,suffix,ans) thay vìa,b,tmp1,tmp2. - Trước mỗi vòng lặp
for, nói một câu ngắn gọn về bất biến của vòng lặp đó (ví dụ: "Vòng lặp đầu tiên từ \(0\) đến \(n - 1\) sẽ gánans[i]bằng tích của các phần tử nằm bên trái chỉ số \(i\)"). - Không vừa gõ vừa đọc từng ký tự cú pháp (
"chấm phẩy, mở ngoặc nhọn"), mà giữ nhịp nói ở mức ý tưởng thiết kế.
Bước 4: Chủ động chạy tay (Dry Run) trên dữ liệu cụ thể (Phút \(30 \to 38\))
Đừng đợi người phỏng vấn hỏi "Bạn chắc code này đúng chứ?". Ngay khi gõ xong dấu đóng ngoặc cuối cùng, hãy viết một dòng chú thích bên dưới và chạy tay từng bước với nums = [1, 2, 3, 4] (\(n = 4\)):
| Pha thực thi | Chỉ số \(i\) | Giá trị nums[i] |
Biến tích lũy (prefix / suffix) trước khi cập nhật |
Giá trị ans[i] sau khi gán |
Mảng ans hiện tại |
Biến tích lũy sau khi nhân thêm nums[i] |
|---|---|---|---|---|---|---|
| Lượt 1 (Trái \(\to\) Phải) | \(i = 0\) | 1 |
prefix = 1 |
ans[0] = 1 |
[1, _, _, _] |
prefix = 1 * 1 = 1 |
| Lượt 1 (Trái \(\to\) Phải) | \(i = 1\) | 2 |
prefix = 1 |
ans[1] = 1 |
[1, 1, _, _] |
prefix = 1 * 2 = 2 |
| Lượt 1 (Trái \(\to\) Phải) | \(i = 2\) | 3 |
prefix = 2 |
ans[2] = 2 |
[1, 1, 2, _] |
prefix = 2 * 3 = 6 |
| Lượt 1 (Trái \(\to\) Phải) | \(i = 3\) | 4 |
prefix = 6 |
ans[3] = 6 |
[1, 1, 2, 6] |
prefix = 6 * 4 = 24 |
| Lượt 2 (Phải \(\to\) Trái) | \(i = 3\) | 4 |
suffix = 1 |
ans[3] = 6 * 1 = 6 |
[1, 1, 2, 6] |
suffix = 1 * 4 = 4 |
| Lượt 2 (Phải \(\to\) Trái) | \(i = 2\) | 3 |
suffix = 4 |
ans[2] = 2 * 4 = 8 |
[1, 1, 8, 6] |
suffix = 4 * 3 = 12 |
| Lượt 2 (Phải \(\to\) Trái) | \(i = 1\) | 2 |
suffix = 12 |
ans[1] = 1 * 12 = 12 |
[1, 12, 8, 6] |
suffix = 12 * 2 = 24 |
| Lượt 2 (Phải \(\to\) Trái) | \(i = 0\) | 1 |
suffix = 24 |
ans[0] = 1 * 24 = 24 |
[24, 12, 8, 6] |
suffix = 24 * 1 = 24 |
Bước 5: Chốt độ phức tạp và kiểm tra ca biên (Phút \(38 \to 45\))
Kết thúc phần chạy tay, hãy chủ động điểm qua các ca biên mà thuật toán đã xử lý trọn vẹn:
- Ca có đúng 1 số
0(ví dụ[-1, 1, 0, -3, 3]): Mọi vị trí khác vị trí số0đều có tích tiền tố hoặc tích hậu tố chứa thừa số0nên nhận giá trị0; riêng vị trí của số0nhận đúng tích của các số khác0là(-1) * 1 * (-3) * 3 = 9\(\implies\)[0, 0, 9, 0, 0]. - Ca có từ 2 số
0trở lên (ví dụ[0, 4, 0]): Toàn bộ mảng kết quả đều bằng[0, 0, 0]mà không hề xảy ra lỗi chia cho0(ZeroDivisionError).
Cài đặt mẫu chuẩn mực bằng C++17, Python và Java 21
Đoạn mã dưới đây thể hiện đúng phong cách viết code sạch trong phỏng vấn cho bài toán Product of Array Except Self: tên biến rõ ràng, tách bạch hai lượt quét tiền tố và hậu tố, đạt \(O(n)\) thời gian và \(O(1)\) bộ nhớ phụ.
#include <iostream>
#include <vector>
using namespace std;
vector<long long> product_except_self(const vector<long long>& nums) {
int n = (int)nums.size();
vector<long long> ans(n, 1);
long long prefix = 1;
for (int i = 0; i < n; i++) {
ans[i] = prefix;
prefix *= nums[i];
}
long long suffix = 1;
for (int i = n - 1; i >= 0; i--) {
ans[i] *= suffix;
suffix *= nums[i];
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
vector<long long> nums;
if (!(cin >> n)) {
nums = {1, 2, 3, 4};
} else {
nums.resize(n);
for (int i = 0; i < n; i++) cin >> nums[i];
}
vector<long long> ans = product_except_self(nums);
for (size_t i = 0; i < ans.size(); i++) {
if (i) cout << " ";
cout << ans[i];
}
cout << "\n";
return 0;
}
import sys
def product_except_self(nums: list[int]) -> list[int]:
n = len(nums)
ans = [1] * n
prefix = 1
for i in range(n):
ans[i] = prefix
prefix *= nums[i]
suffix = 1
for i in range(n - 1, -1, -1):
ans[i] *= suffix
suffix *= nums[i]
return ans
def main():
tokens = sys.stdin.read().split()
if not tokens:
nums = [1, 2, 3, 4]
else:
n = int(tokens[0])
nums = [int(x) for x in tokens[1:1 + n]]
print(" ".join(str(x) for x in product_except_self(nums)))
if __name__ == "__main__":
main()
import java.util.*;
public class Main {
public static long[] productExceptSelf(long[] nums) {
int n = nums.length;
long[] ans = new long[n];
long prefix = 1;
for (int i = 0; i < n; i++) {
ans[i] = prefix;
prefix *= nums[i];
}
long suffix = 1;
for (int i = n - 1; i >= 0; i--) {
ans[i] *= suffix;
suffix *= nums[i];
}
return ans;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
long[] nums;
if (!sc.hasNextInt()) {
nums = new long[]{1, 2, 3, 4};
} else {
int n = sc.nextInt();
nums = new long[n];
for (int i = 0; i < n; i++) nums[i] = sc.nextLong();
}
long[] ans = productExceptSelf(nums);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < ans.length; i++) {
if (i > 0) sb.append(" ");
sb.append(ans[i]);
}
System.out.println(sb);
}
}
Các lỗi giao tiếp thường gặp và cách tự rèn luyện
- Chạy tay theo kiểu "nghĩ gì trong đầu điền nấy" thay vì đọc đúng code đã viết: Nhiều ứng viên khi chạy tay ở Bước 4 lại nhẩm theo ý tưởng trong đầu và viết ra kết quả đúng, trong khi trên màn hình dòng code viết nhầm
i >= 1thay vìi >= 0! Khi chạy tay, hãy đóng vai một trình thông dịch máy móc: nhìn chính xác điều kiện dừng và thứ tự hai câu lệnhans[i] *= suffix;vàsuffix *= nums[i];trên màn hình. - Bỏ qua gợi ý của người phỏng vấn: Khi người phỏng vấn hỏi "Điều gì xảy ra tại
i = 0nếu mảng có số âm?", đó gần như luôn là một gợi ý hướng bạn tới một lỗi logic hoặc một ca biên chưa xử lý. Hãy dừng lại ngay, kiểm tra đúng trường hợp người phỏng vấn vừa nêu thay vì bảo vệ quan điểm một cách vội vàng. - Cách tự rèn luyện tại nhà: Khi giải bất kỳ bài toán nào trên máy cá nhân, bạn hãy bấm đồng hồ 30 phút và mở một khung soạn thảo văn bản: tự gõ ra \(3\) câu hỏi làm rõ đề, \(2\) dòng so sánh độ phức tạp giữa cách ngây thơ và cách tối ưu, viết code không dùng tính năng tự động hoàn thành (autocomplete), rồi tự lập bảng chạy tay trên một bộ dữ liệu \(4\text{--}5\) phần tử trước khi bấm nút biên dịch lần đầu tiên.
Luyện ngay trên Big-O Coding
Để áp dụng ngay khung 5 bước trình bày Live Coding trên các bài toán mảng tiền tố và ngăn xếp thường gặp nhất trong vòng phỏng vấn kỹ thuật, bạn hãy thực hành trực tiếp bộ ba bài toán dưới đây trong lộ trình Coding Interview 150:
Nên làm gì nếu sau 5 phút suy nghĩ vẫn chưa tìm ra thuật toán tối ưu \(O(n)\)?
Tuyệt đối không ngồi im lặng nhìn màn hình. Hãy chủ động trình bày ngay giải pháp cơ sở (Brute Force) kèm độ phức tạp của nó (ví dụ \(O(n^2)\)), sau đó thử chạy tay giải pháp cơ sở trên một ví dụ nhỏ \(4\text{--}5\) phần tử ngay trên bảng nháp và chỉ ra chỗ nào đang phải tính đi tính lại cùng một phép toán. Việc nói rõ điểm nghẽn (bottleneck) của giải pháp cơ sở vừa giúp bạn tự bật ra hướng dùng bảng băm / mảng tiền tố / hai con trỏ, vừa giúp người phỏng vấn biết chính xác bạn đang ở đâu để đưa ra gợi ý đúng lúc.
Có nên viết các hàm phụ (Helper Functions) trong buổi phỏng vấn chỉ kéo dài 45 phút không?
Rất nên! Khi thuật toán có một thao tác lặp lại hoặc một khối logic độc lập (chẳng hạn hàm detach(node) và attach_front(node) trong bài Thiết kế LRU Cache, hoặc hàm isValid(mid) trong tìm kiếm nhị phân trên đáp án), việc tách hàm phụ với tên gọi rõ nghĩa giúp hàm chính ngắn gọn chỉ còn \(10\text{--}15\) dòng. Hơn nữa, nếu hết giờ mà chưa kịp viết chi tiết một hàm phụ đơn giản, người phỏng vấn vẫn thấy trọn vẹn cấu trúc thuật toán chính của bạn.
Khi phát hiện ra lỗi trong lúc đang chạy tay (Dry Run), ứng viên có bị trừ điểm không?
Ngược lại, việc bạn tự phát hiện ra lỗi nhờ bước chạy tay chủ động và giải thích rõ nguyên nhân lỗi trước khi sửa (ví dụ: "Ở vòng lặp ngược tôi đang nhân suffix *= nums[i] trước khi nhân vào ans[i], làm ans[i] bị nhân thừa chính nums[i]; tôi cần đảo thứ tự hai dòng này") được đánh giá rất cao ở tiêu chí Kiểm thử & Xác minh (Verification). Trong thực tế sản xuất phần mềm, không ai viết code phức tạp mà không bao giờ có lỗi ở bản nháp đầu tiên; khả năng tự rà soát và bắt lỗi trước khi đưa code vào chạy mới là kỹ năng phân biệt kỹ sư vững vàng.
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.


