trackler 2.2.1.179 → 2.2.1.180

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

@@ -1,7 +1,8 @@
 use std::collections::BTreeMap;
 
 pub fn transform(input: &BTreeMap<i32, Vec<char>>) -> BTreeMap<char, i32> {
-    input.iter().flat_map(|(&n, vec)| {
-        vec.iter().map(move |c| (c.to_ascii_lowercase(), n))
-    }).collect()
+    input
+        .iter()
+        .flat_map(|(&n, vec)| vec.iter().map(move |c| (c.to_ascii_lowercase(), n)))
+        .collect()
 }

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

@@ -41,10 +41,9 @@ impl FromStr for Term {
         match s {
             ":" => Ok(StartDefinition),
             ";" => Ok(EndDefinition),
-            _   => Err(())
-        }
-        .or_else(|_| Value::from_str(s).map(Number))
-        .or_else(|_| Ok(Word(s.to_ascii_lowercase())))
+            _ => Err(()),
+        }.or_else(|_| Value::from_str(s).map(Number))
+            .or_else(|_| Ok(Word(s.to_ascii_lowercase())))
     }
 }
 
@@ -77,15 +76,16 @@ impl Forth {
 
     fn step_term(&mut self, term: Term) -> ForthResult {
         match term {
-            Number(value)   => self.push(value),
-            Word(word)      => self.step_word(word),
+            Number(value) => self.push(value),
+            Word(word) => self.step_word(word),
             StartDefinition => self.store_definition(),
-            EndDefinition   => Err(Error::InvalidWord),
+            EndDefinition => Err(Error::InvalidWord),
         }
     }
 
     fn step_word(&mut self, word: String) -> ForthResult {
-        self.defs.get(&word)
+        self.defs
+            .get(&word)
             .ok_or(Error::UnknownWord)
             .map(Clone::clone)
             .map(|mut code| self.code.append(&mut code))
@@ -94,32 +94,17 @@ impl Forth {
 
     fn step_built_in(&mut self, word: &String) -> ForthResult {
         match word.as_ref() {
-            "+" =>
-                self.bin_op(|(a, b)| Ok(a + b)),
-            "-" =>
-                self.bin_op(|(a, b)| Ok(a - b)),
-            "*" =>
-                self.bin_op(|(a, b)| Ok(a * b)),
-            "/" =>
-                self.bin_op(|(a, b)| {
-                    a.checked_div(b).ok_or(Error::DivisionByZero)
-                }),
-            "dup" =>
-                self.pop().and_then(|a| {
-                    self.push(a).and(self.push(a))
-                }),
-            "drop" =>
-                self.pop().and(Forth::ok()),
-            "swap" =>
-                self.pop_two().and_then(|(a, b)| {
-                    self.push(b).and(self.push(a))
-                }),
-            "over" =>
-                self.pop_two().and_then(|(a, b)| {
-                    self.push(a).and(self.push(b)).and(self.push(a))
-                }),
-            _ =>
-                Err(Error::UnknownWord)
+            "+" => self.bin_op(|(a, b)| Ok(a + b)),
+            "-" => self.bin_op(|(a, b)| Ok(a - b)),
+            "*" => self.bin_op(|(a, b)| Ok(a * b)),
+            "/" => self.bin_op(|(a, b)| a.checked_div(b).ok_or(Error::DivisionByZero)),
+            "dup" => self.pop().and_then(|a| self.push(a).and(self.push(a))),
+            "drop" => self.pop().and(Forth::ok()),
+            "swap" => self.pop_two()
+                .and_then(|(a, b)| self.push(b).and(self.push(a))),
+            "over" => self.pop_two()
+                .and_then(|(a, b)| self.push(a).and(self.push(b)).and(self.push(a))),
+            _ => Err(Error::UnknownWord),
         }
     }
 
@@ -129,8 +114,8 @@ impl Forth {
         loop {
             match self.code.pop_front() {
                 Some(EndDefinition) => break,
-                Some(term)          => def.push_back(term),
-                None                => return Err(Error::InvalidWord),
+                Some(term) => def.push_back(term),
+                None => return Err(Error::InvalidWord),
             }
         }
 
@@ -147,20 +132,17 @@ impl Forth {
     }
 
     fn pop(&mut self) -> StackResult<Value> {
-        self.stack.pop_back()
-            .ok_or(Error::StackUnderflow)
+        self.stack.pop_back().ok_or(Error::StackUnderflow)
     }
 
     fn pop_two(&mut self) -> StackResult<(Value, Value)> {
-        self.pop()
-            .and_then(|b| {
-                self.pop()
-                    .and_then(|a| Ok((a, b)))
-            })
+        self.pop().and_then(|b| self.pop().and_then(|a| Ok((a, b))))
     }
 
     fn bin_op<F>(&mut self, op: F) -> ForthResult
-        where F: FnOnce((Value, Value)) -> StackResult<Value> {
+    where
+        F: FnOnce((Value, Value)) -> StackResult<Value>,
+    {
         self.pop_two()
             .and_then(op)
             .and_then(|value| self.push(value))
@@ -180,5 +162,7 @@ impl Forth {
             .collect()
     }
 
-    fn ok() -> ForthResult { Ok(()) }
+    fn ok() -> ForthResult {
+        Ok(())
+    }
 }

data/tracks/rust/exercises/grade-school/example.rs

@@ -1,12 +1,14 @@
 use std::collections::HashMap;
 
 pub struct School {
-    grades: HashMap<u32, Vec<String>>
+    grades: HashMap<u32, Vec<String>>,
 }
 
 impl School {
     pub fn new() -> School {
-        School { grades: HashMap::new() }
+        School {
+            grades: HashMap::new(),
+        }
     }
 
     pub fn add(&mut self, grade: u32, student: &str) {

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

@@ -16,7 +16,7 @@ fn parse_hex_digit(c: char) -> Option<i64> {
         'd' => Some(13),
         'e' => Some(14),
         'f' => Some(15),
-        _   => None,
+        _ => None,
     }
 }
 
@@ -28,8 +28,6 @@ pub fn hex_to_int(string: &str) -> Option<i64> {
         .rev()
         .enumerate()
         .fold(Some(0), |acc, (pos, c)| {
-            parse_hex_digit(c).and_then(|n| {
-                acc.map(|acc| acc + n * base.pow(pos as u32))
-            })
+            parse_hex_digit(c).and_then(|n| acc.map(|acc| acc + n * base.pow(pos as u32)))
         })
 }

data/tracks/rust/exercises/isbn-verifier/example.rs

@@ -8,14 +8,13 @@ enum IsbnType {
 /// Checks if an 'X' is valid at the given position for the given ISBN type
 #[allow(non_snake_case)]
 fn is_X_valid(position: &usize, isbn_type: &IsbnType) -> bool {
-    (isbn_type == &IsbnType::Isbn10 && position == &9 ) ||
-    (isbn_type == &IsbnType::Isbn13 && position == &12)
+    (isbn_type == &IsbnType::Isbn10 && position == &9)
+        || (isbn_type == &IsbnType::Isbn13 && position == &12)
 }
 
 /// Checks if a '-' is valid at the given position for the given ISBN type
 fn is_dash_valid(position: &usize, isbn_type: &IsbnType) -> bool {
-    isbn_type == &IsbnType::Isbn13 &&
-    (position == &1 || position == &5 || position == &11)
+    isbn_type == &IsbnType::Isbn13 && (position == &1 || position == &5 || position == &11)
 }
 
 /// Determines whether the supplied string is a valid ISBN number
@@ -30,10 +29,10 @@ pub fn is_valid_isbn(isbn: &str) -> bool {
     let mut coefficient = 10;
     for (position, c) in isbn.char_indices() {
         let digit_value = match c {
-            '0' ... '9' => c.to_digit(10).unwrap(),
+            '0'...'9' => c.to_digit(10).unwrap(),
             'X' if is_X_valid(&position, &isbn_type) => 10,
             '-' if is_dash_valid(&position, &isbn_type) => continue,
-            _   => return false,
+            _ => return false,
         };
 
         checksum += coefficient * digit_value;

data/tracks/rust/exercises/isbn-verifier/tests/isbn-verifier.rs

@@ -75,6 +75,18 @@ fn test_invalid_isbn_too_long() {
     assert!(!is_valid_isbn("3-598-21507-XX"));
 }
 
+#[test]
+#[ignore]
+fn test_valid_digits_invalid_length() {
+    assert!(!is_valid_isbn("35982150881"));
+}
+
+#[test]
+#[ignore]
+fn test_special_characters() {
+    assert!(!is_valid_isbn("!@#%!@"));
+}
+
 #[test]
 #[ignore]
 #[allow(non_snake_case)]

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

@@ -1,12 +1,18 @@
 pub fn check(word: &str) -> bool {
-
     // Filter all non-Alphabetic character out and collect them in a new String
-    let normalized_string: String = word.to_lowercase().chars().filter(|c| c.is_alphabetic()).collect();
+    let normalized_string: String = word.to_lowercase()
+        .chars()
+        .filter(|c| c.is_alphabetic())
+        .collect();
 
     /* Find the char element from back and front and compare the index.
        If it is the same unique char the index will be the same.*/
     let is_unique = |x: char, word: &str| word.find(x).unwrap() == word.rfind(x).unwrap();
 
     // Length should be the same if it is a isogram
-    normalized_string.len() == normalized_string.chars().filter(|&x| is_unique(x, normalized_string.as_str())).count()
+    normalized_string.len()
+        == normalized_string
+            .chars()
+            .filter(|&x| is_unique(x, normalized_string.as_str()))
+            .count()
 }

data/tracks/rust/exercises/largest-series-product/example.rs

@@ -13,7 +13,8 @@ pub fn lsp(string_digits: &str, span: usize) -> Result<u64, Error> {
         return Err(Error::InvalidDigit(invalid));
     }
 
-    let products: Vec<u64> = string_digits.chars()
+    let products: Vec<u64> = string_digits
+        .chars()
         .map(|c| c.to_digit(10).unwrap() as u64)
         .collect::<Vec<u64>>()
         .windows(span)

data/tracks/rust/exercises/luhn-from/example.rs

@@ -21,7 +21,9 @@ impl Luhn {
 
 impl From<String> for Luhn {
     fn from(s: String) -> Self {
-        Luhn { digits: s.chars().collect() }
+        Luhn {
+            digits: s.chars().collect(),
+        }
     }
 }
 

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

@@ -1,10 +1,12 @@
 pub fn is_valid(candidate: &str) -> bool {
-    if candidate.chars().filter(|c| c.is_digit(10)).take(2).count() <= 1 ||
-       candidate.chars().any(|c| !c.is_digit(10) && c != ' ') {
+    if candidate.chars().filter(|c| c.is_digit(10)).take(2).count() <= 1
+        || candidate.chars().any(|c| !c.is_digit(10) && c != ' ')
+    {
         return false;
     }
 
-    candidate.chars()
+    candidate
+        .chars()
         .filter_map(|c| c.to_digit(10))
         .rev()
         .enumerate()

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

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

data/tracks/rust/exercises/nth-prime/Cargo.toml

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

data/tracks/rust/exercises/nth-prime/example.rs

@@ -1,12 +1,12 @@
 fn is_prime(n: u32) -> bool {
     let mut i: u32 = 3;
     while (i * i) < (n + 1) {
-      if n % i == 0 {
-         return false;
-      }
-      i += 1;
-   }
-   return true;
+        if n % i == 0 {
+            return false;
+        }
+        i += 1;
+    }
+    return true;
 }
 
 pub fn nth(n: u32) -> Option<u32> {

data/tracks/rust/exercises/nucleotide-codons/Cargo.toml

@@ -1,4 +1,3 @@
 [package]
 name = "nucleotide_codons"
 version = "0.1.0"
-authors = ["Peter Minten <peter@pminten.nl>"]

data/tracks/rust/exercises/nucleotide-codons/example.rs

@@ -1,36 +1,42 @@
 use std::collections::HashMap;
 
 pub struct CodonInfo<'a> {
-    actual_codons: HashMap<&'a str, &'a str>
+    actual_codons: HashMap<&'a str, &'a str>,
 }
 
 pub fn parse<'a>(pairs: Vec<(&'a str, &'a str)>) -> CodonInfo<'a> {
-    CodonInfo{
-        actual_codons: pairs.into_iter().collect()
+    CodonInfo {
+        actual_codons: pairs.into_iter().collect(),
     }
 }
 
 impl<'a> CodonInfo<'a> {
     pub fn name_for(&self, codon: &str) -> Result<&'a str, &'static str> {
         if codon.len() != 3 {
-            return Err("invalid length")
+            return Err("invalid length");
         }
 
         let mut valid = true;
-        let lookup: String = codon.chars().map(|l| {
-            // Get an example of a "letter" represented by the possibly encoded letter.
-            // Since every codon represented by the compressed notation has to be of
-            // the desired amino acid just picking one at random will do.
-            match l {
-                'A' | 'W' | 'M' | 'R' | 'D' | 'H' | 'V' | 'N' => 'A',
-                'C' | 'S' | 'Y' | 'B' => 'C',
-                'G' | 'K' => 'G',
-                'T' => 'T',
-                _ => { valid = false; ' ' }
-            }
-        }).collect();
+        let lookup: String = codon
+            .chars()
+            .map(|l| {
+                // Get an example of a "letter" represented by the possibly encoded letter.
+                // Since every codon represented by the compressed notation has to be of
+                // the desired amino acid just picking one at random will do.
+                match l {
+                    'A' | 'W' | 'M' | 'R' | 'D' | 'H' | 'V' | 'N' => 'A',
+                    'C' | 'S' | 'Y' | 'B' => 'C',
+                    'G' | 'K' => 'G',
+                    'T' => 'T',
+                    _ => {
+                        valid = false;
+                        ' '
+                    }
+                }
+            })
+            .collect();
         if !valid {
-            return Err("invalid char")
+            return Err("invalid char");
         }
 
         // If the input table is correct (which it is) every valid codon is in it

data/tracks/rust/exercises/nucleotide-count/example.rs

@@ -2,13 +2,23 @@ use std::collections::HashMap;
 
 static VALID_NUCLEOTIDES: &'static str = "ACGT";
 
-pub fn count(nucleotide: char, input: &str) -> Result<usize, char> {
-    let valid = |x: char| { VALID_NUCLEOTIDES.contains(x) };
-    if valid(nucleotide) && input.chars().all(valid) {
-        Ok(input.chars().filter(|&c| c == nucleotide).count())
+fn valid(c: char) -> Result<char, char> {
+    if VALID_NUCLEOTIDES.contains(c) {
+        Ok(c)
     } else {
-        Err(nucleotide)
+        Err(c)
+    }
+}
+
+pub fn count(nucleotide: char, input: &str) -> Result<usize, char> {
+    valid(nucleotide)?;
+    let mut count = 0;
+    for c in input.chars() {
+        if valid(c)? == nucleotide {
+            count += 1;
+        }
     }
+    Ok(count)
 }
 
 pub fn nucleotide_counts(input: &str) -> Result<HashMap<char, usize>, char> {

data/tracks/rust/exercises/nucleotide-count/src/lib.rs

@@ -1 +1,16 @@
+use std::collections::HashMap;
 
+pub fn count(nucleotide: char, dna: &str) -> Result<usize, char> {
+    unimplemented!(
+        "How much of nucleotide type '{}' is contained inside DNA string '{}'?",
+        nucleotide,
+        dna
+    );
+}
+
+pub fn nucleotide_counts(dna: &str) -> Result<HashMap<char, usize>, char> {
+    unimplemented!(
+        "How much of every nucleotide type is contained inside DNA string '{}'?",
+        dna
+    );
+}

data/tracks/rust/exercises/nucleotide-count/tests/nucleotide-count.rs

@@ -29,13 +29,13 @@ fn test_count_empty() {
 #[test]
 #[ignore]
 fn count_invalid_nucleotide() {
-    assert!(dna::count('X', "A").is_err());
+    assert_eq!(dna::count('X', "A"), Err('X'));
 }
 
 #[test]
 #[ignore]
 fn count_invalid_dna() {
-    assert!(dna::count('A', "AX").is_err());
+    assert_eq!(dna::count('A', "AX"), Err('X'));
 }
 
 #[test]
@@ -81,5 +81,5 @@ fn test_nucleotide_count_counts_all() {
 #[test]
 #[ignore]
 fn counts_invalid_nucleotide_results_in_err() {
-    assert!(dna::nucleotide_counts("GGXXX").is_err());
+    assert_eq!(dna::nucleotide_counts("GGXXX"), Err('X'));
 }