trackler 2.2.1.137 → 2.2.1.138

data/tracks/java/config.json

@@ -638,6 +638,20 @@
       "unlocked_by": "rotational-cipher",
       "uuid": "d36ce010-210f-4e9a-9d6c-cb933e0a59af"
     },
+    {
+      "core": false,
+      "difficulty": 5,
+      "slug": "grep",
+      "topics": [
+        "pattern_matching",
+        "strings",
+        "files",
+        "filtering",
+        "searching"
+      ],
+      "unlocked_by": "robot-name",
+      "uuid": "9c15ddab-7b52-43d4-b38c-0bf635b363c3"
+    },
     {
       "core": false,
       "difficulty": 6,

data/tracks/java/exercises/acronym/src/test/java/AcronymTest.java

@@ -7,40 +7,40 @@ public class AcronymTest {
 
     @Test
     public void basic() {
-        final String phrase = "Portable Network Graphics";
-        final String expected = "PNG";
+        String phrase = "Portable Network Graphics";
+        String expected = "PNG";
         assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void lowercaseWords() {
-        final String phrase = "Ruby on Rails";
-        final String expected = "ROR";
+        String phrase = "Ruby on Rails";
+        String expected = "ROR";
         assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void punctuation() {
-        final String phrase = "First In, First Out";
-        final String expected = "FIFO";
+        String phrase = "First In, First Out";
+        String expected = "FIFO";
         assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void NonAcronymAllCapsWord() {
-        final String phrase = "GNU Image Manipulation Program";
-        final String expected = "GIMP";
+        String phrase = "GNU Image Manipulation Program";
+        String expected = "GIMP";
         assertEquals(expected, new Acronym(phrase).get());
     }
 
     @Ignore("Remove to run test")
     @Test
     public void punctuationWithoutWhitespace() {
-        final String phrase = "Complementary metal-oxide semiconductor";
-        final String expected = "CMOS";
+        String phrase = "Complementary metal-oxide semiconductor";
+        String expected = "CMOS";
         assertEquals(expected, new Acronym(phrase).get());
     }
 

data/tracks/java/exercises/all-your-base/src/test/java/BaseConverterTest.java

@@ -14,10 +14,10 @@ public class BaseConverterTest {
 
     @Test
     public void testSingleBitOneToDecimal() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
 
-        final int[] expectedDigits = new int[]{1};
-        final int[] actualDigits = baseConverter.convertToBase(10);
+         int[] expectedDigits = new int[]{1};
+         int[] actualDigits = baseConverter.convertToBase(10);
 
         assertArrayEquals(
                 String.format(
@@ -31,10 +31,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testBinaryToSingleDecimal() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1});
 
-        final int[] expectedDigits = new int[]{5};
-        final int[] actualDigits = baseConverter.convertToBase(10);
+         int[] expectedDigits = new int[]{5};
+         int[] actualDigits = baseConverter.convertToBase(10);
 
         assertArrayEquals(
                 String.format(
@@ -48,10 +48,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testSingleDecimalToBinary() {
-        final BaseConverter baseConverter = new BaseConverter(10, new int[]{5});
+         BaseConverter baseConverter = new BaseConverter(10, new int[]{5});
 
-        final int[] expectedDigits = new int[]{1, 0, 1};
-        final int[] actualDigits = baseConverter.convertToBase(2);
+         int[] expectedDigits = new int[]{1, 0, 1};
+         int[] actualDigits = baseConverter.convertToBase(2);
 
         assertArrayEquals(
                 String.format(
@@ -65,10 +65,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testBinaryToMultipleDecimal() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
 
-        final int[] expectedDigits = new int[]{4, 2};
-        final int[] actualDigits = baseConverter.convertToBase(10);
+         int[] expectedDigits = new int[]{4, 2};
+         int[] actualDigits = baseConverter.convertToBase(10);
 
         assertArrayEquals(
                 String.format(
@@ -82,10 +82,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testDecimalToBinary() {
-        final BaseConverter baseConverter = new BaseConverter(10, new int[]{4, 2});
+         BaseConverter baseConverter = new BaseConverter(10, new int[]{4, 2});
 
-        final int[] expectedDigits = new int[]{1, 0, 1, 0, 1, 0};
-        final int[] actualDigits = baseConverter.convertToBase(2);
+         int[] expectedDigits = new int[]{1, 0, 1, 0, 1, 0};
+         int[] actualDigits = baseConverter.convertToBase(2);
 
         assertArrayEquals(
                 String.format(
@@ -99,10 +99,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testTrinaryToHexadecimal() {
-        final BaseConverter baseConverter = new BaseConverter(3, new int[]{1, 1, 2, 0});
+         BaseConverter baseConverter = new BaseConverter(3, new int[]{1, 1, 2, 0});
 
-        final int[] expectedDigits = new int[]{2, 10};
-        final int[] actualDigits = baseConverter.convertToBase(16);
+         int[] expectedDigits = new int[]{2, 10};
+         int[] actualDigits = baseConverter.convertToBase(16);
 
         assertArrayEquals(
                 String.format(
@@ -116,10 +116,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testHexadecimalToTrinary() {
-        final BaseConverter baseConverter = new BaseConverter(16, new int[]{2, 10});
+         BaseConverter baseConverter = new BaseConverter(16, new int[]{2, 10});
 
-        final int[] expectedDigits = new int[]{1, 1, 2, 0};
-        final int[] actualDigits = baseConverter.convertToBase(3);
+         int[] expectedDigits = new int[]{1, 1, 2, 0};
+         int[] actualDigits = baseConverter.convertToBase(3);
 
         assertArrayEquals(
                 String.format(
@@ -133,10 +133,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void test15BitInteger() {
-        final BaseConverter baseConverter = new BaseConverter(97, new int[]{3, 46, 60});
+         BaseConverter baseConverter = new BaseConverter(97, new int[]{3, 46, 60});
 
-        final int[] expectedDigits = new int[]{6, 10, 45};
-        final int[] actualDigits = baseConverter.convertToBase(73);
+         int[] expectedDigits = new int[]{6, 10, 45};
+         int[] actualDigits = baseConverter.convertToBase(73);
 
         assertArrayEquals(
                 String.format(
@@ -150,10 +150,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testEmptyDigits() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{});
 
-        final int[] expectedDigits = new int[]{0};
-        final int[] actualDigits = baseConverter.convertToBase(10);
+         int[] expectedDigits = new int[]{0};
+         int[] actualDigits = baseConverter.convertToBase(10);
 
         assertArrayEquals(
             String.format(
@@ -167,10 +167,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testSingleZero() {
-        final BaseConverter baseConverter = new BaseConverter(10, new int[]{0});
+         BaseConverter baseConverter = new BaseConverter(10, new int[]{0});
 
-        final int[] expectedDigits = new int[]{0};
-        final int[] actualDigits = baseConverter.convertToBase(2);
+         int[] expectedDigits = new int[]{0};
+         int[] actualDigits = baseConverter.convertToBase(2);
 
         assertArrayEquals(
                 String.format(
@@ -184,10 +184,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testMultipleZeros() {
-        final BaseConverter baseConverter = new BaseConverter(10, new int[]{0, 0, 0});
+         BaseConverter baseConverter = new BaseConverter(10, new int[]{0, 0, 0});
 
-        final int[] expectedDigits = new int[]{0};
-        final int[] actualDigits = baseConverter.convertToBase(2);
+         int[] expectedDigits = new int[]{0};
+         int[] actualDigits = baseConverter.convertToBase(2);
 
         assertArrayEquals(
             String.format(
@@ -201,10 +201,10 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testLeadingZeros() {
-        final BaseConverter baseConverter = new BaseConverter(7, new int[]{0, 6, 0});
+         BaseConverter baseConverter = new BaseConverter(7, new int[]{0, 6, 0});
 
-        final int[] expectedDigits = new int[]{4, 2};
-        final int[] actualDigits = baseConverter.convertToBase(10);
+         int[] expectedDigits = new int[]{4, 2};
+         int[] actualDigits = baseConverter.convertToBase(10);
 
         assertArrayEquals(
             String.format(
@@ -263,7 +263,7 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsOne() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{1, 0, 1, 0, 1, 0});
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");
@@ -274,7 +274,7 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsZero() {
-        final BaseConverter baseConverter = new BaseConverter(10, new int[]{7});
+         BaseConverter baseConverter = new BaseConverter(10, new int[]{7});
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");
@@ -285,7 +285,7 @@ public class BaseConverterTest {
     @Ignore("Remove to run test")
     @Test
     public void testSecondBaseIsNegative() {
-        final BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
+         BaseConverter baseConverter = new BaseConverter(2, new int[]{1});
 
         expectedException.expect(IllegalArgumentException.class);
         expectedException.expectMessage("Bases must be at least 2.");

data/tracks/java/exercises/grep/.meta/hints.md

@@ -0,0 +1,58 @@
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!

data/tracks/java/exercises/grep/.meta/src/reference/java/GrepTool.java

@@ -0,0 +1,65 @@
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+class GrepTool {
+
+    String grep(String pattern, List<String> flags, List<String> files) {
+        boolean shouldAddFilenameToEachLine = files.size() > 1;
+        return files
+            .stream()
+            .map(file -> grepFile(pattern, flags, file, shouldAddFilenameToEachLine))
+            .filter(line -> !line.isEmpty())
+            .collect(Collectors.joining("\n"));
+    }
+
+    private String grepFile(String pattern, List<String> flags, String filename, boolean shouldAddFilenameToEachLine) {
+        List<String> lines = readFile(filename);
+
+        String matchingLines = IntStream.range(0, lines.size())
+            .filter(lineIndex -> lineMatchesPattern(lines.get(lineIndex), pattern, flags))
+            .mapToObj(lineIndex -> {
+                String lineWithFlagsApplied = applyFlagsToLine(lines.get(lineIndex), flags, lineIndex + 1);
+                return shouldAddFilenameToEachLine ? filename + ":" + lineWithFlagsApplied : lineWithFlagsApplied;
+            })
+            .collect(Collectors.joining("\n"));
+
+        boolean shouldPrintFilenameInsteadOfMatchingLines = flags.contains("-l");
+        return shouldPrintFilenameInsteadOfMatchingLines && !matchingLines.isEmpty() ? filename : matchingLines;
+    }
+
+    private boolean lineMatchesPattern(String line, String pattern, List<String> flags) {
+        boolean isCaseInsensitive = flags.contains("-i");
+        String lineToCompare = isCaseInsensitive ? line.toLowerCase() : line;
+        String patternToCompare = isCaseInsensitive ? pattern.toLowerCase() : pattern;
+
+        boolean shouldMatchEntireLine = flags.contains("-x");
+        boolean matchesPattern = shouldMatchEntireLine
+            ? lineToCompare.equals(patternToCompare)
+            : lineToCompare.contains(patternToCompare);
+
+        boolean shouldInvertMatch = flags.contains("-v");
+        //noinspection SimplifiableConditionalExpression
+        return shouldInvertMatch ? !matchesPattern : matchesPattern;
+    }
+
+
+    private String applyFlagsToLine(String line, List<String> flags, int lineNumber) {
+        boolean shouldAddLineNumber = flags.contains("-n");
+        return shouldAddLineNumber ? lineNumber + ":" + line : line;
+    }
+
+    private List<String> readFile(String filename) {
+        try {
+            return Files.readAllLines(Paths.get(filename), Charset.forName("UTF-8"));
+        } catch (IOException e) {
+            return Collections.emptyList();
+        }
+    }
+
+}

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

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

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

@@ -0,0 +1,145 @@
+# Grep
+
+Search a file for lines matching a regular expression pattern. Return the line
+number and contents of each matching line.
+
+The Unix [`grep`](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/grep.html) command can be used to search for lines in one or more files
+that match a user-provided search query (known as the *pattern*).
+
+The `grep` command takes three arguments:
+
+1. The pattern used to match lines in a file.
+2. Zero or more flags to customize the matching behavior.
+3. One or more files in which to search for matching lines.
+
+Your task is to implement the `grep` function, which should read the contents
+of the specified files, find the lines that match the specified pattern
+and then output those lines as a single string. Note that the lines should
+be output in the order in which they were found, with the first matching line
+in the first file being output first.
+
+As an example, suppose there is a file named "input.txt" with the following contents:
+
+```text
+hello
+world
+hello again
+```
+
+If we were to call `grep "hello" input.txt`, the returned string should be:
+
+```text
+hello
+hello again
+```
+
+### Flags
+
+As said earlier, the `grep` command should also support the following flags:
+
+- `-n` Print the line numbers of each matching line.
+- `-l` Print only the names of files that contain at least one matching line.
+- `-i` Match line using a case-insensitive comparison.
+- `-v` Invert the program -- collect all lines that fail to match the pattern.
+- `-x` Only match entire lines, instead of lines that contain a match.
+
+If we run `grep -n "hello" input.txt`, the `-n` flag will require the matching
+lines to be prefixed with its line number:
+
+```text
+1:hello
+3:hello again
+```
+
+And if we run `grep -i "HELLO" input.txt`, we'll do a case-insensitive match,
+and the output will be:
+
+```text
+hello
+hello again
+```
+
+The `grep` command should support multiple flags at once.
+
+For example, running `grep -l -v "hello" file1.txt file2.txt` should
+print the names of files that do not contain the string "hello".
+
+# Java Tips
+
+Since this exercise has difficulty 5 it doesn't come with any starter implementation.
+This is so that you get to practice creating classes and methods which is an important part of programming in Java.
+It does mean that when you first try to run the tests, they won't compile.
+They will give you an error similar to:
+```
+ path-to-exercism-dir\exercism\java\name-of-exercise\src\test\java\ExerciseClassNameTest.java:14: error: cannot find symbol
+        ExerciseClassName exerciseClassName = new ExerciseClassName();
+        ^
+ symbol:   class ExerciseClassName
+ location: class ExerciseClassNameTest
+```
+This error occurs because the test refers to a class that hasn't been created yet (`ExerciseClassName`).
+To resolve the error you need to add a file matching the class name in the error to the `src/main/java` directory.
+For example, for the error above you would add a file called `ExerciseClassName.java`.
+
+When you try to run the tests again you will get slightly different errors.
+You might get an error similar to:
+```
+  constructor ExerciseClassName in class ExerciseClassName cannot be applied to given types;
+        ExerciseClassName exerciseClassName = new ExerciseClassName("some argument");
+                                              ^
+  required: no arguments
+  found: String
+  reason: actual and formal argument lists differ in length
+```
+This error means that you need to add a [constructor](https://docs.oracle.com/javase/tutorial/java/javaOO/constructors.html) to your new class.
+If you don't add a constructor, Java will add a default one for you.
+This default constructor takes no arguments.
+So if the tests expect your class to have a constructor which takes arguments, then you need to create this constructor yourself.
+In the example above you could add:
+```
+ExerciseClassName(String input) {
+
+}
+``` 
+That should make the error go away, though you might need to add some more code to your constructor to make the test pass!
+
+You might also get an error similar to:
+```
+  error: cannot find symbol
+        assertEquals(expectedOutput, exerciseClassName.someMethod());
+                                                       ^
+  symbol:   method someMethod()
+  location: variable exerciseClassName of type ExerciseClassName
+```
+This error means that you need to add a method called `someMethod` to your new class.
+In the example above you would add:
+```
+String someMethod() {
+  return "";
+}
+```
+Make sure the return type matches what the test is expecting.
+You can find out which return type it should have by looking at the type of object it's being compared to in the tests.
+Or you could set your method to return some random type (e.g. `void`), and run the tests again.
+The new error should tell you which type it's expecting.
+
+After having resolved these errors you should be ready to start making the tests pass!
+
+
+# Running the tests
+
+You can run all the tests for an exercise by entering
+
+```sh
+$ gradle test
+```
+
+in your terminal.
+
+## Source
+
+Conversation with Nate Foster. [http://www.cs.cornell.edu/Courses/cs3110/2014sp/hw/0/ps0.pdf](http://www.cs.cornell.edu/Courses/cs3110/2014sp/hw/0/ps0.pdf)
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.