• Số phức là:
   ○ Dạng tổng quát: a + bi, với:
       ▪ a: Phần thực của số phức
       ▪ b: Phần ảo của số phức
       ▪ i: Đơn vị ảo với giá trị i² = -1

• Phép Cộng Hai Số Phức:
   ○ Công thức: (a + bi) + (c + di) = (a + c) + (b + d)i
   ○ Phần thực: a + c
   ○ Phần ảo: b + d

• Phép Trừ Hai Số Phức:
   ○ Công thức: (a + bi) — (c + di) = (a — c) + (b — d)i
   ○ Phần thực: a — c
   ○ Phần ảo: b — d

• Phép Nhân Hai Số Phức:
   ○ Công thức: (a + bi) * (c + di) = (a * c — b * d) + (a * d + b * c)i
   ○ Phần thực: a * c — b * d
   ○ Phần ảo: a * d + b * c

• Quy tắc In Kết Quả:
   ○ Chỉ in phần thực nếu khác 0.
   ○ Chỉ in phần ảo nếu khác 0. Nếu b = 1 hoặc b = -1, in i hoặc -i thay vì 1i hoặc -1i.
   ○ Nếu cả phần thực và phần ảo đều là 0, in 0.
 

Làm quen với struct

Cộng, trừ, nhân, chia Phân Số như đã học.

Quy tắc In Kết Quả:
   ○ Phân Số phải ở dạng rút gọn
   ○ Mẫu không âm
 

Phân số

Sử dụng 1 Struct “D24”:

• Tên
• Điểm 1, 2, 3
• Tổng điểm

Rồi sử dụng bất kì cách sắp xếp nào như với 1 kiểu dữ liệu bình thường.
 

Sắp xếp bảng điểm

Mỗi lần nhập tên, ta sẽ tách xâu:

vì đề đảm bảo chỉ có 1 khoảng trắng giữa các từ, nên ta sẽ có một mảng để lưu các từ.

Và một biến tạm string tmp, khi gặp kí tự thì tmp += kí tự. Nếu gặp khoảng trắng thì lưu từ đó vào mảng và reset lại biến tạm về tmp = “”;

Sau đó duyệt qua mảng ta đã tạo được, chỉ số tại 0 sẽ là Họ.

Chuẩn hóa tên

Bài này dễ, các bạn tự Code.

Gợi ý:

• Vì giới hạn đề cho rất lớn, vượt qua cả kiểu long long, nên ta sẽ sử dụng String.
• Số 0 không phải số âm hay số dương.
• Xét vị trí 0 của xâu sẽ biết số đó là âm hay dương.

1. Tính tổng các số trong chuỗi: 
  — Duyệt qua từng ký tự trong chuỗi `s`.
  — Nếu ký tự là chữ cái (từ 'A' đến 'Z'), nó được đếm vào mảng `count` (mỗi phần tử `count[i]` đếm số lần xuất hiện của ký tự `i`).
  — Nếu gặp ký tự là số ('0' đến '9'), ký tự đó được nối vào chuỗi `num` để tạo thành một số đầy đủ.
  — Khi chuyển từ số sang chữ cái, hoặc khi kết thúc chuỗi, `num` được chuyển thành số (`stoll`) và cộng vào `sum`, rồi `num` được làm trống để chuẩn bị cho số tiếp theo.

2. In các ký tự chữ cái theo thứ tự từ 'A' đến ‘Z’:
  — Duyệt qua mảng `count` để in ra mỗi ký tự theo số lần xuất hiện của nó.

Tách xâu

Tương tự các bài tách xâu ở trên, các bạn tách thành 2 phần số và đơn vị. Rồi xét đơn vị để ra kết quả.
 

bool cmp(string a, string b) 
{

   return a + b < b + a;

}

- Hàm cmp so sánh hai chuỗi a và b bằng cách ghép chúng lại theo hai thứ tự khác nhau:
 - a + b: chuỗi a trước b.
 - b + a: chuỗi b trước a.
- Nếu a + b nhỏ hơn b + a nghĩa là a+b có thứ tự từ điển nhỏ hơn, trả về true. Ngược lại trả về false thì swap trong hàm Sort

Dùng 2 biến:

- `start` và `end` dùng để xác định phạm vi hiện tại của mỗi vòng xoắn ốc.
- `start` là điểm bắt đầu của hàng hoặc cột (ban đầu là 0, và sẽ tăng lên mỗi khi vòng xoắn ốc tiến vào bên trong).
- `end` là điểm kết thúc của hàng hoặc cột (ban đầu bằng `N`, và sẽ giảm dần mỗi khi vòng xoắn ốc tiến vào bên trong).

Cụ thể:

1. Ở vòng lặp đầu tiên, `start = 0` và `end = N`, ta điền các phần tử từ rìa ngoài cùng của ma trận.
2. Sau khi hoàn thành một vòng xoắn ốc (điền xong cả 4 cạnh), `start++` và `end--` để giới hạn lại phạm vi cho vòng lặp tiếp theo, điền vào vòng xoắn kế tiếp phía bên trong.
3. Quá trình này tiếp tục cho đến khi `start < end` không còn thỏa mãn, tức là đã điền xong tất cả các phần tử trong ma trận.

Ma Trận Xoáy!

det(A) = a₁₁(a₂₂a₃₃ — a₂₃a₃₂) — a₁₂(a₂₁a₃₃ — a₂₃a₃₁) + a₁₃(a₂₁a₃₂ — a₂₂a₃₁)

long long det = A[0][0] * (A[1][1] * A[2][2] — A[1][2] * A[2][1]) — A[0][1] * (A[1][0] * A[2][2] — A[1][2] * A[2][0]) + A[0][2] * (A[1][0] * A[2][1] — A[1][1] * A[2][0]);

Dùng 1 biến cnt để đếm số lá bài. Dùng nhập đến khi nào không nhập được nữa, mỗi lần nhập thành công thì biến cnt++, đồng thời cộng tổng tất cả lại. Kết quả là tổng trừ đi số lá bài.

Lá bài

 - Tạo một biến streak để đếm chuỗi ngày tăng dần liên tiếp, bắt đầu với giá trị 1 (vì ngày đầu tiên luôn tính là streak).

  — Tạo một biến maxStreak để lưu streak dài nhất mà Louis đạt được, cũng khởi tạo bằng 1.

Duyệt qua các ngày để tính streak

  — Bắt đầu từ ngày thứ hai (vị trí i = 1) đến ngày cuối cùng (i = n-1):

  — Nếu số từ mới học được ngày hôm nay (a[i]) lớn hơn ngày hôm trước (a[i-1]), nghĩa là streak tăng lên:

  — Tăng streak thêm 1.

  — Cập nhật maxStreak nếu streak hiện tại dài hơn maxStreak.

 - Nếu không (tức là số từ không tăng), đặt lại streak về 1 vì chuỗi liên tiếp bị ngắt.

Học tiếng anh

Gợi ý:

Duyệt qua mảng `arr` để xác định các dãy con tăng.
  — Nếu phần tử hiện tại lớn hơn phần tử trước đó, cập nhật độ dài dãy con và vị trí bắt đầu, kết thúc.
  — Nếu độ dài dãy con lớn hơn độ dài lớn nhất (maxLen), lưu vị trí dãy con vào mảng `batDau` (chứa chỉ số bắt đầu của dãy thoả mãn) và `ketThuc` (chứa chỉ số kết thúc của dãy thoả mãn).
In độ dài lớn nhất `maxLen` và các dãy con tăng dài nhất tìm được.

Dãy con tăng dần!

Chạy cho đến khi `N` chỉ còn là một chữ số (tức là `N < 10`). Khi đó:
Tính tổng các chữ số của `N` (dùng phép `% 10` để lấy chữ số cuối và `/= 10` để bỏ chữ số đã tính).
Cập nhật `N` bằng tổng vừa tính được.

Số đơn giản

Tìm ước số của N: Duyệt qua các số từ 1 đến sqrt(N), nếu i là ước của N (tức là N % i == 0), thì cả i và N / i đều là ước của N.
  — Nếu i * i == N thì chỉ lưu i một lần (vì i == N / i).
  — Nếu không, lưu cả i và N / i vào mảng kết quả.

Sau đó sắp xếp và in ra.