Cấp Độ Nhiệm Vụ: Sơ Cấp (nhưng đầy thử thách!)
Thời Lượng Ước Tính: Khoảng 300 phút (5 giờ) – đủ thời gian để bạn “nạp năng lượng vũ trụ” và “xử lý dữ liệu” liên tục.
Mô tả Nhiệm Vụ: Chào mừng các Nhà Thám Hiểm Dữ Liệu! Hôm nay, phi thuyền của chúng ta sẽ hạ cánh xuống một vùng không gian đặc biệt: Mặt phẳng tọa độ Oxy. Nhiệm vụ của bạn là nhận diện và phân tích một thực thể hình học cơ bản nhưng đầy quyền năng: Hình tam giác ABC.
Chúng ta sẽ được cung cấp tọa độ của ba “ngôi sao” A, B, C và từ đó, bạn phải sử dụng sức mạnh của Python để:
1 Kiểm tra tính tồn tại: Ba ngôi sao này có thật sự tạo thành một “chòm sao tam giác” hay chúng chỉ đang thẳng hàng trên bản đồ thiên văn?
2 Đo đạc vũ trụ: Tính toán khoảng cách giữa các ngôi sao (độ dài cạnh) và độ lớn của các góc mà chúng tạo thành.
3 Phân loại chòm sao: Xác định xem chòm sao tam giác này thuộc loại nào: bình thường, “vuông góc” (vuông), “cân bằng” (cân), “hoàn hảo” (đều), hay “vuông cân” đặc biệt.
4 Tính diện tích vùng ảnh hưởng: Tính diện tích không gian mà chòm sao tam giác này bao phủ.
5 Dựng “đường cao năng lượng”: Tính độ dài các đường cao từ mỗi đỉnh, tượng trưng cho những “trụ năng lượng” thẳng đứng trong không gian.
6 Xác định “đường trung tuyến vận chuyển”: Tính độ dài các đường trung tuyến, giống như những “tuyến đường” kết nối đỉnh với trung điểm cạnh đối diện.
7 Định vị “trung tâm vũ trụ”: Tìm tọa độ Trọng tâm (điểm cân bằng của tam giác) và Trực tâm (giao điểm của các đường cao) – những “điểm neo” quan trọng trong không gian.
Tại sao đây là một dự án thú vị? Đây không chỉ là một bài toán hình học khô khan, mà là cơ hội để bạn biến những công thức toán học thành code Python “sống động”! Bạn sẽ học cách:
• Chia để trị: Phân tách một vấn đề lớn thành nhiều hàm nhỏ, chuyên biệt (chính là sức mạnh của hàm mà chúng ta vừa học!).
• Tái sử dụng code: Viết một hàm để tính khoảng cách giữa hai điểm, rồi dùng nó nhiều lần. Viết một hàm để tính góc, rồi áp dụng cho cả ba góc.
• Xử lý dữ liệu đầu vào: Đảm bảo dữ liệu người dùng nhập vào là hợp lệ.
• Áp dụng kiến thức toán học vào lập trình: Biến các công thức toán thành code.
Tài nguyên Dẫn Đường (La Bàn & Bản Đồ HaivanStory):
HaivanStory đã chuẩn bị sẵn những “bản đồ” và “la bàn” cực kỳ hữu ích để bạn không bị lạc lối trong không gian toán học này:
• Tính khoảng cách giữa 2 điểm: https://toanthaydinh.com/cong-thuc-tinh-khoang-cach-giua-2-diem/
• Bất đẳng thức trong tam giác (Kiểm tra điều kiện tạo tam giác): https://blog.marathon.edu.vn/bat-dang-thuc-tam-giac/
• Chứng minh 3 điểm thẳng hàng với Vector: https://hoctoan24h.net/chung-minh-3-diem-thang-hang-bang-vecto-lop-10/
• Công thức tính góc giữa hai vector trong mặt phẳng: https://www.mathvn.com/2019/12/cong-thuc-tinh-goc-giua-hai-vecto-trong.html?m=1
• Lý thuyết về Vector: https://suretest.vn/cung-co/bai-1-cac-dinh-nghia-7204.html
• Cách tính diện tích tam giác: https://thuthuatphanmem.vn/cach-tinh-dien-tich-tam-giac-chuan/
• Công thức tính đường cao trong tam giác thường: https://quantrimang.com/cong-nghe/cong-thuc-tinh-duong-cao-trong-tam-giac-180795
• Công thức tính độ dài đường trung tuyến: https://www.studytienganh.vn/news/5865/cong-thuc-duong-trung-tuyen
• Tìm tọa độ trọng tâm của tam giác: https://hoctoan24h.net/tim-toa-do-trong-tam-tam-giac-trong-mat-phang-oxy/
• Tìm tọa độ trực tâm của tam giác: https://blogchiasekienthuc.com/toan-hoc/cach-tim-toa-do-truc-tam-cua-tam-giac.html
Cấu trúc gợi ý cho dự án (HaivanStory Blueprint):
Để “nhiệm vụ” này trở nên dễ dàng và có hệ thống, chúng ta sẽ xây dựng chương trình theo từng “phân đội” nhỏ, mỗi phân đội là một hàm Python chuyên trách.
Bước 1: Chuẩn bị Căn Cứ Dữ Liệu (Data Input)
• Đầu tiên, chúng ta cần thu thập tọa độ của 3 ngôi sao A, B, C từ người dùng.
• Tạo một hàm nhap_toa_do_diem() để yêu cầu người dùng nhập tọa độ x, y cho một điểm. Hàm này sẽ trả về một tuple hoặc list (x, y).
• Sử dụng hàm này 3 lần để nhập A, B, C.
Bước 2: Các “Công Cụ” Toán Học Cơ Bản (Core Utility Functions)
Đây là lúc chúng ta áp dụng Bài 7 về Hàm. Hãy viết các hàm nhỏ nhưng cực kỳ quan trọng sau:
• Hàm tinh_khoang_cach(diem1, diem2):
• Nhận vào tọa độ 2 điểm.
• Sử dụng công thức tính khoảng cách giữa 2 điểm.
• Trả về độ dài.
• Gợi ý: Sử dụng math.sqrt() để tính căn bậc hai.
• Hàm tinh_do_dai_canh(diem1, diem2): (có thể gọi lại tinh_khoang_cach)
• Nhận vào tọa độ 2 điểm.
• Trả về độ dài cạnh.
• Hàm tinh_vector(diem_dau, diem_cuoi):
• Nhận vào tọa độ 2 điểm.
• Trả về vector từ điểm đầu đến điểm cuối dưới dạng tuple (vx, vy).
• Hàm tich_vo_huong(vec1, vec2):
• Nhận vào 2 vector.
• Trả về tích vô hướng của chúng.
• Hàm tinh_do_lon_vector(vec):
• Nhận vào một vector.
• Trả về độ lớn (độ dài) của vector.
• Hàm tinh_goc_giua_2_vector(vec1, vec2):
• Nhận vào 2 vector.
• Sử dụng công thức tính góc giữa 2 vector.
• Trả về góc bằng radian, sau đó có thể chuyển sang độ (math.degrees()).
• Lưu ý: Cần xử lý trường hợp mẫu số bằng 0 (khi một trong các vector có độ lớn bằng 0).
• Hàm lam_tron_so(so, so_chu_so_sau_dau_phay):
• Giúp làm tròn kết quả cho đẹp mắt, ví dụ 2 chữ số thập phân.
Bước 3: Nhiệm Vụ Phân Tích Cơ Bản (Basic Analysis Functions)
• Hàm kiem_tra_tam_giac(a, b, c):
• Nhận vào độ dài 3 cạnh.
• Kiểm tra bất đẳng thức tam giác: a + b > c, a + c > b, b + c > a.
• Kiểm tra 3 điểm không thẳng hàng (tổng 2 cạnh không bằng cạnh còn lại).
• Trả về True nếu tạo thành tam giác, ngược lại False. Nếu False, hãy in ra thông báo giải thích.
• Hàm tinh_cac_canh(A, B, C):
• Nhận vào tọa độ 3 điểm A, B, C.
• Gọi tinh_khoang_cach để tính độ dài 3 cạnh ab, bc, ca.
• Trả về một tuple (ab, bc, ca).
• Hàm tinh_cac_goc(a, b, c): (với a, b, c là độ dài các cạnh)
• Nhận vào độ dài 3 cạnh ab, bc, ca.
• Sử dụng định lý Cosin để tính 3 góc.
• Góc A: \\cos A = \\frac{b^2 + c^2 – a^2}{2bc}
• Góc B: \\cos B = \\frac{a^2 + c^2 – b^2}{2ac}
• Góc C: \\cos C = \\frac{a^2 + b^2 – c^2}{2ab}
• Sử dụng math.acos() để tính góc từ cosin, sau đó chuyển sang độ.
• Trả về một tuple (goc_A, goc_B, goc_C).
• Hàm phan_loai_tam_giac(goc_A, goc_B, goc_C, ab, bc, ca):
• Nhận vào 3 góc và 3 cạnh.
• Sử dụng các điều kiện logic (if-elif-else) để phân loại:
• Tam giác đều: 3 cạnh bằng nhau HOẶC 3 góc bằng 60 độ (xấp xỉ).
• Tam giác cân: Có ít nhất 2 cạnh bằng nhau HOẶC 2 góc bằng nhau.
• Tam giác vuông: Có một góc bằng 90 độ (xấp xỉ).
• Tam giác vuông cân: Vừa vuông vừa cân.
• Tam giác thường: Các trường hợp còn lại.
• Trả về một chuỗi mô tả loại tam giác.
Bước 4: Nhiệm Vụ Phân Tích Nâng Cao (Advanced Analysis Functions)
• Hàm tinh_dien_tich(a, b, c): (với a, b, c là độ dài các cạnh)
• Nhận vào độ dài 3 cạnh.
• Sử dụng công thức Heron:
• Nửa chu vi p = (a+b+c)/2
• Diện tích S = \\sqrt{p(p-a)(p-b)(p-c)}
• Trả về diện tích.
• Hàm tinh_duong_cao(a, b, c, S): (với a, b, c là độ dài các cạnh, S là diện tích)
• Nhận vào độ dài 3 cạnh và diện tích.
• Đường cao h\_a = 2S/a, h\_b = 2S/b, h\_c = 2S/c.
• Trả về tuple (h_a, h_b, h_c).
• Hàm tinh_duong_trung_tuyen(a, b, c):
• Nhận vào độ dài 3 cạnh.
• Trung tuyến m\_a = \\frac{1}{2} \\sqrt{2(b^2+c^2) – a^2}
• Tương tự cho m\_b, m\_c.
• Trả về tuple (m_a, m_b, m_c).
• Hàm tinh_trong_tam(A, B, C):
• Nhận vào tọa độ 3 đỉnh.
• Trọng tâm G\_x = (A\_x + B\_x + C\_x) / 3
• Trọng tâm G\_y = (A\_y + B\_y + C\_y) / 3
• Trả về tuple (G_x, G_y).
• Hàm tinh_truc_tam(A, B, C):
• Nhận vào tọa độ 3 đỉnh.
• Đây là phần phức tạp nhất, bạn cần tìm phương trình đường cao từ 2 đỉnh, sau đó tìm giao điểm của 2 đường thẳng đó.
• Gợi ý: Tìm phương trình đường thẳng đi qua 1 điểm và vuông góc với 1 vector.
• Trả về tuple (H_x, H_y).
Bước 5: Lắp Ráp Hệ Thống (Main Program Flow)
Tạo hàm main() để điều phối toàn bộ chương trình:
1 Gọi nhap_toa_do_diem() 3 lần để lấy tọa độ A, B, C.
2 Tính độ dài 3 cạnh bằng tinh_cac_canh().
3 Kiểm tra xem có tạo thành tam giác không bằng kiem_tra_tam_giac().
• Nếu không, in thông báo và kết thúc chương trình.
• Nếu có, tiếp tục:
4 Tính các góc bằng tinh_cac_goc().
5 Phân loại tam giác bằng phan_loai_tam_giac().
6 Tính diện tích bằng tinh_dien_tich().
7 Tính các đường cao bằng tinh_duong_cao().
8 Tính các đường trung tuyến bằng tinh_duong_trung_tuyen().
9 Tính trọng tâm bằng tinh_trong_tam().
10 Tính trực tâm bằng tinh_truc_tam().
11 In ra tất cả các kết quả một cách rõ ràng và dễ đọc, sử dụng f-string để định dạng. Nhớ làm tròn các số thập phân cho đẹp!
Cấu trúc file (gợi ý):
Bạn có thể tạo một file Python duy nhất tam_giac.py và đặt tất cả các hàm vào đó.
# tam_giac.py
import math
# Bước 1: Chuẩn bị Căn Cứ Dữ Liệu
def nhap_toa_do_diem(ten_diem):
# ... code nhập tọa độ ...
pass
# Bước 2: Các "Công Cụ" Toán Học Cơ Bản
def tinh_khoang_cach(diem1, diem2):
# ... code tính khoảng cách ...
pass
def tinh_vector(diem_dau, diem_cuoi):
# ... code tính vector ...
pass
def tich_vo_huong(vec1, vec2):
# ... code tính tích vô hướng ...
pass
def tinh_do_lon_vector(vec):
# ... code tính độ lớn vector ...
pass
def tinh_goc_giua_2_vector(vec1, vec2):
# ... code tính góc ...
pass
def lam_tron_so(so, so_chu_so_sau_dau_phay=2):
return round(so, so_chu_so_sau_dau_phay)
# Bước 3: Nhiệm Vụ Phân Tích Cơ Bản
def kiem_tra_tam_giac(a, b, c):
# ... code kiểm tra bất đẳng thức tam giác và thẳng hàng ...
pass
def tinh_cac_canh(A, B, C):
# ... code tính 3 cạnh ...
pass
def tinh_cac_goc(a, b, c):
# ... code tính 3 góc bằng định lý cosin ...
pass
def phan_loai_tam_giac(goc_A, goc_B, goc_C, ab, bc, ca):
# ... code phân loại tam giác ...
pass
# Bước 4: Nhiệm Vụ Phân Tích Nâng Cao
def tinh_dien_tich(a, b, c):
# ... code tính diện tích bằng Heron ...
pass
def tinh_duong_cao(a, b, c, S):
# ... code tính đường cao ...
pass
def tinh_duong_trung_tuyen(a, b, c):
# ... code tính đường trung tuyến ...
pass
def tinh_trong_tam(A, B, C):
# ... code tính trọng tâm ...
pass
def tinh_truc_tam(A, B, C):
# ... code tính trực tâm (phức tạp nhất) ...
# Gợi ý: có thể cần hàm phụ để tính phương trình đường thẳng, giao điểm 2 đường thẳng
pass
# Bước 5: Lắp Ráp Hệ Thống (Main Program)
def main():
print("--- Chào mừng đến với Hệ thống Phân tích Tam giác ABC! ---")
print("Vui lòng nhập tọa độ 3 đỉnh của tam giác.")
A = nhap_toa_do_diem("A")
B = nhap_toa_do_diem("B")
C = nhap_toa_do_diem("C")
# ... các bước gọi hàm và in kết quả ...
# Ví dụ:
# ab, bc, ca = tinh_cac_canh(A, B, C)
# if not kiem_tra_tam_giac(ab, bc, ca):
# print("Ba điểm này không tạo thành một tam giác.")
# return
# else:
# print("\n--- Kết quả Phân tích Tam giác ABC ---")
# print(f"Độ dài các cạnh: AB={lam_tron_so(ab)}, BC={lam_tron_so(bc)}, CA={lam_tron_so(ca)}")
# goc_A, goc_B, goc_C = tinh_cac_goc(ab, bc, ca)
# print(f"Độ lớn các góc: Góc A={lam_tron_so(goc_A)}°, Góc B={lam_tron_so(goc_B)}°, Góc C={lam_tron_so(goc_C)}°")
# loai_tam_giac = phan_loai_tam_giac(goc_A, goc_B, goc_C, ab, bc, ca)
# print(f"Đây là: {loai_tam_giac}")
# # ... tiếp tục với diện tích, đường cao, trung tuyến, trọng tâm, trực tâm ...
if __name__ == "__main__":
main()Mẹo của HaivanStory để bạn thành công:
1 Code từng bước: Đừng cố gắng viết hết cả chương trình một lúc. Hãy viết từng hàm nhỏ, kiểm tra nó hoạt động đúng rồi mới chuyển sang hàm tiếp theo.
2 Sử dụng print() để gỡ lỗi: Nếu một hàm không trả về kết quả như bạn mong đợi, hãy thêm các câu lệnh print() bên trong hàm đó để xem các giá trị trung gian.
3 Học hỏi từ tài nguyên: Các link tài nguyên cung cấp là “kho báu” công thức. Hãy đọc kỹ và hiểu công thức trước khi biến nó thành code.
4 Tận dụng Colab: Sử dụng Google Colab để viết và chạy code một cách linh hoạt, dễ dàng chia sẻ và thử nghiệm.
5 Không ngại thử nghiệm: Đây là dự án của bạn, hãy thoải mái sáng tạo, thêm các tính năng mà bạn thấy hay ho (ví dụ: vẽ tam giác đơn giản bằng thư viện nào đó nếu bạn muốn thử sức).
Chúc các phi hành gia Pythonista hoàn thành xuất sắc nhiệm vụ này và tiếp tục hành trình khám phá vũ trụ lập trình cùng HaivanStory Blog! Hãy chia sẻ thành quả của bạn khi hoàn thành nhé!
