Đề thi tin học trẻ huyện Từ Sơn, tỉnh Bắc Ninh, năm 2024

Bài 1: Năm số tự nhiên

Đề bài:

Cho 5 số tự nhiên có giá trị là 1 hoặc 2. Hãy cho biết giá trị nào có số lần xuất hiện nhiều hơn.
Dữ liệu: Dữ liệu nhập vào gồm 5 dòng:

• Dòng thứ nhất ghi số tự nhiên a (1 ≤ a ≤ 2)
• Dòng thứ hai ghi số tự nhiên b (1 ≤ b ≤ 2)
• Dòng thứ ba ghi số tự nhiên c (1 ≤ c ≤ 2)
• Dòng thứ tư ghi số tự nhiên d (1 ≤ d ≤ 2)
• Dòng thứ năm ghi số tự nhiên e (1 ≤ e ≤ 2)

Kết quả: Đưa ra số có số lần xuất hiện nhiều hơn.
Ví dụ:

Dữ liệu	Kết quả
1 1 1 2 1	1

Hướng dẫn làm bài:

Phân tích bài toán:

• Dữ liệu đầu vào (Input): Đúng 5 con số, và các số này chỉ có thể là 1 hoặc 2.
• Kết quả đầu ra (Output): Số nào xuất hiện nhiều lần hơn.

Thuật toán:
Cách 1: Kỹ thuật đếm

• Ta chỉ cần tạo một biến đếm để đếm xem có bao nhiêu số 1.
• Lặp 5 lần quá trình nhập số: Nếu số nhập vào là 1 thì tăng biến đếm lên 1 đơn vị.
• Cuối cùng, kiểm tra biến đếm: Nếu biến đếm ≥ 3 thì chắc chắn số 1 xuất hiện nhiều hơn. Nếu không, chắc chắn số 2 xuất hiện nhiều hơn (không cần đếm số 2 mất công).

Cách 2: Tư duy toán học (Mẹo tính tổng)

• Cộng tổng cả 5 số lại với nhau.
• Trường hợp số 1 xuất hiện nhiều nhất (3 lần 1, 2 lần 2): Tổng lớn nhất có thể là 1 + 1 + 1 + 2 + 2 = 7. Các trường hợp nhiều số 1 hơn (như 4 số 1, 5 số 1) tổng sẽ còn nhỏ hơn 7.
• Trường hợp số 2 xuất hiện nhiều nhất (3 lần 2, 2 lần 1): Tổng nhỏ nhất có thể là 2 + 2 + 2 + 1 + 1 = 8.
• Kết luận:Nếu Tổng ≤ 7 thì in ra 1. Ngược lại (Tổng ≥ 8) thì in ra 2. Cách này code cực ngắn, như một “mẹo giải nhanh”.

Hướng dẫn cài đặt bằng Scratch (Theo Cách 1)
Các bước lập trình Scratch:

1. Tạo một biến tên là đếm số 1.
2. Khi lá cờ xanh được nhấn:
   • Đặt đếm số 1 thành 0.
   • Sử dụng vòng lặp Lặp lại 5 lần:
     • Hỏi “Nhập số:” và đợi.
     • Sử dụng khối điều kiện Nếu … thì: Nếu trả lời = 1, thì thay đổi đếm số 1 một lượng 1.
3. Thoát khỏi vòng lặp, dùng khối Nếu … thì … không thì:
   • Nếu đếm số 1 > 2: Nói 1.
   • Không thì: Nói 2.

Code tham khảo:

Hướng dẫn cài đặt bằng Python
Code cách 1:

# Khởi tạo biến đếm số 1
dem_1 = 0

# Lặp 5 lần để đọc 5 dòng dữ liệu
for i in range(5):
    so = int(input())
    if so == 1:
        dem_1 += 1

# Kiểm tra xem số 1 có xuất hiện từ 3 lần trở lên không
if dem_1 >= 3:
    print(1)
else:
    print(2)

Code cách 2:

tong = 0

# Tính tổng 5 số nhập vào
for i in range(5):
    so = int(input())
    tong += so

# Nếu tổng nhỏ hơn hoặc bằng 7 thì 1 thắng, ngược lại 2 thắng
if tong <= 7:
    print(1)
else:
    print(2)

Bài 2: Số đặc biệt

Đề bài:

Cho 3 số tự nhiên a, b, c. Trong đó, có một số có giá trị khác 2 số còn lại. Hãy tìm số đó.
Dữ liệu: Dữ liệu nhập vào gồm 3 dòng:

• Dòng thứ nhất chứa số tự nhiên a (1 ≤ a ≤ 10⁹)
• Dòng thứ hai chứa số tự nhiên b (1 ≤ b ≤ 10⁹)
• Dòng thứ ba chứa số tự nhiên c (1 ≤ c ≤ 10⁹)

Kết quả: Một số tự nhiên là kết quả bài toán.
Ví dụ:

Dữ liệu	Kết quả
1 2 1	2

Hướng dẫn làm bài:

Phân tích bài toán:

• Dữ liệu đầu vào (Input): 3 số tự nhiên a, b, c. Đề bài có một giới hạn là số có thể lên tới 10⁹ (một tỷ), nhưng cả Scratch và Python đều xử lý rất tốt con số này nên ta không cần lo lắng về hiện tượng tràn số.
• Đặc điểm cốt lõi: Luôn luôn có 2 số bằng nhau (là một cặp), và 1 số khác biệt.
• Nhiệm vụ (Output): Tìm và in ra số khác biệt đó.

Thuật toán:

• Trường hợp 1: Lấy số thứ nhất (a) so sánh với số thứ hai (b). Nếu a = b, chứng tỏ hai bạn này là một cặp “sinh đôi”, vậy kẻ “lạc loài” chắc chắn là bạn thứ ba (c).
• Trường hợp 2: Nếu a không bằng b, ta lại lấy a đi so sánh với c. Nếu a = c, thì cặp sinh đôi là a và c, kẻ lạc loài là bạn thứ hai (b).
• Trường hợp 3: Nếu cả hai trường hợp trên đều trật (nghĩa là $a$ khác b, và a cũng khác c), thì bản thân bạn a chính là kẻ “lạc loài” khác biệt so với hai bạn kia.

Hướng dẫn làm bằng Scratch:

1. Tạo 3 biến tên là a, b, c.
2. Khi lá cờ xanh được nhấn:
   • Hỏi “Nhập số a:” và đợi. Sau đó đặt [a] thành (trả lời).
   • Làm tương tự: Hỏi và đặt [b] thành (trả lời).
   • Làm tương tự: Hỏi và đặt [c] thành (trả lời).
3. Kéo khối Nếu … thì … không thì:
   • Ở ô điều kiện: Lắp phép toán [a] = [b].
   • Ở nhánh thì: Kéo khối Nói [c].
   • Ở nhánh không thì: Kéo thêm một khối Nếu … thì … không thì khác lồng vào trong:
     • Ở ô điều kiện: Lắp phép toán [a] = [c].
     • Ở nhánh thì: Kéo khối Nói [b].
     • Ở nhánh không thì: Kéo khối Nói [a].

Code tham khảo:

Hướng dẫn làm bằng Python:
Code tham khảo:

# Đọc 3 số từ 3 dòng
a = int(input())
b = int(input())
c = int(input())

# Sử dụng cấu trúc rẽ nhánh để so sánh
if a == b:
    print(c)
elif a == c:
    print(b)
else:
    print(a)

Bài 3: Vận tốc

Đề bài:

Đất nước nơi Thuận và Ánh sống là một trục đường thẳng gồm 10⁹ + 1 thành phố, được đánh số lần lượt từ trái sang phải từ 0 tới 10⁹, hai thành phố kế nhau cách nhau 1 km.
Thuận đang đứng ở thành phố x, Ánh đang đứng ở thành phố y. Biết rằng Thuận đang di chuyển với tốc độ n km/h, hỏi sau bao lâu thì Thuận gặp Ánh?
Dữ liệu:

• Dòng thứ nhất chứa số tự nhiên x (1 ≤ x ≤ 10⁹)
• Dòng thứ hai chứa số tự nhiên y (1 ≤ y ≤ 10⁹)
• Dòng thứ ba chứa số tự nhiên n (1 ≤ n ≤ 10⁹)

Kết quả: Một số tự nhiên là kết quả bài toán.
Ví dụ:

Dữ liệu	Kết quả
5 6 1	1

Hướng dẫn làm bài:

Phân tích bài toán:

• Dữ liệu đầu vào (Input): 3 số tự nhiên x, y, n.
  • x: Vị trí của Thuận.
  • y: Vị trí của Ánh.
  • n: Vận tốc của Thuận (km/h).
• Kiến thức Toán học cốt lõi:
  • Thời gian = Quãng đường : Vận tốc (t = S/v).
  • Vận tốc v ở đây chính là n.
  • Quãng đường S chính là khoảng cách giữa thành phố x và thành phố y.

Hướng dẫn làm bằng Scratch:

1. Tạo 3 biến: x, y, n.
2. Khi lá cờ xanh được nhấn:
   • Hỏi “Nhập x:” và đặt [x] thành (trả lời).
   • Hỏi “Nhập y:” và đặt [y] thành (trả lời).
   • Hỏi “Nhập n:” và đặt [n] thành (trả lời).
3. Tính toán và in ra kết quả:
   • Ta dùng khối Nói (…):
   • Bên trong khối Nói, ta lắp khối phép chia ( ) / ( ).
   • Vế trái của phép chia: Lắp khối [giá trị tuyệt đối v] của ( (x) – (y) ) (Nằm trong nhóm lệnh Các phép toán, chọn hàm “giá trị tuyệt đối” từ menu thả xuống).
   • Vế phải của phép chia: Lắp biến n.

Code tham khảo:

Hướng dẫn làm bằng Python:

# Đọc dữ liệu đầu vào
x = int(input())
y = int(input())
n = int(input())

# Tính khoảng cách bằng hàm giá trị tuyệt đối abs()
khoang_cach = abs(x - y)

# Tính thời gian (dùng phép chia lấy nguyên // để kết quả là số tự nhiên)
thoi_gian = khoang_cach // n

# In ra kết quả
print(thoi_gian)

Bài 4: Dãy số

Đề bài:

Cho một dãy số sau: 1, 3, 6, 10, 15, 21, … Hãy đếm số lượng số chia hết cho 6 trong N số đầu tiên.
Dữ liệu: Dữ liệu nhập vào gồm 1 dòng duy nhất chứa số tự nhiên N (1 ≤ N ≤ 10¹⁵).
Kết quả: Một số tự nhiên là kết quả bài toán.
Ví dụ:

Dữ liệu	Kết quả
10	2

Chấm điểm:

• 60% số điểm ứng với 1 ≤ N ≤ 10⁵.
• 40% số điểm còn lại không có ràng buộc gì thêm.

Hướng dẫn làm bài:

Phân tích dãy số:
Nhận diện dãy số:

• Số thứ 1: 1
• Số thứ 2: 1 + 2 = 3
• Số thứ 3: 3 + 3 = 6
• Số thứ 4: 6 + 4 = 10
• Số thứ 5: 10 + 5 = 15
• Quy luật: Số hiện tại = Số trước đó + Vị trí hiện tại.

Cách 1: Vòng lặp cơ bản (Dành cho 60% số điểm)
Với N ≤ 10⁵, máy tính hoàn toàn có thể chạy một vòng lặp từ 1 đến N, tạo ra từng số và kiểm tra xem số đó có chia hết cho 6 hay không.
Hướng dẫn Scratch (Cách 60%):

1. Tạo các biến: N, vị trí (khởi tạo = 1), số hiện tại (khởi tạo = 1), kết quả đếm (khởi tạo = 0).
2. Hỏi người dùng nhập N.
3. Dùng vòng lặp Lặp lại (N) lần:
   • Nếu (số hiện tại) chia lấy dư cho 6 = 0 thì: tăng kết quả đếm lên 1.
   • Tăng vị trí lên 1.
   • Đặt số hiện tại thành (số hiện tại) + (vị trí).
4. Nói ra kết quả đếm.

Code tham khảo Scratch:

Code tham khảo Python (Cách 60%):

N = int(input())
so_hien_tai = 1
dem = 0

for vi_tri in range(1, N + 1):
    # Kiểm tra chia hết cho 6
    if so_hien_tai % 6 == 0:
        dem += 1
    
    # Tạo số tiếp theo của dãy
    so_hien_tai = so_hien_tai + (vi_tri + 1)

print(dem)

Cách 2: Tìm quy luật chu kỳ (Tuyệt chiêu cho 100% số điểm)
Với N ≤ 10¹⁵, một vòng lặp chạy 10¹⁵ lần sẽ khiến chương trình bị quá thời gian (Time Limit Exceeded – TLE).
Nếu ta liệt kê các vị trí (i) có số chia hết cho 6:

• i = 1 → 1
• i = 2 → 3
• i = 3 → 6 (Chia hết)
• i = 4 → 10
• i = 5 → 15
• i = 6 → 21
• i = 7 → 28
• i = 8 → 36 (Chia hết)
• i = 9 → 45
• i = 10 → 55
• i = 11 → 66 (Chia hết)
• i = 12 → 78 (Chia hết)
• i = 13 → 91 …

Phát hiện chu kỳ vàng:

• Cứ mỗi một nhóm 12 số liên tiếp (chu kỳ 12), sẽ luôn có chính xác 4 số chia hết cho 6 (rơi vào các vị trí thứ 3, 8, 11, 12 trong chu kỳ đó).
• Ví dụ: N = 10. Ta có 10 chia 12 được 0 (không có chu kỳ hoàn chỉnh nào), dư 10. Trong 10 số phần dư này, chỉ có vị trí số 3 và số 8 là thỏa mãn. Vậy kết quả là 2 (Khớp với ví dụ đề bài!).

Thuật toán O(1) siêu tốc:

1. Tính số chu kỳ trọn vẹn: So_chu_ky = N // 12
2. Tính số lượng số chia hết cho 6 trong các chu kỳ này: So_luong = So_chu_ky * 4
3. Xét phần dư: Phan_du = N % 12. Ta chỉ cần kiểm tra xem phần dư này có vượt qua các mốc vị trí 3, 8, 11 hay không để cộng thêm vào kết quả.

Code tham khảo Python (Cách 100%):

N = int(input())

# Số chu kỳ 12 trọn vẹn
so_chu_ky = N // 12

# Mỗi chu kỳ có chắc chắn 4 số thỏa mãn
ket_qua = so_chu_ky * 4

# Xử lý phần dư còn lại
phan_du = N % 12

if phan_du >= 11:
    ket_qua += 3
elif phan_du >= 8:
    ket_qua += 2
elif phan_du >= 3:
    ket_qua += 1

print(ket_qua)