In ra 10 dòng dầu của tam giác Pascal

Tam giác Pascal là gì? Quy luật của Tam giác Pascal rất đơn giản : bắt đầu từ hàng thứ ba, mỗi số bên trong là tổng của hai số ngay phía trên nó. Ví dụ : ở hàng 3, số 2 là tổng của 1 và 1 ; hàng 4, số 3 là tổng của 2 và 1 ; hàng 5, số 6 là tổng của 3 và 3. Căn cứ theo quy luật đó, Tam giác Pascal là kéo dài đến vô hạn.
Ví dụ:

                     1
                   2 3 2
                 3 4 5 4 3
               4 5 6 7 6 5 4
             5 6 7 8 9 8 7 6 5

Đoạn code sau sẽ in ra màn hình 10 dòng đầu của tam giác Pascal (được căn giữa).

uses crt;
const n=10;
var i,j:integer;
begin
 for i:=1 to n do
  begin
   for j:=n downto i do
    write('  '); { <- thêm dấu cách }
   for j:=i to 2*i-1 do write(j:2); { <- đặt chỗ trống cho số}
   for j:=2*i-2 downto i do write(j:2); { <- đặt chỗ trống cho số}
   writeln;
  end;
 readln;
end. 

Tuổi cha tuổi con

Nhập từ bàn phím tuổi cha và con (hiện tại tuổi cha lớn hơn 2 lần tuổi con và tuổi cha hơn tuổi con ít nhất là 25). Đưa ra màn hình câu trả lời cho câu hỏi "Bao nhiêu năm nữa thì tuổi cha gấp đôi tuổi con"?

uses crt;
var tcha,tcon,nam,kq:byte;
begin
write('nhập tuổi con:');readln(tcon);
write('nhập tuổi cha gấp ba lần tuổi con và ít nhất lớn hơn tuổi con 25:');readln(tcha);
repeat
nam:=nam+1;
tcon:=tcon+1:
tcha:=tcha+1;
until tcha=2*tcon;
kq:=nam;
writeln('vậy sau ',kq,' năm thì tuổi cha gấp 2 tuổi con');
readln;
end.

Tìm ước chung lớn nhất và bội chung nhỏ nhất pascal

Ý tưởng: Lấy số lớn hơn trong 2 số trừ đi nhau. Lặp lại thao tác đến khi nào 2 số bằng nhau -> UCLN. Lấy tích của 2 số chia cho UCLN -> BCNN.

Thuật toán tìm Bội chung nhỏ nhất và Ước chung lớn của 2 số trong Pascal:

Cách 1: Dưới đây là thuật toán tìm UCLN bằng cách trừ đi nhau, được trình bày trong SGK tin học 10.

var x,y,UCLN,BCNN:integer;

begin

readln(x,y);
BCNN:=x*y;

While x<>y do If x>y then x:=x-y else y:=y-x;
UCLN:=x;
BCNN:=BCNN div UCLN;

write(UCLN,' ',BCNN);

end.

Cách 2: Thuật toán Euclide: Ngoài cách tìm UCLN như trên. Các bạn có thể sử dụng cách chia lấy dư (mod), chương trình sẽ tối ưu do phải thực hiện ít phép tính hơn.

Ý tưởng: UCLN của 2 số x, y cũng là UCLN của 2 số y và x mod y, vậy ta sẽ đổi x là y, y là x mod y cho đến khi y bằng 0. Khi đó UCLN là x.

var x,y,UCLN,BCNN,t:integer;

begin

readln(x,y);
BCNN:=x*y;
t:= y mod x;
While t <> 0 do
      Begin
        t:= x MOD y;
        x:= y;
        y:= t;
      End;

ucln:=x;
BCNN:=BCNN div UCLN;

write(UCLN,' ',BCNN);

end.

Cách 3: Tìm UCLN bằng cách dùng đệ quy: Đệ quy được hiểu đơn giản là sự gọi nhiều lần chương trình con trong chương trình. Thực sự, đối với bài toán đơn giản, không ai sử dụng đệ quy vì sẽ làm phức tạp vấn đề và làm chương trình trở nên rắc rối, phải thực hiện nhiều phép tính hơn. Tuy nhiên, nếu bắt buộc phải dùng đệ quy, các bạn có thể tham khảo cách làm dưới đây:

function ucln(x,y:integer):integer;
begin
if x = y then
ucln:=x
else if x > y then
ucln:=ucln(x mod y,y)
else
ucln:=ucln(x, y mod x);
end;

var x,y:integer;

begin

readln(x,y);

write('Ước chung lớn nhất là: ', UCLN(x,y), ' Bội chung nhỏ nhất là: ', (x*y) div UCLN(x,y));

end.

Dãy số Fibonacci và bài toán nuôi thỏ

Dãy số Fibonacci bắt nguồn từ bài toán cổ về việc sinh sản của các cặp thỏ. Bài toán đặt ra như sau:
1) Các con thỏ không bao giờ chết
2) Hai tháng sau khi ra đời, mỗi cặp thỏ mới sẽ sinh ra một cặp thỏ con (một đực, một cái)
3) Khi đã sinh con rồi thì cứ mỗi tháng tiếp theo chúng lại sinh được một cặp con mới
Giả sử từ đầu tháng 1 có một cặp mới ra đời thì đến giữa tháng thứ n sẽ có bao nhiêu cặp.

Ví dụ, n = 5, ta thấy:
Giữa tháng thứ 1: 1 cặp (ab) (cặp ban đầu)
Giữa tháng thứ 2: 1 cặp (ab) (cặp ban đầu vẫn chưa đẻ)
Giữa tháng thứ 3: 2 cặp (AB)(cd) (cặp ban đầu đẻ ra thêm 1 cặp con)
Giữa tháng thứ 4: 3 cặp (AB)(cd)(ef) (cặp ban đầu tiếp tục đẻ)
Giữa tháng thứ 5: 5 cặp (AB)(CD)(ef)(gh)(ik) (cả cặp (AB) và (CD) cùng đẻ)
Bây giờ, ta xét tới việc tính số cặp thỏ ở tháng thứ n: F(n)

Nếu mỗi cặp thỏ ở tháng thứ n – 1 đều sinh ra một cặp thỏ con thì số cặp thỏ ở tháng thứ n sẽ là:
F(n) = 2 * F(n – 1)

Nhưng vấn đề không phải như vậy, trong các cặp thỏ ở tháng thứ n – 1, chỉ có những cặp thỏ đã có ở tháng thứ n – 2 mới sinh con ở tháng thứ n được thôi. Do đó F(n) = F(n – 1) + F(n – 2) (= số cũ + số sinh ra). Vậy có thể tính được F(n) theo công thức sau:
• F(n) = 1 nếu n ≤ 2
• F(n) = F(n – 1) + F(n – 2) nếu n > 2
(Trích: Cấu trúc dữ liệu và giải thuật – Lê Minh Hoàng)

VAR thang,i, tn, tn_1, tn_2:INTEGER;
BEGIN           
    write('Nhap so thang: ');
    readln(thang);
    IF thang>2 THEN
    BEGIN
        tn_2:=1; {Thang dau tien co 1 cap tho}
        tn_1:=1; {Thang thu 2 van co 1 cap tho}
        FOR i:=3 TO thang DO
        BEGIN
            tn:=tn_1 + tn_2;
            tn_2:=tn_1;
            tn_1:=tn;
        END;
    END
    ELSE
        tn:=1;
    writeln('So con tho sau ',thang,' thang la: ',2*tn);
    readln
END.

Lưu ý: hiện nay có một số sai khác về định nghĩa dãy Fibonacci như sau:
• F(n) = 1 nếu n < 2
• F(n) = F(n – 1) + F(n – 2) nếu n >= 2
hoặc theo định nghĩa trên wikipedia:
• F(n) = n nếu n < 2
• F(n) = F(n – 1) + F(n – 2) nếu n >= 2

Kiểm tra số nguyên tổ trong pascal

Nhập vào 1 số. Xác định xem số đó có phải số nguyên tố hay không.

Đây là một bài toán rất căn bản trong Pascal. Ý tưởng: Số nguyên tố là số chia cho 1 và chính nó. Giả sử số vừa nhập vào là n, ta cho i chạy từ 2 đến n-1, nếu n chia hết cho i trong bất cứ lần lặp nào thì có nghĩa là n không nguyên tố, nếu không chia hết cho bất cứ lần lặp nào là nguyên tố. Về nguyên tắc là như vậy, nhưng người ta đã chứng minh được rằng chỉ cần xét từ 1 đến phần nguyên căn 2 của N. Như thế thuật toán sẽ tối ưu hơn.


program kiem_tra_nguyen_to;
uses crt;
var n,i:integer; bl:boolean;
begin
 clrscr;
 bl:=true;
 write('nhap vao so can kiem tra tinh nguyen to: '); readln(n);
 if n<=1 then bl:=false;
 for i:=2 to trunc(sqrt(n)) then
  if n mod i=0 then bl:=false;
 if bl=true then write('so vua nhap nguyen to.')
 else write('so vua nhap khong nguyen to.');
readln;
end.

Bouns: Chứng minh: Chỉ cần xét từ 1 đến phần nguyên căn 2 của N thay vì xét đến N: 

Lấy ví dụ số không nguyên tố:

9=3*3
12=3*4
18=2*9=3*6
20=4*5=2*10
trong các ví dụ trên, các số không nguyên tố được phân tích thành tích các cặp ước của chúng, trong mỗi cặp số nhỏ đứng trước, số lớn đứng sau. Trong mỗi cặp, ta có thể thấy rõ một điều: số đứng trước (nhỏ hơn) luôn luôn nhỏ hơn hoặc bằng căn bậc hai của số cần xét. Ví dụ ta thấy 20=4*5, rõ ràng 4 nhỏ hơn căn bậc hai của 20. Bạn tự xét các ví dụ khác nhé. Có thể chứng minh được điều này bằng toán học như sau:

Chứng minh: Gọi số cần xét là n, căn bậc hai của nó là x, hai ước tương ứng có tích bằng n của nó là a và b(a<>b), ta cần chứng minh a<x hoặc b<x. Vì a và b có vai trò tương đương, nên ta giả sử a<b.
Giả sử a>x và b>x, ta có a*b>x*x=n => trái với giải thiết. Vậy trong hai số a và b, phải có một số nhỏ hơn x. 

Dựa vào đặc điểm trên, ta sẽ giới hạn phạm vi của i là 2->n-1 thành 2->sqrt(n). Tuy nhiên, sqrt(n) với n không chính phương sẽ ra số vô tỉ, trong khi i là số nguyên, vậy cần làm tròn sqrt(n). Phạm vi mới sẽ là 2->trunc(sqrt(n)).

Dãy số Fibonaci

In ra màn hình dãy số Fibonaci với n số nhập từ bàn phím. Biết dãy số Fibonaci là dãy số mà F(1)=0, F(2)=1, F(n)=F(n-1)+F(n-2).

uses crt;
var i,n,f1,f2: integer;
begin
 clrscr;
 write('Nhap n: ');
 readln(n);
 f1:=0;
 f2:=1;
 for i:=1 to n do
 begin
  write(f1,' ');
  f2:=f2+f1;
  f1:=f2-f1;
 end;
 readln;
end.

Phân loại lao động của công nhân

1 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 bằ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 a, b, c và nơi làm việc cơ sở 1 hay 2 của mỗi người trong tháng cụ thể trong bảng sau:
|Loại 1|___|CS1|___|CS2|
|A|_______|2.0|___ |2.5|
|B|_______|1.5|___ |1.8|
|C|_______|1.0|___ |1.0|
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 công nhân. Tính tiền thưởng cho người đó.

var ten, cs: string;
  loai: char;
  i,n: integer;
  hs,tien: real;
begin
 write('Nhap so cong nhan: ');
 readln(n);
 for i:=1 to n do
 begin
  write('Nhap ten cong nhan thu ',i,': ');readln(ten);
  write('Nhap phan loai lao dong (a/b/c): ');readln(loai);
  write('Nhap noi lam viec (cs1/cs2): ');readln(cs);
  Case loai of
   'a' : if cs='cs1' then hs:=2.0
         else hs:=2.5;
   'b' : if cs='cs1' then hs:=1.5
         else hs:=1.8;
   'c' : hs:=1.0 ;
  end;
  tien:=hs*200;
  writeln('So tien thuong cua cong nhan ',ten,' la: ',tien:0:2);
 end;
 readln;
end.

Bài toán gà chó

Vừa gà vừa chó, bó lại cho tròn, ba mươi sáu con, một trăm chân chẵn. Hỏi có bảo nhiêu chó gà?

Bài giải

+ Gọi số gà là x ( Điều kiện x nguyên dương, x< 36)
Thì số chó là 36 - x

Số chân gà là 2x, số chân chó là 4 (36 - x)
Tổng số chân là 100 nên theo bài ra ta có phương trình:
2x + 4(36 - x ) = 100

+ Giải phương trình trên :
2x + 4( 36 - x) = 100
=> x = 22

Lập trình trong Pascal

uses crt;
var g,c: integer;
begin
 clrscr;
 for c:=1 to 25 do
 begin
  g:=36-c;
  if 4*c+2*g=100 then
   write('So ga: ',g,' So cho: ',c);
 end;
 readln;
end.

Bài 3: Câu lệnh vòng lặp trong Pascal (for, while, repeat)

- Đánh răng mỗi ngày hai lần, học Tin học mỗi tuần 2 tiết, mỗi ngày tắm một lần...
- Học cho đến khi thuộc bài, rửa tách trà cho đến khi sạch...

Trong cuộc sống, những hành động trên được gọi là lặp đi lặp lặp lại nhiều. Trong Pascal, cách mô tả công việc (hoạt động) được lặp lại nhiều lần gọi là cấu trúc lặp. Có 3 loại cấu trúc vòng lặp như sau:

1. Vòng lặp for

- Đây là vòng lặp căn bản và được sử dụng nhiều nhất trong kiến thức phổ thông. Vòng lặp for dùng để lặp với số lần định trước, có cấu trúc như sau:

for <biến đếm>:= <giá trị đầu> to <giá trị cuối> do <câu lệnh>;

Dạng khác (giảm dần biến đếm của vòng lặp for):

for <biến đếm>:= <giá trị cuối> downto 1 do <câu lệnh>;

vd: Tính tổng các số liên tiếp từ 1 đến 100

program Tinh_tong;
var i,S:integer;
begin   
    S:=0;
    for i:=1 to 100 do S:=S+1;
    write('Tổng là:',S);
    readln;
end.

2. Vòng lặp while

- Cú pháp:  

while <điều kiện> do <câu lệnh>

- Câu lệnh sẽ được lặp lại nhiều lần cho đến khi nào điều kiện còn đúng (nếu điều kiện sai thì các lệnh này sẽ không thực hiện nữa). Đối với lệnh này điều kiện sẽ được kiểm tra trước khi thực hiện lệnh nên nên điều kiện sai thì không có lệnh nào được thực hiện.

vd: Tính tổng các số liên tiếp từ 1 đến 100

var i: byte;
    S: longint;
begin
    S:= 0;
    i:= 1;
    while i <= 100 do
         begin
              S:= S + i;
              i:= i +1;
         end;
    write('Tong tu 1 den 100 la:',S);
    readln;
end.

3. Vòng lặp repeat 

- Cú pháp:

repeat
<câu lệnh>;
until <điều kiện>;

- Câu lệnh giữa repeat và until sẽ được lặp lại nhiều lần khi nào điều kiện sai, nếu điều kiện đúng thì ngưng (ngược với vòng lặp while). Đối với lệnh này điều kiện sẽ được kiểm tra sau khi thực hiện các lệnh giữa repeat và until nên ít nhất các lệnh sẽ được thực hiện trước 1 lần rồi mới kiểm tra điều kiện đúng hay sai (nếu sai thì thực hiện tiếp vòng lặp, đúng thì ngưng).

vd: Tính tổng các số liên tiếp từ 1 đến 100

var i,n: integer;

    S: real;
begin   
    S:=0; i:=1;
    repeat 

    S:=S+i; i:=i+1;
    until i>100;
    writeln('Tong = ',S);
    readln;
end.

Tổng hợp và biên tập