From 9dbc4eb4c9e7ad8b737eb02702023669ecc812bf Mon Sep 17 00:00:00 2001
From: Dennis Kobert <dennis@kobert.dev>
Date: Fri, 17 Jan 2020 12:28:59 +0100
Subject: Some minor fixas and code formatting

---
 src/solvers/bwinf.rs | 58 ++++++++++++++++++++++++++++++----------------------
 1 file changed, 33 insertions(+), 25 deletions(-)

diff --git a/src/solvers/bwinf.rs b/src/solvers/bwinf.rs
index fcf6876..2049acc 100644
--- a/src/solvers/bwinf.rs
+++ b/src/solvers/bwinf.rs
@@ -1,22 +1,24 @@
 #[derive(Clone, Debug)]
 struct Row {
-    n: u32, b: u32,
+    n: u32,
+    b: u32,
     palette: Vec<bool>,
     max_stone: u32,
     width: u32,
     stones: Vec<u32>,
-    max_reachable: u32
+    max_reachable: u32,
 }
 
 impl Row {
     fn new(n: u32, b: u32) -> Row {
         Self {
-            n, b,
+            n,
+            b,
             palette: vec![true; n as usize],
             max_stone: n,
             width: 0,
             stones: Vec::with_capacity(n as usize),
-            max_reachable: n
+            max_reachable: n,
         }
     }
 
@@ -25,9 +27,10 @@ impl Row {
         stones.push(s);
         let max_stone = n - if s == n { 1 } else { 0 };
         Self {
-            n, b,
+            n,
+            b,
             palette: (1..=n).map(|i| i != s).collect(),
-            max_stone: max_stone,
+            max_stone,
             width: s,
             stones,
             max_reachable: s + max_stone,
@@ -75,51 +78,57 @@ impl Row {
                 print!("{}", ['-', '*'][i & 1]);
             }
         }
-        println!("");
+        println!();
     }
 
     fn output_numbers(&self) {
         for stone in self.stones.iter() {
             print!("{:2} ", stone);
         }
-        println!("");
+        println!();
     }
 }
 
 #[derive(Clone, Debug)]
 pub struct Wall {
-    n: u32, h: u32, b: u32,
+    n: u32,
+    h: u32,
+    b: u32,
     rows: Vec<Row>,
     x: u32,
     min_max_reachable: u32,
     max_reached: u32,
-    steps: u32
+    steps: u32,
 }
 
 impl Wall {
     pub fn new(n: u32) -> Self {
-        let (h, b) = ((n >> 1) + 1, (n * n + n ) >> 1);
+        let (h, b) = ((n >> 1) + 1, (n * n + n) >> 1);
         Self {
-            n, h, b,
+            n,
+            h,
+            b,
             rows: vec![Row::new(n, b); h as usize],
             x: 1,
             min_max_reachable: n,
             max_reached: 0,
-            steps: 0
+            steps: 0,
         }
     }
 
     fn new_linear(n: u32) -> Self {
-        let (h, b) = ((n >> 1) + 1, (n * n + n ) >> 1);
+        let (h, b) = ((n >> 1) + 1, (n * n + n) >> 1);
         let rows = (1..=h).map(|i| Row::with_stone(n, b, i)).collect();
         let x = h + 1;
         Self {
-            n, h, b,
+            n,
+            h,
+            b,
             rows,
             x,
             min_max_reachable: 1 + n,
             max_reached: n,
-            steps: 0
+            steps: 0,
         }
     }
 
@@ -131,8 +140,8 @@ impl Wall {
 
     fn order_key(&self, index: u32) -> (i32, i32) {
         let row = self.rows.get(index as usize).unwrap();
-        let stones = row.stones.len() as i32;
-        let width = row.width as i32;
+        let _stones = row.stones.len() as i32;
+        let _width = row.width as i32;
         let max_stone = row.max_stone as i32;
         let index = index as i32;
         //(-max_stone, index)
@@ -142,11 +151,11 @@ impl Wall {
     }
 
     fn order(&self) -> Vec<u32> {
-        //(0..self.h).collect()
-        let mut v: Vec<u32> = (0..self.h).collect();
+        (0..self.h).collect()
+        /*let mut v: Vec<u32> = (0..self.h).collect();
         let b = self.b;
         v.sort_unstable_by_key(|&row| self.order_key(row));
-        v
+        v*/
     }
 
     pub fn solve(&mut self) -> bool {
@@ -161,16 +170,15 @@ impl Wall {
         for row_index in self.order() {
             if self.rows[row_index as usize].stones.is_empty() {
                 if row_empty {
-                    break
+                    break;
                 }
                 row_empty = true;
             }
             let max_reachable = self.rows[row_index as usize].max_reachable;
             if self.rows[row_index as usize].update(self.x) {
                 if max_reachable == self.min_max_reachable {
-                    self.min_max_reachable = self.rows.iter()
-                        .map(|v| v.max_reachable).min()
-                        .unwrap();
+                    self.min_max_reachable =
+                        self.rows.iter().map(|v| v.max_reachable).min().unwrap();
                 }
                 if self.min_max_reachable > self.x {
                     self.x += 1;
-- 
cgit v1.2.3-54-g00ecf