trackler 2.2.1.59 → 2.2.1.60

data/tracks/rust/exercises/circular-buffer/README.md

@@ -31,18 +31,25 @@ If the buffer has 7 elements then it is completely full:
 When the buffer is full an error will be raised, alerting the client
 that further writes are blocked until a slot becomes free.
 
-The client can opt to overwrite the oldest data with a forced write. In
-this case, two more elements — A & B — are added and they overwrite the
-3 & 4:
+When the buffer is full, the client can opt to overwrite the oldest
+data with a forced write. In this case, two more elements — A & B —
+are added and they overwrite the 3 & 4:
 
     [6][7][8][9][A][B][5]
 
-Finally, if two elements are now removed then what would be returned is
-not 3 & 4 but 5 & 6 because A & B overwrote the 3 & the 4 yielding the
-buffer with:
+3 & 4 have been replaced by A & B making 5 now the oldest data in the
+buffer. Finally, if two elements are removed then what would be
+returned is 5 & 6 yielding the buffer:
 
     [ ][7][8][9][A][B][ ]
 
+Because there is space available, if the client again uses overwrite
+to store C & D then the space where 5 & 6 were stored previously will
+be used not the location of 7 & 8. 7 is still the oldest element and
+the buffer is once again full.
+
+    [D][7][8][9][A][B][C]
+
 ## Rust Installation
 
 Refer to the [exercism help page][help-page] for Rust installation and learning

data/tracks/rust/exercises/crypto-square/README.md

@@ -26,7 +26,7 @@ and `r` is the number of rows.
 Our normalized text is 54 characters long, dictating a rectangle with
 `c = 8` and `r = 7`:
 
-```plain
+```text
 ifmanwas
 meanttos
 tayonthe
@@ -41,22 +41,24 @@ right.
 
 The message above is coded as:
 
-```plain
+```text
 imtgdvsfearwermayoogoanouuiontnnlvtwttddesaohghnsseoau
 ```
 
-Output the encoded text in chunks.  Phrases that fill perfect squares
-`(r X r)` should be output in `r`-length chunks separated by spaces.
-Imperfect squares will have `n` empty spaces.  Those spaces should be distributed evenly across the last `n` rows.
+Output the encoded text in chunks.  Phrases that fill perfect rectangles
+`(r X c)` should be output `c` chunks of `r` length, separated by spaces.
+Phrases that do not fill perfect rectangles will have `n` empty spaces.
+Those spaces should be distributed evenly, added to the end of the last
+`n` chunks.
 
-```plain
-imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn sseoau
+```text
+imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau 
 ```
 
 Notice that were we to stack these, we could visually decode the
 cyphertext back in to the original message:
 
-```plain
+```text
 imtgdvs
 fearwer
 mayoogo

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

@@ -1,3 +1,3 @@
 [package]
 name = "dominoes"
-version = "1.0.1"
+version = "2.0.0"

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

@@ -3,6 +3,7 @@
 We are going to do the `Transform` step of an Extract-Transform-Load.
 
 ### ETL
+
 Extract-Transform-Load (ETL) is a fancy way of saying, "We have some crufty, legacy data over in this system, and now we need it in this shiny new system over here, so
 we're going to migrate this."
 
@@ -11,6 +12,7 @@ once." That's then typically followed by much forehead slapping and
 moaning about how stupid we could possibly be.)
 
 ### The goal
+
 We're going to extract some scrabble scores from a legacy system.
 
 The old system stored a list of letters per score:

data/tracks/rust/exercises/grade-school/README.md

@@ -21,7 +21,6 @@ In the end, you should be able to:
 Note that all our students only have one name.  (It's a small town, what
 do you want?)
 
-
 ## For bonus points
 
 Did you get the tests passing and the code clean? If you want to, these

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

@@ -15,7 +15,6 @@ Write code that shows:
 - how many grains were on each square, and
 - the total number of grains
 
-
 ## For bonus points
 
 Did you get the tests passing and the code clean? If you want to, these

data/tracks/rust/exercises/isbn-verifier/Cargo.lock

@@ -0,0 +1,4 @@
+[root]
+name = "isbn-verifier"
+version = "1.1.0"
+

data/tracks/rust/exercises/isbn-verifier/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "isbn-verifier"
+version = "1.1.0"

data/tracks/rust/exercises/isbn-verifier/README.md

@@ -0,0 +1,74 @@
+# Isbn Verifier
+
+Check if a given ISBN-10 is valid.
+
+## Functionality
+
+Given an unknown string the program should check if the provided string is a valid ISBN-10.
+Putting this into place requires some thinking about preprocessing/parsing of the string prior to calculating the check digit for the ISBN.
+
+The program should allow for ISBN-10 without the separating dashes to be verified as well.
+
+## ISBN
+
+Let's take a random ISBN-10 number, say `3-598-21508-8` for this.
+The first digit block indicates the group where the ISBN belongs. Groups can consist of shared languages, geographic regions or countries. The leading '3' signals this ISBN is from a german speaking country.
+The following number block is to identify the publisher. Since this is a three digit publisher number there is a 5 digit title number for this book.
+The last digit in the ISBN is the check digit which is used to detect read errors.
+
+The first 9 digits in the ISBN have to be between 0 and 9.
+The check digit can additionally be an 'X' to allow 10 to be a valid check digit as well.
+
+A valid ISBN-10 is calculated with this formula `(x1 * 10 + x2 * 9 + x3 * 8 + x4 * 7 + x5 * 6 + x6 * 5 + x7 * 4 + x8 * 3 + x9 * 2 + x10 * 1) mod 11 == 0`
+So for our example ISBN this means:
+(3 * 10 + 5 * 9 + 9 * 8 + 8 * 7 + 2 * 6 + 1 * 5 + 5 * 4 + 0 * 3 + 8 * 2 + 8 * 1) mod 11 = 0
+
+Which proves that the ISBN is valid.
+
+## Caveats
+
+Converting from string to number can be tricky in certain languages.
+It's getting even trickier since the check-digit of an ISBN-10 can be 'X'.
+
+## Bonus tasks
+
+* Generate a valid ISBN-13 from the input ISBN-10 (and maybe verify it again with a derived verifier)
+
+* Generate valid ISBN, maybe even from a given starting ISBN
+## Rust Installation
+
+Refer to the [exercism help page][help-page] for Rust installation and learning
+resources.
+
+## Writing the Code
+
+Execute the tests with:
+
+```bash
+$ 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.
+
+Make sure to read the [Crates and Modules](https://doc.rust-lang.org/stable/book/crates-and-modules.html) chapter if you
+haven't already, it will help you with organizing your files.
+
+## Feedback, Issues, Pull Requests
+
+The [exercism/rust](https://github.com/exercism/rust) repository on GitHub is the home for all of the Rust exercises. If you have feedback about an exercise, or want to help implement new exercises, head over there and create an issue. Members of the [rust track team](https://github.com/orgs/exercism/teams/rust) are happy to help!
+
+If you want to know more about Exercism, take a look at the [contribution guide](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/README.md).
+
+[help-page]: http://exercism.io/languages/rust
+[crates-and-modules]: http://doc.rust-lang.org/stable/book/crates-and-modules.html
+
+## Source
+
+Converting a string into a number and some basic processing utilizing a relatable real world example. [https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation](https://en.wikipedia.org/wiki/International_Standard_Book_Number#ISBN-10_check_digit_calculation)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

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

@@ -0,0 +1,44 @@
+/// An ISBN type
+#[derive(PartialEq, Eq)]
+enum IsbnType {
+    Isbn10,
+    Isbn13,
+}
+
+/// 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)
+}
+
+/// 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)
+}
+
+/// Determines whether the supplied string is a valid ISBN number
+pub fn is_valid_isbn(isbn: &str) -> bool {
+    let isbn_type = match isbn.len() {
+        10 => IsbnType::Isbn10,
+        13 => IsbnType::Isbn13,
+        _ => return false,
+    };
+
+    let mut checksum = 0;
+    let mut coefficient = 10;
+    for (position, c) in isbn.char_indices() {
+        let digit_value = match c {
+            '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,
+        };
+
+        checksum += coefficient * digit_value;
+        coefficient -= 1;
+    }
+
+    checksum % 11 == 0
+}

data/tracks/rust/exercises/isbn-verifier/src/lib.rs

@@ -0,0 +1,4 @@
+/// Determines whether the supplied string is a valid ISBN number
+pub fn is_valid_isbn(_isbn: &str) -> bool {
+    unimplemented!();
+}

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

@@ -0,0 +1,83 @@
+extern crate isbn_verifier;
+
+use isbn_verifier::is_valid_isbn;
+
+#[test]
+fn test_valid() {
+    assert!(is_valid_isbn("3-598-21508-8"));
+}
+
+#[test]
+#[ignore]
+fn test_invalid_check_digit() {
+    assert!(!is_valid_isbn("3-598-21508-9"));
+}
+
+#[test]
+#[ignore]
+fn test_valid_check_digit_of_10() {
+    assert!(is_valid_isbn("3-598-21507-X"));
+}
+
+#[test]
+#[ignore]
+fn test_invalid_character_as_check_digit() {
+    assert!(!is_valid_isbn("3-598-21507-A"));
+}
+
+#[test]
+#[ignore]
+fn test_invalid_character_in_isbn() {
+    assert!(!is_valid_isbn("3-598-2K507-0"));
+}
+
+#[test]
+#[ignore]
+#[allow(non_snake_case)]
+fn test_invalid_isbn_with_invalid_X() {
+    assert!(!is_valid_isbn("3-598-2X507-9"));
+}
+
+#[test]
+#[ignore]
+fn test_valid_isbn_without_dashes() {
+    assert!(is_valid_isbn("3598215088"));
+}
+
+#[test]
+#[ignore]
+#[allow(non_snake_case)]
+fn test_valid_isbn_without_dashes_and_X_as_check() {
+    assert!(is_valid_isbn("359821507X"));
+}
+
+#[test]
+#[ignore]
+fn test_invalid_isbn_without_dashes_and_no_check_digit() {
+    assert!(!is_valid_isbn("359821507"));
+}
+
+#[test]
+#[ignore]
+fn test_invalid_isbn_without_dashes_and_too_long() {
+    assert!(!is_valid_isbn("3598215078X"));
+}
+
+#[test]
+#[ignore]
+fn test_invalid_isbn_without_check_digit() {
+    assert!(!is_valid_isbn("3-598-21507"));
+}
+
+#[test]
+#[ignore]
+fn test_invalid_isbn_too_long() {
+    assert!(!is_valid_isbn("3-598-21507-XX"));
+}
+
+#[test]
+#[ignore]
+#[allow(non_snake_case)]
+fn test_invalid_isbn_with_check_digit_X_instead_of_0() {
+    assert!(!is_valid_isbn("3-598-21515-X"));
+}

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

@@ -32,7 +32,7 @@ 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.
 
-Make sure to read the [Crates and Modules](https://doc.rust-lang.org/stable/book/crates-and-modules.html) chapter if you
+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.
 
 ## Feedback, Issues, Pull Requests
@@ -42,7 +42,8 @@ The [exercism/rust](https://github.com/exercism/rust) repository on GitHub is th
 If you want to know more about Exercism, take a look at the [contribution guide](https://github.com/exercism/docs/blob/master/contributing-to-language-tracks/README.md).
 
 [help-page]: http://exercism.io/languages/rust
-[crates-and-modules]: http://doc.rust-lang.org/stable/book/crates-and-modules.html
+[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
 
 ## Source
 

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

@@ -4,7 +4,7 @@ Given a year, report if it is a leap year.
 
 The tricky thing here is that a leap year in the Gregorian calendar occurs:
 
-```plain
+```text
 on every year that is evenly divisible by 4
   except every year that is evenly divisible by 100
     unless the year is also evenly divisible by 400

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

@@ -18,27 +18,27 @@ are disallowed.
 
 ## Example 1: valid credit card number
 
-```
+```text
 4539 1488 0343 6467
 ```
 
 The first step of the Luhn algorithm is to double every second digit,
 starting from the right. We will be doubling
 
-```
+```text
 4_3_ 1_8_ 0_4_ 6_6_
 ```
 
 If doubling the number results in a number greater than 9 then subtract 9
 from the product. The results of our doubling:
 
-```
+```text
 8569 2478 0383 3437
 ```
 
 Then sum all of the digits:
 
-```
+```text
 8+5+6+9+2+4+7+8+0+3+8+3+3+4+3+7 = 80
 ```
 
@@ -46,19 +46,19 @@ If the sum is evenly divisible by 10, then the number is valid. This number is v
 
 ## Example 2: invalid credit card number
 
-```
+```text
 8273 1232 7352 0569
 ```
 
 Double the second digits, starting from the right
 
-```
+```text
 7253 2262 5312 0539
 ```
 
 Sum the digits
 
-```
+```text
 7+2+5+3+2+2+6+2+5+3+1+2+0+5+3+9 = 57
 ```
 

data/tracks/rust/exercises/nucleotide-count/README.md

@@ -1,30 +1,16 @@
 # Nucleotide Count
 
-Given a DNA string, compute how many times each nucleotide occurs in the string.
+Given a single stranded DNA string, compute how many times each nucleotide occurs in the string.
 
-DNA is represented by an alphabet of the following symbols: 'A', 'C',
-'G', and 'T'.
-
-Each symbol represents a nucleotide, which is a fancy name for the
-particular molecules that happen to make up a large part of DNA.
-
-Shortest intro to biochemistry EVAR:
+The genetic language of every living thing on the planet is DNA. 
+DNA is a large molecule that is built from an extremely long sequence of individual elements called nucleotides. 
+4 types exist in DNA and these differ only slightly and can be represented as the following symbols: 'A' for adenine, 'C' for cytosine, 'G' for guanine, and 'T' thymine.
 
+Here is an analogy:
 - twigs are to birds nests as
-- nucleotides are to DNA and RNA as
-- amino acids are to proteins as
-- sugar is to starch as
-- oh crap lipids
-
-I'm not going to talk about lipids because they're crazy complex.
-
-So back to nucleotides.
-
-DNA contains four types of them: adenine (`A`), cytosine (`C`), guanine
-(`G`), and thymine (`T`).
-
-RNA contains a slightly different set of nucleotides, but we don't care
-about that for now.
+- nucleotides are to DNA as
+- legos are to lego houses as
+- words are to sentences as...
 
 ## Rust Installation