Nhập vào một số tự nhiên N, yêu cầu in ra số đảo ngược lại của số N. Ví dụ: N = …
Ví dụ
Input
Output
123
321
100
1
(làm bằng c++ mình đang cần gấp )
Các em đã sẵn sàng chưa nào? Chúng ta bắt đầu nhé!
Bước 1: Phân tích yêu cầu của bài toán
Đề bài yêu cầu chúng ta:
1. Nhập vào một số tự nhiên N.
2. In ra số đảo ngược lại của số N.
3. Lưu ý:
– Các số 0 đứng trước kết quả đảo ngược sẽ bị bỏ đi (ví dụ: 100 đảo ngược là 1).
– Số 0 đảo ngược vẫn là 0.
Để làm được điều này, chúng ta cần suy nghĩ xem làm thế nào để lấy từng chữ số của số N và sắp xếp chúng theo thứ tự ngược lại.
Bước 2: Tìm hiểu cách lấy từng chữ số của một số
Trong lập trình, để lấy chữ số cuối cùng của một số, chúng ta thường sử dụng phép chia lấy dư cho 10.
Ví dụ: Nếu N = 1324
– Lấy chữ số cuối cùng: \( 1324 \mod 10 = 4 \)
– Để loại bỏ chữ số cuối cùng vừa lấy ra, chúng ta chia số đó cho 10 lấy phần nguyên.
– \( 1324 / 10 = 132 \) (lấy phần nguyên)
Chúng ta có thể lặp lại quá trình này cho đến khi số N trở về 0 để lấy hết tất cả các chữ số.
Bước 3: Xây dựng thuật toán để đảo ngược số
Bây giờ, chúng ta cần nghĩ cách ghép các chữ số lấy được theo thứ tự ngược lại để tạo thành số mới.
Giả sử chúng ta có một biến \(so_dao_nguoc\) để lưu trữ số đảo ngược, ban đầu bằng 0.
Khi lấy được chữ số cuối cùng của N (gọi là \(chu_so_cuoi\)), chúng ta sẽ thêm nó vào \(so_dao_nguoc\). Tuy nhiên, để các chữ số được xếp đúng vị trí, chúng ta cần nhân \(so_dao_nguoc\) với 10 trước khi cộng \(chu_so_cuoi\).
Hãy xem ví dụ N = 1324:
Lần lặp 1:
– N = 1324
– \(chu_so_cuoi\) = \( 1324 \mod 10 = 4 \)
– \(so_dao_nguoc\) = \( 0 * 10 + 4 = 4 \)
– N mới = \( 1324 / 10 = 132 \)
Lần lặp 2:
– N = 132
– \(chu_so_cuoi\) = \( 132 \mod 10 = 2 \)
– \(so_dao_nguoc\) = \( 4 * 10 + 2 = 42 \)
– N mới = \( 132 / 10 = 13 \)
Lần lặp 3:
– N = 13
– \(chu_so_cuoi\) = \( 13 \mod 10 = 3 \)
– \(so_dao_nguoc\) = \( 42 * 10 + 3 = 423 \)
– N mới = \( 13 / 10 = 1 \)
Lần lặp 4:
– N = 1
– \(chu_so_cuoi\) = \( 1 \mod 10 = 1 \)
– \(so_dao_nguoc\) = \( 423 * 10 + 1 = 4231 \)
– N mới = \( 1 / 10 = 0 \)
Khi N trở về 0, chúng ta dừng vòng lặp và \(so_dao_nguoc\) chính là kết quả.
Xử lý trường hợp đặc biệt: số 0 đứng trước
Với thuật toán trên, nếu N = 100:
Lần lặp 1: N=100, chu_so_cuoi=0, so_dao_nguoc=0, N moi=10
Lần lặp 2: N=10, chu_so_cuoi=0, so_dao_nguoc=0, N moi=1
Lần lặp 3: N=1, chu_so_cuoi=1, so_dao_nguoc=1, N moi=0
Kết quả là 1, đúng như yêu cầu.
Nếu N = 0:
Vòng lặp sẽ không chạy, \(so_dao_nguoc\) vẫn là 0. Đúng yêu cầu.
Như vậy, thuật toán này đã xử lý được các trường hợp đặc biệt.
Bước 4: Viết chương trình bằng C++
Dựa trên thuật toán đã xây dựng, chúng ta sẽ viết chương trình C++.
cpp
#include
int main() {
int n; // Khai báo biến để lưu số tự nhiên nhập vào
std::cout << "Nhap mot so tu nhien N: "; // Thông báo cho người dùng nhập N
std::cin >> n; // Đọc giá trị N từ bàn phím
int so_dao_nguoc = 0; // Khai báo biến để lưu số đảo ngược, khởi tạo bằng 0
int n_temp = n; // Tạo một biến tạm để làm việc, giữ nguyên giá trị N ban đầu nếu cần
// Trường hợp đặc biệt: nếu N = 0, kết quả đảo ngược là 0
if (n_temp == 0) {
so_dao_nguoc = 0;
} else {
// Vòng lặp while sẽ tiếp tục chạy khi n_temp còn lớn hơn 0
while (n_temp > 0) {
int chu_so_cuoi = n_temp % 10; // Lấy chữ số cuối cùng của n_temp
so_dao_nguoc = so_dao_nguoc * 10 + chu_so_cuoi; // Ghép chữ số vào số đảo ngược
n_temp = n_temp / 10; // Loại bỏ chữ số cuối cùng khỏi n_temp (lấy phần nguyên)
}
}
std::cout << "So dao nguoc cua " << n << " la: " << so_dao_nguoc << std::endl; // In kết quả return 0; // Kết thúc chương trình } Giải thích chi tiết từng dòng lệnh trong chương trình:
– \(#include
– \(int main() { … }\): Đây là hàm chính của chương trình. Mọi chương trình C++ đều cần có hàm \(main()\). Lệnh \(return 0;\) ở cuối hàm \(main\) cho biết chương trình đã kết thúc thành công.
– \(int n;\): Khai báo một biến có tên là \(n\) thuộc kiểu dữ liệu số nguyên (\(int\)). Biến này sẽ dùng để lưu trữ số tự nhiên mà người dùng nhập vào.
– \(std::cout << "Nhap mot so tu nhien N: ";\): Lệnh này sử dụng đối tượng \(std::cout\) để in ra màn hình dòng chữ "Nhap mot so tu nhien N: ". Dấu \(<<\) là toán tử chèn (insertion operator), dùng để đưa dữ liệu vào luồng xuất. - \(std::cin >> n;\): Lệnh này sử dụng đối tượng \(std::cin\) để đọc dữ liệu từ bàn phím và lưu vào biến \(n\). Dấu \(>>\) là toán tử trích xuất (extraction operator), dùng để lấy dữ liệu từ luồng nhập.
– \(int so_dao_nguoc = 0;\): Khai báo một biến số nguyên \(so_dao_nguoc\) và khởi tạo giá trị ban đầu của nó là 0. Biến này sẽ tích lũy dần các chữ số theo thứ tự đảo ngược.
– \(int n_temp = n;\): Khai báo một biến số nguyên \(n_temp\) và gán giá trị của \(n\) cho nó. Chúng ta dùng biến tạm \(n_temp\) để thực hiện các phép toán xử lý số, tránh làm thay đổi giá trị ban đầu của \(n\) mà chúng ta có thể muốn hiển thị ở cuối chương trình.
– \(if (n_temp == 0) { … } else { … }\): Đây là cấu trúc điều kiện \(if-else\).
– \(if (n_temp == 0)\): Kiểm tra xem \(n_temp\) có bằng 0 hay không. Nếu bằng 0, thì số đảo ngược cũng là 0.
– \(so_dao_nguoc = 0;\): Gán giá trị 0 cho \(so_dao_nguoc\).
– \(else { … }\): Nếu điều kiện trong \(if\) không đúng (tức là \(n_temp\) khác 0), khối lệnh trong \(else\) sẽ được thực thi.
– \(while (n_temp > 0) { … }\): Đây là cấu trúc vòng lặp \(while\). Vòng lặp này sẽ tiếp tục thực hiện các lệnh bên trong nó chừng nào điều kiện \(n_temp > 0\) còn đúng. Khi \(n_temp\) nhỏ hơn hoặc bằng 0, vòng lặp sẽ dừng lại.
– \(int chu_so_cuoi = n_temp % 10;\): Bên trong vòng lặp, chúng ta khai báo một biến số nguyên \(chu_so_cuoi\). Lệnh \(n_temp % 10\) thực hiện phép chia lấy dư \(n_temp\) cho 10, kết quả là chữ số cuối cùng của \(n_temp\).
– \(so_dao_nguoc = so_dao_nguoc * 10 + chu_so_cuoi;\): Đây là dòng lệnh quan trọng nhất để xây dựng số đảo ngược.
– \(so_dao_nguoc * 10\): Nhân giá trị hiện tại của \(so_dao_nguoc\) với 10. Điều này tạo ra một “chỗ trống” ở hàng đơn vị cho chữ số mới.
– \(+ chu_so_cuoi\): Cộng chữ số cuối cùng vừa lấy ra (\(chu_so_cuoi\)) vào vị trí hàng đơn vị này.
– \(n_temp = n_temp / 10;\): Lệnh này thực hiện phép chia lấy phần nguyên \(n_temp\) cho 10. Điều này có tác dụng loại bỏ chữ số cuối cùng khỏi \(n_temp\), chuẩn bị cho lần lặp tiếp theo.
– \(std::cout << "So dao nguoc cua " << n << " la: " << so_dao_nguoc << std::endl;\): Sau khi vòng lặp kết thúc (khi \(n_temp\) đã bằng 0), chúng ta in ra màn hình kết quả. Dòng này in ra thông báo "So dao nguoc cua ", theo sau là giá trị ban đầu của \(n\), rồi đến " la: " và cuối cùng là giá trị của \(so_dao_nguoc\). \(std::endl\) là một ký tự đặc biệt dùng để xuống dòng. - \(return 0;\): Cho biết chương trình đã kết thúc thành công. Bước 5: Kiểm tra với các ví dụ
Bây giờ, chúng ta cùng thử chạy chương trình với các ví dụ trong đề bài để đảm bảo nó hoạt động đúng:
– Input: 123
– \(n = 123\), \(n_temp = 123\), \(so_dao_nguoc = 0\)
– Lần 1: \(chu_so_cuoi = 3\), \(so_dao_nguoc = 0 * 10 + 3 = 3\), \(n_temp = 12\)
– Lần 2: \(chu_so_cuoi = 2\), \(so_dao_nguoc = 3 * 10 + 2 = 32\), \(n_temp = 1\)
– Lần 3: \(chu_so_cuoi = 1\), \(so_dao_nguoc = 32 * 10 + 1 = 321\), \(n_temp = 0\)
– Vòng lặp kết thúc.
– Output: So dao nguoc cua 123 la: 321 (Đúng)
– Input: 100
– \(n = 100\), \(n_temp = 100\), \(so_dao_nguoc = 0\)
– Lần 1: \(chu_so_cuoi = 0\), \(so_dao_nguoc = 0 * 10 + 0 = 0\), \(n_temp = 10\)
– Lần 2: \(chu_so_cuoi = 0\), \(so_dao_nguoc = 0 * 10 + 0 = 0\), \(n_temp = 1\)
– Lần 3: \(chu_so_cuoi = 1\), \(so_dao_nguoc = 0 * 10 + 1 = 1\), \(n_temp = 0\)
– Vòng lặp kết thúc.
– Output: So dao nguoc cua 100 la: 1 (Đúng)
– Input: 0
– \(n = 0\), \(n_temp = 0\)
– \(if (n_temp == 0)\) là đúng.
– \(so_dao_nguoc = 0\).
– Output: So dao nguoc cua 0 la: 0 (Đúng)
Bài tập này rất cơ bản nhưng lại là nền tảng quan trọng cho nhiều bài toán xử lý số khác. Các em hãy tự mình gõ lại chương trình và thử với nhiều số khác nhau nhé. Nếu có bất kỳ thắc mắc nào, đừng ngần ngại hỏi cô! Chúc các em học tốt!
\begin{array}{c} \color{#db1616}{\texttt{#Khoadang09}} \end{array}
\(@\)\(\texttt{C++: }\)
#include <bits/stdc++.h>
#define buff ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define int long long
using namespace std;
int reverse_number(int n){
int result_reverse = 0;
while (n!=0){
result_reverse = result_reverse * 10 + n % 10;
n /= 10;
}
return result_reverse;
}
signed main(){
buff;
int n; cin >> n;
cout << reverse_number(n);
return 0;
}*Code C++:
#include <bits/stdc++.h>
using namespace std;
int dn(long long n)
{
long long tmp,res=0;
while (n>0) {
tmp=n%10; //hàm đảo ngược n
res=res*10+tmp;
n=n/10;
}
return res;
}
int main(){
long long n;
cin>>n;
cout<<dn(n); //in kết quả của đảo ngược n
}
*Code Pascal:
var n,sodao:int64;
function dx(n:int64):int64;
var res,tmp:int64;
begin
res:=0;
while n>0 do
begin
tmp:=n mod 10;
res:=res*10+tmp; //hàm đảo ngược n
n:=n div 10;
end;
exit(res);
end;
begin
read(n);
write(dx(n)); //in kết quả của đảo ngược n
end.