trackler 2.2.1.62 → 2.2.1.63

data/tracks/go/exercises/zebra-puzzle/example.go

@@ -0,0 +1,256 @@
+package zebra
+
+import "fmt"
+
+/* The Zebra Puzzle facts given:
+
+1. There are five houses.
+2. The Englishman lives in the red house.
+3. The Spaniard owns the dog.
+4. Coffee is drunk in the green house.
+5. The Ukrainian drinks tea.
+6. The green house is immediately to the right of the ivory house.
+7. The Old Gold smoker owns snails.
+8. Kools are smoked in the yellow house.
+9. Milk is drunk in the middle house.
+10. The Norwegian lives in the first house.
+11. The man who smokes Chesterfields lives in the house next to the man with the fox.
+12. Kools are smoked in the house next to the house where the horse is kept.
+13. The Lucky Strike smoker drinks orange juice.
+14. The Japanese smokes Parliaments.
+15. The Norwegian lives next to the blue house.
+
+*/
+
+type Solution struct {
+	DrinksWater string
+	OwnsZebra   string
+}
+
+// SolvePuzzle returns a solution answering the two questions for the zebra puzzle,
+// which are "Who drinks water?", and "Who owns the zebra?"
+func SolvePuzzle() (solution Solution) {
+
+	// 1. There are five houses.
+	const (
+		firstHouse = iota // name/identity of each house
+		secondHouse
+		middleHouse
+		fourthHouse
+		fifthHouse
+		numHouses
+	)
+	houses := []int{firstHouse, secondHouse, middleHouse, fourthHouse, fifthHouse}
+
+	// Generate the permutations of all the house identities.
+	houseIdentityPermutations := permutations(houses, numHouses)
+
+	// Note: Below, the pattern of var naming of "iXyz" is notation for "potential house (i)dentity of Xyz"
+	// So for example, when comparing pEnglishman == pRed, the test is determining whether the permutation
+	// of placements for both the Englishman and the red house agree to meet the given fact #2.
+
+	for _, houseColors := range houseIdentityPermutations {
+
+		iRed, iGreen, iIvory, iYellow, iBlue := assign(houseColors)
+
+		// 6. The green house is immediately to the right of the ivory house.
+		if !justRightOf(iGreen, iIvory) {
+			continue
+		}
+
+		for _, residents := range houseIdentityPermutations {
+
+			iEnglishman, iSpaniard, iUkrainian, iNorwegian, iJapanese := assign(residents)
+
+			// 2. The Englishman lives in the red house.
+			// 10. The Norwegian lives in the first house.
+			// 15. The Norwegian lives next to the blue house.
+			if iEnglishman != iRed || iNorwegian != firstHouse || !nextTo(iNorwegian, iBlue) {
+				continue
+			}
+
+			for _, beverages := range houseIdentityPermutations {
+
+				iCoffee, iTea, iMilk, iOrangeJuice, iWater := assign(beverages)
+
+				// 4. Coffee is drunk in the green house.
+				// 5. The Ukrainian drinks tea.
+				// 9. Milk is drunk in the middle house.
+				if iCoffee != iGreen || iUkrainian != iTea || iMilk != middleHouse {
+					continue
+				}
+
+				for _, smokeBrands := range houseIdentityPermutations {
+
+					iOldGold, iKools, iChesterfields, iLuckyStrike, iParliaments := assign(smokeBrands)
+
+					// 8. Kools are smoked in the yellow house.
+					// 13. The Lucky Strike smoker drinks orange juice.
+					// 14. The Japanese smokes Parliaments.
+					if iKools != iYellow || iLuckyStrike != iOrangeJuice || iJapanese != iParliaments {
+						continue
+					}
+
+					for _, pets := range houseIdentityPermutations {
+
+						iDog, iSnails, iFox, iHorse, iZebra := assign(pets)
+
+						// 3. The Spaniard owns the dog.
+						// 7. The Old Gold smoker owns snails.
+						// 11. The man who smokes Chesterfields lives in the house next to the man with the fox.
+						// 12. Kools are smoked in the house next to the house where the horse is kept.
+						if iSpaniard != iDog || iOldGold != iSnails ||
+							!nextTo(iChesterfields, iFox) || !nextTo(iKools, iHorse) {
+							continue
+						}
+
+						// At this point all criteria are met, so we arrived at the solution,
+						// and can fill in an array h of house facts (actually we only need the residents).
+
+						var h [numHouses]struct {
+							resident   string
+							color      string
+							pet        string
+							beverage   string
+							smokeBrand string
+						}
+
+						h[iEnglishman].resident = "Englishman"
+						h[iSpaniard].resident = "Spaniard"
+						h[iUkrainian].resident = "Ukrainian"
+						h[iJapanese].resident = "Japanese"
+						h[iNorwegian].resident = "Norwegian"
+
+						solution = Solution{
+							DrinksWater: h[iWater].resident,
+							OwnsZebra:   h[iZebra].resident}
+
+						if !showHouseFacts {
+							return
+						}
+						h[iRed].color = "red"
+						h[iGreen].color = "green"
+						h[iIvory].color = "ivory"
+						h[iYellow].color = "yellow"
+						h[iBlue].color = "blue"
+						h[iDog].pet = "dog"
+						h[iSnails].pet = "snails"
+						h[iFox].pet = "fox"
+						h[iHorse].pet = "horse"
+						h[iZebra].pet = "zebra"
+						h[iCoffee].beverage = "coffee"
+						h[iTea].beverage = "tea"
+						h[iMilk].beverage = "milk"
+						h[iOrangeJuice].beverage = "orange juice"
+						h[iWater].beverage = "water"
+						h[iOldGold].smokeBrand = "OldGold"
+						h[iKools].smokeBrand = "Kools"
+						h[iChesterfields].smokeBrand = "Chesterfields"
+						h[iLuckyStrike].smokeBrand = "LuckyStrike"
+						h[iParliaments].smokeBrand = "Parliaments"
+						var houseNames = [5]string{"first", "second", "middle", "fourth", "fifth"}
+
+						for p := firstHouse; p <= fifthHouse; p++ {
+							var separator string
+							if h[p].pet[len(h[p].pet)-1] != 's' {
+								separator = "a "
+							}
+							fmt.Printf("The %-10s lives in the %-6s house which is %-7s owns %-8s drinks %-13s and smokes %-13s\n",
+								h[p].resident,
+								houseNames[p],
+								h[p].color+",",
+								separator+h[p].pet+",",
+								h[p].beverage+",",
+								h[p].smokeBrand+".")
+						}
+
+						return
+					}
+				}
+			}
+		}
+	}
+	return
+}
+
+const showHouseFacts = false // when true, print all house facts for fun.
+
+// assign is notational helper function which returns the successive members
+// of a permutation slice as five distinct values.
+func assign(p []int) (a, b, c, d, e int) {
+	return p[0], p[1], p[2], p[3], p[4]
+}
+
+// justRightOf returns true if positionally x is just to the right of y.
+func justRightOf(x, y int) bool {
+	return (x - y) == 1
+}
+
+// nextTo returns true if positionally, x is next to y, differing only by 1.
+func nextTo(x, y int) bool {
+	return (x-y) == 1 || (y-x) == 1
+}
+
+// permutations returns a slice containing the r length permutations of the elements in iterable.
+// The implementation is modeled after the Python intertools.permutations().
+func permutations(iterable []int, r int) (perms [][]int) {
+	pool := iterable
+	n := len(pool)
+
+	if r > n {
+		return
+	}
+
+	indices := make([]int, n)
+	for i := range indices {
+		indices[i] = i
+	}
+
+	cycles := make([]int, r)
+	for i := range cycles {
+		cycles[i] = n - i
+	}
+
+	result := make([]int, r)
+	for i, el := range indices[:r] {
+		result[i] = pool[el]
+	}
+
+	p := make([]int, len(result))
+	copy(p, result)
+	perms = append(perms, p)
+
+	for n > 0 {
+		i := r - 1
+		for ; i >= 0; i-- {
+			cycles[i]--
+			if cycles[i] == 0 {
+				index := indices[i]
+				for j := i; j < n-1; j++ {
+					indices[j] = indices[j+1]
+				}
+				indices[n-1] = index
+				cycles[i] = n - i
+			} else {
+				j := cycles[i]
+				indices[i], indices[n-j] = indices[n-j], indices[i]
+
+				for k := i; k < r; k++ {
+					result[k] = pool[indices[k]]
+				}
+
+				p = make([]int, len(result))
+				copy(p, result)
+				perms = append(perms, p)
+
+				break
+			}
+		}
+
+		if i < 0 {
+			return
+		}
+
+	}
+	return
+}

data/tracks/go/exercises/zebra-puzzle/zebra_puzzle_test.go

@@ -0,0 +1,18 @@
+package zebra
+
+import "testing"
+
+func TestSolvePuzzle(t *testing.T) {
+	expected := Solution{DrinksWater: "Norwegian", OwnsZebra: "Japanese"}
+	actual := SolvePuzzle()
+	if expected != actual {
+		t.Fatalf("FAILED:\nExpected: %#v\nActual: %#v",
+			expected, actual)
+	}
+}
+
+func BenchmarkScore(b *testing.B) {
+	for i := 0; i < b.N; i++ {
+		SolvePuzzle()
+	}
+}

data/tracks/haskell/exercises/forth/package.yaml

@@ -1,5 +1,5 @@
 name: forth
-version: 1.2.0.4
+version: 1.3.0.5
 
 dependencies:
   - base

data/tracks/haskell/exercises/forth/test/Tests.hs

@@ -14,10 +14,7 @@ specs = do
 
     let runTexts = fmap toList . foldM (flip evalText) empty
 
-    describe "parsing and numbers" $ do
-      it "empty input results in empty stack" $
-        toList empty `shouldBe` []
-
+    describe "parsing and numbers" $
       it "numbers just get pushed onto the stack" $
         runTexts ["1 2 3 4 5"] `shouldBe` Right [1, 2, 3, 4, 5]
 

data/tracks/haskell/exercises/pascals-triangle/package.yaml

@@ -1,5 +1,5 @@
 name: pascals-triangle
-version: 1.1.0.4
+version: 1.2.0.5
 
 dependencies:
   - base

data/tracks/haskell/exercises/pascals-triangle/test/Tests.hs

@@ -22,4 +22,25 @@ specs = describe "rows" $ for_ rowsCases rowsTest
                 , ("two rows"     , 2, [[1], [1, 1]                         ])
                 , ("three rows"   , 3, [[1], [1, 1], [1, 2, 1]              ])
                 , ("four rows"    , 4, [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]])
-                , ("negative rows",-1, [                                    ]) ]
+                , ("five rows"    , 5, [[1],
+                                        [1, 1],
+                                        [1, 2, 1],
+                                        [1, 3, 3, 1],
+                                        [1, 4, 6, 4, 1]])
+                , ("six rows"     , 6, [[1],
+                                        [1, 1],
+                                        [1, 2, 1],
+                                        [1, 3, 3, 1],
+                                        [1, 4, 6, 4, 1],
+                                        [1, 5, 10, 10, 5, 1]])
+                , ("ten rows"     ,10, [[1],
+                                        [1, 1],
+                                        [1, 2, 1],
+                                        [1, 3, 3, 1],
+                                        [1, 4, 6, 4, 1],
+                                        [1, 5, 10, 10, 5, 1],
+                                        [1, 6, 15, 20, 15, 6, 1],
+                                        [1, 7, 21, 35, 35, 21, 7, 1],
+                                        [1, 8, 28, 56, 70, 56, 28, 8, 1],
+                                        [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]])
+                , ("negative rows",-1, []) ]

data/tracks/java/POLICIES.md

@@ -33,11 +33,11 @@ References: [[1](https://github.com/exercism/java/issues/177#issuecomment-261291
 
 ### Starter implementations
 
-> - Exercises 1-20: provide stubs for all required constructors and methods. Stubs should include the following body:
+> - Exercises of difficulty 4 or lower: provide stubs for all required constructors and methods. Stubs should include the following body:
     `throw new UnsupportedOperationException("Delete this statement and write your own implementation.");`
-> - Exercises 21+: provide no stubs by default, but either (1) add hints to the hints.md file (which gets merged into the README.md for the exercise) or (2) provide stubs as in exercises 1-20 for exercises that demand complicated method signatures.
+> - Exercises of difficulty 5 or higher: provide no stubs by default, but either (1) add hints to the hints.md file (which gets merged into the README.md for the exercise) or (2) provide stubs as above for exercises that demand complicated method signatures.
 
-References: [[1](https://github.com/exercism/java/issues/178)], [[2](https://github.com/exercism/java/pull/683#discussion_r125506930)]
+References: [[1](https://github.com/exercism/java/issues/178)], [[2](https://github.com/exercism/java/pull/683#discussion_r125506930)], [[3](https://github.com/exercism/java/issues/977)]
 
 ### Avoid using final
 

data/tracks/java/config.json

@@ -166,6 +166,19 @@
       "unlocked_by": "difference-of-squares",
       "uuid": "d0dcc898-ec38-4822-9e3c-1a1829c9b2d9"
     },
+    {
+      "core": false,
+      "difficulty": 3,
+      "slug": "protein-translation",
+      "topics": [
+        "arrays",
+        "conditionals",
+        "loops",
+        "strings"
+      ],
+      "unlocked_by": "rna-transcription",
+      "uuid": "331073b3-bd1a-4868-b767-a64ce9fd9d97"
+    },
     {
       "core": false,
       "difficulty": 4,
@@ -763,7 +776,13 @@
       "core": false,
       "difficulty": 6,
       "slug": "bowling",
-      "topics": null,
+      "topics": [
+        "conditionals",
+        "exception_handling",
+        "games",
+        "integers",
+        "mathematics"
+      ],
       "unlocked_by": "scrabble-score",
       "uuid": "4b3f7771-c642-4278-a3d9-2fb958f26361"
     },
@@ -791,7 +810,7 @@
         "text_formatting"
       ],
       "unlocked_by": "matrix",
-      "uuid": "99191d53-0fed-f680-de7a-55cfb872de17bc58629"
+      "uuid": "486d342e-c834-40fc-b691-a4dab3f790da"
     },
     {
       "core": false,

data/tracks/java/exercises/atbash-cipher/.meta/src/reference/java/Atbash.java

@@ -1,44 +1,44 @@
 import java.util.ArrayList;
 import java.util.List;
 
-public class Atbash {
+class Atbash {
 
     private static final int GROUP_SIZE = 5;
     private static final String PLAIN = "abcdefghijklmnopqrstuvwxyz";
     private static final String CIPHER = "zyxwvutsrqponmlkjihgfedcba";
 
-    public String encode(String input) {
+    String encode(String input) {
         String encoded = stripInvalidCharacters(input).toLowerCase();
-        String cyphered = "";
+        StringBuilder cyphered = new StringBuilder(input.length());
 
         for (char c : encoded.toCharArray()) {
-            cyphered += applyCipher(c);
+            cyphered.append(applyCipher(c));
         }
 
-        return splitIntoFiveLetterWords(cyphered);
+        return splitIntoFiveLetterWords(cyphered.toString());
     }
 
-    public String decode(String input) {
+    String decode(String input) {
         String encoded = stripInvalidCharacters(input).toLowerCase();
-        String deciphered = "";
+        StringBuilder deciphered = new StringBuilder(input.length());
 
         for (char c : encoded.toCharArray()) {
-            deciphered += applyCipher(c);
+            deciphered.append(applyCipher(c));
         }
 
-        return deciphered;
+        return deciphered.toString();
     }
 
     private String stripInvalidCharacters(String input) {
-        String filteredValue = "";
+        StringBuilder filteredValue = new StringBuilder(input.length());
 
         for (char c : input.toCharArray()) {
             if (Character.isLetterOrDigit(c)) {
-                filteredValue += c;
+                filteredValue.append(c);
             }
         }
 
-        return filteredValue;
+        return filteredValue.toString();
     }
 
     private char applyCipher(char input) {

data/tracks/java/exercises/protein-translation/.meta/src/reference/java/ProteinTranslator.java

@@ -0,0 +1,47 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+class ProteinTranslator {
+
+    private static final String[] METHIONINE = {"AUG"};
+    private static final String[] PHENYLALANINE = {"UUU", "UUC"};
+    private static final String[] LEUCINE = {"UUA", "UUG"};
+    private static final String[] SERINE = {"UCU", "UCC", "UCA", "UCG"};
+    private static final String[] TYROSINE = {"UAU", "UAC"};
+    private static final String[] CYSTEINE = {"UGU", "UGC"};
+    private static final String[] TRYPTOPHAN = {"UGG"};
+    private static final String[] STOP = {"UAA", "UAG", "UGA"};
+
+    List<String> translate(String rnaSequence) {
+
+        List<String> proteinList = new ArrayList<String>();
+
+        for (int i = 0; i < rnaSequence.length(); i += 3) {
+            String codon = rnaSequence.substring(i, i+3);
+
+            if (Arrays.asList(METHIONINE).contains(codon)) {
+                proteinList.add("Methionine");
+            } else if (Arrays.asList(PHENYLALANINE).contains(codon)) {
+                proteinList.add("Phenylalanine");
+            } else if (Arrays.asList(LEUCINE).contains(codon)) {
+                proteinList.add("Leucine");
+            } else if (Arrays.asList(SERINE).contains(codon)) {
+                proteinList.add("Serine");
+            } else if (Arrays.asList(TYROSINE).contains(codon)) {
+                proteinList.add("Tyrosine");
+            } else if (Arrays.asList(CYSTEINE).contains(codon)) {
+                proteinList.add("Cysteine");
+            } else if (Arrays.asList(TRYPTOPHAN).contains(codon)) {
+                proteinList.add("Tryptophan");
+            } else if (Arrays.asList(STOP).contains(codon)) {
+                break;
+            } else {
+                throw new IllegalArgumentException("Invalid input");
+            }
+
+        }
+
+        return proteinList;
+    }
+}

data/tracks/java/exercises/protein-translation/.meta/version

@@ -0,0 +1 @@
+1.0.0

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

@@ -0,0 +1,58 @@
+#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 three 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))
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## 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/java/exercises/protein-translation/build.gradle

@@ -0,0 +1,18 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

data/tracks/java/exercises/protein-translation/src/main/java/ProteinTranslator.java

@@ -0,0 +1,8 @@
+import java.util.List;
+
+class ProteinTranslator {
+
+    List<String> translate(String rnaSequence) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+}