trackler 2.0.8.22 → 2.0.8.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 28265fe418af7d9c5995b20eb82d68a92ddf07b2
-  data.tar.gz: cd16284994158ed45cf56925c5565d87d5868ffc
+  metadata.gz: 9a1f212f5e5a8fe0bd77c82df4bb702031173e6a
+  data.tar.gz: f69ad361660445af45147b30a15af3bb30028a46
 SHA512:
-  metadata.gz: a5dc72ae892154a72cc837452319410d2e29ce9b5713323cb0e6ac9c3116e41b815bb34d2f541f246a0a92c213b4e39f94c2d5517d0c8f970d6ee5d9871be2e1
-  data.tar.gz: 56866b238c8d404534442171cd70ab349349f79a380dcae93f1cc498ed9e3d9faad92907fc7acabdd759d165bb31da0ef4f231b554d108188d9df0c4f4d740de
+  metadata.gz: b0c6afffb4a75f583baf4673a4b88c6b8f27ec0d9c91732abdd13823ac97e1663c24b14b891477fddc97e273997a09df02ec50590909400960a0e8a6f9aebc6e
+  data.tar.gz: ca2bbf86a9563cb67f6577505b5e7a7bce225cbdc6edb380cd7595b9a868e5661384ffbec352580083aa0b67564e329195a8612d74a47084e47b46fe5d6b6f23

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.0.8.22"
+  VERSION = "2.0.8.23"
 end

data/tracks/csharp/exercises/accumulate/HINTS.md

@@ -1,3 +1,2 @@
 ## Hints
-This exercise requires you to write an extension method. For more information, see [this page] 
-(https://msdn.microsoft.com/en-us//library/bb383977.aspx).
+This exercise requires you to write an extension method. For more information, see [this page](https://msdn.microsoft.com/en-us//library/bb383977.aspx).

data/tracks/csharp/exercises/nth-prime/HINTS.md

@@ -0,0 +1,7 @@
+## Hints
+
+For this exercise the following C# feature comes in handy: 
+Enumerables are evaluated lazily.    They allow you to work with an infinite sequence of values.
+See [this article](https://blogs.msdn.microsoft.com/pedram/2007/06/02/lazy-evaluation-in-c/).
+
+Note: to help speedup calculation, you should not check numbers which you know beforehand will never be prime. For more information, see the [Sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes).

data/tracks/csharp/exercises/proverb/HINTS.md

@@ -0,0 +1,3 @@
+## HINTS
+
+Try to capture the structure of the song in your code, where you build up the song by composing its parts.

data/tracks/go/exercises/trinary/trinary_test.go

@@ -22,7 +22,7 @@ var tests = []struct {
 
 func TestTestVersion(t *testing.T) {
 	if testVersion != targetTestVersion {
-		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
 	}
 }
 

data/tracks/go/exercises/twelve-days/twelve_days_test.go

@@ -52,6 +52,12 @@ func diff(got, want string) string {
 	}
 }
 
+func TestTestVersion(t *testing.T) {
+	if testVersion != targetTestVersion {
+		t.Fatalf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
+	}
+}
+
 func TestSong(t *testing.T) {
 	var expected = ""
 	for _, test := range testCases {
@@ -71,9 +77,3 @@ func TestVerse(t *testing.T) {
 		}
 	}
 }
-
-func TestTestVersion(t *testing.T) {
-	if testVersion != targetTestVersion {
-		t.Errorf("Found testVersion = %v, want %v.", testVersion, targetTestVersion)
-	}
-}

data/tracks/java/config.json

@@ -3,6 +3,7 @@
   "language": "Java",
   "repository": "https://github.com/exercism/xjava",
   "active": true,
+
   "exercises": [
     {
       "slug": "hello-world",
@@ -313,6 +314,16 @@
       "slug": "ocr-numbers",
       "difficulty": 1,
       "topics": []
+    },
+     {
+      "slug": "isogram",
+      "difficulty": 1,
+      "topics": []
+    },
+    {
+      "slug": "book-store",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [
@@ -335,3 +346,4 @@
     "say"
   ]
 }
+

data/tracks/java/exercises/book-store/build.gradle

@@ -0,0 +1,17 @@
+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/book-store/src/example/java/Bookstore.java

@@ -0,0 +1,61 @@
+import java.awt.print.Printable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Bookstore{
+
+	private static int BOOK_PRICE = 8, MAX_GROUP_SIZE = 5;
+	private List<Integer> books;
+	private static double[] DISCOUNT_TIERS = {0,5,10,20,25};   	
+
+	public Bookstore (List<Integer> books){
+		this.books = books;
+	}	
+	
+
+
+
+	public double calculateTotalCost(){
+		return calculateTotalCost(this.books,0);
+	}
+
+	private double calculateTotalCost (List<Integer> books,double priceSoFar ){
+		double minPrice = Double.MAX_VALUE;
+
+
+		if(books.size() == 0){
+			return priceSoFar;
+		}
+
+		List<Integer> groups = (ArrayList<Integer>) books.stream().distinct().collect(Collectors.toList());
+
+		
+		double price = 0;
+
+		for(int i = 0;i<groups.size();i++){
+			books.remove(groups.get(i));	
+		}
+				
+		try {
+			price = calculateTotalCost(books,priceSoFar + costPerGroup(groups.size()));
+		} catch (Exception e) {
+			e.printStackTrace();
+		}
+		
+		minPrice = Math.min(minPrice, price);
+		return minPrice;
+
+
+	}
+
+	private double costPerGroup(int groupSize) throws Exception{
+		if (groupSize < 1 || groupSize > MAX_GROUP_SIZE){
+        		throw new Exception("Invalid group size : " + groupSize );
+     		}
+    		return BOOK_PRICE * groupSize * (100 - DISCOUNT_TIERS[groupSize-1])/100;
+	}
+
+
+}

data/tracks/java/exercises/book-store/src/test/java/BookstoreTest.java

@@ -0,0 +1,117 @@
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import org.junit.Test;
+
+public class BookstoreTest{
+
+	@Test
+	public void onlyASingleBook(){
+		List<Integer> books = new ArrayList<>(Arrays.asList(1));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(8,bookstore.calculateTotalCost(),2);
+	}
+	
+	@Ignore
+	@Test
+	public void twoOfSameBook(){
+		List<Integer> books = new ArrayList<>(Arrays.asList(1,1));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(16,bookstore.calculateTotalCost(),2);
+	}
+
+	@Ignore
+	@Test
+	public void emptyBasket(){
+		List<Integer> books = new ArrayList<>();
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(0,bookstore.calculateTotalCost(),2);
+	}
+
+	@Ignore
+	@Test
+	public void twoDifferentBooks(){
+		List<Integer> books = new ArrayList<>(Arrays.asList(1,2));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(15.20,bookstore.calculateTotalCost(),2);
+	}
+
+	@Ignore
+	@Test
+	public void threeDifferentBooks(){
+		List<Integer> books = new ArrayList<>(Arrays.asList(1,2,3));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(21.6,bookstore.calculateTotalCost(),2);
+	}
+
+	@Ignore
+	@Test
+	public void fourDifferentBooks(){
+		ArrayList<Integer> books = new ArrayList<>(Arrays.asList(1,2,3,4));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(25.6,bookstore.calculateTotalCost(),2);
+
+	}
+
+	@Ignore
+	@Test
+	public void fiveDifferentBooks(){
+		ArrayList<Integer> books = new ArrayList<>(Arrays.asList(1,2,3,4,5));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(30,bookstore.calculateTotalCost(),2);
+	}
+
+	@Ignore
+	@Test
+	public void twoGroupsOfFourIsCheaperThanGroupOfFivePlusGroupOfThree(){
+		List<Integer> books = new ArrayList<>(Arrays.asList(1,1,2,2,3,3,4,5));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(51.20,bookstore.calculateTotalCost(),2);
+	}
+
+	@Ignore
+	@Test
+	public void groupOfFourPlusGroupOfTwoIsCheaperThanTwoGroupsOfThree(){
+		List<Integer> books = new ArrayList<>(Arrays.asList(1,1,2,2,3,4));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(40.8,bookstore.calculateTotalCost(),2);
+	}
+
+	@Ignore
+	@Test
+	public void twoEachOfFirst4BooksAnd1CopyEachOfRest(){
+		Integer[] p = {1,1,2,2,3,3,4,4,5};
+		List<Integer> books = new ArrayList<>(Arrays.asList(1,1,2,2,3,3,4,4,5));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(55.60,bookstore.calculateTotalCost(),2);
+	}
+
+	@Ignore
+	@Test
+	public void twoCopiesOfEachBook(){
+		List<Integer> books = new ArrayList<>(Arrays.asList(1,1,2,2,3,3,4,4,5,5));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(60.00,bookstore.calculateTotalCost(),2);
+	}
+
+	@Ignore
+	@Test
+	public void threeCopiesOfFirstBookAnd2EachOfRemaining(){
+		List<Integer> books = new ArrayList<>(Arrays.asList(1,1,2,2,3,3,4,4,5,5,1));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(68.00,bookstore.calculateTotalCost(),2);
+	}
+
+	@Ignore
+	@Test
+	public void threeEachOFirst2BooksAnd2EachOfRemainingBooks(){
+		List<Integer> books = new ArrayList<>(Arrays.asList(1,1,2,2,3,3,4,4,5,5,1,2));
+		Bookstore bookstore = new Bookstore(books);
+		assertEquals(75.20,bookstore.calculateTotalCost(),2);
+	}
+
+}
+

data/tracks/java/exercises/hamming/src/example/java/Hamming.java

@@ -1,6 +1,15 @@
 public class Hamming {
+    private final int hammingDistance;
 
-    public static int compute(String leftStrand, String rightStrand) {
+    public Hamming(String leftStrand, String rightStrand) {
+        hammingDistance = computeHammingDistance(leftStrand, rightStrand);
+    }
+
+    public int getHammingDistance() {
+        return hammingDistance;
+    }
+
+    private int computeHammingDistance(String leftStrand, String rightStrand) {
         if(leftStrand.length() != rightStrand.length()) {
             throw new IllegalArgumentException("leftStrand and rightStrand must be of equal length.");
         }
@@ -13,7 +22,7 @@ public class Hamming {
         return distance;
     }
 
-    private static int hammingContributionAt(int index, String leftStrand, String rightStrand) {
+    private int hammingContributionAt(int index, String leftStrand, String rightStrand) {
       return leftStrand.charAt(index) != rightStrand.charAt(index) ? 1 : 0;
     }
 

data/tracks/java/exercises/hamming/src/test/java/HammingTest.java

@@ -7,64 +7,63 @@ import org.junit.Rule;
 import org.junit.rules.ExpectedException;
 
 public class HammingTest {
-    
 
     @Rule
     public ExpectedException thrown = ExpectedException.none();
     
     @Test
     public void testNoDifferenceBetweenIdenticalStrands() {
-        assertThat(Hamming.compute("A", "A"), is(0));
+        assertThat(new Hamming("A", "A").getHammingDistance(), is(0));
     }
 
     @Ignore
     @Test
     public void testHammingDistanceForSingleNucleotideStrand() {
-        assertThat(Hamming.compute("A", "G"), is(1));
+        assertThat(new Hamming("A", "G").getHammingDistance(), is(1));
     }
 
     @Ignore
     @Test
     public void testHammingDistanceForSmallStrand() {
-        assertThat(Hamming.compute("AG", "CT"), is(2)); 
+        assertThat(new Hamming("AG", "CT").getHammingDistance(), is(2));
     }
 
     @Ignore
     @Test
     public void testSmallHammingDistance() {
-        assertThat(Hamming.compute("AT", "CT"), is(1));
+        assertThat(new Hamming("AT", "CT").getHammingDistance(), is(1));
     }
 
     @Ignore
     @Test
     public void testSmallHammingDistanceInLongerStrand() {
-        assertThat(Hamming.compute("GGACG", "GGTCG"), is(1));
+        assertThat(new Hamming("GGACG", "GGTCG").getHammingDistance(), is(1));
     }
 
     @Ignore
     @Test
     public void testValidatesFirstStrandNotLonger() {
         thrown.expect(IllegalArgumentException.class);
-        Hamming.compute("AAAG", "AAA");                
+        new Hamming("AAAG", "AAA");
     }
 
     @Ignore
     @Test
     public void testValidatesOtherStrandNotLonger() {
         thrown.expect(IllegalArgumentException.class);
-        Hamming.compute("AAA", "AAAG");
+        new Hamming("AAA", "AAAG");
     }
 
     @Ignore
     @Test
     public void testLargeHammingDistance() {
-        assertThat(Hamming.compute("GATACA", "GCATAA"), is(4));
+        assertThat(new Hamming("GATACA", "GCATAA").getHammingDistance(), is(4));
     }
 
     @Ignore
     @Test
     public void testHammingDistanceInVeryLongStrand() {
-        assertThat(Hamming.compute("GGACGGATTCTG", "AGGACGGATTCT"), is(9));
+        assertThat(new Hamming("GGACGGATTCTG", "AGGACGGATTCT").getHammingDistance(), is(9));
     }
 
 }

data/tracks/java/exercises/isogram/build.gradle

@@ -0,0 +1,17 @@
+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/isogram/src/example/java/IsogramChecker.java

@@ -0,0 +1,34 @@
+package example;
+
+import java.util.HashSet;
+import java.util.Set;
+import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.joining;
+
+public class IsogramChecker {
+	
+	public IsogramChecker(){
+	}
+	
+	public boolean isIsogram(String word){
+		
+		Set<Character> charSet = new HashSet<>();
+		
+		String[] words = word.split(" ");
+		String newWord = concat(words);
+		
+		words = newWord.split("-");
+		newWord = concat(words).toLowerCase();
+		
+		for(int i = 0; i < newWord.length(); i++){
+			charSet.add(newWord.charAt(i));
+		}
+		
+		return charSet.size() == newWord.length();
+	}
+	
+	private String concat(String[] words){
+		return stream(words).collect(joining());
+	}
+	
+}

data/tracks/java/exercises/isogram/src/test/java/IsogramTest.java

@@ -0,0 +1,80 @@
+package test;
+
+import static org.junit.Assert.*;
+
+import org.junit.Ignore;
+import org.junit.Test;
+import example.IsogramChecker;
+
+public class IsogramTest {
+
+	@Test
+	public void testIsogram() {
+		IsogramChecker iso = new IsogramChecker();
+		assertTrue(iso.isIsogram("duplicates"));
+	}
+	
+	@Ignore
+	@Test
+	public void testNotIsogram() {
+		IsogramChecker iso = new IsogramChecker();
+		assertFalse(iso.isIsogram("eleven"));
+	}
+	
+	@Ignore
+	@Test
+	public void testMediumLongIsogram() {
+		IsogramChecker iso = new IsogramChecker();
+		assertTrue(iso.isIsogram("subdermatoglyphic"));
+	}
+	
+	@Ignore
+	@Test
+	public void testCaseInsensitive() {
+		IsogramChecker iso = new IsogramChecker();
+		assertFalse(iso.isIsogram("Alphabet"));
+	}
+	
+	@Ignore
+	@Test
+	public void testIsogramWithHyphen() {
+		IsogramChecker iso = new IsogramChecker();
+		assertTrue(iso.isIsogram("thumbscrew-japingly"));
+	}
+	
+	@Ignore
+	@Test
+	public void testIgnoresMultipleHyphens() {
+		IsogramChecker iso = new IsogramChecker();
+		assertTrue(iso.isIsogram("Hjelmqvist-Gryb-Zock-Pfund-Wax"));
+	}
+	
+	@Ignore
+	@Test
+	public void testWorksWithGermanLetters() {
+		IsogramChecker iso = new IsogramChecker();
+		assertTrue(iso.isIsogram("Heizölrückstoßabdämpfung"));
+	}
+	
+	@Ignore
+	@Test
+	public void testIgnoresSpaces() {
+		IsogramChecker iso = new IsogramChecker();
+		assertFalse(iso.isIsogram("the quick brown fox"));
+	}
+	
+	@Ignore
+	@Test
+	public void testIgnoresSpaces2() {
+		IsogramChecker iso = new IsogramChecker();
+		assertTrue(iso.isIsogram("Emily Jung Schwartzkopf"));
+	}
+	
+	@Ignore
+	@Test
+	public void testDuplicateAccentedLetters() {
+		IsogramChecker iso = new IsogramChecker();
+		assertFalse(iso.isIsogram("éléphant"));
+	}
+
+}

data/tracks/java/exercises/raindrops/src/example/java/{Raindrops.java → RaindropConverter.java}

@@ -1,6 +1,6 @@
-public class Raindrops {
+public class RaindropConverter {
 
-    public static String convert(int number) {
+    public String convert(int number) {
         String result = "";
 
         if (number % 3 == 0) {

data/tracks/java/exercises/raindrops/src/test/java/{RaindropsTest.java → RaindropConverterTest.java}

@@ -10,7 +10,7 @@ import java.util.Collection;
 import static org.junit.Assert.assertEquals;
 
 @RunWith(Parameterized.class)
-public class RaindropsTest {
+public class RaindropConverterTest {
 
     private int inputNumber;
     private String outputFromRaindropConversion;
@@ -46,7 +46,7 @@ public class RaindropsTest {
         });
     }
 
-    public RaindropsTest(int inputNumber, String outputFromRaindropConversion) {
+    public RaindropConverterTest(int inputNumber, String outputFromRaindropConversion) {
         this.inputNumber = inputNumber;
         this.outputFromRaindropConversion = outputFromRaindropConversion;
     }
@@ -54,6 +54,6 @@ public class RaindropsTest {
 
     @Test
     public void test() {
-        assertEquals(outputFromRaindropConversion, Raindrops.convert(inputNumber));
+        assertEquals(outputFromRaindropConversion, new RaindropConverter().convert(inputNumber));
     }
 }

data/tracks/java/exercises/settings.gradle

@@ -9,6 +9,7 @@ include 'binary'
 include 'binary-search'
 include 'binary-search-tree'
 include 'bob'
+include 'book-store'
 include 'bracket-push'
 include 'change'
 include 'clock'
@@ -23,6 +24,7 @@ include 'grade-school'
 include 'hamming'
 include 'hexadecimal'
 include 'hello-world'
+include 'isogram'
 include 'largest-series-product'
 include 'linked-list'
 include 'list-ops'

data/tracks/ocaml/.vscode/launch.json

@@ -0,0 +1,13 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "OCaml",
+      "type": "ocamldebug",
+      "request": "launch",
+      "program": "/home/steve/dev/exercism/xocaml/tools/test-generator/debug.byte",
+      "console": "internalConsole",
+      "stopOnEntry": false
+    }
+  ]
+}

data/tracks/ocaml/config.json

@@ -71,6 +71,11 @@
       "difficulty": 3,
       "topics": []
     },
+    {
+      "slug": "triangle",
+      "difficulty": 3,
+      "topics": ["Mathematics"]
+    },
     {
       "slug": "pangram",
       "difficulty": 3,