Several new problems and solutions added. Some of the examples are easier to solve with side effects and mutable data structures, so I solved those in Java.

Author: dpetrovics

Diff for: .gitignore

@@ -6,3 +6,4 @@
 /.lein-failures
 /checkouts
 /.lein-deps-sum
+*.DS_Store

Diff for: src/coding_exercises/chapter1.clj

@@ -0,0 +1,75 @@
+(ns chapter1
+  [:use coding-exercises.core]
+  [:require [clojure.string :as s]])
+
+(def problem1
+  "Implement an algorithm to determine if a string has all unique
+  characters What if you can not use additional data structures?")
+
+(comment
+  "SEE JAVA file for solution. There are 256 ASCII
+  characters (character encoding scheme). You could create an array
+  with 256 slots, and then make array[current-char] = true as you
+  iterate through the chars in the word. As you iterate, check if
+  array[current-char] already = true, in which case there is a repeat
+  char (ie not unique). There are 256 ASCII chars because each ASCII
+  char gets one byte (8bits, ie 2^8 combos). Unicode gets more bytes
+  so it can support more chars.")
+
+(defn unique-chars?
+  ^{:doc "Problem with this solution is that it
+  goes all the way through the string, even if a character has already
+  been repeated. (It builds the whole frequency map before it checks
+  the count)"}
+  [s]
+  (every? #(= 1 %1)
+          (vals
+           (frequencies s))))
+
+(defn unique-chars-bit
+  "Uses one long to store a bit vector. This means we have 8 bytes (64 bits) available for storage. Only A-Z, a-z are allowed in the input string, no numbers or special chars."
+  [s]
+  
+  )
+
+(def problem2
+  "Write code to reverse a string.")
+
+(defn my-reverse
+  [word]
+  (apply str
+         (for [i (range 0 (count word))]
+           (.charAt word 
+                    (- (dec (count word)) 
+                       i)))))
+
+(defn another-reverse
+  [word]
+  (apply str
+         (reduce conj () word)))
+
+(comment
+  "This would be easiest to do with (reverse word).")
+
+(def problem3
+  "Design an algorithm and write code to remove the duplicate
+  characters in a string without using any additional buffer. Assume
+  this means keep the first time a char appears, but remove any
+  subsequent appearances. SEE SOLUTION IN JAVA FILE")
+
+
+(def problem4
+  "Write a method to decide if two strings are anagrams or not.")
+
+;;clojure is awesome for this problem
+(defn anagrams?  ^{:doc "Takes in two strings and returns true if they
+  are anagrams, false otherwise."}
+  [s1 s2]
+  (= (frequencies s1)
+     (frequencies s2)))
+
+(defn anagrams2?
+  ^{:doc "Checks to see if two strings are anagrams, ignores whitespace and capitalization." }
+  [s1 s2]
+  (= (frequencies (s/replace (s/lower-case s1) " " ""))
+     (frequencies (s/replace (s/lower-case s2) " " ""))))

Diff for: src/coding_exercises/chapter5.clj

@@ -0,0 +1,32 @@
+(ns chapter5
+  [:use coding-exercises.core])
+
+;;BITWISE OPERATIONS
+
+(defn my-encode
+  ^{:doc "Takes in an age (0-127), a gender (0 or 1), and a height (0-127), and encodes them in a 2byte (16bit) short."}
+  [age gender height]
+  (short
+   (bit-or 
+    (bit-shift-left 
+     (bit-or 
+      (bit-shift-left age 1)
+      gender) 
+     7)
+    height)))
+
+(defn my-decode
+  ^{:doc "Takes in a short encoded with (my-encode) and spits out a str with the decoded age. height, and gender."}
+  [num]
+  (str "age: "
+       (bit-shift-right num 8)
+       ", gender: "
+       (bit-and
+        (bit-shift-right num 7) 1)
+       ", height: "
+       (bit-and num 127)))
+
+(defn binStr
+  ^{:doc "Outputs the binary string representation of the number."}
+  [num]
+  (. Long toBinaryString num))

Diff for: src/coding_exercises/core.clj

@@ -18,6 +18,21 @@
   (map first
        (iterate (fn [[a b]] [b (+ a b)]) [0 1])))
 
+(def map-example
+  "You have a collection of 2-tuples (user, follower). You want to get out (user, [followers]). Solution: put them all into a map, and use merge-with.")
+
+(def inputs
+  '(("Angie" "Dave") ("Angie" "Max") ("Bill" "Joe") ("Joe" "Moe") ("Bill" "Dave") ("Mike" "Dave") ("Angie" "Bill")))
+
+(defn user-followers
+  [uf-list]
+  (let [usr-map (map #(apply hash-map %1) uf-list)]
+    (apply merge-with
+           #(if (seq? %1)
+              (conj %1 %2)
+              (list %1 %2))
+           usr-map)))
+
 (defn clock-angle
   ^{:doc "Finds the angle in degrees between the hour hand and minute hand."}
   [hr min]
@@ -39,3 +54,6 @@
    (re-seq #"\w+" sentence)))
 
 
+(defn power [base exp]
+  (nth
+   (iterate #(* %1 base) 1) exp))

Diff for: src/coding_exercises/data-structures.clj

@@ -0,0 +1,3 @@
+(ns data-structures
+  )
+