SHARE
TWEET

nonogram

a guest Mar 22nd, 2019 78 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. use std::io::{prelude::*, stdin};
  2.  
  3. type Rule = Vec<Vec<u32>>;
  4. type Board = Vec<Vec<bool>>;
  5.  
  6. struct Nonogram {
  7.     rules_x: Rule,
  8.     rules_y: Rule,
  9.     board: Board,
  10. }
  11.  
  12. impl Nonogram {
  13.     fn new(rules_x: Rule, rules_y: Rule) -> Self {
  14.         let board = (0..rules_x.len())
  15.             .map(|_| (0..rules_y.len()).map(|_| false).collect())
  16.             .collect();
  17.         Self {
  18.             rules_x,
  19.             rules_y,
  20.             board,
  21.         }
  22.     }
  23.  
  24.     fn with_board(rules_x: Rule, rules_y: Rule, board: Board) -> Self {
  25.         let Self {
  26.             rules_x,
  27.             rules_y,
  28.             board: _,
  29.         } = Self::new(rules_x, rules_y);
  30.         Self {
  31.             rules_x,
  32.             rules_y,
  33.             board,
  34.         }
  35.     }
  36.  
  37.     #[inline]
  38.     fn get_vert(&self, ind: usize) -> impl Iterator<Item = bool> {
  39.         (0..self.rules_x.len())
  40.             .map(|n| self.board[n][ind])
  41.             .collect::<Vec<bool>>()
  42.             .into_iter()
  43.     }
  44.  
  45.     #[inline]
  46.     fn get_horiz(&self, ind: usize) -> impl Iterator<Item = bool> {
  47.         (0..self.rules_y.len())
  48.             .map(|n| self.board[ind][n])
  49.             .collect::<Vec<bool>>()
  50.             .into_iter()
  51.     }
  52.  
  53.     #[inline]
  54.     fn check(&self) -> bool {
  55.         for (vals, rule) in (0..self.rules_y.len()).map(|n| (self.get_horiz(n), &self.rules_y[n])) {
  56.             let mut check = Vec::new();
  57.             let mut last = false;
  58.             for checked in vals {
  59.                 if !checked {
  60.                     last = checked;
  61.                     continue;
  62.                 }
  63.                 if !last {
  64.                     check.push(0);
  65.                 }
  66.                 let len = check.len();
  67.                 check[len - 1] += 1;
  68.                 last = checked;
  69.             }
  70.  
  71.             if check != *rule {
  72.                 return false;
  73.             }
  74.         }
  75.         for (vals, rule) in (0..self.rules_x.len()).map(|n| (self.get_vert(n), &self.rules_x[n])) {
  76.             let mut check = Vec::new();
  77.             let mut last = false;
  78.             for checked in vals {
  79.                 if !checked {
  80.                     last = checked;
  81.                     continue;
  82.                 } else if !last {
  83.                     check.push(0);
  84.                 }
  85.                 let len = check.len();
  86.                 check[len - 1] += 1;
  87.                 last = checked;
  88.             }
  89.  
  90.             if check != *rule {
  91.                 return false;
  92.             }
  93.         }
  94.         true
  95.     }
  96.  
  97.     fn set_board(&mut self, board: Board) {
  98.         self.board = board;
  99.     }
  100. }
  101.  
  102. impl std::fmt::Display for Nonogram {
  103.     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
  104.         for row in (0..self.rules_x.len()).map(|n| self.get_horiz(n)) {
  105.             for val in row {
  106.                 write!(f, "{}", if val { "#" } else { "." });
  107.             }
  108.             writeln!(f);
  109.         }
  110.         Ok(())
  111.     }
  112. }
  113.  
  114. fn main() -> Result<(), Box<std::error::Error>> {
  115.     let mut buf = String::new();
  116.     stdin().read_line(&mut buf)?;
  117.     let x_rules: Rule = buf.trim()
  118.         .replace(" ", "")
  119.         .split(";")
  120.         .map(|s| s.split(",").map(|n| n.parse().unwrap()).collect())
  121.         .collect();
  122.     buf = String::new();
  123.     stdin().read_line(&mut buf)?;
  124.     let y_rules: Rule = buf.trim()
  125.         .replace(" ", "")
  126.         .split(";")
  127.         .map(|s| s.split(",").map(|n| n.parse().unwrap()).collect())
  128.         .collect();
  129.     let len = x_rules.len();
  130.  
  131.     let mut ngram = Nonogram::new(x_rules, y_rules);
  132.  
  133.     let mut num = 0;
  134.     while !ngram.check() {
  135.         let bools = get_bools(num, len * len);
  136.         let mut board: Board = std::iter::repeat(Vec::new()).take(len).collect();
  137.         for (i, item) in bools.into_iter().enumerate() {
  138.             board[(i / len) as usize].push(item);
  139.         }
  140.  
  141.         ngram.set_board(board);
  142.         num += 1;
  143.     }
  144.     println!("{}", ngram);
  145.     Ok(())
  146. }
  147.  
  148. #[inline]
  149. fn get_bools(num: i64, amount: usize) -> Vec<bool> {
  150.     let mut num = num;
  151.     let mut out = Vec::with_capacity(amount);
  152.     for _ in 0..amount {
  153.         out.push(num % 2 == 0);
  154.         num = num >> 1;
  155.     }
  156.     out
  157. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top