trackler 2.0.0.8 → 2.0.0.9

data/tracks/java/exercises/nucleotide-count/src/test/java/NucleotideTest.java

@@ -7,87 +7,87 @@ import org.junit.Ignore;
 public class NucleotideTest {
 
     @Test
-  public void testEmptyDnaStringHasNoAdenosine() {
-    DNA dna = new DNA("");
-    assertThat(dna.count('A')).isEqualTo(0);
-  }
+    public void testEmptyDnaStringHasNoAdenosine() {
+        DNA dna = new DNA("");
+        assertThat(dna.count('A')).isEqualTo(0);
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testEmptyDnaStringHasNoNucleotides() {
-    DNA dna = new DNA("");
-    assertThat(dna.nucleotideCounts()).hasSize(4).contains(
-        entry('A', 0),
-        entry('C', 0),
-        entry('G', 0),
-        entry('T', 0)
-    );
-  }
+    public void testEmptyDnaStringHasNoNucleotides() {
+        DNA dna = new DNA("");
+        assertThat(dna.nucleotideCounts()).hasSize(4).contains(
+            entry('A', 0),
+            entry('C', 0),
+            entry('G', 0),
+            entry('T', 0)
+        );
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testRepetitiveCytidineGetsCounted() {
-    DNA dna = new DNA("CCCCC");
-    assertThat(dna.count('C')).isEqualTo(5);
-  }
+    public void testRepetitiveCytidineGetsCounted() {
+        DNA dna = new DNA("CCCCC");
+        assertThat(dna.count('C')).isEqualTo(5);
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testRepetitiveSequenceWithOnlyGuanosine() {
-    DNA dna = new DNA("GGGGGGGG");
-    assertThat(dna.nucleotideCounts()).hasSize(4).contains(
-        entry('A', 0),
-        entry('C', 0),
-        entry('G', 8),
-        entry('T', 0)
-    );
-  }
+    public void testRepetitiveSequenceWithOnlyGuanosine() {
+        DNA dna = new DNA("GGGGGGGG");
+        assertThat(dna.nucleotideCounts()).hasSize(4).contains(
+            entry('A', 0),
+            entry('C', 0),
+            entry('G', 8),
+            entry('T', 0)
+        );
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testCountsOnlyThymidine() {
-    DNA dna = new DNA("GGGGGTAACCCGG");
-    assertThat(dna.count('T')).isEqualTo(1);
-  }
+    public void testCountsOnlyThymidine() {
+        DNA dna = new DNA("GGGGGTAACCCGG");
+        assertThat(dna.count('T')).isEqualTo(1);
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testCountsANucleotideOnlyOnce() {
-    DNA dna = new DNA("CGATTGGG");
-    dna.count('T');
-    assertThat(dna.count('T')).isEqualTo(2);
-  }
+    public void testCountsANucleotideOnlyOnce() {
+        DNA dna = new DNA("CGATTGGG");
+        dna.count('T');
+        assertThat(dna.count('T')).isEqualTo(2);
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testDnaCountsDoNotChangeAfterCountingAdenosine() {
-    DNA dna = new DNA("GATTACA");
-    dna.count('A');
-    assertThat(dna.nucleotideCounts()).hasSize(4).contains(
-        entry('A', 3),
-        entry('C', 1),
-        entry('G', 1),
-        entry('T', 2)
-    );
-  }
+    public void testDnaCountsDoNotChangeAfterCountingAdenosine() {
+        DNA dna = new DNA("GATTACA");
+        dna.count('A');
+        assertThat(dna.nucleotideCounts()).hasSize(4).contains(
+            entry('A', 3),
+            entry('C', 1),
+            entry('G', 1),
+            entry('T', 2)
+        );
+    }
 
-  @Ignore
+    @Ignore
     @Test(expected = IllegalArgumentException.class)
-  public void testValidatesNucleotides() {
-    DNA dna = new DNA("GACT");
-    dna.count('X');
-  }
+    public void testValidatesNucleotides() {
+        DNA dna = new DNA("GACT");
+        dna.count('X');
+    }
 
-  @Ignore
+    @Ignore
     @Test
-  public void testCountsAllNucleotides() {
-    String s = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC";
-    DNA dna = new DNA(s);
-    assertThat(dna.nucleotideCounts()).hasSize(4).contains(
-        entry('A', 20),
-        entry('C', 12),
-        entry('G', 17),
-        entry('T', 21)
-    );
-  }
+    public void testCountsAllNucleotides() {
+        String s = "AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC";
+        DNA dna = new DNA(s);
+        assertThat(dna.nucleotideCounts()).hasSize(4).contains(
+            entry('A', 20),
+            entry('C', 12),
+            entry('G', 17),
+            entry('T', 21)
+        );
+    }
 }

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

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

data/tracks/java/exercises/series/src/example/java/Series.java

@@ -0,0 +1,39 @@
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class Series {
+
+    private final int digitsSize;
+    private List<Integer> digits;
+
+    public Series(String string) {
+        this.digits = Arrays
+                .asList(string.split(("")))
+                .stream()
+                .map(digit -> Integer.parseInt(digit))
+                .collect(Collectors.toList());
+        this.digitsSize = this.digits.size();
+    }
+
+    public List<List<Integer>> slices(int num) {
+        if (num > this.digitsSize) {
+            throw new IllegalArgumentException("Slice size is too big.");
+        }
+        final int limit = this.digitsSize - num + 1;
+        List<List<Integer>> result = new ArrayList<>(limit);
+        List<Integer> tmp;
+        for (int i = 0; i < limit; i++) {
+            tmp = this.digits.subList(i, i + num);
+            result.add(tmp);
+        }
+        return result;
+    }
+
+    public List<Integer> getDigits() {
+        return digits;
+    }
+
+}

data/tracks/java/exercises/series/src/main/java/Series.java

@@ -0,0 +1,3 @@
+public class Series {
+    
+}

data/tracks/java/exercises/series/src/test/java/SeriesTest.java

@@ -0,0 +1,154 @@
+
+import java.util.Arrays;
+import java.util.List;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import org.junit.Ignore;
+
+public class SeriesTest {
+
+    @Test
+    public void hasDigitsShort() {
+        Series sut = new Series("01234");
+        List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4);
+        List<Integer> actual = sut.getDigits();
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void hasDigitsLong() {
+        Series sut = new Series("0123456789");
+        List<Integer> expected = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+        List<Integer> actual = sut.getDigits();
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void keepsTheDigitOrderIfReversed() {
+        Series sut = new Series("9876543210");
+        List<Integer> expected = Arrays.asList(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
+        List<Integer> actual = sut.getDigits();
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void keepsArbitraryDigitOrder() {
+        Series sut = new Series("936923468");
+        List<Integer> expected = Arrays.asList(9, 3, 6, 9, 2, 3, 4, 6, 8);
+        List<Integer> actual = sut.getDigits();
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByOne() {
+        Series sut = new Series("01234");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(0),
+                Arrays.asList(1),
+                Arrays.asList(2),
+                Arrays.asList(3),
+                Arrays.asList(4)
+        );
+        List<List<Integer>> actual = sut.slices(1);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByTwo() {
+        Series sut = new Series("98273463");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(9, 8),
+                Arrays.asList(8, 2),
+                Arrays.asList(2, 7),
+                Arrays.asList(7, 3),
+                Arrays.asList(3, 4),
+                Arrays.asList(4, 6),
+                Arrays.asList(6, 3)
+        );
+        List<List<Integer>> actual = sut.slices(2);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByThree() {
+        Series sut = new Series("01234");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(0, 1, 2),
+                Arrays.asList(1, 2, 3),
+                Arrays.asList(2, 3, 4)
+        );
+        List<List<Integer>> actual = sut.slices(3);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByThreeWithDuplicateDigits() {
+        Series sut = new Series("31001");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(3, 1, 0),
+                Arrays.asList(1, 0, 0),
+                Arrays.asList(0, 0, 1)
+        );
+        List<List<Integer>> actual = sut.slices(3);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByFour() {
+        Series sut = new Series("91274");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(9, 1, 2, 7),
+                Arrays.asList(1, 2, 7, 4)
+        );
+        List<List<Integer>> actual = sut.slices(4);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @Ignore
+    public void canSliceByFive() {
+        Series sut = new Series("81228");
+        List<List<Integer>> expected = Arrays.asList(
+                Arrays.asList(8, 1, 2, 2, 8)
+        );
+        List<List<Integer>> actual = sut.slices(5);
+        assertNotNull(actual);
+        assertFalse(actual.isEmpty());
+        assertEquals(expected, actual);
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    @Ignore
+    public void throwsAnErrorIfNotEnoughDigitsToSlice() {
+        new Series("01032987583").slices(12);
+    }
+}

data/tracks/java/exercises/settings.gradle

@@ -17,6 +17,7 @@ include 'hello-world'
 include 'largest-series-product'
 include 'linked-list'
 include 'luhn'
+include 'minesweeper'
 include 'meetup'
 include 'nth-prime'
 include 'nucleotide-count'
@@ -32,6 +33,7 @@ include 'robot-name'
 include 'roman-numerals'
 include 'prime-factors'
 include 'scrabble-score'
+include 'series'
 include 'sieve'
 include 'simple-cipher'
 include 'simple-linked-list'