trackler 2.2.1.48 → 2.2.1.49

data/tracks/python/exercises/simple-cipher/simple_cipher_test.py

@@ -68,8 +68,10 @@ class CipherTest(unittest.TestCase):
                         'All items in the key must be chars and lowercase!')
 
     def test_cipher_wrong_key(self):
-        self.assertRaises(ValueError, Cipher, 'a1cde')
-        self.assertRaises(ValueError, Cipher, 'aBcde')
+        with self.assertRaises(ValueError):
+            Cipher('a1cde')
+        with self.assertRaises(ValueError):
+            Cipher('aBcde')
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/triangle/triangle_test.py

@@ -34,19 +34,24 @@ class TriangleTests(unittest.TestCase):
         self.assertEqual(Triangle(0.4, 0.6, 0.3).kind(), "scalene")
 
     def test_triangles_with_no_size_are_illegal(self):
-        self.assertRaises(TriangleError, Triangle, 0, 0, 0)
+        with self.assertRaises(TriangleError):
+            Triangle(0, 0, 0)
 
     def test_triangles_with_negative_sides_are_illegal(self):
-        self.assertRaises(TriangleError, Triangle, 3, 4, -5)
+        with self.assertRaises(TriangleError):
+            Triangle(3, 4, -5)
 
     def test_triangles_violating_triangle_inequality_are_illegal(self):
-        self.assertRaises(TriangleError, Triangle, 1, 1, 3)
+        with self.assertRaises(TriangleError):
+            Triangle(1, 1, 3)
 
     def test_triangles_violating_triangle_inequality_are_illegal_2(self):
-        self.assertRaises(TriangleError, Triangle, 2, 4, 2)
+        with self.assertRaises(TriangleError):
+            Triangle(2, 4, 2)
 
     def test_triangles_violating_triangle_inequality_are_illegal_3(self):
-        self.assertRaises(TriangleError, Triangle, 7, 3, 2)
+        with self.assertRaises(TriangleError):
+            Triangle(7, 3, 2)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/wordy/wordy_test.py

@@ -49,17 +49,20 @@ class WordyTest(unittest.TestCase):
             calculate("What is -12000 divided by 25 divided by -30?"), 16)
 
     def test_invalid_operation(self):
-        self.assertRaises(ValueError, calculate, "What is 4 xor 7?")
+        with self.assertRaises(ValueError):
+            calculate("What is 4 xor 7?")
 
     def test_missing_operation(self):
-        self.assertRaises(ValueError, calculate, "What is 2 2 minus 3?")
+        with self.assertRaises(ValueError):
+            calculate("What is 2 2 minus 3?")
 
     def test_missing_number(self):
-        self.assertRaises(ValueError, calculate,
-                          "What is 7 plus multiplied by -2?")
+        with self.assertRaises(ValueError):
+            calculate("What is 7 plus multiplied by -2?")
 
     def test_irrelevant_question(self):
-        self.assertRaises(ValueError, calculate, "Which is greater, 3 or 2?")
+        with self.assertRaises(ValueError):
+            calculate("Which is greater, 3 or 2?")
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/zipper/README.md

@@ -0,0 +1,43 @@
+# Zipper
+
+Creating a zipper for a binary tree.
+
+[Zippers](https://en.wikipedia.org/wiki/Zipper_%28data_structure%29) are
+a purely functional way of navigating within a data structure and
+manipulating it.  They essentially contain a data structure and a
+pointer into that data structure (called the focus).
+
+For example given a rose tree (where each node contains a value and a
+list of child nodes) a zipper might support these operations:
+
+- `from_tree` (get a zipper out of a rose tree, the focus is on the root node)
+- `to_tree` (get the rose tree out of the zipper)
+- `value` (get the value of the focus node)
+- `prev` (move the focus to the previous child of the same parent,
+  returns a new zipper)
+- `next` (move the focus to the next child of the same parent, returns a
+  new zipper)
+- `up` (move the focus to the parent, returns a new zipper)
+- `set_value` (set the value of the focus node, returns a new zipper)
+- `insert_before` (insert a new subtree before the focus node, it
+  becomes the `prev` of the focus node, returns a new zipper)
+- `insert_after` (insert a new subtree after the focus node, it becomes
+  the `next` of the focus node, returns a new zipper)
+- `delete` (removes the focus node and all subtrees, focus moves to the
+  `next` node if possible otherwise to the `prev` node if possible,
+  otherwise to the parent node, returns a new zipper)
+
+### Submitting Exercises
+
+Note that, when trying to submit an exercise, make sure the solution is in the `exercism/python/<exerciseName>` directory.
+
+For example, if you're submitting `bob.py` for the Bob exercise, the submit command would be something like `exercism submit <path_to_exercism_dir>/python/bob/bob.py`.
+
+
+For more detailed information about running tests, code style and linting,
+please see the [help page](http://exercism.io/languages/python).
+
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/python/exercises/zipper/example.py

@@ -0,0 +1,41 @@
+class Zipper(object):
+    @staticmethod
+    def from_tree(tree):
+        return Zipper(dict(tree), [])
+
+    def __init__(self, tree, ancestors):
+        self.tree = tree
+        self.ancestors = ancestors
+
+    def value(self):
+        return self.tree['value']
+
+    def set_value(self, value):
+        self.tree['value'] = value
+        return self
+
+    def left(self):
+        if self.tree['left'] is None:
+            return None
+        return Zipper(self.tree['left'], self.ancestors + [self.tree])
+
+    def set_left(self, tree):
+        self.tree['left'] = tree
+        return self
+
+    def right(self):
+        if self.tree['right'] is None:
+            return None
+        return Zipper(self.tree['right'], self.ancestors + [self.tree])
+
+    def set_right(self, tree):
+        self.tree['right'] = tree
+        return self
+
+    def up(self):
+        return Zipper(self.ancestors[-1], self.ancestors[:-1])
+
+    def to_tree(self):
+        if any(self.ancestors):
+            return self.ancestors[0]
+        return self.tree

data/tracks/python/exercises/zipper/zipper.py

@@ -0,0 +1,28 @@
+class Zipper(object):
+    @staticmethod
+    def from_tree(tree):
+        pass
+
+    def value(self):
+        pass
+
+    def set_value(self):
+        pass
+
+    def left(self):
+        pass
+
+    def set_left(self):
+        pass
+
+    def right(self):
+        pass
+
+    def set_right(self):
+        pass
+
+    def up(self):
+        pass
+
+    def to_tree(self):
+        pass

data/tracks/python/exercises/zipper/zipper_test.py

@@ -0,0 +1,82 @@
+import unittest
+
+from zipper import Zipper
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
+
+def bt(value, left, right):
+    return {
+        'value': value,
+        'left': left,
+        'right': right
+        }
+
+
+def leaf(value):
+    return bt(value, None, None)
+
+
+EMPTY_TREE = None
+
+
+def create_trees():
+    t1 = bt(1, bt(2, EMPTY_TREE, leaf(3)), leaf(4))
+    t2 = bt(1, bt(5, EMPTY_TREE, leaf(3)), leaf(4))
+    t3 = bt(1, bt(2, leaf(5), leaf(3)), leaf(4))
+    t4 = bt(1, leaf(2), leaf(4))
+    return (t1, t2, t3, t4)
+
+
+class ZipperTest(unittest.TestCase):
+    def test_data_is_retained(self):
+        t1, _, _, _ = create_trees()
+        zipper = Zipper.from_tree(t1)
+        tree = zipper.to_tree()
+        self.assertEqual(tree, t1)
+
+    def test_left_and_right_value(self):
+        t1, _, _, _ = create_trees()
+        zipper = Zipper.from_tree(t1)
+        self.assertEqual(zipper.left().right().value(), 3)
+
+    def test_dead_end(self):
+        t1, _, _, _ = create_trees()
+        zipper = Zipper.from_tree(t1)
+        self.assertIsNone(zipper.left().left())
+
+    def test_tree_from_deep_focus(self):
+        t1, _, _, _ = create_trees()
+        zipper = Zipper.from_tree(t1)
+        self.assertEqual(zipper.left().right().to_tree(), t1)
+
+    def test_set_value(self):
+        t1, t2, _, _ = create_trees()
+        zipper = Zipper.from_tree(t1)
+        updatedZipper = zipper.left().set_value(5)
+        tree = updatedZipper.to_tree()
+        self.assertEqual(tree, t2)
+
+    def test_set_left_with_value(self):
+        t1, _, t3, _ = create_trees()
+        zipper = Zipper.from_tree(t1)
+        updatedZipper = zipper.left().set_left(leaf(5))
+        tree = updatedZipper.to_tree()
+        self.assertEqual(tree, t3)
+
+    def test_set_right_to_none(self):
+        t1, _, _, t4 = create_trees()
+        zipper = Zipper.from_tree(t1)
+        updatedZipper = zipper.left().set_right(None)
+        tree = updatedZipper.to_tree()
+        self.assertEqual(tree, t4)
+
+    def test_different_paths_to_same_zipper(self):
+        t1, _, _, _ = create_trees()
+        zipper = Zipper.from_tree(t1)
+        self.assertEqual(zipper.left().up().right().to_tree(),
+                         zipper.right().to_tree())
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/racket/.travis.yml

@@ -5,7 +5,7 @@ env:
   global:
   - RACKET_DIR=~/racket
   matrix:
-  - RACKET_VERSION=6.3 RACKET_MINIMAL=1
+  - RACKET_VERSION=6.6 RACKET_MINIMAL=1
 before_install:
   - git clone https://github.com/zenspider/travis-racket.git
   - cd travis-racket

data/tracks/racket/config.json

@@ -113,6 +113,20 @@
 
       ]
     },
+    {
+      "uuid": "d330a93f-063f-0d80-f35b-02cc2f9da754e0be296",
+      "slug": "meetup",
+      "core": false,
+      "unlocked_by": null,
+      "difficulty": 1,
+      "topics": [
+        "strings",
+        "conditionals",
+        "dates",
+        "parsing",
+        "pattern_recognition"
+      ]
+    },
     {
       "uuid": "67b41645-7a02-4c45-af55-86401db69eee",
       "slug": "anagram",

data/tracks/racket/exercises/meetup/README.md

@@ -0,0 +1,54 @@
+# Meetup
+
+Calculate the date of meetups.
+
+Typically meetups happen on the same day of the week.  In this exercise, you will take
+a description of a meetup date, and return the actual meetup date.
+
+Examples of general descriptions are:
+
+- the first Monday of January 2017
+- the third Tuesday of January 2017
+- the Wednesteenth of January 2017
+- the last Thursday of January 2017
+
+Note that "Monteenth", "Tuesteenth", etc are all made up words. There
+was a meetup whose members realized that there are exactly 7 numbered days in a month that
+end in '-teenth'. Therefore, one is guaranteed that each day of the week
+(Monday, Tuesday, ...) will have exactly one date that is named with '-teenth'
+in every month.
+
+Given examples of a meetup dates, each containing a month, day, year, and descriptor
+(first, second, teenth, etc), calculate the date of the actual meetup.
+For example, if given "First Monday of January 2017", the correct meetup date is 2017/1/2
+
+* * * *
+
+For installation and learning resources, refer to the
+[exercism Racket page](http://exercism.io/languages/racket).
+
+You can run the provided tests through DrRacket, or via the command line.
+
+To run the test through DrRacket, simply open the test file and click the 'Run' button in the upper right.
+
+To run the test from the command line, simply run the test from the exercise directory. For example, if the test suite is called `hello-world-test.rkt`, you can run the following command:
+
+```
+raco test hello-world-test.rkt
+```
+
+which will display the following:
+
+```
+raco test: (submod "hello-world-test.rkt" test)
+2 success(es) 0 failure(s) 0 error(s) 2 test(s) run
+0
+2 tests passed
+```
+
+## Source
+
+Jeremy Hinegardner mentioned a Boulder meetup that happens on the Wednesteenth of every month [https://twitter.com/copiousfreetime](https://twitter.com/copiousfreetime)
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/racket/exercises/meetup/example.rkt

@@ -0,0 +1,45 @@
+#lang racket
+
+(require racket/date)
+
+(define (leap-year? year)
+  (or (and (zero? (modulo year 4))
+           (not (zero? (modulo year 100))))
+      (zero? (modulo year 400))))
+
+(define (days-in-month year month)
+  (case month
+    [(1 3 5 7 8 10 12) 31]
+    [(4 6 9 11) 30]
+    [(2) (if (leap-year? year) 29 28)]))
+
+(define (make-date year month day)
+  (seconds->date (find-seconds 0 0 0 day month year #f) #f))
+
+(define (meetup-day year month weekday week)
+  (let ([first-of-week
+          (case week
+            [(first) 1]
+            [(second) 8]
+            [(teenth) 13]
+            [(third) 15]
+            [(fourth) 22]
+            [(last) (- (days-in-month year month) 6)]
+            [else (raise-argument-error 'meetup-day "week" 3 year month weekday week)])]
+        [weekday
+          (case weekday
+            [(Sunday) 0]
+            [(Monday) 1]
+            [(Tuesday) 2]
+            [(Wednesday) 3]
+            [(Thursday) 4]
+            [(Friday) 5]
+            [(Saturday) 6]
+            [else (raise-argument-error 'meetup-day "weekday" 3 year month weekday week)])])
+    (make-date year month
+               (+ first-of-week
+                    (modulo
+                      (- weekday
+                       (date-week-day (make-date year month first-of-week))) 7)))))
+
+(provide meetup-day)

data/tracks/racket/exercises/meetup/meetup-test.rkt

@@ -0,0 +1,39 @@
+#lang racket
+
+(module+ test
+  (require rackunit rackunit/text-ui)
+  (require racket/date)
+  (require "meetup.rkt")
+
+  (define (make-date year month day)
+    (seconds->date (find-seconds 0 0 0 day month year #f) #f))
+
+  (define suite
+    (test-suite
+     "Tests for the meetup exercise"
+
+     (check-equal? (meetup-day 2013 5 'Monday 'teenth)
+                   (make-date 2013 5 13))
+
+     (check-equal? (meetup-day 2013 2 'Saturday 'teenth)
+                   (make-date 2013 2 16))
+
+     (check-equal? (meetup-day 2013 5 'Tuesday 'first)
+                   (make-date 2013 5 7))
+
+     (check-equal? (meetup-day 2013 4 'Monday 'second)
+                   (make-date 2013 4 8))
+
+     (check-equal? (meetup-day 2013 9 'Thursday 'third)
+                   (make-date 2013 9 19))
+
+     (check-equal? (meetup-day 2013 3 'Sunday 'fourth)
+                   (make-date 2013 3 24))
+
+     (check-equal? (meetup-day 2013 10 'Thursday 'last)
+                   (make-date 2013 10 31))
+
+     (check-equal? (meetup-day 2012 2 'Wednesday 'last)
+                   (make-date 2012 2 29))))
+
+  (run-tests suite))