trackler 2.2.1.45 → 2.2.1.46

data/tracks/python/exercises/rail-fence-cipher/rail_fence_cipher_test.py

@@ -3,7 +3,7 @@ import unittest
 from rail_fence_cipher import encode, decode
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.1
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.1
 
 class RailFenceTests(unittest.TestCase):
     def test_encode_with_two_rails(self):

data/tracks/python/exercises/rectangles/rectangles_test.py

@@ -3,7 +3,7 @@ import unittest
 from rectangles import count
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class WordTest(unittest.TestCase):
     def test_no_rows(self):

data/tracks/python/exercises/robot-simulator/robot_simulator.py

@@ -1,3 +1,11 @@
+# Globals for the bearings
+# Change the values as you see fit
+EAST = None
+NORTH = None
+WEST = None
+SOUTH = None
+
+
 class Robot(object):
-    def __init__(self):
+    def __init__(self, bearing=NORTH, x=0, y=0):
         pass

data/tracks/python/exercises/roman-numerals/roman_numerals_test.py

@@ -3,7 +3,7 @@ import unittest
 import roman_numerals
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class RomanTest(unittest.TestCase):
     numerals = {

data/tracks/python/exercises/run-length-encoding/run_length_encoding_test.py

@@ -3,7 +3,7 @@ import unittest
 from run_length_encoding import encode, decode
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class WordCountTests(unittest.TestCase):
     def test_encode_empty_string(self):

data/tracks/python/exercises/say/say_test.py

@@ -3,7 +3,7 @@ import unittest
 from say import say
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class SayTest(unittest.TestCase):
     def test_zero(self):

data/tracks/python/exercises/scrabble-score/scrabble_score_test.py

@@ -3,7 +3,7 @@ import unittest
 from scrabble_score import score
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class WordTest(unittest.TestCase):
     def test_lowercase_letter(self):

data/tracks/python/exercises/series/series.py

@@ -1,2 +1,2 @@
-def slices():
+def slices(series, length):
     pass

data/tracks/python/exercises/sieve/sieve_test.py

@@ -3,7 +3,7 @@ import unittest
 from sieve import sieve
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class SieveTest(unittest.TestCase):
     def test_no_primes_under_two(self):

data/tracks/python/exercises/sublist/sublist_test.py

@@ -3,7 +3,7 @@ import unittest
 from sublist import check_lists, SUBLIST, SUPERLIST, EQUAL, UNEQUAL
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class SublistTest(unittest.TestCase):
     def test_unique_return_values(self):

data/tracks/python/exercises/tournament/tournament_test.py

@@ -3,7 +3,7 @@ import unittest
 from tournament import tally
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.3.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.3.0
 
 class TestTournament(unittest.TestCase):
     def test_just_the_header_if_no_input(self):

data/tracks/python/exercises/transpose/transpose_test.py

@@ -2,7 +2,7 @@ import unittest
 from transpose import transpose
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class TransposeTests(unittest.TestCase):
     def test_empty_string(self):

data/tracks/python/exercises/two-bucket/example.py

@@ -1,59 +1,54 @@
 '''
-The solution follows the following approach:
-
-->Pour from first bucket to second
-  1.Fill the first bucket and empty it into the second bucket.
-  2.If first bucket is empty fill it.
-  3.If the second bucket is full empty it.
-  4.Repeat steps 1,2,3 till either the first or second bucket contains the
-    desired amount.
-
-->Pour from first bucket to second
-  1.Fill the second bucket and empty it into the first bucket.
-  2.If second bucket is empty fill it.
-  3.If the firts bucket is full empty it.
-  4.Repeat steps 1,2,3 till either the first or second bucket contains the
-    desired amount.
+    This solution implements a breadth-first search of the graph
+    of possible valid states for the two buckets until it reaches a state
+    in which one of the two buckets contains the goal amount
 '''
 
 
 def two_bucket(bucket_one_cap, bucket_two_cap, desired_liters, first):
-    if first == "one":
-        moves = 0
-        bucket_one, bucket_two = 0, 0
-        while(True):
-            if bucket_one == 0:
-                moves += 1
-                bucket_one = bucket_one_cap
-            elif bucket_two == bucket_two_cap:
-                moves += 1
-                bucket_two = 0
-            else:
-                moves += 1
-                measure = min(bucket_one, bucket_two_cap - bucket_two)
-                bucket_one -= measure
-                bucket_two += measure
-            if bucket_one == desired_liters:
-                return (moves, "one", bucket_two)
-            elif bucket_two == desired_liters:
-                return (moves, "two", bucket_one)
-
-    elif first == "two":
-        moves = 0
-        bucket_one, bucket_two = 0, 0
-        while(True):
-            if bucket_two == 0:
-                moves += 1
-                bucket_two = bucket_two_cap
-            elif bucket_one == bucket_one_cap:
-                moves += 1
-                bucket_one = 0
-            else:
-                moves += 1
-                measure = min(bucket_two, bucket_one_cap - bucket_one)
-                bucket_two -= measure
-                bucket_one += measure
-            if bucket_one == desired_liters:
-                return (moves, "one", bucket_two)
-            elif bucket_two == desired_liters:
-                return (moves, "two", bucket_one)
+    sizes = [bucket_one_cap, bucket_two_cap]
+    goal = desired_liters
+    goalIndex = 0 if first == 'one' else 1
+
+    def empty(buckets, i):
+        return [0, buckets[1]] if i == 0 else [buckets[0], 0]
+
+    def fill(buckets, i):
+        return [sizes[0], buckets[1]] if i == 0 else [buckets[0], sizes[1]]
+
+    def consolidate(buckets, i):
+        amount = min(buckets[1 - i], sizes[i] - buckets[i])
+        target = buckets[i] + amount
+        src = buckets[1 - i] - amount
+        return [target, src] if i == 0 else [src, target]
+
+    def bucket_str(buckets):
+        return '{},{}'.format(*buckets)
+
+    invalid = [0, 0]
+    invalid[1 - goalIndex] = sizes[1 - goalIndex]
+    invalidStr = bucket_str(invalid)
+    buckets = [0, 0]
+    buckets[goalIndex] = sizes[goalIndex]
+    toVisit = []
+    visited = set()
+    count = 1
+    while goal not in buckets:
+        key = bucket_str(buckets)
+        if key != invalidStr and key not in visited:
+            visited.add(key)
+            nc = count + 1
+            for i in range(2):
+                if buckets[i] != 0:
+                    toVisit.append((empty(buckets, i), nc))
+                if buckets[i] != sizes[i]:
+                    toVisit.append((fill(buckets, i), nc))
+                    toVisit.append((consolidate(buckets, i), nc))
+        if not any(toVisit):
+            raise ValueError('No more moves!')
+        buckets, count = toVisit.pop(0)
+
+    goalIndex = buckets.index(goal)
+    goalBucket = ['one', 'two'][goalIndex]
+    otherBucket = buckets[1 - goalIndex]
+    return (count, goalBucket, otherBucket)

data/tracks/python/exercises/two-bucket/two_bucket_test.py

@@ -25,7 +25,7 @@ class TwoBucketTest(unittest.TestCase):
         self.assertEqual(two_bucket(1, 3, 3, "two"), (1, "two", 0))
 
     def test_bucket_one_size_2_bucket_two_size_3_start_with_bucket_one(self):
-        self.assertEqual(two_bucket(2, 3, 3, "one"), (4, "two", 1))
+        self.assertEqual(two_bucket(2, 3, 3, "one"), (2, "two", 2))
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/variable-length-quantity/variable_length_quantity_test.py

@@ -3,7 +3,7 @@ import unittest
 from variable_length_quantity import encode, decode
 
 
-# test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
 
 class TestVLQ(unittest.TestCase):
     def test_zero(self):

data/tracks/rust/config.json

@@ -143,6 +143,16 @@
         "mathematics"
       ]
     },
+    {
+      "uuid": "f9afd650-8103-4373-a284-fa4ecfee7207",
+      "slug": "collatz-conjecture",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "error handling with Result<T, E>"
+      ]
+    },
     {
       "uuid": "4ba35adb-230b-49a6-adc9-2d3cd9a4c538",
       "slug": "say",
@@ -647,6 +657,20 @@
          "traits"
       ]
     },
+    {
+      "uuid": "7cefed7c-37f4-46c5-9a45-68fe4d0fb326",
+      "slug": "decimal",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 6,
+      "topics": [
+        "struct",
+        "traits",
+        "string parsing",
+        "bigint",
+        "external crates (optional)"
+      ]
+    },
     {
       "uuid": "f3172997-91f5-4941-a76e-91c4b8eed401",
       "slug": "anagram",

data/tracks/rust/exercises/collatz-conjecture/Cargo.lock

@@ -0,0 +1,4 @@
+[root]
+name = "collatz_conjecture"
+version = "1.1.1"
+

data/tracks/rust/exercises/collatz-conjecture/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "collatz_conjecture"
+version = "1.1.1"

data/tracks/rust/exercises/collatz-conjecture/README.md

@@ -0,0 +1,65 @@
+# Collatz Conjecture
+
+The Collatz Conjecture or 3x+1 problem can be summarized as follows:
+
+Take any positive integer n. If n is even, divide n by 2 to get n / 2. If n is
+odd, multiply n by 3 and add 1 to get 3n + 1. Repeat the process indefinitely.
+The conjecture states that no matter which number you start with, you will
+always reach 1 eventually.
+
+Given a number n, return the number of steps required to reach 1.
+
+## Examples
+
+Starting with n = 12, the steps would be as follows:
+
+0. 12
+1. 6
+2. 3
+3. 10
+4. 5
+5. 16
+6. 8
+7. 4
+8. 2
+9. 1
+
+Resulting in 9 steps. So for input n = 12, the return value would be 9.
+
+## 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
+
+An unsolved problem in mathematics named after mathematician Lothar Collatz [https://en.wikipedia.org/wiki/3x_%2B_1_problem](https://en.wikipedia.org/wiki/3x_%2B_1_problem)
+
+## 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/collatz-conjecture/example.rs

@@ -0,0 +1,19 @@
+pub fn collatz_positive(n: u64) -> u64 {
+    if n == 1 {
+        0
+    } else  {
+        1 + match n % 2 {
+            0 => collatz_positive(n / 2),
+            _ => collatz_positive(n * 3 + 1)
+        }
+    }
+}
+
+// return Ok(x) where x is the number of steps required to reach 1
+pub fn collatz(n: u64) -> Result<u64, &'static str> {
+    if n < 1 {
+        Err("Only positive numbers are allowed")
+    } else {
+        Ok(collatz_positive(n))
+    }
+}

data/tracks/rust/exercises/collatz-conjecture/src/lib.rs

@@ -0,0 +1,4 @@
+// return Ok(x) where x is the number of steps required to reach 1
+pub fn collatz(n: u64) -> Result<u64, &'static str> {
+
+}

data/tracks/rust/exercises/collatz-conjecture/tests/collatz-conjecture.rs

@@ -0,0 +1,32 @@
+extern crate collatz_conjecture;
+
+use collatz_conjecture::*;
+
+#[test]
+fn test_1() {
+    assert_eq!(Ok(0), collatz(1));
+}
+
+#[test]
+#[ignore]
+fn test_16() {
+    assert_eq!(Ok(4), collatz(16));
+}
+
+#[test]
+#[ignore]
+fn test_12() {
+    assert_eq!(Ok(9), collatz(12));
+}
+
+#[test]
+#[ignore]
+fn test_1000000() {
+    assert_eq!(Ok(152), collatz(1000000));
+}
+
+#[test]
+#[ignore]
+fn test_0() {
+    assert!(collatz(0).is_err());
+}

data/tracks/rust/exercises/decimal/.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/decimal/.meta/description.md

@@ -0,0 +1,19 @@
+Implement an arbitrary-precision `Decimal` class.
+
+Floating point numbers are the most common representation of non-integer real numbers in computing, and they're a common standard defined by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754). They're very flexible and versatile, but they do have some limitations. Famously, in floating point arithmetic, [`0.1 + 0.2 != 0.3`](http://0.30000000000000004.com/).
+
+The solution to this issue is to find another, lossless way to model arbitrary-precision non-integer reals. This may be less efficient in terms of memory or processing speed than floating point numbers; the goal is to provide exact results.
+
+Despite `Decimal` being a custom type, we should still be able to treat them as numbers: the `==`, `<`, `>`, `+`, `-`, and `*` operators should all work as expected on Decimals. For expediency, you are not required to implement division, as arbitrary-precision division can very quickly get out of hand. (How do you represent arbitrary-precision `1/3`?)
+
+In Rust, the way to get these operations on custom types is to implement the relevant traits for your custom object. In particular, you'll need to implement at least `PartialEq`, `PartialOrd`, `Add`, `Sub`, and `Mul`. Strictly speaking, given that the decimal numbers form a total ordering, you should also implement `Eq` and `Ord`, though those traits are not checked for by these tests.
+
+# Note
+
+It would be very easy to implement this exercise by using the [bigdecimal](https://crates.io/crates/bigdecimal) crate. Don't do that; implement this yourself.
+
+# Hints
+
+- Instead of implementing arbitrary-precision arithmetic from scratch, consider building your type on top of the [num_bigint](https://crates.io/crates/num-bigint) crate.
+- You might be able to [derive](https://doc.rust-lang.org/book/first-edition/traits.html#deriving) some of the required traits.
+- `Decimal` is assumed to be a signed type. You do not have to create a separate unsigned type, though you may do so as an implementation detail if you so choose.