Làm quen với Python

Danh sách bài tập

Note: Đề bài được tạo bằng pipeline scrape từ web trường (Moodle PHP) về, và reformat từng bài bằng Gemini 2.0 Flash (sửa lại markdown, nếu có ảnh, dịch ra latex hoặc sử dụng ASCII để minh họa). Để AI tự code rồi tự check trên Mimgo thì chắc cũng được nhưng mà thôi 🥴.

1.1 Tính tổng 2 số

Viết chương trình nhập vào 2 số nguyên từ bàn phím, mỗi số nhập trên 1 dòng, tính tổng và in kết quả ra màn hình.

Ví dụ:

Input là:

• $ 101 $
• $ 201 $

Output là:

• $ 302 $

while True:
    try:
        a = int(input())
        b = int(input())
        print(a + b)
        break
    except ValueError:
        print("Invalid input. Please enter integers.")

1.2 Số siêu nguyên tố

Viết chương trình nhập vào số nguyên dương $n$ từ bàn phím, kiểm tra xem $n$ có phải là số siêu nguyên tố hay không?

Số siêu nguyên tố là số nguyên tố mà khi bỏ 1 số tùy ý các chữ số bên phải của nó thì phần còn lại vẫn là số nguyên tố.

Ví dụ:

• Với $ n = 5939 $ kết quả là True.
• Với $ n = 26 $ kết quả là False.
• Với $ n = 43 $ kết quả là False.

import math

test_sup_prime = [5939, 26, 43, 0]

def is_super_prime(number):
    if number < 2:
        return False
    while number > 0:
        if not is_prime(number):
            return False
        else:
            number = number // 10
            
    return True


def is_prime(number):
    if number < 2:
        return False
    for i in range(2, int(math.sqrt(number)) + 1):
        if number % i == 0:
            return False

    return True

for test in test_sup_prime:
    print(is_super_prime(test))

1.3 Giải phương trình bậc 2

Viết chương trình giải và biện luận phương trình bậc 2. Giải và biện luận phương trình $ax^2 + bx + c = 0 $:

• Phương trình có nghiệm duy nhất in ra nghiệm duy nhất.
• Phương trình Có 2 nghiệm in ra 2 nghiệm cách nhau bởi 1 dấu cách.
• Phương trình vô nghiệm in ra VN.
• Phương trình vô số nghiệm in ra VSN.

import math

def solver(a, b, c):
    if a == 0:
        if b == 0:
            if c == 0:
                print("VSN")
            else:
                print("VN")
        else:
            x = -c / b
            print(f"{x:.2f}")
    else:
        delta = b ** 2 - 4 * a * c
        if delta < 0:
            print("VN")
        elif delta == 0:
            x = -b / (2 * a)
            print(f"{x:.2f}")
        else:
            x1 = (-b - math.sqrt(delta)) / (2 * a)
            x2 = (-b + math.sqrt(delta)) / (2 * a)
            print(f"{x1} {x2}")
            # print(f"{x1:.2f} {x2:.2f}")

1.4 Tam giác

Nhập ba số $ a, b, c $ tương ứng là độ dài 3

cạnh của một tam giác. Kiểm tra xem 3 cạnh có lập thành tam giác hay không, nếu có, tính chu vi và diện tích tam giác.

Chú ý, $ a, b , c $ được nhập lần lượt trên từng dòng.

• Nếu 3 cạnh không lập thành tam giác in ra INVALID
• Nếu 3 cạnh lập thành tam giác in ra S = #S C = #C

trong đó #S, #C là chu vi và diện tích của tam giác

import math

a = float(input())
b = float(input())
c = float(input())

def triangle_checker(a, b, c):
    if not ((a + b > c) and (a + c > b) and (b + c > a)):
        print("INVALID")
        return

    C = a + b + c
    s = C / 2
    S = math.sqrt(s * (s - a) * (s - b) * (s - c))

    print(f"S = {S} ; C = {C}")

triangle_checker(a, b, c)

1.5 Tính giai thừa kép

Nhập vào một số nguyên dương $n$, tính giai thừa kép $ n!! $ của $ n $.

\[n!! = \begin{cases} 2 \times 4 \times 6 \times \cdots \times n & \text{với } n \text{ là số chẵn} \\ 1 \times 3 \times 5 \times \cdots \times n & \text{với } n \text{ là số lẻ} \end{cases}\]

• Ví dụ $n = 6$, kết quả in ra là $6!! = 48 $.

import math

n = int(input())

# def dual_factorial(n):
#     result = 1
    
#     if n % 2 == 0:
#         for i in range(2, n + 2, 2):
#             result = result * i

#     else:
#         for i in range(1, n + 2, 2):
#             result = result * i

#     return result

def dual_factorial(n):
    return math.prod(range(1 if n % 2 != 0 else 2, n + 1, 2))

print(f"{n}!! = {dual_factorial(n)}")

1.6 Bộ 3 Pitago

Viết chương trình thực hiện việc nhập số nguyên $ n $, liệt kê các số nguyên $ a, b, c $ trong đoạn $ [1, n] $ để bộ 3 $ (a, b, c) $ lập thành bộ Pitago.

$ a, b, c $ được sắp theo thứ tự tăng dần $ (a \leq b \leq c) $, mỗi bộ trên 1 dòng theo mẫu $ (a, b, c) $.

n = int(input())

triples = []

for c in range(1, n + 1):
    for b in range(1, c + 1):
        for a in range(1, b + 1):
            if a * a + b * b == c * c:
                triples.append((a, b, c))

triples.sort()

for triple in triples:
    print(f"({triple[0]}, {triple[1]}, {triple[2]})")

1.7 Tính tổng

Viết chương trình cho phép nhập một số nguyên $n$ từ bàn phím, tính và in ra kết quả của biểu thức $n + nn + nnn + nnnn $.

• Ví dụ $n = 5$, kết quả là $5 + 55 + 5555 + 5555 = 6170 $
• Chú ý: $ n $ có thể là số tự nhiên bất kỳ

n = input().strip()

n1 = int(n)
n2 = int(n * 2)
n3 = int(n * 3)
n4 = int(n * 4)

result = n1 + n2 + n3 + n4

print(result)

n = input().strip()

is_negative = n[0] == '-'

n_abs = n.lstrip('-')

n1 = int(n_abs)
n2 = int(n_abs * 2)
n3 = int(n_abs * 3)
n4 = int(n_abs * 4)

if is_negative:
    result = -n1 + n2 - n3 + n4
else:
    result = n1 + n2 + n3 + n4

print(result)

1.8 Số đối xứng

Hoàn thiện hàm is_palindrome(p), hàm này thực hiện kiểm tra số nguyên p có phải là số đối xứng hay không, nếu có thì trả lại giá trị True, và ngược lại thì trả lại giá trị False.

def is_palindrome(p):
    p = str(p)
    return p == p[::-1]

1.9 Phân số

• Hàm is_minimalist_fraction(numerator, denominator) kiểm tra phân số gồm tử số là numerator, và mẫu số là denominator có phải phân số tối giản hay không?
• Hàm get_minimalist_fraction(numerator, denominator) thực hiện tính và trả lại phân số tối giản của phân số đầu vào (phân số được trả lại là 2 giá trị tương ứng là tử số và mẫu số)
• Bạn có thể dùng hàm gcd(u, v) trong module math để tìm ước chung lớn nhất của 2 số  u, v.

from math import gcd

# Hàm is_minimalist_fraction(numerator, denominator) kiểm tra phân số gồm tử số
# là numerator, và mẫu số là denominator có phải phân số tối giản hay không nếu
# đúng trả lại giá trị là True, ngược lại trả lại giá trị là False?

def is_minimalist_fraction(numerator, denominator):
    if denominator == 0:
        return False
    return gcd(numerator, denominator) == 1

# Hàm get_minimalist_fraction(numerator, denominator) thực hiện tính và trả lại
# phân số tối giản của phân số đầu vào (phân số được trả lại là 2 giá trị tương
# ứng là tử số và mẫu số)

def get_minimalist_fraction(numerator, denominator):
    if denominator == 0:
        raise ValueError("Mẫu số không được bằng 0")
    common_divisor = gcd(numerator, denominator)
    return numerator // common_divisor, denominator // common_divisor

1.10 Giải phương trình bằng phương pháp chia đôi

• Hàm $ f(x) $ liên tục trên đoạn $ [a, b] $ và có $ f(a) \cdot f(b) < 0 $ thì tồn tại giá trị $ c $ thuộc $ [a, b] $ sao cho $ f(c) = 0 $.
• Hoàn thiện hàm solver(f, a, b, e=0.00001) để tìm nghiệm xấp xỉ của phương trình $ f(x) = 0 $.
• Trong các đối số có $ f $ là 1 hàm, khi đó lời gọi hàm $ f(t) $ sẽ trả lại giá trị của hàm $ f $ tại điểm $ t $.
• Nghiệm cần tìm là giá trị $ c $ sao cho $ \mid f(c) \mid \leq e $. Dùng hàm abs trong module math để tính giá trị tuyệt đối.
• Áp dụng phương pháp chia đôi để tìm nghiệm gần đúng của phương trình.

# giải phương trình f(x) = 0, tìm nghiệm xấp xỉ c theo phương pháp chia đôi.
def solver(f, a, b, e=0.000001):
    if f(a) * f(b) >= 0:
        raise ValueError()

    while True:
        c = (a + b) / 2
        fc = f(c)
        if abs(fc) <= e or (b - a) / 2 < e:
            return c
        if f(a) * fc < 0:
            b = c
        else:
            a = c

1.11 Tính sin, cos theo khai triển Taylor

• Hoàn thiện 2 phương thức sinTaylor(x), cosTaylor(x) với $x$ cho trước.

\[\sin x = \sum_{n=0}^{\infty} \frac{(-1)^n}{(2n + 1)!} x^{2n+1} = x - \frac{x^3}{3!} + \frac{x^5}{5!} - \cdots \quad \text{với mọi } x \\ \cos x = \sum_{n=0}^{\infty} \frac{(-1)^n}{(2n)!} x^{2n} = 1 - \frac{x^2}{2!} + \frac{x^4}{4!} - \cdots \quad \text{với mọi } x\]

• Chú ý: Điều kiện dừng: $\frac{(x^n)}{n!} = 0$.

from math import factorial

def sinTaylor(x):
    n = 0
    term = x
    total = 0
    while abs(term) > 1e-15:
        term = ((-1)**n) * (x**(2*n + 1)) / factorial(2*n + 1)
        total += term
        n += 1
    return total

def cosTaylor(x):
    n = 0
    term = 1
    total = 0
    while abs(term) > 1e-15:
        term = ((-1)**n) * (x**(2*n)) / factorial(2*n)
        total += term
        n += 1
    return total

1.12 Căn bậc hai theo phương pháp Newton

• Tính căn bậc hai theo phương pháp Newton: Để tính căn bậc hai của một số dương $t$, hãy bắt đầu với ước tính $t = c$. Nếu $t = c/ t$ thì $t$ bằng căn bậc hai của $c$. Nếu không, hãy tinh chỉnh ước tính bằng cách thay thế $t$ bằng giá trị trung bình của $t$ và $c/t$ và lặp lại cho tới khi nhận được kết quả có độ chính xác tới 15 chữ số sau dấu phẩy. Chú ý: Điều kiện dừng là abs(t - c/t) < (EPSILON * t). Với EPSILON = 10E-15.

def sqrt_newton(c):
    EPSILON = 1e-15
    if c < 0:
        raise ValueError()
    if c == 0:
        return 0.0

    t = c
    while abs(t - c / t) > EPSILON * t:
        t = (t + c / t) / 2
    return t

1.13 Vay vốn trả góp

Hãy hoàn thiện phương thức trả nợ:

Dưới đây là cách tính tiền hoàn nợ:

Cách tính số tiền còn lại sau $n$ tháng giống hoàn toàn công thức gửi tiết kiệm ngân hàng và rút tiền hàng tháng nên ta có:

\[S_n = A(1 + r)^n - X \frac{(1 + r)^n - 1}{r}\]

Để sau đúng $n$ tháng trả hết nợ thì $S_n = 0$ nên

\[A(1 + r)^n - X \frac{(1 + r)^n - 1}{r} = 0\]

và

\[X = \frac{A(1 + r)^n r}{(1 + r)^n - 1}\]

Chú ý:

Ví dụ:

Đầu vào cho trước: $A = 3786784723$

$r = 0.12$

$n = 6$

Đầu ra:

• Vay: 3,786,784,723.00 Đồng
• Lãi suất: 12.00%/tháng
• Trong: 6.00 tháng
• Mỗi tháng cần trả: 921,043,434.771 Đồng

Mỗi thông tin được in trên một dòng; các mục Vay, Lãi suất, Số Tháng thì được lấy 2 chữ số sau dấu phẩy, mục Trả góp lấy 3 chữ số sau dấu phẩy.

Để in có định dạng dấu phẩy phân cách hàng nghìn có thể dùng phương thức format của lớp String (str)

Ví dụ: print("{:,.3f}".format(56789))

Kết quả in ra là: 56,789.000

def loan(A, r, n):
    X = (A * (1 + r)**n * r) / ((1 + r)**n - 1)
    
    print("Vay: {:,.2f} Đồng".format(A))
    print("Lãi suất: {:.2f}%/tháng".format(r * 100))
    print("Trong: {:.2f} tháng".format(n))
    print("Mỗi tháng cần trả: {:,.3f} Đồng".format(X))

1.14 Thừa số nguyên tố

• Sinh viên hoàn thiện phương thức parse nhận $n$ là tham số đầu vào cho phép phân tích 1 số nguyên dương thành tích các thừa số nguyên tố sử dụng thuật toán sàng nguyên tố Eratosthenes. Thuật toán sàng: Duyệt hết tất cả các số từ 1 đến $N$ và đếm số ước của $N$. Nếu số ước của $N$ là 2 thì $N$ là số nguyên tố, nếu không thì $N$ không là số nguyên tố.
• Ví dụ: Input: 15 Output: 15 = 3 x 5.

def parse(n):
    def is_prime(x):
        if x < 2:
            return False
        for i in range(2, int(x**0.5) + 1):
            if x % i == 0:
                return False
        return True

    result = []
    i = 2
    original = n
    while i <= n:
        if is_prime(i) and n % i == 0:
            result.append(str(i))
            n //= i
        else:
            i += 1

    print(f"{original} = {' x '.join(result)}")

1.15 ToBinary

Sinh viên hoàn thiện hàm convert trong file ToBinary.py, hàm này nhận vào đối số $n$ là một số nguyên hệ cơ số 10 và trả về chuỗi dạng nhị phân của $n$.

Sử dụng phép chuyển đổi số dạng thập phân sang nhị phân bằng phép chia với 2.

11 | 2
---
 1 | 5 | 2
     ---
     1 | 2 | 2
         ---
         0 | 1 | 2
             ---
             1 | 0

Ví dụ:

• input = 11
• output = 1011

def convert(n):
    if n == 0:
        return "0"
    bits = []
    while n > 0:
        bits.append(str(n % 2))
        n //= 2
    return ''.join(reversed(bits))

1.16 ToDecimal

Sinh viên hoàn thiện phương thức convert với n là tham số cho trước để thực hiện chuyển đổi số dạng nhị phân sang thập phân.

Xét ví dụ:

Bây giờ chúng ta chuyển số nhị phân 1000111 về số thập phân. Ta thấy số 1000111 có tổng cộng 7 kí tự, chúng ta sẽ đánh số 7 kí tự này từ phải sang trái và bắt đầu từ 0 như sau:

Số thập phân kết quả sẽ là tổng các tích của kí tự nhị phân x 2 lũy thừa vị trí.

Tức là $1 \times 2^6 + 0 \times 2^5 + 0 \times 2^4 + 0 \times 2^3 + 1 \times 2^2 + 1 \times 2^1 + 1 \times 2^0$ $= 64 + 0 + 0 + 0 + 4 + 2 + 1 = 71$

Chú ý: Kiểu dữ liệu đầu vào là xâu (chuỗi).

Ví dụ:

• input = "00001"
• output = 1

def convert(n):
    n = n.replace(" ", "")
    result = 0
    for i in range(len(n)):
        result += int(n[-(i + 1)]) * (2 ** i)
    return result

1.17 Add binary

Sinh viên hoàn thiện phương thức add(a, b) với a, b là tham số truyền vào cho trước để thực hiện phép cộng nhị phân.

Xét ví dụ dưới đây:

Để cộng hai số nhị phân, chúng ta cần nhớ các nguyên tắc sau: $0 + 0 = 0$ $1 + 0 = 1$ $0 + 1 = 1$ $1 + 1 = 10$ (nhớ 1 để cộng vào hàng trước nó, tương tự như phép cộng số thập phân)

Bây giờ ta tiến hành cộng hai số nhị phân 1000111 (số 71 trong hệ thập phân) và 11110 (số 30 trong hệ thập phân).

Chú ý: Kiểu dữ liệu đầu vào là xâu (chuỗi). Ví dụ: “0001”

def add(a, b):
    a = a.replace(" ", "")
    b = b.replace(" ", "")
    
    max_len = max(len(a), len(b))
    a = a.zfill(max_len)
    b = b.zfill(max_len)

    carry = 0
    result = []

    for i in range(max_len - 1, -1, -1):
        sum = int(a[i]) + int(b[i]) + carry
        if sum == 0:
            result.append('0')
            carry = 0
        elif sum == 1:
            result.append('1')
            carry = 0
        elif sum == 2:
            result.append('0')
            carry = 1
        else:
            result.append('1')
            carry = 1

    if carry:
        result.append('1')

    return ''.join(reversed(result))

1.18 Pyramid Patterns

Mục tiêu: Hoàn thiện các hàm để in ra màn hình các mẫu hình tam giác khác nhau dựa trên kích thước đầu vào n.

Ví dụ với input: n=5

Output mong muốn (minh họa bằng ASCII):

1, leftHalfPyramid(n)

*
**
***
****
*****

2, rightHalfPyramid(n)

    *
   **
  ***
 ****
*****

3, fullPyramid(n)

    *
   ***
  *****
 *******
*********

4, invertedFullPyramid(n)

*********
 *******
  *****
   ***
    *

5, hollowPyramid(n)

    *
   * *
  *   *
 *     *
*********

def leftHalfPyramid(n):
    for i in range(1, n + 1):
        print("*" * i)

def rightHalfPyramid(n):
    for i in range(1, n + 1):
        print(" " * (n - i) + "*" * i)

def fullPyramid(n):
    for i in range(1, n + 1):
        print(" " * (n - i) + "*" * (2 * i - 1))

def invertedFullPyramid(n):
    for i in range(n, 0, -1):
        print(" " * (n - i) + "*" * (2 * i - 1))

def hollowPyramid(n):
    for i in range(1, n + 1):
        if i == n:
            print("*" * (2 * n - 1))
        else:
            spaces = 2 * i - 3
            if spaces < 0:
                print(" " * (n - i) + "*")
            else:
                print(" " * (n - i) + "*" + " " * spaces + "*")

Bài tập tổng hợp 1

Câu 1:

• Số hoàn hảo là một số nguyên dương mà tổng các ước nguyên dương thực sự của nó (các ước nguyên dương ngoại trừ chính số đó) bằng chính nó. Hoàn thiện hàm isPerfectNumber(number) nhận vào số nguyên dương number và trả về True nếu number là số hoàn hảo và False nếu number không phải là số hoàn hảo.
• Ví dụ:
• input: 6 output: True
• input: 14 output: False

Câu 2:

• Hoàn thiện hàm drawPatterm(height: int) nhận đầu vào là số nguyên dương height. Hãy vẽ hình vuông có chiều cao height.
• Ví dụ
• input: 4

****
*  *
*  *
****

Câu 3:

• $ e^x$ được tính theo công thức sau:

\[e^x = 1 + \frac{x}{1!} + \frac{x^2}{2!} + \frac{x^3}{3!} + ... + \frac{x^n}{n!}\]

• Hãy hoàn thiện hàm caculateExp(x : float, n : int) trả về giá trị của $e^x$ tính theo giá trị của $n$ dựa vào công thức trên.

def isPerfectNumber(number: int):
    total = 0
    for i in range(1, number):
        if number % i == 0:
            total += i
    return total == number

def drawPatterm(height: int):
    for i in range(height):
        if i == 0 or i == height - 1:
            print("*" * height)
        else:
            print("*" + " " * (height - 2) + "*")

def caculateExp(x: float, n: int):
    result = 1.0
    term = 1.0
    for i in range(1, n + 1):
        term *= x / i
        result += term
    return result

1.1.4 Fibonacci Series

• Dãy Fibonacci là dãy số tự nhiên có công thức truy hồi như sau:

\[\begin{cases} F(n) = F(n-1) + F(n-2) \\ F(0) = F(1) = 1 \end{cases}\]

• Hoàn thiện hàm displayFibonacciSeries(n) nhận vào số nguyên dương $n$ và in ra $n$ số đầu tiên của dãy Fibonacci. Định dạng đầu vào và đầu ra như sau.
• input: 5
• output: 1 1 2 3 5

def displayFibonacciSeries(n):
    a, b = 1, 1
    result = []
    for _ in range(n):
        result.append(str(a))
        a, b = b, a + b
    print(" ".join(result))

1.1.5 Kth Largest Element

• Viết chương trình nhận vào số nguyên dương $k$ và mảng gồm $n$ số nguyên $(n \geq 1)$. In ra màn hình phần tử lớn thứ $k$ trong mảng, nếu không tồn tại phần tử lớn thứ $k$ thì in ra màn hình thông báo "Unable to get kth largest element". Định dạng đầu vào và đầu ra tương ứng như sau:

input: 
3 
2 3 1 1 4 
output: 3 

input: 
4 
2 2 1 1 1 
output: Unable to get kth largest element 

k = int(input())
arr = list(map(int, input().split()))
unique_sorted = sorted(set(arr), reverse=True)

if k <= len(unique_sorted):
    print(unique_sorted[k - 1])
else:
    print("Unable to get kth largest element")

1.1.6 GPA Calculator

Sau khi biết điểm tổng kết học phần hệ 10 của từng môn học trong học kỳ, bạn Việt muốn tính xem GPA theo hệ 4 và xếp loại tương ứng của kỳ học này là gì. Biết rằng để tính GPA theo hệ 4 ta dùng công thức sau:

$ GPA = \dfrac{\displaystyle\sum_{i = 1}^n c_i \times g_i}{\displaystyle\sum_{i = 1}^n c_i} $

trong đó $c_i, g_i \ (i = 1, 2, …, n) $ lần lượt là số tín chỉ và điểm hệ 4 tương ứng của từng môn học (n môn học). Điểm tổng kết học phần hệ 10 được làm tròn đến 1 chữ số thập phân sau dấu phẩy và GPA hệ 4 được làm tròn đến 2 chữ số thập phân sau dấu phẩy.

Công thức quy đổi từ điểm hệ 10 sang điểm chữ và sang điểm hệ 4 tương ứng như sau:

Bảng quy đổi điểm hệ 10, điểm chữ và điểm hệ 4

Xếp loại với GPA hệ 4 tương ứng như sau:

Hãy viết chương trình giúp Việt tính GPA theo hệ 4 và xếp loại tương ứng. Biết rằng đầu vào của chương trình nhận dòng đầu tiên là số nguyên $n$ tương ứng với số môn học trong học kỳ, sau đó là $n$ dòng với định dạng “<số tín chỉ môn học> <điểm hệ 10 của môn học tương ứng>”. Kết quả đầu ra cần đưa ra được thông tin về GPA hệ 4 và xếp loại học lực tương ứng theo định dạng “<GPA>: <Xếp loại>”. Nếu đạt loại xuất sắc thì xếp loại in ra là “Excellent”, loại giỏi là “Very good”, loại khá là “Good”, loại trung bình là “Average”, loại yếu là “At risk”.

Định dạng đầu vào và đầu ra tương ứng như sau:

Input:

4
3 8.9
4 10
5 10
4 8.8

Output:

• 3.87: Excellent

def convert_to_g4(score_10):
    if 9.0 <= score_10 <= 10.0:
        return 4.0
    elif 8.5 <= score_10 < 9.0:
        return 3.7
    elif 8.0 <= score_10 < 8.5:
        return 3.5
    elif 7.0 <= score_10 < 8.0:
        return 3.0
    elif 6.5 <= score_10 < 7.0:
        return 2.5
    elif 5.5 <= score_10 < 6.5:
        return 2.0
    elif 5.0 <= score_10 < 5.5:
        return 1.5
    elif 4.0 <= score_10 < 5.0:
        return 1.0
    else:
        return 0.0

def classify(gpa):
    if gpa >= 3.6:
        return "Excellent"
    elif gpa >= 3.2:
        return "Very good"
    elif gpa >= 2.5:
        return "Good"
    elif gpa >= 2.0:
        return "Average"
    else:
        return "At risk"

n = int(input())
total_credits = 0
total_points = 0

for _ in range(n):
    credit, score_10 = input().split()
    credit = int(credit)
    score_10 = round(float(score_10), 1)
    g4 = convert_to_g4(score_10)
    total_credits += credit
    total_points += credit * g4

gpa = round(total_points / total_credits, 2)
print(f"{gpa:.2f}: {classify(gpa)}")

1.1.7 Birthday Paradox

• Viết chương trình nhận vào số nguyên dương $n$ và in ra xác suất có ít nhất 2 sinh viên trùng ngày sinh nhật (trùng ngày và tháng) trong 1 lớp có $n$ người, giả sử rằng năm đó có 365 ngày. Kết quả xác suất được nhân với 100% và làm tròn đến 10 chữ số thập phân sau dấu phẩy. Chi tiết đầu vào và đầu ra của chương trình như sau.
• input: 10
• output: 11.6948177711%

n = int(input())
if n > 365:
    print("100.0000000000%")
else:
    prob_unique = 1.0
    for i in range(n):
        prob_unique *= (365 - i) / 365
    prob_shared = 1 - prob_unique
    print(f"{prob_shared * 100:.10f}%")