trackler 2.2.1.179 → 2.2.1.180

data/tracks/reasonml/exercises/rna-transcription/README.md

@@ -17,15 +17,25 @@ each nucleotide with its complement:
 * `C` -> `G`
 * `T` -> `A`
 * `A` -> `U`
+## Source
 
-# Build + Watch
+Hyperphysics [http://hyperphysics.phy-astr.gsu.edu/hbase/Organic/transcription.html](http://hyperphysics.phy-astr.gsu.edu/hbase/Organic/transcription.html)
 
+## Building and testing
+You will need the node package manager (npm) installed - download from [here](https://www.npmjs.com/get-npm)
+There is one time setup for each exercise, which may take a few minutes:
 ```
-npm start
+npm install
 ```
 
-# Test + Watch
+Open two shells, and in the first, start the build process.
+```
+npm start
+```
 
+In the second, start the tests running.
 ```
 npm test
 ```
+
+As you edit the code, the two processes will continually rebuild and rerun the tests.

data/tracks/reasonml/exercises/roman-numerals/README.md

@@ -41,6 +41,9 @@ In Roman numerals 1990 is MCMXC:
 8=VIII
 
 See also: http://www.novaroma.org/via_romana/numbers.html
+## Source
+
+The Roman Numeral Kata [http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals](http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals)
 
 ## Building and testing
 You will need the node package manager (npm) installed - download from [here](https://www.npmjs.com/get-npm)
@@ -59,11 +62,4 @@ In the second, start the tests running.
 npm test
 ```
 
-As you edit the code, the two processes will continually rebuild and rerun the tests.
-
-## Source
-
-The Roman Numeral Kata [http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals](http://codingdojo.org/cgi-bin/index.pl?KataRomanNumerals)
-
-## Submitting Incomplete Solutions
-It's possible to submit an incomplete solution so you can see how others have completed the exercise.
+As you edit the code, the two processes will continually rebuild and rerun the tests.

data/tracks/reasonml/exercises/run-length-encoding/README.md

@@ -22,18 +22,25 @@ For simplicity, you can assume that the unencoded string will only contain
 the letters A through Z (either lower or upper case) and whitespace. This way
 data to be encoded will never contain any numbers and numbers inside data to
 be decoded always represent the count for the following character.
+## Source
 
-# Build
+Wikipedia [https://en.wikipedia.org/wiki/Run-length_encoding](https://en.wikipedia.org/wiki/Run-length_encoding)
+
+## Building and testing
+You will need the node package manager (npm) installed - download from [here](https://www.npmjs.com/get-npm)
+There is one time setup for each exercise, which may take a few minutes:
 ```
-npm run build
+npm install
 ```
 
-# Build + Watch
-
+Open two shells, and in the first, start the build process.
 ```
-npm run start
+npm start
 ```
 
+In the second, start the tests running.
+```
+npm test
+```
 
-# Editor
-If you use `vscode`, Press `Windows + Shift + B` it will build automatically
+As you edit the code, the two processes will continually rebuild and rerun the tests.

data/tracks/reasonml/exercises/space-age/README.md

@@ -16,15 +16,25 @@ be able to say that they're 31.69 Earth-years old.
 
 If you're wondering why Pluto didn't make the cut, go watch [this
 youtube video](http://www.youtube.com/watch?v=Z_2gbGXzFbs).
+## Source
 
-# Build + Watch
+Partially inspired by Chapter 1 in Chris Pine's online Learn to Program tutorial. [http://pine.fm/LearnToProgram/?Chapter=01](http://pine.fm/LearnToProgram/?Chapter=01)
 
+## Building and testing
+You will need the node package manager (npm) installed - download from [here](https://www.npmjs.com/get-npm)
+There is one time setup for each exercise, which may take a few minutes:
 ```
-npm start
+npm install
 ```
 
-# Test + Watch
+Open two shells, and in the first, start the build process.
+```
+npm start
+```
 
+In the second, start the tests running.
 ```
 npm test
 ```
+
+As you edit the code, the two processes will continually rebuild and rerun the tests.

data/tracks/reasonml/exercises/word-count/README.md

@@ -1,24 +1,34 @@
 # Word Count
+
 Given a phrase, count the occurrences of each word in that phrase.
 
-For example for the input "olly olly in come free"
+For example for the input `"olly olly in come free"`
 
+```text
 olly: 2
 in: 1
 come: 1
 free: 1
+```
+## Source
+
+This is a classic toy problem, but we were reminded of it by seeing it in the Go Tour.
 
-# Build
+## Building and testing
+You will need the node package manager (npm) installed - download from [here](https://www.npmjs.com/get-npm)
+There is one time setup for each exercise, which may take a few minutes:
 ```
-npm run build
+npm install
 ```
 
-# Build + Watch
-
+Open two shells, and in the first, start the build process.
 ```
-npm run start
+npm start
 ```
 
+In the second, start the tests running.
+```
+npm test
+```
 
-# Editor
-If you use `vscode`, Press `Windows + Shift + B` it will build automatically
+As you edit the code, the two processes will continually rebuild and rerun the tests.

data/tracks/rust/.travis.yml

@@ -10,6 +10,7 @@ script:
 - "sh ./_test/ensure-readmes-are-updated.sh"
 - "./bin/configlet lint ."
 - "./_test/verify-exercise-difficulties.sh"
+- "./_test/check-exercises-for-authors.sh"
 sudo: false
 rust:
   - stable

data/tracks/rust/_test/check-exercises-for-authors.sh

@@ -0,0 +1,10 @@
+#!/bin/sh
+
+repo=$(cd "$(dirname "$0")/.." && pwd)
+
+grep -rnw "$repo/exercises/" --include="*.toml" -e "authors"
+
+if [ $? -eq 0 ]; then
+	echo "Found 'authors' field in exercises";
+	exit 1;
+fi

data/tracks/rust/bin/format_exercises

@@ -25,6 +25,8 @@ for exercise_dir in ${EXERCISES_PATH}/*; do
 			cd "$exercise_dir"
 
 			cargo fmt
+
+			[ -f example.rs ] && rustfmt example.rs
 		)
 	fi
 

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

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

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

@@ -6,7 +6,10 @@ pub fn map_function(values: Vec<i32>, f: &Fn(i32) -> i32) -> Vec<i32> {
     out
 }
 
-pub fn map_closure<F>(values: Vec<i32>, f: F) -> Vec<i32> where F: Fn(i32) -> i32 {
+pub fn map_closure<F>(values: Vec<i32>, f: F) -> Vec<i32>
+where
+    F: Fn(i32) -> i32,
+{
     let mut out: Vec<i32> = vec![];
     for val in values {
         out.push(f(val))

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

@@ -1,9 +1,10 @@
 pub fn abbreviate(phrase: &str) -> String {
-    phrase.split(|c: char| c.is_whitespace() || !c.is_alphanumeric())
-          .flat_map(|word| split_camel(word))
-          .filter_map(|word| word.chars().next())
-          .collect::<String>()
-          .to_uppercase()
+    phrase
+        .split(|c: char| c.is_whitespace() || !c.is_alphanumeric())
+        .flat_map(|word| split_camel(word))
+        .filter_map(|word| word.chars().next())
+        .collect::<String>()
+        .to_uppercase()
 }
 
 fn split_camel(phrase: &str) -> Vec<String> {

data/tracks/rust/exercises/acronym/tests/acronym.rs

@@ -2,7 +2,7 @@ extern crate acronym;
 
 #[test]
 fn empty() {
-  assert_eq!(acronym::abbreviate(""), "");
+    assert_eq!(acronym::abbreviate(""), "");
 }
 
 #[test]

data/tracks/rust/exercises/all-your-base/example.rs

@@ -38,7 +38,11 @@ pub enum Error {
 ///  * Never output leading 0 digits. However, your function must be able to
 ///     process input with leading 0 digits.
 ///
-pub fn convert<P: AsRef<[Digit]>>(digits: P, from_base: Digit, to_base: Digit) -> Result<Vec<Digit>, Error> {
+pub fn convert<P: AsRef<[Digit]>>(
+    digits: P,
+    from_base: Digit,
+    to_base: Digit,
+) -> Result<Vec<Digit>, Error> {
     // check that both bases are in the correct range
     if from_base < 2 {
         return Err(Error::InvalidInputBase);
@@ -53,7 +57,9 @@ pub fn convert<P: AsRef<[Digit]>>(digits: P, from_base: Digit, to_base: Digit) -
     }
 
     // convert all digits into a single large number
-    let mut immediate = digits.as_ref().iter()
+    let mut immediate = digits
+        .as_ref()
+        .iter()
         .rev()
         .enumerate()
         .map(|(i, &num)| num * from_base.pow(i as u32))

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

@@ -1,7 +1,16 @@
 pub struct Allergies(pub usize);
 
 #[derive(PartialEq, Debug)]
-pub enum Allergen { Eggs, Peanuts, Shellfish, Strawberries, Tomatoes, Chocolate, Pollen, Cats }
+pub enum Allergen {
+    Eggs,
+    Peanuts,
+    Shellfish,
+    Strawberries,
+    Tomatoes,
+    Chocolate,
+    Pollen,
+    Cats,
+}
 
 impl Allergies {
     pub fn new(score: usize) -> Allergies {
@@ -10,17 +19,30 @@ impl Allergies {
 
     pub fn is_allergic_to(&self, allergen: &Allergen) -> bool {
         let allergens = Allergies::allergens();
-        let index = allergens.iter().position(|x: &Allergen| x == allergen).unwrap();
+        let index = allergens
+            .iter()
+            .position(|x: &Allergen| x == allergen)
+            .unwrap();
         (self.0 & (1 << index)) != 0
     }
 
     pub fn allergies(&self) -> Vec<Allergen> {
-        Allergies::allergens().into_iter().filter(|allergen| self.is_allergic_to(allergen)).collect()
+        Allergies::allergens()
+            .into_iter()
+            .filter(|allergen| self.is_allergic_to(allergen))
+            .collect()
     }
 
     fn allergens() -> Vec<Allergen> {
-        vec![Allergen::Eggs, Allergen::Peanuts, Allergen::Shellfish,
-            Allergen::Strawberries, Allergen::Tomatoes, Allergen::Chocolate,
-            Allergen::Pollen, Allergen::Cats]
+        vec![
+            Allergen::Eggs,
+            Allergen::Peanuts,
+            Allergen::Shellfish,
+            Allergen::Strawberries,
+            Allergen::Tomatoes,
+            Allergen::Chocolate,
+            Allergen::Pollen,
+            Allergen::Cats,
+        ]
     }
 }

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

@@ -6,14 +6,14 @@ extern crate permutohedron;
 use itertools::Itertools;
 use permutohedron::Heap as Permutations;
 
-
+use std::char;
 use std::collections::HashMap;
 use std::collections::HashSet;
-use std::char;
 
 fn test_equation(puzzle: &str, substitutions: &HashMap<char, u8>) -> bool {
     // Create a new String with characters changed to numbers
-    let puzzle: String = puzzle.chars()
+    let puzzle: String = puzzle
+        .chars()
         .map(|c| {
             if let Some(&n) = substitutions.get(&c) {
                 // If the character is in the substitutions, get the number and
@@ -33,13 +33,20 @@ fn test_equation(puzzle: &str, substitutions: &HashMap<char, u8>) -> bool {
     let right = equation[1].trim().parse::<u32>().unwrap();
 
     // Sum the parts on the left side
-    let left: u32 = equation[0].split('+').map(str::trim).map(|n| n.parse::<u32>().unwrap()).sum();
+    let left: u32 = equation[0]
+        .split('+')
+        .map(str::trim)
+        .map(|n| n.parse::<u32>().unwrap())
+        .sum();
 
     // Create a String with just the numbers and spaces
-    let just_numbers =
-        puzzle.chars().filter(|c| c.is_digit(10) || c.is_whitespace()).collect::<String>();
+    let just_numbers = puzzle
+        .chars()
+        .filter(|c| c.is_digit(10) || c.is_whitespace())
+        .collect::<String>();
     // Split this into the numbers and check every number's first character
-    let no_leading_zeroes = just_numbers.split_whitespace()
+    let no_leading_zeroes = just_numbers
+        .split_whitespace()
         .all(|number| number.chars().next().unwrap() != '0');
 
     // Return true if left and right side is equal and the equation doesnt
@@ -47,11 +54,12 @@ fn test_equation(puzzle: &str, substitutions: &HashMap<char, u8>) -> bool {
     left == right && no_leading_zeroes
 }
 
-
 pub fn solve(puzzle: &str) -> Option<HashMap<char, u8>> {
     // Get unique letters from the puzzle
-    let letters: HashSet<char> =
-        puzzle.chars().filter(|&c| c.is_alphabetic() && c.is_uppercase()).collect();
+    let letters: HashSet<char> = puzzle
+        .chars()
+        .filter(|&c| c.is_alphabetic() && c.is_uppercase())
+        .collect();
     let letters: Vec<char> = letters.into_iter().collect();
 
     // All available numbers for substitution

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

@@ -7,8 +7,12 @@ fn sort(word: &String) -> String {
 pub fn anagrams_for<'a>(word: &str, inputs: &[&'a str]) -> Vec<&'a str> {
     let lower = word.to_lowercase();
     let sorted = sort(&lower);
-    inputs.iter().filter(|input| {
-        let input_lower = input.to_lowercase();
-        lower != input_lower && sorted == sort(&input_lower)
-    }).cloned().collect()
+    inputs
+        .iter()
+        .filter(|input| {
+            let input_lower = input.to_lowercase();
+            lower != input_lower && sorted == sort(&input_lower)
+        })
+        .cloned()
+        .collect()
 }

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

@@ -12,23 +12,23 @@ fn get_transpose(ch: char) -> char {
 
 pub fn encode(plaintext: &str) -> String {
     plaintext
-    .to_lowercase()
-    .chars()
-    .filter(|&ch| ch.is_ascii())
-    .filter(|&ch| ch.is_alphanumeric())
-    .map(|ch| get_transpose(ch))
-    .collect::<Vec<char>>()
-    .chunks(5)
-    .map(|slice| slice.iter().cloned().collect::<String>())
-    .collect::<Vec<String>>()
-    .join(" ")
+        .to_lowercase()
+        .chars()
+        .filter(|&ch| ch.is_ascii())
+        .filter(|&ch| ch.is_alphanumeric())
+        .map(|ch| get_transpose(ch))
+        .collect::<Vec<char>>()
+        .chunks(5)
+        .map(|slice| slice.iter().cloned().collect::<String>())
+        .collect::<Vec<String>>()
+        .join(" ")
 }
 
 pub fn decode(ciphertext: &str) -> String {
     ciphertext
-    .split::<char>(' ')
-    .collect::<String>()
-    .chars()
-    .map(|ch| get_transpose(ch))
-    .collect::<String>()
+        .split::<char>(' ')
+        .collect::<String>()
+        .chars()
+        .map(|ch| get_transpose(ch))
+        .collect::<String>()
 }

data/tracks/rust/exercises/beer-song/example.rs

@@ -1,22 +1,28 @@
 pub fn verse(n: i32) -> String {
     match n {
         0 => "No more bottles of beer on the wall, no more bottles of beer.\n\
-              Go to the store and buy some more, 99 bottles of beer on the wall.\n".to_string(),
+              Go to the store and buy some more, 99 bottles of beer on the wall.\n"
+            .to_string(),
         1 => "1 bottle of beer on the wall, 1 bottle of beer.\n\
-              Take it down and pass it around, no more bottles of beer on the wall.\n".to_string(),
+              Take it down and pass it around, no more bottles of beer on the wall.\n"
+            .to_string(),
         2 => "2 bottles of beer on the wall, 2 bottles of beer.\n\
-              Take one down and pass it around, 1 bottle of beer on the wall.\n".to_string(),
-        n if n > 2 && n <= 99 =>
-            format!(
-                "{n} bottles of beer on the wall, {n} bottles of beer.\n\
-                 Take one down and pass it around, {n_minus_1} bottles of beer on the wall.\n",
-                n=n,
-                n_minus_1=n - 1),
-        _ =>
-            panic!(),
+              Take one down and pass it around, 1 bottle of beer on the wall.\n"
+            .to_string(),
+        n if n > 2 && n <= 99 => format!(
+            "{n} bottles of beer on the wall, {n} bottles of beer.\n\
+             Take one down and pass it around, {n_minus_1} bottles of beer on the wall.\n",
+            n = n,
+            n_minus_1 = n - 1
+        ),
+        _ => panic!(),
     }
 }
 
 pub fn sing(start: i32, end: i32) -> String {
-    (end .. start + 1).rev().map(|n| verse(n)).collect::<Vec<_>>().join("\n")
+    (end..start + 1)
+        .rev()
+        .map(|n| verse(n))
+        .collect::<Vec<_>>()
+        .join("\n")
 }