snipt

Ctrl+h for KB shortcuts

Clojure

Caesar Cipher (ROT13) in Clojure 1.1

(set! *warn-on-reflection* true)

(ns caesar-cipher
 (:require (clojure.contrib [str-utils2 :as s]))
 (:use clojure.contrib.test-is))

;; forward declaring just so I can order the functions how I want...
(declare
  rot13
  rot-msg
  rot-letter
  in-range?
  rot-char)

(defn rot13 "rot13 implementation"
  [msg] (rot-msg msg 13))

(defn rot-msg
  "Cipher a message via caesarian rotation.
   Accepts only uppercase ascii and spaces.
     message - String to be encoded.
     i - factor by which to encode the message."
  [message i]
  (s/map-str #(rot-letter % i) message))

(defn rot-letter
  "applies caesar cipher to a single character. Only ciphers
   ascii a-z and A-Z, leaving other characters unchanged.
   c - a single ascii character.
   i - the factor by which to rotate the character."
  [c i] {:pre [(char? c) (number? i)]}
  (cond
    (in-range? c \A \Z) (rot-char c i \A \Z)
    (in-range? c \a \z) (rot-char c i \a \z)
    :else c))

(defn in-range? [^Character c start end]
  (if (or (.equals c start) (.equals c end))
    true
    (let [compared-to-start (compare c start)
          compared-to-end (compare c end)]
      (or (= 0 compared-to-start)
          (= 0 compared-to-end)
          (and (pos? compared-to-start) (neg? compared-to-end))))))

;; This is a slightly different solution than the one found around the internets,
;; because it doesn't attempt to map the original message to 0-base character lookup table.
;; Instead we just need to be provided with the start and end range (i.e. in a
;; typical cipher of the roman alphabet, the range is 0...25, but here  our range is based
; on the ASCII table). We then shift the character, and wrap around if we overflow the end boundary.
(defn rot-char
  [c i start end]
  (let [shift (mod i 26)
        shifted-char-as-int (+ (int c) shift)
        shifted-char (char shifted-char-as-int)]
    (if (in-range? shifted-char start end)
      shifted-char
      (let [start-minus-1 (- (int start) 1)
            overflow (- shifted-char-as-int (int end))]
        (char (+ start-minus-1 overflow))))))



;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Unit tests

(deftest test-rot13
  (testing "rot13 must be reciprocal"
    (are (= _str (rot13 (rot13 _str)))
      "A MesSage"
      "Another message!"
      "Some goofy characters \\@#!^&*(_"
      "Numb3r5 and 13tt3r5")))

(deftest test-rot-1
  (testing "expected rot-1 functionality"
    (are (= _2 (rot-msg _1 1))
      "A" "B"
      "A1" "B1"
      "Aa" "Bb"
      "Zz" "Aa"
      "A1&*(" "B1&*(")))

(deftest test-rot-100
  (testing "rotating some messages 100 characters"
    (is (= "XHWDxhwd 100" (rot-msg "BLAHblah 100" 100)))))

(run-tests)

;; Example manual REPL unit testing output:
;;     user=> (in-ns 'caesar-cipher)
;;     #<Namespace caesar-cipher>
;;     caesar-cipher=> (run-tests)
;;
;;     Testing caesar-cipher
;;
;;     Ran 3 tests containing 10 assertions.
;;     0 failures, 0 errors.
;;     {:type :summary, :test 3, :pass 10, :fail 0, :error 0}
;;     caesar-cipher=>


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Just for fun...

(defn do-all-rotations [msg]
  (loop [i 0]
      (if (= i 26)
        (println "done")
        (do
          (println (rot-msg msg i))
          (recur (inc i))))))

(defn rotate-alphabet []
  (let [uppercase-alphabet "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
        lowercase-alphabet "abcdefghijklmnopqrstuvwxyz"]
    (do
      (do-all-rotations uppercase-alphabet)
      (do-all-rotations lowercase-alphabet))))
https://snipt.net/embed/7745e30bdaa389d2ffc0cfe20eda7173/
/raw/7745e30bdaa389d2ffc0cfe20eda7173/
7745e30bdaa389d2ffc0cfe20eda7173
clojure
Clojure
120
2019-08-18T21:13:03
True
False
False
/api/public/snipt/19802/
caesar-cipher-rot13-in-clojure-11
<table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre><a href="#L-1"> 1</a> <a href="#L-2"> 2</a> <a href="#L-3"> 3</a> <a href="#L-4"> 4</a> <a href="#L-5"> 5</a> <a href="#L-6"> 6</a> <a href="#L-7"> 7</a> <a href="#L-8"> 8</a> <a href="#L-9"> 9</a> <a href="#L-10"> 10</a> <a href="#L-11"> 11</a> <a href="#L-12"> 12</a> <a href="#L-13"> 13</a> <a href="#L-14"> 14</a> <a href="#L-15"> 15</a> <a href="#L-16"> 16</a> <a href="#L-17"> 17</a> <a href="#L-18"> 18</a> <a href="#L-19"> 19</a> <a href="#L-20"> 20</a> <a href="#L-21"> 21</a> <a href="#L-22"> 22</a> <a href="#L-23"> 23</a> <a href="#L-24"> 24</a> <a href="#L-25"> 25</a> <a href="#L-26"> 26</a> <a href="#L-27"> 27</a> <a href="#L-28"> 28</a> <a href="#L-29"> 29</a> <a href="#L-30"> 30</a> <a href="#L-31"> 31</a> <a href="#L-32"> 32</a> <a href="#L-33"> 33</a> <a href="#L-34"> 34</a> <a href="#L-35"> 35</a> <a href="#L-36"> 36</a> <a href="#L-37"> 37</a> <a href="#L-38"> 38</a> <a href="#L-39"> 39</a> <a href="#L-40"> 40</a> <a href="#L-41"> 41</a> <a href="#L-42"> 42</a> <a href="#L-43"> 43</a> <a href="#L-44"> 44</a> <a href="#L-45"> 45</a> <a href="#L-46"> 46</a> <a href="#L-47"> 47</a> <a href="#L-48"> 48</a> <a href="#L-49"> 49</a> <a href="#L-50"> 50</a> <a href="#L-51"> 51</a> <a href="#L-52"> 52</a> <a href="#L-53"> 53</a> <a href="#L-54"> 54</a> <a href="#L-55"> 55</a> <a href="#L-56"> 56</a> <a href="#L-57"> 57</a> <a href="#L-58"> 58</a> <a href="#L-59"> 59</a> <a href="#L-60"> 60</a> <a href="#L-61"> 61</a> <a href="#L-62"> 62</a> <a href="#L-63"> 63</a> <a href="#L-64"> 64</a> <a href="#L-65"> 65</a> <a href="#L-66"> 66</a> <a href="#L-67"> 67</a> <a href="#L-68"> 68</a> <a href="#L-69"> 69</a> <a href="#L-70"> 70</a> <a href="#L-71"> 71</a> <a href="#L-72"> 72</a> <a href="#L-73"> 73</a> <a href="#L-74"> 74</a> <a href="#L-75"> 75</a> <a href="#L-76"> 76</a> <a href="#L-77"> 77</a> <a href="#L-78"> 78</a> <a href="#L-79"> 79</a> <a href="#L-80"> 80</a> <a href="#L-81"> 81</a> <a href="#L-82"> 82</a> <a href="#L-83"> 83</a> <a href="#L-84"> 84</a> <a href="#L-85"> 85</a> <a href="#L-86"> 86</a> <a href="#L-87"> 87</a> <a href="#L-88"> 88</a> <a href="#L-89"> 89</a> <a href="#L-90"> 90</a> <a href="#L-91"> 91</a> <a href="#L-92"> 92</a> <a href="#L-93"> 93</a> <a href="#L-94"> 94</a> <a href="#L-95"> 95</a> <a href="#L-96"> 96</a> <a href="#L-97"> 97</a> <a href="#L-98"> 98</a> <a href="#L-99"> 99</a> <a href="#L-100">100</a> <a href="#L-101">101</a> <a href="#L-102">102</a> <a href="#L-103">103</a> <a href="#L-104">104</a> <a href="#L-105">105</a> <a href="#L-106">106</a> <a href="#L-107">107</a> <a href="#L-108">108</a> <a href="#L-109">109</a> <a href="#L-110">110</a> <a href="#L-111">111</a> <a href="#L-112">112</a> <a href="#L-113">113</a> <a href="#L-114">114</a> <a href="#L-115">115</a> <a href="#L-116">116</a> <a href="#L-117">117</a> <a href="#L-118">118</a> <a href="#L-119">119</a></pre></div></td><td class="code"><div class="highlight"><pre><span></span><span id="L-1"><a name="L-1"></a><span class="p">(</span><span class="nf">set!</span> <span class="nv">*warn-on-reflection*</span> <span class="nv">true</span><span class="p">)</span> </span><span id="L-2"><a name="L-2"></a> </span><span id="L-3"><a name="L-3"></a><span class="p">(</span><span class="kd">ns </span><span class="nv">caesar-cipher</span> </span><span id="L-4"><a name="L-4"></a> <span class="p">(</span><span class="ss">:require</span> <span class="p">(</span><span class="nf">clojure.contrib</span> <span class="p">[</span><span class="nv">str-utils2</span> <span class="ss">:as</span> <span class="nv">s</span><span class="p">]))</span> </span><span id="L-5"><a name="L-5"></a> <span class="p">(</span><span class="ss">:use</span> <span class="nv">clojure.contrib.test-is</span><span class="p">))</span> </span><span id="L-6"><a name="L-6"></a> </span><span id="L-7"><a name="L-7"></a><span class="c1">;; forward declaring just so I can order the functions how I want...</span> </span><span id="L-8"><a name="L-8"></a><span class="p">(</span><span class="nf">declare</span> </span><span id="L-9"><a name="L-9"></a> <span class="nv">rot13</span> </span><span id="L-10"><a name="L-10"></a> <span class="nv">rot-msg</span> </span><span id="L-11"><a name="L-11"></a> <span class="nv">rot-letter</span> </span><span id="L-12"><a name="L-12"></a> <span class="nv">in-range?</span> </span><span id="L-13"><a name="L-13"></a> <span class="nv">rot-char</span><span class="p">)</span> </span><span id="L-14"><a name="L-14"></a> </span><span id="L-15"><a name="L-15"></a><span class="p">(</span><span class="kd">defn </span><span class="nv">rot13</span> <span class="s">&quot;rot13 implementation&quot;</span> </span><span id="L-16"><a name="L-16"></a> <span class="p">[</span><span class="nv">msg</span><span class="p">]</span> <span class="p">(</span><span class="nf">rot-msg</span> <span class="nv">msg</span> <span class="mi">13</span><span class="p">))</span> </span><span id="L-17"><a name="L-17"></a> </span><span id="L-18"><a name="L-18"></a><span class="p">(</span><span class="kd">defn </span><span class="nv">rot-msg</span> </span><span id="L-19"><a name="L-19"></a> <span class="s">&quot;Cipher a message via caesarian rotation.</span> </span><span id="L-20"><a name="L-20"></a><span class="s"> Accepts only uppercase ascii and spaces.</span> </span><span id="L-21"><a name="L-21"></a><span class="s"> message - String to be encoded.</span> </span><span id="L-22"><a name="L-22"></a><span class="s"> i - factor by which to encode the message.&quot;</span> </span><span id="L-23"><a name="L-23"></a> <span class="p">[</span><span class="nv">message</span> <span class="nv">i</span><span class="p">]</span> </span><span id="L-24"><a name="L-24"></a> <span class="p">(</span><span class="nf">s/map-str</span> <span class="o">#</span><span class="p">(</span><span class="nf">rot-letter</span> <span class="nv">%</span> <span class="nv">i</span><span class="p">)</span> <span class="nv">message</span><span class="p">))</span> </span><span id="L-25"><a name="L-25"></a> </span><span id="L-26"><a name="L-26"></a><span class="p">(</span><span class="kd">defn </span><span class="nv">rot-letter</span> </span><span id="L-27"><a name="L-27"></a> <span class="s">&quot;applies caesar cipher to a single character. Only ciphers</span> </span><span id="L-28"><a name="L-28"></a><span class="s"> ascii a-z and A-Z, leaving other characters unchanged.</span> </span><span id="L-29"><a name="L-29"></a><span class="s"> c - a single ascii character.</span> </span><span id="L-30"><a name="L-30"></a><span class="s"> i - the factor by which to rotate the character.&quot;</span> </span><span id="L-31"><a name="L-31"></a> <span class="p">[</span><span class="nv">c</span> <span class="nv">i</span><span class="p">]</span> <span class="p">{</span><span class="ss">:pre</span> <span class="p">[(</span><span class="nf">char?</span> <span class="nv">c</span><span class="p">)</span> <span class="p">(</span><span class="nf">number?</span> <span class="nv">i</span><span class="p">)]}</span> </span><span id="L-32"><a name="L-32"></a> <span class="p">(</span><span class="nf">cond</span> </span><span id="L-33"><a name="L-33"></a> <span class="p">(</span><span class="nf">in-range?</span> <span class="nv">c</span> <span class="sc">\A</span> <span class="sc">\Z</span><span class="p">)</span> <span class="p">(</span><span class="nf">rot-char</span> <span class="nv">c</span> <span class="nv">i</span> <span class="sc">\A</span> <span class="sc">\Z</span><span class="p">)</span> </span><span id="L-34"><a name="L-34"></a> <span class="p">(</span><span class="nf">in-range?</span> <span class="nv">c</span> <span class="sc">\a</span> <span class="sc">\z</span><span class="p">)</span> <span class="p">(</span><span class="nf">rot-char</span> <span class="nv">c</span> <span class="nv">i</span> <span class="sc">\a</span> <span class="sc">\z</span><span class="p">)</span> </span><span id="L-35"><a name="L-35"></a> <span class="ss">:else</span> <span class="nv">c</span><span class="p">))</span> </span><span id="L-36"><a name="L-36"></a> </span><span id="L-37"><a name="L-37"></a><span class="p">(</span><span class="kd">defn </span><span class="nv">in-range?</span> <span class="p">[</span><span class="o">^</span><span class="nv">Character</span> <span class="nv">c</span> <span class="nv">start</span> <span class="nv">end</span><span class="p">]</span> </span><span id="L-38"><a name="L-38"></a> <span class="p">(</span><span class="k">if </span><span class="p">(</span><span class="nb">or </span><span class="p">(</span><span class="nf">.equals</span> <span class="nv">c</span> <span class="nv">start</span><span class="p">)</span> <span class="p">(</span><span class="nf">.equals</span> <span class="nv">c</span> <span class="nv">end</span><span class="p">))</span> </span><span id="L-39"><a name="L-39"></a> <span class="nv">true</span> </span><span id="L-40"><a name="L-40"></a> <span class="p">(</span><span class="k">let </span><span class="p">[</span><span class="nv">compared-to-start</span> <span class="p">(</span><span class="nf">compare</span> <span class="nv">c</span> <span class="nv">start</span><span class="p">)</span> </span><span id="L-41"><a name="L-41"></a> <span class="nv">compared-to-end</span> <span class="p">(</span><span class="nf">compare</span> <span class="nv">c</span> <span class="nv">end</span><span class="p">)]</span> </span><span id="L-42"><a name="L-42"></a> <span class="p">(</span><span class="nb">or </span><span class="p">(</span><span class="nb">= </span><span class="mi">0</span> <span class="nv">compared-to-start</span><span class="p">)</span> </span><span id="L-43"><a name="L-43"></a> <span class="p">(</span><span class="nb">= </span><span class="mi">0</span> <span class="nv">compared-to-end</span><span class="p">)</span> </span><span id="L-44"><a name="L-44"></a> <span class="p">(</span><span class="nb">and </span><span class="p">(</span><span class="nb">pos? </span><span class="nv">compared-to-start</span><span class="p">)</span> <span class="p">(</span><span class="nb">neg? </span><span class="nv">compared-to-end</span><span class="p">))))))</span> </span><span id="L-45"><a name="L-45"></a> </span><span id="L-46"><a name="L-46"></a><span class="c1">;; This is a slightly different solution than the one found around the internets,</span> </span><span id="L-47"><a name="L-47"></a><span class="c1">;; because it doesn&#39;t attempt to map the original message to 0-base character lookup table.</span> </span><span id="L-48"><a name="L-48"></a><span class="c1">;; Instead we just need to be provided with the start and end range (i.e. in a</span> </span><span id="L-49"><a name="L-49"></a><span class="c1">;; typical cipher of the roman alphabet, the range is 0...25, but here our range is based</span> </span><span id="L-50"><a name="L-50"></a><span class="c1">; on the ASCII table). We then shift the character, and wrap around if we overflow the end boundary.</span> </span><span id="L-51"><a name="L-51"></a><span class="p">(</span><span class="kd">defn </span><span class="nv">rot-char</span> </span><span id="L-52"><a name="L-52"></a> <span class="p">[</span><span class="nv">c</span> <span class="nv">i</span> <span class="nv">start</span> <span class="nv">end</span><span class="p">]</span> </span><span id="L-53"><a name="L-53"></a> <span class="p">(</span><span class="k">let </span><span class="p">[</span><span class="nv">shift</span> <span class="p">(</span><span class="nf">mod</span> <span class="nv">i</span> <span class="mi">26</span><span class="p">)</span> </span><span id="L-54"><a name="L-54"></a> <span class="nv">shifted-char-as-int</span> <span class="p">(</span><span class="nb">+ </span><span class="p">(</span><span class="nb">int </span><span class="nv">c</span><span class="p">)</span> <span class="nv">shift</span><span class="p">)</span> </span><span id="L-55"><a name="L-55"></a> <span class="nv">shifted-char</span> <span class="p">(</span><span class="nb">char </span><span class="nv">shifted-char-as-int</span><span class="p">)]</span> </span><span id="L-56"><a name="L-56"></a> <span class="p">(</span><span class="k">if </span><span class="p">(</span><span class="nf">in-range?</span> <span class="nv">shifted-char</span> <span class="nv">start</span> <span class="nv">end</span><span class="p">)</span> </span><span id="L-57"><a name="L-57"></a> <span class="nv">shifted-char</span> </span><span id="L-58"><a name="L-58"></a> <span class="p">(</span><span class="k">let </span><span class="p">[</span><span class="nv">start-minus-1</span> <span class="p">(</span><span class="nb">- </span><span class="p">(</span><span class="nb">int </span><span class="nv">start</span><span class="p">)</span> <span class="mi">1</span><span class="p">)</span> </span><span id="L-59"><a name="L-59"></a> <span class="nv">overflow</span> <span class="p">(</span><span class="nb">- </span><span class="nv">shifted-char-as-int</span> <span class="p">(</span><span class="nb">int </span><span class="nv">end</span><span class="p">))]</span> </span><span id="L-60"><a name="L-60"></a> <span class="p">(</span><span class="nb">char </span><span class="p">(</span><span class="nb">+ </span><span class="nv">start-minus-1</span> <span class="nv">overflow</span><span class="p">))))))</span> </span><span id="L-61"><a name="L-61"></a> </span><span id="L-62"><a name="L-62"></a> </span><span id="L-63"><a name="L-63"></a> </span><span id="L-64"><a name="L-64"></a><span class="c1">;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;</span> </span><span id="L-65"><a name="L-65"></a><span class="c1">;; Unit tests</span> </span><span id="L-66"><a name="L-66"></a> </span><span id="L-67"><a name="L-67"></a><span class="p">(</span><span class="nf">deftest</span> <span class="nv">test-rot13</span> </span><span id="L-68"><a name="L-68"></a> <span class="p">(</span><span class="nf">testing</span> <span class="s">&quot;rot13 must be reciprocal&quot;</span> </span><span id="L-69"><a name="L-69"></a> <span class="p">(</span><span class="nf">are</span> <span class="p">(</span><span class="nb">= </span><span class="nv">_str</span> <span class="p">(</span><span class="nf">rot13</span> <span class="p">(</span><span class="nf">rot13</span> <span class="nv">_str</span><span class="p">)))</span> </span><span id="L-70"><a name="L-70"></a> <span class="s">&quot;A MesSage&quot;</span> </span><span id="L-71"><a name="L-71"></a> <span class="s">&quot;Another message!&quot;</span> </span><span id="L-72"><a name="L-72"></a> <span class="s">&quot;Some goofy characters \\@#!^&amp;*(_&quot;</span> </span><span id="L-73"><a name="L-73"></a> <span class="s">&quot;Numb3r5 and 13tt3r5&quot;</span><span class="p">)))</span> </span><span id="L-74"><a name="L-74"></a> </span><span id="L-75"><a name="L-75"></a><span class="p">(</span><span class="nf">deftest</span> <span class="nv">test-rot-1</span> </span><span id="L-76"><a name="L-76"></a> <span class="p">(</span><span class="nf">testing</span> <span class="s">&quot;expected rot-1 functionality&quot;</span> </span><span id="L-77"><a name="L-77"></a> <span class="p">(</span><span class="nf">are</span> <span class="p">(</span><span class="nb">= </span><span class="nv">_2</span> <span class="p">(</span><span class="nf">rot-msg</span> <span class="nv">_1</span> <span class="mi">1</span><span class="p">))</span> </span><span id="L-78"><a name="L-78"></a> <span class="s">&quot;A&quot;</span> <span class="s">&quot;B&quot;</span> </span><span id="L-79"><a name="L-79"></a> <span class="s">&quot;A1&quot;</span> <span class="s">&quot;B1&quot;</span> </span><span id="L-80"><a name="L-80"></a> <span class="s">&quot;Aa&quot;</span> <span class="s">&quot;Bb&quot;</span> </span><span id="L-81"><a name="L-81"></a> <span class="s">&quot;Zz&quot;</span> <span class="s">&quot;Aa&quot;</span> </span><span id="L-82"><a name="L-82"></a> <span class="s">&quot;A1&amp;*(&quot;</span> <span class="s">&quot;B1&amp;*(&quot;</span><span class="p">)))</span> </span><span id="L-83"><a name="L-83"></a> </span><span id="L-84"><a name="L-84"></a><span class="p">(</span><span class="nf">deftest</span> <span class="nv">test-rot-100</span> </span><span id="L-85"><a name="L-85"></a> <span class="p">(</span><span class="nf">testing</span> <span class="s">&quot;rotating some messages 100 characters&quot;</span> </span><span id="L-86"><a name="L-86"></a> <span class="p">(</span><span class="nf">is</span> <span class="p">(</span><span class="nb">= </span><span class="s">&quot;XHWDxhwd 100&quot;</span> <span class="p">(</span><span class="nf">rot-msg</span> <span class="s">&quot;BLAHblah 100&quot;</span> <span class="mi">100</span><span class="p">)))))</span> </span><span id="L-87"><a name="L-87"></a> </span><span id="L-88"><a name="L-88"></a><span class="p">(</span><span class="nf">run-tests</span><span class="p">)</span> </span><span id="L-89"><a name="L-89"></a> </span><span id="L-90"><a name="L-90"></a><span class="c1">;; Example manual REPL unit testing output:</span> </span><span id="L-91"><a name="L-91"></a><span class="c1">;; user=&gt; (in-ns &#39;caesar-cipher)</span> </span><span id="L-92"><a name="L-92"></a><span class="c1">;; #&lt;Namespace caesar-cipher&gt;</span> </span><span id="L-93"><a name="L-93"></a><span class="c1">;; caesar-cipher=&gt; (run-tests)</span> </span><span id="L-94"><a name="L-94"></a><span class="c1">;;</span> </span><span id="L-95"><a name="L-95"></a><span class="c1">;; Testing caesar-cipher</span> </span><span id="L-96"><a name="L-96"></a><span class="c1">;;</span> </span><span id="L-97"><a name="L-97"></a><span class="c1">;; Ran 3 tests containing 10 assertions.</span> </span><span id="L-98"><a name="L-98"></a><span class="c1">;; 0 failures, 0 errors.</span> </span><span id="L-99"><a name="L-99"></a><span class="c1">;; {:type :summary, :test 3, :pass 10, :fail 0, :error 0}</span> </span><span id="L-100"><a name="L-100"></a><span class="c1">;; caesar-cipher=&gt;</span> </span><span id="L-101"><a name="L-101"></a> </span><span id="L-102"><a name="L-102"></a> </span><span id="L-103"><a name="L-103"></a><span class="c1">;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;</span> </span><span id="L-104"><a name="L-104"></a><span class="c1">;; Just for fun...</span> </span><span id="L-105"><a name="L-105"></a> </span><span id="L-106"><a name="L-106"></a><span class="p">(</span><span class="kd">defn </span><span class="nv">do-all-rotations</span> <span class="p">[</span><span class="nv">msg</span><span class="p">]</span> </span><span id="L-107"><a name="L-107"></a> <span class="p">(</span><span class="k">loop </span><span class="p">[</span><span class="nv">i</span> <span class="mi">0</span><span class="p">]</span> </span><span id="L-108"><a name="L-108"></a> <span class="p">(</span><span class="k">if </span><span class="p">(</span><span class="nb">= </span><span class="nv">i</span> <span class="mi">26</span><span class="p">)</span> </span><span id="L-109"><a name="L-109"></a> <span class="p">(</span><span class="nb">println </span><span class="s">&quot;done&quot;</span><span class="p">)</span> </span><span id="L-110"><a name="L-110"></a> <span class="p">(</span><span class="nf">do</span> </span><span id="L-111"><a name="L-111"></a> <span class="p">(</span><span class="nb">println </span><span class="p">(</span><span class="nf">rot-msg</span> <span class="nv">msg</span> <span class="nv">i</span><span class="p">))</span> </span><span id="L-112"><a name="L-112"></a> <span class="p">(</span><span class="nf">recur</span> <span class="p">(</span><span class="nb">inc </span><span class="nv">i</span><span class="p">))))))</span> </span><span id="L-113"><a name="L-113"></a> </span><span id="L-114"><a name="L-114"></a><span class="p">(</span><span class="kd">defn </span><span class="nv">rotate-alphabet</span> <span class="p">[]</span> </span><span id="L-115"><a name="L-115"></a> <span class="p">(</span><span class="k">let </span><span class="p">[</span><span class="nv">uppercase-alphabet</span> <span class="s">&quot;ABCDEFGHIJKLMNOPQRSTUVWXYZ&quot;</span> </span><span id="L-116"><a name="L-116"></a> <span class="nv">lowercase-alphabet</span> <span class="s">&quot;abcdefghijklmnopqrstuvwxyz&quot;</span><span class="p">]</span> </span><span id="L-117"><a name="L-117"></a> <span class="p">(</span><span class="nf">do</span> </span><span id="L-118"><a name="L-118"></a> <span class="p">(</span><span class="nf">do-all-rotations</span> <span class="nv">uppercase-alphabet</span><span class="p">)</span> </span><span id="L-119"><a name="L-119"></a> <span class="p">(</span><span class="nf">do-all-rotations</span> <span class="nv">lowercase-alphabet</span><span class="p">))))</span> </span></pre></div> </td></tr></table>
clojure, rot13