trackler 2.2.1.171 → 2.2.1.172

data/tracks/rust/exercises/run-length-encoding/src/lib.rs

@@ -4,4 +4,4 @@ pub fn encode(source: &str) -> String {
 
 pub fn decode(source: &str) -> String {
     unimplemented!("Return the run-length decoding of {}.", source);
-}
+}

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

@@ -22,8 +22,10 @@ fn test_encode_string_with_no_single_characters() {
 #[test]
 #[ignore]
 fn test_encode_single_characters_mixed_with_repeated_characters() {
-    assert_eq!("12WB12W3B24WB", rle::encode(
-        "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB"));
+    assert_eq!(
+        "12WB12W3B24WB",
+        rle::encode("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB")
+    );
 }
 
 #[test]
@@ -61,8 +63,10 @@ fn test_decode_string_with_no_single_characters() {
 #[test]
 #[ignore]
 fn test_decode_single_characters_with_repeated_characters() {
-    assert_eq!("WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB",
-               rle::decode("12WB12W3B24WB"));
+    assert_eq!(
+        "WWWWWWWWWWWWBWWWWWWWWWWWWBBBWWWWWWWWWWWWWWWWWWWWWWWWB",
+        rle::decode("12WB12W3B24WB")
+    );
 }
 
 #[test]
@@ -82,5 +86,8 @@ fn test_decode_lower_case_string() {
 #[test]
 #[ignore]
 fn test_consistency() {
-    assert_eq!("zzz ZZ  zZ", rle::decode(rle::encode("zzz ZZ  zZ").as_str()));
+    assert_eq!(
+        "zzz ZZ  zZ",
+        rle::decode(rle::encode("zzz ZZ  zZ").as_str())
+    );
 }

data/tracks/rust/exercises/saddle-points/README.md

@@ -39,11 +39,31 @@ Execute the tests with:
 $ cargo test
 ```
 
-All but the first test have been ignored.  After you get the first test to
-pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
-to pass again.  The test file is located in the `tests` directory.   You can
-also remove the ignore flag from all the tests to get them to run all at once
-if you wish.
+All but the first test have been ignored. After you get the first test to
+pass, open the tests source file wich is located in the `tests` directory
+and remove the `#[ignore]` flag from the next test and get the tests to pass
+again. Each separate test is a function with `#[test]` flag above it.
+Continue, until you pass every test. 
+
+If you wish to run all tests without editing the tests source file, use:
+
+```bash
+$ cargo test -- --ignored
+```
+
+To run a specific test, for example `some_test`, you can use:
+
+```bash
+$ cargo test some_test
+```
+
+If the specfic test is ignored use:
+
+```bash
+$ cargo test some_test -- --ignored
+```
+
+To learn more about Rust tests refer to the [online test documentation][rust-tests]
 
 Make sure to read the [Modules](https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html) chapter if you
 haven't already, it will help you with organizing your files.
@@ -57,6 +77,7 @@ If you want to know more about Exercism, take a look at the [contribution guide]
 [help-page]: http://exercism.io/languages/rust
 [modules]: https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html
 [cargo]: https://doc.rust-lang.org/book/second-edition/ch14-00-more-about-cargo.html
+[rust-tests]: https://doc.rust-lang.org/book/second-edition/ch11-02-running-tests.html
 
 ## Source
 

data/tracks/rust/exercises/saddle-points/src/lib.rs

@@ -1,3 +1,6 @@
 pub fn find_saddle_points(input: &[Vec<u64>]) -> Vec<(usize, usize)> {
-    unimplemented!("find the saddle points of the following matrix: {:?}", input)
+    unimplemented!(
+        "find the saddle points of the following matrix: {:?}",
+        input
+    )
 }

data/tracks/rust/exercises/say/README.md

@@ -24,7 +24,7 @@ Some good test cases for this program are:
 ### Extension
 
 If you're on a Mac, shell out to Mac OS X's `say` program to talk out
-loud.
+loud. If you're on Linux or Windows, eSpeakNG may be available with the command `espeak`.
 
 ## Step 2
 
@@ -96,11 +96,31 @@ Execute the tests with:
 $ cargo test
 ```
 
-All but the first test have been ignored.  After you get the first test to
-pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
-to pass again.  The test file is located in the `tests` directory.   You can
-also remove the ignore flag from all the tests to get them to run all at once
-if you wish.
+All but the first test have been ignored. After you get the first test to
+pass, open the tests source file wich is located in the `tests` directory
+and remove the `#[ignore]` flag from the next test and get the tests to pass
+again. Each separate test is a function with `#[test]` flag above it.
+Continue, until you pass every test. 
+
+If you wish to run all tests without editing the tests source file, use:
+
+```bash
+$ cargo test -- --ignored
+```
+
+To run a specific test, for example `some_test`, you can use:
+
+```bash
+$ cargo test some_test
+```
+
+If the specfic test is ignored use:
+
+```bash
+$ cargo test some_test -- --ignored
+```
+
+To learn more about Rust tests refer to the [online test documentation][rust-tests]
 
 Make sure to read the [Modules](https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html) chapter if you
 haven't already, it will help you with organizing your files.
@@ -114,6 +134,7 @@ If you want to know more about Exercism, take a look at the [contribution guide]
 [help-page]: http://exercism.io/languages/rust
 [modules]: https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html
 [cargo]: https://doc.rust-lang.org/book/second-edition/ch14-00-more-about-cargo.html
+[rust-tests]: https://doc.rust-lang.org/book/second-edition/ch11-02-running-tests.html
 
 ## Source
 

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

@@ -1,3 +1,3 @@
 pub fn encode(n: u64) -> String {
     unimplemented!("Say {} in English.", n);
-}
+}

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

@@ -72,14 +72,20 @@ fn test_one_thousand() {
 #[test]
 #[ignore]
 fn test_one_thousand_two_hundred_thirty_four() {
-    assert_eq!(say::encode(1234), String::from("one thousand two hundred thirty-four"));
+    assert_eq!(
+        say::encode(1234),
+        String::from("one thousand two hundred thirty-four")
+    );
 }
 
 // note, using American style with no and
 #[test]
 #[ignore]
 fn test_eight_hundred_and_ten_thousand() {
-    assert_eq!(say::encode(810_000), String::from("eight hundred ten thousand"));
+    assert_eq!(
+        say::encode(810_000),
+        String::from("eight hundred ten thousand")
+    );
 }
 
 #[test]
@@ -98,8 +104,10 @@ fn test_one_million_two() {
 #[test]
 #[ignore]
 fn test_1002345() {
-    assert_eq!(say::encode(1_002_345),
-               String::from("one million two thousand three hundred forty-five"));
+    assert_eq!(
+        say::encode(1_002_345),
+        String::from("one million two thousand three hundred forty-five")
+    );
 }
 
 #[test]
@@ -111,11 +119,15 @@ fn test_one_billion() {
 #[test]
 #[ignore]
 fn test_987654321123() {
-    assert_eq!(say::encode(987_654_321_123),
-               String::from("nine hundred eighty-seven billion \
-                             six hundred fifty-four million \
-                             three hundred twenty-one thousand \
-                             one hundred twenty-three"));
+    assert_eq!(
+        say::encode(987_654_321_123),
+        String::from(
+            "nine hundred eighty-seven billion \
+             six hundred fifty-four million \
+             three hundred twenty-one thousand \
+             one hundred twenty-three"
+        )
+    );
 }
 
 /*
@@ -124,9 +136,13 @@ fn test_987654321123() {
 #[test]
 #[ignore]
 fn test_max_u64() {
-    assert_eq!(say::encode(9_223_372_036_854_775_807),
-               String::from("nine quintillion two hundred twenty-three \
-                             quadrillion three hundred seventy-two trillion \
-                             thirty-six billion eight hundred fifty-four million \
-                             seven hundred seventy-five thousand eight hundred seven"));
+    assert_eq!(
+        say::encode(9_223_372_036_854_775_807),
+        String::from(
+            "nine quintillion two hundred twenty-three \
+             quadrillion three hundred seventy-two trillion \
+             thirty-six billion eight hundred fifty-four million \
+             seven hundred seventy-five thousand eight hundred seven"
+        )
+    );
 }

data/tracks/rust/exercises/scrabble-score/README.md

@@ -52,11 +52,31 @@ Execute the tests with:
 $ cargo test
 ```
 
-All but the first test have been ignored.  After you get the first test to
-pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
-to pass again.  The test file is located in the `tests` directory.   You can
-also remove the ignore flag from all the tests to get them to run all at once
-if you wish.
+All but the first test have been ignored. After you get the first test to
+pass, open the tests source file wich is located in the `tests` directory
+and remove the `#[ignore]` flag from the next test and get the tests to pass
+again. Each separate test is a function with `#[test]` flag above it.
+Continue, until you pass every test. 
+
+If you wish to run all tests without editing the tests source file, use:
+
+```bash
+$ cargo test -- --ignored
+```
+
+To run a specific test, for example `some_test`, you can use:
+
+```bash
+$ cargo test some_test
+```
+
+If the specfic test is ignored use:
+
+```bash
+$ cargo test some_test -- --ignored
+```
+
+To learn more about Rust tests refer to the [online test documentation][rust-tests]
 
 Make sure to read the [Modules](https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html) chapter if you
 haven't already, it will help you with organizing your files.
@@ -70,6 +90,7 @@ If you want to know more about Exercism, take a look at the [contribution guide]
 [help-page]: http://exercism.io/languages/rust
 [modules]: https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html
 [cargo]: https://doc.rust-lang.org/book/second-edition/ch14-00-more-about-cargo.html
+[rust-tests]: https://doc.rust-lang.org/book/second-edition/ch11-02-running-tests.html
 
 ## Source
 

data/tracks/rust/exercises/scrabble-score/src/lib.rs

@@ -1,4 +1,4 @@
 /// Compute the Scrabble score for a word.
 pub fn score(word: &str) -> u64 {
     unimplemented!("Score {} in Scrabble.", word);
-}
+}

data/tracks/rust/exercises/series/README.md

@@ -1,18 +1,18 @@
 # Series
 
 Given a string of digits, output all the contiguous substrings of length `n` in
-that string.
+that string in the order that they appear.
 
 For example, the string "49142" has the following 3-digit series:
 
-- 491
-- 914
-- 142
+- "491"
+- "914"
+- "142"
 
 And the following 4-digit series:
 
-- 4914
-- 9142
+- "4914"
+- "9142"
 
 And if you ask for a 6-digit series from a 5-digit string, you deserve
 whatever you get.
@@ -33,11 +33,31 @@ Execute the tests with:
 $ cargo test
 ```
 
-All but the first test have been ignored.  After you get the first test to
-pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
-to pass again.  The test file is located in the `tests` directory.   You can
-also remove the ignore flag from all the tests to get them to run all at once
-if you wish.
+All but the first test have been ignored. After you get the first test to
+pass, open the tests source file wich is located in the `tests` directory
+and remove the `#[ignore]` flag from the next test and get the tests to pass
+again. Each separate test is a function with `#[test]` flag above it.
+Continue, until you pass every test. 
+
+If you wish to run all tests without editing the tests source file, use:
+
+```bash
+$ cargo test -- --ignored
+```
+
+To run a specific test, for example `some_test`, you can use:
+
+```bash
+$ cargo test some_test
+```
+
+If the specfic test is ignored use:
+
+```bash
+$ cargo test some_test -- --ignored
+```
+
+To learn more about Rust tests refer to the [online test documentation][rust-tests]
 
 Make sure to read the [Modules](https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html) chapter if you
 haven't already, it will help you with organizing your files.
@@ -51,6 +71,7 @@ If you want to know more about Exercism, take a look at the [contribution guide]
 [help-page]: http://exercism.io/languages/rust
 [modules]: https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html
 [cargo]: https://doc.rust-lang.org/book/second-edition/ch14-00-more-about-cargo.html
+[rust-tests]: https://doc.rust-lang.org/book/second-edition/ch11-02-running-tests.html
 
 ## Source
 

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

@@ -1,3 +1,7 @@
 pub fn series(digits: &str, len: usize) -> Vec<String> {
-    unimplemented!("What are the series of length {} in string {:?}", len, digits)
+    unimplemented!(
+        "What are the series of length {} in string {:?}",
+        len,
+        digits
+    )
 }

data/tracks/rust/exercises/sieve/README.md

@@ -5,8 +5,8 @@ number.
 
 The Sieve of Eratosthenes is a simple, ancient algorithm for finding all
 prime numbers up to any given limit. It does so by iteratively marking as
-composite (i.e. not prime) the multiples of each prime,
-starting with the multiples of 2.
+composite (i.e. not prime) the multiples of each prime, starting with the
+multiples of 2. It does not use any division or remainder operation.
 
 Create your range, starting at two and continuing up to and including the given limit. (i.e. [2, limit])
 
@@ -25,7 +25,9 @@ https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
 
 Notice that this is a very specific algorithm, and the tests don't check
 that you've implemented the algorithm, only that you've come up with the
-correct list of primes.
+correct list of primes. A good first test is to check that you do not use
+division or remainder operations (div, /, mod or % depending on the
+language).
 
 ## Rust Installation
 
@@ -40,11 +42,31 @@ Execute the tests with:
 $ cargo test
 ```
 
-All but the first test have been ignored.  After you get the first test to
-pass, remove the ignore flag (`#[ignore]`) from the next test and get the tests
-to pass again.  The test file is located in the `tests` directory.   You can
-also remove the ignore flag from all the tests to get them to run all at once
-if you wish.
+All but the first test have been ignored. After you get the first test to
+pass, open the tests source file wich is located in the `tests` directory
+and remove the `#[ignore]` flag from the next test and get the tests to pass
+again. Each separate test is a function with `#[test]` flag above it.
+Continue, until you pass every test. 
+
+If you wish to run all tests without editing the tests source file, use:
+
+```bash
+$ cargo test -- --ignored
+```
+
+To run a specific test, for example `some_test`, you can use:
+
+```bash
+$ cargo test some_test
+```
+
+If the specfic test is ignored use:
+
+```bash
+$ cargo test some_test -- --ignored
+```
+
+To learn more about Rust tests refer to the [online test documentation][rust-tests]
 
 Make sure to read the [Modules](https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html) chapter if you
 haven't already, it will help you with organizing your files.
@@ -58,6 +80,7 @@ If you want to know more about Exercism, take a look at the [contribution guide]
 [help-page]: http://exercism.io/languages/rust
 [modules]: https://doc.rust-lang.org/book/second-edition/ch07-00-modules.html
 [cargo]: https://doc.rust-lang.org/book/second-edition/ch14-00-more-about-cargo.html
+[rust-tests]: https://doc.rust-lang.org/book/second-edition/ch11-02-running-tests.html
 
 ## Source
 

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

@@ -0,0 +1 @@
+

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

@@ -17,7 +17,6 @@ fn primes_up_to_10() {
     assert_eq!(sieve::primes_up_to(10), [2, 3, 5, 7]);
 }
 
-
 #[test]
 #[ignore]
 fn limit_is_prime() {
@@ -27,16 +26,16 @@ fn limit_is_prime() {
 #[test]
 #[ignore]
 fn limit_of_1000() {
-    let expected = vec![2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
-                        71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149,
-                        151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
-                        233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,
-                        317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
-                        419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499,
-                        503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
-                        607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691,
-                        701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
-                        811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907,
-                        911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997];
+    let expected = vec![
+        2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89,
+        97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181,
+        191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
+        283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397,
+        401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503,
+        509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619,
+        631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743,
+        751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
+        877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997,
+    ];
     assert_eq!(sieve::primes_up_to(1000), expected);
 }