trackler 2.2.1.179 → 2.2.1.180

data/tracks/rust/exercises/reverse-string/Cargo.toml

@@ -1,7 +1,6 @@
 [package]
 name = "reverse_string"
 version = "1.0.0"
-authors = ["Peter Goodspeed-Niklaus <peter.r.goodspeedniklaus@gmail.com>"]
 
 [features]
 grapheme = []

data/tracks/rust/exercises/rna-transcription/example.rs

@@ -1,5 +1,3 @@
-
-
 /// The possible nucleotides in DNA and RNA
 #[derive(Debug, Eq, PartialEq, Clone, Copy)]
 pub enum Nucleotide {
@@ -7,7 +5,7 @@ pub enum Nucleotide {
     Cytosine,
     Guanine,
     Thymine,
-    Uracil
+    Uracil,
 }
 
 impl Nucleotide {
@@ -19,7 +17,9 @@ impl Nucleotide {
             'G' => Nucleotide::Guanine,
             'T' => Nucleotide::Thymine,
             'U' => Nucleotide::Uracil,
-            _ => { return None; }
+            _ => {
+                return None;
+            }
         })
     }
 }
@@ -38,8 +38,12 @@ impl DNA {
         let mut out = Vec::new();
         for (idx, ch) in input.chars().enumerate() {
             match Nucleotide::from_char(ch) {
-                Some(Nucleotide::Uracil) | None => { return Err(idx); },
-                Some(n) => { out.push(n);  },
+                Some(Nucleotide::Uracil) | None => {
+                    return Err(idx);
+                }
+                Some(n) => {
+                    out.push(n);
+                }
             }
         }
         Ok(DNA(out))
@@ -52,7 +56,7 @@ impl DNA {
                 Nucleotide::Cytosine => Nucleotide::Guanine,
                 Nucleotide::Guanine => Nucleotide::Cytosine,
                 Nucleotide::Thymine => Nucleotide::Adenine,
-                Nucleotide::Uracil => unreachable!()
+                Nucleotide::Uracil => unreachable!(),
             }
         }
         RNA(self.0)
@@ -70,8 +74,12 @@ impl RNA {
         let mut out = Vec::new();
         for (idx, ch) in input.chars().enumerate() {
             match Nucleotide::from_char(ch) {
-                Some(Nucleotide::Thymine) | None => { return Err(idx); },
-                Some(n) => { out.push(n);  },
+                Some(Nucleotide::Thymine) | None => {
+                    return Err(idx);
+                }
+                Some(n) => {
+                    out.push(n);
+                }
             }
         }
         Ok(RNA(out))

data/tracks/rust/exercises/robot-name/example.rs

@@ -2,7 +2,7 @@ extern crate rand;
 use rand::{thread_rng, Rng};
 
 pub struct Robot {
-    name: String
+    name: String,
 }
 
 fn generate_name() -> String {
@@ -20,7 +20,9 @@ fn generate_name() -> String {
 
 impl Robot {
     pub fn new() -> Robot {
-        Robot { name: generate_name() }
+        Robot {
+            name: generate_name(),
+        }
     }
 
     pub fn name<'a>(&'a self) -> &'a str {
@@ -30,5 +32,4 @@ impl Robot {
     pub fn reset_name(&mut self) {
         self.name = generate_name();
     }
-
 }

data/tracks/rust/exercises/robot-simulator/example.rs

@@ -78,8 +78,11 @@ impl Robot {
     }
 
     pub fn instructions(&self, instructions: &str) -> Self {
-        instructions.chars().fold(self.clone(),
-                                  |robot, instruction| robot.execute(instruction))
+        instructions
+            .chars()
+            .fold(self.clone(), |robot, instruction| {
+                robot.execute(instruction)
+            })
     }
 
     pub fn position(&self) -> (i32, i32) {

data/tracks/rust/exercises/roman-numerals/example.rs

@@ -1,18 +1,20 @@
 use std::fmt;
 
-static ROMAN_MAP: [(usize, &'static str); 13] = [(1, "I"),
-                                                 (4, "IV"),
-                                                 (5, "V"),
-                                                 (9, "IX"),
-                                                 (10, "X"),
-                                                 (40, "XL"),
-                                                 (50, "L"),
-                                                 (90, "XC"),
-                                                 (100, "C"),
-                                                 (400, "CD"),
-                                                 (500, "D"),
-                                                 (900, "CM"),
-                                                 (1000, "M")];
+static ROMAN_MAP: [(usize, &'static str); 13] = [
+    (1, "I"),
+    (4, "IV"),
+    (5, "V"),
+    (9, "IX"),
+    (10, "X"),
+    (40, "XL"),
+    (50, "L"),
+    (90, "XC"),
+    (100, "C"),
+    (400, "CD"),
+    (500, "D"),
+    (900, "CM"),
+    (1000, "M"),
+];
 
 pub struct Roman {
     num: usize,
@@ -38,7 +40,6 @@ impl fmt::Display for Roman {
     }
 }
 
-
 impl Roman {
     fn new(num: usize) -> Roman {
         Roman { num: num }

data/tracks/rust/exercises/rotational-cipher/Cargo.toml

@@ -1,4 +1,3 @@
 [package]
 name = "rotational-cipher"
 version = "1.0.0"
-authors = ["Chad Baxter <cbaxter@mail.umw.edu>"]

data/tracks/rust/exercises/rotational-cipher/example.rs

@@ -1,16 +1,12 @@
 pub fn rotate(text: &str, shift_key: u8) -> String {
-
-    text.chars().map(|c| {
-        let case = if c.is_uppercase() {
-            'A'
-        } else {
-            'a'
-        } as u8;
-        if c.is_alphabetic() {
-            (((c as u8 - case + shift_key) % 26) + case) as char
-        } else {
-            c
-        }
-    }).collect::<String>()
-
+    text.chars()
+        .map(|c| {
+            let case = if c.is_uppercase() { 'A' } else { 'a' } as u8;
+            if c.is_alphabetic() {
+                (((c as u8 - case + shift_key) % 26) + case) as char
+            } else {
+                c
+            }
+        })
+        .collect::<String>()
 }

data/tracks/rust/exercises/rotational-cipher/src/lib.rs

@@ -1 +1,7 @@
-
+pub fn rotate(input: &str, key: i8) -> String {
+    unimplemented!(
+        "How would input text '{}' transform when every letter is shifted using key '{}'?",
+        input,
+        key
+    );
+}

data/tracks/rust/exercises/run-length-encoding/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "run-length-encoding"
 version = "1.1.0"
-authors = ["zombiefungus <divmermarlav@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/run-length-encoding/example.rs

@@ -3,30 +3,36 @@ use std::cmp;
 pub fn encode(input: &str) -> String {
     input
         .chars()
-        .fold((String::new(), ' ', 0, 1), |(mut acc, last, last_n, pos), c| {
-            // acc = where answer is accumulated
-            // last = last character read
-            // last_n = accum count for last
-            if c == last {
-                if pos == input.len() { // end of string
-                    acc += (last_n + 1).to_string().as_str();
-                    acc.push(c);
+        .fold(
+            (String::new(), ' ', 0, 1),
+            |(mut acc, last, last_n, pos), c| {
+                // acc = where answer is accumulated
+                // last = last character read
+                // last_n = accum count for last
+                if c == last {
+                    if pos == input.len() {
+                        // end of string
+                        acc += (last_n + 1).to_string().as_str();
+                        acc.push(c);
+                    }
+                    (acc, last, last_n + 1, pos + 1)
+                } else {
+                    if last_n > 1 {
+                        acc += last_n.to_string().as_str();
+                    }
+                    if last_n > 0 {
+                        // ignore initial last (single whitespace)
+                        acc.push(last);
+                    }
+                    if pos == input.len() {
+                        // end of string
+                        acc.push(c);
+                    }
+                    (acc, c, 1, pos + 1)
                 }
-                (acc, last, last_n + 1, pos + 1)
-            }
-            else {
-                if last_n > 1 {
-                    acc += last_n.to_string().as_str();
-                }
-                if last_n > 0 { // ignore initial last (single whitespace)
-                    acc.push(last);
-                }
-                if pos == input.len() { // end of string
-                    acc.push(c);
-                }
-                (acc, c, 1, pos + 1)
-            }
-        }).0
+            },
+        )
+        .0
 }
 
 pub fn decode(input: &str) -> String {
@@ -34,12 +40,11 @@ pub fn decode(input: &str) -> String {
         .chars()
         .fold((String::new(), 0), |(mut acc, last_n), c| {
             if let Some(d) = c.to_digit(10) {
-                (acc, 10*last_n + d)
-            }
-            else {
-                acc += c.to_string()
-                    .repeat(cmp::max(last_n, 1) as usize).as_str();
+                (acc, 10 * last_n + d)
+            } else {
+                acc += c.to_string().repeat(cmp::max(last_n, 1) as usize).as_str();
                 (acc, 0)
             }
-        }).0
+        })
+        .0
 }

data/tracks/rust/exercises/saddle-points/example.rs

@@ -6,7 +6,6 @@ pub fn find_saddle_points(input: &[Vec<u64>]) -> Vec<(usize, usize)> {
 
     for i in 0..width {
         for j in 0..height {
-
             let column = input.iter().map(|x| x[j]).collect::<Vec<u64>>();
             let row = &input[i];
 

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

@@ -1,4 +1,3 @@
 [package]
 name = "say"
 version = "1.1.0"
-authors = ["sacherjj <sacherjj@gmail.com>"]

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

@@ -1,13 +1,39 @@
-const SMALL: &'static [&'static str] = &["zero", "one", "two", "three", "four", "five",
-                                         "six", "seven", "eight", "nine", "ten",
-                                         "eleven", "twelve", "thirteen", "fourteen", "fifteen",
-                                         "sixteen", "seventeen", "eighteen", "nineteen"];
+const SMALL: &'static [&'static str] = &[
+    "zero",
+    "one",
+    "two",
+    "three",
+    "four",
+    "five",
+    "six",
+    "seven",
+    "eight",
+    "nine",
+    "ten",
+    "eleven",
+    "twelve",
+    "thirteen",
+    "fourteen",
+    "fifteen",
+    "sixteen",
+    "seventeen",
+    "eighteen",
+    "nineteen",
+];
 
-const TENS: &'static [&'static str] = &["ones", "ten", "twenty", "thirty", "forty",
-                                        "fifty", "sixty", "seventy", "eighty", "ninety"];
+const TENS: &'static [&'static str] = &[
+    "ones", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety",
+];
 
-const SCALE: &'static [&'static str] = &["", "thousand", "million", "billion",
-                                         "trillion", "quadrillion", "quintillion"];
+const SCALE: &'static [&'static str] = &[
+    "",
+    "thousand",
+    "million",
+    "billion",
+    "trillion",
+    "quadrillion",
+    "quintillion",
+];
 
 pub fn encode(n: u64) -> String {
     if n < 20 {

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

@@ -1,13 +1,11 @@
 pub fn series(digits: &str, len: usize) -> Vec<String> {
     match len {
         0 => vec!["".to_string(); digits.len() + 1],
-        _ => {
-            digits
-                .chars()
-                .collect::<Vec<char>>()
-                .windows(len)
-                .map(|window| window.into_iter().collect::<String>())
-                .collect::<Vec<String>>()
-        }
+        _ => digits
+            .chars()
+            .collect::<Vec<char>>()
+            .windows(len)
+            .map(|window| window.into_iter().collect::<String>())
+            .collect::<Vec<String>>(),
     }
 }

data/tracks/rust/exercises/simple-linked-list/example.rs

@@ -8,7 +8,6 @@ struct Node<T> {
     next: Option<Box<Node<T>>>,
 }
 
-
 impl<T> SimpleLinkedList<T> {
     pub fn new() -> Self {
         SimpleLinkedList { head: None, len: 0 }
@@ -55,7 +54,6 @@ impl<T: Clone> SimpleLinkedList<T> {
     }
 }
 
-
 impl<'a, T: Clone> From<&'a [T]> for SimpleLinkedList<T> {
     fn from(item: &[T]) -> Self {
         let mut list = SimpleLinkedList::new();

data/tracks/rust/exercises/spiral-matrix/example.rs

@@ -4,7 +4,6 @@ pub fn spiral_matrix(size: usize) -> Vec<Vec<usize>> {
     let mut counter: usize = 1;
     let mut sidelen = size;
     for i in 0..num_concentric_squares {
-
         for j in 0..sidelen {
             matrix[i][i + j] = counter;
             counter += 1;

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

@@ -4,7 +4,7 @@ use std::collections::HashMap;
 enum GameResult {
     Win,
     Draw,
-    Loss
+    Loss,
 }
 
 struct TeamResult {
@@ -15,7 +15,11 @@ struct TeamResult {
 
 impl TeamResult {
     fn new() -> TeamResult {
-        TeamResult { wins: 0, draws: 0, losses: 0 }
+        TeamResult {
+            wins: 0,
+            draws: 0,
+            losses: 0,
+        }
     }
     fn add_game_result(&mut self, result: GameResult) {
         match result {
@@ -30,7 +34,9 @@ pub fn tally(input: &str) -> String {
     let mut results: HashMap<String, TeamResult> = HashMap::new();
     for line in input.to_string().lines() {
         let parts: Vec<&str> = line.trim_right().split(';').collect();
-        if parts.len() != 3 { continue; }
+        if parts.len() != 3 {
+            continue;
+        }
         let team1 = parts[0];
         let team2 = parts[1];
         let outcome = parts[2];
@@ -38,41 +44,48 @@ pub fn tally(input: &str) -> String {
             "win" => {
                 add_game_result(&mut results, team1.to_string(), GameResult::Win);
                 add_game_result(&mut results, team2.to_string(), GameResult::Loss);
-            },
+            }
             "draw" => {
                 add_game_result(&mut results, team1.to_string(), GameResult::Draw);
                 add_game_result(&mut results, team2.to_string(), GameResult::Draw);
-            },
+            }
             "loss" => {
                 add_game_result(&mut results, team1.to_string(), GameResult::Loss);
                 add_game_result(&mut results, team2.to_string(), GameResult::Win);
-            },
-            _ => () // Ignore bad lines
+            }
+            _ => (), // Ignore bad lines
         }
     }
     write_tally(&results)
 }
 
 fn write_tally(results: &HashMap<String, TeamResult>) -> String {
-    let mut v: Vec<_> = results.iter().map(|(team, r)| {
-        let games = r.wins + r.draws + r.losses;
-        let points = r.wins * 3 + r.draws;
-        (team, games, r, points)
-    }).collect();
+    let mut v: Vec<_> = results
+        .iter()
+        .map(|(team, r)| {
+            let games = r.wins + r.draws + r.losses;
+            let points = r.wins * 3 + r.draws;
+            (team, games, r, points)
+        })
+        .collect();
     // Sort by points descending, then name A-Z.
-    v.sort_by(|a, b|
-              match a.3.cmp(&(b.3)).reverse() {
-                  Equal => a.0.cmp(&(b.0)),
-                  other => other
-              });
+    v.sort_by(|a, b| match a.3.cmp(&(b.3)).reverse() {
+        Equal => a.0.cmp(&(b.0)),
+        other => other,
+    });
     let mut lines = vec![format!("{:30} | MP |  W |  D |  L |  P", "Team")];
     lines.extend(v.iter().map(|&(ref team, games, r, points)| {
-        format!("{:30} | {:2} | {:2} | {:2} | {:2} | {:2}",
-                team, games, r.wins, r.draws, r.losses, points)
+        format!(
+            "{:30} | {:2} | {:2} | {:2} | {:2} | {:2}",
+            team, games, r.wins, r.draws, r.losses, points
+        )
     }));
     lines.join("\n")
 }
 
 fn add_game_result(results: &mut HashMap<String, TeamResult>, team: String, result: GameResult) {
-    results.entry(team).or_insert(TeamResult::new()).add_game_result(result);
+    results
+        .entry(team)
+        .or_insert(TeamResult::new())
+        .add_game_result(result);
 }