trackler 2.0.6.22 → 2.0.6.23

data/tracks/java/exercises/grade-school/src/example/java/School.java

@@ -1,38 +1,39 @@
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
+import java.util.*;
 
 public class School {
 
-  private final Map<Integer, Set<String>> database = new HashMap<Integer, Set<String>>();
+  private final Map<Integer, List<String>> database = new HashMap<>();
 
-  public Map<Integer, Set<String>> db() {
-    // Leaks internal storage to caller
-    return database;
+  public int numberOfStudents() {
+    int result = 0;
+    for (List<String> studentsInGrade: database.values()) {
+      result += studentsInGrade.size();
+    }
+    return result;
   }
 
   public void add(String student, int grade) {
-    Set<String> students = grade(grade);
+    List<String> students = fetchGradeFromDatabase(grade);
     students.add(student);
   }
 
-  public Set<String> grade(int grade) {
-    // Leaks internal storage to caller
+  public List<String> grade(int grade) {
+    return new ArrayList<>(fetchGradeFromDatabase(grade));
+  }
+
+  private List<String> fetchGradeFromDatabase(int grade) {
     if (!database.containsKey(grade)) {
-      database.put(grade, new TreeSet<String>());
+      database.put(grade, new LinkedList<>());
     }
     return database.get(grade);
   }
 
-  public Map<Integer, List<String>> sort() {
-    Map<Integer, List<String>> sortedStudents = new HashMap<Integer, List<String>>();
+  public Map<Integer, List<String>> studentsByGradeAlphabetical() {
+    Map<Integer, List<String>> sortedStudents = new HashMap<>();
     for (Integer grade : database.keySet()) {
-      // Relies on using a TreeSet internally
-      List<String> sortedGrade = new ArrayList<String>(database.get(grade));
-      sortedStudents.put(grade, sortedGrade);
+      List<String> studentsInGrade = database.get(grade);
+      Collections.sort(studentsInGrade);
+      sortedStudents.put(grade, studentsInGrade);
     }
     return sortedStudents;
   }

data/tracks/java/exercises/grade-school/src/test/java/SchoolTest.java

@@ -1,28 +1,32 @@
 import org.junit.Ignore;
 import org.junit.Test;
 
+import java.lang.Integer;
+import java.util.*;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
 import static org.hamcrest.CoreMatchers.*;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
 
 public class SchoolTest {
   private final School school = new School();
 
-
   @Test
   public void startsWithNoStudents() {
-    assertTrue(school.db().isEmpty());
+    assertThat(school.numberOfStudents(), is(0));
   }
 
   @Ignore
   @Test
   public void addsStudents() {
     school.add("Aimee", 2);
-    assertThat(school.db().get(2), hasItem("Aimee"));
+    assertThat(school.grade(2), hasItem("Aimee"));
   }
 
   @Ignore
@@ -33,8 +37,8 @@ public class SchoolTest {
     school.add("Blair", grade);
     school.add("Paul", grade);
 
-    assertThat(school.db().get(grade).size(), is(3));
-    assertThat(school.db().get(grade), allOf(hasItem("James"), hasItem("Blair"), hasItem("Paul")));
+    assertThat(school.grade(grade).size(), is(3));
+    assertThat(school.grade(grade), allOf(hasItem("James"), hasItem("Blair"), hasItem("Paul")));
   }
 
   @Ignore
@@ -43,27 +47,30 @@ public class SchoolTest {
     school.add("Chelsea", 3);
     school.add("Logan", 7);
 
-    assertThat(school.db().size(), is(2));
-    assertThat(school.db().get(3).size(), is(1));
-    assertThat(school.db().get(3), hasItem("Chelsea"));
-    assertThat(school.db().get(7).size(), is(1));
-    assertThat(school.db().get(7), hasItem("Logan"));
+    assertThat(school.numberOfStudents(), is(2));
+    assertThat(school.grade(3).size(), is(1));
+    assertThat(school.grade(3), hasItem("Chelsea"));
+    assertThat(school.grade(7).size(), is(1));
+    assertThat(school.grade(7), hasItem("Logan"));
   }
 
   @Ignore
   @Test
-  public void getsStudentsInAGrade() {
-    school.add("Franklin", 5);
-    school.add("Bradley", 5);
-    school.add("Jeff", 1);
-    assertThat(school.grade(5).size(), is(2));
-    assertThat(school.grade(5), allOf(hasItem("Franklin"), hasItem("Bradley")));
+  public void getsStudentsInEmptyGrade() {
+    assertTrue(school.grade(1).isEmpty());
   }
 
   @Ignore
   @Test
-  public void getsStudentsInEmptyGrade() {
-    assertTrue(school.grade(1).isEmpty());
+  public void gradeReturnsStudentsInTheOrderTheyWereInserted() {
+    int grade = 4;
+    school.add("Bartimaeus", grade);
+    school.add("Nathaniel", grade);
+    school.add("Faquarl", grade);
+    List<String> studentsInGrade = school.grade(grade);
+    assertThat(studentsInGrade.get(0), is("Bartimaeus"));
+    assertThat(studentsInGrade.get(1), is("Nathaniel"));
+    assertThat(studentsInGrade.get(2), is("Faquarl"));
   }
 
   @Ignore
@@ -77,6 +84,32 @@ public class SchoolTest {
     sortedStudents.put(6, Arrays.asList("Kareem"));
     sortedStudents.put(4, Arrays.asList("Christopher", "Jennifer"));
     sortedStudents.put(3, Arrays.asList("Kyle"));
-    assertEquals(school.sort(), sortedStudents);
+    assertEquals(school.studentsByGradeAlphabetical(), sortedStudents);
+  }
+
+  @Ignore
+  @Test
+  public void modifyingFetchedGradeShouldNotModifyInternalDatabase() {
+    String shouldNotBeAdded = "Should not be added to school";
+    int grade = 1;
+
+    List<String> students = school.grade(grade);
+    students.add(shouldNotBeAdded);
+
+    assertThat(school.grade(grade), not(hasItem(shouldNotBeAdded)));
+  }
+
+  @Ignore
+  @Test
+  public void modifyingSortedStudentsShouldNotModifyInternalDatabase() {
+    int grade = 2;
+    String studentWhichShouldNotBeAdded = "Should not be added";
+    List<String> listWhichShouldNotBeAdded = new ArrayList<>();
+    listWhichShouldNotBeAdded.add(studentWhichShouldNotBeAdded);
+
+    Map<Integer, List<String>> sortedStudents = school.studentsByGradeAlphabetical();
+    sortedStudents.put(grade,listWhichShouldNotBeAdded);
+
+    assertThat(school.studentsByGradeAlphabetical().get(grade), not(hasItem(studentWhichShouldNotBeAdded)));
   }
 }

data/tracks/java/exercises/secret-handshake/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/secret-handshake/src/example/java/HandshakeCalculator.java

@@ -0,0 +1,29 @@
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+final class HandshakeCalculator {
+
+    private static final int REVERSE_SIGNALS_BIT_POSITION = 4;
+
+    List<Signal> calculateHandshake(final int number) {
+        final List<Signal> result = new ArrayList<>();
+
+        for (final Signal signal : Signal.values()) {
+            if (isBitSet(signal.ordinal(), number)) {
+                result.add(signal);
+            }
+        }
+
+        if (isBitSet(REVERSE_SIGNALS_BIT_POSITION, number)) {
+            Collections.reverse(result);
+        }
+
+        return result;
+    }
+
+    private boolean isBitSet(final int position, final int number) {
+        return ((number >> position) & 1) == 1;
+    }
+
+}

data/tracks/java/exercises/secret-handshake/src/example/java/Signal.java

@@ -0,0 +1 @@
+tracks/java/exercises/secret-handshake/src/example/java/../../main/java/Signal.java

data/tracks/java/exercises/secret-handshake/src/main/java/HandshakeCalculator.java

@@ -0,0 +1,5 @@
+final class HandshakeCalculator {
+
+
+
+}

data/tracks/java/exercises/secret-handshake/src/main/java/Signal.java

@@ -0,0 +1,5 @@
+enum Signal {
+
+    WINK, DOUBLE_BLINK, CLOSE_YOUR_EYES, JUMP
+
+}

data/tracks/java/exercises/secret-handshake/src/test/java/HandshakeCalculatorTest.java

@@ -0,0 +1,106 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+import static org.junit.Assert.assertEquals;
+
+public final class HandshakeCalculatorTest {
+
+    @Test
+    public void testThatInput1YieldsAWink() {
+        assertEquals(
+                singletonList(Signal.WINK),
+                new HandshakeCalculator().calculateHandshake(1));
+    }
+
+    @Ignore
+    @Test
+    public void testThatInput2YieldsADoubleBlink() {
+        assertEquals(
+                singletonList(Signal.DOUBLE_BLINK),
+                new HandshakeCalculator().calculateHandshake(2));
+    }
+
+    @Ignore
+    @Test
+    public void testThatInput4YieldsACloseYourEyes() {
+        assertEquals(
+                singletonList(Signal.CLOSE_YOUR_EYES),
+                new HandshakeCalculator().calculateHandshake(4));
+    }
+
+    @Ignore
+    @Test
+    public void testThatInput8YieldsAJump() {
+        assertEquals(
+                singletonList(Signal.JUMP),
+                new HandshakeCalculator().calculateHandshake(8));
+    }
+
+    @Ignore
+    @Test
+    public void testAnInputThatYieldsTwoActions() {
+        assertEquals(
+                asList(Signal.WINK, Signal.DOUBLE_BLINK),
+                new HandshakeCalculator().calculateHandshake(3));
+    }
+
+    @Ignore
+    @Test
+    public void testAnInputThatYieldsTwoReversedActions() {
+        assertEquals(
+                asList(Signal.DOUBLE_BLINK, Signal.WINK),
+                new HandshakeCalculator().calculateHandshake(19));
+    }
+
+    @Ignore
+    @Test
+    public void testReversingASingleActionYieldsTheSameAction() {
+        assertEquals(
+                singletonList(Signal.JUMP),
+                new HandshakeCalculator().calculateHandshake(24));
+    }
+
+    @Ignore
+    @Test
+    public void testReversingNoActionsYieldsNoActions() {
+        assertEquals(
+                emptyList(),
+                new HandshakeCalculator().calculateHandshake(16));
+    }
+
+    @Ignore
+    @Test
+    public void testInputThatYieldsAllActions() {
+        assertEquals(
+                asList(Signal.WINK, Signal.DOUBLE_BLINK, Signal.CLOSE_YOUR_EYES, Signal.JUMP),
+                new HandshakeCalculator().calculateHandshake(15));
+    }
+
+    @Ignore
+    @Test
+    public void testInputThatYieldsAllActionsReversed() {
+        assertEquals(
+                asList(Signal.JUMP, Signal.CLOSE_YOUR_EYES, Signal.DOUBLE_BLINK, Signal.WINK),
+                new HandshakeCalculator().calculateHandshake(31));
+    }
+
+    @Ignore
+    @Test
+    public void testThatInput0YieldsNoActions() {
+        assertEquals(
+                emptyList(),
+                new HandshakeCalculator().calculateHandshake(0));
+    }
+
+    @Ignore
+    @Test
+    public void testThatInputWithLower5BitsNotSetYieldsNoActions() {
+        assertEquals(
+                emptyList(),
+                new HandshakeCalculator().calculateHandshake(32));
+    }
+
+}

data/tracks/java/exercises/settings.gradle

@@ -12,6 +12,7 @@ include 'bob'
 include 'bracket-push'
 include 'crypto-square'
 include 'custom-set'
+include 'diamond'
 include 'difference-of-squares'
 include 'etl'
 include 'gigasecond'
@@ -43,6 +44,7 @@ include 'robot-name'
 include 'robot-simulator'
 include 'roman-numerals'
 include 'scrabble-score'
+include 'secret-handshake'
 include 'series'
 include 'sieve'
 include 'simple-cipher'

data/tracks/julia/config.json

@@ -5,6 +5,39 @@
   "active": false,
   "test_pattern": "TODO",
   "exercises": [
+    {
+      "slug": "hello-world",
+      "difficulty": 1,
+      "topics": [
+        "strings",
+        "string interpolation"
+      ]
+    },
+    {
+      "slug": "hamming",
+      "difficulty": 1,
+      "topics": [
+        "generators",
+        "strings",
+        "exceptions"
+      ]
+    },
+    {
+      "slug": "difference-of-squares",
+      "difficulty": 1,
+      "topics": [
+        "generators"
+      ]
+    },
+    {
+      "slug": "word-count",
+      "difficulty": 1,
+      "topics": [
+        "control-flow (loops)",
+        "arrays",
+        "strings"
+      ]
+    },
     {
       "slug": "rna-transcription",
       "difficulty": 1,
@@ -34,6 +67,15 @@
         "sorting",
         "filtering"
       ]
+    },
+    {
+      "slug": "bob",
+      "difficulty": 2,
+      "topics": [
+        "strings",
+        "unicode",
+        "control-flow (if-else statements)"
+      ]
     }
   ],
   "deprecated": [

data/tracks/julia/exercises/bob/bob.jl

@@ -0,0 +1,3 @@
+function bob(stimulus::AbstractString)
+
+end

data/tracks/julia/exercises/bob/example.jl

@@ -0,0 +1,30 @@
+function bob(stimulus::AbstractString)
+    stimulus = strip(stimulus)
+
+    if issilence(stimulus)
+        return "Fine. Be that way!"
+    elseif isshouting(stimulus)
+        return "Whoa, chill out!"
+    elseif isquestion(stimulus)
+        return "Sure."
+    else
+        return "Whatever."
+    end
+end
+
+issilence(stimulus::AbstractString) = isempty(stimulus)
+isquestion(stimulus::AbstractString) = endswith(stimulus, '?')
+
+function isshouting(stimulus::AbstractString)
+    isupper(stimulus) && return true
+    !any(isalpha, stimulus) && return false
+
+    for c in stimulus
+        # ignore all non-letter chars
+        if isalpha(c) && !isupper(c)
+            return false
+        end
+    end
+    
+    return true
+end