Add a function to get the ordered sequence that can form a key.

project.clj

@@ -7,7 +7,8 @@
                  [org.clojure/tools.cli "1.0.219"]
                  [org.apache.tika/tika-core "1.28.5"]
                  [org.apache.tika/tika-langdetect "1.28.5"]
-                 [cheshire "5.12.0"]]
+                 [cheshire "5.12.0"]
+                 [org.clojure/math.combinatorics "0.2.0"]]
   :main ^:skip-aot cipher-analytical-machine.core
   :java-source-paths ["src/main/java"]
   :target-path "target/%s"

src/cipher_analytical_machine/analyzers/analyzers.clj

@@ -11,6 +11,16 @@
             (inc (get acc val 0))))
    {} text))
 
+(defn reverse-count-characters
+  "Convert a map of pairs to a map where the characters grouped by the count and a count is the key."
+  [count-map]
+  (reduce
+   (fn [acc [symbol count]]
+     (->> (conj (get acc count []) symbol)
+          (into [])
+          (assoc acc count)))
+   {} count-map))
+
 (defn chi-squared-letter-statistic
   "To calculate the frequency distribution of a letter."
   [letter-count letter-frequence length-text]

src/cipher_analytical_machine/analyzers/simple_substitution.clj

@@ -0,0 +1,31 @@
+(ns cipher-analytical-machine.analyzers.simple-substitution
+  (:require [clojure.string :as cs]
+            [clojure.math.combinatorics :as comb]
+            [cipher-analytical-machine.ciphers.simple-substitution :as ss]
+            [cipher-analytical-machine.analyzers.analyzers :as analyzers]
+            [cipher-analytical-machine.analyzers.caesar :as caesar])
+  (:gen-class))
+
+(defn get-possible-key-vector
+  "Convert a possible key map to a vector of possible keys. For example, if you have a map: {\\a [\\a \\b \\c] \\b [\\b \\c] \\c [\\a \\c]}, then the vector is [[\\a \\b \\c] [\\b \\c] [\\a \\c]]."
+  [possible-key-map symbols]
+  (reduce
+   (fn [acc el]
+     (conj acc (get possible-key-map el)))
+   [] symbols))
+
+(defn get-possible-key-vector-from-reversed-count-map
+  "Convert a reversed count map to a vector. Example, from {2 [\\a \\b] 1 [\\d] 3 [\\e]} to [[\\e] [\\a \\b] [\\d]])."
+  [reversed-count-map]
+  (->>  reversed-count-map
+        (into [])
+        (sort-by #(- (first %)))
+        (map second)
+        (into [])))
+
+(defn get-possible-keys
+  "Return possible keys for a possible key vector. For example, if you have a map: {\\a [\\a \\b \\c] \\b [\\b \\c] \\c [\\a \\c]}, then the vector is [[\\a \\b \\c] [\\b \\c] [\\a \\c]] and keys (\"aba\" \"abc\" ...)."
+  [possible-key-vector]
+  (->> (apply comb/cartesian-product possible-key-vector)
+       (map cs/join)))
+

src/cipher_analytical_machine/cli/actions/cracking.clj

@@ -9,7 +9,8 @@
   (let [analyzer (:analyzer options)
         message (:message options)
         symbols (:symbols options)
-        frequencies symbol-frequencies/english-letter-frequencies]
+        frequencies (-> (get options :language "en")
+                        (symbol-frequencies/default-frequency-factory))]
     (cond
       (= analyzer "Chi^2")
       (caesar-analyzers/get-plaintext message symbols frequencies)

src/cipher_analytical_machine/symbols/frequencies.clj

@@ -77,3 +77,16 @@
    \  0.138
 })
 
+(defn default-frequency-factory
+  "Returns a default map of letter frequencies for a language"
+  [language-code]
+  (cond
+    (= language-code "en")
+    english-letter-frequencies
+
+    (= language-code "uk")
+    ukrainian-letter-frequencies
+
+    :else
+    english-letter-frequencies))
+

test/cipher_analytical_machine/analyzers/analyzers_test.clj

@@ -8,6 +8,13 @@
     (is (= {\a 2 \b 1}
            (count-characters "aba")))))
 
+(deftest reverse-count-characters-test
+  (testing "The symbols must be grouped as a vector and the count must be a key."
+    (are [count-map expected-map]
+        (= expected-map (reverse-count-characters count-map))
+      {\a 1 \b 2 \c 1} {1 [\a \c] 2 [\b]}
+      {\a 1 \b 2 \c 3} {1 [\a] 2 [\b] 3 [\c]})))
+
 (deftest chi-squared-letter-statistic-test
   (testing "If the frequence of A is 0.1, the text length is 100 and contains 20 times, then the chi-squared is 10."
     (is (= 10.0

test/cipher_analytical_machine/analyzers/simple_substitution_test.clj

@@ -0,0 +1,30 @@
+(ns cipher-analytical-machine.analyzers.simple-substitution-test
+  (:require
+   [clojure.test :refer :all]
+   [cipher-analytical-machine.symbols.frequencies :as sf]
+   [cipher-analytical-machine.ciphers.simple-substitution :as ss]
+   [cipher-analytical-machine.analyzers.simple-substitution :refer :all])
+  (:gen-class))
+
+(deftest get-possible-keys-vector-test
+  (testing "The vector must be ordered by symbols"
+    (are [possible-keys-map symbols expected-key-vector]
+        (= expected-key-vector (get-possible-key-vector possible-keys-map symbols))
+      {\a [\a \b] \b [\b \a] \c [\a \c]} "abc" [[\a \b] [\b \a] [\a \c]]
+      {\a [\a \b] \c [\b \a] \b [\a \c]} "abc" [[\a \b] [\a \c] [\b \a]])))
+
+(deftest get-possible-key-vector-from-reversed-count-map-test
+  (testing ""
+    (are [reversed-count-map expected-key-vector]
+        (= expected-key-vector (get-possible-key-vector-from-reversed-count-map reversed-count-map))
+      {1 [\a \c] 2 [\b]}     [[\b] [\a \c]]
+      {2 [\a] 1 [\b] 3 [\c]} [[\c] [\a] [\b]])))
+
+(deftest get-possible-keys-test
+  (testing "The keys must be the all combinations"
+    (are [possible-keys-vector expected-keys]
+        (= expected-keys (get-possible-keys possible-keys-vector))
+      [[\a \b] [\f] [\a \c] [\g]] '("afag" "afcg" "bfag" "bfcg")
+      [[\a \b] [\a \c]] '("aa" "ac" "ba" "bc")
+      [[\a \b \c] [\a \c] [\b \c]] '("aab" "aac" "acb" "acc" "bab" "bac" "bcb" "bcc" "cab" "cac" "ccb" "ccc"))))
+

test/cipher_analytical_machine/symbols/frequencies_test.clj

@@ -9,3 +9,13 @@
       (is (= "etaoinsrhldcumfpgwybvkxjqz"
              (map-to-string symbol-map))))))
 
+(deftest default-frequency-factory-test
+  (testing "Factory supports languages: English (en), Ukrainian (uk). If language code is unidentified, then it must have the 'en'."
+    (are [language-code expected-map-size]
+        (->> (default-frequency-factory language-code)
+             count
+             (= expected-map-size))
+      "en"           26
+      "uk"           34
+      "Maybe a code" 26)))
+