Thuật toán tìm tất cả các ước chẵn của hai số a và b

Dưới dạng bước liệt kê:

1. Nhập hai số nguyên dương a và b.
2. Khởi tạo hai danh sách rỗng: uoc_chan_a để lưu các ước chẵn của a và uoc_chan_b để lưu các ước chẵn của b.
3. Tìm ước chẵn của a:
4. • Duyệt qua tất cả các số nguyên i từ 1 đến a (hoặc hiệu quả hơn, từ 1 đến ⌊a/2⌋ và kiểm tra riêng a nếu a chẵn).
   • Với mỗi i, kiểm tra xem a có chia hết cho i hay không (a % i == 0).
   • Nếu a chia hết cho i, kiểm tra xem i có phải là số chẵn hay không (i % 2 == 0).
   • Nếu cả hai điều kiện trên đều đúng, thêm i vào danh sách uoc_chan_a.
   • Kiểm tra riêng nếu a là số chẵn, thì a cũng là một ước chẵn của chính nó và cần được thêm vào uoc_chan_a.
5. Tìm ước chẵn của b:
6. • Thực hiện tương tự bước 3, nhưng thay a bằng b và thêm các ước chẵn tìm được vào danh sách uoc_chan_b.
   • Kiểm tra riêng nếu b là số chẵn, thì b cũng là một ước chẵn của chính nó và cần được thêm vào uoc_chan_b.
7. In ra kết quả:
8. • In danh sách uoc_chan_a (các ước chẵn của a).
   • In danh sách uoc_chan_b (các ước chẵn của b).

Dưới dạng giả mã:

ALGORITHM TimUocChan(a, b)
  // Nhập: Hai số nguyên dương a và b
  // Xuất: Danh sách các ước chẵn của a và b

  uoc_chan_a <- []
  uoc_chan_b <- []

  // Tìm ước chẵn của a
  FOR i FROM 1 TO floor(a / 2) DO
    IF a MOD i == 0 AND i MOD 2 == 0 THEN
      ADD i TO uoc_chan_a
    ENDIF
  ENDFOR
  IF a MOD 2 == 0 THEN
    ADD a TO uoc_chan_a
  ENDIF

  // Tìm ước chẵn của b
  FOR j FROM 1 TO floor(b / 2) DO
    IF b MOD j == 0 AND j MOD 2 == 0 THEN
      ADD j TO uoc_chan_b
    ENDIF
  ENDFOR
  IF b MOD 2 == 0 THEN
    ADD b TO uoc_chan_b
  ENDIF

  PRINT "Các ước chẵn của", a, "là:", uoc_chan_a
  PRINT "Các ước chẵn của", b, "là:", uoc_chan_b
END ALGORITHM

Chuyển thuật toán thành chương trình theo phương pháp làm mịn dần

Phương pháp làm mịn dần (stepwise refinement) là cách tiếp cận giải quyết vấn đề bằng cách bắt đầu với một mô tả cấp cao của thuật toán, sau đó dần dần chia nhỏ các bước thành các chi tiết cụ thể hơn.

Bước 1: Mô tả cấp cao

Chúng ta cần một chương trình nhận hai số đầu vào, tìm các ước chẵn của từng số và hiển thị kết quả.

Bước 2: Chia nhỏ thành các hàm (làm mịn lần 1)

Chúng ta có thể chia chương trình thành các hàm nhỏ hơn để dễ quản lý:

• Hàm tim_uoc_chan(n): Nhận một số nguyên n và trả về danh sách các ước chẵn của nó.
• Hàm main(): Nhận đầu vào, gọi hàm tim_uoc_chan cho cả hai số và in kết quả.

Bước 3: Hiện thực hóa hàm tim_uoc_chan(n) (làm mịn lần 2)

Trong hàm này, chúng ta sẽ thực hiện logic tìm ước chẵn như đã mô tả trong thuật toán.

Bước 4: Hiện thực hóa hàm main() (làm mịn lần 2)

Hàm này sẽ xử lý việc nhập liệu và xuất kết quả.

Hiện thực bằng Python:

def tim_uoc_chan(n):
  """Tìm tất cả các ước chẵn của một số nguyên n."""
  uoc_chan = []
  for i in range(1, n // 2 + 1):
    if n % i == 0 and i % 2 == 0:
      uoc_chan.append(i)
  if n % 2 == 0:
    uoc_chan.append(n)
  return uoc_chan

def main():
  """Chương trình chính để tìm ước chẵn của hai số."""
  try:
    a = int(input("Nhập số nguyên dương a: "))
    b = int(input("Nhập số nguyên dương b: "))
    if a <= 0 or b <= 0:
      print("Vui lòng nhập số nguyên dương.")
      return

    uoc_chan_a = tim_uoc_chan(a)
    uoc_chan_b = tim_uoc_chan(b)

    print(f"Các ước chẵn của {a} là: {uoc_chan_a}")
    print(f"Các ước chẵn của {b} là: {uoc_chan_b}")

  except ValueError:
    print("Đầu vào không hợp lệ. Vui lòng nhập số nguyên.")

if __name__ == "__main__":
  main()

Hiện thực bằng C++:

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

std::vector<int> timUocChan(int n) {
    std::vector<int> uoc_chan;
    for (int i = 1; i <= n / 2; ++i) {
        if (n % i == 0 && i % 2 == 0) {
            uoc_chan.push_back(i);
        }
    }
    if (n % 2 == 0) {
        uoc_chan.push_back(n);
    }
    std::sort(uoc_chan.begin(), uoc_chan.end()); // Sắp xếp cho đẹp (tùy chọn)
    return uoc_chan;
}

int main() {
    int a, b;
    std::cout << "Nhập số nguyên dương a: ";
    std::cin >> a;
    std::cout << "Nhập số nguyên dương b: ";
    std::cin >> b;

    if (a <= 0 || b <= 0) {
        std::cout << "Vui lòng nhập số nguyên dương." << std::endl;
        return 1; // Mã lỗi
    }

    std::vector<int> uoc_chan_a = timUocChan(a);
    std::vector<int> uoc_chan_b = timUocChan(b);

    std::cout << "Các ước chẵn của " << a << " là: ";
    for (int uoc : uoc_chan_a) {
        std::cout << uoc << " ";
    }
    std::cout << std::endl;

    std::cout << "Các ước chẵn của " << b << " là: ";
    for (int uoc : uoc_chan_b) {
        std::cout << uoc << " ";
    }
    std::cout << std::endl;

    return 0; // Thành công
}

def tim_phan_tu_lon_nhat(danh_sach):
  """
  Tìm phần tử lớn nhất trong một danh sách các số.

  Độ phức tạp thời gian: O(n), trong đó n là số lượng phần tử trong danh sách.
  """
  if not danh_sach:
    return None  # Trả về None nếu danh sách rỗng

  lon_nhat = danh_sach[0]  # Khởi tạo phần tử lớn nhất là phần tử đầu tiên
  for phan_tu in danh_sach:  # Duyệt qua từng phần tử trong danh sách
    if phan_tu > lon_nhat:
      lon_nhat = phan_tu  # Cập nhật nếu tìm thấy phần tử lớn hơn
  return lon_nhat

# Ví dụ sử dụng
my_list = [3, 1, 4, 1, 5, 9, 2, 6]
max_element = tim_phan_tu_lon_nhat(my_list)
print(f"Phần tử lớn nhất trong danh sách là: {max_element}")