Merge pull request #1 from exercism/master

merge

accumulate/build.gradle

@@ -0,0 +1,11 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.10"
+}

accumulate/example.java

@@ -0,0 +1,16 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Function;
+
+public class Accumulate {
+
+	public static <T> List<T> accumulate(List<T> collection, Function<T, T> function) {
+		List<T> newCollection = new ArrayList<>();
+
+		for (T item : collection) {
+			newCollection.add(function.apply(item));
+		}
+
+		return newCollection;
+	}
+}

accumulate/src/main/java/Accumulate.java

@@ -0,0 +1,2 @@
+public class Accumulate {
+}

accumulate/src/test/java/AccumulateTest.java

@@ -0,0 +1,53 @@
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class AccumulateTest {
+
+    @Test
+    public void emptyAccumulateProducesEmptyAccumulation() {
+        List<Integer> input = new LinkedList<>();
+        List<Integer> expectedOutput = new LinkedList<>();
+        assertEquals(expectedOutput, Accumulate.accumulate(input, x -> x * x));
+    }
+
+    @Test
+    public void accumulateSquares() {
+        List<Integer> input = Arrays.asList(1, 2, 3);
+        List<Integer> expectedOutput = Arrays.asList(1, 4, 9);
+        assertEquals(expectedOutput, Accumulate.accumulate(input, x -> x * x));
+    }
+
+    @Test
+    public void accumulateUpperCases() {
+        List<String> input = Arrays.asList("hello", "world");
+        List<String> expectedOutput = Arrays.asList("HELLO", "WORLD");
+        assertEquals(expectedOutput, Accumulate.accumulate(input, x -> x.toUpperCase()));
+    }
+
+    @Test
+    public void accumulateReversedStrings() {
+        List<String> input = Arrays.asList("the quick brown fox etc".split(" "));
+        List<String> expectedOutput = Arrays.asList("eht kciuq nworb xof cte".split(" "));
+        assertEquals(expectedOutput, Accumulate.accumulate(input, this::reverse));
+    }
+
+    private String reverse(String input) {
+        return new StringBuilder(input).reverse().toString();
+    }
+
+    @Test
+    public void accumulateWithinAccumulate() {
+        List<String> input1 = Arrays.asList("a", "b", "c");
+        List<String> input2 = Arrays.asList("1", "2", "3");
+        List<String> expectedOutput = Arrays.asList("a1 a2 a3", "b1 b2 b3", "c1 c2 c3");
+        assertEquals(expectedOutput, Accumulate.accumulate(
+                input1, c ->
+                        String.join(" ", Accumulate.accumulate(input2, d -> c + d))
+        ));
+    }
+}

atbash-cipher/build.gradle

@@ -0,0 +1,11 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.10"
+}

atbash-cipher/example.java

@@ -0,0 +1,48 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Atbash {
+
+    private static final int GROUP_SIZE = 5;
+    private static final String PLAIN = "abcdefghijklmnopqrstuvwxyz";
+    private static final String CIPHER = "zyxwvutsrqponmlkjihgfedcba";
+
+    public static String encode(String input) {
+        String encoded = stripInvalidCharacters(input).toLowerCase();
+        String cyphered = "";
+
+        for (char c : encoded.toCharArray()) {
+            cyphered += applyCipher(c);
+        }
+
+        return splitIntoFiveLetterWords(cyphered);
+    }
+
+    private static String stripInvalidCharacters(String input) {
+        String filteredValue = "";
+
+        for (char c : input.toCharArray()) {
+            if (Character.isLetterOrDigit(c)) {
+                filteredValue += c;
+            }
+        }
+
+        return filteredValue;
+    }
+
+    private static char applyCipher(char input) {
+        int idx = PLAIN.indexOf(input);
+
+        return idx >= 0 ? CIPHER.toCharArray()[idx] : input;
+    }
+
+    private static String splitIntoFiveLetterWords(String value) {
+        List<String> words = new ArrayList<>();
+
+        for (int i = 0; i < value.length(); i += GROUP_SIZE) {
+            words.add(i + GROUP_SIZE <= value.length() ? value.substring(i, i + GROUP_SIZE) : value.substring(i));
+        }
+
+        return String.join(" ", words);
+    }
+}

atbash-cipher/src/main/java/Atbash.java

@@ -0,0 +1,2 @@
+public class Atbash {
+}

atbash-cipher/src/test/java/AtbashTest.java

@@ -0,0 +1,38 @@
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(Parameterized.class)
+public class AtbashTest {
+
+    private String input;
+    private String expectedOutput;
+
+    @Parameterized.Parameters
+    public static Collection<Object[]> data() {
+        return Arrays.asList(new Object[][]{
+                {"no", "ml"},
+                {"yes", "bvh"},
+                {"OMG", "lnt"},
+                {"mindblowingly", "nrmwy oldrm tob"},
+                {"Testing, 1 2 3, testing.", "gvhgr mt123 gvhgr mt"},
+                {"Truth is fiction.", "gifgs rhurx grlm"},
+                {"The quick brown fox jumps over the lazy dog.", "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"}
+        });
+    }
+
+    public AtbashTest(String input, String expectedOutput) {
+        this.input = input;
+        this.expectedOutput = expectedOutput;
+    }
+
+    @Test
+    public void test() {
+        assertEquals(expectedOutput, Atbash.encode(input));
+    }
+}

config.json

@@ -23,7 +23,10 @@
     "prime-factors",
     "raindrops",
     "allergies",
-    "strain"
+    "strain",
+    "atbash-cipher",
+    "accumulate",
+    "crypto-square"
   ],
   "deprecated": [
   ],

crypto-square/build.gradle

@@ -0,0 +1,11 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.10"
+}

crypto-square/example.java

@@ -0,0 +1,72 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Crypto {
+
+    private String normalizedPlaintext;
+    private int squareSize;
+
+    public Crypto(String text) {
+        this.normalizedPlaintext = normalizeText(text);
+        this.squareSize = calculateSquareSize(normalizedPlaintext);
+    }
+
+    public String getNormalizedPlaintext() {
+        return normalizedPlaintext;
+    }
+
+    public int getSquareSize() {
+        return squareSize;
+    }
+
+    private static String normalizeText(String text) {
+        return text.toLowerCase().codePoints()
+                .filter(x -> Character.isLetterOrDigit(x))
+                .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+                .toString();
+    }
+
+    private static int calculateSquareSize(String text) {
+        return (int) Math.ceil(Math.sqrt(text.length()));
+    }
+
+    public List<String> getPlaintextSegments() {
+        return getSegmentText(normalizedPlaintext, squareSize);
+    }
+
+    private static List<String> getSegmentText(String text, int squareSize) {
+        List<String> segments = new ArrayList<>();
+        int index = 0;
+
+        while (index < text.length()) {
+            if (index + squareSize < text.length()) {
+                segments.add(text.substring(index, index + squareSize));
+            } else {
+                segments.add(text.substring(index));
+            }
+            index += squareSize;
+        }
+
+        return segments;
+    }
+
+    public String getCipherText() {
+        StringBuilder cipherText = new StringBuilder(normalizedPlaintext.length());
+
+        for (int index = 0; index < squareSize; index++) {
+            for (String segment : getPlaintextSegments()) {
+                if (index < segment.length()) {
+                    cipherText.append(segment.charAt(index));
+                }
+            }
+        }
+
+        return cipherText.toString();
+    }
+
+    public String getNormalizedCipherText() {
+        String cipher = getCipherText();
+
+        return String.join(" ", getSegmentText(cipher, squareSize - 1));
+    }
+}

crypto-square/src/main/java/Crypto.java

@@ -0,0 +1,2 @@
+public class Crypto {
+}

crypto-square/src/test/java/CryptoSquareTest.java

@@ -0,0 +1,129 @@
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class CryptoSquareTest {
+
+    @Test
+    public void strangeCharactersAreStrippedDuringNormalization() {
+        Crypto crypto = new Crypto("s#$%^&plunk");
+        String expectedOutput = "splunk";
+
+        assertEquals(expectedOutput, crypto.getNormalizedPlaintext());
+    }
+
+    @Test
+    public void lettersAreLowerCasedDuringNormalization() {
+        Crypto crypto = new Crypto("WHOA HEY!");
+        String expectedOutput = "whoahey";
+
+        assertEquals(expectedOutput, crypto.getNormalizedPlaintext());
+    }
+
+    @Test
+    public void numbersAreKeptDuringNormalization() {
+        Crypto crypto = new Crypto("1, 2, 3, GO!");
+        String expectedOutput = "123go";
+
+        assertEquals(expectedOutput, crypto.getNormalizedPlaintext());
+    }
+
+    @Test
+    public void smallestSquareSizeIs2() {
+        Crypto crypto = new Crypto("1234");
+        int expectedOutput = 2;
+
+        assertEquals(expectedOutput, crypto.getSquareSize());
+    }
+
+    @Test
+    public void sizeOfTextWhoseLengthIsPerfectSquareIsItsSquareRoot() {
+        Crypto crypto = new Crypto("123456789");
+        int expectedOutput = 3;
+
+        assertEquals(expectedOutput, crypto.getSquareSize());
+    }
+
+    @Test
+    public void sizeOfTextWhoseLengthIsNoPerfectSquareIsNextBiggestSquareRoot() {
+        Crypto crypto = new Crypto("123456789abc");
+        int expectedOutput = 4;
+
+        assertEquals(expectedOutput, crypto.getSquareSize());
+    }
+
+    @Test
+    public void sizeIsDeterminedByNormalizedText() {
+        Crypto crypto = new Crypto("Oh hey, this is nuts!");
+        int expectedOutput = 4;
+
+        assertEquals(expectedOutput, crypto.getSquareSize());
+    }
+
+    @Test
+    public void segmentsAreSplitBySquareSize() {
+        Crypto crypto = new Crypto("Never vex thine heart with idle woes");
+        List<String> expectedOutput = Arrays.asList(new String[]{"neverv", "exthin", "eheart", "withid", "lewoes"});
+
+        assertEquals(expectedOutput, crypto.getPlaintextSegments());
+    }
+
+    @Test
+    public void segmentsAreSplitBySquareSizeUntilTextRunsOut() {
+        Crypto crypto = new Crypto("ZOMG! ZOMBIES!!!");
+        List<String> expectedOutput = Arrays.asList(new String[]{"zomg", "zomb", "ies"});
+
+        assertEquals(expectedOutput, crypto.getPlaintextSegments());
+    }
+
+    @Test
+    public void cipherTextCombinesTextByColumn() {
+        Crypto crypto = new Crypto("First, solve the problem. Then, write the code.");
+        String expectedOutput = "foeewhilpmrervrticseohtottbeedshlnte";
+
+        assertEquals(expectedOutput, crypto.getCipherText());
+    }
+
+    @Test
+    public void cipherTextSkipsCellsWithNoText() {
+        Crypto crypto = new Crypto("Time is an illusion. Lunchtime doubly so.");
+        String expectedOutput = "tasneyinicdsmiohooelntuillibsuuml";
+
+        assertEquals(expectedOutput, crypto.getCipherText());
+    }
+
+    @Test
+    public void normalizedCipherTextIsSplitByHeightOfSquare() {
+        Crypto crypto = new Crypto("Vampires are people too!");
+        String expectedOutput = "vrel aepe mset paoo irpo";
+
+        assertEquals(expectedOutput, crypto.getNormalizedCipherText());
+    }
+
+    @Test
+    public void normalizedCipherNotExactlyDivisibleBy5SpillsIntoSmallerSegment() {
+        Crypto crypto = new Crypto("Madness, and then illumination.");
+        String expectedOutput = "msemo aanin dninn dlaet ltshu i";
+
+        assertEquals(expectedOutput, crypto.getNormalizedCipherText());
+    }
+
+    @Test
+    public void normalizedCipherIsSplitIntoSegmentsOfCorrectSize() {
+        Crypto crypto = new Crypto("If man was meant to stay on the ground god would have given us roots");
+        String expectedOutput = "imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghns seoau";
+
+        assertEquals(expectedOutput, crypto.getNormalizedCipherText());
+    }
+
+    @Test
+    public void normalizedCipherTextIsSplitIntoSegmentsOfCorrectSizeWithPunctuation() {
+        Crypto crypto = new Crypto("Have a nice day. Feed the dog & chill out!");
+        String expectedOutput = "hifei acedl veeol eddgo aatcu nyhht";
+
+        assertEquals(expectedOutput, crypto.getNormalizedCipherText());
+    }
+}

space-age/example.java

@@ -1,25 +1,32 @@
+import java.math.BigDecimal;
+
 public class SpaceAge {
 
     private enum Planet {
-        EARTH, MERCURY, VENUS, MARS, JUPITER, SATURN, URANUS, NEPTUNE
+        EARTH(1.0),
+        MERCURY(0.2408467),
+        VENUS(0.61519726),
+        MARS(1.8808158),
+        JUPITER(11.862615),
+        SATURN(29.447498),
+        URANUS(84.016846),
+        NEPTUNE(164.79132);
+
+        private final double relativeOrbitalPeriod;
+
+        Planet(double relativeOrbitalPeriod) {
+            this.relativeOrbitalPeriod = relativeOrbitalPeriod;
+        }
+
+        public double getRelativeOrbitalPeriod() {
+            return relativeOrbitalPeriod;
+        }
     }
 
-    private double seconds;
-
     private static final double EARTH_ORBITAL_PERIOD_IN_SECONDS = 31557600.0;
     private static final int PRECISION = 2;
-    private static final Map<Planet, Double> relativeOrbitalPeriods = new HashMap<>();
-
-    static {
-        relativeOrbitalPeriods.put(Planet.EARTH, 1.0);
-        relativeOrbitalPeriods.put(Planet.MERCURY, 0.2408467);
-        relativeOrbitalPeriods.put(Planet.VENUS, 0.61519726);
-        relativeOrbitalPeriods.put(Planet.MARS, 1.8808158);
-        relativeOrbitalPeriods.put(Planet.JUPITER, 11.862615);
-        relativeOrbitalPeriods.put(Planet.SATURN, 29.447498);
-        relativeOrbitalPeriods.put(Planet.URANUS, 84.016846);
-        relativeOrbitalPeriods.put(Planet.NEPTUNE, 164.79132);
-    }
+
+    private double seconds;
 
     public SpaceAge(double seconds) {
         this.seconds = seconds;
@@ -30,39 +37,39 @@ public class SpaceAge {
     }
 
     public double onEarth() {
-        return calculateAge(relativeOrbitalPeriods.get(Planet.EARTH));
+        return calculateAge(Planet.EARTH);
     }
 
     public double onMercury() {
-        return calculateAge(relativeOrbitalPeriods.get(Planet.MERCURY));
+        return calculateAge(Planet.MERCURY);
     }
 
     public double onVenus() {
-        return calculateAge(relativeOrbitalPeriods.get(Planet.VENUS));
+        return calculateAge(Planet.VENUS);
     }
 
     public double onMars() {
-        return calculateAge(relativeOrbitalPeriods.get(Planet.MARS));
+        return calculateAge(Planet.MARS);
     }
 
     public double onJupiter() {
-        return calculateAge(relativeOrbitalPeriods.get(Planet.JUPITER));
+        return calculateAge(Planet.JUPITER);
     }
 
     public double onSaturn() {
-        return calculateAge(relativeOrbitalPeriods.get(Planet.SATURN));
+        return calculateAge(Planet.SATURN);
     }
 
     public double onUranus() {
-        return calculateAge(relativeOrbitalPeriods.get(Planet.URANUS));
+        return calculateAge(Planet.URANUS);
     }
 
     public double onNeptune() {
-        return calculateAge(relativeOrbitalPeriods.get(Planet.NEPTUNE));
+        return calculateAge(Planet.NEPTUNE);
     }
 
-    private double calculateAge(double relativeOrbitalPeriod) {
-        double age = seconds / (EARTH_ORBITAL_PERIOD_IN_SECONDS * relativeOrbitalPeriod);
+    private double calculateAge(Planet planet) {
+        double age = seconds / (EARTH_ORBITAL_PERIOD_IN_SECONDS * planet.getRelativeOrbitalPeriod());
 
         return new BigDecimal(age).setScale(PRECISION, BigDecimal.ROUND_HALF_UP).doubleValue();
     }

strain/example.java

@@ -1,16 +1,26 @@
-import java.util.Collection;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.function.Predicate;
-import java.util.stream.Collectors;
 
 public class Strain {
 
-	public static <T> Collection<T> keep(Collection<T> coll, Predicate<T> func)
-	{
-		return coll.stream().filter(func).collect(Collectors.toList());
+	public static <T> List<T> keep(List<T> collection, Predicate<T> predicate) {
+		return filter(collection, predicate);
 	}
-	
-	public static <T> Collection<T> discard(Collection<T> coll, Predicate<T> func)
-	{
-		return coll.stream().filter(func.negate()).collect(Collectors.toList());
+
+	public static <T> List<T> discard(List<T> collection, Predicate<T> predicate) {
+		return filter(collection, predicate.negate());
+	}
+
+	public static <T> List<T> filter(List<T> collection, Predicate<T> predicate) {
+		List<T> filteredCollection = new ArrayList<>();
+
+		for (T item : collection) {
+			if (predicate.test(item)) {
+				filteredCollection.add(item);
+			}
+		}
+
+		return filteredCollection;
 	}
 }

strain/src/test/java/StrainTest.java

@@ -1,123 +1,121 @@
-package strain;
+import org.junit.Assert;
+import org.junit.Test;
 
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 
-import org.junit.Assert;
-import org.junit.Test;
-
 public class StrainTest {
 
-	@Test
-	public void emptyKeep() {
-		List<Integer> expected = new LinkedList<>();
-		List<Integer> test = new LinkedList<>();
-		Assert.assertEquals(expected, Strain.keep(test, x -> x < 10));
-	}
-
-	@Test
-	public void keepEverything() {
-		List<Integer> expected = Arrays.asList(1, 2, 3);
-		List<Integer> test = Arrays.asList(1, 2, 3);
-		Assert.assertEquals(expected, Strain.keep(test, x -> x < 10));
-	}
-
-	@Test
-	public void keepFirstAndLast() {
-		List<Integer> expected = Arrays.asList(1, 3);
-		List<Integer> test = Arrays.asList(1, 2, 3);
-		Assert.assertEquals(expected, Strain.keep(test, x -> x % 2 != 0));
-	}
-
-	@Test
-	public void keepNeitherFirstNorLast() {
-		List<Integer> expected = Arrays.asList(2, 4);
-		List<Integer> test = Arrays.asList(1, 2, 3, 4, 5);
-		Assert.assertEquals(expected, Strain.keep(test, x -> x % 2 == 0));
-	}
-
-	@Test
-	public void KeepStrings() {
-		List<String> words = Arrays
-				.asList("apple zebra banana zombies cherimoya zelot".split(" "));
-		List<String> expected = Arrays.asList("zebra", "zombies", "zelot");
-		Assert.assertEquals(expected,
-				Strain.keep(words, x -> x.startsWith("z")));
-	}
-
-	@Test
-	public void KeepArrays() {
-		List<List<Integer>> actual = Arrays.asList(
-				Arrays.asList(1, 2, 3),
-				Arrays.asList(5, 5, 5), 
-				Arrays.asList(5, 1, 2),
-				Arrays.asList(2, 1, 2), 
-				Arrays.asList(1, 5, 2),
-				Arrays.asList(2, 2, 1), 
-				Arrays.asList(1, 2, 5));
-		List<List<Integer>> expected = Arrays.asList(
-				Arrays.asList(5, 5, 5),
-				Arrays.asList(5, 1, 2), 
-				Arrays.asList(1, 5, 2),
-				Arrays.asList(1, 2, 5));
-		Assert.assertEquals(expected,
-				Strain.keep(actual, col -> col.contains(5)));
-	}
-
-	@Test
-	public void emptyDiscard() {
-		List<Integer> expected = new LinkedList<>();
-		List<Integer> test = new LinkedList<>();
-		Assert.assertEquals(expected, Strain.discard(test, x -> x < 10));
-	}
-
-	@Test
-	public void discardNothing() {
-		List<Integer> expected = Arrays.asList(1, 2, 3);
-		List<Integer> test = Arrays.asList(1, 2, 3);
-		Assert.assertEquals(expected, Strain.discard(test, x -> x > 10));
-	}
-
-	@Test
-	public void discardFirstAndLast() {
-		List<Integer> expected = Arrays.asList(2);
-		List<Integer> test = Arrays.asList(1, 2, 3);
-		Assert.assertEquals(expected, Strain.discard(test, x -> x % 2 != 0));
-
-	}
-
-	@Test
-	public void discardNeitherFirstNorLast() {
-		List<Integer> expected = Arrays.asList(1, 3, 5);
-		List<Integer> test = Arrays.asList(1, 2, 3, 4, 5);
-		Assert.assertEquals(expected, Strain.discard(test, x -> x % 2 == 0));
-	}
-
-	@Test
-	public void discardStrings() {
-		List<String> words = Arrays
-				.asList("apple zebra banana zombies cherimoya zelot".split(" "));
-		List<String> expected = Arrays.asList("apple", "banana", "cherimoya");
-		Assert.assertEquals(expected,
-				Strain.discard(words, x -> x.startsWith("z")));
-	}
-
-	@Test
-	public void discardArrays() {
-		List<List<Integer>> actual = Arrays.asList(
-				Arrays.asList(1, 2, 3),
-				Arrays.asList(5, 5, 5),
-				Arrays.asList(5, 1, 2),
-				Arrays.asList(2, 1, 2),
-				Arrays.asList(1, 5, 2),
-				Arrays.asList(2, 2, 1),
-				Arrays.asList(1, 2, 5));
-		List<List<Integer>> expected = Arrays.asList(
-				Arrays.asList(1, 2, 3),
-				Arrays.asList(2, 1, 2),
-				Arrays.asList(2, 2, 1));
-		Assert.assertEquals(expected,
-				Strain.discard(actual, col -> col.contains(5)));
-	}
+    @Test
+    public void emptyKeep() {
+        List<Integer> input = new LinkedList<>();
+        List<Integer> expectedOutput = new LinkedList<>();
+        Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x < 10));
+    }
+
+    @Test
+    public void keepEverything() {
+        List<Integer> input = Arrays.asList(1, 2, 3);
+        List<Integer> expectedOutput = Arrays.asList(1, 2, 3);
+        Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x < 10));
+    }
+
+    @Test
+    public void keepFirstAndLast() {
+        List<Integer> input = Arrays.asList(1, 2, 3);
+        List<Integer> expectedOutput = Arrays.asList(1, 3);
+        Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x % 2 != 0));
+    }
+
+    @Test
+    public void keepNeitherFirstNorLast() {
+        List<Integer> input = Arrays.asList(1, 2, 3, 4, 5);
+        List<Integer> expectedOutput = Arrays.asList(2, 4);
+        Assert.assertEquals(expectedOutput, Strain.keep(input, x -> x % 2 == 0));
+    }
+
+    @Test
+    public void KeepStrings() {
+        List<String> words = Arrays
+                .asList("apple zebra banana zombies cherimoya zelot".split(" "));
+        List<String> expectedOutput = Arrays.asList("zebra", "zombies", "zelot");
+        Assert.assertEquals(expectedOutput,
+                Strain.keep(words, x -> x.startsWith("z")));
+    }
+
+    @Test
+    public void KeepArrays() {
+        List<List<Integer>> actual = Arrays.asList(
+                Arrays.asList(1, 2, 3),
+                Arrays.asList(5, 5, 5),
+                Arrays.asList(5, 1, 2),
+                Arrays.asList(2, 1, 2),
+                Arrays.asList(1, 5, 2),
+                Arrays.asList(2, 2, 1),
+                Arrays.asList(1, 2, 5));
+        List<List<Integer>> expectedOutput = Arrays.asList(
+                Arrays.asList(5, 5, 5),
+                Arrays.asList(5, 1, 2),
+                Arrays.asList(1, 5, 2),
+                Arrays.asList(1, 2, 5));
+        Assert.assertEquals(expectedOutput,
+                Strain.keep(actual, col -> col.contains(5)));
+    }
+
+    @Test
+    public void emptyDiscard() {
+        List<Integer> input = new LinkedList<>();
+        List<Integer> expectedOutput = new LinkedList<>();
+        Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x < 10));
+    }
+
+    @Test
+    public void discardNothing() {
+        List<Integer> input = Arrays.asList(1, 2, 3);
+        List<Integer> expectedOutput = Arrays.asList(1, 2, 3);
+        Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x > 10));
+    }
+
+    @Test
+    public void discardFirstAndLast() {
+        List<Integer> input = Arrays.asList(1, 2, 3);
+        List<Integer> expectedOutput = Arrays.asList(2);
+        Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x % 2 != 0));
+
+    }
+
+    @Test
+    public void discardNeitherFirstNorLast() {
+        List<Integer> input = Arrays.asList(1, 2, 3, 4, 5);
+        List<Integer> expectedOutput = Arrays.asList(1, 3, 5);
+        Assert.assertEquals(expectedOutput, Strain.discard(input, x -> x % 2 == 0));
+    }
+
+    @Test
+    public void discardStrings() {
+        List<String> words = Arrays
+                .asList("apple zebra banana zombies cherimoya zelot".split(" "));
+        List<String> expectedOutput = Arrays.asList("apple", "banana", "cherimoya");
+        Assert.assertEquals(expectedOutput,
+                Strain.discard(words, x -> x.startsWith("z")));
+    }
+
+    @Test
+    public void discardArrays() {
+        List<List<Integer>> actual = Arrays.asList(
+                Arrays.asList(1, 2, 3),
+                Arrays.asList(5, 5, 5),
+                Arrays.asList(5, 1, 2),
+                Arrays.asList(2, 1, 2),
+                Arrays.asList(1, 5, 2),
+                Arrays.asList(2, 2, 1),
+                Arrays.asList(1, 2, 5));
+        List<List<Integer>> expectedOutput = Arrays.asList(
+                Arrays.asList(1, 2, 3),
+                Arrays.asList(2, 1, 2),
+                Arrays.asList(2, 2, 1));
+        Assert.assertEquals(expectedOutput,
+                Strain.discard(actual, col -> col.contains(5)));
+    }
 }