- Câu "giải thích code này" thường cho bản kể lại từng dòng. Hỏi mục đích, bảng truy vết trên dữ liệu cụ thể và vai trò của đúng dòng bạn vướng thì mới nhận được điều kiểm được.
- Câu hỏi đáng giá nhất: bỏ hoặc đổi dòng này thì đầu vào nào cho kết quả sai? Phản ví dụ là thứ bạn tự chạy được.
- Lời giải thích của AI là dự đoán về code, không phải kết quả chạy. In giá trị biến, chạy phản ví dụ, so với cách vét cạn trên mảng nhỏ.
- Hiểu thật là đóng cuộc trò chuyện lại mà vẫn tự giải thích được, và làm được một biến thể nhỏ.
Code trong bài là Python, chỉ dùng thư viện chuẩn. Lời giải mẫu và các câu trả lời của AI là minh họa do bài tự viết. Bài học lập trình với AI đã nêu ý chung là xin bảng truy vết thay vì hỏi "giải thích code"; bài này đi sâu vào cách hỏi và cách chạy để kiểm cho một đoạn code cụ thể.
Vì sao "giải thích code này" chưa đủ
Khi nhận một đoạn code kèm câu "giải thích code này", mô hình thường đi từ trên xuống: dòng này tạo biến, dòng kia chạy vòng lặp, dòng cuối trả kết quả. Câu nào cũng đúng, nhưng đó là đọc lại cú pháp, việc bạn tự làm được. Thứ bạn thiếu là lý do: biến này đại diện cho cái gì, dòng này ngăn lỗi nào, bỏ nó đi thì chuyện gì xảy ra.
Còn một vấn đề nữa. Bản kể lại từng dòng trông giống hệt nhau dù code đúng hay sai, vì nó chỉ thuật lại những gì có trên trang. Và trừ khi công cụ thật sự chạy code rồi cho bạn xem đầu ra, mô hình đang dự đoán code sẽ làm gì, chứ không quan sát việc code làm.
Cách khắc phục là hỏi những câu có đáp án kiểm được:
- mục đích của hàm trong một câu, và mỗi biến đại diện cho cái gì;
- bảng giá trị của các biến sau mỗi vòng lặp, trên một đầu vào nhỏ do bạn chọn;
- vai trò của dòng bạn vướng, kèm một phản ví dụ: một đầu vào cụ thể cho kết quả sai khi bỏ dòng đó;
- dự đoán cho vài ca biên.
Mỗi thứ trong danh sách này đều đem đi chạy được. Phần còn lại của bài đi qua từng thứ trên một ví dụ thật.
Ví dụ: một dòng khó hiểu trong lời giải mẫu
Đề bài: cho mảng số nguyên a, có thể có số âm, và một số k; đếm số đoạn con liên tiếp có tổng bằng k. Với a = [1, 2, 3] và k = 3 có hai đoạn là [1, 2] và [3]. Lời giải mẫu như sau:
def dem_doan_con(a, k):
"""Đếm số đoạn con liên tiếp của a có tổng bằng k."""
dem = {0: 1}
tong = 0
kq = 0
for x in a:
tong += x
kq += dem.get(tong - k, 0)
dem[tong] = dem.get(tong, 0) + 1
return kq
print(dem_doan_con([1, 2, 3], 3)) # 2: hai đoạn [1, 2] và [3]
print(dem_doan_con([1, -1, 1, 1], 1)) # 5
Giả sử bạn đã quen vòng lặp và từ điển, nhưng còn hai chỗ chưa rõ: vì sao dem bắt đầu bằng {0: 1} chứ không rỗng, và vì sao dòng cộng vào kq phải đứng trước dòng cập nhật dem. Đây đúng là kiểu câu hỏi nên mang đi hỏi AI, vì bạn biết chính xác mình vướng ở đâu.
Câu hỏi yếu và câu hỏi tốt
Câu hỏi yếu là dán code rồi gõ "giải thích code này". Một câu trả lời điển hình, do bài viết lại để minh họa:
Hàm nhận mảng a và số k. Dòng đầu tạo từ điển dem với khóa 0, giá trị 1. Biến tong lưu tổng, kq lưu kết quả. Trong vòng lặp, cộng x vào tong, cộng dem.get(tong - k, 0) vào kq, rồi tăng dem[tong] thêm 1. Cuối cùng trả về kq.
Không câu nào sai, và bạn vẫn không biết vì sao lại có {0: 1}.
Câu hỏi tốt nói rõ bạn đang ở đâu và muốn nhận lại những gì:
Mình học Python được vài tháng, biết vòng lặp và từ điển, chưa học kỹ thuật tổng tiền tố.
Đây là lời giải mẫu cho bài: đếm số đoạn con liên tiếp có tổng bằng k, mảng có thể có số âm.
[dán code]
Đừng viết lại code. Làm lần lượt từng phần, xong mỗi phần thì dừng để mình đoán trước phần sau.
1. Mục đích của hàm trong một câu; tong, dem, kq lần lượt đại diện cho cái gì.
2. Bảng truy vết với a = [1, 2, 3], k = 3: mỗi vòng một hàng gồm x, tong, tong - k, dem.get(tong - k, 0), kq.
3. Dòng dem = {0: 1} để làm gì? Cho một mảng nhỏ mà nếu đổi thành dem = {} thì kết quả sai, kèm kết quả đúng và kết quả sai.
4. Nếu đổi chỗ hai dòng cuối trong vòng lặp thì có sai không? Nếu có, cho một đầu vào làm sai.
Dòng đầu cho AI biết nên giải thích ở mức nào: không giảng lại vòng lặp, cũng không nhảy vào thuật ngữ bạn chưa học. Câu "đừng viết lại code" giữ cuộc trò chuyện ở việc hiểu, thay vì nhận một bản code khác cũng khó hiểu như vậy. Yêu cầu dừng sau mỗi phần biến lời giải thích thành bài tập nhỏ: bạn đoán trước, rồi mới so. Phần 2 và phần 3 cho ra những con số chạy lại được, đó là chỗ bạn sẽ kiểm.
Tóm lại một câu trả lời tốt, cũng do bài viết để minh họa: tong là tổng tiền tố, tức tổng của đoạn đầu mảng tính tới phần tử đang xét. dem[t] đếm đã gặp bao nhiêu đoạn đầu mảng có tổng bằng t. Một đoạn kết thúc ở vị trí hiện tại có tổng bằng k khi phần đầu mảng nằm trước nó có tổng bằng tong - k, nên dem.get(tong - k, 0) chính là số đoạn có tổng k kết thúc ở đây. Còn {0: 1} đại diện cho đoạn đầu rỗng, chưa lấy phần tử nào, tổng bằng 0: nhờ nó mà các đoạn bắt đầu ngay từ đầu mảng được đếm. Phản ví dụ: a = [2], k = 2 có một đoạn là [2], nhưng bỏ {0: 1} thì hàm trả 0.
Với phần 4, mô hình có thể khẳng định chắc nịch rằng đổi chỗ "sẽ đếm sai". Đừng vội tin hay vội bác: xin phản ví dụ và chạy. Phần sau cho thấy câu đó chỉ đúng một nửa.
Nếu bạn dùng trợ lý ngay trong trình soạn thảo, Copilot Chat có lệnh /explain (trong VS Code, Visual Studio và JetBrains) để giải thích code đang mở. Lệnh này tiện, nhưng bản chất vẫn là câu hỏi chung chung; hãy viết thêm các yêu cầu như trên ngay sau nó. Học sinh, sinh viên đã xác minh qua GitHub Education dùng được Copilot miễn phí với gói Copilot Student; cách nhận có trong bài GitHub Copilot cho sinh viên.
Chạy code để kiểm lời giải thích
Đoạn code dưới đây in bảng truy vết của lời giải mẫu, rồi chạy ba ca: một phản ví dụ cho dòng {0: 1} và hai ca cho việc đổi chỗ hai dòng. Hàm vet_can thử mọi đoạn con; nó chậm nhưng dễ tin, nên dùng làm đáp án.
# In bảng truy vết của lời giải mẫu và chạy các phản ví dụ AI đưa ra.
COT = '{:>2} {:>5} {:>7} {:>16} {:>4}'
def truy_vet(a, k):
"""Chạy đúng lời giải mẫu, in mỗi vòng lặp một hàng."""
dem = {0: 1}
tong = kq = 0
print(COT.format('x', 'tong', 'tong-k', 'dem.get(tong-k)', 'kq'))
for x in a:
tong += x
da_gap = dem.get(tong - k, 0)
kq += da_gap
dem[tong] = dem.get(tong, 0) + 1
print(COT.format(x, tong, tong - k, da_gap, kq))
return kq
def ban_bo_khoi_dau(a, k):
"""Giống lời giải mẫu, chỉ khác một chỗ: dem bắt đầu rỗng."""
dem = {}
tong = kq = 0
for x in a:
tong += x
kq += dem.get(tong - k, 0)
dem[tong] = dem.get(tong, 0) + 1
return kq
def ban_doi_cho(a, k):
"""Giống lời giải mẫu, chỉ khác một chỗ: cập nhật dem trước rồi mới cộng vào kq."""
dem = {0: 1}
tong = kq = 0
for x in a:
tong += x
dem[tong] = dem.get(tong, 0) + 1
kq += dem.get(tong - k, 0)
return kq
def vet_can(a, k):
"""Thử mọi đoạn con: chậm, nhưng dễ tin, dùng làm đáp án trên mảng nhỏ."""
n = len(a)
return sum(1 for i in range(n) for j in range(i, n) if sum(a[i:j + 1]) == k)
truy_vet([1, 2, 3], 3)
print('Bỏ {0: 1}, a = [2], k = 2:', ban_bo_khoi_dau([2], 2), '| vét cạn:', vet_can([2], 2))
print('Đổi chỗ, a = [1, 2, 3], k = 3:', ban_doi_cho([1, 2, 3], 3), '| vét cạn:', vet_can([1, 2, 3], 3))
print('Đổi chỗ, a = [1], k = 0:', ban_doi_cho([1], 0), '| vét cạn:', vet_can([1], 0))
Kết quả chạy:
x tong tong-k dem.get(tong-k) kq
1 1 -2 0 0
2 3 0 1 1
3 6 3 1 2
Bỏ {0: 1}, a = [2], k = 2: 0 | vét cạn: 1
Đổi chỗ, a = [1, 2, 3], k = 3: 2 | vét cạn: 2
Đổi chỗ, a = [1], k = 0: 1 | vét cạn: 0
Hàng thứ hai của bảng là nơi {0: 1} làm việc: tong = 3, tong - k = 0, và dem[0] bằng 1 nhờ giá trị khởi đầu, nên đoạn [1, 2] được đếm. Hãy so bảng AI đưa với bảng này từng hàng một. Hàng đầu tiên lệch nhau cho biết chỗ mà AI, hoặc chính bạn, đã hiểu sai.
Phản ví dụ cho dòng {0: 1} đúng như AI nói: bỏ dòng đó thì [2] với k = 2 cho 0 thay vì 1.
Phản ví dụ cho việc đổi chỗ thì thú vị hơn. Với a = [1, 2, 3], k = 3, bản đổi chỗ vẫn ra 2, đúng. Lý do: khi k khác 0 thì tong - k khác tong, nên cập nhật dem[tong] trước không ảnh hưởng tới lần tra dem[tong - k]. Chỉ khi k = 0, bản đổi chỗ đếm thêm một "đoạn rỗng" kết thúc ở vị trí hiện tại: a = [1], k = 0 ra 1, trong khi không có đoạn nào có tổng bằng 0. Câu "đổi chỗ sẽ sai" vì vậy chỉ đúng một nửa, và chỉ việc chạy mới cho bạn biết nửa nào.
Hai cách kiểm khác nên biết:
- Xem từng bước bằng Python Tutor. Trang này cho bạn viết code ngay trên trình duyệt và xem chương trình chạy từng bước, với giá trị biến, đối tượng và các khung gọi hàm. Nó hỗ trợ Python, Java, C, C++ và JavaScript. Trình soạn thảo của bạn cũng có trình gỡ lỗi để chạy từng dòng.
- So với cách vét cạn trên nhiều mảng nhỏ ngẫu nhiên. Cách làm có trong bài kiểm chứng việc AI làm.
Hỏi ca biên và độ phức tạp, rồi tự chạy thử
Hiểu ý chính rồi, hãy nhờ AI dự đoán vài ca biên trước khi bạn chạy:
arỗng: không có đoạn nào, kết quả 0.a = [0, 0],k = 0: ba đoạn, là số 0 thứ nhất, số 0 thứ hai và cả[0, 0]. Ca này cho thấydemcủa một tổng có thể lớn hơn 1.a = [1, -1, 1, 1],k = 1: năm đoạn. Vì có số âm, tổng của đoạn không tăng dần khi đoạn dài ra; đó là lý do kỹ thuật cửa sổ trượt không dùng được ở bài này, còn tổng tiền tố cộng từ điển thì được.
So từng dự đoán với kết quả chạy thật. Dự đoán nào lệch thì hỏi lại đúng chỗ lệch.
Về độ phức tạp, câu trả lời bạn nên nhận được kèm lý do: mỗi phần tử được xử lý một lần, mỗi lần tra và cập nhật từ điển trung bình tốn O(1), nên cả hàm chạy O(n) trung bình và dùng O(n) bộ nhớ. Hàm vet_can thì tốn O(n³), vì ngoài hai vòng lặp chọn đầu và cuối đoạn, nó còn cộng lại từng đoạn. Đừng nhận một ký hiệu độ phức tạp không có lý do đi kèm.
Khi đoạn code bạn đưa đang sai
Thử đưa cho AI bản dem = {} và chỉ hỏi "giải thích code này". Một lời giải thích kiểu kể lại từng dòng vẫn sẽ nói rằng hàm đếm số đoạn con có tổng bằng k, vì tên hàm, tên biến và cấu trúc đều gợi ý như vậy. Lời giải thích dựa trên ý định mà code thể hiện ra, không dựa trên việc code thật sự làm. Đây là lý do một lời giải thích nghe hợp lý chưa bao giờ là bằng chứng code đúng.
Hai thói quen giúp tránh bẫy này:
- Nói rõ nguồn gốc của code. "Đoạn này mình chép từ một bài đăng, có thể sai" khiến câu trả lời đi tìm lỗi thay vì chỉ thuật lại. Tốt hơn nữa là hỏi thẳng: "code này có thể cho kết quả sai với đầu vào nào?"
- Luôn có một phép thử không phụ thuộc vào lời giải thích: bảng truy vết do máy in ra, phản ví dụ chạy thật, hoặc so với cách vét cạn.
Code của chính bạn cũng vậy. Nhờ AI giải thích lời giải bạn vừa nộp là cách hay để thấy chỗ bạn làm đúng mà chưa hiểu vì sao đúng.
Đóng cuộc trò chuyện, tự giải thích lại
Bước kiểm cuối cùng là chính bạn. Đóng cửa sổ chat và viết ra năm điều: mục đích của hàm; tong và dem đại diện cho cái gì; vì sao cần {0: 1}; vì sao thứ tự hai dòng chỉ quan trọng khi k = 0; độ phức tạp và lý do.
Rồi làm một biến thể nhỏ mà không hỏi lại: đếm số đoạn con có tổng chia hết cho m. Gợi ý: hai tổng tiền tố có cùng số dư khi chia cho m thì đoạn nằm giữa chúng có tổng chia hết cho m. Với a = [3, 1, 2, 4] và m = 3, đáp số là 4: các đoạn [3], [1, 2], [3, 1, 2] và [2, 4]. Viết được và ra đúng 4 nghĩa là bạn đã nắm ý tưởng, không chỉ nhớ một lời giải.
Nếu chưa làm được, đừng xin thêm một bản giải thích dài hơn. Quay lại đúng chỗ còn mờ, thường là câu "dem[t] đếm cái gì", và tự truy vết thêm một mảng khác.
Luyện ngay trên Big-O Coding
Ba bài dưới đây dùng đúng ý tưởng tổng tiền tố cộng từ điển trong bài, cả ba là bài Premium. Giải xong, nhờ AI giải thích lời giải của chính bạn theo bốn câu hỏi ở trên, rồi chạy để kiểm từng câu trả lời.
- Hỏi "giải thích code này", đọc bản kể lại từng dòng rồi tưởng mình đã hiểu.
- Không nói mình đang ở trình độ nào, nên nhận lời giải thích quá sâu hoặc quá nông.
- Tin một khẳng định về hành vi của code mà không chạy phản ví dụ.
- Để AI viết lại cả hàm trong khi bạn chỉ cần hiểu một dòng.
- Nhận ký hiệu độ phức tạp không kèm lý do.
- Dán vào chatbot đoạn code có khóa API, mật khẩu hay dữ liệu thật.
Câu hỏi thường gặp
Nhờ ChatGPT giải thích code có chính xác không?
Thường đúng với đoạn code ngắn, nhưng lời giải thích là dự đoán. Kiểm bằng bảng truy vết chạy thật và phản ví dụ.
Nên hỏi AI thế nào để hiểu một đoạn code?
Nói trình độ của bạn, xin mục đích, bảng truy vết trên một đầu vào nhỏ, vai trò của dòng khó kèm phản ví dụ, và dặn AI đừng viết lại code.
Có công cụ nào cho xem code chạy từng bước không?
Có. Python Tutor chạy trên trình duyệt và cho xem từng bước với giá trị biến; trình soạn thảo cũng có trình gỡ lỗi.
Làm sao biết mình đã hiểu một đoạn code?
Tự giải thích lại mà không nhìn, dự đoán đúng kết quả với đầu vào mới, và viết được một biến thể nhỏ.
Học tiếp
- Đọc cả một kho mã lạ thay vì một đoạn: dùng AI đọc hiểu một kho mã lớn.
- Code chạy sai và cần tìm nguyên nhân: debug với AI.
- Thói quen học lập trình mà không phụ thuộc AI: học lập trình với AI.
Nếu bạn muốn học Python và AI bài bản cùng giảng viên, tham khảo khóa học AI của Big-O Coding.
Khóa AI – Introduction to Machine Learning: nền tảng Máy học từ thuật toán cơ bản đến Neural Networks và LLM, học bằng Python. Học thử buổi 1 miễn phí.


