Palindrome: Hướng dẫn 2 cách kiểm tra số trong Python cho người mới

Bài viết này sẽ hướng dẫn bạn chi tiết cách giải quyết bài toán kiểm tra số palindrome trong Python. Bằng việc đi từ phương pháp xử lý chuỗi đơn giản nhất đến thuật toán toán học tối ưu, bạn không chỉ giải được bài tập mà còn rèn luyện tư duy lập trình cực kỳ hiệu quả.

💡 Trả lời nhanh: Để kiểm tra một số có phải là palindrome hay không, cách nhanh nhất là chuyển số đó thành chuỗi bằng hàm str(), sau đó so sánh chuỗi đó với chính nó khi được đảo ngược bằng cú pháp slicing [::-1]. Ví dụ: str(n) == str(n)[::-1].

Đề bài 

Viết một chương trình Python để kiểm tra xem một số nguyên được nhập vào có phải là số palindrome hay không.

Input: Một số nguyên n bất kỳ (có thể là số dương, số âm hoặc số 0).

Output: Trả về giá trị boolean True nếu n là số palindrome, và False nếu n không phải là số palindrome.

Ràng buộc: Không có ràng buộc đặc biệt về thời gian thực thi hay bộ nhớ cho mức độ cơ bản. Tuy nhiên, chương trình cần xử lý đúng các trường hợp số âm và số có một chữ số.

Phân tích 

Số palindrome trong Python là một số nguyên có giá trị không thay đổi khi bạn đọc các chữ số của nó từ trái sang phải hay từ phải sang trái. Nói một cách đơn giản, nó giống như một sự đối xứng hoàn hảo qua gương. Ví dụ, số 121, 1331, hoặc 9 đều là những số palindrome hợp lệ. Ngược lại, số 123 khi đọc ngược lại sẽ thành 321, giá trị đã bị thay đổi, nên nó không phải là palindrome.

📌 Góc nhìn thực tế: Trong thực tế giảng dạy, tôi nhận thấy người mới học thường hay bối rối nhất ở khâu xử lý dấu trừ của số âm. Nhiều bạn cố gắng lấy giá trị tuyệt đối của số âm trước khi đảo ngược, dẫn đến sai logic toán học cơ bản.

Giả định về số âm

Đối với bài toán này, chúng ta thống nhất quy tắc toán học tiêu chuẩn: mọi số âm đều không phải là số palindrome. Nguyên nhân là vì dấu trừ - nằm ở đầu con số. Khi bạn đảo ngược một số âm, ví dụ -121, kết quả thu được sẽ là chuỗi ký tự 121-. Rõ ràng -121 không thể bằng 121-, do đó kết quả trả về luôn phải là False.

Từ phân tích trên, chúng ta có hai hướng tiếp cận chính: một là lợi dụng sức mạnh xử lý chuỗi tích hợp sẵn của Python, hai là sử dụng các phép toán số học cơ bản để mổ xẻ cấu trúc của con số.

Cách giải 1: Dùng chuỗi (String Slicing) – Cách kiểm tra số đơn giản nhất 

Cách dùng chuỗi (String Slicing) là phương pháp ngắn gọn, trực quan và dễ triển khai nhất để kiểm tra số palindrome trong Python. Bạn không cần phải thiết lập các vòng lặp phức tạp, thay vào đó chỉ cần tận dụng cú pháp mạnh mẽ có sẵn của ngôn ngữ.

Ý tưởng cốt lõi

Khái niệm “đọc ngược đọc xuôi” về bản chất rất giống với việc xử lý văn bản. Do đó, ý tưởng ở đây là chúng ta sẽ biến đổi con số khô khan thành một chuỗi văn bản (string). Khi đã ở định dạng chuỗi, Python cung cấp một cú pháp cực kỳ lợi hại gọi là slicing (cắt lát) với bước nhảy -1 ([::-1]) để lật ngược toàn bộ ký tự trong chớp mắt. Cuối cùng, ta chỉ việc đặt chuỗi ban đầu và chuỗi đã lật ngược lên bàn cân so sánh.

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

1. Biến đổi số nguyên n ban đầu thành một chuỗi ký tự bằng cách sử dụng hàm ép kiểu str(n). Lưu kết quả vào biến chuoi_n.

2. Tạo một bản sao đảo ngược của chuoi_n bằng cú pháp chuoi_n[::-1].

3. Sử dụng toán tử so sánh == để đối chiếu chuoi_n với bản sao đã đảo ngược. Nếu chúng hoàn toàn giống nhau, trả về True, ngược lại trả về False.

Minh họa tay chi tiết

Hãy cùng chạy thử với Input: 121

• Bước 1: Ép kiểu 121 thành chuỗi. Ta có chuoi_n = "121".

• Bước 2: Đảo ngược chuỗi. "121"[::-1] sẽ lấy ký tự từ cuối lên đầu, tạo ra chuỗi mới là "121".

• Bước 3: So sánh. "121" == "121". Kết quả là True.

Thử với một số âm, Input: -121

• Bước 1: Ép kiểu -121. Ta có chuoi_n = "-121".

• Bước 2: Đảo ngược. "-121"[::-1] sẽ tạo ra chuỗi "121-".

• Bước 3: So sánh. "-121" == "121-". Rõ ràng hai chuỗi này khác nhau. Kết quả là False (hoàn toàn đúng với giả định ban đầu).

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

• Phù hợp người mới vì: Mã nguồn cực kỳ ngắn gọn (thường chỉ mất 1 dòng code), không đòi hỏi kiến thức về vòng lặp hay toán tử modulo.

• Ưu điểm: Viết code nhanh, ít nguy cơ dính lỗi logic (bug), tận dụng được thư viện C tối ưu ẩn bên dưới của Python.

• Nhược điểm: Tiêu tốn thêm không gian bộ nhớ trong hệ thống. Khi ép kiểu, Python phải cấp phát vùng nhớ mới để lưu trữ biến chuỗi, và thêm một vùng nhớ nữa cho chuỗi đảo ngược.

• Độ phức tạp: O(n) thời gian / O(n) bộ nhớ (với n là số lượng chữ số của số nguyên đầu vào).

Cách giải 2: Dùng toán học (Vòng lặp While)

Khác với Cách 1, phương pháp dùng toán học với vòng lặp while không cần chuyển đổi kiểu dữ liệu sang chuỗi mà thao tác trực tiếp trên các chữ số, giúp tối ưu không gian bộ nhớ. Đây là cách giải mang đậm chất “thuật toán” truyền thống.

Ý tưởng cốt lõi

Khác với Cách 1 ở chỗ chúng ta sẽ không tạo ra bất kỳ chuỗi văn bản nào. Thay vào đó, chúng ta sẽ “bóc tách” từng chữ số của con số ban đầu từ phải sang trái. Để lấy chữ số cuối cùng, ta dùng phép chia lấy dư cho 10 (% 10). Để loại bỏ chữ số cuối cùng vừa lấy, ta dùng phép chia lấy phần nguyên cho 10 (// 10). Các chữ số được bóc ra sẽ được lắp ráp lại thành một con số hoàn toàn mới. Cuối cùng, so sánh con số mới xây dựng này với số nguyên gốc.

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

1. Xử lý nhanh trường hợp số âm: Nếu số đầu vào n < 0, lập tức trả về False để tiết kiệm thời gian xử lý.

2. Lưu trữ giá trị ban đầu của n vào một biến tạm tên là so_goc. Điều này cực kỳ quan trọng vì quá trình lặp sẽ phá hủy giá trị của n.

3. Khởi tạo một biến so_dao_nguoc = 0. Đây sẽ là “thùng chứa” để lắp ráp con số mới.

4. Bắt đầu vòng lặp while với điều kiện n > 0. Trong mỗi vòng lặp:

   • Lấy chữ số cuối cùng: chu_so = n % 10.

   • Ghép chữ số này vào biến lưu trữ: so_dao_nguoc = so_dao_nguoc * 10 + chu_so.

   • Cắt bỏ chữ số cuối cùng khỏi n: n = n // 10.

5. Sau khi vòng lặp kết thúc, so sánh so_dao_nguoc với so_goc. Nếu bằng nhau thì trả về True.

Minh họa tay chi tiết

Hãy cùng lướt qua Input: 121.

• Khởi tạo: so_goc = 121, n = 121, so_dao_nguoc = 0.

• Vòng lặp 1 (n đang là 121 > 0):

  • chu_so = 121 % 10 = 1.

  • so_dao_nguoc = 0 * 10 + 1 = 1.

  • n = 121 // 10 = 12.

• Vòng lặp 2 (n đang là 12 > 0):

  • chu_so = 12 % 10 = 2.

  • so_dao_nguoc = 1 * 10 + 2 = 12.

  • n = 12 // 10 = 1.

• Vòng lặp 3 (n đang là 1 > 0):

  • chu_so = 1 % 10 = 1.

  • so_dao_nguoc = 12 * 10 + 1 = 121.

  • n = 1 // 10 = 0.

• Vòng lặp kết thúc vì n bằng 0.

• So sánh kết quả: so_dao_nguoc (121) hoàn toàn bằng so_goc (121). Trả về True.

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

Phương pháp này là bắt buộc nếu bạn đang giải bài tập trên các nền tảng như LeetCode, HackerRank và đề bài có kèm theo câu “Follow up: Giải bài toán mà không chuyển số thành chuỗi”. Nó cũng cực kỳ hữu ích khi bạn lập trình trên các hệ thống nhúng, nơi bộ nhớ RAM bị giới hạn nghiêm ngặt và việc cấp phát biến chuỗi liên tục có thể gây phình bộ nhớ.

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

• Ưu điểm: Hiệu năng quản lý bộ nhớ xuất sắc. Hoạt động độc lập hoàn toàn bằng logic toán học thuần túy, giúp củng cố tư duy về vòng lặp và toán tử.

• Nhược điểm: Code dài hơn, logic phức tạp hơn và dễ mắc các lỗi liên quan đến điều kiện dừng của vòng lặp (vòng lặp vô tận).

• Độ phức tạp: O(n) thời gian (số lần lặp bằng đúng số lượng chữ số) / O(1) bộ nhớ (không cần mảng hay chuỗi phụ trợ).

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 quyết bài toán kiểm tra số palindrome một cách nhanh nhất mà không cần đọc lại toàn bài.

Code đầy đủ 

Cách 1 — Dùng chuỗi (Slicing):

# Tên biến nhất quán với phần minh họa tay phía trên
def kiem_tra_palindrome_chuoi(n):
    """
    Hàm này kiểm tra số palindrome bằng cách chuyển đổi qua lại giữa số và chuỗi.
    Nhận vào: số nguyên n.
    Trả về: True nếu là palindrome, False nếu không phải.
    """
    # Ép kiểu số nguyên thành chuỗi ký tự
    chuoi_n = str(n)
    
    # So sánh chuỗi ban đầu với phiên bản đảo ngược của nó [::-1]
    return chuoi_n == chuoi_n[::-1]

# --- TEST NHANH ---
# Lưu ý: giả định input nhập vào luôn hợp lệ (đúng định dạng số nguyên)
so_nhap = int(input("Nhập n (Cách 1): "))
print(kiem_tra_palindrome_chuoi(so_nhap))

Cách 2 — Dùng toán học (While):

# Điểm khác với Cách 1: Thao tác thuần túy bằng toán học, không dùng hàm str()
def kiem_tra_palindrome_toan_hoc(n):
    """
    Hàm này kiểm tra số palindrome bằng vòng lặp while và toán tử %, //.
    Nhận vào: số nguyên n.
    Trả về: True nếu là palindrome, False nếu không phải.
    """
    # Các số âm không bao giờ là palindrome (do có dấu - ở đầu)
    if n < 0:
        return False
        
    so_goc = n
    so_dao_nguoc = 0
    
    # Lặp để bóc tách từng chữ số từ hàng đơn vị trở lên
    while n > 0:
        chu_so = n % 10
        so_dao_nguoc = (so_dao_nguoc * 10) + chu_so
        n = n // 10 # Cắt bỏ chữ số cuối
        
    # Trả về kết quả so sánh
    return so_dao_nguoc == so_goc
# --- TEST NHANH ---
so_nhap = int(input("Nhập n (Cách 2): "))
print(kiem_tra_palindrome_toan_hoc(so_nhap))

Ví dụ chạy thử 

Lỗi thường gặp 

Mỗi đoạn lỗi dưới đây được viết để bạn có thể đọc thẳng và đối chiếu ngay với đoạn code đang bị lỗi của mình mà không cần lật lại kiến thức từ đầu bài.

Lỗi 1: Bỏ quên trường hợp số âm trong thuật toán toán học

Lỗi này xảy ra khi bạn vội vàng viết vòng lặp while mà quên mất rằng con số truyền vào có thể mang dấu trừ, dẫn đến việc chương trình hiểu sai yêu cầu và cho ra kết quả sai lệch hoàn toàn.

Hiện tượng: Output ra True khi bạn nhập -121, thay vì kết quả đúng phải là False.

Nguyên nhân: Vì nếu bạn cố tình dùng hàm abs(n) để ép biến thành số dương trước khi tính, hoặc vòng lặp của bạn bỏ qua dấu âm, thì -121 sẽ được đối xử y hệt như 121. Xét về mặt toán học chuẩn mực, số âm không đối xứng do ký tự dấu trừ không có điểm đối xứng ở đuôi số.

Code sai:

def sai_so_am(n):
    n = abs(n) # Lỗi ở đây: cố tình khử dấu trừ
    so_goc = n
    so_dao_nguoc = 0
    while n > 0:
        so_dao_nguoc = so_dao_nguoc * 10 + (n % 10)
        n //= 10
    return so_dao_nguoc == so_goc # output sai là: True với n = -121

Code đúng:

def dung_so_am(n):
    if n < 0: return False # Chặn ngay từ đầu
    # ... logic vòng lặp ...
    # output đúng là: False với n = -121

Lỗi 2: Quên lưu trữ biến số gốc để đối chiếu

Khi làm việc với các bài toán yêu cầu so sánh kết quả cuối cùng với trạng thái ban đầu, việc quên tạo “bản sao” của dữ liệu đầu vào là một tai nạn lập trình cực kỳ phổ biến.

Hiện tượng: Output luôn luôn ra False đối với mọi con số được nhập vào, kể cả khi đó rành rành là một số palindrome như 1331.

Nguyên nhân: Vì vòng lặp while n > 0 sẽ liên tục băm nhỏ biến n bằng phép chia // 10. Khi vòng lặp kết thúc, n chắc chắn sẽ có giá trị bằng 0. Ở dòng return, bạn đem so_dao_nguoc so sánh với n (lúc này đang bằng 0), nên kết quả sẽ không bao giờ bằng nhau.

Code sai:

def sai_bien_goc(n):
    so_dao_nguoc = 0
    while n > 0:
        so_dao_nguoc = so_dao_nguoc * 10 + n % 10
        n //= 10
    return so_dao_nguoc == n # output sai là: False vì n hiện tại bằng 0

Code đúng:

def dung_bien_goc(n):
    so_goc = n # Phải lưu lại giá trị ngay lập tức
    # ... vòng lặp ...
    return so_dao_nguoc == so_goc # output đúng là: True hoặc False chuẩn xác

Lỗi 3: Dùng nhầm phép chia thập phân thay vì chia lấy phần nguyên

Trong Python 3, sự khác biệt giữa một dấu / và hai dấu // có thể phá nát hoàn toàn logic của một bài toán số học, đặc biệt là các thuật toán cần tính toán số nguyên.

Hiện tượng: Vòng lặp chạy vô hạn (infinite loop) hoặc báo lỗi tính toán liên quan đến kiểu float (số thực).

Nguyên nhân: Vì phép chia một dấu / trong Python luôn trả về số thập phân (ví dụ: 12 / 10 = 1.2). Biến n sẽ dần trở thành 1.2, rồi 0.12, 0.012… Nó sẽ tiến sát về 0 nhưng không bao giờ thực sự bằng 0, khiến điều kiện n > 0 luôn đúng. Phép chia // (Floor Division) mới thực sự cắt bỏ phần thập phân để giữ lại phần nguyên.

Code sai:

def sai_phep_chia(n):
    so_dao_nguoc = 0
    while n > 0:
        so_dao_nguoc = so_dao_nguoc * 10 + n % 10
        n = n / 10 # Lỗi ở đây: chia thập phân
    return so_dao_nguoc 
# output sai là: Chương trình treo (treo máy) do lặp vô hạn

Code đúng:

def dung_phep_chia(n):
    # ... logic ...
        n = n // 10 # Chia lấy phần nguyên, n sẽ về 0
    # output đúng là: Chương trình kết thúc và trả kết quả

Lỗi 4: Điều kiện lặp sai khi kiểm tra các con số có đuôi là số 0

Nhiều người mới học gặp rắc rối khi cố gắng khái quát hóa bài toán mà chưa cân nhắc kỹ các giá trị đường biên (edge cases), điển hình là các con số chia hết cho 10.

Hiện tượng: Code xử lý lủng củng, không dứt khoát hoặc sinh ra lỗi logic ngầm khi nhập các số như 10, 100, 120.

Nguyên nhân: Vì số có số 0 ở đuôi (ngoại trừ chính con số 0) không bao giờ là số palindrome (ví dụ 10 đảo lại là 01, tức là 1). Nếu bạn tối ưu hóa bằng cách đặt điều kiện lặp while n != 0, số âm cũng sẽ vượt qua cửa kiểm tra này và đi vào vòng lặp tính toán sai lệch, thay vì dùng while n > 0 kết hợp bẫy số âm từ đầu.

Code sai:

def sai_dieu_kien(n):
    # Bỏ qua không bẫy số âm và số chẵn chục
    so_goc = n
    so_dao_nguoc = 0
    while n != 0: # Cố tình dùng != thay vì >
        so_dao_nguoc = so_dao_nguoc * 10 + (n % 10)
        n //= 10
    return so_dao_nguoc == so_goc # Gây nhiễu logic với số âm

Code đúng:

def dung_dieu_kien(n):
    # Bẫy sớm: số âm và số có đuôi 0 (nhưng khác 0) thì fail luôn
    if n < 0 or (n % 10 == 0 and n != 0): 
        return False
    # ... tiếp tục tính toán chỉ với số khả thi

Lỗi 5: Cú pháp slicing viết sai khoảng cách

Slicing là vũ khí mạnh, nhưng nó cũng là con dao hai lưỡi nếu bạn không nhớ chính xác vị trí của các dấu hai chấm : trong chuỗi định dạng.

Hiện tượng: Python ném ra thông báo lỗi cú pháp (SyntaxError) hoặc lỗi kiểu dữ liệu, chương trình dừng đột ngột.

Nguyên nhân: Vì khi bạn muốn lấy bước nhảy lùi là -1, bạn phải bỏ trống tham số start và stop, nghĩa là phải có đủ 2 dấu hai chấm ::. Rất nhiều bạn sinh viên viết nhầm thành [:-1], thao tác này không phải là đảo ngược chuỗi mà là lấy toàn bộ chuỗi nhưng bỏ đi ký tự cuối cùng.

Code sai:

def sai_slicing(n):
    chuoi = str(n)
    return chuoi == chuoi[:-1] # Lỗi ở đây: Thiếu một dấu hai chấm
# output sai là: False với n = 121 (so sánh "121" với "12")

Code đúng:

def dung_slicing(n):
    chuoi = str(n)
    return chuoi == chuoi[::-1] # Đủ 2 dấu hai chấm
# output đúng là: True với n = 121 (so sánh "121" với "121")

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

Số palindrome là gì trong Python?

Số palindrome trong Python (hay còn gọi là số đối xứng) là một số nguyên mà khi bạn tiến hành đảo ngược toàn bộ thứ tự các chữ số của nó, giá trị thu được hoàn toàn giống hệt với con số ban đầu. Ví dụ tiêu biểu là các số 121, 1331 hoặc bất kỳ số nào có một chữ số từ 0 đến 9.

Kiểm tra số palindrome có thể áp dụng cho số âm không?

Xét theo quy chuẩn toán học lập trình thông thường, số âm không bao giờ được coi là số palindrome. Nguyên nhân là do khi bạn đảo ngược một số âm như -121, dấu trừ sẽ bị đẩy về phía cuối tạo thành 121-. Chuỗi ký tự này không khớp với chuỗi -121 ban đầu, nên kết quả luôn trả về False.

Làm thế nào để viết code kiểm tra số palindrome bằng Python nhanh nhất?

Cách nhanh và ít tốn sức gõ phím nhất trong Python là kết hợp hàm ép kiểu chuỗi str() và kỹ thuật cắt lát (slicing) mảng. Bạn chỉ cần viết một dòng logic duy nhất: return str(n) == str(n)[::-1]. Cú pháp này tận dụng trình xử lý mã nguồn C bên dưới của Python nên hoạt động cực kỳ ổn định.

Hàm kiểm tra số palindrome có thể dùng thư viện reversed() được không?

Hoàn toàn có thể. Bạn có thể sử dụng hàm reversed() có sẵn kết hợp với hàm join() để nối chuỗi lại. Cú pháp sẽ trông như sau: "".join(reversed(str(n))) == str(n). Tuy nhiên, cách này rườm rà hơn một chút và không thực sự thanh thoát bằng việc sử dụng cú pháp slicing [::-1].

Nên dùng cách slicing chuỗi hay toán học để kiểm tra số palindrome?

Nếu bạn lập trình ứng dụng thông thường hoặc kịch bản tự động hóa, hãy chọn cách slicing chuỗi vì nó trực quan, dễ bảo trì và cực kỳ chuẩn Python (Pythonic). Bạn chỉ nên dùng toán học (vòng lặp while) khi đang tham gia phỏng vấn xin việc thuật toán, thi đấu lập trình, hoặc chạy code trên vi điều khiển có RAM cực thấp.

Sự khác biệt về bộ nhớ khi kiểm tra số palindrome trong Python là gì?

Cách dùng chuỗi có độ phức tạp bộ nhớ là O(n) do hệ thống phải cấp phát thêm bộ nhớ mới để lưu lại chuỗi đảo ngược của con số. Ngược lại, cách dùng toán học bằng vòng lặp while có độ phức tạp bộ nhớ chỉ là O(1), do nó thao tác chia chẵn lẻ trực tiếp trên biến số nguyên mà không sinh ra dữ liệu mới.

Tại sao code kiểm tra palindrome Python bằng while lại bị lặp vô hạn?

Lỗi lặp vô hạn (treo chương trình) xảy ra khi bạn sử dụng nhầm toán tử chia. Nếu bạn dùng dấu chia thập phân / thay vì dấu chia lấy phần nguyên //, biến đếm n sẽ liên tục biến thành số thập phân bé dần (như 0.1, 0.01) nhưng vĩnh viễn không bao giờ bằng 0. Do đó, điều kiện while n > 0 không bao giờ bị phá vỡ.

Kết luận

Bài toán kiểm tra số palindrome tuy đơn giản nhưng lại là một phép thử rất tốt để phân loại tư duy lập trình viên. Trong môi trường thực tế hàng ngày, hãy tự tin sử dụng cú pháp slicing chuỗi để tiết kiệm thời gian code và dễ dàng bảo trì. Tuy nhiên, khi đối diện với các bài kiểm tra thuật toán khắt khe hoặc muốn ép bản thân rèn luyện tư duy logic cốt lõi, việc tự tay xây dựng vòng lặp bằng toán tử chia lấy dư chắc chắn sẽ giúp bạn tiến bộ vượt bậc. Chúc bạn thực hành hiệu quả!

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