rust_exercise1.rs

fn rotate_one(arr: &mut [i32]) {
    //arr[1] = 10;
    let c=arr.len();
    let first=arr[0];
    let mut i=1;
    while i<c{
        arr[i-1]=arr[i];
        i+=1;
    }
    arr[c-1]=first;
}
fn rotate(arr: &mut [i32],r:i32){
    for n in 0..r{
        rotate_one(arr);
    }
}
///
fn find_missing(arr1:&[i32],arr2:&[i32])->Vec<i32>{
    let mut n:Vec<i32>=Vec::new();
    //let v: Vec<i32> = Vec::new();
    let mut b:&[i32]=arr1;
    let mut s:&[i32]=arr2;
    if(arr2.len()>arr1.len()){
        b=arr2;
        s=arr1;
    }
    let mut flag=true;
    for v1 in b.iter(){
        flag=true;
        for v2 in s.iter(){
            if *v1==*v2{
                flag=false;
                break;
            }
        }
        if flag==true{
            n.push(*v1);
        }
    }
    return n;
}
fn change(mut arr:[i32;6]){
    arr[0]=234;
    let p=&arr;
    println!("into change address {:p}",p);
    println!("into cahange is {:?}", arr);
}
fn buble_sort(arr:&mut[i32]){
    let mut temp:i32;
    for i in 0..arr.len(){
        let mut j=arr.len()-1;
        while j>i{
            if arr[j-1]>arr[j]{
                temp=arr[j-1];
                arr[j-1]=arr[j];
                arr[j]=temp;
            }
            j=j-1;
        }
    }
}
fn main() {
    let mut arr: [i32;6] = [1, 2, 3, 4,5,6];
    rotate(&mut arr,6);
    println!("this is {:?}", arr);
    let result = find_missing(&[4,12,9,5],&[4,9,12,6,17,21]);
    println!("misssing is {:?}", result);
    let mut arr2: [i32;6] = [1, 2, 3, 4,5,6];
    let p=&arr2;
    println!("main address {:p}",p);
    change(arr2);
    println!("after cahange is {:?}", arr2);
    
    let s = String::from("12345");

   let len = s.len();

   let slice = &s[1..3];
   println!("string is {} {}", slice,s);
   
   let mut v1=vec![1,2,3];
   let mut t2=&mut v1[0];
   *t2=4;

   let tw=&v1[1];
   let s=String::from("aaa");
   let mut s2=s;
   s2.push_str("dd");
   let mut n=3;
   let mut b=Box::new(n);
    println!("{:p}",b);
   box2(&mut b);
   //*b=5;
   let p1=&mut n;
   //*p1=6;
   //println!("vec is {:p} {:p} {:p} {:p} {:?} {:p} {} {}", &v1,&v1[1],tw,&*tw,v1,&n,n,*b);
   let mut v3=[5,7,2,9,6,1,3];
   buble_sort(&mut v3);
   println!("v3:{:?}",v3);
   
   let node=Node{node_type:12};
   let np1=&node;
   let node2=node;
   let np2=&node2;
   
   let d1=Direction::North;
   let d2=d1;
   println!("{:?} {:?}",d1,d2);
   println!("node:{:p} {:p}",&np1,&np2);
   
   let mut a=4;
   let b=&mut a;
   //let c=&mut a;
   println!("{:p} {:p}",b,&a);
   
}
#[derive(Debug,Copy, Clone)]
enum Direction {
    North,
    East,
    South,
    West,
}
#[derive(Debug,Copy,Clone)]
pub struct Node {

    pub node_type: i32,
}
fn box2(bx:&mut i32){
    *bx=7;
    println!("{:p}",&*bx);
}