Merge pull request #3 from arcuri82/update-2020-exam

Update 2020 exam

Author: arcuri82

Diff for: .github/workflows/ci.yml

@@ -0,0 +1,22 @@
+name: CI
+
+on: [push]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Setup JDK 11
+        uses: actions/setup-java@v1
+        with:
+          java-version: 11
+      - name: Cache Maven packages
+        uses: actions/cache@v2
+        with:
+          path: ~/.m2
+          key: ${{ runner.os }}-m2-${{ hashFiles('**/pom.xml') }}
+          restore-keys: ${{ runner.os }}-m2
+      - name: Build with Maven
+        run: mvn clean verify -Dhttp.keepAlive=false -Dmaven.wagon.http.pool=false -Dmaven.wagon.httpconnectionManager.ttlSeconds=120

Diff for: .travis.yml

@@ -1,8 +1,7 @@
 
 # Algorithms and Data Structures
 
-[![Build Status](https://travis-ci.org/arcuri82/algorithms.svg?branch=master)](https://travis-ci.org/arcuri82/pg4200)
-
+![CI](https://github.com/arcuri82/algorithms/workflows/CI/badge.svg)
 
 Slides, code examples and exercises (with solutions) for the PG4200 course: 
 Algoritmer og datastrukturer (Algorithms and Data Structures).

Diff for: README.md

@@ -45,12 +45,28 @@ On the other hand, when `index > size()/2` it would be more efficient to start f
 
 Write a `MyBidirectionalLinkedListTest` that extends `MyListTestTemplate`. 
 If your implementation is correct, all tests should pass.
-Run the tests with code coverage enabled, and verify that all of the instructions in your
-code are covered. If not, add new tests to `MyBidirectionalLinkedListTest`.  
- 
+
 
 
 ## Part D
+ 
+Write a new class `MyMiddleBidirectionalLinkedList` that extends `MyList`, using `MyBidirectionalLinkedList` as starting point. 
+However, besides having a link to the `head` and the `tail` of the list, you need to have a 3rd link, pointing to the `middle` of the list.
+When you need to access an element (e.g., with a get), then you need to minimize the number of nodes to traverse. 
+For example, assume a list with 100 elements, and you need to delete the element at position 40. 
+Then, the most efficient way would be to start from the `middle` link, and go backwards following the previous links till position 40. 
+On the other hand, if accessing at position 20, it would be more efficient to start from head and follow the next links.
+In other words, all indices in the range 25%-75% of the size of the list should be accessed starting from the `middle` link.
+
+Pay particular attention at the fact that, at each `delete` and `add` operation, the value of `middle` will likely need to be updated. 
+Note: in case of list with an even number of elements, the middle could have 2 values, choose the lower. 
+For example: `length=1` and `length=2` would have middle at position `0`, whereas `length=3` and `length=4` would have it at position `1`, `length=5` at `2`, and so on.
+ 
+Write a `MyMiddleBidirectionalLinkedListTest` that extends `MyListTestTemplate`. 
+If your implementation is correct, all tests should pass.
+
+ 
+## Part E
 
 Study the source code of `MyLinkedList`, `MyStackLinkedList` and `MyQueueArray`.
 Once you think you fully understand them, write their implementation

Diff for: docs/exercises/ex02.md

@@ -1,5 +1,7 @@
 # Exercise 12
 
+## Part A
+
 Implement a class `HuffmanIso` that extends `Huffman`.
 In such class, override the methods `writeTrie` and `readTrie`.
 When writing/reading a char for a given leaf node, use the charset ISO-8859-1 instead
@@ -25,6 +27,23 @@ Write a test class `HuffmanIsoTest` with the following two tests:
   Explain why.
 
 
+## Part B
+
+Consider a string representation for exam grades, in the format of `<id><grade>`, where `id` is a number starting from 0 (can assume __NO MORE__ than 500 students in an exam, and there can be exams with just a couple of students), and grades in the range `A-F`. 
+A valid string would be for example:  `0A1F2F3C12F13B14B27A201B497A`.
+You can assume that the ids are sorted, but there can be holes in the sequence (e.g., representing students that did not submit).
+
+Write a class `GradeCompressorImp` that implements the given `GradeCompressor` interface. 
+
+You __MUST__ come up with an efficient compression algorithm which is specialized and customized for this problem domain (i.e., do not use either `Huffman` nor `LZW`, but rather use `DnaCompressor` as inspiration). 
+For example, if there is just 1 student, you should not use more than 2 bytes in total for the compression. 
+If there are 100 students, should not use more than 150 bytes.
+In your implementation, you can rely on and use the classes `BitWriter` and `BitReader`.
+
+Write a test class `GradeCompressorTest` that extends the given `GradeCompressorTestTemplate` test suite.
+If your implementation of `GradeCompressorImp` is correct, all tests should pass. 
+
+
 ## Solutions
 
 Solutions to this exercise can be found in the `solutions`

Diff for: docs/exercises/ex12.md

@@ -1,5 +1,7 @@
 package org.pg4200.ex07;
 
+import java.util.Optional;
+import java.util.function.BinaryOperator;
 import java.util.function.Predicate;
 
 /**
@@ -30,6 +32,14 @@ public interface AnotherStream<T> {
      */
     boolean any(Predicate<T> predicate);
 
+    /**
+     *  Performs a reduction on the elements of this stream, using an associative accumulation function,
+     *  and returns an Optional describing the reduced value, if any (ie, if the stream as at least one element).
+     *  This is equivalent to take the first element, apply accumulator with second element, get result
+     *  and apply accumulator with 3rd element, then take this result and accumulate with 4th element, and so on.
+     */
+    Optional<T> reduce(BinaryOperator<T> accumulator);
+
     /**
      * Filtering operation that only let pass an element
      * once. Ie, if an element in the stream is

Diff for: exercises/src/main/java/org/pg4200/ex07/AnotherStream.java

@@ -30,4 +30,15 @@ public interface PatternExamples {
      * - a final domain code, which is at least 2 letters (upper or lower case), and no digits
      */
     String emailRegex();
+
+    /**
+     * Need match the following sentence:
+     *
+     * Is this an out of season april fools joke?
+     *
+     * However, the regex should be general enough to also match for further string variants following these properties:
+     * a)	there can  be any number of spaces between the words
+     * b)	each letter can be either in lower or upper case
+     */
+    String isItAJoke();
 }

Diff for: exercises/src/main/java/org/pg4200/ex09/PatternExamples.java

@@ -0,0 +1,14 @@
+package org.pg4200.ex12;
+
+public interface GradeCompressor {
+
+    /**
+     *
+     * @param idsAndGrades string list in the form id:grade, eg, 0A1F2C
+     * @return compressed bytes
+     */
+    byte[] compress(String idsAndGrades);
+
+    String decompress(byte[] data);
+
+}

Diff for: exercises/src/main/java/org/pg4200/ex12/GradeCompressor.java

@@ -77,4 +77,20 @@ public void testEmail(){
         assertTrue("[email protected]".matches(regex));
         assertTrue("[email protected]".matches(regex));
     }
+
+    @Test
+    public void testIsItAJoke(){
+
+        String regex = getNewInstance().isItAJoke();
+
+        assertFalse("".matches(regex));
+        assertFalse("Is this an out of season april fools jok".matches(regex));
+        assertFalse("Is this an out of season april fools joke".matches(regex));
+        assertFalse("a b c d e f g h i?".matches(regex));
+        assertFalse("i S THIS          AN oUT of sEason              APRIL FOOLs joKe?".matches(regex));
+        assertFalse("this Is an out of season april fools joke?".matches(regex));
+
+        assertTrue("Is this an out of season april fools joke?".matches(regex));
+        assertTrue("iS THIS          AN oUT of sEason              APRIL FOOLs joKe?".matches(regex));
+    }
 }

Diff for: exercises/src/test/java/org/pg4200/ex09/PatternExamplesTestTemplate.java

@@ -0,0 +1,52 @@
+package org.pg4200.ex12;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public abstract class GradeCompressorTestTemplate {
+
+    protected abstract GradeCompressor getNewInstance();
+
+    @Test
+    public void testOne(){
+
+        GradeCompressor gc = getNewInstance();
+
+        String data = "0A";
+        byte[] compressed = gc.compress(data);
+        assertTrue(compressed.length <= 2);
+
+        String decompressed = gc.decompress(compressed);
+        assertEquals(data, decompressed);
+    }
+
+    @Test
+    public void testSeveral(){
+
+        GradeCompressor gc = getNewInstance();
+
+        String data = "0A1F2F3C12F13B14B27A201B497A";
+        byte[] compressed = gc.compress(data);
+        String decompressed = gc.decompress(compressed);
+        assertEquals(data, decompressed);
+    }
+
+    @Test
+    public void test100(){
+
+        GradeCompressor gc = getNewInstance();
+
+        String data = "";
+        for(int i=0; i<100; i++){
+            data += (i + "A");
+        }
+
+        byte[] compressed = gc.compress(data);
+        assertTrue(compressed.length <= 150);
+
+        String decompressed = gc.decompress(compressed);
+        assertEquals(data, decompressed);
+    }
+}

Diff for: exercises/src/test/java/org/pg4200/ex12/GradeCompressorTestTemplate.java

@@ -6,6 +6,8 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assumptions.assumeFalse;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
 /**
  * Created by arcuri82 on 15-Aug-17.
@@ -262,4 +264,21 @@ public void testInsertMiddle(){
         assertEquals("b", data.get(2));
         assertEquals("c", data.get(3));
     }
+
+    @Test
+    public void testInsertAndGetMany(){
+
+        //skip running this test on that class, due to limited length
+        assumeFalse(this.getClass().getSimpleName().equals("MyArrayListTest"));
+
+        MyList<Integer> data = getNewInstance(Integer.class);
+
+        for(int i=0; i<100; i++){
+            data.add(i*2);
+        }
+
+        for(int i=0; i<100; i++){
+            assertEquals(i*2, data.get(i));
+        }
+    }
 }