Muốn chọn mục nào ta gõ chữ cái đầu của mục đó. Ví dụ gõ A thì màn hình hiện kết quả của x+y, gõ B thì hiện kết quả của x-y,... Ðối với mục D, nếu y khác không thì in kết quả của x/y, còn y=0 thì in câu " Không xác định".
Nếu người dùng nhập một ký tự khác A, B, C, D, a, b, c, d thì máy hiện lời nhắc: "
Không có mục này ".
Biến Ch kiểu ký tự được dùng để lưu chữ cái (mục) mà người dùng đã chọn. Tùy theo giá trị của Ch mà lệnh CASE sẽ quyết định phải làm gì.
Chương trình được viết như sau:
PROGRAM VIDU89;
{ Thực đơn } Uses Crt;
Var
x, y: Real;
Ch: Char;
Begin
Clrscr;
Write('Nhap x va y:');
Readln(x, y);
Gotoxy(10, 3); Write('A. TINH TONG HAI SO');
Gotoxy(10, 5); Write('B. TINH HIEU HAI SO');
Gotoxy(10, 7); Write('C. TINH TICH HAI SO');
Gotoxy(10, 9); Write('D. TINH THUONG HAI SO');
Gotoxy(2,11); Write('-Ban chon muc nao (A, B, C, D) ?:');
Readln(Ch);
CASE Ch of
'A', 'a': Writeln('Tong =', x+y:6:2);
'B', 'b': Writeln(' Hieu =', x-y:6:2);
'C', 'c': Writeln(' Tich =', x*y:6:2);
END;
Readln;
End.
Trong chương trình có sử dụng thủ tục: GOTOXY (m, n) thuộc thư viện CRT, có chức năng đặt con trỏ màn hình vào tọa độ cột thứ m, dòng thứ n trên màn hình. Ví dụ lệnh Gotoxy (10, 3); đặt con trỏ màn hình vào tọa độ cột 10, dòng 3.
Ví dụ 4.10:
Nhập vào tháng và năm, cho biết tháng đó trong năm đó có bao nhiêu ngày.
Theo dương lịch:
Các tháng 4, 6, 9, và 11: có 30 ngày,
Các tháng 1, 3, 5, 7, 8, 10 và 12: có 31 ngày,
Riêng tháng 2 thì bình thường có 28 ngày, nhưng nếu là năm nhuận thì có 29 ngày.
Cách xác định một năm là nhuận như sau:
* hoặc là năm chia hết cho 400 (ví dụ năm 1600, năm 2000).
* hoặc là năm không chia hết cho 100 và chia hết cho 4 (ví dụ các năm 1988, 1992, 1996 đều là năm nhuận).
Trong chương trình ta dùng một biến lôgic có tên là Nhuan để xác định có phải là năm nhuận hay không.
PROGRAM VIDU810;
{ Xác định số ngày của tháng } Var
Thang, Nam, Songay: Integer;
Nhuan: Boolean;
Begin
Write(‘Nhập Thang, Nam: ‘);
Readln(Thang, Nam);
If (Thang<1) or (Thang>12) then writeln(‘ Nhập sai ’) else
begin
Case Thang OF
4, 6, 9, 11: Songay:=30;
1, 3, 5, 7, 8, 10, 12: Songay:=31;
2: begin
Nhuan:= (Nam mod 400=0) or ((Nam mod 100<>0) and (Nam mod 4=0));
If Nhuan= TRUE then Songay:=29 else Songay:=28;
end;
End; { Hết Case }
Writeln(‘ Số ngày là: ‘, Songay);
end;
Readln;
End.
Trong ví dụ này, khi Tháng=2 thì phải làm hai lệnh được đặt trong khối begin và end, đó chính là một lệnh ghép:
begin
Nhuan:= (Nam mod 400=0) or ((Nam mod 100<>0) and (Nam mod 4=0));
If Nhuan= TRUE then Songay:=29 else Songay:=28;
end;
c) Câu lệnh CASE lồng nhau:
Trong cấu trúc CASE, khi một trong các LệnhP1, LệnhP2,..., LệnhPk hay LệnhQ lại là một lệnh CASE thì ta có cấu trúc CASE lồng nhau.
Ví dụ 8.11: Một xí nghiệp tính tiền thưởng hàng tháng cho công nhân theo công thức: Tiền thưởng= Hệ số * 200.
Trong đó Hệ số được tính dựa vào kết quả bình chọn phân loại lao động (loại A, B hay C) và nơi làm việc (cơ sở 1 hay cơ sở 2) của mỗi người trong tháng, cụ thể như sau:
Loại Cơ sở 1 Cơ sở 2
A 2.0 2.5
B 1.5 1.8
C 1.0 1.0
Ví dụ nếu ông X được xếp loại A và làm việc ở cơ sở 1 thì có hệ số thưởng là 2.0, nên tiền thưởng là =2.0*200=400.
Viết chương trình nhập họ tên, phân loại lao động và nơi làm việc của một công nhân, tính tiền thưởng cho người đó.
PROGRAM VIDU4.11;
{ Tính tiền thưởng cho công nhân } Var
Ho_ten: String[20];
Loai: Char;
Coso: Byte;
Heso, Thuong: Real;
Begin
Write(‘ Nhập họ và tên: ‘);
Readln(Ho_ten);
Write(‘ Nhập cơ sở làm việc (1,2): ‘);
Readln(Coso);
Write(‘ Nhập phân loại lao động (A,B,C): ‘);
Readln(Loai);
CASE Loai OF
‘A’, ‘a’: Case Coso of 1: Heso:=2.0;
2: Heso:=2.5;
end;
‘B’, ‘b’: Case Coso of
END; { Hết CASE } Thuong:=Heso*200;
Writeln(‘Họ và tên Tiền thưởng ‘);
Writeln(Ho_ten, Thuong:8:2);
Readln;
End.
* So sánh lệnh Case với lệnh If:
Lệnh If và lệnh Case đều là các câu lệnh rẽ nhánh, cho phép lựa chọn một công việc trong nhiều công việc được lựa chọn. Nhưng cấu trúc If tổng quát và mạnh hơn cấu trúc Case vì lệnh If không hạn chế gì cả, còn lệnh Case thì yêu cầu biểu thức và các hằng phải thuộc kiểu dữ liệu đếm được: nguyên, ký tự, lô gic, liệt kê hay đoạn con, không được là kiểu thực hay chuỗi.
Lệnh Case nào cũng có thể thay thế tương đương bằng các lệnh IF. Ví dụ lệnh Case trong chương trình nói trên (Ví dụ 8.11) có thể thay bằng ba lệnh If sau:
If (Loai=‘A’) or (Loai=‘a’) then
if Coso=1 then Heso:=2.0 else Heso:=2.5;
If (Loai=‘B’) or (Loai=‘b’) then
if Coso=1 then Heso:=1.5 else Heso:=1.8;
If (Loai=‘C’) or (Loai=‘c’) then Heso:=1.0;
Tuy nhiên không phải lệnh If nào cũng thay bằng lệnh Case được.
Việc sử dụng lệnh Case trong nhiều trường hợp có tác dụng làm rõ ràng và nổi bật bố cục của một đoạn chương trình, từ đó dễ đọc, dễ hiểu hơn.
Thông thường, người ta dùng lệnh Case để thay thế các cấu trúc If lồng nhau khi có nhiều (ba, bốn,...) tình huống rẽ nhánh và khi điều kiện cho phép.
Các bạn hãy viết lại các chương trình trong các ví dụ 8.8, 8.9, 8.10, 8.11 nhưng thay lệnh Case bằng các lệnh IF.
CHƯƠNG 186. Cấu trúc lặp FOR a) Câu lệnh FOR dạng 1:
Cú pháp:
FOR biến_đ_kh := m1 TO m2 DO LệnhP;
Yêu cầu:
biến_đ_kh phải thuộc kiểu dữ liệu đơn giản đếm được, thường là kiểu nguyên, ký tự hay lô gic, không thể là kiểu thực hay chuỗi.
m1, m2 là các biểu thức có cùng kiểu dữ liệu với biến, (m2 > m1)
LệnhP có thể là một lệnh đơn giản, lệnh có cấu trúc, hoặc là một lệnh ghép gồm nhiều lệnh đặt trong khối begin và end;.
Cách thức hoạt động của FOR:
Bước 1: Gán giá trị biến_đ_kh := m1;
Bước 2: Nếu biến_đ_kh <= m2 thì làm LệnhP, rồi sang bước 3;
Nếu biến_đ_kh >m2 thì không làm LệnhP mà chuyển sang lệnh kế tiếp ở phía sau vòng lặp FOR.
Bước 3: Tăng giá trị của biến: biến_đ_kh := Succ(biến);
Quay lại bước 2.
Tóm lại: LệnhP sẽ được làm đi làm lại, bắt đầu khi biến = m1, và kết thúc khi biến = m2+1, cả thảy là m2-m1+1 lần. Vì thế, người ta gọi FOR là vòng lặp có số lần lặp đã biết trước.
Các ví dụ cơ bản:
Ví dụ 5.1: Bài toán tính tổng:
Hãy tính tổng: S= 12 + 22+ 32+...+ 102 Thuật toán:
Bước 0: gán S:=0; { gán giá trị ban đầu cho S}
Bước 1: gán S:=S+1*1; { được S=12 } Bước 2: gán S:=S+2*2; { được S=12+22}
Bước 3: gán S:=S+3*3; { S=12+22+32} v.v.
Bước 10: gán S:=S+10*10; { được S=12+22+32+...+102}
Quá trình từ bước 1 đến bước 10 được gọi là phép cộng dồn vào biến S. Tại bước thứ i, lấy giá trị của biến S cộng với i2, kết quả lại được gán cho biến S, do đó giá trị của biến S được tăng thêm một lượng bằng i2. Khi i thay đổi từ 1 đến 10 thì các số 12, 22, 32,..., 102 đều được cộng vào S, kết quả là sau bước thứ 10 giá trị của S đúng bằng tổng 12 + 22 + 32 +... + 102.
Tóm lại, lệnh: S:=S + i*i; được làm cả thảy 10 lầ?, ứng với i=1, 2,..., 10. Quá trình này được diễn đạt bằng lệh FOR, như sau:
For i := 1 To 10 DO S:=S + i*i;
Một cách tổng quát, để tính tổng:S= 12 + 22+ 32+...+ N2, trong đó N là một số nguyên dương bất kỳ, ta dùng hai lệnh:
S:=0;
For i:=1 To N DO S:=S + i*i;
Dưới đây là chương trình cụ thể:
PROGRAM VIDU5.1;
{ Tính tổng các bình phương các số tự nhiên <= N}
Var
N, i: Integer;
S: LongInt;
Begin
Write(‘ Nhập N:’); Readln(N);
S :=0 ;
For i := 1 to N do S := S+i*i;
Writeln(‘S = ‘, S);
Ta viết:
S = 12 + (- 22) + 32 + (- 42) +... +(-1)N-1 N2
Nhận thấy, số hạng thứ i của vế phải có giá trị tuyệt đối bằng i2, mang dấu cộng nếu i lẻ, mang dấu trừ nếu i chẵn. Nói cách khác, ta sẽ cộng dồn i2 vào S nếu i lẻ, và cộng dồn (- i2) vào S nếu i chẵn. Việc xác định i lẻ hay chẵn dựa vào hàm Odd(i) hay kết quả của phép toán i Mod 2. Vậy, các lệnh sẽ dùng là:
S:=0;
For i:=1 To N DO
if i mod 2 <> 0 then S:=S+ i*i else S:= S- i*i;
Các bạn hãy viết chương trình để tính tổng đan dấu này.
Ví dụ 9.2: Bài toán tính tích:
Tính S= 10!.
Ta viết S=1*2*3*...*10.
Thuật toán:
Bước 0: gán S:=1; { gán giá trị ban đầ? cho S}
Bước 1: gán S:=S*1; { được S=1 } Bước 2: gán S:=S*2; { được S=1*2}
Bước 3: gán S:=S*3; { được S=1*2*3}
v.v.
Bước 10: gán S:=S*10; { được S=1*2*3*...*10 =10!}
Nếu trong ví dụ 5.1, ta phải cộng dồn vào biến S thì trong ví dụ này ta phải nhân dồn vào biến S. Tại bước thứ i, lấy giá trị của biến S nhân với i, rồi lại gán kết quả cho biến S. Khi i thay đổi từ 1 đến 10 thì S sẽ tích lũy đủ các thừa số 1, 2, 3,...,10, và giá trị của S sau bước thứ 10 đúng bằng 1*2*3*...*10 =10!.
Quá trình thực hiện từ bước 1 đến bước thứ 10 được mô tả bằng câu lệnh For:
For i:=1 to 10 DO S:=S * i;
Một cách tổng quát, để tính tích: S= 1*2*...*N, trong đó N là một số nguyên dương bất kỳ, ta dùng hai lệnh:
S:=1;
For i:=1 To N DO S:=S* i;
Dưới đây là chương trình cụ thể:
PROGRAM VIDU92;
{ Tính S=N! } Var
N, i: Integer;
S: LongInt;
Begin
Write(‘Nhập số dương N: ‘); Readln(N);
S:=1;
For i:=1 to N do S:=S * i;
Writeln(‘Giai thua = ‘, S);
Readln;
End.
Ví dụ 5.3: Bài toán tính lũy thừa:
Nhập số tự nhiên N và một số thực x bất kỳ, tính S= xN.
Tương tự như tính N!: đầu tiên ta gán S:=1, sau đó tại mỗi bước lặp, ta nhân dồn x vào S bằng lệnh S:=S*x. Sau N bước như vậy, S sẽ được nhân với x đúng N lần. Vậy hai lệnh cần dùng là:
S:=1;
For i:=1 TO N DO S:=S*x;
Dưới đây là chương trình cụ thể:
PROGRAM VIDU5.3; { Tính S=lũy thừa N của x } Var
N, i: Byte;
S, x: Real;
Begin
Write(‘Nhập hai số x và N: ‘);
Readln(x, N);
S:=1;
For i:= 1 to N do S:= S * x;
Writeln(‘Luy thua= ‘, S: 6:2);
Readln;
End.
Ví dụ 5.4: In bảng các chữ cái từ A đến Z thành bốn cột như sau:
KÝ TỰ MÃ KÝ TỰ MÃ A 65 a 97 B 66 b 98
Yêu cầu in thành từng trang màn hình, mỗi trang 15 dòng.
Trong chương trình ta dùng biến Dem để đếm số dòng đã in, mỗi khi in xong một dòng thì biến Dem được cộng thêm 1. Khi Dem = 15, 30, 45,... (tức Dem mod 15=0) thì phải làm lệnh Readln; lệnh này sẽ dừng màn hình cho đến khi ta gõ Enter mới in tiếp.
PROGRAM VIDU94;
{ In bảng các chữ cái}
Uses Crt;
Var
ch, ch1: Char;
Dem: Integer;
Begin
CLRSCR;
Writeln(‘ KY TU MA KY TU MA’);
Dem:=0;
For ch:=‘a’ to ‘z’ do begin
ch1:=Upcase(ch);
begin
Write(‘ Enter để xem tiếp ‘);
Readln;
end;
end;
Writeln(‘ HET ‘);
Readln;
End.
Chương trình trên là một ví dụ về cách dùng biến chạy kiểu ký tự (ch) trong lệnh FOR, ngoài ra, đóng vai trò LệnhP là một lệnh ghép, gồm nhiều lệnh đặt trong khối begin và end.
b) Câu lệnh FOR dạng 2:
Cú pháp:
FOR biến_đ_kh := m2 DOWNTO m1 DO LệnhP; với m2 > m1 Cách thức hoạt động của FOR dạng 2:
Bước 1: gán giá trị biến_đ_kh:= m2;
Bước 2: Nếu biến_đ_kh ≥ m1 thì làm LệnhP, rồi sang bước 3.
Nếu biến_đ_kh < m1 thì không làm LệnhP mà chuyển sang lệnh kế tiếp ở phía dưới
Bước 3: Giảm giá trị của biến_đ_kh:
Biến_đ_kh:=Pred(biến_đ_kh)
;
Quay lại bước 2.
Tóm lại, LệnhP sẽ được làm đi làm lại, bắt đầu khi biến_đ_kh=m2, và kết thúc khi biến_đ_kh
= m1-1, cả thảy là m2-m1+1 lần.
Hình bên là lưu đồ thuật toán cho vòng lặp FOR dạng hai
Ví dụ 9.5: Ðể tính S= N!, ta có thể viết:
S=N*(N-1)*(N-2)*...*2*1
Cách viết cho thấy ngay cách tính: đầu tiên gán S:=1, sau đó thực hiện việc nhân dồn S:=S* i với i= N, N-1,..., 2, 1. Tức là:
S:=1;
For i:=N downto 1 do S:=S* i;
Tương tự, để tính S=xN, ta cũng có thể dùng FOR dạng 2:
S:=1;
For i:=N downto 1 do S:=S* x;
Như vậy, lệnh FOR dạng 2 về bản chất chỉ là một cách viết khác của dạng 1. Thông thường người ta hay dùng lệnh FOR dạng 1, tuy nhiên có khá nhiều tình huống mà việc dùng lệnh FOR dạng 2 tỏ ra rất hiệu quả, như ví dụ sau đây:
Ví dụ 9.6: In các chữ cái theo thứ tự ngược từ Z đến A thành hai dòng:
Z, Y, X,..., C, B, A z, y, x,..., c, b, a
Chương trình được viết như sau:
PROGRAM VIDU4.6;
{ In các chữ cái theo thứ tự đảo ngược từ z đến a}
Var
Ch: Char;
Begin
For ch:=‘Z’ downto ‘A’ do write(ch:3);
Writeln;
For ch:=‘z’ downto ‘a’ do write(ch:3);
Writeln;
Readln;
End.
c) Câu lệnh FOR lồng nhau:
Trong cấu trúc FOR, khi LệnhP cũng là một lệnh FOR thì ta có cấu trúc FOR lồng nhau:
FOR biến1:= n1 TO n2 DO {1}
FOR biến2:=m1 TO m2 DO LệnhP; {2}
Cách thức hoạt động của lệnh này như sau:
Ðầu tiên cho biến1:= n1 và làm lệnh ở dòng {2}. Vì dòng {2} là lệnh FOR nên với mỗi giá trị của biến2=m1,..., m,2, đều phải làm LệnhP, kết quả là LệnhP được làm m2-m1+1 lần.
Bây giờ tăng: biến1:=Succ(biến1), rồi lại làm lệnh FOR ở dòng {2}, kết quả lệnhP được làm thêm n2-n1+1 lần nữa.
v.v...
Quá trình trên cứ tiếp tục cho đến khi biến1=n2-n1+1 thì dừng.
Lệnh FOR {1} làm n2-n1+1 lần lệnh FOR {2}, còn chính lệnh FOR {2} lại làm m2- m1+1 lần LệnhP. Vì thế lệnhP được làm cả thảy là (m2-m1+1)*(n2-n1+1) lần.
Ví dụ 9.7: In hình chữ nhật đặc như dưới đây:
Ta thấy mỗi dòng gồm m chữ A, tức là chữ A được in liên tiếp cả thảy m lần, việc này được làm bằng lệnh:
For j:=1 to m do write(‘A’);
Lệnh Write in m chữ A trên một dòng. In xong, con trỏ vẫn nằm ở cuối dòng đó, vì
Writeln;
Cả thảy ta phải in n dòng như thế, tức là:
For i:=1 to n do In dòng i;
Thay In dòng i bằng hai lệnh nói trên (đặt trong khối begin... end), ta có thuật toán để in hình chữ nhật đặc là:
For i:=1 to n do begin
for j:=1 to m do write(‘A’);
Writeln;
end;
Các bạn hãy viết chương trình cụ thể cho ví dụ này, ở đây m và n là hai số nguyên dương nhập từ bàn phím.
d) Các ứng dụng khác của lệnh FOR:
Lệnh For rất thông dụng, dễ dùng và giải quyết được nhiều bài toán trong khoa học kỹ thuật và trong thực tiễn. Dưới đây chỉ xin nêu hai ứng dụng.
Ví dụ 9.8: Tìm các số Fibonaci.
Dãy số Fibonaci { 1, 1, 2, 3, 5, 8, 13, 21,... } được nhắc nhiều trong giới khoa học kỹ thuật, nó được xây dựng như sau:
U0=1, U1=1, Uk=Uk-1 + Uk-2 với mọi k= 2, 3, 4,...
Gọi U là số hạng thứ k, Uo và U1 lần lượt là hai số hạng đứng ngay trước U.
Ðầu tiên ta gán:
Uo:=1;
U1:=1;
Bước 1: tính U:=Uo+U1 và in U. Lúc này U=2 chính là U2.
Ðể chuẩn bị tính U3, ta cho Uo đóng vai trò của U1 và U1 đóng vai trò của U, tức là gán:
Uo:=U1;
U1:=U;
Kết quả là Uo=1 và U1=2.
Bước 2: tính U:=Uo+U1 và in U. Lúc này U=3 chính là U3.
Ðể chuẩn bị tính U4, ta lại cho Uo đóng vai trò của U1 và U1 đóng vai trò của U, tức là gán:
Uo:=U1;
U1:=U;
Kết quả là Uo=2 và U1=3.
v.v.
Tóm lại các lệnh phải lặp đi lặp lại là:
U:=Uo+U1;
Uo:=U1;
U1:=U;
Vì sang bước sau thì giá trị của U sẽ bị thay đổi nên tại mỗi bước ta đều phải in U.
chương trình được viết như sau:
PROGRAM VIDU5.8;
{ In N+1 số Fibonaci đầu tiên } Var
N, i, U, Uo, U1: Integer;
Begin
Write(‘ Nhập N:’);
Readln(N);
Uo:=1;
U1:=1;
Writeln(N+1, ‘ số Fibonaci đầu tiên là:’);
Write(Uo:3, U1:3);
For i:=2 to N do begin
U:=Uo+U1;
Write(U:3);
Uo:=U1;
U1:=U;
end;
Readln;
End.
Ví dụ 9.9: Bài toán tính tiền lãi gửi ngân hàng:
Nhập tiền vốn ban đầu, số tháng gửi N và lãi suất hàng tháng. Tính số tiền nhận được sau mỗi tháng gửi biết rằng tiền lãi hàng tháng được gộp vào tiền vốn.
Ví dụ, tiền vốn là100, lãi suất tháng là 2%. Sau 1 tháng gửi sẽ có số tiền là:
Số tiền=100 + 100*0.02 = 102 Sau 2 tháng gửi sẽ có số tiền là:
Số tiền=102 + 102*0.02 = 104.04
Công thức tính tiền thu được sau mỗi tháng gửi là:
Số tiền:= Tiền vốn + Tiền vốn * Lãi suất
Số tiền này lại trở thành tiền vốn của tháng sau, tức là:
Tiền vốn:= Số tiền;
Quá trình cứ lặp đi lặp lại từ tháng 1 đến tháng N.
Chương trình cụ thể như sau:
PROGRAM VIDU5.9;
{ Tính tiền gửi ngân hàng sau N tháng}
Var
Tienvon, Laisuat, Sotien: Real;
N, i: Byte;
Begin
Write(‘ Nhập tiền vốn, lãi suất và số tháng gửi: ‘);
Readln(Tienvon, Laisuat, N);
For i:=1 to N do begin
Sotien:= Tienvon + Tienvon*Laisuat;
Writeln(‘Số tiền sau ‘, i, ‘ tháng =‘, Sotien:8:2);
Tienvon:=Sotien;
end;
Cú pháp:
REPEAT
LệnhP;
UNTIL Ðiều_kiện;
Ý nghĩa: Chừng nào Ðiều_kiện còn sai thì cứ làm LệnhP, cho đến khi Ðiều_kiện đúng thì không làm LệnhP nữa mà chuyển sang lệnh kế tiếp ở phía dưới.
Sau đây là lưu đồ thuật toán của vòng lặp Repeat … Until
Cách thức hoạt động của REPEAT:
Bước 1: Làm LệnhP
Bước 2: kiểm tra Ðiềukiện, nếu Ðiều_kiện đúng thì chuyển sang lệnh tiếp theo ở phía dưới, ngược lại, nếu Ðiều_kiện sai thì quay lại bước 1.
LệnhP cũng được gọi là thân của vòng lặp REPEAT, nếu nó gồm nhiều lệnh thì các lệnh đó không cần phải đặt trong khối begin và end.
Nếu Ðiều_kiện không bao giờ đúng thì LệnhP sẽ phải làm mãi, lúc đó ta có vòng lặp vô hạn. Trong trường hợp này, muốn dừng chương trình, hãy gõ đồng thời hai phím Ctrl và Pause (^Pause).
Ðể tránh các vòng lặp vô hạn, trong thân của lệnh REPEAT cần có ít nhất một lệnh có tác dụng làm biến đổi các đại lượng tham gia trong Ðiều_kiện để đến một lúc nào đó thì Ðiều_kiện sẽ đúng và do đó vòng lặp sẽ kết thúc.
Các vòng lặp có số lần lặp biết trước đều có thể giải được bằng lệnh REPEAT. Ðặc biệt, cũng như lệnh WHILE, lệnh REPEAT rất thích hợp với các vòng lặp có số lần lặp không biết trước
Ví dụ 5.12: Ðảm bảo tính hợp lý của dữ liệu nhập từ bàn phím.
Khi giải phương trình bậc hai Ax2+Bx+C=0, ta thường giả thiết A ≠ 0, khi tính S=N!, ta thường yêu cầu N ≠ 0. Sự hạn chế phạm vi đối với các dữ liệu nhập sẽ đảm bảo tính hợp lý của chúng và làm giảm bớt các phức tạp khi biện luận.
Ðể buộc người sử dụng phải nhập A ≠ 0, nếu nhập A=0 thì bắt nhập lại cho tới khi nhập A ≠ 0 mới thôi, ta dùng cấu trúc:
Repeat
Write(‘Nhập A khác không: ‘);
Readln(A);
Until A<> 0;
Ðể đảm bảo chắc chắn nhập N thỏa điều kiện 0<N<20, ta dùng cấu trúc:
Repeat
Write(‘ Nhập N (0<N<20): ‘);
Readln(N);
If (N<=0) or (N>=20) then write(#7);
Until (0<N) and (N<20);
Lệnh write(chr(7)) hay write(#7) có công dụng phát ra tiếng kêu bip để cảnh báo người dùng đã nhập dữ liệu sai yêu cầu.
Ví dụ 5.13: Tìm bội số chung nhỏ nhất của hai số nguyên dương M và N.
Bài toán này có những cách giải khác nhau, dưới đây là một cách đơn giản. Trước hết, hãy xem cách tìm BSCNN của hai số M=5 và N=9.
Vì N>M nên ta sẽ tìm trong tập các bội số của N:{ 9, 18, 27, 36, 45,...} số nhỏ nhất chia hết cho M, đó là số 45.
Một cách tổng quát, gọi Max là số lớn nhất của M và N. Ðầu tiên ta gán:
BSCNN:=0;
Sau đó cứ làm lệnh BSCNN:=BSCNN+Max; hoài cho đến khi BSCNN chia hết cho cả M và N thì dừng.
Trong chương trình ta dùng lệnh repeat để nhập hai số M, N đảm bảo dương.
PROGRAM VIDU913;
{ Tìm BSCNN của M và N } Var
M, N, Max, BSCNN: Integer;
Begin
Repeat
Write(‘ Nhập M và N dương:’);
Readln(M, N);
Until (M>0) and (N>0);
If N>M then Max:=N else Max:=M;
BSCNN:=0;
Repeat
BSCNN:=BSCNN + Max;
Until (BSCNN mod N=0) and (BSCNN mod M=0);
Writeln(‘ Bội số chung nhỏ nhất= ‘, BSCNN);
Readln;
End.
Ví dụ 9.14: Thiết kế để chạy nhiều lần một chương trình.
Trong Turbo Pascal, mỗi lần muốn chạy chương trình ta phải gõ cặp phím Ctrl và F9 (viết tắt là ^F9), điều này sẽ bất tiện nếu cần chạy chương trình nhiều lần ứng với các bộ dữ liệu thử khác nhau. Cấu trúc sau đây cho phép ta chạy chương trình một số lần theo ý muốn: