Alien Numbers in Clojure

;;; -*- mode: Clojure; coding: utf-8 -*-
;;; Solution by Luis Sergio Oliveira for the Alien Numbers exercise from
;;; Programming Praxis
;;; See http://programmingpraxis.com/2010/09/24/alien-numbers/

;;; Run from the shell as so:
;;; ~/programacao/programmingpraxis$ ../clojure/clj-dev.sh alien-numbers.clj <<-END
;;; > 2
;;; > abc abcd 0123456789
;;; > ([}} {([}? 0123456
;;; > END
;;;
;;; Or execute its tests like so:
;;; (clojure.test/run-tests 'euluis.aliennum)

(ns euluis.aliennum
  (:use [clojure.test :only [is are testing deftest]]))

^L
;;; Conversion given strings alien-num source-lang target-lang.
;;; See convert-num fn which is the entry point.

(defn decimal-to-lang
  "Converts decimal-num to the equivalent number in lang as a string.
  The algorithm was a translation of the algorithm by Rodrigo Menezes
  in C# that he posted in the programming praxis site."
  [decimal-num lang]
  (let [lang-radix (count lang)]
    (loop [decimal-value decimal-num lang-num []]
      (if (>= 0 decimal-value)
        (apply str lang-num)
        (recur (int (/ decimal-value lang-radix))
               (concat [(nth lang (mod decimal-value lang-radix))] lang-num))))))

(deftest decimal-to-lang-test
  (testing "that given a decimal-num and a target lang, decimal-to-lang fn
converts it correctly to expected-num"
    (are [expected-num decimal-num lang]
         (= expected-num (decimal-to-lang decimal-num lang))
         "1100120" 987 "012"
         "33123" 987 "0123"
         "3" 3 "0123456789")))

(defn digit-index
  [digit lang]
  (loop [i 0]
    (if (= digit (nth lang i))
      i
      (recur (inc i)))))

(defn lang-to-decimal
  [alien-num lang]
  (let [radix (count lang)
        ralien-num (reverse alien-num)]
    (loop [i 0 decimal-num 0 product 1]
      (if (= i (count ralien-num))
        decimal-num
        (recur (inc i) (+ decimal-num (* (digit-index (nth ralien-num i) lang) product))
               (* radix product))))))

(deftest lang-to-decimal-test
  (testing "that given an alien-num and a lang we can transform it to a decimal number"
    (are [expected-num alien-num lang]
         (= expected-num (lang-to-decimal alien-num lang))
         987 "1100120" "012"
         987 "33123" "0123"
         3 "11" "01")))

(defn convert-num
  "Convert alien-num which is in source-lang into the same number in target-lang"
  [alien-num source-lang target-lang]
  (decimal-to-lang (lang-to-decimal alien-num source-lang) target-lang))

(deftest convert-num-tests
  (testing "convert-num tests based on 2 to 36 radix numerals"
    (are [expected-num alien-num source-lang target-lang]
         (= expected-num
            (convert-num alien-num source-lang target-lang))
         ;; test: 987 0123456789 012 -> should be 1100120
         "1100120"
         "987" "0123456789" "012"
         "987"
         "1100120" "012" "0123456789"
         "33123"
         "987" "0123456789" "0123"
         "//-*/"
         "987" "0123456789" "+-*/"
         "RF"
         "987" "0123456789" "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
         "35"
         "Z" "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789"
         "cj"
         "\"!" "!\"#$%&'()*+,-./:;?@[\\]^_`{|}~" "abcdefghij"
         "3"
         "11" "01" "0123456789")))

^L
;;; Process the I/O
;;; N
;;; "<alien number>" "<sl0>..<slN>" "<tl0>..<tlM>"

;; production code to retrieve the lines containing the numbers to convert
(defn my-read-line
  ([] (read-line))
  ([stream]
     (binding [*in* stream]
       (read-line))))

(defn get-lines
  "Processes stream, returning a seq of lines in the order they are given
   and each line is guaranteed to be a string."
  [stream]
  (let [lines-number (Integer. (my-read-line stream))
        lines (loop [n lines-number lines '()]
                (if (>= 0 n)
                  lines
                  (recur (dec n) (conj lines (my-read-line stream)))))]
    ;; what should be the behavior when we inconsistent number and lines?
    ;; I'll go for beneficent behavior...
    (reverse (filter #(not (nil? %)) lines))))

;; test code to retrieve the lines containing the numbers to convert
(defn stream-str
  "Returns an open BufferedReader from str."
  [str]
  (java.io.BufferedReader. (java.io.StringReader. str)))

(defn get-lines-str
  "Given str, creates and opens a stream from this and hands over to get-lines."
  [str]
  (with-open [s (stream-str str)]
    (get-lines s)))

(deftest get-lines-tests
  (testing "get-lines for happy path test cases"
    (are [expected-lines in-str]
         (= expected-lines (get-lines-str in-str))
         ["123 abc" "4 5 7"] "2\n123 abc\n4 5 7\n"
         ;; No \\n in the end, but, get-lines has benevolent behavior.
         ["1" "2" "3"] "3\n1\n2\n3"
         ;; Although the specified number of lines is larger than the actual
         ;; lines, get-lines has benevolent behavior.
         ["1" "2" "3"] "4\n1\n2\n3"
         [] "0"
         [] "-1\n33\n44"))
  (testing "get-lines for exceptional cases"
    (is (thrown? NullPointerException (get-lines nil)))
    (are [str]
         (thrown? NumberFormatException (get-lines-str str))
         "ab1\n line 1"
         "1 not valid\n1")))

^L
;; transform each line to convert, validating it and making it amiable for conversion

;; 0-9a-zA-Z!"#$%&'()*+,-./:;?@[\]^_`{|}~
(def valid-chars (set (concat "!\"#$%&'()*+,-./:;?@[\\]^_`{|}~"
                              (map char (range (int \0) (inc (int \9))))
                              (map char (range (int \a) (inc (int \z))))
                              (map char (range (int \A) (inc (int \Z)))))))

(defn throw-illegal-arg
  "Throws IllegalArgumentException constructed with s."
  [s]
  (throw (IllegalArgumentException. s)))

(defn if-line-invalid-throw
  "Checks if line-data is valid, throwing an IllegalArgumentException if it
   isn't."
  [line-data original-line]
  (if (not (= 3 (count line-data)))
    (throw-illegal-arg
     (str "Expected \"<alien-num> <source-lang> <target-lang>\", but, was: "
          original-line))
    (let [alien-num (first line-data)
          source-lang (second line-data)
          target-lang (nth line-data 2)]
      (cond
       (= (first alien-num) (first source-lang))
       (throw-illegal-arg
        "First digit of alien-num is the lowest valued digit of the source-lang.")
       (not (every? (set source-lang) alien-num))
       (throw-illegal-arg
        (str "Not all digits of alien-num (" alien-num
             ") are contained in the source-lang (" source-lang ")."))
       (not (= (count (set source-lang)) (count source-lang)))
       (throw-illegal-arg (str "Not all digits of the source-lang ("
                               source-lang ") are unique."))
       (not (= (count (set target-lang)) (count target-lang)))
       (throw-illegal-arg (str "Not all digits of the target-lang ("
                               target-lang ") are unique."))
       ;; 0-9a-zA-Z!"#$%&'()*+,-./:;?@[\]^_`{|}~
       (not (every? valid-chars (set (concat alien-num source-lang target-lang))))
       (throw-illegal-arg (str "There are invalid chars in "
                               original-line "."))))))

(defn process-line [s]
  "Being s an input line, transform and validate it."
  (let [split-chars #{\space \tab}
        line-data (remove #(some split-chars %)
                          (partition-by #(contains? split-chars %) s))]
    (if-line-invalid-throw line-data s)
    (map #(apply str %) line-data)))

;; tests for the transformation and validation functions
(deftest process-line-tests
  (testing "that given well formed lines the result is correct"
    (are [expected line]
         (= expected (process-line line))
         ["123" "0123456789" "abcdefghij"]
         "123 0123456789 abcdefghij"
         ;; notice that the benevolent behavior is guaranteed by accepting
         ;; a tab character and one space
         ["1" "01" "abc"]
         (str "1 01" \tab " abc")))
  (testing "that invalid input is rejected"
    (are [line]
         (thrown? IllegalArgumentException (process-line line))
         "1 0123 ABC xy" ; too many arguments
         "123 012345678" ; too few arguments
         ;; the number should not start with the lowest digit of the source language
         "012 01234 ABC"
         ;; the source language doesn't contain all digits in the number
         "12x 0123 xyz0"
         "12x x122 YZXO" ; the source language contains duplicate digits
         "12x x123 YZXY" ; the target language contains duplicate digits
         ;; the target language contains the invalid digit €
         "12x x123 €ZXY")))

^L
;; output
(defn case-out
  [case-num converted-num]
  (str "Case #" case-num ": " converted-num))

(deftest case-out-tests
  (is (= "Case #3: xyz!!"
         (case-out 3 "xyz!!"))
      "given a case-num and a converted-num a correct str is returned")
  (is (= "Case #55: java.lang.IllegalArgumentException: There are invalid chars in 12x x123 €ZXY."
         (case-out 55 (IllegalArgumentException. "There are invalid chars in 12x x123 €ZXY.")))))

^L
;; the entry point
(defn main [args]
  (let [lines (get-lines *in*)
        numbered-lines (map-indexed (fn [case-num line] [(inc case-num) line]) lines)
        cases (map (fn [[case-num line]]
                     [case-num
                      (try (->> (process-line line)
                                (apply convert-num))
                           (catch IllegalArgumentException e e))])
                   numbered-lines)]
    (doseq [[case-num result] cases]
      (println (case-out case-num result)))))

(main *command-line-args*)