//extern crate rand;

//use rand::{thread_rng, seq};

fn main()
{

    //let mut str = String::from("Hello world");
    //println!("{:?}", str.into_bytes());

    // some bytes, in a vector
    let byte_array = vec![72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 194, 161];

    let target_str: &str = "Hello World!";

    // We know these bytes are valid, so we'll use `unwrap()`.
    let output = String::from_utf8(byte_array).unwrap();
    let mut output_iter = output.bytes();

    for(idx, c) in target_str.bytes().enumerate()
    {
        if output.len() > idx
        {
                println!("output:{} target:{:?}", c ,output_iter.next())
        }
    }
    //println!("{}", output);

    /*let mut rng = thread_rng();
    let samples = vec!["hi", "this", "is", "a", "test!"];
    //let sample = seq::sample_iter(&mut rng, 0..2, 2);
    //println!("{:?}", sample);
    for _ in 0..100
    {
        let sample = seq::sample_iter(&mut rng, 0..3, 2);
        println!("{:?}", sample);
    }*/
    /*let str = "ABCD";
    //let slice = &str[str.len()-1..str.len()];
    //println!("{}", slice);
    let len = (str.len() -1) as u32;

    let mut rng = thread_rng();
    let mut l: u32 = rng.gen_range(0, len);
    let mut r: u32 = rng.gen_range(l, len);
    for _ in 0..1000 {
        println!("{} to {}", l, r);
        l = rng.gen_range(0, len);
        r = rng.gen_range(l, len);
    }*/

}