Rust学习第二天（基础数据类型，代码结构刷题体验）

第二天 了解高级数据结构以及所有权，以及编程实战，刷了几道题。

```clike
//Guess number game 
use std::io;
use rand::Rng;
use std::cmp::Ordering;

fn main() {
    println!("Guess Number Game Start!");

    let secret = rand::thread_rng().gen_range(1, 101);
    //println!("secret is {}", secret);

    loop {
        let mut guess = String::new();
        println!("Guess the number!");
        io::stdin().read_line(&mut guess).expect("Failed to read line");
        let guess: i32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => {
                println!("Failed to parse string to i32");
                continue;
            },
        };

        match guess.cmp(&secret) {
            Ordering::Less => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal => {
                println!("You win!");
                break;
            },
        }
    }
}

体验所有权，和各种基础数据类型的差别

```clike
fn main() {
    //实现了Copy Trait的基本数据类型所有权不会转移
    let x = 3;
    let y = x;
    println!("hello y {}", y);
    println!("hello x {}", x);
    let arr = [1,2,3,4,5];

    let l = arr.len();
    println!("arr length {}", l);
    for i in arr.iter() {
        println!("i is {}", i);
    }
    //数组切片
    let slice = &arr[1..3];
    println!("slice lentgh {}", slice.len());
    for i in slice.iter(){
        println!("i is {}", i);
    }
    
    //string切片
    let s = String::from("hello rust");
    
    let hello = &s[0..5];
    let rust = &s[6..];
    
    println!("hello rust is {} + {}", hello, rust);
    //需要注意的是 String并没有iter()方法。
}

高级数据结构
可变数组 Vec
写了一个冒泡排序玩玩

fn bubble_sort(arr: &mut Vec<i32> ) {
    let mut i: usize = 0;
    let mut j: usize;
    while i < arr.len() - 1 {
        j = 0;
        while j < arr.len() -1 - i {
            match arr[j].cmp(&arr[j+1]) {
                Ordering::Less => println!("do nothing"),
                Ordering::Greater=> {
                    println!("swap {} to {}", arr[j], arr[j+1]);
                    let tmp =  arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = tmp;
                }
                Ordering::Equal=>{
                    println!("do nothing");
                }
            };
            j += 1;
        }
        i += 1;
    }
}

//标准答案

// bubble sort
pub fn bubble_sort(arrary: &mut Vec<i32>) {
    let len = arrary.len();
    for i in 0..len {
        for j in 0..len - i - 1 {
            if arrary[j + 1] < arrary[j] {
                arrary.swap(j, j + 1);
            }
        }
    }
}

卧槽 感觉rust原来可以这么玩，瞬间对0…len产生了好感

数组和可变数组常用的一些
.swap（index1,index2)
.len()可以获取长度
.reverse() 反转

Vec
.push(&mut self, value T)
.capacity()
.len()

刷题必须要从标准输入提取一些数字，整数啥的，肯定要搞搞这个。
从字符串s中解析出一个整数
let mut s = String::new();
io::stdin().read_line(&mut s).unwrap();
let a : i32 = s.trim().parse().unwrap(); // 字符串s解析成i32类型整数a
从字符串s中解析出多个整数
let arr : Vec = s.split_whitespace().map(|s| s.parse().unwrap()).collect();
// 每个整数都是i32类型，分别为arr[0],arr[1],……
.is_empty() 判断是否为空

rust leetcode刷题，第一题-转矩阵
123
456
789

147
258
369

impl Solution {
    pub fn transpose(matrix: Vec<Vec<i32>>) -> Vec<Vec<i32>> {
        let m = matrix.len();
        let n = matrix[0].len();
        let mut tran_matrix: Vec<Vec<i32>> = vec![vec![0i32;m];n];
        for i in 0..m {
            for j in 0..n {
                tran_matrix[j][i] = matrix[i][j];
            }
        }
        tran_matrix
    }
}

二维数组 申请44
let mut arr = [[0i32; 4]; 4];
二位Vec 申请mn
let mut v = vec![vec![0i32;n];m]
不得不说 rust的二维数组，二维vec是我见过的最优美的申请方式。
呦西！ 这第一道题坚定了我本要放弃Rust的信心，原来的go语言版本简直不堪入目了。。。

func transpose(matrix [][]int) [][]int {

    m := len(matrix)
    n := len(matrix[0])
    trans_matrix := make([][]int,n,n)
    for k, _ := range trans_matrix {
        x := make([]int,m,m)
        trans_matrix[k] = x
    }

    for i:= 0;i<len(matrix);i++ {
        for j:=0;j<len(matrix[0]);j++ {
            trans_matrix[j][i] = matrix[i][j]
        }
    }
    return trans_matrix
}

不得不说rust语言申请二维数组用宏的方式是真的优美快速！！！