nonogram

use std::io::{prelude::*, stdin};

type Rule = Vec<Vec<u32>>;
type Board = Vec<Vec<bool>>;

struct Nonogram {
    rules_x: Rule,
    rules_y: Rule,
    board: Board,
}

impl Nonogram {
    fn new(rules_x: Rule, rules_y: Rule) -> Self {
        let board = (0..rules_x.len())
            .map(|_| (0..rules_y.len()).map(|_| false).collect())
            .collect();
        Self {
            rules_x,
            rules_y,
            board,
        }
    }

    fn with_board(rules_x: Rule, rules_y: Rule, board: Board) -> Self {
        let Self {
            rules_x,
            rules_y,
            board: _,
        } = Self::new(rules_x, rules_y);
        Self {
            rules_x,
            rules_y,
            board,
        }
    }

    #[inline]
    fn get_vert(&self, ind: usize) -> impl Iterator<Item = bool> {
        (0..self.rules_x.len())
            .map(|n| self.board[n][ind])
            .collect::<Vec<bool>>()
            .into_iter()
    }

    #[inline]
    fn get_horiz(&self, ind: usize) -> impl Iterator<Item = bool> {
        (0..self.rules_y.len())
            .map(|n| self.board[ind][n])
            .collect::<Vec<bool>>()
            .into_iter()
    }

    #[inline]
    fn check(&self) -> bool {
        for (vals, rule) in (0..self.rules_y.len()).map(|n| (self.get_horiz(n), &self.rules_y[n])) {
            let mut check = Vec::new();
            let mut last = false;
            for checked in vals {
                if !checked {
                    last = checked;
                    continue;
                }
                if !last {
                    check.push(0);
                }
                let len = check.len();
                check[len - 1] += 1;
                last = checked;
            }

            if check != *rule {
                return false;
            }
        }
        for (vals, rule) in (0..self.rules_x.len()).map(|n| (self.get_vert(n), &self.rules_x[n])) {
            let mut check = Vec::new();
            let mut last = false;
            for checked in vals {
                if !checked {
                    last = checked;
                    continue;
                } else if !last {
                    check.push(0);
                }
                let len = check.len();
                check[len - 1] += 1;
                last = checked;
            }

            if check != *rule {
                return false;
            }
        }
        true
    }

    fn set_board(&mut self, board: Board) {
        self.board = board;
    }
}

impl std::fmt::Display for Nonogram {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        for row in (0..self.rules_x.len()).map(|n| self.get_horiz(n)) {
            for val in row {
                write!(f, "{}", if val { "#" } else { "." });
            }
            writeln!(f);
        }
        Ok(())
    }
}

fn main() -> Result<(), Box<std::error::Error>> {
    let mut buf = String::new();
    stdin().read_line(&mut buf)?;
    let x_rules: Rule = buf.trim()
        .replace(" ", "")
        .split(";")
        .map(|s| s.split(",").map(|n| n.parse().unwrap()).collect())
        .collect();
    buf = String::new();
    stdin().read_line(&mut buf)?;
    let y_rules: Rule = buf.trim()
        .replace(" ", "")
        .split(";")
        .map(|s| s.split(",").map(|n| n.parse().unwrap()).collect())
        .collect();
    let len = x_rules.len();

    let mut ngram = Nonogram::new(x_rules, y_rules);

    let mut num = 0;
    while !ngram.check() {
        let bools = get_bools(num, len * len);
        let mut board: Board = std::iter::repeat(Vec::new()).take(len).collect();
        for (i, item) in bools.into_iter().enumerate() {
            board[(i / len) as usize].push(item);
        }

        ngram.set_board(board);
        num += 1;
    }
    println!("{}", ngram);
    Ok(())
}

#[inline]
fn get_bools(num: i64, amount: usize) -> Vec<bool> {
    let mut num = num;
    let mut out = Vec::with_capacity(amount);
    for _ in 0..amount {
        out.push(num % 2 == 0);
        num = num >> 1;
    }
    out
}