trackler 2.0.8.27 → 2.0.8.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b5c894b894e9f0f3d11e47d960d538044a4863cd
-  data.tar.gz: f0150355935cc408bc6fe6cfb8922fb32bd32267
+  metadata.gz: 88860310ccc044c6401cd6578337ddc2b13bcbf1
+  data.tar.gz: 2b09ed02e5926183697dafc3d13f8402cf7ee95f
 SHA512:
-  metadata.gz: 7c70f073bbd990f0d6dbbe5734a19016bc18435f151a009e7c6cd48dda5b2101d5096cc993a749c167a228d97ed29588478d4ace4d0c63ced64976b9234f88b6
-  data.tar.gz: af5c762cba7ea0dc69d25c8e8b05c7108754597a869cf7a5c20ea071a4d6a937c98a5be02d46530a0c8298aba7b7fe59c9ef4a7458e86fa126a949bcb4f6acda
+  metadata.gz: 778a87faf57b3b14f0260da2c758dbb284d88e6b7d4e0befc81426e6724f6147129c19037398b21d85824efe1ab4d7aaa8d8f071695b8f29fda71f8c0a3d99f4
+  data.tar.gz: 0d89dad5d10d0087386d7704eaf9e80255642b039aa0590ac9d61de0e4aca0674f5aecaa2c3934fab785012bdda26fde53bb11eb94ce9d21d02b4c950f9979c1

data/common/exercises/simple-cipher/description.md

@@ -54,7 +54,7 @@ would get the same thing as the Caesar Cipher.
 
 The weakest link in any cipher is the human being. Let's make your
 substitution cipher a little more fault tolerant by providing a source
-of randomness and ensuring that they key is not composed of numbers or
+of randomness and ensuring that the key is not composed of numbers or
 capital letters.
 
 If someone doesn't submit a key at all, generate a truly random key of

data/common/exercises/triangle/description.md

@@ -1,28 +1,17 @@
-The program should raise an error if the triangle cannot exist.
+An _equilateral_ triangle has all three sides the same length.<br/>
+An _isoceles_ triangle has at least two sides the same length. (It is sometimes
+specified as having exactly two sides the same length, but for the purposes of
+this exercise we'll say at least two.)<br/>
+A _scalene_ triangle has all sides of different lengths.
 
-## Hint
+## Note
 
-The triangle inequality theorem states:
-z ≤ x + y
-where x,y, and z are the lengths of the sides of a triangle. In other words, the
-sum of the lengths of any two sides of a triangle always exceeds or is equal to
-the length of the third side.
-
-A corollary to the triangle inequality theorem is there are two classes of
-triangles--degenerate and non-degenerate. If the sum of the lengths of any two
-sides of a triangle is greater than the length of the third side, that triangle
-is two dimensional, has area, and belongs to the non-degenerate class. In
-mathematics, a degenerate case is a limiting case in which an element of a class
-of objects is qualitatively different from the rest of the class and hence
-belongs to another, usually simpler, class. The degenerate case of the triangle
-inequality theorem is when the sum of the lengths of any two sides of a triangle
-is equal to the length of the third side. A triangle with such qualities is
-qualitatively different from all the triangles in the non-degenerate class since
-it is one dimensional, looks like a straight line, and has no area. Such
-triangles are called degenerate triangles and they belong to the degenerate
-class.
+For a shape to be a triangle at all, all sides have to be of length > 0, and 
+the sum of the lengths of any two sides must be greater than or equal to the 
+length of the third side. See [Triangle Inequality](https://en.wikipedia.org/wiki/Triangle_inequality).
 
 ## Dig Deeper
 
-This exercise does not test for degenerate triangles. Feel free to add your own
-tests to check for degenerate triangles.
+The case where the sum of the lengths of two sides _equals_ that of the 
+third is known as a _degenerate_ triangle - it has zero area and looks like 
+a single line. Feel free to add your own code/tests to check for degenerate triangles.

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.27"
+  VERSION = "2.0.8.28"
 end

data/tracks/kotlin/config.json

@@ -233,6 +233,11 @@
       "slug": "triangle",
       "topics": []
     },
+    {
+      "difficulty": 2,
+      "slug": "bank-account",
+      "topics": ["Concurrency"]
+    },
     {
       "difficulty": 10,
       "slug": "react",

data/tracks/kotlin/exercises/bank-account/build.gradle

@@ -0,0 +1,32 @@
+buildscript {
+    ext.kotlin_version = '1.1.1'
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+apply plugin: 'kotlin'
+
+kotlin.experimental.coroutines = 'enable'
+
+repositories {
+    mavenCentral()
+    jcenter()
+}
+
+dependencies {
+    compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+    testCompile 'junit:junit:4.12'
+    testCompile "org.jetbrains.kotlin:kotlin-test-junit:$kotlin_version"
+    testCompile 'org.jetbrains.kotlinx:kotlinx-coroutines-core:0.13'
+}
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

data/tracks/kotlin/exercises/bank-account/src/example/kotlin/BankAccount.kt

@@ -0,0 +1,27 @@
+class BankAccount {
+    var balance: Long = 0
+        get() {
+            synchronized(lock) {
+                if (!isOpen) throw IllegalStateException("Account is closed")
+                return field
+            }
+        }
+        private set
+
+    var isOpen = true
+        private set
+
+    fun adjustBalance(amount: Long) {
+        synchronized(lock) {
+            balance += amount
+        }
+    }
+
+    fun close() {
+        synchronized(lock) {
+            isOpen = false
+        }
+    }
+
+    private val lock = Any()
+}

data/tracks/kotlin/exercises/bank-account/src/test/kotlin/BankAccountTest.kt

@@ -0,0 +1,73 @@
+import org.junit.Ignore
+import org.junit.Test
+import java.util.*
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.experimental.*
+
+class BankAccountTest {
+
+    @Test
+    fun zeroBalanceWhenOpened() {
+        val account = BankAccount()
+        assertEquals(0, account.balance)
+    }
+
+    @Ignore
+    @Test
+    fun sequentialBalanceAdjustments() {
+        val account = BankAccount()
+
+        account.adjustBalance(1000)
+        assertEquals(1000, account.balance)
+
+        account.adjustBalance(-958)
+        assertEquals(42, account.balance)
+    }
+
+    @Ignore
+    @Test
+    fun closedAccountHasNoBalance() {
+        val account = BankAccount()
+        account.close()
+
+        assertFailsWith(IllegalStateException::class, { account.balance })
+    }
+
+    @Ignore
+    @Test
+    fun closedAccountCannotBeAdjusted() {
+        val account = BankAccount()
+        account.close()
+
+        assertFailsWith(IllegalStateException::class, { account.adjustBalance(1000) })
+    }
+
+    @Ignore
+    @Test
+    fun concurrentBalanceAdjustments() {
+        val threads = 1000
+        val iterations = 500
+        val random = Random()
+
+        val account = BankAccount()
+
+        val jobs = List(threads) {
+            launch(CommonPool) {
+                repeat(iterations) {
+                    account.adjustBalance(1)
+                    delay(random.nextInt(10).toLong())
+                    account.adjustBalance(-1)
+                }
+            }
+        }
+
+        runBlocking {
+            jobs.forEach { it.join() }
+        }
+
+        assertEquals(0, account.balance)
+    }
+
+}
+

data/tracks/kotlin/exercises/settings.gradle

@@ -42,3 +42,4 @@ include 'largest-series-product'
 include 'change'
 include 'binary-search'
 include 'triangle'
+include 'bank-account'

data/tracks/python/config.json

@@ -22,17 +22,6 @@
           "logic"
       ]
     },
-    {
-      "slug": "clock",
-      "difficulty": 2,
-      "topics": [
-          "classes",
-          "time",
-          "mathematics",
-          "logic",
-          "text formatting"
-      ]
-    },
     {
       "slug": "isogram",
       "difficulty": 1,
@@ -432,6 +421,17 @@
         "transforming"
       ]
     },
+    {
+      "slug": "clock",
+      "difficulty": 2,
+      "topics": [
+          "classes",
+          "time",
+          "mathematics",
+          "logic",
+          "text formatting"
+      ]
+    },
     {
       "slug": "grep",
       "difficulty": 4,

data/tracks/python/exercises/accumulate/accumulate_test.py

@@ -5,32 +5,34 @@ from accumulate import accumulate
 
 class AccumulateTest(unittest.TestCase):
     def test_empty_sequence(self):
-        self.assertEqual([], accumulate([], lambda x: x / 2))
+        self.assertEqual(accumulate([], lambda x: x / 2), [])
 
     def test_pow(self):
-        self.assertEqual([1, 4, 9, 16, 25], accumulate([1, 2, 3, 4, 5],
-                         lambda x: x * x))
+        self.assertEqual(
+            accumulate([1, 2, 3, 4, 5], lambda x: x * x), [1, 4, 9, 16, 25])
 
     def test_divmod(self):
-        inp = [10, 17, 23]
-        out = [(1, 3), (2, 3), (3, 2)]
-        self.assertEqual(out, accumulate(inp, lambda x: divmod(x, 7)))
+        self.assertEqual(
+            accumulate([10, 17, 23], lambda x: divmod(x, 7)),
+            [(1, 3), (2, 3), (3, 2)])
 
     def test_composition(self):
         inp = [10, 17, 23]
-        self.assertEqual(inp, accumulate(accumulate(inp, lambda x: divmod(x, 7)),
-                         lambda x: 7 * x[0] + x[1]))
+        self.assertEqual(
+            accumulate(
+                accumulate(inp, lambda x: divmod(x, 7)),
+                lambda x: 7 * x[0] + x[1]), inp)
 
     def test_capitalize(self):
-        inp = ['hello', 'world']
-        out = ['HELLO', 'WORLD']
-        self.assertEqual(out, accumulate(inp, str.upper))
+        self.assertEqual(
+            accumulate(['hello', 'world'], str.upper), ['HELLO', 'WORLD'])
 
     def test_recursive(self):
-        inp = list('abc')
+        inp = ['a', 'b', 'c']
         out = [['a1', 'a2', 'a3'], ['b1', 'b2', 'b3'], ['c1', 'c2', 'c3']]
-        self.assertEqual(out, accumulate(inp, lambda x: accumulate(list('123'),
-                         lambda y: x + y)))
+        self.assertEqual(
+            accumulate(
+                inp, lambda x: accumulate(list('123'), lambda y: x + y)), out)
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/acronym/acronym_test.py

@@ -7,25 +7,26 @@ from acronym import abbreviate
 
 class AcronymTest(unittest.TestCase):
     def test_basic(self):
-        self.assertEqual('PNG', abbreviate('Portable Network Graphics'))
+        self.assertEqual(abbreviate('Portable Network Graphics'), 'PNG')
 
     def test_lowercase_words(self):
-        self.assertEqual('ROR', abbreviate('Ruby on Rails'))
+        self.assertEqual(abbreviate('Ruby on Rails'), 'ROR')
 
     def test_camelcase(self):
-        self.assertEqual('HTML', abbreviate('HyperText Markup Language'))
+        self.assertEqual(abbreviate('HyperText Markup Language'), 'HTML')
 
     def test_punctuation(self):
-        self.assertEqual('FIFO', abbreviate('First In, First Out'))
+        self.assertEqual(abbreviate('First In, First Out'), 'FIFO')
 
     def test_all_caps_words(self):
-        self.assertEqual('PHP', abbreviate('PHP: Hypertext Preprocessor'))
+        self.assertEqual(abbreviate('PHP: Hypertext Preprocessor'), 'PHP')
 
     def test_non_acronym_all_caps_word(self):
-        self.assertEqual('GIMP', abbreviate('GNU Image Manipulation Program'))
+        self.assertEqual(abbreviate('GNU Image Manipulation Program'), 'GIMP')
 
     def test_hyphenated(self):
-        self.assertEqual('CMOS', abbreviate('Complementary metal-oxide semiconductor'))
+        self.assertEqual(
+            abbreviate('Complementary metal-oxide semiconductor'), 'CMOS')
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/allergies/allergies_test.py

@@ -4,7 +4,6 @@ from allergies import Allergies
 
 
 class AllergiesTests(unittest.TestCase):
-
     def test_no_allergies_means_not_allergic(self):
         allergies = Allergies(0)
         self.assertFalse(allergies.is_allergic_to('peanuts'))
@@ -21,20 +20,20 @@ class AllergiesTests(unittest.TestCase):
         self.assertFalse(allergies.is_allergic_to('strawberries'))
 
     def test_no_allergies_at_all(self):
-        self.assertEqual([], Allergies(0).lst)
+        self.assertEqual(Allergies(0).lst, [])
 
     def test_allergic_to_just_peanuts(self):
-        self.assertEqual(['peanuts'], Allergies(2).lst)
+        self.assertEqual(Allergies(2).lst, ['peanuts'])
 
     def test_allergic_to_everything(self):
         self.assertEqual(
+            sorted(Allergies(255).lst),
             sorted(('eggs peanuts shellfish strawberries tomatoes '
-                    'chocolate pollen cats').split()),
-            sorted(Allergies(255).lst))
+                    'chocolate pollen cats').split()))
 
     @unittest.skip('Extra Credit: Passes with a specific type of solution')
     def test_ignore_non_allergen_score_parts(self):
-        self.assertEqual(['eggs'], Allergies(257).lst)
+        self.assertEqual(Allergies(257).lst, ['eggs'])
 
 
 if __name__ == '__main__':

data/tracks/python/exercises/atbash-cipher/atbash_cipher_test.py

@@ -6,61 +6,55 @@ from atbash_cipher import decode, encode
 # test cases adapted from `x-common//canonical-data.json` @ version: 1.0.0
 
 class AtbashCipherTest(unittest.TestCase):
-
     def test_encode_no(self):
-        self.assertMultiLineEqual("ml", encode("no"))
+        self.assertMultiLineEqual(encode("no"), "ml")
 
     def test_encode_yes(self):
-        self.assertMultiLineEqual("bvh", encode("yes"))
+        self.assertMultiLineEqual(encode("yes"), "bvh")
 
     def test_encode_OMG(self):
-        self.assertMultiLineEqual("lnt", encode("OMG"))
+        self.assertMultiLineEqual(encode("OMG"), "lnt")
 
     def test_encode_O_M_G(self):
-        self.assertMultiLineEqual("lnt", encode("O M G"))
+        self.assertMultiLineEqual(encode("O M G"), "lnt")
 
     def test_encode_long_word(self):
-        self.assertMultiLineEqual("nrmwy oldrm tob", encode("mindblowingly"))
+        self.assertMultiLineEqual(encode("mindblowingly"), "nrmwy oldrm tob")
 
     def test_encode_numbers(self):
-        self.assertMultiLineEqual("gvhgr mt123 gvhgr mt",
-                                  encode("Testing, 1 2 3, testing."))
+        self.assertMultiLineEqual(
+            encode("Testing, 1 2 3, testing."), "gvhgr mt123 gvhgr mt")
 
     def test_encode_sentence(self):
-        self.assertMultiLineEqual("gifgs rhurx grlm",
-                                  encode("Truth is fiction."))
+        self.assertMultiLineEqual(
+            encode("Truth is fiction."), "gifgs rhurx grlm")
 
     def test_encode_all_things(self):
         plaintext = "The quick brown fox jumps over the lazy dog."
         ciphertext = "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
-        self.assertMultiLineEqual(ciphertext, encode(plaintext))
+        self.assertMultiLineEqual(encode(plaintext), ciphertext)
 
     def test_decode_word(self):
-        self.assertMultiLineEqual("exercism", decode("vcvix rhn"))
+        self.assertMultiLineEqual(decode("vcvix rhn"), "exercism")
 
     def test_decode_sentence(self):
         self.assertMultiLineEqual(
-            "anobstacleisoftenasteppingstone",
-            decode("zmlyh gzxov rhlug vmzhg vkkrm thglm v")
-        )
+            decode("zmlyh gzxov rhlug vmzhg vkkrm thglm v"),
+            "anobstacleisoftenasteppingstone")
 
     def test_decode_numbers(self):
         self.assertMultiLineEqual(
-            "testing123testing",
-            decode("gvhgr mt123 gvhgr mt")
-        )
+            decode("gvhgr mt123 gvhgr mt"), "testing123testing")
 
     def test_decode_all_the_letters(self):
         ciphertext = "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
         plaintext = "thequickbrownfoxjumpsoverthelazydog"
-        self.assertMultiLineEqual(plaintext, decode(ciphertext))
+        self.assertMultiLineEqual(decode(ciphertext), plaintext)
 
     # additional track specific test
     def test_encode_decode(self):
         self.assertMultiLineEqual(
-            "testing123testing",
-            decode(encode("Testing, 1 2 3, testing."))
-        )
+            decode(encode("Testing, 1 2 3, testing.")), "testing123testing")
 
 
 if __name__ == '__main__':