Affine cipher exercise

config.json

@@ -672,6 +672,18 @@
           "lists"
         ]
       },
+      {
+        "slug": "affine-cipher",
+        "name": "Affine Cipher",
+        "uuid": "31d1b9b8-558c-46ee-8d11-c2217ad5fd77",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 6,
+        "topics": [
+          "algorithms",
+          "strings"
+        ]
+      },
       {
         "slug": "alphametics",
         "name": "Alphametics",
@@ -1109,6 +1121,19 @@
           "number_theory"
         ]
       },
+      {
+        "slug": "rational-numbers",
+        "name": "Rational Numbers",
+        "uuid": "b4426fe9-2e49-48c5-9dea-c86032009687",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 3,
+        "topics": [
+          "define_type",
+          "math",
+          "number_theory"
+        ]
+      },
       {
         "slug": "largest-series-product",
         "name": "Largest Series Product",

exercises/practice/affine-cipher/.docs/instructions.append.md

@@ -0,0 +1,37 @@
+# Hints
+
+You need to implement the `decode` and `encode` functions, which decode and encode a `String` using an Affine cipher.
+You can use the provided signature if you are unsure about the types, but don't let it restrict your creativity.
+
+This exercise works with textual data. For historical reasons, Haskell's
+`String` type is synonymous with `[Char]`, a list of characters. For more
+efficient handling of textual data, the `Text` type can be used.
+
+As an optional extension to this exercise, you can
+
+- read about [string types](https://haskell-lang.org/tutorial/string-types) in
+  Haskell.
+- add `- text` to your list of dependencies in package.yaml.
+- import `Data.Text` in [the following
+  way](https://hackernoon.com/4-steps-to-a-better-imports-list-in-haskell-43a3d868273c):
+
+```haskell
+import qualified Data.Text as T
+import           Data.Text (Text)
+```
+
+- use the `Text` type e.g. `decode :: Text -> Text` and refer to
+  `Data.Text` combinators as e.g. `T.pack`.
+- look up the documentation for
+  [`Data.Text`](https://hackage.haskell.org/package/text/docs/Data-Text.html).
+- replace all occurrences of `String` with `Text` in Affine.hs, i.e.:
+
+```haskell
+encode :: (Int, Int) -> Text -> Maybe Text
+encode key plainText = ...
+
+decode :: (Int, Int) -> Text -> Maybe Text
+decode key cipherText = ...
+```
+
+This part is entirely optional.

exercises/practice/affine-cipher/.docs/instructions.md

@@ -0,0 +1,74 @@
+# Instructions
+
+Create an implementation of the affine cipher, an ancient encryption system created in the Middle East.
+
+The affine cipher is a type of monoalphabetic substitution cipher.
+Each character is mapped to its numeric equivalent, encrypted with a mathematical function and then converted to the letter relating to its new numeric value.
+Although all monoalphabetic ciphers are weak, the affine cipher is much stronger than the atbash cipher, because it has many more keys.
+
+[//]: # " monoalphabetic as spelled by Merriam-Webster, compare to polyalphabetic "
+
+## Encryption
+
+The encryption function is:
+
+```text
+E(x) = (ai + b) mod m
+```
+
+Where:
+
+- `i` is the letter's index from `0` to the length of the alphabet - 1
+- `m` is the length of the alphabet.
+  For the Roman alphabet `m` is `26`.
+- `a` and `b` are integers which make the encryption key
+
+Values `a` and `m` must be _coprime_ (or, _relatively prime_) for automatic decryption to succeed, i.e., they have number `1` as their only common factor (more information can be found in the [Wikipedia article about coprime integers][coprime-integers]).
+In case `a` is not coprime to `m`, your program should indicate that this is an error.
+Otherwise it should encrypt or decrypt with the provided key.
+
+For the purpose of this exercise, digits are valid input but they are not encrypted.
+Spaces and punctuation characters are excluded.
+Ciphertext is written out in groups of fixed length separated by space, the traditional group size being `5` letters.
+This is to make it harder to guess encrypted text based on word boundaries.
+
+## Decryption
+
+The decryption function is:
+
+```text
+D(y) = (a^-1)(y - b) mod m
+```
+
+Where:
+
+- `y` is the numeric value of an encrypted letter, i.e., `y = E(x)`
+- it is important to note that `a^-1` is the modular multiplicative inverse (MMI) of `a mod m`
+- the modular multiplicative inverse only exists if `a` and `m` are coprime.
+
+The MMI of `a` is `x` such that the remainder after dividing `ax` by `m` is `1`:
+
+```text
+ax mod m = 1
+```
+
+More information regarding how to find a Modular Multiplicative Inverse and what it means can be found in the [related Wikipedia article][mmi].
+
+## General Examples
+
+- Encrypting `"test"` gives `"ybty"` with the key `a = 5`, `b = 7`
+- Decrypting `"ybty"` gives `"test"` with the key `a = 5`, `b = 7`
+- Decrypting `"ybty"` gives `"lqul"` with the wrong key `a = 11`, `b = 7`
+- Decrypting `"kqlfd jzvgy tpaet icdhm rtwly kqlon ubstx"` gives `"thequickbrownfoxjumpsoverthelazydog"` with the key `a = 19`, `b = 13`
+- Encrypting `"test"` with the key `a = 18`, `b = 13` is an error because `18` and `26` are not coprime
+
+## Example of finding a Modular Multiplicative Inverse (MMI)
+
+Finding MMI for `a = 15`:
+
+- `(15 * x) mod 26 = 1`
+- `(15 * 7) mod 26 = 1`, ie. `105 mod 26 = 1`
+- `7` is the MMI of `15 mod 26`
+
+[mmi]: https://en.wikipedia.org/wiki/Modular_multiplicative_inverse
+[coprime-integers]: https://en.wikipedia.org/wiki/Coprime_integers

exercises/practice/affine-cipher/.meta/config.json

@@ -0,0 +1,22 @@
+{
+  "authors": [],
+  "files": {
+    "solution": [
+      "src/AffineCipher.hs",
+      "package.yaml"
+    ],
+    "test": [
+      "test/Tests.hs"
+    ],
+    "example": [
+      ".meta/examples/success-standard/src/AffineCipher.hs",
+      ".meta/examples/success-text/src/AffineCipher.hs"
+    ],
+    "invalidator": [
+      "stack.yaml"
+    ]
+  },
+  "blurb": "Create an implementation of the Affine cipher, an ancient encryption algorithm from the Middle East.",
+  "source": "Wikipedia",
+  "source_url": "https://en.wikipedia.org/wiki/Affine_cipher"
+}

exercises/practice/affine-cipher/.meta/examples/success-standard/package.yaml

@@ -0,0 +1,18 @@
+name: affine-cipher
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Affine
+  source-dirs: src
+  dependencies:
+    - split
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - affine-cipher
+      - hspec

exercises/practice/affine-cipher/.meta/examples/success-standard/src/Affine.hs

@@ -0,0 +1,35 @@
+module Affine (decode, encode) where
+
+import Data.Char (chr, isAlphaNum, isDigit, ord, toLower)
+import Data.List (find)
+import Data.List.Split (chunksOf)
+
+alphabetStart :: Int
+alphabetStart = ord 'a'
+
+alphabetLength :: Int
+alphabetLength = 26
+
+encode :: (Int, Int) -> String -> Maybe String
+encode (keyA, keyB) cipherText = processText <$> findMMI keyA
+  where
+    processText mmi = unwords $ chunksOf 5 $ translateString (func mmi) cipherText
+    func _ idx = (keyA*idx + keyB) `mod` alphabetLength
+
+decode :: (Int, Int) -> String -> Maybe String
+decode (keyA, keyB) plainText = processText <$> findMMI keyA
+  where
+    processText mmi = translateString (func mmi) plainText
+    func mmi idx = mmi*(idx-keyB) `mod` alphabetLength
+
+translateString :: (Int -> Int) -> String -> String
+translateString func text = map translateChar $ filter isAlphaNum text 
+  where
+    translateChar ch = if isDigit ch then ch else fromIndex $ func $ toIndex $ toLower ch
+    fromIndex idx = chr (idx + alphabetStart)
+    toIndex ch = ord ch - alphabetStart
+
+findMMI :: Int -> Maybe Int
+findMMI keyA = find isMMI [1..alphabetLength]
+  where
+    isMMI x = keyA*x `mod` alphabetLength == 1

exercises/practice/affine-cipher/.meta/examples/success-text/package.yaml

@@ -0,0 +1,18 @@
+name: affine-cipher
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Affine
+  source-dirs: src
+  dependencies:
+    - text
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - affine-cipher
+      - hspec

exercises/practice/affine-cipher/.meta/examples/success-text/src/Affine.hs

@@ -0,0 +1,36 @@
+module Affine (decode, encode) where
+
+import           Data.Char
+import           Data.List (find)
+import qualified Data.Text as T
+import           Data.Text (Text)
+
+alphabetStart :: Int
+alphabetStart = ord 'a'
+
+alphabetLength :: Int
+alphabetLength = 26
+
+encode :: (Int, Int) -> Text -> Maybe Text
+encode (keyA, keyB) cipherText = processText <$> findMMI keyA
+  where
+    processText mmi = T.unwords $ T.chunksOf 5 $ translateString (func mmi) cipherText
+    func _ idx = (keyA*idx + keyB) `mod` alphabetLength
+
+decode :: (Int, Int) -> Text -> Maybe Text
+decode (keyA, keyB) plainText = processText <$> findMMI keyA
+  where
+    processText mmi = translateString (func mmi) plainText
+    func mmi idx = mmi*(idx-keyB) `mod` alphabetLength
+
+translateString :: (Int -> Int) -> Text -> Text
+translateString func text = T.map translateChar $ T.filter isAlphaNum text 
+  where
+    translateChar ch = if isDigit ch then ch else fromIndex $ func $ toIndex $ toLower ch
+    fromIndex idx = chr (idx + alphabetStart)
+    toIndex ch = ord ch - alphabetStart
+
+findMMI :: Int -> Maybe Int
+findMMI keyA = find isMMI [1..alphabetLength]
+  where
+    isMMI x = keyA*x `mod` alphabetLength == 1

exercises/practice/affine-cipher/.meta/tests.toml

@@ -0,0 +1,58 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[2ee1d9af-1c43-416c-b41b-cefd7d4d2b2a]
+description = "encode -> encode yes"
+
+[785bade9-e98b-4d4f-a5b0-087ba3d7de4b]
+description = "encode -> encode no"
+
+[2854851c-48fb-40d8-9bf6-8f192ed25054]
+description = "encode -> encode OMG"
+
+[bc0c1244-b544-49dd-9777-13a770be1bad]
+description = "encode -> encode O M G"
+
+[381a1a20-b74a-46ce-9277-3778625c9e27]
+description = "encode -> encode mindblowingly"
+
+[6686f4e2-753b-47d4-9715-876fdc59029d]
+description = "encode -> encode numbers"
+
+[ae23d5bd-30a8-44b6-afbe-23c8c0c7faa3]
+description = "encode -> encode deep thought"
+
+[c93a8a4d-426c-42ef-9610-76ded6f7ef57]
+description = "encode -> encode all the letters"
+
+[0673638a-4375-40bd-871c-fb6a2c28effb]
+description = "encode -> encode with a not coprime to m"
+
+[3f0ac7e2-ec0e-4a79-949e-95e414953438]
+description = "decode -> decode exercism"
+
+[241ee64d-5a47-4092-a5d7-7939d259e077]
+description = "decode -> decode a sentence"
+
+[33fb16a1-765a-496f-907f-12e644837f5e]
+description = "decode -> decode numbers"
+
+[20bc9dce-c5ec-4db6-a3f1-845c776bcbf7]
+description = "decode -> decode all the letters"
+
+[623e78c0-922d-49c5-8702-227a3e8eaf81]
+description = "decode -> decode with no spaces in input"
+
+[58fd5c2a-1fd9-4563-a80a-71cff200f26f]
+description = "decode -> decode with too many spaces"
+
+[b004626f-c186-4af9-a3f4-58f74cdb86d5]
+description = "decode -> decode with a not coprime to m"

exercises/practice/affine-cipher/package.yaml

@@ -0,0 +1,21 @@
+name: affine-cipher
+version: 1.0.0.0
+
+dependencies:
+  - base
+
+library:
+  exposed-modules: Affine
+  source-dirs: src
+  ghc-options: -Wall
+  # dependencies:
+  # - foo       # List here the packages you
+  # - bar       # want to use in your solution.
+
+tests:
+  test:
+    main: Tests.hs
+    source-dirs: test
+    dependencies:
+      - affine-cipher
+      - hspec

exercises/practice/affine-cipher/src/Affine.hs

@@ -0,0 +1,7 @@
+module Affine (decode, encode) where
+
+decode :: (Int, Int) -> String -> Maybe String
+decode key cipherText = error "You need to implement this function."
+
+encode :: (Int, Int) -> String -> Maybe String
+encode key plainText = error "You need to implement this function."

exercises/practice/affine-cipher/stack.yaml

@@ -0,0 +1 @@
+resolver: lts-20.18