pub struct Wall {
    heights: Vec<u32>,
}

impl Wall {
    fn create_empty(w: u32) -> Self {
        let heights = if w == 0 {
            vec![]
        } else if w == 1 {
            vec![0]
        } else {
            let mut v = Vec::with_capacity(w as usize);
            v.push(0);
            v.push(1);
            v
        };
        Self { heights }
    }

    pub fn calculate_row(&self, r: u32, stones: &mut [u32]) {
        let mut len = 0;
        let mut i = 0;
        for &height in self.heights.iter() {
            if height == r {
                stones[i] = len;
                i += 1;
                len = 0;
            }
            len += 1;
        }
    }

    pub fn output(&self, n: u32, h: u32) {
        let mut stones = vec![0; n as usize];
        for row in 0..h {
            self.calculate_row(row, &mut stones);
            for &len in stones.iter() {
                if len <= 1 {
                    print!("◼");
                } else if len > 1 {
                    print!("◢");
                    for _ in 0..(len - 2) {
                        print!("◼");
                    }
                    print!("◣");
                }
            }
            println!("");
        }
    }
}

/// Solve for a given N and return the resulting wall
pub struct Solver<T: num::PrimInt> {
    pub n: u32,
    /// calculated height [might not be correct!]
    pub h: u32,
    /// width
    pub w: u32,
    /// Use to store already used blocks as a bitmask
    solve_stack: Vec<T>,
}

impl<T: num::PrimInt> Solver<T> {
    pub fn new(n: usize) -> Self {
        let h = n / 2 + 1;
        let w = h * (n - 1);
        Self {
            n: (n as u32),
            h: (h as u32),
            w: (w as u32),
            solve_stack: Vec::with_capacity(n),
        }
    }

    pub fn solve(&mut self) -> Wall {
        Wall::create_empty(self.w)
    }
}