Merge pull request #240 from exercism/sublist

sublist: add to track

config.json

@@ -53,7 +53,8 @@
     "all-your-base",
     "custom-set",
     "wordy",
-    "palindrome-products"
+    "palindrome-products",
+    "sublist"
   ],
   "exercises": [
     {
@@ -305,6 +306,11 @@
       "slug": "palindrome-products",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "sublist",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

exercises/settings.gradle

@@ -44,6 +44,7 @@ include 'series'
 include 'sieve'
 include 'simple-cipher'
 include 'simple-linked-list'
+include 'sublist'
 include 'sum-of-multiples'
 include 'space-age'
 include 'strain'

exercises/sublist/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"]
+  }
+}

exercises/sublist/src/example/java/Relationship.java

@@ -0,0 +1 @@
+../../main/java/Relationship.java

exercises/sublist/src/example/java/RelationshipComputer.java

@@ -0,0 +1,29 @@
+import java.util.List;
+
+final class RelationshipComputer<T extends Comparable> {
+
+    Relationship computeRelationship(final List<T> firstList, final List<T> secondList) {
+        if (firstList.equals(secondList))          return Relationship.EQUAL;
+        if (checkIfSublist(firstList, secondList)) return Relationship.SUBLIST;
+        if (checkIfSublist(secondList, firstList)) return Relationship.SUPERLIST;
+        return Relationship.UNEQUAL;
+    }
+
+    private boolean checkIfSublist(final List<T> firstList, final List<T> secondList) {
+        final int firstListSize = firstList.size();
+        final int secondListSize = secondList.size();
+
+        if (firstListSize > secondListSize) return false;
+
+        final int numberOfSublistCandidates = secondListSize - firstListSize + 1;
+
+        for (int startIndex = 0; startIndex < numberOfSublistCandidates; startIndex++) {
+            if (secondList.subList(startIndex, startIndex + firstListSize).equals(firstList)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+}

exercises/sublist/src/main/java/Relationship.java

@@ -0,0 +1,5 @@
+enum Relationship {
+
+    EQUAL, SUBLIST, SUPERLIST, UNEQUAL
+
+}

exercises/sublist/src/main/java/RelationshipComputer.java

@@ -0,0 +1,5 @@
+final class RelationshipComputer<T extends Comparable> {
+
+
+
+}

exercises/sublist/src/test/java/RelationshipComputerTest.java

@@ -0,0 +1,183 @@
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.List;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.emptyList;
+import static org.junit.Assert.assertEquals;
+
+public class RelationshipComputerTest {
+
+    @Test
+    public void testThatTwoEmptyListsAreConsideredEqual() {
+        Relationship computedRelationship = new RelationshipComputer<>().computeRelationship(
+                emptyList(),
+                emptyList());
+
+        assertEquals(Relationship.EQUAL, computedRelationship);
+    }
+
+    @Ignore
+    @Test
+    public void testEmptyListIsSublistOfNonEmptyList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                emptyList(),
+                asList(1, 2, 3));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testNonEmptyListIsSuperlistOfEmptyList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('1', '2', '3'),
+                emptyList());
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testListIsEqualToItself() {
+        List<String> anyList = asList("1", "2", "3");
+
+        Relationship relationship = new RelationshipComputer<String>().computeRelationship(
+                anyList,
+                anyList);
+
+        assertEquals(Relationship.EQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testDifferentListsOfTheSameLengthAreUnequal() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(1, 2, 3),
+                asList(2, 3, 4));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistCheckDoesNotAbortAfterFalseStart() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('1', '2', '5'),
+                asList('0', '1', '2', '3', '1', '2', '5', '6'));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistCheckHandlesExtraneousRepeatsOfFirstEntry() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("1", "1", "2"),
+                asList("0", "1", "1", "1", "2", "1", "2"));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistAtStart() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(0, 1, 2),
+                asList(0, 1, 2, 3, 4, 5));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistInMiddle() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('2', '3', '4'),
+                asList('0', '1', '2', '3', '4', '5'));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSublistAtEnd() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("3", "4", "5"),
+                asList("0", "1", "2", "3", "4", "5"));
+
+        assertEquals(Relationship.SUBLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testAtStartOfSuperlist() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(0, 1, 2, 3, 4, 5),
+                asList(0, 1, 2));
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testInMiddleOfSuperlist() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('0', '1', '2', '3', '4', '5'),
+                asList('2', '3'));
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testAtEndOfSuperlist() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("0", "1", "2", "3", "4", "5"),
+                asList("3", "4", "5"));
+
+        assertEquals(Relationship.SUPERLIST, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testFirstListMissingElementFromSecondList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(1, 3),
+                asList(1, 2, 3));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testSecondListMissingElementFromFirstList() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList('1', '2', '3'),
+                asList('1', '3'));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testThatListOrderingIsAccountedFor() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList("1", "2", "3"),
+                asList("3", "2", "1"));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+    @Ignore
+    @Test
+    public void testThatListsWithSameDigitsButDifferentNumbersAreUnequal() {
+        Relationship relationship = new RelationshipComputer<>().computeRelationship(
+                asList(1, 0, 1),
+                asList(10, 1));
+
+        assertEquals(Relationship.UNEQUAL, relationship);
+    }
+
+}