trackler 2.2.1.73 → 2.2.1.74

data/tracks/python/exercises/armstrong-numbers/README.md

@@ -0,0 +1,28 @@
+# Armstrong Numbers
+
+An [Armstrong number](https://en.wikipedia.org/wiki/Narcissistic_number) is a number that is the sum of its own digits each raised to the power of the number of digits.
+
+For example:
+
+- 9 is an Armstrong number, because `9 = 9^1 = 9`
+- 10 is *not* an Armstrong number, because `10 != 1^2 + 0^2 = 2`
+- 153 is an Armstrong number, because: `153 = 1^3 + 5^3 + 3^3 = 1 + 125 + 27 = 153`
+- 154 is *not* an Armstrong number, because: `154 != 1^3 + 5^3 + 4^3 = 1 + 125 + 64 = 190`
+
+Write some code to determine whether a number is an Armstrong number.
+
+## 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).
+
+## Source
+
+Wikipedia [https://en.wikipedia.org/wiki/Narcissistic_number](https://en.wikipedia.org/wiki/Narcissistic_number)
+
+## 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/armstrong-numbers/armstrong_numbers.py

@@ -0,0 +1,2 @@
+def is_armstrong(number):
+    pass

data/tracks/python/exercises/armstrong-numbers/armstrong_numbers_test.py

@@ -0,0 +1,36 @@
+import unittest
+
+from armstrong_numbers import is_armstrong
+
+
+# Tests adapted from `problem-specifications//canonical-data.json` @ v1.0.0
+
+class ArmstrongTests(unittest.TestCase):
+
+    def test_single_digit_numbers_are_armstrong_numbers(self):
+        self.assertIs(is_armstrong(5), True)
+
+    def test_there_are_no_two_digit_armstrong_numbers(self):
+        self.assertIs(is_armstrong(10), False)
+
+    def test_three_digit_number_that_is_an_armstrong_number(self):
+        self.assertIs(is_armstrong(153), True)
+
+    def test_three_digit_number_that_is_not_an_armstrong_number(self):
+        self.assertIs(is_armstrong(100), False)
+
+    def test_four_digit_number_that_is_an_armstrong_number(self):
+        self.assertIs(is_armstrong(9474), True)
+
+    def test_four_digit_number_that_is_not_an_armstrong_number(self):
+        self.assertIs(is_armstrong(9475), False)
+
+    def test_seven_digit_number_that_is_an_armstrong_number(self):
+        self.assertIs(is_armstrong(9926315), True)
+
+    def test_seven_digit_number_that_is_not_an_armstrong_number(self):
+        self.assertIs(is_armstrong(9926314), False)
+
+
+if __name__ == '__main__':
+    unittest.main()

data/tracks/python/exercises/armstrong-numbers/example.py

@@ -0,0 +1,2 @@
+def is_armstrong(number):
+    return sum(pow(int(d), len(str(number))) for d in str(number)) == number

data/tracks/python/exercises/protein-translation/example.py

@@ -12,7 +12,7 @@ def of_codon(codon):
     return CODONS[codon]
 
 
-def of_rna(strand):
+def proteins(strand):
     proteins = []
     for codon in map(of_codon, _chunkstring(strand, 3)):
         if codon == 'STOP':

data/tracks/python/exercises/protein-translation/protein_translation.py

@@ -1,6 +1,2 @@
-def of_codon(codon):
-    pass
-
-
-def of_rna(strand):
+def proteins(strand):
     pass

data/tracks/python/exercises/protein-translation/protein_translation_test.py

@@ -1,58 +1,69 @@
 import unittest
 
-from protein_translation import of_codon, of_rna
+from protein_translation import proteins
 
 
+# Tests adapted from problem-specifications/canonical-data.json @ v1.0.0
+
 class ProteinTranslationTests(unittest.TestCase):
 
     def test_AUG_translates_to_methionine(self):
-        self.assertEqual('Methionine', of_codon('AUG'))
+        self.assertEqual(['Methionine'], proteins('AUG'))
 
     def test_identifies_Phenylalanine_codons(self):
         for codon in ['UUU', 'UUC']:
-            self.assertEqual('Phenylalanine', of_codon(codon))
+            self.assertEqual(['Phenylalanine'], proteins(codon))
 
     def test_identifies_Leucine_codons(self):
         for codon in ['UUA', 'UUG']:
-            self.assertEqual('Leucine', of_codon(codon))
+            self.assertEqual(['Leucine'], proteins(codon))
 
     def test_identifies_Serine_codons(self):
         for codon in ['UCU', 'UCC', 'UCA', 'UCG']:
-            self.assertEqual('Serine', of_codon(codon))
+            self.assertEqual(['Serine'], proteins(codon))
 
     def test_identifies_Tyrosine_codons(self):
         for codon in ['UAU', 'UAC']:
-            self.assertEqual('Tyrosine', of_codon(codon))
+            self.assertEqual(['Tyrosine'], proteins(codon))
 
     def test_identifies_Cysteine_codons(self):
         for codon in ['UGU', 'UGC']:
-            self.assertEqual('Cysteine', of_codon(codon))
+            self.assertEqual(['Cysteine'], proteins(codon))
 
     def test_identifies_Tryptophan_codons(self):
-        self.assertEqual('Tryptophan', of_codon('UGG'))
+        self.assertEqual(['Tryptophan'], proteins('UGG'))
 
     def test_identifies_stop_codons(self):
         for codon in ['UAA', 'UAG', 'UGA']:
-            self.assertEqual('STOP', of_codon(codon))
+            self.assertEqual([], proteins(codon))
 
-    def test_translates_rna_strand_into_correct_protein(self):
+    def test_translates_rna_strand_into_correct_protein_list(self):
         strand = 'AUGUUUUGG'
         expected = ['Methionine', 'Phenylalanine', 'Tryptophan']
-        self.assertEqual(expected, of_rna(strand))
+        self.assertEqual(expected, proteins(strand))
+
+    def test_stops_translation_if_stop_codon_at_beginning_of_sequence(self):
+        strand = 'UAGUGG'
+        expected = []
+        self.assertEqual(expected, proteins(strand))
 
-    def test_stops_translation_if_stop_codon_present(self):
+    def test_stops_translation_if_stop_codon_at_end_of_two_codon_sequence(
+            self):
+        strand = 'UGGUAG'
+        expected = ['Tryptophan']
+        self.assertEqual(expected, proteins(strand))
+
+    def test_stops_translation_if_stop_codon_at_end_of_three_codon_sequence(
+            self):
         strand = 'AUGUUUUAA'
         expected = ['Methionine', 'Phenylalanine']
-        self.assertEqual(expected, of_rna(strand))
+        self.assertEqual(expected, proteins(strand))
 
-    def test_stops_translation_of_longer_strand(self):
+    def test_stops_translation_if_stop_codon_in_middle_of_six_codon_sequence(
+            self):
         strand = 'UGGUGUUAUUAAUGGUUU'
         expected = ['Tryptophan', 'Cysteine', 'Tyrosine']
-        self.assertEqual(expected, of_rna(strand))
-
-    def test_invalid_codons(self):
-        with self.assertRaises(ValueError):
-            of_rna('CARROT')
+        self.assertEqual(expected, proteins(strand))
 
 
 if __name__ == '__main__':

data/tracks/ruby/exercises/secret-handshake/README.md

@@ -55,7 +55,7 @@ To include color from the command line:
 
 ## Source
 
-Bert, in Mary Poppins [http://www.imdb.com/character/ch0011238/quotes](http://www.imdb.com/character/ch0011238/quotes)
+Bert, in Mary Poppins [http://www.imdb.com/title/tt0058331/quotes/qt0437047](http://www.imdb.com/title/tt0058331/quotes/qt0437047)
 
 ## 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/simple-linked-list/.meta/hints.md

@@ -17,7 +17,7 @@ struct Node<T> {
 ```
 `data` contains the stored data, and `next` points to the following node (if available) or None.  
 
-### Why Option<__Box__<Node<T>>> and not just Option<Node<T>>?
+### Why `Option<Box<Node<T>>>` and not just `Option<Node<T>>`?
 Try it on your own. You will get the following error.
 
 ```
@@ -27,8 +27,7 @@ Try it on your own. You will get the following error.
 |     next: Option<Node<T>>,
 |     --------------------- recursive without indirection
  ```
- 
+
  The problem is that at compile time the size of next must be known.
  Since `next` is recursive ("a node has a node has a node..."), the compiler does not know how much memory is to be allocated.
  In contrast, [Box](https://doc.rust-lang.org/std/boxed/) is a heap pointer with a defined size.
- 

data/tracks/rust/exercises/simple-linked-list/README.md

@@ -40,7 +40,7 @@ struct Node<T> {
 ```
 `data` contains the stored data, and `next` points to the following node (if available) or None.  
 
-### Why Option<__Box__<Node<T>>> and not just Option<Node<T>>?
+### Why `Option<Box<Node<T>>>` and not just `Option<Node<T>>`?
 Try it on your own. You will get the following error.
 
 ```
@@ -50,11 +50,11 @@ Try it on your own. You will get the following error.
 |     next: Option<Node<T>>,
 |     --------------------- recursive without indirection
  ```
- 
+
  The problem is that at compile time the size of next must be known.
  Since `next` is recursive ("a node has a node has a node..."), the compiler does not know how much memory is to be allocated.
  In contrast, [Box](https://doc.rust-lang.org/std/boxed/) is a heap pointer with a defined size.
- 
+
 
 ## Rust Installation
 

data/tracks/swift/config.json

@@ -382,6 +382,19 @@
       "unlocked_by": null,
       "uuid": "5854447a-ff9f-4321-bd5c-430555b91fc6"
     },
+    {
+      "core": false,
+      "difficulty": 3,
+      "slug": "protein-translation",
+      "topics": [
+        "control-flow-(conditionals)",
+        "control-flow-(loops)",
+        "strings",
+        "algorithms"
+      ],
+      "unlocked_by": null,
+      "uuid": "72bd3b46-c3ed-4399-a925-9b616cfa1e9b"
+    },
     {
       "core": false,
       "difficulty": 4,

data/tracks/swift/exercises/protein-translation/Package.swift

@@ -0,0 +1,5 @@
+import PackageDescription
+
+let package = Package(
+    name: "ProteinTranslation"
+)

data/tracks/swift/exercises/protein-translation/README.md

@@ -0,0 +1,56 @@
+# Protein Translation
+
+Translate RNA sequences into proteins.
+
+RNA can be broken into three nucleotide sequences called codons, and then translated to a polypeptide like so:
+
+RNA: `"AUGUUUUCU"` => translates to
+
+Codons: `"AUG", "UUU", "UCU"`
+=> which become a polypeptide with the following sequence =>
+
+Protein: `"Methionine", "Phenylalanine", "Serine"`
+
+There are 64 codons which in turn correspond to 20 amino acids; however, all of the codon sequences and resulting amino acids are not important in this exercise.  If it works for one codon, the program should work for all of them.
+However, feel free to expand the list in the test suite to include them all.
+
+There are also four terminating codons (also known as 'STOP' codons); if any of these codons are encountered (by the ribosome), all translation ends and the protein is terminated.
+
+All subsequent codons after are ignored, like this:
+
+RNA: `"AUGUUUUCUUAAAUG"` =>
+
+Codons: `"AUG", "UUU", "UCU", "UAG", "AUG"` =>
+
+Protein: `"Methionine", "Phenylalanine", "Serine"`
+
+Note the stop codon terminates the translation and the final methionine is not translated into the protein sequence.
+
+Below are the codons and resulting Amino Acids needed for the exercise.
+
+Codon                 | Protein
+:---                  | :---
+AUG                   | Methionine
+UUU, UUC              | Phenylalanine
+UUA, UUG              | Leucine
+UCU, UCC, UCA, UCG    | Serine
+UAU, UAC              | Tyrosine
+UGU, UGC              | Cysteine
+UGG                   | Tryptophan
+UAA, UAG, UGA         | STOP
+
+
+Learn more about [protein translation on Wikipedia](http://en.wikipedia.org/wiki/Translation_(biology))
+
+## Setup
+
+Go through the project setup instructions for Xcode using Swift:
+
+http://exercism.io/languages/swift
+
+## Source
+
+Tyler Long
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/swift/exercises/protein-translation/Sources/ProteinTranslation.swift

@@ -0,0 +1 @@
+//Solution goes in Sources

data/tracks/swift/exercises/protein-translation/Sources/ProteinTranslationExample.swift

@@ -0,0 +1,54 @@
+enum ProteinTranslationError: Error {
+    case invalidCodon
+}
+
+struct ProteinTranslation {
+
+    private static func lookup(codon: String) -> String? {
+        switch codon {
+        case "AUG":
+            return "Methionine"
+        case "UUU", "UUC":
+            return "Phenylalanine"
+        case "UUA", "UUG":
+            return "Leucine"
+        case "UCU", "UCC", "UCA", "UCG":
+            return "Serine"
+        case "UAU", "UAC":
+            return "Tyrosine"
+        case "UGU", "UGC":
+            return "Cysteine"
+        case "UGG":
+            return "Tryptophan"
+        case "UAA", "UAG", "UGA":
+            return "STOP"
+        default:
+            return nil
+        }
+    }
+
+    static func translationOfCodon(_ codon: String) throws -> String {
+        guard let protein = lookup(codon: codon) else {
+            throw ProteinTranslationError.invalidCodon
+        }
+
+        return protein
+    }
+
+    static func translationOfRNA(_ strand: String) throws -> [String] {
+        var strand = strand
+        var result = [String]()
+
+        while !strand.isEmpty {
+            let codon = String(strand.characters.prefix(3))
+            let translation = try translationOfCodon(codon)
+            if translation == "STOP" {
+                return result
+            }
+            result.append(translation)
+            strand = String(strand.characters.dropFirst(3))
+        }
+
+        return result
+    }
+}

data/tracks/swift/exercises/protein-translation/Tests/LinuxMain.swift

@@ -0,0 +1,6 @@
+import XCTest
+@testable import ProteinTranslationTests
+
+XCTMain([
+    testCase(ProteinTranslationTests.allTests),
+])

data/tracks/swift/exercises/protein-translation/Tests/ProteinTranslationTests/ProteinTranslationTests.swift

@@ -0,0 +1,83 @@
+import XCTest
+@testable import ProteinTranslation
+
+class ProteinTranslationTests: XCTestCase {
+
+    func testAUGTranslatesToMethionine() {
+        XCTAssertEqual("Methionine", try? ProteinTranslation.translationOfCodon("AUG"))
+    }
+
+    func testIdentifiesPhenylalanineCodons() {
+        XCTAssertEqual("Phenylalanine", try? ProteinTranslation.translationOfCodon("UUU"))
+        XCTAssertEqual("Phenylalanine", try? ProteinTranslation.translationOfCodon("UUC"))
+    }
+
+    func testIdentifiesLeucineCodons() {
+        ["UUA", "UUG"].forEach {
+            XCTAssertEqual("Leucine", try? ProteinTranslation.translationOfCodon($0))
+        }
+    }
+
+    func testIdentifiesSerineCodons() {
+        ["UCU", "UCC", "UCA", "UCG"].forEach {
+            XCTAssertEqual("Serine", try? ProteinTranslation.translationOfCodon($0))
+        }
+    }
+
+    func testIdentifiesTyrosineCodons() {
+        ["UAU", "UAC"].forEach {
+            XCTAssertEqual("Tyrosine", try? ProteinTranslation.translationOfCodon($0))
+        }
+    }
+
+    func testIdentifiesCysteineCodons() {
+        ["UGU", "UGC"].forEach {
+            XCTAssertEqual("Cysteine", try? ProteinTranslation.translationOfCodon($0))
+        }
+    }
+
+    func testIdentifiesTryptophanCodons() {
+        XCTAssertEqual("Tryptophan", try? ProteinTranslation.translationOfCodon("UGG"))
+    }
+
+    func testIdentifiesStopCodons() {
+        ["UAA", "UAG", "UGA"].forEach {
+            XCTAssertEqual("STOP", try? ProteinTranslation.translationOfCodon($0))
+        }
+    }
+
+    func testTranslatesRNAStrandIntoCorrectProtein() {
+        XCTAssertEqual(["Methionine", "Phenylalanine", "Tryptophan"],
+                   try!ProteinTranslation.translationOfRNA("AUGUUUUGG"))
+    }
+
+    func testStopsTranslationIfStopCodonPresent() {
+        XCTAssertEqual(["Methionine", "Phenylalanine"], try! ProteinTranslation.translationOfRNA("AUGUUUUAA"))
+    }
+
+    func testStopsTranslationOfLongerStrand() {
+        XCTAssertEqual(["Tryptophan", "Cysteine", "Tyrosine"],
+                       try! ProteinTranslation.translationOfRNA("UGGUGUUAUUAAUGGUUU"))
+    }
+
+    func testInvalidCodons() {
+        XCTAssertThrowsError(try ProteinTranslation.translationOfRNA("CARROT"))
+    }
+
+    static var allTests: [(String, (ProteinTranslationTests) -> () throws -> Void)] {
+        return [
+            ("testAUGTranslatesToMethionine", testAUGTranslatesToMethionine),
+            ("testIdentifiesPhenylalanineCodons", testIdentifiesPhenylalanineCodons),
+            ("testIdentifiesLeucineCodons", testIdentifiesLeucineCodons),
+            ("testIdentifiesSerineCodons", testIdentifiesSerineCodons),
+            ("testIdentifiesTyrosineCodons", testIdentifiesTyrosineCodons),
+            ("testIdentifiesCysteineCodons", testIdentifiesCysteineCodons),
+            ("testIdentifiesTryptophanCodons", testIdentifiesTryptophanCodons),
+            ("testIdentifiesStopCodons", testIdentifiesStopCodons),
+            ("testTranslatesRNAStrandIntoCorrectProtein", testTranslatesRNAStrandIntoCorrectProtein),
+            ("testStopsTranslationIfStopCodonPresent", testStopsTranslationIfStopCodonPresent),
+            ("testStopsTranslationOfLongerStrand", testStopsTranslationOfLongerStrand),
+            ("testInvalidCodons", testInvalidCodons),
+        ]
+    }
+}