Kiểm tra chuỗi a-z (Pangram) bằng Python: 2 Cách Tối Ưu

Bài toán kiểm tra xem một câu có chứa đầy đủ 26 chữ cái tiếng Anh hay không (còn gọi là Pangram) là một bài tập nền tảng tuyệt vời cho sinh viên năm nhất. Qua bài này, bạn không chỉ học cách xử lý chuỗi cơ bản mà còn làm quen với các cấu trúc dữ liệu tối ưu như Set và Generator trong Python.

💡 Trả lời nhanh: Để kiểm tra chuỗi chứa tất cả ký tự từ a đến z, cách nhanh và chuẩn nhất trong Python là sử dụng cấu trúc tập hợp (Set): set(string.ascii_lowercase).issubset(set(text.lower())). Cách này chạy với độ phức tạp O(N) và code cực kỳ ngắn gọn.

Đề bài 

Bạn được cung cấp một chuỗi ký tự (string) bất kỳ. Hãy viết một hàm kiểm tra xem chuỗi đó có chứa ít nhất một lần tất cả 26 chữ cái tiếng Anh từ ‘a’ đến ‘z’ hay không. Nếu có, trả về True, ngược lại trả về False.

Input: Một chuỗi s có độ dài bất kỳ, có thể chứa chữ hoa, chữ thường, chữ số, khoảng trắng và các ký tự đặc biệt.

Output: Giá trị boolean (True hoặc False).

Ràng buộc: – Không phân biệt chữ hoa và chữ thường (ví dụ ‘A’ và ‘a’ được tính là một).

• Bỏ qua toàn bộ các ký tự không phải là chữ cái tiếng Anh (như dấu câu, số, khoảng trắng).

• Mã nguồn phải tối ưu về mặt thời gian thực thi cho các chuỗi đầu vào rất dài.

Phân tích bài toán kiểm tra chuỗi 

Bài toán kiểm tra chuỗi có chứa tất cả ký tự a-z (hay còn gọi là bài toán Pangram) trong Python yêu cầu xác định xem 26 chữ cái tiếng Anh có xuất hiện ít nhất một lần trong chuỗi đầu vào hay không, bất kể chữ hoa hay chữ thường. Đây là dạng bài kiểm tra kỹ năng chuẩn hóa dữ liệu và vận dụng cấu trúc lưu trữ của người học lập trình.

Trong quá trình xử lý, dữ liệu đầu vào thường rất lộn xộn. Bạn sẽ gặp câu có cả chữ hoa lẫn chữ thường (như “The Quick Brown Fox…”), hoặc có chứa vô số dấu phẩy, dấu chấm than. Do đó, bước cốt lõi đầu tiên luôn là “chuẩn hóa”: biến mọi thứ thành chữ thường (lowercase) để dễ so sánh. Hệ thống máy tính coi ký tự ‘A’ (mã ASCII 65) và ‘a’ (mã ASCII 97) là hai giá trị hoàn toàn khác biệt. Nếu không chuẩn hóa, thuật toán của bạn sẽ đếm sót ký tự.

📌 Góc nhìn thực tế: Trong thực tế đi dạy, tôi thấy 90% sinh viên năm nhất khi làm bài này thường mắc lỗi cố gắng dùng vòng lặp for lồng nhau để đếm từng chữ cái một cách thủ công. Cách đó không sai về kết quả, nhưng biến code thành một mớ bòng bong O(N^2) và chạy rất chậm khi chuỗi dài hàng triệu ký tự.

Giả định của chúng ta

Trong bài viết này, chúng ta giả định hệ thống chỉ yêu cầu kiểm tra bảng chữ cái tiếng Anh chuẩn (26 ký tự ASCII). Nếu bài toán mở rộng ra các ngôn ngữ có dấu như tiếng Việt, ta sẽ phải dùng unicodedata để chuẩn hóa unicode, nhưng với phạm vi bảng chữ cái a-z, các phương thức built-in của chuỗi là đủ.

Chính vì những đặc điểm trên, tôi sẽ hướng dẫn bạn hai cách tiếp cận chuyên nghiệp nhất: dùng toán học tập hợp (Set) và dùng cơ chế đánh giá đoản mạch (Short-circuit evaluation) của Generator. Hai hướng này đại diện cho hai tư duy lập trình cực kỳ quan trọng mà bất kỳ lập trình viên Python nào cũng phải nắm vững.

Cách giải 1: Cấu trúc dữ liệu Set (Tối ưu nhất) 

Sử dụng cấu trúc dữ liệu Set trong Python là cách tối ưu nhất để kiểm tra các ký tự duy nhất nhờ khả năng loại bỏ phần tử trùng lặp với độ phức tạp O(1) cho mỗi lần tra cứu. Phương pháp này tận dụng tính chất toán học của tập hợp để tìm ra câu trả lời chỉ trong vài dòng code.

Ý tưởng cốt lõi

Tập hợp (Set) trong toán học và trong Python là một danh sách không có thứ tự và không chứa các phần tử trùng lặp. Hãy tưởng tượng bạn có một cái rổ chứa đúng 26 chữ cái chuẩn từ ‘a’ đến ‘z’ (gọi là Tập Chuẩn). Chuỗi đầu vào của bạn, sau khi được ép thành chữ thường, cũng sẽ được ném vào một cái rổ thứ hai (gọi là Tập Input). Chức năng của Set sẽ tự động lọc bỏ mọi chữ cái lặp lại trong Tập Input.

Lúc này, công việc của chúng ta cực kỳ đơn giản: Chỉ cần hỏi Python xem “Tập Chuẩn có nằm gọn bên trong Tập Input hay không?”. Nếu câu trả lời là có (Tập Chuẩn là tập con của Tập Input), thì chuỗi đó chính là Pangram.

Các bước thực hiện

1. Import module: Kéo thư viện string vào để gọi string.ascii_lowercase (chuỗi chứa sẵn “abcdefghijklmnopqrstuvwxyz”) thay vì phải gõ tay dễ sai sót.

2. Khởi tạo Tập Chuẩn: Ép string.ascii_lowercase thành một cấu trúc set.

3. Chuẩn hóa input: Gọi hàm .lower() trên chuỗi truyền vào để đổi toàn bộ thành chữ thường.

4. Khởi tạo Tập Input: Ép chuỗi vừa chuyển đổi thành một set. Python sẽ tự động lọc trùng và tách riêng các ký tự.

5. Kiểm tra tập con: Dùng phương thức .issubset() (hoặc toán tử <=) để kiểm tra xem Tập Chuẩn có phải là tập con của Tập Input hay không. Trả về kết quả True hoặc False.

Minh họa tay với ví dụ

Giả sử người dùng nhập: text = "Pack my box!" (Đây không phải là pangram, nhưng hãy xem thuật toán chạy).

• Bước chuẩn hóa: text.lower() biến thành "pack my box!".

• Tập Chuẩn (chỉ lấy ví dụ vài chữ): {'a', 'b', 'c', ..., 'z'} (đủ 26 chữ).

• Tập Input: set("pack my box!") sẽ tạo ra: {'p', 'a', 'c', 'k', ' ', 'm', 'y', 'b', 'o', 'x', '!'}.

• Kiểm tra subset: Tập Chuẩn có nằm hoàn toàn trong Tập Input không? Rõ ràng là thiếu chữ ‘d’, ‘e’, ‘f’… nên kết quả lập tức trả về False.

Đánh giá phương pháp

• Phù hợp người mới vì: Tư duy cực kỳ tự nhiên, sát với logic toán học cấp 3. Code rất ngắn gọn, thể hiện tính “Pythonic” (viết code kiểu Python).

• Ưu điểm: Khả năng loại bỏ phần tử trùng lặp của set được tối ưu hóa ở tầng C (ngôn ngữ gốc viết ra Python), nên tốc độ thực thi rất mượt. Việc dùng .issubset() thể hiện ý đồ của lập trình viên cực kỳ rõ ràng, dễ bảo trì.

• Nhược điểm: Python phải duyệt qua toàn bộ chuỗi đầu vào để tạo ra Tập Input, ngay cả khi chuỗi đó dài 10 triệu ký tự và chỉ chứa toàn chữ ‘a’. Nó tốn một lượng bộ nhớ tương đương với số ký tự duy nhất có trong chuỗi đầu vào.

• Độ phức tạp: O(N) về thời gian (N là độ dài chuỗi đầu vào) / O(N) về bộ nhớ để lưu trữ các ký tự vào set.

Cách giải 2: Hàm all() và Generator Expression 

Khác với Cách 1 tập trung vào tập hợp, cách giải sử dụng hàm all() và Generator Expression này mang lại cơ chế đoản mạch (short-circuiting), giúp hệ thống dừng lại ngay lập tức khi phát hiện chữ cái đầu tiên bị thiếu, qua đó tiết kiệm tài nguyên đáng kể trong một số trường hợp cụ thể.

Ý tưởng giải thuật

Thay vì gom tất cả ký tự của chuỗi đầu vào lại thành một tập hợp, chúng ta sẽ lật ngược vấn đề: Ta cầm danh sách 26 chữ cái (từ a đến z), sau đó đi hỏi chuỗi đầu vào từng câu một.

• “Ê chuỗi, mày có chữ ‘a’ không?” -> Có.

• “Có chữ ‘b’ không?” -> Có.

• “Có chữ ‘c’ không?” -> KHÔNG!

Ngay tại khoảnh khắc nhận được từ “KHÔNG”, chúng ta kết luận ngay chuỗi này không phải Pangram và dừng toàn bộ chương trình lại. Không cần tốn công đi hỏi các chữ cái từ ‘d’ đến ‘z’ nữa. Trong Python, hàm all() làm chính xác nhiệm vụ này. Nó nhận vào một danh sách các điều kiện, nếu gặp bất kỳ điều kiện nào False, nó ngừng ngay lập tức và trả về False.

Các bước triển khai

1. Chuẩn hóa chuỗi một lần: Gán lower_text = text.lower(). Rất quan trọng phải làm trước vòng lặp, nếu không mỗi lần kiểm tra chữ cái bạn lại bắt Python hạ chữ thường cả một đoạn văn dài.

2. Dùng Generator Expression: Viết một biểu thức (char in lower_text for char in string.ascii_lowercase). Đoạn này sẽ sinh ra từng giá trị True/False cho mỗi chữ cái.

3. Bọc hàm all(): Đưa biểu thức trên vào trong hàm all().

4. Trả về kết quả: Trả về trực tiếp giá trị mà all() tính toán được.

Minh họa bằng tay

Input truyền vào: text = "Hello World"

• Chuẩn hóa: lower_text = "hello world".

• Vòng lặp Generator bắt đầu chạy, lấy chữ ‘a’ từ string.ascii_lowercase.

• Xét điều kiện: 'a' in "hello world" -> Kết quả là False.

• Hàm all() nhận được False đầu tiên. Nó lập tức kích hoạt cơ chế đoản mạch (short-circuit).

• Vòng lặp bị hủy bỏ. Kết quả False được trả về ngay lập tức. Các ký tự từ ‘b’ đến ‘z’ chưa bao giờ được đưa ra để kiểm tra.

Khi nào nên dùng Cách 2?

Phương pháp này tỏa sáng nhất khi bạn phải xử lý những chuỗi văn bản khổng lồ (vài trăm Megabytes) mà bạn nghi ngờ rằng nó KHÔNG phải là Pangram (ví dụ: chuỗi bị thiếu chữ ‘a’). Việc dừng lại ngay lập tức giúp tốc độ phản hồi gần như tức thì, thay vì phải quét toàn bộ văn bản để xây dựng Set như Cách 1.

Đánh giá chuyên sâu

• Ưu điểm: Khai thác tối đa sức mạnh của Generator để tối ưu hóa bộ nhớ (không cần tạo danh sách hay tập hợp mới để so sánh). Cơ chế dừng sớm (short-circuit) giúp tiết kiệm CPU.

• Nhược điểm: Toán tử in khi tìm kiếm trên một chuỗi (string) có độ phức tạp là O(N). Vì chúng ta có vòng lặp 26 chữ cái, trong trường hợp xấu nhất (chuỗi đúng là Pangram, phải quét đủ 26 chữ), thời gian chạy sẽ là 26 * O(N). Mặc dù về lý thuyết Big-O, hằng số 26 bị loại bỏ và vẫn là O(N), nhưng hằng số này khiến nó chạy chậm hơn Cách 1 một chút trong trường hợp chuỗi hợp lệ.

• Độ phức tạp: O(N) về thời gian (tối đa quét N ký tự 26 lần) / O(N) về bộ nhớ (do phải tạo ra chuỗi lower_text mới).

So sánh nhanh 2 cách

Bảng này giúp bạn quyết định nên dùng cách nào để giải bài toán kiểm tra chuỗi mà không cần đọc lại toàn bộ bài phân tích ở trên.

Code Python đầy đủ 

Cách 1 — Cấu trúc dữ liệu Set (Tối ưu nhất):

# Cách tiếp cận: So sánh tập hợp để kiểm tra Pangram
import string
import unicodedata
def solve(tham_so_chuoi):
    """
    Hàm nhận vào một chuỗi bất kỳ, kiểm tra xem nó có chứa đầy đủ
    26 chữ cái tiếng Anh (a-z) hay không. Trả về True/False.
    """
    # Ép kiểu an toàn (tránh lỗi nếu người dùng vô tình truyền số int)
    if not isinstance(tham_so_chuoi, str):
        return False
        
    # Chuẩn hóa Unicode (NFC) cho text tiếng Việt/quốc tế (thói quen tốt)
    chuoi_chuan_hoa = unicodedata.normalize('NFC', tham_so_chuoi)
    
    # Bước 1 & 2 & 3: Lấy set bảng chữ cái và set của chuỗi đã lower
    tap_chuan = set(string.ascii_lowercase)
    tap_input = set(chuoi_chuan_hoa.lower())
    
    # Bước 4: Kiểm tra tập con
    ket_qua = tap_chuan.issubset(tap_input)
    
    return ket_qua
# --- TEST NHANH ---
assert solve("The quick brown fox jumps over the lazy dog") == True
assert solve("Pack my box with five dozen liquor jugs.") == True
assert solve("Hello World") == False
assert solve("") == False
# --- Nhập liệu từ người dùng ---
# Lưu ý: Hàm đã xử lý trường hợp đầu vào rỗng hoặc sai kiểu dữ liệu
if __name__ == "__main__":
    n = input("Nhập chuỗi cần kiểm tra: ")
    if solve(n):
        print("Chuỗi này LÀ một Pangram (đủ 26 chữ cái).")
    else:
        print("Chuỗi này KHÔNG PHẢI là Pangram.")

Cách 2 — Hàm all() và Generator Expression:

# Cách tiếp cận: Short-circuit đánh giá để tối ưu trường hợp thiếu chữ sớm
import string
def solve_v2(tham_so_chuoi):
    """
    Dùng hàm all() để quét từng chữ cái a-z. Sẽ dừng vòng lặp ngay
    khi phát hiện một chữ cái không tồn tại trong chuỗi đầu vào.
    """
    if not isinstance(tham_so_chuoi, str):
        return False
        
    # Tạo biến lưu chuỗi in thường một lần duy nhất để tối ưu
    lower_text = tham_so_chuoi.lower()
    
    # logic khác biệt: duyệt generator bên trong all()
    # Nếu chữ 'char' không có trong lower_text, all() trả về False ngay.
    ket_qua = all(char in lower_text for char in string.ascii_lowercase)
    
    return ket_qua
# --- TEST NHANH ---
assert solve_v2("The quick brown fox jumps over the lazy dog") == True
assert solve_v2("Hello World") == False
if __name__ == "__main__":
    n = input("Nhập chuỗi cần kiểm tra: ")
    print("Kết quả:", solve_v2(n))

Ví dụ chạy thử đầu vào/đầu ra 

Lỗi thường gặp khi lập trình kiểm tra chuỗi 

Lỗi 1: Quên hạ chữ thường (Lowercase) trước khi kiểm tra

Hiện tượng phổ biến nhất khi sinh viên nộp bài là output trả về False dù chuỗi nhập vào rõ ràng chứa đủ các chữ cái từ A đến Z. Nguyên nhân gốc rễ là vì bảng mã ASCII quy định chữ hoa (‘A’) và chữ thường (‘a’) là hai giá trị nhị phân hoàn toàn khác nhau. Tập chuẩn string.ascii_lowercase chỉ chứa chữ thường. Nếu bạn không gọi .lower(), chữ ‘A’ trong chuỗi của bạn sẽ không được ghi nhận là đã xuất hiện.

Code sai:

# Quên dùng lower()
tap_input = set(text)
return set(string.ascii_lowercase).issubset(tap_input)
# output sai là: False (với input "A B C ... Z")

Code đúng:

# Đã bổ sung lower()
tap_input = set(text.lower())
return set(string.ascii_lowercase).issubset(tap_input)
# output đúng là: True

Lỗi 2: Nhầm lẫn về bản chất của Set và gọi hàm len()

Nhiều bạn nghĩ rằng: “Đã có 26 chữ cái tiếng Anh, vậy cứ đếm nếu chuỗi có chiều dài từ 26 trở lên là xong”. Suy nghĩ này dẫn đến việc sử dụng hàm len() trực tiếp lên chuỗi thay vì dùng tập hợp. Nguyên nhân sai lầm này xuất phát từ việc không tính đến trường hợp một chữ cái lặp lại nhiều lần. Ví dụ, chuỗi “aaaaaaaa…a” dài 100 ký tự nhưng chỉ chứa đúng 1 chữ ‘a’.

Code sai:

# Chỉ kiểm tra độ dài chuỗi
if len(text.replace(" ", "")) >= 26:
    return True
# output sai là: True (với chuỗi "aaaaaaaaaaaaaaaaaaaaaaaaaa")

Code đúng:

# Lọc trùng bằng Set rồi mới đếm (nếu muốn dùng cách đếm)
tap_ky_tu_chu_cai = set(c for c in text.lower() if c.isalpha())
return len(tap_ky_tu_chu_cai) == 26
# output đúng là: False

Lỗi 3: Tạo mới Set hoặc gọi .lower() bên trong vòng lặp

Việc thiết kế luồng lặp kém hiệu quả sẽ làm sập server nếu chuỗi kiểm tra quá lớn. Hiện tượng là chương trình bị “treo” hoặc chạy cực kỳ chậm (Time Limit Exceeded). Nguyên nhân là do bạn ép chuỗi thành in thường HOẶC khởi tạo danh sách ngay tại dòng điều kiện của vòng lặp for. Do đó, nếu chuỗi có 26 chữ cái cần check, Python sẽ phải đi chuẩn hóa lại toàn bộ đoạn văn bản đó đúng 26 lần!

Code sai:

# text.lower() bị thực thi lại 26 lần
for char in string.ascii_lowercase:
    if char not in text.lower():
        return False
return True

Code đúng:

# Biến lower_text được lưu sẵn ở ngoài vòng lặp
lower_text = text.lower()
for char in string.ascii_lowercase:
    if char not in lower_text:
        return False
return True

Lỗi 4: Xóa ký tự đặc biệt thủ công một cách máy móc

Khi cố gắng kiểm tra chuỗi có chứa tất cả ký tự a-z, nhiều bạn bị “ám ảnh” bởi các ký tự dấu câu (như chấm, phẩy, gạch ngang) nên cố gắng viết các hàm replace() dài dằng dặc để xóa chúng đi trước khi xử lý. Nguyên nhân là do chưa hiểu rõ tính chất của thuật toán tập con (issubset). Việc Tập Input có chứa dấu chấm hay khoảng trắng không hề ảnh hưởng đến việc hỏi xem Tập Chuẩn (chỉ có a-z) có nằm trong nó hay không. Việc thay thế thủ công này vừa dễ sót lỗi vừa lãng phí CPU.

Code sai:

# Dư thừa và tốn kém tài nguyên
text = text.replace(".", "").replace(",", "").replace("!", "").replace(" ", "")
tap_input = set(text.lower())
return set(string.ascii_lowercase).issubset(tap_input)

Code đúng:

# Không cần xóa gì cả, Set xử lý subset một cách hoàn hảo
tap_input = set(text.lower())
return set(string.ascii_lowercase).issubset(tap_input)

Lỗi 5: Nhầm lẫn logic giữa issubset và issuperset

Lỗi này sinh ra một kết quả rất buồn cười: Mọi chuỗi đưa vào đều trả về False trừ khi chuỗi đó chỉ toàn chữ a-z mà không có bất kỳ dấu cách hay ký tự nào khác. Nguyên nhân là do bạn nhầm lẫn khái niệm. A.issubset(B) nghĩa là “A có nằm gọn trong B không?”. Còn bạn lại viết B.issubset(A) (Tập Input có nằm gọn trong bảng chữ cái không?). Khi chuỗi có dấu cách, tập Input có ký tự khoảng trắng, mà khoảng trắng không nằm trong bảng chữ cái, nên kết quả luôn sai.

Code sai:

tap_chuan = set(string.ascii_lowercase)
tap_input = set(text.lower())
# Sai logic Toán học
return tap_input.issubset(tap_chuan)

Code đúng:

tap_chuan = set(string.ascii_lowercase)
tap_input = set(text.lower())
# Tập chuẩn a-z phải là con của chuỗi đầu vào
return tap_chuan.issubset(tap_input) 

Câu hỏi thường gặp 

Kiểm tra chuỗi Pangram là gì?

Bài toán kiểm tra chuỗi Pangram là việc bạn thiết kế thuật toán để xác định xem một đoạn văn bản (string) bất kỳ có sự xuất hiện của đầy đủ 26 chữ cái trong bảng mã tiếng Anh từ ‘a’ đến ‘z’ hay không, ít nhất mỗi chữ một lần. Câu ví dụ nổi tiếng nhất là “The quick brown fox jumps over the lazy dog” thường được dùng để test font chữ.

Tại sao nên dùng cấu trúc Set khi kiểm tra chuỗi có chứa tất cả ký tự a-z?

Cấu trúc dữ liệu Set được áp dụng vì đặc tính toán học cốt lõi của nó: chỉ lưu trữ các giá trị duy nhất và loại bỏ mọi phần tử lặp lại bằng bảng băm (hash table). Khi đưa một văn bản vào Set, tốc độ tìm kiếm và đối chiếu sự tồn tại của 26 chữ cái diễn ra với độ phức tạp thời gian cực nhanh O(1), đánh bại mọi vòng lặp thủ công.

Làm thế nào để bỏ qua dấu câu khi thực hiện việc kiểm tra chuỗi trong Python?

Nếu bạn sử dụng phương pháp tập con (subset) của set, bạn không cần viết code để loại bỏ dấu câu vì hàm subset tự động lờ đi các ký tự rác. Tuy nhiên, nếu bạn thực sự muốn lọc sạch chuỗi chỉ còn chữ cái, bạn có thể kết hợp list comprehension với phương thức .isalpha(): [c for c in text if c.isalpha()].

Triển khai hàm all() như thế nào để kiểm tra chuỗi tối ưu nhất?

Để kiểm tra chuỗi tối ưu bằng all(), bạn bắt buộc phải truyền vào trong nó một Generator Expression dạng (char in text.lower() for char in string.ascii_lowercase). Không được dùng ngoặc vuông [...] vì nó sẽ tạo List Comprehension, phá vỡ khả năng dừng sớm (short-circuit) – tính năng quan trọng nhất khiến all() trở nên đáng giá.

Nên dùng cấu trúc Set hay hàm all() để kiểm tra chuỗi có chứa tất cả ký tự a-z?

Đối với hầu hết các bài tập và dự án thực tế thông thường, cách giải bằng Set luôn được ưu tiên vì độ ngắn gọn, minh bạch và khả năng tận dụng tốc độ nội tại của C-Python. Bạn chỉ nên chuyển sang dùng hàm all() khi chắc chắn phải quét những tệp nhật ký siêu lớn và muốn ưu tiên phát hiện sớm trường hợp lỗi thiếu chữ.

Sự khác biệt về quản lý bộ nhớ giữa hai cách giải kiểm tra chuỗi này là gì?

Cách dùng Set yêu cầu Python cấp phát thêm vùng nhớ để lưu trữ một tập hợp chứa các ký tự rời rạc của chuỗi gốc. Ngược lại, cách dùng all() với Generator hầu như không tốn thêm bộ nhớ ngoài việc sinh ra phiên bản chữ thường của chuỗi gốc, bởi vì Generator trả về kết quả on-the-fly (tính toán đến đâu trả về đến đó) thay vì lưu trữ.

Tại sao mã kiểm tra chuỗi của tôi lại báo sai khi đầu vào có chứa dấu cách?

Nếu bạn đếm tổng số ký tự của chuỗi hoặc dùng phép giao/hợp sai cách, khoảng trắng (space) sẽ được tính là một ký tự hợp lệ. Để khắc phục, bạn phải đối chiếu chuỗi của mình với một tập hợp “chuẩn” chỉ giới hạn chặt chẽ trong 26 ký tự alphabet (string.ascii_lowercase), từ đó khoảng trắng sẽ bị hệ thống cô lập một cách tự nhiên.

Kết luận

Bài toán kiểm tra chuỗi có chứa tất cả ký tự a-z (Pangram) là ví dụ kinh điển minh chứng cho triết lý lập trình của Python: “Có rất nhiều cách giải, nhưng sẽ luôn có một cách thanh lịch và tối ưu nhất”. Bạn nên dùng cấu trúc Set khi cần một giải pháp gọn gàng, hiệu suất tổng thể cao và sát với logic toán học. Trong khi đó, việc kết hợp hàm all() cùng Generator lại là vũ khí sắc bén cho các bài toán xử lý chuỗi cực lớn cần sự nhạy bén của cơ chế dừng sớm.

Khuyên bạn đừng chỉ đọc lý thuyết. Hãy mở trình soạn thảo lên, copy thử một đoạn văn ngẫu nhiên và áp dụng cả hai mã nguồn trên xem sao. Khi bạn tự tay chạy thử, các khái niệm về độ phức tạp O(N) hay cơ chế đoản mạch sẽ trở nên sống động hơn bao giờ hết!

Các khóa học liên quan: 

• Làm chủ Python trong 4 tuần

• Học python căn bản thông qua lập trình 1 game

• Python Excel cho người đi làm

• Học lập trình Python cho mọi lứa tuổi

• Thành thạo xử lý dữ liệu với Python

• Tập làm kĩ sư Amazon vận hành robot nông nghiệp với Python

Một số sản phẩm từ Python:

• Tool MMO: “Máy xay clip” chuẩn MMO cho TikTok, YouTube Shorts, Facebook Reels

Một số sách lập trình Python bạn hãy tham khảo

• Tiki: Python
• Shopee: Pyhon