Giáo trình bồi dưỡng học sinh giỏi môn Tin học - Bài giảng Lập trình cấu trúc - Bản đầy đủ

Nội dung tài liệu: Giáo trình bồi dưỡng học sinh giỏi môn Tin học - Bài giảng Lập trình cấu trúc - Bản đầy đủ

1. Mục lục Chương 1. Giải thuật ....................................................................................................... 7 1.1. Khái niệm giải thuật ................................................................................................. 7 1.2. Các tính chất của giải thuật ...................................................................................... 8 1.3. Các cách viết giải thuật ............................................................................................. 8 1.3.1. Liệt kê từng bước ................................................................................................... 8 1.3.2. Lưu đồ .................................................................................................................... 8 1.3.3. Giả mã lệnh .......................................................................................................... 10 1.4. Ví dụ ....................................................................................................................... 10 Câu hỏi và bài tập .......................................................................................................... 11 Chương 2. Căn bản về Turbo Pascal ............................................................................. 13 2.1. Khởi động và kết thúc phiên làm việc với Turbo Pascal........................................ 14 2.1.1. Các tệp tin cần thiết ............................................................................................. 14 2.1.2. Khởi động Turbo Pascal ...................................................................................... 15 2.1.3. Kết thúc................................................................................................................ 15 2.2. Các thao tác xử lý tệp tin ........................................................................................ 15 2.3. Cấu trúc chương trình Turbo Pascal ....................................................................... 15 2.3.1. Giới thiệu cấu trúc chung .................................................................................... 15 2.3.2. Bảng ký tự ........................................................................................................... 16 2.3.3. Từ khóa, tên chuẩn và qui tắc đặt tên .................................................................. 16 2.4. Các thao tác soạn thảo và thực thi chương trình .................................................... 17 2.4.1. Di chuyển con trỏ ................................................................................................ 17 2.4.2. Chọn văn bản ....................................................................................................... 17 2.4.3. Sao chép, di chuyển, xóa văn bản........................................................................ 17 2.4.4. Các bước thực thi chương trình ........................................................................... 18 2.5. Chương trình Pascal đơn giản ................................................................................ 18 2.5.1. Bài toán ................................................................................................................ 18 2.5.2. Xác định các biến ................................................................................................ 18 2.5.2. Soạn thảo chương trình ........................................................................................ 18 2.5.3. Biên dịch và thực thi chương trình ..................................................................... 18 2.6. Các câu lệnh cơ bản ................................................................................................ 19 2.6.1. Lệnh gán .............................................................................................................. 19 2.6.2. Các câu lệnh viết ra màn hình ............................................................................. 19 2.6.3. Các câu lệnh nhập dữ liệu ................................................................................... 19 2.6.4. Cách viết có qui cách ........................................................................................... 20 2.7. Kiểu dữ liệu và các phép toán ................................................................................ 20 2.7.1. Khai báo biến ....................................................................................................... 20 2.7.2. Kiểu số nguyên .................................................................................................... 20 2.7.3. Kiểu số thực ......................................................................................................... 21 2.7.4. Các hàm số học chuẩn ......................................................................................... 21 Bài giảng Lập trình cấu trúc 3
2. 2.7.5. Kiểu ký tự ............................................................................................................ 21 2.7.6. Kiểu logic ............................................................................................................ 22 Câu hỏi và bài tập .......................................................................................................... 22 Chương 3. Cấu trúc điều khiển cơ bản .......................................................................... 24 3.1. Cấu trúc lệnh tuần tự .............................................................................................. 24 3.2. Cấu trúc rẽ nhánh .................................................................................................... 24 3.2.1. Cấu trúc If .. then .. .............................................................................................. 24 3.2.2. Cấu trúc Case of ............................................................................................. 26 3.3. Cấu trúc lặp ............................................................................................................. 28 3.3.1. Cấu trúc For .. to ................................................................................................. 28 3.3.2. Cấu trúc Repeat và While .................................................................................... 30 Câu hỏi và bài tập .......................................................................................................... 31 Chương 4. Chương trình con ......................................................................................... 34 4.1. Các khái niệm cơ bản ............................................................................................. 34 4.2. Cấu trúc chương trình con ...................................................................................... 34 4.2.1. Chương trình con hàm ......................................................................................... 35 4.2.2. Chương trình con thủ tục ..................................................................................... 35 4.3. Biến toàn cục, biến địa phương .............................................................................. 36 4.4. Tham số chương trình con ...................................................................................... 37 4.5. Chương trình con đệ qui ......................................................................................... 38 4.5.1. Khái niệm đệ qui ................................................................................................. 38 4.5.2. Viết chương trình con đệ qui ............................................................................... 38 4.5.3. Mô tả hoạt động của chương trình con đệ qui ..................................................... 39 4.6. Các hàm và thủ tục của unit CRT ........................................................................... 39 Câu hỏi và bài tập .......................................................................................................... 40 Chương 5. Lập trình xử lý giao diện ............................................................................. 43 5.1. Giới thiệu bảng mã ký tự mở rộng ......................................................................... 43 5.2. Các hàm xử lý phím................................................................................................ 43 5.3. Tạo và xử lý giao diện ............................................................................................ 45 5.3.1. Tạo cửa sổ ............................................................................................................ 45 5.3.2. Tạo thực đơn ........................................................................................................ 46 Câu hỏi và bài tập .......................................................................................................... 49 Chương 6. Dữ liệu kiểu mảng ....................................................................................... 50 6.1. Khái niệm và phân loại mảng ................................................................................. 50 6.2. Mảng một chiểu ...................................................................................................... 50 6.2.1. Khai báo mảng ..................................................................................................... 50 6.2.2. Truy xuất phần tử ................................................................................................ 51 6.2.3. Tìm kiếm phần tử ................................................................................................ 52 6.2.4. Sắp xếp mảng ...................................................................................................... 53 6.3. Mảng hai chiều ....................................................................................................... 54 Bài giảng Lập trình cấu trúc 4
3. 6.3.1. Khai báo mảng hai chiều ..................................................................................... 54 6.3.2. Một số bài toán về ma trận .................................................................................. 55 Câu hỏi và bài tập .......................................................................................................... 56 Chương 7. Dữ liệu kiểu xâu ký tự ................................................................................. 59 7.1. Khái niệm xâu ký tự ............................................................................................... 59 7.2. Khai báo và truy xuất ............................................................................................. 59 7.3. Các hàm về xâu ký tự ............................................................................................. 60 7.4. Bài toán ................................................................................................................... 60 Câu hỏi và bài tập .......................................................................................................... 61 Chương 8. Dữ liệu kiểu bản ghi .................................................................................... 63 8.1. Khái niệm về bản ghi .............................................................................................. 63 8.2. Khai báo bản ghi ..................................................................................................... 63 8.3. Truy xuất thành phần trong bản ghi ....................................................................... 63 8.4. Ví dụ áp dụng ......................................................................................................... 64 Câu hỏi và bài tập .......................................................................................................... 65 Chương 9. Dữ liệu kiểu tệp tin ...................................................................................... 66 9.1. Khái niệm và phân loại tệp tin ................................................................................ 66 9.2. Tệp có kiểu ............................................................................................................. 66 9.2.1. Khai báo ............................................................................................................... 67 9.2.2. Các hàm và thủ tục xử lý tệp tin .......................................................................... 67 9.2.3. Ví dụ áp dụng ...................................................................................................... 69 9.3. Tệp văn bản ............................................................................................................ 70 9.3.1. Khai báo ............................................................................................................... 70 9.3.2. Ví dụ áp dụng ...................................................................................................... 70 9.4. Tệp không định kiểu ............................................................................................... 76 9.4.1. Khái báo ............................................................................................................... 76 9.4.2. Các hàm và thủ tục xử lý tệp tin .......................................................................... 76 9.4.3. Ví dụ áp dụng ...................................................................................................... 76 Câu hỏi và bài tập .......................................................................................................... 77 Tài liệu tham khảo ......................................................................................................... 78 Bài giảng Lập trình cấu trúc 5
4. Lời nói đầu Trong hệ thống kiến thức chuyên ngành trang bị cho sinh viên, giáo trình Lập trình cấu trúc góp phần cung cấp những nội dung kiến thức chung nhất về lập trình, thực nghiệm trên ngôn ngữ lập trình Pascal. Giúp người học nắm bắt được những thuật toán cơ bản để giải quyết những bài toán trong từng chương và biết vận dụng những giải thuật đó để giải quyết các bài toán yêu cầu cao hơn. Để phục vụ công tác giảng dạy và học tập, qua những năm trực tiếp giảng dạy, đồng thời tham khảo thêm một số tài liệu khác, tôi biên soạn cuốn giáo trình Lập trình cấu trúc nhằm cung cấp tới người học một số kiến thức cơ bản nhất về lĩnh vực này. Mặc dù đã cố gắng nhiều trong biên soạn, do kiến thức và thời gian có hạn, nên giáo trình không tránh khỏi những thiếu sót. Tôi mong muốn nhận được sự thông cảm và ý kiến đóng góp của các thầy cô, các bạn học sinh, sinh viên và bạn đọc để cuốn giáo trình được tốt hơn. Liên hệ: Vũ Văn Minh Khoa Công nghệ thông tin Trường Cao đẳng Công nghiệp Nam Định Bài giảng Lập trình cấu trúc 6
5. Chương 1. Giải thuật Mục tiêu bài học: - Xác định được tập dữ liệu vào, dữ liệu ra, biết phân chia công việc thành các bước. Sau mỗi bước bao giờ cũng cho 1 kết quả xác định không phụ thuộc vào người hay máy thực hiện mà chỉ phụ thuộc vào dữ liệu vào. - Chỉ ra tính khả thi của các bước thực hiện. Tính dừng sau một số hữu hạn bước. Nắm được 3 cách biểu diễn thuật toán. Trong toán học, để giải quyết một bài toán ta luôn tìm cách áp dụng những định lý, tính chất, tiên đề, hệ quả... nhằm biến đổi dữ kiện đề bài để đưa về kết quả cuối cùng. Trong tin học việc giải các bài toán trước hết là đi tìm thuật giải của bài toán đó. 1.1. Khái niệm giải thuật Thuật giải giải một bài toán nào đó là một dãy các thao tác đơn giản được sắp xếp theo một trình tự xác định rõ ràng và kết thúc sau một số hữu hạn bước nhằm biến đổi dữ liệu vào (input) của một bài toán thành dữ liệu ra (output) mô tả lời giải bài toán đó. Ví dụ. Bài toán tìm UCLN của hai số nguyên dương. Cho: hai số nguyên dương a, b; Cần biết: UCLN của hai số a, b? Ý tưởng để giải quyết bài toán - Để giải quyết bài toán này ta phải hiểu UCLN là gì?  UCLN của a, b là một số lớn nhất mà cả a và b đều chia hết. - Hình dung ra giải thuật để giải quyết Đối với mỗi bài toán có rất nhiều cách giải quyết khác nhau, vấn đề ta tìm ra được một cách giải quyết tối ưu như thế nào? vậy ta cần phải phân tích thuật toán.  Cho biến x bắt đầu từ a hoặc b lùi tới 1, nếu cả a và b đều chia hết cho x thì x là UCLN của a và b.  Thực hiện vòng lặp {nếu a>b thì a=a-b nếu a<b thì b=b-a} đến khi nào a=b thì UCLN là a hoặc b.  Thực hiện phép toán chia dư, như trình bày dưới đây: Thuật toán chia dư giải bài toán trên như sau: - Input: a, b nguyên dương - Output: UCLN của a và b Bước 1: nhận vào số a và số b Bước 2: chia a cho b tìm số dư r Bài giảng Lập trình cấu trúc 7
6. Bước 3: Nếu r = 0 thì chuyển đến bước 5 Bước 4: gán giá trị b cho a, gán giá trị r cho b. Quay về bước 2 Bước 5: thông báo kết quả UCLN là b; Bước 6: Kết thúc.  Phân tích cả 3 thuật toán và chỉ ra ưu điểm của từng thuật toán. 1.2. Các tính chất của giải thuật 1.2.1. Có dữ liệu vào (input) Mỗi thuật giải có thể có một hoặc nhiều dữ liệu vào. 1.2.2. Xác định dữ liệu ra (output) Sau khi thuật giải đã được thực hiện xong, tuỳ theo chức năng mà thuật giải đảm nhiệm ta có thể thu được một số dữ liệu ra xác định 1.2.3. Tính xác định Tính xác định của thuật giải đòi hỏi ở mỗi bước các thao tác phải hết sức rõ ràng, không thể gây nên sự nhập nhằng, lẫn lộn, tuỳ tiện. 1.2.4. Tính kết thúc (tính dừng) Thuật giải phải dừng sau một số hữu hạn bước thực hiện. 1.2.5. Tính hiệu quả Một yêu cầu quan trọng là với input đúng thuật giải phải cho output đúng. 1.2.6. Tính phổ dụng Một thuật giải được xem là có tính phổ dụng cao nếu nó có thể giải bất kỳ bài toán nào trong một lớp lớn các bài toán. 1.3. Các cách viết giải thuật 1.3.1. Liệt kê từng bước - Thuật giải UCLN ở trên được diễn tả theo hình thức liệt kê từng bước. 1.3.2. Lưu đồ(sơ đồ khối) Lưu đồ là công cụ giúp ta diễn tả thuật giải một cách trực quan. Lưu đồ được tạo bởi 4 loại khối nối với nhau bằng các cung Bài giảng Lập trình cấu trúc 8
7. - Khối thao tác được biểu diễn bằng hình chữ nhật. Trong khối này ta viết một hoặc một dãy các thao tác như gán trị, tính toán biểu thức v.v... Khối thao tác có 1 cung đi đến và 1 cung đi ra: y = a + b - Khối điều kiện được biểu diễn bằng hình thoi. Trong khối này ta viết một biểu thức logic. Tuỳ theo giá trị của biểu thức logic là đúng hay sai mà việc thực hiện tiếp theo sẽ được chỉ dẫn bởi một trong hai cung đi ra mang dấu + (cho trường hợp đúng) hoặc dấu - (cho trường hợp sai). Như vậy khối điều kiện có 1 cung đi đến và 2 cung đi ra: a > b - + - Hai khối đặc biệt là khối bắt đầu và khối kết thúc được biểu diễn bằng hình ellip chỉ rõ điểm bắt đầu và điểm kết thúc (điểm dừng) của thuật giải. Khối bắt đầu không có cung đi đến và có 1 cung đi ra. Khối kết thúc có 1 cung đi đến và không có cung đi ra: Begin End - Hình bình hành dùng để biểu diễn thao tác vào ra của thuật toán: Nhập a Kết quả = Dùng lưu đồ diễn tả thuật giải Ơclid tìm UCLN của hai số nguyên dương: Bài giảng Lập trình cấu trúc 9
8. Begin Nhập a, b Tính r là số dư của a chia b r = 0 UCLN = b + - Gán b cho a Gán r cho b End 1.3.3. Giả mã lệnh Khi thể hiện thuật giải bằng giả mã lệnh, ta sẽ vay mượn các cú pháp của một ngôn ngữ lập trình nào đó. Ở đây chúng ta vay mượn các khái niệm của ngôn ngữ lập trình pascal. 1.4. Ví dụ Người A nghĩ trong đầu một số nguyên X trong đoạn từ 1 đến 100. Người B hỏi, người A trả lời hoặc đúng hoặc sai. Sau không quá 7 lần hỏi đáp người B biết số X là số nào. Viết thuật giải cho bài toán này. 1.4.1. Dùng ngôn ngữ liệt kê từng bước Bước 1 Gán T := 1 ; P := 100; Bước 2 Lấy thương nguyên của tổng (T + P) chia cho 2 rồi gán cho G. Bước 3 Kiểm tra điều kiện X > G nếu đúng thì chuyển đến bước 4, còn sai thì chuyển đến bước 5; Bước 4 Lấy G + 1 gán cho T; chuyển đến bước 6; Bước 5 Lấy G gán cho P; Bước 6 Kiểm tra điều kiện T = P nếu sai thì chuyển đến bước 2; Bước 7 Trả lời X = T ; Bước 8 Kết thúc; Bài giảng Lập trình cấu trúc 10
9. 1.4.2. Dùng sơ đồ khối Begin T=1; P=100 G=(T+P) DIV 2 - + P=G X>G T=G+1 - T=P + X=T End 1.4.3. Dùng giả mã lệnh Biến nguyên không âm T, P, G, X; Bắt đầu T :=1; P :=100; Lặp G := (P+T) div 2; nếu X > G thì T :=G+1 ngược lại P :=G; đến khi T = P; Thông báo X = P; Kết thúc. Câu hỏi và bài tập 1. Thuật giải là gì? Thuật giải có những tính chất cơ bản nào? 2. Có mấy cách biểu diễn thuật giải Bài giảng Lập trình cấu trúc 11
10. 3. Hãy viết thuật giải vẽ đồ thị của hàm số y = |ax| (với a khác 0) thông qua đồ thị của hàm số y = ax. 4. Trình bày tính chất xác định của thuật giải và nêu rõ ý nghĩa của tính chất này 5. Hãy phát biểu thuật giải để giải bài toán sau: "Có một số quả táo. Dùng cân hai đĩa (không có quả cân) để xác định quả táo nặng nhất"(giả sử mỗi đĩa cân có thể đựng được nửa số quả táo). 6. Xác định dữ liệu vào và dữ liệu ra cho các thuật giải sau đây: a. Rút gọn một phân số. b. Kiểm tra xem ba số cho trước a, b và c có thể là độ dài ba cạnh của một tam giác hay không? Tính trung bình cộng của hai số. Dùng một cốc phụ để tráo nuớc ở hai cốc cho trước. Tìm chu vi và diện tích của hình tròn có bán kính cho trước 7. Có hai bình A và B. Bình A có dung tích 8 lít, bình B có dung tích 5 lít. Trình bày các bước thực hiện để lấy được 2 lít nước. 8. Có 3 bình A, B, C. Bình A có dung tích 8 lít và đựng đầy 8 lít rượu, bình B có dung tích 5 lít, bình C có dung tích 3 lít. Trình bày các bước thực hiện để có được 4 lít rượu ở bình A và 4 lít rượu ở bình B. 9. Một người có 1 con gấu, 1 con dê và 1 cái bắp cải. Nếu không có người ở bên chúng thì con gấu sẽ ăn thịt con dê hoặc con dê sẽ ăn bắp cải. Thuyền chỉ có thể chở được người đó với con gấu hoặc con dê hoặc bắp cải. Người đó làm thế nào để mang chúng sang sông. 10. Có 4 người phải qua một cái cầu, trời tối họ chỉ có một chiếc đèn. Cầu chỉ đi được tối đa 2 người. Như vậy qua cầu phải có đèn và nhiều nhất là chỉ đi được 2 người cùng một lúc. Biết rằng người thứ nhất đi qua cầu hết 1 phút. Người thứ hai đi qua cầu hết 2 phút. Người thứ ba đi qua cầu hết 5 phút. Người thứ tư đi qua cầu hết 10 phút. Hãy tìm cách cho 4 người này qua cầu sao cho tổng số thời gian ít nhất Bài giảng Lập trình cấu trúc 12
11. Chương 2. Căn bản về Turbo Pascal Mục tiêu bài học: - Biết khai thác môi trường làm việc của Turbo Pascal. - Nắm được cấu trúc của 1 chương trình Pascal đơn giản. - Biết viết 1 chương trình Pascal đơn giản với các câu lệnh đơn giản. Sau khi đã có thuật giải cho bài toán, một câu hỏi đặt ra là làm thế nào để máy thực thi thuật giải đó để đưa ra output của bài toán? Chính là ta cần một công cụ lập trình. Turbo Pascal là một công cụ như thế. Sau khi chương trình đã soạn thảo xong, ta dùng TP để kiểm tra xem trong chương trình đó có lỗi cú pháp (viết sai quy cách câu lệnh hoặc mô tả) hay không. Khi không còn các thông báo lỗi nữa, nghĩa là chương trình đã đúng đắn về mặt cú pháp, ta có thể chạy chương trình, nạp dữ liệu và thu nhận kết quả. 2.1. Khởi động và kết thúc phiên làm việc với Turbo Pascal 2.1.1. Các tệp tin cần thiết Để sử dụng TURBO PASCAL ta cần tối thiểu là hai tệp: TURBO.EXE và TURBO.TPL. Ngoài ra, để làm việc được đầy đủ với Turbo Pascal, cần phải có đầy đủ các thư mục sau: BGI thường lưu trữ các tệp tin làm việc về đồ họa BIN thư mục chứa các tệp tin phục vụ chương trình TP. SOURCE chứa các chương trình mẫu UNITS chứa các thư viện chương trình WORK chứa các tệp tin được sinh ra khi thi hành chương trình. Bài giảng Lập trình cấu trúc 13
12. 2.1.2. Khởi động Turbo Pascal Khởi động TURBO PASCAL, giả sử ta đang ở thư mục có hai tệp nói trên ta gõ TURBO tiếp theo là phím ENTER (có nhiều cách khởi động TURBO PASCAL, nếu trên màn hình Windows chúng ta thấy biểu tượng của TURBO PASCAL thì ta chỉ cần kích chuột vào đó) 2.1.3. Kết thúc Để kết thúc phiên làm việc, cần phải tắt chương trình ứng dụng. Trước khi tắt chương trình ứng dụng, chú ý lưu các tệp tin đang làm việc và nhấn tổ hợp phím Alt+X hoặc vào thực đơn File, chọn Exit. 2.2. Các thao tác xử lý tệp tin Ctrl + N hoặc File \ New Tạo tệp tin mới F3 hoặc File \ Open Mở tệp tin có sẵn F2 hoặc File \ Save Lưu trữ tệp tin Alt + F3 hoặc File \ Close Đóng cửa sổ tệp tin hiện hành F6 Chuyển đổi giữa các cửa sổ tệp tin F5 Phóng to cửa sổ tệp tin hiện hành 2.3. Cấu trúc chương trình Turbo Pascal 2.3.1. Giới thiệu cấu trúc chung {Tieu de chuong trinh} Program ten_chuong_trinh; {Cac khai bao} Uses CRT, GRAPH;{Khai bao thu vien} LABEL L1, L2; {Khai bao nhan} CONST C1, C2; {Khai bao hang} TYPE Nguyen = Integer; {Khai bao kieu du lieu theo y nguoi su dung} VAR v1, v2 : Nguyen ; {Khai bao bien} BEGIN {Cac lenh} END. Bài giảng Lập trình cấu trúc 14
13. 2.3.2. Bảng ký tự Bảng chữ gốc của TP là bảng ASCII (American Standard Codes for Information Interchanges). ASCII có 128 kí hiệu bao gồm bộ chữ cái la tinh, các chữ số, các dấu và một số kí hiệu đặc biệt. Bộ chữ cái La tinh Gồm 26 chữ cái tiếng Anh in hoa A-Z và in thường a-z. TP không phân biệt chữ thường và chữ hoa trong tên các đối tượng, ngoại trừ trường hợp trong các xâu văn bản. Bộ chữ số Gồm các chữ số thập phân: 0, 1, ... , 9. Để tránh lẫn 0 (chữ số không) và O (chữ O) TP quy định gạch chéo trong chữ số không. Những dấu phép toán số học + (cộng), - (trừ), * (nhân), / (chia) Các dấu so sánh = (bằng) , > (lớn hơn) , < (nhỏ hơn), >= (lớn hơn hoặc bằng), (khác) Những kí hiệu khác: . ,;: ' ":! @ # $ % \ ^ & () [ ] { } Trong bảng chữ có một kí hiệu gọi là dấu cách hay khoảng trống. Dấu cách được dùng để tạo một khoảng trắng ngăn cách các từ. 2.3.3. Từ khóa, tên chuẩn và qui tắc đặt tên Từ khóa: Trong từ vựng Pascal có một số từ dành riêng mà nghĩa đã được quy định sẵn, chẳng hạn program, begin, end, mà ta đã biết được gọi là từ khoá. chúng tôi giới thiệu dưới đây một số từ khoá sẽ dùng trong giáo trình này AND ARRAY BEGIN CASE CONST DIV DO DOWNTO ELSE END FOR FUNCTION GOTO IF IN LABEL MOD NOT OF OR PROCEDURE PROGRAM REPEAT STRING THEN TO TYPE UNTIL USES VAR WHILE Tên chuẩn: Những tên được đặt sẵn trong TP, chẳng hạn pi, byte, word, integer, longint, read, readln, write, writeln, char, boolean, ... được gọi là tên chuẩn. Qui tắc đặt tên: Bài giảng Lập trình cấu trúc 15
14. Tên chương trình, tên biến và các tên sau này ta gặp phải bắt đầu bằng chữ cái, tiếp theo có thể có một số kí tự nữa nhưng chỉ lấy trong tập gồm chữ cái, chữ số, dấu gạch nối. Tên có thể nhận đến 127 kí tự. Chú ý: TP không phân biệt ký tự hoa hoặc ký tự thường. Ví dụ các cách viết sau là có ý nghĩa như nhau: Begin, BEGIN, begin, beGIN, 2.4. Các thao tác soạn thảo và thực thi chương trình 2.4.1. Di chuyển con trỏ - Các phím lên, xuống, phải, trái (có hình những mũi tên ở bên phải bàn phím): dịch con trỏ từng kí tự theo chiều mũi tên. - Ctrl và phím mũi tên sang trái (phải) : dịch chuyển con trỏ theo từng từ sang trái (phải) của dòng văn bản. - Home: đưa con trỏ về đầu dòng. - End: đưa con trỏ về cuối dòng. - PgUp (PgDn): dịch con trỏ lên (xuống) theo từng trang màn hình. - Ctrl-PgUp hoặc Ctrl-PgDn: đưa con trỏ về đầu hoặc cuối văn bản. 2.4.2. Chọn văn bản - Ctrl-K, B. Đánh dấu đến đầu khối. - Ctrl-K, K. Đánh dấu đến cuối khối. - Ctrl-K, Y. Xoá khối dòng đã đánh dấu. - Nhấn phím Shift + Các phím di chuyển con trỏ 2.4.3. Sao chép, di chuyển, xóa văn bản - Ctrl-K, C hoặc Ctrl + Ins Sao chép khối dòng tới vị trí mới của con trỏ. - Ctrl-K, V hoặc Shift + Ins Chuyển khối dòng tới vị trí mới của con trỏ. - Ctrl-K, W. Ghi khối dòng vào một tệp. - Ctrl-K, R. Đọc một tệp từ đĩa vào và xen vào chỗ con trỏ. - Phím Del để xoá một kí tự tại vị trí hiện thời của con trỏ. - Phím lùi (Backspace) để xoá đi một kí tự nằm bên trái con trỏ. - Phím INSERT để chọn chế độ chèn hoặc đè. - Ctrl-Y. Xoá cả dòng đang chứa con trỏ. - Ctrl-Q, Y. Xoá từ vị trí con trỏ đến cuối dòng - Ctrl- Q, A. Tìm kiếm một dãy kí tự và thay thế. Bài giảng Lập trình cấu trúc 16
15. 2.4.4. Các bước thực thi chương trình - Alt + F9: biên dịch chương trình - Ctrl + F9: thi hành chương trình - Theo mặc định, Turbo Pascal dịch chương trình nguồn ra tệp thi hành (exe) ở trên RAM và thực thi trên RAM. Người lập trình có thể lấy tệp exe đó bằng cách chọn lại nơi lưu trữ tệp exe khi dịch của TP bằng cách chọn thực đơn COMPILE, chọn DESTINATION là DISK và chọn nơi lưu trữ bằng cách vào thực đơn OPTION chọn DIRECTORY, thiết lập đường dẫn tại dòng EXE and TPU 2.5. Chương trình Pascal đơn giản 2.5.1. Bài toán Tính chu vi và diện tích hình vuông có độ dài cạnh là một số nguyên được nhận vào từ bàn phím. Xây dựng thuật giải Bước 1. Nhận vào a; Bước 2. Viết ra giá trị của biểu thức chu vi là 4 * a; Bước 3. Viết ra giá trị của biểu thức diện tích là a * a; Bước 4. Kết thúc 2.5.2. Xác định các biến a được nhận giá trị mỗi khi thực hiện chương trình (phù hợp với cạnh hình vuông khác nhau) nên a là biến cạnh a Tính toán S, P S và P 2.5.2. Soạn thảo chương trình Program HinhVuong; Var a : Word; Begin readln (a); writeln („Chu vi S= „, 4*a); write („Dien tich P= „, a*a); Readln; End. 2.5.3. Biên dịch và thực thi chương trình Gõ phím F9 để máy dịch chương trình ta vừa viết ở trên sang mã máy. Nếu có lỗi thì máy thông báo cho ta sửa. Sửa xong lại gõ phím F9 để máy báo lỗi tiếp theo (nếu Bài giảng Lập trình cấu trúc 17
16. còn). Khi nào gõ phím F9 mà máy không báo có lỗi thì ta cho chạy chương trình bằng cách gõ tổ hợp hai phím Ctrl-F9 (giữ phím Ctrl và gõ phím F9) sau đó gõ giá trị của a từ bàn phím (thực hiện lệnh Readln(a)). 2.6. Các câu lệnh cơ bản 2.6.1. Lệnh gán Tên_biến := Biểu_thức; Thực hiện lệnh này, máy tính giá trị của biểu thức ở bên phải dấu gán (:=), sau đó gán giá trị này cho biến ở bên trái dấu gán, tức là đưa giá trị đó vào địa chỉ được kí hiệu bởi tên biến ở bên trái dấu gán. Sau lệnh gán, giá trị cũ của biến bị mất và biến nhận giá trị mới. Ví dụ ta khai báo Var a : Integer ; Ở phần thân chương trình ta có hai lệnh gán a := - 6; a := a + 8 thì thực hiện lệnh gán thứ nhất a có giá trị là -6. Tiếp đến sau khi thực hiện lệnh gán thứ hai biến a có giá trị là 2. Giá trị cũ là -6 bị mất, biến nhận giá trị mới. Chú ý: Biểu thức và biến phải cùng kiểu dữ liệu 2.6.2. Các câu lệnh viết ra màn hình Viết lên màn hình tại vị trị hiện hành các giá trị Write(biến, hằng, biểu thức); của biến, hằng, biểu thức. Sau đó con trỏ đặt ở cuối dòng Viết lên màn hình tại vị trị hiện hành các giá trị Writeln(biến, hằng, biểu thức); của biến, hằng, biểu thức. Sau đó con trỏ đặt ở đầu dòng tiếp theo Writeln; Xuống dòng, về đầu dòng tiếp theo. Ví dụ: Write(„Nhap canh hinh vuong a=‟); readln (a); 2.6.3. Các câu lệnh nhập dữ liệu Nhập giá trị cho các biến, mỗi biến cách nhau Read(biến, biến, biến); ít nhất một dấu cách. Nhập giá trị cho các biến, mỗi biến cách nhau Readln(biến, biến, biến); ít nhất một dấu cách, nhập xong ấn phím Enter. Readln; Dừng chương trình, chờ ấn phím Enter. Bài giảng Lập trình cấu trúc 18
17. 2.6.4. Cách viết có qui cách Hiện lên màn hình tại vị trị hiện hành giá_trị ở một Write(giá_trị : m); vùng có m ký tự được căn phải. Nếu giá_trị là số thực thì được làm tròn. Writeln(giá_trị : m); Tương tự, xuống dòng. Chỉ áp dụng cho số thực, hiển thị lên màn hình có m Write(giá_trị : m:n); ký tự trong đó có n ký tự là phần lẻ của giá_trị Ví dụ Write(pi); Cho kết quả 3.1492635432E00 Writeln(pi:4:2); Cho kết quả: 3.14 2.7. Kiểu dữ liệu và các phép toán 2.7.1. Khai báo biến Mỗi biến có một kiểu dữ liệu khác nhau tùy theo mục đích sử dụng biến của lập trình viên. Các biến phải được khai báo trước khi sử dụng. Cú pháp: ten_bien : KIEU_DU_LIEU; ten_bien được đặt theo quy tắc đặt tên đã trình bày ở mục 2.3.3 KIEU_DU_LIEU là các kiểu dữ liệu chuẩn hoặc kiểu của người sử dụng định nghĩa. 2.7.2. Kiểu số nguyên Có 5 kiểu số nguyên với kích thước ô nhớ khác nhau, tùy theo tính chất sử dụng biến trong chương trình, người lập trình khai báo biến cho phù hợp (tránh lãng phí bộ nhớ). Kích thước ô Tên kiểu Phạm vi giá trị nhớ (byte) Byte 0 255 1 ShortInt -128 127 1 Word 0 65535 2 Integer -32768 32767 2 LongInt - 2147483648 2147483647 4 Các phép toán với số nguyên  Phép toán số học: + (cộng) - (trừ) * (nhân) / (chia) DIV (phép chia nguyên) MOD (phép chia dư)  Phép so sánh: = = <>  Phép toán trên bit: AND (và) OR (hoặc) NOT (phủ định) SHL (dịch trái) SHR (dịch phải) Bài giảng Lập trình cấu trúc 19
18. 2.7.3. Kiểu số thực Trong chế độ làm việc mặc định của TP, ta chỉ có thể làm việc được với kiểu REAL, muốn làm việc với kiểu dữ liệu khác, ta phải có khai báo xa. Kích thước ô Tên kiểu Phạm vi giá trị nhớ (byte) Single 1.5E-45 3.4E38 4 Real 2.9E-39 1.7E38 6 Double 5.0E324 1.7E308 8 Các phép toán trên kiểu số thực  Phép toán số học: + (cộng) - (trừ) * (nhân) / (chia)  Phép so sánh: = = <> Vì số thực được lưu trữ trong các ô nhớ dạng cấu trúc nên không có phép toán DIV, MOD và các phép toán xử lý BIT. 2.7.4. Các hàm số học chuẩn Abs(x): Lấy giá trị tuyệt đối của x. Giá trị của hàm cùng kiểu với kiểu đối số x. Sqr(x) : Cho x bình phương. Giá trị của hàm cùng kiểu với kiểu của đối số x. Sqrt(x): Lấy căn bậc 2 của x. Giá trị của hàm thuộc kiểu thực. Int(x) : Cho phần nguyên của x. Giá trị của hàm thuộc kiểu thực. Trunc(x): Cho phần nguyên của x. Giá trị của hàm thuộc kiểu nguyên. Round(x): Làm tròn x đến số nguyên gần x nhất. Giá trị của hàm có kiểu nguyên Sin(x): Cho giá trị của sinx, ở đây x tính bằng đơn vị là radian. Cos(x): Cho giá trị của cosx, ở đây x tính bằng đơn vị là radian. Arctan(x): Cho góc tính bằng radian có tang bằng x. Exp(x): Tính ex. Giá trị của hàm thuộc kiểu thực. Ln(x): Tính lôgarit cơ số e của x. Giá trị của hàm thuộc kiểu thực. Frac(x): Cho phần thập phân của x. Giá trị của hàm thuộc kiểu thực Random(x): đối số x phải là nguyên. Hàm này cho ngẫu nhiên một số nguyên lớn hơn hoặc bằng 0 và nhỏ hơn x. 2.7.5. Kiểu ký tự Kiểu ký tự (CHAR) để biểu diễn các giá trị là các ký tự thuộc bảng chữ cái ASCII. Bảng mã ASCII có 256 ký tự được gán thứ tự từ 0 255, ví dụ ký tự „A‟ có mã là 65, „a‟ có mã là 97. Bài giảng Lập trình cấu trúc 20
19. Bảng mã ASCII được chia thành 3 loại ký tự: ký tự điều khiển, ký tự văn bản, ký tự đồ họa: Loại ký tự Mã ký tự Ví dụ xuống dòng: 13 Ký tự điều khiển 0..31 về đầu dòng: 10 tab: 8 Ký tự văn bản 32..127 „A‟: 65; „a‟:97; „0‟:48 Ký tự đồ họa 128..255 „|‟:179 Các hàm và thủ tục với kiểu Char Readkey: hàm đọc một ký tự từ bộ đệm bàn phím, nếu bộ đệm bàn phím rỗng, hàm chờ người sử dụng nhấn phím Enter. Keypressed: hàm kiểm tra nếu có một phím được nhấn thì hàm trả về giá trị TRUE, ngược lại hàm cho giá trị FALSE. chr(x) hàm trả về ký tự có mã là x ord(c) hàm trả về mã của ký tự c pred(c) hàm trả về ký tự đứng trước ký tự c. succ(c) hàm trả về ký tự đứng sau ký tự c. 2.7.6. Kiểu logic Kiểu logic (BOOLEAN) để biểu diễn trạng thái đúng hoặc sai của phép toán; biến có kiểu logic nhận một trong hai giá trị là TRUE hoặc FALSE. Mặc định FALSE<TRUE Các phép toán: x y x and y x or y not y TRUE TRUE TRUE TRUE FALSE TRUE FALSE FALSE TRUE TRUE FALSE TRUE FALSE TRUE FALSE FALSE FALSE FALSE FALSE TRUE Câu hỏi và bài tập 1.Những tên sau đây viết đúng hay sai: A, AA, BIC, 1B, St , A*, A-B, CHU VI, In, TO, READ, _10A, F(x), M[, $Q, P^ 2. Hãy lấy các ký tự đồ họa bằng cách ấn phím Alt với phím số bên phải bàn phím (ví dụ: Alt_219: giữ phím Alt, gõ các số 2, 1, 9 ở các phím phía bên phải bàn phím) để viết khối hình chữ nhật. Viết chương trình để máy in lên màn hình thông tin sinh viên như sau: Bài giảng Lập trình cấu trúc 21
20. TRUONG CAO DANG CONG NGHIEP NAM DINH KHOA CONG NGHE THONG TIN SINH VIEN: NGUYEN TIEN DUNG LOP: CD51TH1 MA SINH VIEN: CD510023 3. Viết chương trình tính diện tích xung quanh, diện tích toàn phần, thể tích hình lập phương khi cho độ dài cạnh là một số nguyên. 4. Viết chương trình tính giá trị của biểu thức X3- 4X2 + 3X-5 cho biết X là một số nguyên. 5. Lập chương trình tính chu vi và diện tích hình tròn theo bán kính r. 6. Viết chương trình tính diện tích, thể tích hình cầu khi cho bán kính. 7. Viết chương trình cho máy nhận vào ba cạnh a, b, c của tam giác ABC. 8. Tính độ dài các đường trung tuyến của tam giác ABC. 9. Tính bán kính đường tròn ngoại tiếp tam giác ABC. 10. Tính chu kì dao động của một con lắc đơn có chiều dài dây là l. 11. Biết cạnh huyền a, cạnh góc vuông b của tam giac vuông ABC. Tính bán kính đường tròn nội tiếp tam giác đó. 12. Cho tam giác vuông ABC có góc A = 90o. Lập chương trình tính góc C, cạnh AC, cạnh AB khi cho biết cạnh huyền BC và góc B (góc B, góc C tính bằng độ và phút). 13. Viết chương trình giải tam giác ABC khi biết góc A, góc B và cạnh c (các góc cho bằng độ và phút). Bài giảng Lập trình cấu trúc 22