Rust专项——九九乘法表：四种方向的实现详解
·
引言
九九乘法表是编程初学者的经典练习，也是掌握嵌套循环的绝佳案例。在Rust中，我们可以用不同的方式打印九九乘法表，每种方式都展现了不同的编程技巧和Rust特性。
本文将详细讲解如何在Rust中实现九九乘法表的四种方向：
- 标准方向：左上到右下，完整的乘法表
- 上三角方向：只显示上三角部分（i≤j）
- 下三角方向：只显示下三角部分（i≥j）
- 倒序方向：从大到小的反向打印
每种实现方式都将包含：
- 核心代码实现
- 代码详细解析
- 输出效果展示
- 优化版本和变体
- Rust特性应用
通过本文的学习，你将能够：
- 熟练使用嵌套循环解决实际问题
- 理解不同循环控制的方式
- 掌握Rust的格式化输出
- 学习代码优化和重构技巧
1. 标准九九乘法表（完整版）
1.1 基本实现
这是最常见的九九乘法表格式，显示所有9×9的乘法结果：
fn main() {
println!("=== 标准九九乘法表 ===");
for i in 1..=9 {
for j in 1..=9 {
print!("{}×{}={}\t", j, i, i * j);
}
println!();
}
}
输出效果：
代码解析：
i控制行（被乘数）j控制列（乘数）- 使用
\t（制表符）对齐 - 每行结束后用
println!()换行
1.2 优化版本：对齐格式
fn main() {
println!("=== 标准九九乘法表（对齐版） ===");
for i in 1..=9 {
for j in 1..=9 {
print!("{:2}×{:2}={:2}\t", j, i, i * j);
}
println!();
}
}
代码解析：
{:2}表示最小宽度为2，右对齐- 确保数字小于10时也有固定宽度
1.3 添加分隔线和标题
fn main() {
println!("=== 标准九九乘法表（完整版） ===");
// 使用 format! 进行字符串拼接，避免直接使用 + 运算符
println!("┌{}┐", "─".repeat(80));
for i in 1..=9 {
print!("│ ");
for j in 1..=9 {
// 使用 {:<8} 控制宽度（原 \t 可能导致对齐不一致）
print!("{}×{}={:<8}", j, i, i * j);
}
println!("│");
if i < 9 {
println!("├{}┤", "─".repeat(80));
}
}
println!("└{}┘", "─".repeat(80));
}
关键点：
- 使用
{:<3}左对齐，宽度3 - 使用Unicode字符绘制表格边框
2. 上三角九九乘法表（i ≤ j）
2.1 基本实现
只显示上三角部分，避免重复显示相同的乘法（如3×2和2×3）：
fn main() {
println!("=== 上三角九九乘法表 ===");
for i in 1..=9 {
for j in 1..=9 {
if j >= i { // 只显示 j >= i 的部分
print!("{}×{}={}\t", i, j, i * j);
} else {
print!("\t"); // 空白对齐·看情况写一个或两个\t
}
}
println!();
}
}
输出效果：
2.2 优化版本：紧凑对齐
fn main() {
println!("=== 上三角九九乘法表（紧凑版） ===");
for i in 1..=9 {
for _ in 1..i {
print!(" "); // 8个空格对齐
}
for j in i..=9 {
print!("{}×{}={:<3}\t", i, j, i * j);
}
println!();
}
}
代码解析：
- 第一个循环打印前导空格
- 第二个循环只打印 j>=i 的部分
- 更清晰的控制流
2.3 使用continue优化
fn main() {
println!("=== 上三角九九乘法表（continue版） ===");
for i in 1..=9 {
for j in 1..=9 {
if j < i {
print!(" "); // 空白
continue;
}
print!("{}×{}={:<3}\t", i, j, i * j);
}
println!();
}
}
3. 下三角九九乘法表（i ≥ j）
3.1 基本实现
只显示下三角部分，另一种避免重复的方式：
fn main() {
println!("=== 下三角九九乘法表 ===");
for i in 1..=9 {
for j in 1..=i { // 只显示 j <= i 的部分
print!("{}×{}={}\t", j, i, i * j);
}
println!();
}
}
输出效果：
代码解析：
j的范围是1..=i，而不是1..=9- 每行的项数等于行号
- 更简洁的实现
3.2 优化版本：更好的对齐
fn main() {
println!("=== 下三角九九乘法表（对齐版） ===");
for i in 1..=9 {
for j in 1..=i {
print!("{}×{}={:<3}\t", j, i, i * j);
}
// 填充剩余空格以对齐
for _ in (i + 1)..=9 {
print!(" ");
}
println!();
}
}
3.3 使用不同的格式
fn main() {
println!("=== 下三角九九乘法表（格式化版） ===");
for i in 1..=9 {
for j in 1..=i {
let result = i * j;
if result < 10 {
print!("{}×{}={} ", j, i, result);
} else {
print!("{}×{}={} ", j, i, result);
}
}
println!();
}
}
4. 倒序九九乘法表（从大到小）
4.1 基本实现
从9×9开始，倒序打印到1×1：
fn main() {
println!("=== 倒序九九乘法表 ===");
for i in (1..=9).rev() { // 从9到1
for j in (1..=9).rev() { // 从9到1
print!("{}×{}={}\t", j, i, i * j);
}
println!();
}
}
输出效果：
**代码解析**：
- `(1..=9).rev()` 使用迭代器的 `rev()` 方法反转
- 从大到小的打印顺序
### 4.2 倒序下三角版本
```rust
fn main() {
println!("=== 倒序下三角九九乘法表 ===");
for i in (1..=9).rev() {
for j in (1..=i).rev() { // 倒序的下三角
print!("{}×{}={}\t", j, i, i * j);
}
println!();
}
}
输出效果：
4.3 倒序上三角版本
fn main() {
println!("=== 倒序上三角九九乘法表 ===");
for i in (1..=9).rev() {
for j in (1..=9).rev() {
if j >= i {
print!("{}×{}={}\t", i, j, i * j);
} else {
print!("\t\t");
}
}
println!();
}
}
5. 综合对比与代码重构
5.1 统一接口的函数式实现
enum TableType {
Full, // 完整版
UpperTri, // 上三角
LowerTri, // 下三角
Reverse, // 倒序
}
fn print_multiplication_table(table_type: TableType) {
match table_type {
TableType::Full => {
println!("=== 标准九九乘法表 ===");
for i in 1..=9 {
for j in 1..=9 {
print!("{}×{}={:<3}\t", j, i, i * j);
}
println!();
}
}
TableType::UpperTri => {
println!("=== 上三角九九乘法表 ===");
for i in 1..=9 {
for _ in 1..i {
print!(" ");
}
for j in i..=9 {
print!("{}×{}={:<3}\t", i, j, i * j);
}
println!();
}
}
TableType::LowerTri => {
println!("=== 下三角九九乘法表 ===");
for i in 1..=9 {
for j in 1..=i {
print!("{}×{}={:<3}\t", j, i, i * j);
}
println!();
}
}
TableType::Reverse => {
println!("=== 倒序九九乘法表 ===");
for i in (1..=9).rev() {
for j in (1..=9).rev() {
print!("{}×{}={:<3}\t", j, i, i * j);
}
println!();
}
}
}
}
fn main() {
print_multiplication_table(TableType::Full);
println!();
print_multiplication_table(TableType::UpperTri);
println!();
print_multiplication_table(TableType::LowerTri);
println!();
print_multiplication_table(TableType::Reverse);
}
5.2 使用结构体和方法
struct MultiplicationTable {
size: u32,
}
impl MultiplicationTable {
fn new(size: u32) -> Self {
Self { size }
}
fn print_full(&self) {
println!("=== 标准九九乘法表（{}×{}） ===", self.size, self.size);
for i in 1..=self.size {
for j in 1..=self.size {
print!("{}×{}={:<3}\t", j, i, i * j);
}
println!();
}
}
fn print_upper_triangle(&self) {
println!("=== 上三角九九乘法表（{}×{}） ===", self.size, self.size);
for i in 1..=self.size {
for _ in 1..i {
print!(" ");
}
for j in i..=self.size {
print!("{}×{}={:<3}\t", i, j, i * j);
}
println!();
}
}
fn print_lower_triangle(&self) {
println!("=== 下三角九九乘法表（{}×{}） ===", self.size, self.size);
for i in 1..=self.size {
for j in 1..=i {
print!("{}×{}={:<3}\t", j, i, i * j);
}
println!();
}
}
fn print_reverse(&self) {
println!("=== 倒序九九乘法表（{}×{}） ===", self.size, self.size);
for i in (1..=self.size).rev() {
for j in (1..=self.size).rev() {
print!("{}×{}={:<3}\t", j, i, i * j);
}
println!();
}
}
}
fn main() {
let table = MultiplicationTable::new(9);
table.print_full();
println!();
table.print_upper_triangle();
println!();
table.print_lower_triangle();
println!();
table.print_reverse();
}
6. 高级特性应用
6.1 使用迭代器和函数式风格
fn main() {
println!("=== 使用迭代器的九九乘法表 ===");
(1..=9)
.map(|i| {
(1..=9)
.map(|j| format!("{}×{}={}", j, i, i * j))
.collect::<Vec<_>>()
.join("\t")
})
.for_each(|row| println!("{}", row));
}
6.2 上三角的迭代器版本
fn main() {
println!("=== 迭代器版上三角九九乘法表 ===");
for i in 1..=9 {
let padding: String = (1..i).map(|_| " ").collect();
let row: String = (i..=9)
.map(|j| format!("{}×{}={:<3}", i, j, i * j))
.collect::<Vec<_>>()
.join("\t");
println!("{}{}", padding, row);
}
}
6.3 使用宏简化代码
macro_rules! print_cell {
($a:expr, $b:expr) => {
print!("{}×{}={:<3}\t", $a, $b, $a * $b);
};
}
fn main() {
println!("=== 使用宏的九九乘法表 ===");
for i in 1..=9 {
for j in 1..=9 {
print_cell!(j, i);
}
println!();
}
}
7. 性能优化和最佳实践
7.1 字符串预分配
fn main() {
println!("=== 优化版九九乘法表 ===");
// 预分配字符串，减少内存分配
let mut output = String::with_capacity(1000);
for i in 1..=9 {
output.clear();
for j in 1..=9 {
output.push_str(&format!("{}×{}={:<3}\t", j, i, i * j));
}
println!("{}", output);
}
}
7.2 避免重复计算
fn main() {
println!("=== 避免重复计算的九九乘法表 ===");
for i in 1..=9 {
for j in 1..=i { // 只计算下三角
let result = i * j;
print!("{}×{}={:<3}\t", j, i, result);
}
println!();
}
}
8. 美化输出版本
8.1 带边框的表格
fn main() {
println!("╔══════════════════════════════════════════════════════════════╗");
println!("║ 九九乘法表 ║");
println!("╠══════════════════════════════════════════════════════════════╣");
for i in 1..=9 {
print!("║ ");
for j in 1..=9 {
print!("{}×{}={:<3}\t", j, i, i * j);
}
println!("║");
}
println!("╚══════════════════════════════════════════════════════════════╝");
}
8.2 彩色输出（使用ANSI转义码）
fn main() {
const RESET: &str = "\x1b[0m";
const RED: &str = "\x1b[31m";
const GREEN: &str = "\x1b[32m";
const YELLOW: &str = "\x1b[33m";
println!("=== 彩色九九乘法表 ===");
for i in 1..=9 {
for j in 1..=9 {
let color = if i == j {
RED
} else if i * j < 10 {
GREEN
} else {
YELLOW
};
print!("{}{}×{}={:<3}{}\t", color, j, i, i * j, RESET);
}
println!();
}
}
9. 完整示例程序
use std::io;
fn show_menu() {
println!("\n=== 九九乘法表程序 ===");
println!("1. 标准九九乘法表（完整版）");
println!("2. 上三角九九乘法表");
println!("3. 下三角九九乘法表");
println!("4. 倒序九九乘法表");
println!("5. 显示所有版本");
println!("0. 退出");
print!("请选择（0-5）: ");
}
fn print_full_table() {
println!("\n=== 标准九九乘法表 ===");
for i in 1..=9 {
for j in 1..=9 {
print!("{}×{}={:<3}\t", j, i, i * j);
}
println!();
}
}
fn print_upper_triangle() {
println!("\n=== 上三角九九乘法表 ===");
for i in 1..=9 {
for _ in 1..i {
print!(" ");
}
for j in i..=9 {
print!("{}×{}={:<3}\t", i, j, i * j);
}
println!();
}
}
fn print_lower_triangle() {
println!("\n=== 下三角九九乘法表 ===");
for i in 1..=9 {
for j in 1..=i {
print!("{}×{}={:<3}\t", j, i, i * j);
}
println!();
}
}
fn print_reverse() {
println!("\n=== 倒序九九乘法表 ===");
for i in (1..=9).rev() {
for j in (1..=9).rev() {
print!("{}×{}={:<3}\t", j, i, i * j);
}
println!();
}
}
fn print_all() {
print_full_table();
println!();
print_upper_triangle();
println!();
print_lower_triangle();
println!();
print_reverse();
}
fn main() {
loop {
show_menu();
let mut choice = String::new();
io::stdin()
.read_line(&mut choice)
.expect("读取输入失败");
let choice: u32 = match choice.trim().parse() {
Ok(num) => num,
Err(_) => {
println!("无效输入，请重新选择！");
continue;
}
};
match choice {
1 => print_full_table(),
2 => print_upper_triangle(),
3 => print_lower_triangle(),
4 => print_reverse(),
5 => print_all(),
0 => {
println!("再见！");
break;
}
_ => println!("无效选择，请重新输入！"),
}
}
}
10. 总结对比
10.1 四种方向的对比表
| 方向 | 特点 | 循环范围 | 适用场景 |
|---|---|---|---|
| 标准版 | 显示所有乘积 | 1..=9 × 1..=9 |
完整学习乘法 |
| 上三角 | 避免重复，j≥i | j in i..=9 |
简洁展示，节省空间 |
| 下三角 | 避免重复，j≤i | j in 1..=i |
最简洁的实现 |
| 倒序版 | 从大到小 | (1..=9).rev() |
反向思维训练 |
10.2 代码复杂度对比
| 方向 | 代码行数 | 嵌套层数 | 条件判断 |
|---|---|---|---|
| 标准版 | 最少 | 2层 | 无 |
| 上三角 | 中等 | 2-3层 | 需要 |
| 下三角 | 最少 | 2层 | 无（通过范围控制） |
| 倒序版 | 中等 | 2层 | 无 |
10.3 学习建议
- 初学者：从标准版开始，理解基本嵌套循环
- 进阶学习：掌握下三角版，理解范围控制
- 提高训练：实现上三角版，练习条件判断
- 深入理解：倒序版，掌握迭代器方法
新一代开源开发者平台 GitCode，通过集成代码托管服务、代码仓库以及可信赖的开源组件库，让开发者可以在云端进行代码托管和开发。旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。
更多推荐
27
0- 0
已为社区贡献81条内容
所有评论(0)