Khóa học Python từ Cơ bản đến Nâng cao

def find_second_largest_sorting(numbers):
    # Bước 1: Kiểm tra danh sách có đủ phần tử không
    # Nếu danh sách rỗng hoặc chỉ có 1 phần tử, không thể có số lớn thứ hai
    if len(numbers) < 2:
        return "Danh sách cần ít nhất 2 phần tử để có số lớn thứ hai."

    # Bước 2: Tạo một bản sao của danh sách và sắp xếp nó
    # Sử dụng sorted() thay vì sort() để không làm thay đổi danh sách gốc
    # sorted() trả về một danh sách mới đã được sắp xếp
    sorted_numbers = sorted(numbers)

    # Bước 3: Trả về phần tử áp chót
    # Trong Python, chỉ số âm -1 là phần tử cuối cùng, -2 là phần tử áp chót
    return sorted_numbers[-2]

# --- Các ví dụ minh họa ---

print("--- Phương pháp 1: Sắp xếp ---")

# Ví dụ 1: Danh sách cơ bản
my_list_1 = [10, 5, 20, 15, 25]
result_1 = find_second_largest_sorting(my_list_1)
print(f"Danh sách: {my_list_1}")
print(f"Số lớn thứ hai: {result_1}") # Kết quả: 20

# Ví dụ 2: Danh sách có số trùng lặp
my_list_2 = [30, 10, 20, 30, 25, 10]
result_2 = find_second_largest_sorting(my_list_2)
print(f"\nDanh sách: {my_list_2}")
print(f"Số lớn thứ hai (có trùng lặp): {result_2}") # Kết quả: 30 (vì 30 xuất hiện 2 lần, vị trí áp chót là 30)

# Ví dụ 3: Danh sách tất cả các số giống nhau
my_list_3 = [7, 7, 7, 7]
result_3 = find_second_largest_sorting(my_list_3)
print(f"\nDanh sách: {my_list_3}")
print(f"Số lớn thứ hai (tất cả giống nhau): {result_3}") # Kết quả: 7 (vì sau khi sắp xếp là [7, 7, 7, 7], áp chót là 7)

# Ví dụ 4: Danh sách có số âm
my_list_4 = [-10, -5, -20, -15, -25]
result_4 = find_second_largest_sorting(my_list_4)
print(f"\nDanh sách: {my_list_4}")
print(f"Số lớn thứ hai (số âm): {result_4}") # Kết quả: -10

# Ví dụ 5: Edge case - Chỉ có 1 phần tử
my_list_5 = [42]
result_5 = find_second_largest_sorting(my_list_5)
print(f"\nDanh sách: {my_list_5}")
print(f"Số lớn thứ hai (1 phần tử): {result_5}") # Kết quả: Thông báo lỗi

# Ví dụ 6: Edge case - Danh sách rỗng
my_list_6 = []
result_6 = find_second_largest_sorting(my_list_6)
print(f"\nDanh sách: {my_list_6}")
print(f"Số lớn thứ hai (rỗng): {result_6}") # Kết quả: Thông báo lỗi

import sys # Cần thiết để sử dụng sys.float('-inf')

def find_second_largest_iteration(numbers):
    # Bước 1: Kiểm tra danh sách có đủ phần tử không
    if len(numbers) < 2:
        return "Danh sách cần ít nhất 2 phần tử để có số lớn thứ hai."

    # Bước 2: Khởi tạo hai biến để lưu trữ số lớn nhất và lớn thứ hai
    # Ban đầu, gán chúng bằng giá trị âm vô cùng để đảm bảo mọi số trong danh sách
    # (kể cả số âm) đều lớn hơn giá trị khởi tạo này.
    largest = float('-inf')
    second_largest = float('-inf')

    # Bước 3: Duyệt qua từng phần tử trong danh sách
    for number in numbers:
        # Nếu số hiện tại (number) lớn hơn số lớn nhất (largest) đã biết
        if number > largest:
            # Số lớn nhất cũ (largest) bây giờ trở thành số lớn thứ hai (second_largest)
            second_largest = largest
            # Cập nhật số lớn nhất mới
            largest = number
        # Ngược lại (số hiện tại KHÔNG lớn hơn số lớn nhất),
        # Kiểm tra xem nó có lớn hơn số lớn thứ hai đã biết không
        # VÀ đảm bảo nó KHÔNG phải là số lớn nhất hiện tại (để xử lý trùng lặp của số lớn nhất)
        elif number > second_largest and number != largest:
            # Nếu đúng, cập nhật số lớn thứ hai
            second_largest = number

    # Bước 4: Kiểm tra kết quả cuối cùng
    # Nếu sau khi duyệt hết, second_largest vẫn là float('-inf'),
    # điều này có nghĩa là không tìm thấy số lớn thứ hai hợp lệ.
    # Điều này xảy ra nếu tất cả các số trong danh sách đều giống nhau
    # hoặc danh sách chỉ có đúng 2 phần tử và 2 phần tử đó bằng nhau.
    # Trong trường hợp tất cả các số giống nhau, chúng ta có thể coi số lớn thứ hai là chính số đó
    # (tương tự cách xử lý của phương pháp Sắp xếp) hoặc trả về thông báo.
    # Ở đây, ta sẽ trả về giá trị của largest nếu second_largest không thay đổi.
    if second_largest == float('-inf'):
         # Điều này xảy ra nếu list có dạng [x, x, x...] hoặc [x, x].
         # Theo cách hiểu của phương pháp Sắp xếp, số lớn thứ hai cũng là x.
         # Hoặc có thể trả về thông báo "Không có số lớn thứ hai duy nhất".
         # Chọn trả về largest để nhất quán hơn với phương pháp Sắp xếp khi có trùng lặp
         return largest
    else:
        return second_largest

# --- Các ví dụ minh họa ---

print("\n--- Phương pháp 2: Duyệt qua danh sách ---")

# Ví dụ 1: Danh sách cơ bản
my_list_1 = [10, 5, 20, 15, 25]
result_1 = find_second_largest_iteration(my_list_1)
print(f"Danh sách: {my_list_1}")
print(f"Số lớn thứ hai: {result_1}") # Kết quả: 20

# Ví dụ 2: Danh sách có số trùng lặp (số lớn nhất trùng lặp)
my_list_2 = [30, 10, 20, 30, 25, 10]
result_2 = find_second_largest_iteration(my_list_2)
print(f"\nDanh sách: {my_list_2}")
print(f"Số lớn thứ hai (có trùng lặp số lớn nhất): {result_2}") # Kết quả: 25 (lớn nhất là 30, số lớn thứ hai phân biệt là 25)

# Ví dụ 3: Danh sách tất cả các số giống nhau
my_list_3 = [7, 7, 7, 7]
result_3 = find_second_largest_iteration(my_list_3)
print(f"\nDanh sách: {my_list_3}")
print(f"Số lớn thứ hai (tất cả giống nhau): {result_3}") # Kết quả: 7

# Ví dụ 4: Danh sách có số âm
my_list_4 = [-10, -5, -20, -15, -25]
result_4 = find_second_largest_iteration(my_list_4)
print(f"\nDanh sách: {my_list_4}")
print(f"Số lớn thứ hai (số âm): {result_4}") # Kết quả: -10

# Ví dụ 5: Edge case - Chỉ có 1 phần tử
my_list_5 = [42]
result_5 = find_second_largest_iteration(my_list_5)
print(f"\nDanh sách: {my_list_5}")
print(f"Số lớn thứ hai (1 phần tử): {result_5}") # Kết quả: Thông báo lỗi

# Ví dụ 6: Edge case - Danh sách rỗng
my_list_6 = []
result_6 = find_second_largest_iteration(my_list_6)
print(f"\nDanh sách: {my_list_6}")
print(f"Số lớn thứ hai (rỗng): {result_6}") # Kết quả: Thông báo lỗi

# Ví dụ 7: Edge case - Chỉ có 2 phần tử bằng nhau
my_list_7 = [50, 50]
result_7 = find_second_largest_iteration(my_list_7)
print(f"\nDanh sách: {my_list_7}")
print(f"Số lớn thứ hai (2 phần tử bằng nhau): {result_7}") # Kết quả: 50

# Ví dụ 8: Kết hợp số âm và dương
my_list_8 = [-10, 5, -20, 15, -25, 0]
result_8 = find_second_largest_iteration(my_list_8)
print(f"\nDanh sách: {my_list_8}")
print(f"Số lớn thứ hai (âm dương): {result_8}") # Kết quả: 5

def find_second_largest_set_sorting(numbers):
    # Bước 1: Kiểm tra danh sách đầu vào
     if not numbers: # Kiểm tra danh sách rỗng
        return "Danh sách không được rỗng."

    # Bước 2: Chuyển danh sách sang set để loại bỏ các số trùng lặp
    # Sau đó chuyển set lại thành list để có thể sắp xếp và truy cập theo chỉ số
    unique_numbers = sorted(list(set(numbers)))

    # Bước 3: Kiểm tra số lượng phần tử duy nhất còn lại
    # Nếu chỉ còn 0 hoặc 1 phần tử duy nhất, không thể có số lớn thứ hai duy nhất
    if len(unique_numbers) < 2:
        return "Không đủ số duy nhất để có số lớn thứ hai duy nhất."

    # Bước 4: Trả về phần tử áp chót trong danh sách các số duy nhất đã sắp xếp
    return unique_numbers[-2]

# --- Các ví dụ minh họa ---

print("\n--- Phương pháp 3: Sử dụng Set và Sắp xếp ---")

# Ví dụ 1: Danh sách cơ bản
my_list_1 = [10, 5, 20, 15, 25]
result_1 = find_second_largest_set_sorting(my_list_1)
print(f"Danh sách: {my_list_1}")
print(f"Số lớn thứ hai duy nhất: {result_1}") # Kết quả: 20

# Ví dụ 2: Danh sách có số trùng lặp (số lớn nhất trùng lặp)
my_list_2 = [30, 10, 20, 30, 25, 10]
result_2 = find_second_largest_set_sorting(my_list_2)
print(f"\nDanh sách: {my_list_2}")
print(f"Số lớn thứ hai duy nhất (có trùng lặp): {result_2}") # Kết quả: 25 (sau khi loại bỏ trùng lặp: [10, 20, 25, 30])

# Ví dụ 3: Danh sách tất cả các số giống nhau
my_list_3 = [7, 7, 7, 7]
result_3 = find_second_largest_set_sorting(my_list_3)
print(f"\nDanh sách: {my_list_3}")
print(f"Số lớn thứ hai duy nhất (tất cả giống nhau): {result_3}") # Kết quả: Thông báo lỗi (chỉ còn 1 số duy nhất là 7)

# Ví dụ 4: Edge case - Chỉ có 1 phần tử duy nhất sau khi loại bỏ trùng lặp
my_list_4 = [42, 42, 42]
result_4 = find_second_largest_set_sorting(my_list_4)
print(f"\nDanh sách: {my_list_4}")
print(f"Số lớn thứ hai duy nhất (chỉ 1 duy nhất): {result_4}") # Kết quả: Thông báo lỗi

# Ví dụ 5: Edge case - Danh sách rỗng
my_list_5 = []
result_5 = find_second_largest_set_sorting(my_list_5)
print(f"\nDanh sách: {my_list_5}")
print(f"Số lớn thứ hai duy nhất (rỗng): {result_5}") # Kết quả: Thông báo lỗi

# Ví dụ 6: Chỉ có 2 số duy nhất
my_list_6 = [100, 100, 50, 50, 100]
result_6 = find_second_largest_set_sorting(my_list_6)
print(f"\nDanh sách: {my_list_6}")
print(f"Số lớn thứ hai duy nhất (2 số duy nhất): {result_6}") # Kết quả: 50 (sau khi loại bỏ trùng lặp: [50, 100])