循环语句 #

fn main() {
    let mut count = 0;
    
    loop {
        println!("计数: {}", count);
        count += 1;
        
        if count >= 5 {
            break;
        }
    }
}

fn main() {
    let mut counter = 0;
    
    let result = loop {
        counter += 1;
        
        if counter == 10 {
            break counter * 2;  // 返回值
        }
    };
    
    println!("结果: {}", result);  // 20
}

fn main() {
    let mut count = 0;
    
    'outer: loop {
        println!("外层循环 {}", count);
        let mut remaining = 10;
        
        loop {
            println!("  内层循环 {}", remaining);
            
            if remaining == 9 {
                break;  // 只退出内层
            }
            if count == 2 {
                break 'outer;  // 退出外层
            }
            remaining -= 1;
        }
        
        count += 1;
    }
    
    println!("结束");
}

fn main() {
    let mut number = 3;
    
    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }
    
    println!("发射！");
}

fn main() {
    let mut numbers = vec![1, 2, 3, 4, 5];
    
    while !numbers.is_empty() {
        let last = numbers.pop().unwrap();
        println!("弹出: {}", last);
    }
}

fn main() {
    let mut values = vec![Some(1), Some(2), None, Some(3)];
    
    while let Some(Some(value)) = values.pop() {
        println!("值: {}", value);
    }
}

fn main() {
    let fruits = vec!["苹果", "香蕉", "橙子"];
    
    for fruit in fruits {
        println!("水果: {}", fruit);
    }
}

fn main() {
    // 1 到 4
    for i in 1..5 {
        println!("{}", i);
    }
    
    // 1 到 5（包含）
    for i in 1..=5 {
        println!("{}", i);
    }
}

fn main() {
    for i in (1..=5).rev() {
        println!("{}", i);
    }
}

fn main() {
    let fruits = vec!["苹果", "香蕉", "橙子"];
    
    for (index, fruit) in fruits.iter().enumerate() {
        println!("{}: {}", index, fruit);
    }
}

fn main() {
    let mut numbers = vec![1, 2, 3, 4, 5];
    
    for num in numbers.iter_mut() {
        *num *= 2;
    }
    
    println!("{:?}", numbers);  // [2, 4, 6, 8, 10]
}

fn main() {
    for i in 1..=10 {
        if i == 5 {
            break;
        }
        println!("{}", i);
    }
    // 输出 1 2 3 4
}

fn main() {
    for i in 1..=5 {
        if i == 3 {
            continue;
        }
        println!("{}", i);
    }
    // 输出 1 2 4 5
}

fn main() {
    let result = for i in 1..=10 {
        if i == 5 {
            break i * 2;
        }
    };
    
    println!("结果: {:?}", result);  // Some(10)
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    
    // map
    let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
    println!("翻倍: {:?}", doubled);
    
    // filter
    let evens: Vec<&i32> = numbers.iter().filter(|x| *x % 2 == 0).collect();
    println!("偶数: {:?}", evens);
    
    // fold
    let sum: i32 = numbers.iter().fold(0, |acc, x| acc + x);
    println!("总和: {}", sum);
    
    // find
    let first_even = numbers.iter().find(|x| *x % 2 == 0);
    println!("第一个偶数: {:?}", first_even);
}

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    
    let result: Vec<i32> = numbers
        .iter()
        .filter(|x| *x % 2 == 0)
        .map(|x| x * 2)
        .take(3)
        .collect();
    
    println!("结果: {:?}", result);  // [4, 8, 12]
}

fn fibonacci(n: u32) -> u64 {
    if n == 0 {
        return 0;
    }
    
    let mut a = 0;
    let mut b = 1;
    
    for _ in 1..n {
        let temp = a + b;
        a = b;
        b = temp;
    }
    
    b
}

fn main() {
    for i in 0..10 {
        println!("fibonacci({}) = {}", i, fibonacci(i));
    }
}

fn main() {
    for i in 1..=9 {
        for j in 1..=i {
            print!("{}×{}={:<2} ", j, i, i * j);
        }
        println!();
    }
}

fn find_position(numbers: &[i32], target: i32) -> Option<usize> {
    for (index, &value) in numbers.iter().enumerate() {
        if value == target {
            return Some(index);
        }
    }
    None
}

fn main() {
    let numbers = vec![10, 20, 30, 40, 50];
    
    match find_position(&numbers, 30) {
        Some(index) => println!("找到，索引: {}", index),
        None => println!("未找到"),
    }
}