Develop

src/main/java/io/github/vbetsch/codecracker/CodeCracker.java

@@ -1,5 +1,31 @@
 package io.github.vbetsch.codecracker;
 
 public class CodeCracker {
+    private final TranslationDictionary dictionary = new TranslationDictionary();
 
+    public char decryptChar(char letter) {
+        return dictionary.getDecryptions().get(letter);
+    }
+
+    public char encryptLetter(char character) {
+        return dictionary.getEncryptions().get(character);
+    }
+
+    public String decryptString(String string) {
+        StringBuilder stringBuilder = new StringBuilder();
+        for (char character : string.toCharArray()) {
+            stringBuilder.append(decryptChar(character));
+        }
+        return stringBuilder.toString();
+    }
+
+    public String encryptString(String string) {
+        StringBuilder stringBuilder = new StringBuilder();
+        for (char character : string.toCharArray()) {
+            char lowerCaseChar = Character.toLowerCase(character);
+            if (!dictionary.containsDecryptionValue(lowerCaseChar)) continue;
+            stringBuilder.append(encryptLetter(lowerCaseChar));
+        }
+        return stringBuilder.toString();
+    }
 }

src/main/java/io/github/vbetsch/codecracker/Main.java

@@ -1,17 +1,9 @@
 package io.github.vbetsch.codecracker;
 
-//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
-// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
 public class Main {
     static void main() {
-        //TIP Press <shortcut actionId="ShowIntentionActions"/> with your caret at the highlighted text
-        // to see how IntelliJ IDEA suggests fixing it.
-        IO.println(String.format("Hello and welcome!"));
-
-        for (int i = 1; i <= 5; i++) {
-            //TIP Press <shortcut actionId="Debug"/> to start debugging your code. We have set one <icon src="AllIcons.Debugger.Db_set_breakpoint"/> breakpoint
-            // for you, but you can always add more by pressing <shortcut actionId="ToggleLineBreakpoint"/>.
-            IO.println("i = " + i);
-        }
+        CodeCracker codeCracker = new CodeCracker();
+        IO.println(String.format("Hello world!"));
+        System.out.println("Encrypted : " + codeCracker.encryptString("Hello world!"));
     }
 }

src/main/java/io/github/vbetsch/codecracker/TranslationDictionary.java

@@ -0,0 +1,60 @@
+package io.github.vbetsch.codecracker;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static java.util.Map.entry;
+
+public class TranslationDictionary {
+
+    private final Map<Character, Character> decryptions = Map.ofEntries(
+            entry('!', 'a'),
+            entry(')', 'b'),
+            entry('"', 'c'),
+            entry('(', 'd'),
+            entry('£', 'e'),
+            entry('*', 'f'),
+            entry('%', 'g'),
+            entry('&', 'h'),
+            entry('>', 'i'),
+            entry('<', 'j'),
+            entry('@', 'k'),
+            entry('a', 'l'),
+            entry('b', 'm'),
+            entry('c', 'n'),
+            entry('d', 'o'),
+            entry('e', 'p'),
+            entry('f', 'q'),
+            entry('g', 'r'),
+            entry('h', 's'),
+            entry('i', 't'),
+            entry('j', 'u'),
+            entry('k', 'v'),
+            entry('l', 'w'),
+            entry('m', 'x'),
+            entry('n', 'y'),
+            entry('o', 'z')
+    );
+
+    private final Map<Character, Character> encryptions = invert(decryptions);
+
+    private static Map<Character, Character> invert(Map<Character, Character> map) {
+        Map<Character, Character> inverted = new HashMap<>();
+        for (Map.Entry<Character, Character> entry : map.entrySet()) {
+            inverted.put(entry.getValue(), entry.getKey());
+        }
+        return inverted;
+    }
+
+    public Map<Character, Character> getDecryptions() {
+        return decryptions;
+    }
+
+    public Map<Character, Character> getEncryptions() {
+        return encryptions;
+    }
+
+    public boolean containsDecryptionValue(char letter) {
+        return decryptions.containsValue(letter);
+    }
+}

src/test/java/io/github/vbetsch/codecracker/CodeCrackerTest.java

@@ -2,15 +2,151 @@
 
 import org.junit.jupiter.api.Test;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 class CodeCrackerTest {
 
     @Test
-    void should_doSomething_whenSomeCondition() {
+    void should_returnLetterA_whenDecryptExclamationPoint() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        char decryptedExclamationPoint = codeCracker.decryptChar('!');
+
+        // Assert
+        assertEquals('a', decryptedExclamationPoint);
+    }
+
+    @Test
+    void should_returnLetterB_whenDecryptEndParenthesis() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        char decryptedEndParenthesis = codeCracker.decryptChar(')');
+
+        // Assert
+        assertEquals('b', decryptedEndParenthesis);
+    }
+
+    @Test
+    void should_returnWordAB_whenDecryptExclamationPointAndEndParenthesis() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        String decryptedString = codeCracker.decryptString("!)");
+
+        // Assert
+        assertEquals("ab", decryptedString);
+    }
+
+    @Test
+    void should_decryptWordHello() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        String decryptedString = codeCracker.decryptString("&£aad");
+
+        // Assert
+        assertEquals("hello", decryptedString);
+    }
+
+    @Test
+    void should_decryptWordWorld() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        String decryptedString = codeCracker.decryptString("ldga(");
+
+        // Assert
+        assertEquals("world", decryptedString);
+    }
+
+    @Test
+    void should_returnExclamationPoint_whenEncryptLetterA() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        char encryptedLetterA = codeCracker.encryptLetter('a');
+
+        // Assert
+        assertEquals('!', encryptedLetterA);
+    }
+
+    @Test
+    void should_returnEndParenthesis_whenEncryptLetterB() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        char encryptedLetterB = codeCracker.encryptLetter('b');
+
+        // Assert
+        assertEquals(')', encryptedLetterB);
+    }
+
+    @Test
+    void should_returnExclamationPointAndEndParenthesis_whenEncryptAB() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        String encryptedAB = codeCracker.encryptString("ab");
+
+        // Assert
+        assertEquals("!)", encryptedAB);
+    }
+
+    @Test
+    void should_encryptWordHello() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        String encryptedHello = codeCracker.encryptString("hello");
+
+        // Assert
+        assertEquals("&£aad", encryptedHello);
+    }
+
+    @Test
+    void should_encryptWordWorld() {
         // Arrange
         CodeCracker codeCracker = new CodeCracker();
 
         // Act
+        String encryptedWorld = codeCracker.encryptString("world");
+
         // Assert
+        assertEquals("ldga(", encryptedWorld);
     }
 
+    @Test
+    void should_handleUpperCaseInEncrypt() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        String encryptedHello = codeCracker.encryptString("Hello");
+
+        // Assert
+        assertEquals("&£aad", encryptedHello);
+    }
+
+    @Test
+    void should_handleUnknownCharacters() {
+        // Arrange
+        CodeCracker codeCracker = new CodeCracker();
+
+        // Act
+        String encryptedHello = codeCracker.encryptString("Hello !");
+
+        // Assert
+        assertEquals("&£aad", encryptedHello);
+    }
 }