flatten-array: without type safety (#255)

config.json

     "rectangles",
     "matrix",
     "diamond",
-    "secret-handshake"
+    "secret-handshake",
+    "flatten-array"
   ],
   "exercises": [
     {
       "slug": "secret-handshake",
       "difficulty": 1,
       "topics": []
+    },
+    {
+      "slug": "flatten-array",
+      "difficulty": 1,
+      "topics": []
     }
   ],
   "deprecated": [

exercises/flatten-array/build.gradle

+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/flatten-array/src/example/java/Flattener.java

+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+final class Flattener {
+
+    List flatten(final List nestedList) {
+        if (nestedList.isEmpty()) {
+            return new ArrayList<>();
+        } else {
+            final List result = new ArrayList();
+
+            final Object head = nestedList.get(0);
+            final List tail = nestedList.subList(1, nestedList.size());
+
+            if (head instanceof List) {
+                result.addAll(flatten((List) head));
+            } else {
+                result.add(head);
+            }
+
+            result.addAll(flatten(tail));
+            result.removeAll(Collections.singleton(null));
+            return result;
+        }
+    }
+
+}

exercises/flatten-array/src/main/java/Flattener.java

+final class Flattener {
+
+
+
+}

exercises/flatten-array/src/test/java/FlattenerTest.java

+import org.junit.Before;
+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 FlattenerTest {
+
+    private Flattener flattener;
+
+    @Before
+    public void setUp() {
+        flattener = new Flattener();
+    }
+
+    @Test
+    public void testASingleLevelOfNestingWithNoNulls() {
+        assertEquals(
+          asList(1, '2', 3, 4, 5, "six", "7", 8),
+          flattener.flatten(
+            asList(
+              1,
+              asList(
+                '2',
+                3,
+                4,
+                5,
+                "six",
+                "7"),
+              8)));
+    }
+
+    @Test
+    public void testFiveLevelsOfNestingWithNoNulls() {
+        assertEquals(
+          asList(0, '2', 2, "three", '8', 100, "four", 50, "-2"),
+          flattener.flatten(
+            asList(
+              0,
+              '2',
+              asList(
+                asList(
+                  2,
+                  "three"),
+                '8',
+                100,
+                "four",
+                singletonList(
+                  singletonList(
+                    singletonList(
+                      50)))),
+              "-2")));
+    }
+
+    @Test
+    public void testSixLevelsOfNestingWithNoNulls() {
+        assertEquals(
+          asList("one", '2', 3, '4', 5, "six", 7, "8"),
+          flattener.flatten(
+            asList(
+              "one",
+              asList(
+                '2',
+                singletonList(
+                  singletonList(
+                    3)),
+                asList(
+                  '4',
+                  singletonList(
+                    singletonList(
+                      5))),
+                "six",
+                7),
+              "8")));
+    }
+
+    @Test
+    public void testSixLevelsOfNestingWithNulls() {
+        assertEquals(
+          asList("0", 2, "two", '3', "8", "one hundred", "negative two"),
+          flattener.flatten(
+            asList(
+              "0",
+              2,
+              asList(
+                asList(
+                  "two",
+                  '3'),
+                "8",
+                singletonList(
+                  singletonList(
+                    "one hundred")),
+                null,
+                singletonList(
+                  singletonList(
+                    null))),
+              "negative two")));
+    }
+
+    @Test
+    public void testNestedListsFullOfNullsOnly() {
+        assertEquals(
+          emptyList(),
+          flattener.flatten(
+            asList(
+              null,
+              singletonList(
+                singletonList(
+                  singletonList(
+                    null))),
+              null,
+              null,
+              asList(
+                asList(
+                  null,
+                  null),
+                null),
+              null)));
+    }
+
+}

exercises/settings.gradle

 include 'diamond'
 include 'difference-of-squares'
 include 'etl'
+include 'flatten-array'
 include 'gigasecond'
 include 'grade-school'
 include 'hamming'