Tính giai thừa của 1 số – Bài tập Python cơ bản

import math
import sys

# Khắc phục lỗi bảo mật Int-to-String (Python 3.11+)
# Cho phép convert số có tối đa 100.000 chữ số (Default là 4300)
try:
    sys.set_int_max_str_digits(100000)
except AttributeError:
    pass # Python bản cũ chưa có tính năng này

def calculate_factorial_safe(n: int) -> int:
    """
    Sử dụng Module C-Extension (math) thay vì viết lại vòng lặp.
    Đây là cách nhanh nhất vì nó chạy ở tầng máy (Machine Code).
    """
    if n < 0:
        raise ValueError("Giai thừa không xác định cho số âm.")
    return math.factorial(n)

import math
import sys
import time

class SmartFactorial:
    def __init__(self):
        # Mở giới hạn string conversion an toàn
        if hasattr(sys, "set_int_max_str_digits"):
            sys.set_int_max_str_digits(50000)

    def compute(self, n: int):
        print(f"\n🚀 Đang tính {n}! ...")
        
        # 1. Đo lường thời gian tính toán (Computation Time)
        t0 = time.perf_counter()
        result = math.factorial(n)
        t1 = time.perf_counter()
        calc_time = (t1 - t0) * 1000
        
        # 2. Xử lý hiển thị thông minh (Smart Output)
        # Nếu số quá lớn (> 1000 chữ số), KHÔNG convert sang string ngay
        # Sử dụng Logarithm để tính độ dài
        num_digits = int(math.log10(n) * n) if n > 0 else 1 # Ước lượng sơ bộ
        
        if num_digits < 1000:
            print(f"✅ Kết quả: {result}")
        else:
            # Chỉ tính toán độ dài chính xác bằng len(str()) nếu thực sự cần thiết
            # Cảnh báo rủi ro I/O
            print(f"⚠️ Kết quả có {len(str(result))} chữ số.")
            print(f"ℹ️ Dạng khoa học: {self.format_scientific(result)}")
            
        print(f"⚡ Core CPU Time: {calc_time:.4f} ms")

    @staticmethod
    def format_scientific(number):
        """Chuyển BigInt sang dạng a.bc x 10^n mà không cần convert toàn bộ chuỗi"""
        # Đây là kỹ thuật trick: Lấy log10 để tìm số mũ
        # log10(x) = exponent.mantissa
        if number == 0: return "0"
        
        # Với số cực lớn, không thể dùng math.log10 trực tiếp vì Overflow
        # Ta dùng convert string giới hạn
        s = str(number)
        exponent = len(s) - 1
        mantissa = s[:4] # Lấy 4 số đầu
        return f"{mantissa[0]}.{mantissa[1:]}e+{exponent}"

if __name__ == "__main__":
    tool = SmartFactorial()
    tool.compute(100)
    tool.compute(20000) # Thử thách số lớn

import math
import decimal

class StatisticalEngine:
    """
    Engine toán học dùng cho Machine Learning / Data Science.
    Không bao giờ tính giá trị thực của n!.
    Luôn làm việc trên không gian Logarithm (Log-Space).
    """
    
    @staticmethod
    def log_factorial(n: int) -> float:
        """
        Tính ln(n!) cực nhanh.
        Dùng math.lgamma (Log Gamma Function) - Được viết bằng C cực tối ưu.
        Độ phức tạp O(1) hoặc O(log n) tùy implementation, nhanh hơn O(N) vòng lặp.
        """
        # Gamma(n+1) = n!
        return math.lgamma(n + 1)

    @staticmethod
    def stirling_approximation(n: int) -> float:
        """
        Tính giá trị xấp xỉ cho n siêu lớn (n > 1 tỷ) mà math.factorial sẽ treo máy.
        """
        if n == 0: return 0
        # Công thức Stirling dạng Log
        return n * math.log(n) - n + 0.5 * math.log(2 * math.pi * n)

    @staticmethod
    def calculate_combination_log(n: int, k: int) -> float:
        """
        Tính C(n, k) = n! / (k! * (n-k)!)
        Trong Log-space: log(C) = log(n!) - log(k!) - log(n-k)!
        Tránh hoàn toàn việc tính số lớn.
        """
        return math.lgamma(n+1) - math.lgamma(k+1) - math.lgamma(n-k+1)

# Demo ứng dụng: Tính xác suất trúng Vietlott (Chọn 6 số từ 45)
# C(45, 6)
engine = StatisticalEngine()
log_result = engine.calculate_combination_log(45, 6)
real_result = math.exp(log_result) # Convert ngược lại (chỉ khi số nhỏ)

print(f"Log xác suất: {log_result:.4f}")
print(f"Số cách chọn (approx): {real_result:,.0f}") 
# Kết quả chuẩn xác: 8,145,060 mà không cần thực hiện phép nhân giai thừa nào!