arraygen.rs

#![feature(is_sorted)]
use std::vec;
use rand::Rng;


fn construct(input: &Vec<char>, realized_vector: &mut Vec<u64>, i: usize, n: u64) {
    if i == input.len() {
        realized_vector.push(n);
        return;
    }

    if input[i] != '#' {
        let n = n * 10 + (input[i].to_digit(10).unwrap() as u64);
        construct(input, realized_vector, i + 1, n);
        return;
    }

    for j in 0..10 {
        construct(input, realized_vector, i + 1, n * 10 + j);
    }
}

fn random_input_generator(digits: usize, num_hastags: usize) -> String {
    let mut rng = rand::thread_rng();
    let mut input : u64 = rng.gen_range(1..10);

    for _ in 1..digits {
        let random_number = rng.gen_range(0..10);
        input = input * 10 + random_number;
    }

    let mut input = input.to_string().chars().collect::<Vec<char>>();
    while input.iter().filter(|&c| *c == '#').count() < num_hastags {
        let random_index = rng.gen_range(1..input.len());
        input[random_index] = '#';
    }

    input.into_iter().collect::<String>()
}

fn main() {

    let mut average_time = 0;

    for _ in 0..15 {
        let input = random_input_generator(10, 7);    

        let t1 = std::time::Instant::now();
        let number_of_hashtags = input.chars().filter(|&c| c == '#').count();
        let capacity = 10_u64.pow(number_of_hashtags as u32);
        let mut realized_vector : Vec<u64> = Vec::with_capacity(capacity as usize);

        let input = input.chars().collect::<Vec<char>>();
        construct(&input, &mut realized_vector, 0, 0);
        let t2 = std::time::Instant::now();

        println!("Time taken: {:?}", t2 - t1);
        average_time += (t2 - t1).as_millis();
        assert!(realized_vector.is_sorted());
    }

    println!("Average time taken: {:?}", average_time / 15);

}