trackler 2.2.1.0 → 2.2.1.1

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

@@ -0,0 +1,5 @@
+use std::collections::HashMap;
+
+pub fn solve(puzzle: &str) -> Option<HashMap<char, u8>> {
+    unimplemented!()
+}

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

@@ -0,0 +1,23 @@
+pub type Value = i32;
+pub type ForthResult = Result<(), Error>;
+
+pub struct Forth;
+
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    DivisionByZero,
+    StackUnderflow,
+    UnknownWord,
+    InvalidWord,
+}
+
+impl Forth {
+    pub fn new() -> Forth {
+    }
+
+    pub fn stack(&self) -> Vec<Value> {
+    }
+
+    pub fn eval(&mut self, input: &str) -> ForthResult {
+    }
+}

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

@@ -0,0 +1,7 @@
+extern crate chrono;
+use chrono::*;
+
+// Returns a Utc DateTime one billion seconds after start.
+pub fn after(start: DateTime<Utc>) -> DateTime<Utc> {
+    unimplemented!()
+}

data/tracks/rust/exercises/grade-school/src/lib.rs

@@ -0,0 +1,26 @@
+#[allow(unused_variables)]
+
+pub struct School {
+}
+
+impl School {
+    pub fn new() -> School {
+        unimplemented!()
+    }
+
+    pub fn add(&mut self, grade: u32, student: &str) {
+        unimplemented!()
+    }
+
+    pub fn grades(&self) -> Vec<u32> {
+        unimplemented!()
+    }
+
+    // If grade returned an `Option<&Vec<String>>`,
+    // the internal implementation would be forced to keep a `Vec<String>` to lend out.
+    // By returning an owned vector instead,
+    // the internal implementation is free to use whatever it chooses.
+    pub fn grade(&self, grade: u32) -> Option<Vec<String>> {
+        unimplemented!()
+    }
+}

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

@@ -0,0 +1,7 @@
+pub fn square(s: u32) -> u64 {
+    unimplemented!();
+}
+
+pub fn total() -> u64 {
+    unimplemented!();
+}

data/tracks/rust/exercises/hello-world/src/lib.rs

@@ -0,0 +1,5 @@
+// The &'static here means the return type has a static lifetime.
+// This is a Rust feature that you don't need to worry about now.
+pub fn hello() -> &'static str {
+    "Goodbye, World!"
+}

data/tracks/rust/exercises/ocr-numbers/src/lib.rs

@@ -0,0 +1,7 @@
+// The code below is a stub. Just enough to satisfy the compiler.
+// In order to pass the tests you can add-to or change any of this code.
+
+#[allow(unused_variables)]
+pub fn convert(input: &str) -> Result<String, ()> {
+    unimplemented!();
+}

data/tracks/rust/exercises/pascals-triangle/src/lib.rs

@@ -0,0 +1,11 @@
+pub struct PascalsTriangle;
+
+impl PascalsTriangle {
+    pub fn new(row_count: u32) -> Self {
+        unimplemented!();
+    }
+
+    pub fn rows(&self) -> Vec<Vec<u32>> {
+        unimplemented!();
+    }
+}

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

@@ -0,0 +1,89 @@
+#[allow(unused_variables)]
+
+// Because these are passed without & to some functions,
+// it will probably be necessary for these two types to be Copy.
+pub type CellID = ();
+pub type CallbackID = ();
+
+pub struct Reactor<T> {
+    // Just so that the compiler doesn't complain about an unused type parameter.
+    // You probably want to delete this field.
+    dummy: T,
+}
+
+// You are guaranteed that Reactor will only be tested against types that are Copy + PartialEq.
+impl <T: Copy + PartialEq> Reactor<T> {
+    pub fn new() -> Self {
+        unimplemented!()
+    }
+
+    // Creates an input cell with the specified initial value, returning its ID.
+    pub fn create_input(&mut self, initial: T) -> CellID {
+        unimplemented!()
+    }
+
+    // Creates a compute cell with the specified dependencies and compute function.
+    // The compute function is expected to take in its arguments in the same order as specified in
+    // `dependencies`.
+    // You do not need to reject compute functions that expect more arguments than there are
+    // dependencies (how would you check for this, anyway?).
+    //
+    // Return an Err (and you can change the error type) if any dependency doesn't exist.
+    //
+    // Notice that there is no way to *remove* a cell.
+    // This means that you may assume, without checking, that if the dependencies exist at creation
+    // time they will continue to exist as long as the Reactor exists.
+    pub fn create_compute<F: Fn(&[T]) -> T>(&mut self, dependencies: &[CellID], compute_func: F) -> Result<CellID, ()> {
+        unimplemented!()
+    }
+
+    // Retrieves the current value of the cell, or None if the cell does not exist.
+    //
+    // You may wonder whether it is possible to implement `get(&self, id: CellID) -> Option<&Cell>`
+    // and have a `value(&self)` method on `Cell`.
+    //
+    // It turns out this introduces a significant amount of extra complexity to this exercise.
+    // We chose not to cover this here, since this exercise is probably enough work as-is.
+    pub fn value(&self, id: CellID) -> Option<T> {
+        unimplemented!()
+    }
+
+    // Sets the value of the specified input cell.
+    //
+    // Return an Err (and you can change the error type) if the cell does not exist, or the
+    // specified cell is a compute cell, since compute cells cannot have their values directly set.
+    //
+    // Similarly, you may wonder about `get_mut(&mut self, id: CellID) -> Option<&mut Cell>`, with
+    // a `set_value(&mut self, new_value: T)` method on `Cell`.
+    //
+    // As before, that turned out to add too much extra complexity.
+    pub fn set_value(&mut self, id: CellID, new_value: T) -> Result<(), ()> {
+        unimplemented!()
+    }
+
+    // Adds a callback to the specified compute cell.
+    //
+    // Return an Err (and you can change the error type) if the cell does not exist.
+    //
+    // Callbacks on input cells will not be tested.
+    //
+    // The semantics of callbacks (as will be tested):
+    // For a single set_value call, each compute cell's callbacks should each be called:
+    // * Zero times if the compute cell's value did not change as a result of the set_value call.
+    // * Exactly once if the compute cell's value changed as a result of the set_value call.
+    //   The value passed to the callback should be the final value of the compute cell after the
+    //   set_value call.
+    pub fn add_callback<F: FnMut(T) -> ()>(&mut self, id: CellID, callback: F) -> Result<CallbackID, ()> {
+        unimplemented!()
+    }
+
+    // Removes the specified callback, using an ID returned from add_callback.
+    //
+    // Return an Err (and you can change the error type) if either the cell or callback
+    // does not exist.
+    //
+    // A removed callback should no longer be called.
+    pub fn remove_callback(&mut self, cell: CellID, callback: CallbackID) -> Result<(), ()> {
+        unimplemented!()
+    }
+}

data/tracks/rust/exercises/robot-simulator/src/lib.rs

@@ -0,0 +1,44 @@
+// The code below is a stub. Just enough to satisfy the compiler.
+// In order to pass the tests you can add-to or change any of this code.
+
+#[derive(PartialEq, Debug)]
+pub enum Direction {
+    North,
+    East,
+    South,
+    West,
+}
+
+pub struct Robot;
+
+impl Robot {
+    #[allow(unused_variables)]
+    pub fn new(x: isize, y: isize, d: Direction) -> Self {
+        unimplemented!()
+    }
+
+    pub fn turn_right(self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn turn_left(self) -> Self {
+        unimplemented!()
+    }
+
+    pub fn advance(self) -> Self {
+        unimplemented!()
+    }
+
+    #[allow(unused_variables)]
+    pub fn instructions(self, instructions: &str) -> Self {
+        unimplemented!()
+    }
+
+    pub fn position(&self) -> (isize, isize) {
+        unimplemented!()
+    }
+
+    pub fn direction(&self) -> &Direction {
+        unimplemented!()
+    }
+}

data/tracks/rust/exercises/say/.meta/hints.md

@@ -0,0 +1,19 @@
+
+## Rust Specific Exercise Notes
+
+This is slightly changed in the Rust version, compared to other
+language versions of this exercise.  Instead of requiring you to return
+errors for out of range, we are using Rust's strong type system to limit
+input.  It is much easier to make a function deal with all valid inputs,
+rather than requiring the user of your module to handle errors.
+
+There is a -1 version of a test case, but it is commented out.
+If your function is implemented properly, the -1 test case should not compile.
+
+Adding 'and' into number text has not been implemented in test cases.
+
+### Extension
+
+Add capability of converting up to the max value for u64: 9,223,372,036,854,775,807.
+
+For hints at the output this should have, look at the last test case.

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

@@ -0,0 +1,4 @@
+[root]
+name = "say"
+version = "1.0.0"
+

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

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

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

@@ -0,0 +1,122 @@
+# Say
+
+Given a number from 0 to 999,999,999,999, spell out that number in English.
+
+## Step 1
+
+Handle the basic case of 0 through 99.
+
+If the input to the program is `22`, then the output should be
+`'twenty-two'`.
+
+Your program should complain loudly if given a number outside the
+blessed range.
+
+Some good test cases for this program are:
+
+- 0
+- 14
+- 50
+- 98
+- -1
+- 100
+
+### Extension
+
+If you're on a Mac, shell out to Mac OS X's `say` program to talk out
+loud.
+
+## Step 2
+
+Implement breaking a number up into chunks of thousands.
+
+So `1234567890` should yield a list like 1, 234, 567, and 890, while the
+far simpler `1000` should yield just 1 and 0.
+
+The program must also report any values that are out of range.
+
+## Step 3
+
+Now handle inserting the appropriate scale word between those chunks.
+
+So `1234567890` should yield `'1 billion 234 million 567 thousand 890'`
+
+The program must also report any values that are out of range.  It's
+fine to stop at "trillion".
+
+## Step 4
+
+Put it all together to get nothing but plain English.
+
+`12345` should give `twelve thousand three hundred forty-five`.
+
+The program must also report any values that are out of range.
+
+### Extensions
+
+Use _and_ (correctly) when spelling out the number in English:
+
+- 14 becomes "fourteen".
+- 100 becomes "one hundred".
+- 120 becomes "one hundred and twenty".
+- 1002 becomes "one thousand and two".
+- 1323 becomes "one thousand three hundred and twenty-three".
+
+
+## Rust Specific Exercise Notes
+
+This is slightly changed in the Rust version, compared to other
+language versions of this exercise.  Instead of requiring you to return
+errors for out of range, we are using Rust's strong type system to limit
+input.  It is much easier to make a function deal with all valid inputs,
+rather than requiring the user of your module to handle errors.
+
+There is a -1 version of a test case, but it is commented out.
+If your function is implemented properly, the -1 test case should not compile.
+
+Adding 'and' into number text has not been implemented in test cases.
+
+### Extension
+
+Add capability of converting up to the max value for u64: 9,223,372,036,854,775,807.
+
+For hints at the output this should have, look at the last test case.
+
+
+## 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
+
+A variation on JavaRanch CattleDrive, exercise 4a [http://www.javaranch.com/say.jsp](http://www.javaranch.com/say.jsp)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.