• API
• FAQ
• Tools
• Archive
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();
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();
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.

Top