第二天 了解高级数据结构以及所有权,以及编程实战,刷了几道题。
```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语言申请二维数组用宏的方式是真的优美快速!!!