e2-24-25-26-27-28-29

(ns e2-24-25-26-27-28-29

(:use clojure.test))

(deftest test-print-list

(is (= (list 1 (list 2 (list 3 4))) [1 [2 [3 4]]])))

(deftest test-get-7
  (is (= (first (rest (first (rest (rest [1 3 [5 7] 9])))))
         7))
  (is (= (first (first [[7]]))
         7))
  ; This is MADNESS!
  ; No! THIS! IS! DEEPLY NESTED LIST!
  (is (= (first (rest (first (rest (first (rest (first (rest (first (rest (first (rest [1 [2 [3 [4 [5 [6 7]]]]]]))))))))))))
         7)))

(def x [1 2 3])

(def y [4 5 6])

(deftest test-xy
  ; both arguments of (concat) are seqs
  (is (= (concat x y) [1 2 3 4 5 6]))
  ; (cons) expects the first argument to be a value and the second - a seq
  (is (= (cons x y) [[1 2 3] 4 5 6]))
  ; both arguments of (list) are values
  (is (= (list x y) [[1 2 3] [4 5 6]])))

(defn deep-reverse [xs]
  (if (empty? xs) nil
      ; sequential? returns true for VECTORS as well as for other seqs
      ; while seq? is false for VECTORS
      (if (sequential? (first xs))
          (concat (deep-reverse (rest xs)) [(deep-reverse (first xs))])
          (concat (deep-reverse (rest xs)) [(first xs)]))))

(deftest test-deep-reverse

(is (= (deep-reverse [[1 2] [3 4]]) [[4 3] [2 1]])))

Flattens the given tree structure.

(defn fringe
  [t]
  (if (empty? t) nil
      (if (sequential? (first t))
          (concat (fringe (first t)) (fringe (rest t)))
          (cons (first t) (fringe (rest t))))))

(deftest test-fringe
  (is (= (fringe [[1 2] [3 4]]) [1 2 3 4]))
  (is (= (fringe [[[1 2] [3 4]][[1 2] [3 4]]]) [1 2 3 4 1 2 3 4])))

(defn make-mobile [l r]

[l r])

(defn make-branch [len structure]

[len structure])

(defn left-branch [m]

(first m))

(defn right-branch [m]

(second m))

(defn branch-len [b]

(first b))

Returns either the mobile connected to this branch or the weigth of the branch

(defn branch-structure
  [b]
  (second b))

(defn weight? [b]

(number? b))

(defn branch-weight [b]
  (letfn [(weight [b result]
            (let [structure (branch-structure b)]
              (if (weight? structure)
                  (+ result structure)
                  (+ (weight (left-branch structure) result) (weight (right-branch structure) result)))))]
    (weight b 0)))

(defn total-weight [m]

(+ (branch-weight (left-branch m)) (branch-weight (right-branch m))))

(def *mob1* (make-mobile (make-branch 1 5) (make-branch 1 10)))

(def *mob2* (make-mobile (make-branch 1 5)
                         (make-branch 1 (make-mobile (make-branch 2 4)
                                                     (make-branch 1 4)))))

(def *mob3* (make-mobile (make-branch 4 5)
                         (make-branch 1 (make-mobile (make-branch 2 10)
                                                     (make-branch 2 10)))))

(deftest test-total-weight
  (is (= (total-weight *mob1*) 15))
  (is (= (total-weight *mob2*) (+ 5 4 4))))

I bumped into a difficulty while solving this problem, as I didn't really understand what it meant for a binary mobile to be balanced. You need to calculate a torque not only for a branch which contains the weight, but for the branches which contain sub-mobiles too. It may be obvious for you, but it wasn't obvious for me.

(defn torque [b]

(* (branch-weight b) (branch-len b)))

(def balanced?)

(defn branch-balanced? [b]
  (let [structure (branch-structure b)]
    (if (weight? structure) true
        (balanced? structure))))

(defn balanced? [m]
  (and (= (torque (left-branch m)) (torque (right-branch m)))
       (branch-balanced? (left-branch m))
       (branch-balanced? (right-branch m))))

(deftest test-balanced?
  (is (not (balanced? *mob1*)))
  (is (balanced? *mob3*)))