trackler 2.2.1.179 → 2.2.1.180

data/tracks/rust/exercises/binary-search/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "binary-search"
 version = "1.1.0"
-authors = ["<marco.stahl@mailbox.org>"]
 
 [dependencies]

data/tracks/rust/exercises/binary-search/example.rs

@@ -1,10 +1,9 @@
 use std::cmp::Ordering;
 
 pub fn find<C, T>(elements: C, needle: T) -> Option<usize>
-    where
-        C: AsRef<[T]>,
-        T: Ord,
-
+where
+    C: AsRef<[T]>,
+    T: Ord,
 {
     let mut base = 0usize;
     let mut slice: &[T] = elements.as_ref();

data/tracks/rust/exercises/bob/example.rs

@@ -1,9 +1,15 @@
 pub fn reply(message: &str) -> &str {
-    if is_silence(message) { "Fine. Be that way!" }
-    else if is_yelling(message) && is_question(message) { "Calm down, I know what I'm doing!" }
-    else if is_yelling(message) { "Whoa, chill out!" }
-    else if is_question(message) { "Sure." }
-    else { "Whatever." }
+    if is_silence(message) {
+        "Fine. Be that way!"
+    } else if is_yelling(message) && is_question(message) {
+        "Calm down, I know what I'm doing!"
+    } else if is_yelling(message) {
+        "Whoa, chill out!"
+    } else if is_question(message) {
+        "Sure."
+    } else {
+        "Whatever."
+    }
 }
 
 fn is_silence(message: &str) -> bool {

data/tracks/rust/exercises/book-store/Cargo-example.toml

@@ -1,6 +1,5 @@
 [package]
 name = "book_store"
 version = "1.3.0"
-authors = ["Peter Goodspeed-Niklaus <peter.r.goodspeedniklaus@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/book-store/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "book_store"
 version = "1.3.0"
-authors = ["Peter Goodspeed-Niklaus <peter.r.goodspeedniklaus@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/book-store/example.rs

@@ -1,9 +1,9 @@
+use std::cell::RefCell;
 use std::cmp::Ordering;
-use std::collections::{BTreeSet, HashSet};
 use std::collections::hash_map::DefaultHasher;
+use std::collections::{BTreeSet, HashSet};
 use std::hash::{Hash, Hasher};
 use std::mem;
-use std::cell::RefCell;
 
 type Book = usize;
 type GroupedBasket = Vec<Group>;
@@ -25,18 +25,16 @@ impl Group {
     }
 
     fn price(&self) -> Price {
-        (self.0.borrow().len() as Price) * BOOK_PRICE *
-            match self.0.borrow().len() {
-                2 => 95,
-                3 => 90,
-                4 => 80,
-                5 => 75,
-                _ => 100,
-            } / 100
+        (self.0.borrow().len() as Price) * BOOK_PRICE * match self.0.borrow().len() {
+            2 => 95,
+            3 => 90,
+            4 => 80,
+            5 => 75,
+            _ => 100,
+        } / 100
     }
 }
 
-
 impl Ord for Group {
     // we want to order groups first by qty contained DESC, then by lowest value ASC
     fn cmp(&self, other: &Group) -> Ordering {
@@ -45,14 +43,12 @@ impl Ord for Group {
                 if self.0.borrow().len() == 0 {
                     Ordering::Equal
                 } else {
-                    self.0.borrow().iter().next().unwrap().cmp(
-                        other
-                            .0
-                            .borrow()
-                            .iter()
-                            .next()
-                            .unwrap(),
-                    )
+                    self.0
+                        .borrow()
+                        .iter()
+                        .next()
+                        .unwrap()
+                        .cmp(other.0.borrow().iter().next().unwrap())
                 }
             }
             otherwise => otherwise,

data/tracks/rust/exercises/bowling/example.rs

@@ -98,7 +98,9 @@ impl Frame {
 
 impl BowlingGame {
     pub fn new() -> Self {
-        BowlingGame { frames: vec![Frame::new()] }
+        BowlingGame {
+            frames: vec![Frame::new()],
+        }
     }
 
     pub fn roll(&mut self, pins: u16) -> Result<(), Error> {

data/tracks/rust/exercises/bracket-push/example.rs

@@ -45,13 +45,18 @@ pub struct MatchingBrackets {
 
 impl From<Vec<(char, char)>> for MatchingBrackets {
     fn from(v: Vec<(char, char)>) -> Self {
-        MatchingBrackets { collection: v.into_iter().collect::<HashMap<char, char>>() }
+        MatchingBrackets {
+            collection: v.into_iter().collect::<HashMap<char, char>>(),
+        }
     }
 }
 
 impl MatchingBrackets {
     fn contains(&self, other: &char) -> bool {
-        let known = self.collection.keys().chain(self.collection.values()).collect::<Vec<_>>();
+        let known = self.collection
+            .keys()
+            .chain(self.collection.values())
+            .collect::<Vec<_>>();
         known.contains(&other)
     }
 

data/tracks/rust/exercises/circular-buffer/example.rs

@@ -19,7 +19,7 @@ impl<T: Default + Clone> CircularBuffer<T> {
             buffer: vec![T::default(); size + 1],
             size: size + 1,
             start: 0,
-            end: 0
+            end: 0,
         }
     }
 

data/tracks/rust/exercises/clock/.meta/ALLOWED_TO_NOT_COMPILE

@@ -0,0 +1,3 @@
+ Stub doesn't compile because there is no to_string() implementation.
+ This exercise is an introduction to derived and self-implemented traits,
+ therefore adding template for a trait would reduce student learning.

data/tracks/rust/exercises/clock/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "clock"
 version = "1.0.0"
-authors = ["sacherjj <sacherjj@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/clock/example.rs

@@ -1,8 +1,8 @@
 use std::fmt;
 
-#[derive(Eq,PartialEq,Debug)]
+#[derive(Eq, PartialEq, Debug)]
 pub struct Clock {
-    minutes: i32
+    minutes: i32,
 }
 
 impl fmt::Display for Clock {
@@ -23,7 +23,9 @@ impl Clock {
         while mins < 0 {
             mins += 1440;
         }
-        Clock { minutes: mins % 1440 }
+        Clock {
+            minutes: mins % 1440,
+        }
     }
 
     pub fn add_minutes(&mut self, minutes: i32) -> Self {

data/tracks/rust/exercises/clock/src/lib.rs

@@ -1 +1,15 @@
+pub struct Clock;
 
+impl Clock {
+    pub fn new(hours: i32, minutes: i32) -> Self {
+        unimplemented!(
+            "Construct a new Clock from {} hours and {} minutes",
+            hours,
+            minutes
+        );
+    }
+
+    pub fn add_minutes(self, minutes: i32) -> Self {
+        unimplemented!("Add {} minutes to existing Clock time", minutes);
+    }
+}

data/tracks/rust/exercises/collatz-conjecture/example.rs

@@ -1,10 +1,10 @@
 pub fn collatz_positive(n: u64) -> u64 {
     if n == 1 {
         0
-    } else  {
+    } else {
         1 + match n % 2 {
             0 => collatz_positive(n / 2),
-            _ => collatz_positive(n * 3 + 1)
+            _ => collatz_positive(n * 3 + 1),
         }
     }
 }

data/tracks/rust/exercises/crypto-square/Cargo-example.toml

@@ -1,7 +1,6 @@
 [package]
 name = "crypto-square"
 version = "0.1.0"
-authors = ["Peter Goodspeed-Niklaus <peter.r.goodspeedniklaus@gmail.com>"]
 
 [dependencies]
 itertools = "0.6.1"

data/tracks/rust/exercises/crypto-square/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "crypto-square"
 version = "0.1.0"
-authors = ["Peter Goodspeed-Niklaus <peter.r.goodspeedniklaus@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/custom-set/example.rs

@@ -5,14 +5,16 @@ pub struct CustomSet<T> {
 
 impl<T: Ord + Clone> PartialEq for CustomSet<T> {
     fn eq(&self, other: &Self) -> bool {
-        self.collection.iter().all(|x| other.contains(&x)) &&
-        other.collection.iter().all(|x| self.contains(&x))
+        self.collection.iter().all(|x| other.contains(&x))
+            && other.collection.iter().all(|x| self.contains(&x))
     }
 }
 
 impl<T: Ord + Clone> CustomSet<T> {
     pub fn new(inputs: &[T]) -> CustomSet<T> {
-        let mut s = CustomSet { collection: Vec::new() };
+        let mut s = CustomSet {
+            collection: Vec::new(),
+        };
         for input in inputs {
             s.add(input.clone());
         }
@@ -43,25 +45,25 @@ impl<T: Ord + Clone> CustomSet<T> {
 
     pub fn intersection(&self, other: &Self) -> CustomSet<T> {
         CustomSet::new(&self.collection
-                            .iter()
-                            .cloned()
-                            .filter(|c| other.contains(c))
-                            .collect::<Vec<_>>())
+            .iter()
+            .cloned()
+            .filter(|c| other.contains(c))
+            .collect::<Vec<_>>())
     }
 
     pub fn union(&self, other: &Self) -> CustomSet<T> {
         CustomSet::new(&self.collection
-                            .iter()
-                            .cloned()
-                            .chain(other.collection.iter().cloned())
-                            .collect::<Vec<_>>())
+            .iter()
+            .cloned()
+            .chain(other.collection.iter().cloned())
+            .collect::<Vec<_>>())
     }
 
     pub fn difference(&self, other: &Self) -> CustomSet<T> {
         CustomSet::new(&self.collection
-                            .iter()
-                            .cloned()
-                            .filter(|c| !other.contains(c))
-                            .collect::<Vec<_>>())
+            .iter()
+            .cloned()
+            .filter(|c| !other.contains(c))
+            .collect::<Vec<_>>())
     }
 }

data/tracks/rust/exercises/decimal/Cargo-example.toml

@@ -1,7 +1,6 @@
 [package]
 name = "decimal"
 version = "0.1.0"
-authors = ["Peter Goodspeed-Niklaus <peter.r.goodspeedniklaus@gmail.com>"]
 
 [dependencies]
 try_opt = "0.1.1"

data/tracks/rust/exercises/decimal/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "decimal"
 version = "0.1.0"
-authors = ["Peter Goodspeed-Niklaus <peter.r.goodspeedniklaus@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/decimal/example.rs

@@ -1,6 +1,6 @@
 use std::cmp::Ordering;
 use std::fmt;
-use std::ops::{Add, Sub, Mul};
+use std::ops::{Add, Mul, Sub};
 
 #[macro_use]
 extern crate try_opt;
@@ -71,8 +71,8 @@ impl Decimal {
             let precision_difference =
                 (higher_precision.decimal_index - lower_precision.decimal_index) as usize;
 
-            lower_precision.digits = &lower_precision.digits *
-                pow(BigInt::from(10_usize), precision_difference);
+            lower_precision.digits =
+                &lower_precision.digits * pow(BigInt::from(10_usize), precision_difference);
             lower_precision.decimal_index += precision_difference;
         }
         if one.decimal_index < two.decimal_index {
@@ -111,7 +111,7 @@ macro_rules! auto_impl_decimal_ops {
                 )
             }
         }
-    }
+    };
 }
 
 auto_impl_decimal_ops!(Add, add, |s, o| s + o, |s, _| s);
@@ -136,7 +136,7 @@ macro_rules! auto_impl_decimal_cow {
                 }
             }
         }
-    }
+    };
 }
 
 auto_impl_decimal_cow!(PartialEq, eq, |a, b| a == b, bool);

data/tracks/rust/exercises/diamond/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "diamond"
 version = "1.1.0"
-authors = ["Kirill Meng <kimeng@htwg-konstanz.de>"]
 
 [dependencies]

data/tracks/rust/exercises/difference-of-squares/example.rs

@@ -4,7 +4,7 @@ pub fn square_of_sum(n: usize) -> usize {
 }
 
 pub fn sum_of_squares(n: usize) -> usize {
-    (0..n+1).map(|x| x*x).fold(0, |accum, x| accum + x)
+    (0..n + 1).map(|x| x * x).fold(0, |accum, x| accum + x)
 }
 
 pub fn difference(n: usize) -> usize {

data/tracks/rust/exercises/dominoes/example.rs

@@ -8,29 +8,30 @@ pub type Domino = (usize, usize);
 /// dots and row dots. Positions are mirrored ((3,4) == (4,3)), except for positions with equal row
 /// and column numbers.
 struct AvailabilityTable {
-    m: Vec<usize>
+    m: Vec<usize>,
 }
 
 impl AvailabilityTable {
     fn new() -> AvailabilityTable {
-        AvailabilityTable { m: iter::repeat(0).take(6 * 6).collect() }
+        AvailabilityTable {
+            m: iter::repeat(0).take(6 * 6).collect(),
+        }
     }
 
     fn get(&self, x: usize, y: usize) -> usize {
-        self.m[(x-1) * 6 + (y-1)]
+        self.m[(x - 1) * 6 + (y - 1)]
     }
 
     fn set(&mut self, x: usize, y: usize, v: usize) {
         let m = &mut self.m[..];
-        m[(x-1) * 6 + (y-1)] = v;
+        m[(x - 1) * 6 + (y - 1)] = v;
     }
 
     fn add(&mut self, x: usize, y: usize) {
         if x == y {
             let n = self.get(x, y);
             self.set(x, y, n + 1) // Along the diagonal
-        }
-        else {
+        } else {
             let m = self.get(x, y);
             self.set(x, y, m + 1);
             let n = self.get(y, x);
@@ -43,25 +44,23 @@ impl AvailabilityTable {
             if x == y {
                 let n = self.get(x, y);
                 self.set(x, y, n - 1) // Along the diagonal
-            }
-            else {
+            } else {
                 let m = self.get(x, y);
                 self.set(x, y, m - 1);
                 let n = self.get(y, x);
                 self.set(y, x, n - 1);
             }
-        }
-        else {
+        } else {
             // For this toy code hard explicit fail is best
             panic!("remove for 0 stones: ({:?}, {:?})", x, y)
         }
     }
 
     fn pop_first(&mut self, x: usize) -> Option<usize> {
-        for y in 1 .. 7 {
+        for y in 1..7 {
             if self.get(x, y) > 0 {
                 self.remove(x, y);
-                return Some(y)
+                return Some(y);
             }
         }
         None
@@ -70,12 +69,16 @@ impl AvailabilityTable {
 
 pub fn chain(dominoes: &[Domino]) -> Option<Vec<Domino>> {
     match dominoes.len() {
-        0 => Some(vec!()),
-        1 => if dominoes[0].0 == dominoes[0].1 { Some(vec![dominoes[0]]) } else { None },
+        0 => Some(vec![]),
+        1 => if dominoes[0].0 == dominoes[0].1 {
+            Some(vec![dominoes[0]])
+        } else {
+            None
+        },
         _ => {
             // First check if the total number of each amount of dots is even, if not it's not
             // possible to complete a cycle. This follows from that it's an Eulerian path.
-            let mut v: Vec<usize> = vec!(0, 0, 0, 0, 0, 0);
+            let mut v: Vec<usize> = vec![0, 0, 0, 0, 0, 0];
             // Keep the mutable borrow in a small scope here to allow v.iter().
             {
                 let vs = &mut v[..];
@@ -86,14 +89,13 @@ pub fn chain(dominoes: &[Domino]) -> Option<Vec<Domino>> {
             }
             for n in v.iter() {
                 if n % 2 != 0 {
-                    return None
+                    return None;
                 }
             }
             let chain = chain_worker(dominoes);
             if chain.len() == dominoes.len() {
                 Some(chain)
-            }
-            else {
+            } else {
                 None
             }
         }
@@ -106,7 +108,6 @@ fn chain_worker(dominoes: &[Domino]) -> Vec<Domino> {
     let mut t = AvailabilityTable::new();
     for dom in doms.iter() {
         t.add(dom.0, dom.1)
-
     }
     let mut v: Vec<Domino> = Vec::new();
     v.push(first);