trackler 2.2.1.72 → 2.2.1.73

data/tracks/java/bin/run-journey-test-from-ci.sh

@@ -17,7 +17,7 @@ for file in $modded_files
   do if [[ $file == exercises* ]] || [[ $file == config.json ]]
     then
     for file2 in $modded_files
-      do if [[ $file2 == exercises* ]] && [[ $file2 != exercises/settings.gradle ]]
+      do if [[ $file2 == exercises* ]] && [[ $file2 != exercises/settings.gradle ]] && [[ $file2 != exercises/build.gradle ]]
         then modded_exercise=${file2#exercises/}
         modded_exercise=${modded_exercise%%/*}
         if [[ $last_modded_exercise != $modded_exercise ]]

data/tracks/java/config.json

@@ -938,6 +938,19 @@
       "unlocked_by": "rotational-cipher",
       "uuid": "162bebdc-9bf2-43c0-8460-a91f5fc16147"
     },
+    {
+      "core": false,
+      "difficulty": 7,
+      "slug": "markdown",
+      "topics": [
+        "strings",
+        "conditionals",
+        "pattern_matching",
+        "refactoring"
+      ],
+      "unlocked_by": "scrabble-score",
+      "uuid": "cc18f2e5-4e36-47d6-aa60-8ca5ff54019a"
+    },
     {
       "core": false,
       "difficulty": 7,

data/tracks/java/exercises/custom-set/.meta/src/reference/java/CustomSet.java

@@ -6,32 +6,32 @@ import java.util.Set;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
-public class CustomSet<T> {
+class CustomSet<T> {
 
     private Set<T> set;
 
-    public CustomSet() {
+    CustomSet() {
         this(Collections.emptyList());
     }
 
-    public CustomSet(Collection<T> data) {
+    CustomSet(Collection<T> data) {
         set = new HashSet<>(data.size());
         this.set.addAll(data);
     }
 
-    public boolean isEmpty() {
+    boolean isEmpty() {
         return set.isEmpty();
     }
 
-    public boolean contains(T element) {
+    boolean contains(T element) {
         return set.contains(element);
     }
 
-    public boolean isSubset(CustomSet<T> anotherSet) {
+    boolean isSubset(CustomSet<T> anotherSet) {
         return set.containsAll(anotherSet.set);
     }
 
-    public boolean isDisjoint(CustomSet<T> anotherSet) {
+    boolean isDisjoint(CustomSet<T> anotherSet) {
         if (set.isEmpty() || anotherSet.set.isEmpty()) {
             return true;
         }
@@ -40,15 +40,15 @@ public class CustomSet<T> {
                 .count() == 0;
     }
 
-    public boolean equals(CustomSet<T> anotherSet) {
+    boolean equals(CustomSet<T> anotherSet) {
         return set.equals(anotherSet.set);
     }
 
-    public boolean add(T element) {
+    boolean add(T element) {
         return set.add(element);
     }
 
-    public CustomSet<T> getIntersection(CustomSet<T> anotherSet) {
+    CustomSet<T> getIntersection(CustomSet<T> anotherSet) {
         return new CustomSet<>(
                 set.stream()
                         .filter(anotherSet.set::contains)
@@ -56,13 +56,13 @@ public class CustomSet<T> {
         );
     }
 
-    public CustomSet<T> getUnion(CustomSet<T> anotherSet) {
+    CustomSet<T> getUnion(CustomSet<T> anotherSet) {
         final Set<T> union = new HashSet<>(set);
         union.addAll(anotherSet.set);
         return new CustomSet<>(union);
     }
 
-    public CustomSet<T> getDifference(CustomSet<T> anotherSet) {
+    CustomSet<T> getDifference(CustomSet<T> anotherSet) {
         final Predicate<T> predicate = anotherSet::contains;
         return new CustomSet<>(
                 set.stream()

data/tracks/java/exercises/food-chain/.meta/src/reference/java/FoodChain.java

@@ -1,6 +1,6 @@
 import java.util.stream.IntStream;
 
-public class FoodChain {
+class FoodChain {
 
     private static final String[] ANIMALS = {
         "fly",
@@ -21,11 +21,11 @@ public class FoodChain {
         "I don't know how she swallowed a cow!"
     };
 
-    public String verse(int verse) {
+    String verse(int verse) {
         return verseBeginning(verse) + verseMiddle(verse) + verseEnding(verse);
     }
 
-    public String verses(int startVerse, int endVerse) {
+    String verses(int startVerse, int endVerse) {
 
         String[] verses = new String[endVerse - startVerse + 1];
 

data/tracks/java/exercises/grade-school/.meta/src/reference/java/School.java

@@ -1,34 +1,34 @@
 import java.util.*;
 
-public class School {
+class School {
 
   private final Map<Integer, List<String>> database = new HashMap<>();
 
-  public int numberOfStudents() {
+  int numberOfStudents() {
     int result = 0;
-    for (List<String> studentsInGrade: database.values()) {
+    for (List<String> studentsInGrade : database.values()) {
       result += studentsInGrade.size();
     }
     return result;
   }
 
-  public void add(String student, int grade) {
+  void add(String student, int grade) {
     List<String> students = fetchGradeFromDatabase(grade);
     students.add(student);
   }
 
-  public List<String> grade(int grade) {
+  List<String> grade(int grade) {
     return new ArrayList<>(fetchGradeFromDatabase(grade));
   }
 
-  private List<String> fetchGradeFromDatabase(int grade) {
+  List<String> fetchGradeFromDatabase(int grade) {
     if (!database.containsKey(grade)) {
       database.put(grade, new LinkedList<>());
     }
     return database.get(grade);
   }
 
-  public Map<Integer, List<String>> studentsByGradeAlphabetical() {
+  Map<Integer, List<String>> studentsByGradeAlphabetical() {
     Map<Integer, List<String>> sortedStudents = new HashMap<>();
     for (Integer grade : database.keySet()) {
       List<String> studentsInGrade = database.get(grade);

data/tracks/java/exercises/hamming/.meta/src/reference/java/Hamming.java

@@ -1,11 +1,11 @@
-public class Hamming {
+class Hamming {
     private final int hammingDistance;
 
-    public Hamming(String leftStrand, String rightStrand) {
+    Hamming(String leftStrand, String rightStrand) {
         hammingDistance = computeHammingDistance(leftStrand, rightStrand);
     }
 
-    public int getHammingDistance() {
+    int getHammingDistance() {
         return hammingDistance;
     }
 

data/tracks/java/exercises/hexadecimal/.meta/src/reference/java/Hexadecimal.java

@@ -1,8 +1,8 @@
 import java.util.Arrays;
 
-public class Hexadecimal {
+class Hexadecimal {
     private static final String HEXES = "0123456789abcdef";
-    public static int toDecimal(String input){
+    static int toDecimal(String input){
         boolean  isHex = input.matches("^[0-9a-f]+");
         if (!isHex) return 0;
         return Arrays.stream(input.split(""))
@@ -11,5 +11,3 @@ public class Hexadecimal {
 
     }
 }
-
-

data/tracks/java/exercises/isogram/.meta/src/reference/java/IsogramChecker.java

@@ -4,9 +4,9 @@ import java.util.Set;
 import static java.util.Arrays.stream;
 import static java.util.stream.Collectors.joining;
 
-public class IsogramChecker {
+class IsogramChecker {
 
-    public boolean isIsogram(String word) {
+    boolean isIsogram(String word) {
 
         Set<Character> charSet = new HashSet<>();
 

data/tracks/java/exercises/largest-series-product/.meta/src/reference/java/LargestSeriesProductCalculator.java

@@ -1,13 +1,13 @@
-public final class LargestSeriesProductCalculator {
+final class LargestSeriesProductCalculator {
 
     private final String stringToSearch;
 
-    public LargestSeriesProductCalculator(final String stringToSearch) throws IllegalArgumentException {
+    LargestSeriesProductCalculator(final String stringToSearch) throws IllegalArgumentException {
         this.stringToSearch = stringToSearch;
         validateStringToSearch();
     }
 
-    public long calculateLargestProductForSeriesLength(final int seriesLength) throws IllegalArgumentException {
+    long calculateLargestProductForSeriesLength(final int seriesLength) throws IllegalArgumentException {
         if (seriesLength < 0) {
             throw new IllegalArgumentException("Series length must be non-negative.");
         } else if (seriesLength == 0) {

data/tracks/java/exercises/linked-list/.meta/src/reference/java/DoublyLinkedList.java

@@ -1,7 +1,7 @@
-public final class DoublyLinkedList<T> {
+final class DoublyLinkedList<T> {
     private Element<T> head;
 
-    public void push(T value) {
+    void push(T value) {
         if (head == null) {
             head = new Element<>(value, null, null);
             head.next = head;
@@ -15,17 +15,17 @@ public final class DoublyLinkedList<T> {
         head.prev = tail;
     }
 
-    public T pop() {
+    T pop() {
         head = head.prev;
         return shift();
     }
 
-    public void unshift(T value) {
+    void unshift(T value) {
         push(value);
         head = head.prev;
     }
 
-    public T shift() {
+    T shift() {
         T value = head.value;
 
         Element<T> newHead = head.next;
@@ -48,7 +48,7 @@ public final class DoublyLinkedList<T> {
         private Element<T> prev;
         private Element<T> next;
 
-        public Element(T value, Element<T> prev, Element<T> next) {
+        Element(T value, Element<T> prev, Element<T> next) {
             this.value = value;
             this.prev = prev;
             this.next = next;

data/tracks/java/exercises/markdown/.meta/src/reference/java/Markdown.java

@@ -0,0 +1,96 @@
+class Markdown {
+    
+    String parse(String markdown) {
+        String[] lines = markdown.split("\n");
+        StringBuilder result = new StringBuilder();
+        boolean activeList = false;
+
+        for (int i = 0; i < lines.length; i++) {
+            String lineResult = parseLine(lines[i]);
+
+            if (lineResult.matches("(<li>).*") && !activeList) {
+                activeList = true;
+                result.append("<ul>");
+                result.append(lineResult);
+            } else if (!lineResult.matches("(<li>).*") && activeList) {
+                activeList = false;
+                result.append("</ul>");
+                result.append(lineResult);
+            } else {
+                result.append(lineResult);
+            }
+        }
+
+        if (activeList) {
+            result.append("</ul>");
+        }
+
+        return result.toString();
+    }
+
+    private String parseLine(String markdown) {
+        String result = parseHeader(markdown);
+
+        if (result == null) {
+            result = parseListItem(markdown);
+        }
+
+        if (result == null) {
+            result = parseParagraph(markdown);
+        }
+
+        return result;
+    }
+
+    private String parseHeader(String markdown) {
+        int count = 0;
+
+        for (int i = 0; i < markdown.length(); i++) {
+            if (markdown.charAt(i) == '#') {
+                count++;
+            } else {
+                break;
+            }
+        }
+
+        if (count == 0) {
+            return null;
+        }
+
+        return wrap(markdown.substring(count + 1), "h" + Integer.toString(count));
+    }
+
+    private String parseListItem(String markdown) {
+        if (markdown.startsWith("*")) {
+            return wrap(parseText(markdown.substring(2)), "li");
+        }
+
+        return null;
+    }
+
+    private String parseParagraph(String markdown) {
+        return wrap(parseText(markdown), "p");
+    }
+
+    private String parseText(String markdown) {
+        return parseUnderscore(parseDoubleUnderscore(markdown));
+    }
+
+    private String parseUnderscore(String markdown) {
+        return parseViaRegex(markdown, "_", "em");
+    }
+
+    private String parseDoubleUnderscore(String markdown) {
+        return parseViaRegex(markdown, "__", "strong");
+    }
+
+    private String parseViaRegex(String markdown, String delimiter, String tag) {
+        String pattern = delimiter + "(.+)" + delimiter;
+        String replacement = wrap("$1", tag);
+        return markdown.replaceAll(pattern, replacement);
+    }
+
+    private String wrap(String text, String tag) {
+        return "<" + tag + ">" + text + "</" + tag + ">";
+    }
+}

data/tracks/java/exercises/markdown/.meta/version

@@ -0,0 +1 @@
+1.1.0

data/tracks/java/exercises/markdown/README.md

@@ -0,0 +1,30 @@
+# Markdown
+
+Refactor a Markdown parser.
+
+The markdown exercise is a refactoring exercise. There is code that parses a
+given string with [Markdown
+syntax](https://guides.github.com/features/mastering-markdown/) and returns the
+associated HTML for that string. Even though this code is confusingly written
+and hard to follow, somehow it works and all the tests are passing! Your
+challenge is to re-write this code to make it easier to read and maintain
+while still making sure that all the tests keep passing.
+
+It would be helpful if you made notes of what you did in your refactoring in
+comments so reviewers can see that, but it isn't strictly necessary. The most
+important thing is to make the code better!
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+
+## 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/markdown/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/markdown/src/main/java/Markdown.java

@@ -0,0 +1,83 @@
+class Markdown {
+  
+    String parse(String markdown) {
+
+        String[] lines = markdown.split("\n");
+
+        String result = "";
+
+        boolean activeList = false;
+
+        for (int i = 0; i < lines.length; i++) {
+
+            String theLine = parseHeader(lines[i]);
+          
+            if (theLine == null) {
+              theLine = parseListItem(lines[i]);
+            }
+    
+            if (theLine == null) 
+            {
+                theLine = parseParagraph(lines[i]);
+            }
+
+            if (theLine.matches("(<li>).*") && !theLine.matches("(<h).*") && !theLine.matches("(<p>).*") && !activeList) {
+                activeList = true;
+              result = result + "<ul>";
+                result = result + theLine;
+            } 
+            
+            else if (!theLine.matches("(<li>).*") && activeList) {
+                activeList = false;
+                result = result + "</ul>";
+                result = result + theLine;
+            } else {
+              result = result + theLine;
+            }
+        }
+
+        if (activeList) {
+            result = result + "</ul>";
+        }
+
+        return result;
+    }
+
+    private String parseHeader(String markdown) {
+        int count = 0;
+
+        for (int i = 0; i < markdown.length() && markdown.charAt(i) == '#'; i++) 
+        {
+            count++;
+        }
+
+        if (count == 0) { return null; }
+
+        return "<h" + Integer.toString(count) + ">" + markdown.substring(count + 1) + "</h" + Integer.toString(count)+ ">";
+    }
+
+    private String parseListItem(String markdown) {
+        if (markdown.startsWith("*")) {
+            String skipAsterisk = markdown.substring(2);
+            String listItemString = parseSomeSymbols(skipAsterisk);
+            return "<li>" + listItemString + "</li>";
+        }
+
+        return null;
+    }
+
+    private String parseParagraph(String markdown) {
+        return "<p>" + parseSomeSymbols(markdown) + "</p>";
+    }
+
+    private String parseSomeSymbols(String markdown) {
+
+        String lookingFor = "__(.+)__";
+        String update = "<strong>$1</strong>";
+        String workingOn = markdown.replaceAll(lookingFor, update);
+
+        lookingFor = "_(.+)_";
+        update = "<em>$1</em>";
+        return workingOn.replaceAll(lookingFor, update);
+    }
+}