vt ct tìm số đảo ngược bằng ngôn ngữ lập trình pascal
vd nhập n = 123 số đảo ngư…
vd nhập n = 123 số đảo ngược là 321
Thầy biết các em đã được học về các phép toán cơ bản trong Pascal và các cấu trúc điều khiển. Chúng ta sẽ vận dụng những kiến thức này để giải quyết bài toán này một cách chi tiết nhất.
Đề bài của chúng ta là: Viết chương trình Pascal để nhập vào một số nguyên dương \(n\), sau đó tìm và in ra số đảo ngược của \(n\). Ví dụ, nếu nhập \(n = 123\), thì số đảo ngược sẽ là \(321\).
Chúng ta hãy cùng nhau phân tích bài toán này nhé.
Bước 1: Phân tích bài toán và tìm ý tưởng
Để tìm số đảo ngược của một số, chúng ta cần lấy từng chữ số của số đó theo thứ tự ngược lại và ghép chúng lại.
Ví dụ với số \(n = 123\):
– Chữ số cuối cùng là \(3\). Chúng ta sẽ đặt \(3\) làm chữ số đầu tiên của số đảo ngược.
– Bỏ chữ số \(3\) ra khỏi \(n\), ta còn \(12\).
– Chữ số cuối cùng của \(12\) là \(2\). Chúng ta sẽ đặt \(2\) vào sau chữ số \(3\) của số đảo ngược, ta được \(32\).
– Bỏ chữ số \(2\) ra khỏi \(12\), ta còn \(1\).
– Chữ số cuối cùng của \(1\) là \(1\). Chúng ta sẽ đặt \(1\) vào sau chữ số \(2\) của số đảo ngược, ta được \(321\).
– Khi số gốc đã hết chữ số, ta dừng lại.
Vậy, làm thế nào để thực hiện các thao tác này bằng lập trình?
Chúng ta có thể sử dụng phép chia lấy dư và phép chia nguyên để tách từng chữ số và để loại bỏ chữ số đã lấy.
– Phép chia lấy dư cho 10 (\(mod 10\)): Sẽ cho chúng ta chữ số cuối cùng của một số.
Ví dụ: \(123 mod 10 = 3\)
– Phép chia nguyên cho 10 (\(div 10\)): Sẽ cho chúng ta số còn lại sau khi bỏ đi chữ số cuối cùng.
Ví dụ: \(123 div 10 = 12\)
Chúng ta cần một biến để lưu trữ số đảo ngược. Gọi biến này là \(so_dao_nguoc\).
Ban đầu, \(so_dao_nguoc\) sẽ bằng 0.
Khi chúng ta lấy được một chữ số từ số gốc, chúng ta sẽ thêm nó vào \(so_dao_nguoc\) bằng cách:
\(so_dao_nguoc = so_dao_nguoc * 10 + chu_so_lay_duoc\)
Hãy thử lại với ví dụ \(n = 123\):
– Lần lặp 1:
– Lấy chữ số cuối: \(chu_so = 123 mod 10 = 3\)
– Cập nhật \(so_dao_nguoc\): \(so_dao_nguoc = 0 * 10 + 3 = 3\)
– Cập nhật \(n\): \(n = 123 div 10 = 12\)
– Lần lặp 2:
– Lấy chữ số cuối: \(chu_so = 12 mod 10 = 2\)
– Cập nhật \(so_dao_nguoc\): \(so_dao_nguoc = 3 * 10 + 2 = 32\)
– Cập nhật \(n\): \(n = 12 div 10 = 1\)
– Lần lặp 3:
– Lấy chữ số cuối: \(chu_so = 1 mod 10 = 1\)
– Cập nhật \(so_dao_nguoc\): \(so_dao_nguoc = 32 * 10 + 1 = 321\)
– Cập nhật \(n\): \(n = 1 div 10 = 0\)
Bây giờ \(n\) bằng 0, chúng ta dừng lại. Số đảo ngược là \(321\).
Quá trình này lặp đi lặp lại cho đến khi số gốc \(n\) bằng 0. Điều này gợi ý chúng ta nên sử dụng cấu trúc lặp \(WHILE\) (trong khi).
Bước 2: Xây dựng thuật toán
1. Khởi tạo biến \(n\) (số cần đảo ngược), \(so_dao_nguoc\) (số đảo ngược), và \(chu_so\) (chữ số lấy được).
2. Nhập giá trị cho \(n\).
3. Gán \(so_dao_nguoc\) bằng 0.
4. Sử dụng vòng lặp \(WHILE\):
* Điều kiện lặp: \(WHILE n > 0 DO\)
* Bên trong vòng lặp:
* Lấy chữ số cuối của \(n\): \(chu_so := n mod 10;\)
Cập nhật \(so_dao_nguoc\): \(so_dao_nguoc := so_dao_nguoc 10 + chu_so;\)
* Cập nhật \(n\) bằng cách bỏ chữ số cuối: \(n := n div 10;\)
5. Sau khi vòng lặp kết thúc (khi \(n\) bằng 0), \(so_dao_nguoc\) sẽ chứa kết quả.
6. In kết quả \(so_dao_nguoc\) ra màn hình.
Bước 3: Viết chương trình Pascal
Bây giờ, chúng ta sẽ chuyển thuật toán trên thành mã lệnh Pascal.
Program Tim_So_Dao_Nguoc;
Uses Crt; { Thư viện Crt giúp chúng ta sử dụng các hàm như ClrScr để xóa màn hình }
Var
n, so_dao_nguoc, chu_so: Integer; { Khai báo các biến nguyên }
Begin
ClrScr; { Xóa màn hình }
Write(‘Nhap vao mot so nguyen duong n: ‘); { Yêu cầu người dùng nhập số }
Readln(n); { Đọc giá trị người dùng nhập vào và lưu vào biến n }
{ Kiểm tra xem số nhập vào có hợp lệ không. Trong trường hợp này, ta giả định n là số nguyên dương theo đề bài. }
{ Nếu muốn xử lý cả số âm, ta cần thêm logic để xử lý dấu. }
so_dao_nguoc := 0; { Khởi tạo biến số đảo ngược bằng 0 }
{ Vòng lặp để tách từng chữ số và xây dựng số đảo ngược }
WHILE n > 0 DO
Begin
chu_so := n mod 10; { Lấy chữ số cuối cùng của n }
{ Xây dựng số đảo ngược bằng cách ghép chữ số mới vào phía sau }
{ Công thức: so_dao_nguoc = so_dao_nguoc * 10 + chu_so }
so_dao_nguoc := so_dao_nguoc * 10 + chu_so;
n := n div 10; { Loại bỏ chữ số cuối cùng khỏi n }
End;
{ In kết quả ra màn hình }
Write(‘So dao nguoc cua so da nhap la: ‘, so_dao_nguoc);
Readln; { Dừng màn hình để người dùng xem kết quả trước khi thoát }
End.
Bước 4: Kiểm tra và gỡ lỗi
Chúng ta hãy chạy thử chương trình với các trường hợp khác nhau:
* Nhập \(n = 123\):
– \(so_dao_nguoc\) ban đầu là 0.
– Lần 1: \(chu_so = 3\), \(so_dao_nguoc = 3\), \(n = 12\).
– Lần 2: \(chu_so = 2\), \(so_dao_nguoc = 32\), \(n = 1\).
– Lần 3: \(chu_so = 1\), \(so_dao_nguoc = 321\), \(n = 0\).
– Vòng lặp kết thúc. In ra \(321\). (Đúng)
* Nhập \(n = 5\):
– \(so_dao_nguoc\) ban đầu là 0.
– Lần 1: \(chu_so = 5\), \(so_dao_nguoc = 5\), \(n = 0\).
– Vòng lặp kết thúc. In ra \(5\). (Đúng)
* Nhập \(n = 100\):
– \(so_dao_nguoc\) ban đầu là 0.
– Lần 1: \(chu_so = 0\), \(so_dao_nguoc = 0\), \(n = 10\).
– Lần 2: \(chu_so = 0\), \(so_dao_nguoc = 0\), \(n = 1\).
– Lần 3: \(chu_so = 1\), \(so_dao_nguoc = 1\), \(n = 0\).
– Vòng lặp kết thúc. In ra \(1\). (Đúng)
Chương trình chạy đúng với các trường hợp đã thử.
Giải thích chi tiết cho các em:
1. \(Program Tim_So_Dao_Nguoc;\): Dòng này khai báo tên của chương trình.
2. \(Uses Crt;\): Đây là một thư viện chuẩn của Pascal, cung cấp các hàm hữu ích cho việc tương tác với màn hình và bàn phím, ví dụ như \(ClrScr\) để xóa màn hình, \(Readln\) để đọc dữ liệu nhập từ người dùng.
3. \(Var\): Từ khóa này dùng để khai báo các biến mà chương trình sẽ sử dụng.
* \(n, so_dao_nguoc, chu_so: Integer;\): Chúng ta khai báo ba biến là \(n\) (để lưu số gốc người dùng nhập vào), \(so_dao_nguoc\) (để xây dựng số đảo ngược) và \(chu_so\) (để lưu từng chữ số chúng ta lấy ra). Tất cả đều thuộc kiểu dữ liệu \(Integer\), tức là số nguyên.
4. \(Begin\) và \(End.\): Cặp từ khóa này đánh dấu phần thân chính của chương trình, nơi chứa các câu lệnh sẽ được thực thi. Dấu chấm \(.\) ở cuối \(End\) là bắt buộc cho chương trình chính.
5. \(ClrScr;\): Câu lệnh này sẽ xóa sạch màn hình máy tính trước khi chương trình bắt đầu chạy, giúp giao diện gọn gàng hơn.
6. \(Write(‘Nhap vao mot so nguyen duong n: ‘);\): Lệnh \(Write\) dùng để hiển thị một thông báo ra màn hình. Ở đây, nó yêu cầu người dùng nhập vào một số.
7. \(Readln(n);\): Lệnh \(Readln\) dùng để đọc dữ liệu mà người dùng nhập từ bàn phím và lưu nó vào biến \(n\). \(ln\) có nghĩa là đọc xong và xuống dòng.
8. \(so_dao_nguoc := 0;\): Chúng ta khởi tạo giá trị ban đầu cho biến \(so_dao_nguoc\) là 0. Điều này rất quan trọng, vì nếu không khởi tạo, biến này có thể chứa một giá trị rác nào đó, làm sai kết quả.
9. \(WHILE n > 0 DO\): Đây là một vòng lặp \(WHILE\). Vòng lặp này sẽ tiếp tục thực hiện các câu lệnh bên trong nó (từ \(Begin\) đến \(End\) của vòng lặp) CHỪNG NÀO điều kiện \(n > 0\) còn đúng. Khi \(n\) trở thành 0 hoặc nhỏ hơn 0, vòng lặp sẽ dừng lại.
10. \(Begin\) và \(End\) (trong vòng lặp): Cặp từ khóa này nhóm các câu lệnh sẽ được lặp đi lặp lại.
11. \(chu_so := n mod 10;\): Phép toán \(mod 10\) (chia lấy dư cho 10) sẽ cho chúng ta chữ số cuối cùng của số \(n\). Ví dụ, nếu \(n\) là \(123\), thì \(123 mod 10\) sẽ là \(3\).
12. \(so_dao_nguoc := so_dao_nguoc * 10 + chu_so;\): Đây là bước “xây dựng” số đảo ngược.
* Chúng ta lấy giá trị hiện tại của \(so_dao_nguoc\), nhân nó với 10. Điều này giống như việc chúng ta “nhích” các chữ số hiện có của \(so_dao_nguoc\) sang trái một vị trí để dành chỗ cho chữ số mới ở hàng đơn vị. Ví dụ, nếu \(so_dao_nguoc\) đang là \(3\), nhân với 10 ta được \(30\).
* Sau đó, chúng ta cộng \(chu_so\) (chữ số vừa lấy được) vào kết quả. Ví dụ, nếu \(chu_so\) là \(2\), thì \(30 + 2 = 32\). Số đảo ngược của \(12\) đã được xây dựng là \(32\).
13. \(n := n div 10;\): Phép toán \(div 10\) (chia lấy phần nguyên cho 10) sẽ loại bỏ chữ số cuối cùng của \(n\). Ví dụ, nếu \(n\) là \(123\), thì \(123 div 10\) sẽ là \(12\). Số \(n\) được cập nhật để chuẩn bị cho lần lặp tiếp theo.
14. \(Write(‘So dao nguoc cua so da nhap la: ‘, so_dao_nguoc);\): Sau khi vòng lặp kết thúc, biến \(so_dao_nguoc\) đã chứa đúng kết quả, chúng ta in nó ra màn hình cùng với một thông báo.
15. \(Readln;\): Lệnh này được đặt ở cuối chương trình để giữ cho cửa sổ chương trình không tự động đóng lại ngay sau khi in kết quả. Người dùng cần nhấn phím Enter để thoát khỏi chương trình.
Thầy hy vọng với giải thích chi tiết này, các em đã hiểu rõ cách hoạt động của chương trình và tự tin có thể tự mình giải quyết những bài toán tương tự. Hãy luyện tập thật nhiều để thành thạo nhé!
uses crt;
var n: integer;
begin
clrscr;
write(‘nhap n:’); readln(n);
while n>0 do begin
write(n mod 10)
n:= n div 10;
end;
readln
end.
#include<stdio.h>
#include<conio.h>
#include<math.h>
int demso(int n)
{
int dem=0;
while( n !=0)
{
n=n/10;
dem++;
}
return dem;
}
int daonguoc(int n)
{
if(n==0)
{
return n;
}
else
{
return (n%10)*pow(10, demso(n)-1)+daonguoc(n/10);
}
}
int main()
{
int n;
printf(“xin moi ban nhap vao 1 so nguyen\n”);
scanf(“%d”, &n);
printf(“%d”, daonguoc(n));
}