Add a function to decrypt a message with the gamma cipher.

src/cipher_analytical_machine/ciphers/gamma.clj

@@ -0,0 +1,78 @@
+(ns cipher-analytical-machine.ciphers.gamma
+  (:require
+   [clojure.set :as set]
+   [clojure.string :as cs]
+   [cipher-analytical-machine.ciphers.simple-substitution :as ss])
+  (:gen-class))
+
+(defn add-mod
+  [f s module]
+  (-> (+ f s)
+      (mod module)))
+
+(defn generate-seq
+  "Generate a lazy sequence for a key (a b c)."
+  [a b c module]
+  ((fn build-seq [a b c]
+     (lazy-seq (cons a (build-seq b c (add-mod a c module))))) a b c))
+
+(defn generate-gamma-seq
+  "Generate the gamma seq from a sequence."
+  [acc seq module]
+  (if (= (second seq) nil) acc
+    (generate-gamma-seq
+     (conj acc (add-mod (first seq) (second seq) module))
+     (rest seq)
+     module)))
+
+(defn generate-gamma
+  "Generate the gamma from a key (a b c)."
+  [a b c module size]
+  (generate-gamma-seq []
+                      (->> (generate-seq a b c module)
+                           (take (inc size)))
+                      module))
+
+(defn encrypt-array
+  "Encrypt an array using the gamma cipher. The function is case-insensitive. The key is an array of three elements [a b c]. The array contains integer in range [0, module)."
+  [key module array]
+  (let [size (count array)
+        gamma (->> (apply conj [key module size])
+                   (apply generate-gamma))]
+    (->> gamma
+         (map vector array)
+         (map (fn [[a g]] (add-mod a g module))))))
+
+(defn encrypt-message
+  "Encrypt a message using the gamma cipher. The function is case-insensitive. The key is an array of three elements [a b c]. The array contains integer in range [0, module)."
+  [key symbols message]
+  (let [module (count symbols)
+        table (ss/generate-sorted-substitution-table symbols)]
+    (->> message
+         (ss/decrypt-by-table (set/map-invert table))
+         (encrypt-array key module)
+         (ss/decrypt-by-table table)
+         (cs/join))))
+
+(defn decrypt-array
+  "Decrypt an array using the gamma cipher. The function is case-insensitive. The key is an array of three elements [a b c]. The array contains integer in range [0, module)."
+  [key module array]
+  (let [size (count array)
+        gamma (->> (apply conj [key module size])
+                   (apply generate-gamma))]
+    (->> gamma
+         (map -)
+         (map vector array)
+         (map (fn [[a g]] (add-mod a g module))))))
+
+(defn decrypt-message
+  "Decrypt a message using the gamma cipher. The function is case-insensitive. The key is an array of three elements [a b c]. The array contains integer in range [0, module)."
+  [key symbols message]
+  (let [module (count symbols)
+        table (ss/generate-sorted-substitution-table symbols)]
+    (->> message
+         (ss/decrypt-by-table (set/map-invert table))
+         (decrypt-array key module)
+         (ss/decrypt-by-table table)
+         (cs/join))))
+

src/cipher_analytical_machine/ciphers/simple_substitution.clj

@@ -29,11 +29,16 @@
   [char substitution-table]
   (get substitution-table char))
 
+(defn decrypt-by-table
+  "Decrypt a message by the substitution-table"
+  [substitution-table message]
+  (map (fn [char] (find-value-in-table char substitution-table)) message))
+
 (defn encrypt-message
   "Encrypt a message using the simple substitution cipher. The function is case-insensitive. If a symbol isn't in the symbols list, then it will be removed."
   [message substitution-table]
   (->> message
-       (map (fn [char] (find-value-in-table char substitution-table)))
+       (decrypt-by-table substitution-table)
        (remove nil?)
        (cs/join \,)))
 
@@ -44,11 +49,6 @@
       (caesar/encrypt-message key symbols)
       (encrypt-message substitution-table)))
 
-(defn decrypt-by-table
-  "Decrypt a message by the substitution-table"
-  [substitution-table message]
-  (map (fn [char] (find-value-in-table char substitution-table)) message))
-
 (defn decrypt-message-by-symbol-table
   "Decrypt a message using the simple substitution cipher. The function is case-insensitive. The substitution-table must be (symbols, symbols)."
   [substitution-table message]

test/cipher_analytical_machine/ciphers/gamma_test.clj

@@ -0,0 +1,62 @@
+(ns cipher-analytical-machine.ciphers.gamma-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.ciphers.gamma :refer :all]))
+
+(deftest add-mod-test
+  (testing "The remainder must be as expected."
+    (are [a b module expected]
+        (= expected (add-mod a b module))
+      5 2 4 3
+      1 2 3 0
+      2 2 3 1)))
+
+(deftest generate-seq-test
+  (testing "Checking that the next element of a sequence is calculated by (e[i-1] + e[i-3] % mod)."
+    (are [a b c module size expected]
+        (= expected (take size (generate-seq a b c module)))
+      4 32 15 33 10 [4 32 15 19 18 0 19 4 4 23]
+      1 2  3  3  9  [1 2 3 1 0 0 1 1 1])))
+
+(deftest generate-gamma-seq-test
+  (testing "Checking that the next element of a sequence is calculated by (s[i] + s[i+1] % mod)."
+    (are [acc seq module expected]
+        (= expected (generate-gamma-seq acc seq module))
+      [] [4 32 15 19 18 0 19 4 4 23] 33 [3 14 1 4 18 19 23 8 27]
+      [] [1 2 3 1 0 0 1 1 1]         3  [0 2 1 1 0 1 2 2])))
+
+(deftest generate-gamma-test
+  (testing "Checking that the gamma is generated as expected."
+    (are [a b c module size expected]
+        (= expected (generate-gamma a b c module size))
+      4 32 15 33 10 [3 14 1 4 18 19 23 8 27 17]
+      1 2  3  3  9  [0 2 1 1 0 1 2 2 0])))
+
+(deftest encrypt-array-test
+  (testing "Checking that the message is encrypted as expected: (msg+gamma)%module."
+    (are [key module array expected]
+        (= expected (encrypt-array key module array))
+      [4 32 15] 33 [3 14 1 4 18 19 23 8 27 17] [6 28 2 8 3 5 13 16 21 1]
+      [1 2  3 ] 3  [0 2 1 1 0 1 2 2 0]         [0 1 2 2 0 2 1 1 0])))
+
+(deftest encrypt-message-test
+  (testing "Checking that the message is encrypted as expected"
+    (are [key symbols message expected]
+        (= expected (encrypt-message key symbols message))
+      [4 32 15] "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя" "гкбґопужчн" "ешвжгдймсб"
+      [1 2  3 ] "абв"  "авббабвва"  "абввавбба")))
+
+(deftest decrypt-array-test
+  (testing "Checking that the message is decrypted as expected."
+    (are [key module array expected]
+        (= expected (decrypt-array key module array))
+      [4 32 15] 33 [6 28 2 8 3 5 13 16 21 1] [3 14 1 4 18 19 23 8 27 17]
+      [1 2  3 ] 3  [0 1 2 2 0 2 1 1 0]       [0 2 1 1 0 1 2 2 0])))
+
+(deftest decrypt-message-test
+  (testing "Checking that the message is decrypted as expected"
+    (are [key symbols message expected]
+        (= expected (decrypt-message key symbols message))
+      [4 32 15] "абвгґдеєжзиіїйклмнопрстуфхцчшщьюя" "ешвжгдймсб" "гкбґопужчн"
+      [1 2  3 ] "абв" "абввавбба" "авббабвва")))
+