trackler 2.0.8.6 → 2.0.8.7

data/tracks/julia/config.json

@@ -34,6 +34,16 @@
         "generators"
       ]
     },
+    {
+      "slug": "pascals-triangle",
+      "difficulty": 1,
+      "topics": [
+        "control-flow (conditionals)",
+        "integers",
+        "mathematics",
+        "exceptions"
+      ]
+    },
     {
       "slug": "nucleotide-count",
       "difficulty": 1,
@@ -147,6 +157,15 @@
         "filtering"
       ]
     },
+    {
+      "slug": "etl",
+      "difficulty": 2,
+      "topics": [
+        "arrays",
+        "strings",
+        "sorting"
+      ]
+    },
     {
       "slug": "bob",
       "difficulty": 2,

data/tracks/julia/exercises/etl/etl.jl

@@ -0,0 +1,4 @@
+function transform(input::AbstractArray)
+
+end
+

data/tracks/julia/exercises/etl/example.jl

@@ -0,0 +1,11 @@
+function transform(input::Dict)
+    output = []
+    for i = input
+        for j = map(lowercase, i[2])
+            pair = (j, i[1])
+            push!(output, pair)
+        end
+    end
+    Dict(output)
+end
+

data/tracks/julia/exercises/etl/runtests.jl

@@ -0,0 +1,36 @@
+using Base.Test
+
+include("etl.jl")
+
+@testset "a single letter" begin
+    input = Dict(1=>['A'])
+    output = Dict('a'=>1)
+    @test transform(input) == output
+end
+
+@testset "single score with multiple letters" begin
+    input = Dict(1=>['A', 'E', 'I', 'O', 'U'])
+    output = Dict('a'=>1, 'e'=>1, 'i'=>1, 'o'=>1, 'u'=>1)
+    @test transform(input) == output
+end
+
+@testset "multiple scores with multiple letters" begin
+    input = Dict(1=>['A', 'E'], 2=>['D', 'G'])
+    output = Dict('g'=>2, 'e'=>1, 'a'=>1, 'd'=>2)
+    @test transform(input) == output
+end
+
+@testset "multiple scores with differing numbers of letters" begin
+    input = Dict(1=>[ 'A', 'E', 'I', 'O', 'U', 'L', 'N', 'R', 'S', 'T' ],
+                 2=>[ 'D', 'G' ], 3=>[ 'B', 'C', 'M', 'P' ],
+                 4=>[ 'F', 'H', 'V', 'W', 'Y' ], 5=>[ 'K' ],
+                 8=>[ 'J', 'X' ], 10=>[ 'Q', 'Z' ])
+    output = Dict('a'=>1, 'b'=>3,  'c'=>3, 'd'=>2, 'e'=>1,
+                  'f'=>4, 'g'=>2,  'h'=>4, 'i'=>1, 'j'=>8,
+                  'k'=>5, 'l'=>1,  'm'=>3, 'n'=>1, 'o'=>1,
+                  'p'=>3, 'q'=>10, 'r'=>1, 's'=>1, 't'=>1,
+                  'u'=>1, 'v'=>4,  'w'=>4, 'x'=>8, 'y'=>4,
+                  'z'=>10)
+    @test transform(input) == output
+end
+

data/tracks/julia/exercises/pascals-triangle/example.jl

@@ -0,0 +1 @@
+triangle(n::Int) = n >= 0 ? [[binomial(i, j) for j in 0:i] for i in 0:n-1] : throw(DomainError())

data/tracks/julia/exercises/pascals-triangle/pascals-triangle.jl

@@ -0,0 +1,3 @@
+function triangle(n::Int)
+
+end

data/tracks/julia/exercises/pascals-triangle/runtests.jl

@@ -0,0 +1,14 @@
+using Base.Test
+
+include("pascals-triangle.jl")
+
+rows = [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]]
+
+@testset "$i row(s)" for i in 1:4
+    @test triangle(i) == rows[1:i]
+end
+
+@testset "special cases" begin
+    @test_throws DomainError triangle(-1)
+    @test isempty(triangle(0))
+end

data/tracks/rust/config.json

@@ -263,6 +263,16 @@
         "stack or recursion"
       ]
     },
+    {
+      "slug": "luhn-from",
+      "difficulty": 4,
+      "topics": [
+        "from trait",
+        "str to digits",
+        "iterators",
+        "higher-order functions"
+      ]
+    },
     {
       "slug": "queen-attack",
       "difficulty": 4,
@@ -298,6 +308,16 @@
         "Default Trait implementation"
       ]
     },
+    {
+      "slug": "luhn-trait",
+      "difficulty": 4,
+      "topics": [
+        "Custom Trait",
+        "str to digits",
+        "iterators",
+        "higher-order functions"
+      ]
+    },
     {
       "slug": "allergies",
       "difficulty": 4,
@@ -381,7 +401,7 @@
       ]
     },
     {
-      "slug": "nucleotide-codons",
+      "slug": "protein-translation",
       "difficulty": 7,
       "topics": [
         "struct",
@@ -468,6 +488,7 @@
     }
   ],
   "deprecated": [
+    "nucleotide-codons",
     "hexadecimal"
   ],
   "ignored": [

data/tracks/rust/exercises/luhn-from/.gitignore

@@ -0,0 +1,7 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

data/tracks/rust/exercises/luhn-from/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "luhn-from"
+version = "0.0.0"

data/tracks/rust/exercises/luhn-from/description.md

@@ -0,0 +1,9 @@
+# Luhn: Using the From Trait
+
+Before doing this exercise you should probably do the original Luhn exercise. If you have not completed Luhn, you can get it by running the command:
+
+> `exercism fetch rust luhn`
+
+In the original Luhn exercise you only validated strings, but the Luhn algorithm can be applied to integers as well.
+
+In this exercise you'll implement the [From trait](https://doc.rust-lang.org/std/convert/trait.From.html) to convert strings, strs and unsigned integers into a Struct that performs the validation.

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

@@ -0,0 +1,62 @@
+pub struct Luhn {
+    digits: Vec<char>,
+}
+
+impl Luhn {
+    pub fn is_valid(&self) -> bool {
+        if self.digits.iter().any(|c| c.is_alphabetic()) || self.digits.iter().count() == 1 {
+            return false;
+        }
+
+        self.digits
+            .iter()
+            .filter_map(|c| c.to_digit(10))
+            .rev()
+            .enumerate()
+            .map(|(index, digit)| if index % 2 == 0 { digit } else { digit * 2 })
+            .map(|digit| if digit > 9 { digit - 9 } else { digit })
+            .sum::<u32>() % 10 == 0
+    }
+}
+
+impl From<String> for Luhn {
+    fn from(s: String) -> Self {
+        Luhn { digits: s.chars().collect() }
+    }
+}
+
+impl<'a> From<&'a str> for Luhn {
+    fn from(s: &'a str) -> Self {
+        Luhn::from(String::from(s))
+    }
+}
+
+impl From<u8> for Luhn {
+    fn from(s: u8) -> Self {
+        Luhn::from(s.to_string())
+    }
+}
+
+impl From<u16> for Luhn {
+    fn from(s: u16) -> Self {
+        Luhn::from(s.to_string())
+    }
+}
+
+impl From<u32> for Luhn {
+    fn from(s: u32) -> Self {
+        Luhn::from(s.to_string())
+    }
+}
+
+impl From<u64> for Luhn {
+    fn from(s: u64) -> Self {
+        Luhn::from(s.to_string())
+    }
+}
+
+impl From<usize> for Luhn {
+    fn from(s: usize) -> Self {
+        Luhn::from(s.to_string())
+    }
+}

data/tracks/rust/exercises/luhn-from/metadata.yml

@@ -0,0 +1,3 @@
+---
+blurb: "Luhn: Using the From Trait"
+source: "The Rust track maintainers, based on the original Luhn exercise"

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

@@ -0,0 +1,101 @@
+extern crate luhn_from;
+
+use luhn_from::*;
+
+#[test]
+fn you_can_validate_from_a_str() {
+    let valid = Luhn::from("046 454 286");
+    let invalid = Luhn::from("046 454 287");
+    assert!(valid.is_valid());
+    assert!(!invalid.is_valid());
+}
+
+#[test]
+#[ignore]
+fn you_can_validate_from_a_string() {
+    let valid = Luhn::from(String::from("046 454 286"));
+    let invalid = Luhn::from(String::from("046 454 287"));
+    assert!(valid.is_valid());
+    assert!(!invalid.is_valid());
+}
+
+#[test]
+#[ignore]
+fn you_can_validate_from_a_u8() {
+    let valid = Luhn::from(240u8);
+    let invalid = Luhn::from(241u8);
+    assert!(valid.is_valid());
+    assert!(!invalid.is_valid());
+}
+
+#[test]
+#[ignore]
+fn you_can_validate_from_a_u16() {
+    let valid = Luhn::from(64_436u16);
+    let invalid = Luhn::from(64_437u16);
+    assert!(valid.is_valid());
+    assert!(!invalid.is_valid());
+}
+
+#[test]
+#[ignore]
+fn you_can_validate_from_a_u32() {
+    let valid = Luhn::from(46_454_286u32);
+    let invalid = Luhn::from(46_454_287u32);
+    assert!(valid.is_valid());
+    assert!(!invalid.is_valid());
+}
+
+#[test]
+#[ignore]
+fn you_can_validate_from_a_u64() {
+    let valid = Luhn::from(8273_1232_7352_0562u64);
+    let invalid = Luhn::from(8273_1232_7352_0569u64);
+    assert!(valid.is_valid());
+    assert!(!invalid.is_valid());
+}
+
+#[test]
+#[ignore]
+fn you_can_validate_from_a_usize() {
+    let valid = Luhn::from(8273_1232_7352_0562usize);
+    let invalid = Luhn::from(8273_1232_7352_0569usize);
+    assert!(valid.is_valid());
+    assert!(!invalid.is_valid());
+}
+
+#[test]
+#[ignore]
+fn single_digit_string_is_invalid() {
+    assert!(!Luhn::from("1").is_valid());
+}
+
+#[test]
+#[ignore]
+fn single_zero_string_is_invalid() {
+    assert!(!Luhn::from("0").is_valid());
+}
+
+#[test]
+#[ignore]
+fn valid_canadian_sin_is_valid() {
+    assert!(Luhn::from("046 454 286").is_valid());
+}
+
+#[test]
+#[ignore]
+fn invalid_canadian_sin_is_invalid() {
+    assert!(!Luhn::from("046 454 287").is_valid());
+}
+
+#[test]
+#[ignore]
+fn invalid_credit_card_is_invalid() {
+    assert!(!Luhn::from("8273 1232 7352 0569").is_valid());
+}
+
+#[test]
+#[ignore]
+fn strings_that_contain_non_digits_are_invalid() {
+    assert!(!Luhn::from("046a 454 286").is_valid());
+}

data/tracks/rust/exercises/luhn-trait/.gitignore

@@ -0,0 +1,7 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

data/tracks/rust/exercises/luhn-trait/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "luhn-trait"
+version = "0.0.0"

data/tracks/rust/exercises/luhn-trait/description.md

@@ -0,0 +1,17 @@
+# Luhn: Using a Custom Trait
+
+Before doing this exercise you should probably do the original Luhn exercise and its successor, "Luhn: Using the From Trait"
+
+To get the original Luhn exercise, run `exercism fetch rust luhn`
+
+To get the "Luhn: Using the From Trait" exercise, run `exercism fetch rust luhn-from`
+
+In the original Luhn exercise you only validated strings, but the Luhn algorithm can be applied to integers as well.
+
+In "Luhn: Using the From Trait" you implemented a From trait, which also required you to create a Luhn struct.
+
+Instead of creating a Struct just to perform the validation, what if you you validated the primitives (i.e, String, u8, etc.) themselves?
+
+In this exercise you'll create and implement a custom [trait](https://doc.rust-lang.org/book/traits.html) that performs the validation.
+
+Note: It is [not idiomatic Rust to implement traits on on primitives](https://doc.rust-lang.org/book/traits.html#rules-for-implementing-traits). In this exercise we're showing something that you _can_ do, not something you _should_ do. If you find yourself implementing traits on primitives, perhaps you have a case of [Primitive Obsession](http://wiki.c2.com/?PrimitiveObsession).

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

@@ -0,0 +1,55 @@
+pub trait Luhn {
+    fn valid_luhn(&self) -> bool;
+}
+
+impl Luhn for String {
+    fn valid_luhn(&self) -> bool {
+        if self.chars().any(|c| c.is_alphabetic()) || self.chars().count() == 1 {
+            return false;
+        }
+
+        self.chars()
+            .filter_map(|c| c.to_digit(10))
+            .rev()
+            .enumerate()
+            .map(|(index, digit)| if index % 2 == 0 { digit } else { digit * 2 })
+            .map(|digit| if digit > 9 { digit - 9 } else { digit })
+            .sum::<u32>() % 10 == 0
+    }
+}
+
+impl<'a> Luhn for &'a str {
+    fn valid_luhn(&self) -> bool {
+        String::from(*self).valid_luhn()
+    }
+}
+
+impl Luhn for u8 {
+    fn valid_luhn(&self) -> bool {
+        self.to_string().valid_luhn()
+    }
+}
+
+impl Luhn for u16 {
+    fn valid_luhn(&self) -> bool {
+        self.to_string().valid_luhn()
+    }
+}
+
+impl Luhn for u32 {
+    fn valid_luhn(&self) -> bool {
+        self.to_string().valid_luhn()
+    }
+}
+
+impl Luhn for u64 {
+    fn valid_luhn(&self) -> bool {
+        self.to_string().valid_luhn()
+    }
+}
+
+impl Luhn for usize {
+    fn valid_luhn(&self) -> bool {
+        self.to_string().valid_luhn()
+    }
+}

data/tracks/rust/exercises/luhn-trait/metadata.yml

@@ -0,0 +1,3 @@
+---
+blurb: "Luhn: Using a Custom Trait"
+source: "The Rust track maintainters, based on the original Luhn exercise"