crypto-square: update to match canonical data (#1178)

* crypto-square: update to match canonical data

* crypto-square: rename crypto to cryptoSquare in tests

exercises/crypto-square/.meta/src/reference/java/Crypto.java

@@ -1,74 +0,0 @@
-import java.util.ArrayList;
-import java.util.List;
-
-class Crypto {
-
-    private String normalizedPlaintext;
-    private int squareSize;
-
-    Crypto(String text) {
-        this.normalizedPlaintext = normalizeText(text);
-        this.squareSize = calculateSquareSize(normalizedPlaintext);
-    }
-
-    String getNormalizedPlaintext() {
-        return normalizedPlaintext;
-    }
-
-    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()));
-    }
-
-    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;
-    }
-
-    String getCipherText() {
-        return getNormalizedCipherText().replaceAll("\\s", "");
-    }
-
-    String getNormalizedCipherText() {
-        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));
-                }
-            }
-
-            if (index < squareSize - 1) {
-                cipherText.append(" ");
-            }
-        }
-
-        return cipherText.toString();
-    }
-}

exercises/crypto-square/.meta/src/reference/java/CryptoSquare.java

@@ -0,0 +1,62 @@
+import java.util.ArrayList;
+import java.util.List;
+
+class CryptoSquare {
+
+    private String ciphertext;
+
+    CryptoSquare(String plaintext) {
+        this.ciphertext = calculateCiphertext(plaintext);
+    }
+
+    String getCiphertext() {
+        return ciphertext;
+    }
+
+    private String calculateCiphertext(String plaintext) {
+        String normalizedPlaintext = normalizeText(plaintext);
+        StringBuilder ciphertext = new StringBuilder(normalizedPlaintext.length());
+        int squareSize = calculateSquareSize(normalizedPlaintext);
+
+        for (int i = 0; i < squareSize; i++) {
+            for (String segment : getSegments(normalizedPlaintext, squareSize)) {
+                if (i < segment.length()) {
+                    ciphertext.append(segment.charAt(i));
+                } else {
+                    ciphertext.append(" ");
+                }
+            }
+
+            if (i < squareSize - 1) {
+                ciphertext.append(" ");
+            }
+        }
+
+        return ciphertext.toString();
+    }
+
+    private String normalizeText(String plaintext) {
+        return plaintext.toLowerCase().codePoints()
+                .filter(Character::isLetterOrDigit)
+                .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append)
+                .toString();
+    }
+
+    private int calculateSquareSize(String normalizedPlaintext) {
+        return (int) Math.ceil(Math.sqrt(normalizedPlaintext.length()));
+    }
+
+    private List<String> getSegments(String normalizedPlaintext, int squareSize) {
+        List<String> segments = new ArrayList<>();
+
+        for (int i = 0; i < normalizedPlaintext.length(); i += squareSize) {
+            if (i + squareSize < normalizedPlaintext.length()) {
+                segments.add(normalizedPlaintext.substring(i, i + squareSize));
+            } else {
+                segments.add(normalizedPlaintext.substring(i));
+            }
+        }
+
+        return segments;
+    }
+}

exercises/crypto-square/.meta/version

@@ -0,0 +1 @@
+3.1.0

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

@@ -8,138 +8,65 @@ 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());
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void lettersAreLowerCasedDuringNormalization() {
-        Crypto crypto = new Crypto("WHOA HEY!");
-        String expectedOutput = "whoahey";
-
-        assertEquals(expectedOutput, crypto.getNormalizedPlaintext());
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void numbersAreKeptDuringNormalization() {
-        Crypto crypto = new Crypto("1, 2, 3, GO!");
-        String expectedOutput = "123go";
-
-        assertEquals(expectedOutput, crypto.getNormalizedPlaintext());
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void smallestSquareSizeIs2() {
-        Crypto crypto = new Crypto("1234");
-        int expectedOutput = 2;
-
-        assertEquals(expectedOutput, crypto.getSquareSize());
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void sizeOfTextWhoseLengthIsPerfectSquareIsItsSquareRoot() {
-        Crypto crypto = new Crypto("123456789");
-        int expectedOutput = 3;
-
-        assertEquals(expectedOutput, crypto.getSquareSize());
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void sizeOfTextWhoseLengthIsNoPerfectSquareIsNextBiggestSquareRoot() {
-        Crypto crypto = new Crypto("123456789abc");
-        int expectedOutput = 4;
-
-        assertEquals(expectedOutput, crypto.getSquareSize());
-    }
-
-    @Ignore("Remove to run test")
-    @Test
-    public void sizeIsDeterminedByNormalizedText() {
-        Crypto crypto = new Crypto("Oh hey, this is nuts!");
-        int expectedOutput = 4;
-
-        assertEquals(expectedOutput, crypto.getSquareSize());
-    }
-
-    @Ignore("Remove to run test")
-    @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());
-    }
-
-    @Ignore("Remove to run test")
     @Test
-    public void segmentsAreSplitBySquareSizeUntilTextRunsOut() {
-        Crypto crypto = new Crypto("ZOMG! ZOMBIES!!!");
-        List<String> expectedOutput = Arrays.asList(new String[]{"zomg", "zomb", "ies"});
+    public void emptyPlaintextResultsInEmptyCiphertext() {
+        CryptoSquare cryptoSquare = new CryptoSquare("");
+        String expectedOutput = "";
 
-        assertEquals(expectedOutput, crypto.getPlaintextSegments());
+        assertEquals(expectedOutput, cryptoSquare.getCiphertext());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void cipherTextCombinesTextByColumn() {
-        Crypto crypto = new Crypto("First, solve the problem. Then, write the code.");
-        String expectedOutput = "foeewhilpmrervrticseohtottbeedshlnte";
+    public void lettersAreLowerCasedDuringEncryption() {
+        CryptoSquare cryptoSquare = new CryptoSquare("A");
+        String expectedOutput = "a";
 
-        assertEquals(expectedOutput, crypto.getCipherText());
+        assertEquals(expectedOutput, cryptoSquare.getCiphertext());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void cipherTextSkipsCellsWithNoText() {
-        Crypto crypto = new Crypto("Time is an illusion. Lunchtime doubly so.");
-        String expectedOutput = "tasneyinicdsmiohooelntuillibsuuml";
+    public void spacesAreRemovedDuringEncryption() {
+        CryptoSquare cryptoSquare = new CryptoSquare(" b ");
+        String expectedOutput = "b";
 
-        assertEquals(expectedOutput, crypto.getCipherText());
+        assertEquals(expectedOutput, cryptoSquare.getCiphertext());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void normalizedCipherTextIsSplitByHeightOfSquare() {
-        Crypto crypto = new Crypto("Vampires are people too!");
-        String expectedOutput = "vrel aepe mset paoo irpo";
+    public void punctuationIsRemovedDuringEncryption() {
+        CryptoSquare cryptoSquare = new CryptoSquare("@1,%!");
+        String expectedOutput = "1";
 
-        assertEquals(expectedOutput, crypto.getNormalizedCipherText());
+        assertEquals(expectedOutput, cryptoSquare.getCiphertext());
     }
 
     @Ignore("Remove to run test")
     @Test
-    public void normalizedCipherNotExactlyDivisibleBy5SpillsIntoSmallerSegment() {
-        Crypto crypto = new Crypto("Madness, and then illumination.");
-        String expectedOutput = "msemo aanin dnin ndla etlt shui";
+    public void nineCharacterPlaintextResultsInThreeChunksOfThreeCharacters() {
+        CryptoSquare cryptoSquare = new CryptoSquare("This is fun!");
+        String expectedOutput = "tsf hiu isn";
 
-        assertEquals(expectedOutput, crypto.getNormalizedCipherText());
+        assertEquals(expectedOutput, cryptoSquare.getCiphertext());
     }
 
     @Ignore("Remove to run test")
     @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 aohghn sseoau";
+    public void eightCharacterPlaintextResultsInThreeChunksWithATrailingSpace() {
+        CryptoSquare cryptoSquare = new CryptoSquare("Chill out.");
+        String expectedOutput = "clu hlt io ";
 
-        assertEquals(expectedOutput, crypto.getNormalizedCipherText());
+        assertEquals(expectedOutput, cryptoSquare.getCiphertext());
     }
 
     @Ignore("Remove to run test")
     @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";
+    public void fiftyFourCharacterPlaintextResultsInSevenChunksWithTrailingSpaces() {
+        CryptoSquare cryptoSquare = new CryptoSquare("If man was meant to stay on the ground, god would have given us roots.");
+        String expectedOutput = "imtgdvs fearwer mayoogo anouuio ntnnlvt wttddes aohghn  sseoau ";
 
-        assertEquals(expectedOutput, crypto.getNormalizedCipherText());
+        assertEquals(expectedOutput, cryptoSquare.getCiphertext());
     }
 }