# Solutions to 4Clojure Elementary Problems

Mar 16, 2016 · 9 minute read clojureinteractiveIn this post, I will share solutions to the elementary problems I solved on 4Clojure. You can find all the solutions on GitHub. If you have any suggestions/alternative solutions I would love to hear from you.

## 1. Nothing but the Truth

This is a clojure form. Enter a value which will make the form evaluate to `true`

.

```
(def nothing-but-the-truth true)
[(= nothing-but-the-truth true)]
```

## 2. Simple Math

If you are not familiar with polish notation, simple arithmetic might seem confusing.

```
(def simple-math 4)
[(= (- 10 (* 2 3)) simple-math)]
```

## 3. Intro to Strings

Clojure strings are Java strings. This means that you can use any of the Java string methods on Clojure strings.

```
(def intro-to-strings "HELLO WORLD")
[(= intro-to-strings (.toUpperCase "hello world"))]
```

## 4. Intro to Lists

Lists can be constructed with either a function or a quoted form.

`[(= (list :a :b :c) '(:a :b :c))]`

## 5. Lists: conj

When operating on a list, the `conj`

function will return a new list with one or more items "added" to the front.

```
(def lists-conj '(1 2 3 4))
[(= lists-conj (conj '(2 3 4) 1))
(= lists-conj (conj '(3 4) 2 1))]
```

## 6. Intro to Vectors

Vectors can be constructed several ways. You can compare them with lists.

```
(def intro-to-vectors [:a :b :c])
[(= intro-to-vectors (list :a :b :c) (vec '(:a :b :c)) (vector :a :b :c))]
```

## 7. Vectors: conj

When operating on a Vector, the `conj`

function will return a new vector with one or more items "added" to the end.

```
(def vectors-conj [1 2 3 4])
[(= vectors-conj (conj [1 2 3] 4))
(= vectors-conj (conj [1 2] 3 4))]
```

## 8. Intro to Sets

Sets are collections of unique values.

```
(def intro-to-sets #{:a :b :c :d})
[(= intro-to-sets (set '(:a :a :b :c :c :c :c :d :d)))
(= intro-to-sets (clojure.set/union #{:a :b :c} #{:b :c :d}))]
```

## 9. Sets: conj

When operating on a set, the `conj`

function returns a new set with one or more keys "added".

```
(def sets-conj #{1 2 3 4})
[(= sets-conj (conj #{1 4 3} 2))]
```

## 10. Intro to Maps

Maps store key-value pairs. Both maps and keywords can be used as lookup functions. Commas can be used to make maps more readable, but they are not required.

```
(def intro-to-maps 20)
[(= intro-to-maps ((hash-map :a 10, :b 20, :c 30) :b))
(= intro-to-maps (:b {:a 10, :b 20, :c 30}))]
```

## 11. Maps: conj

When operating on a map, the `conj`

function returns a new map with one or more key-value pairs "added".

```
(def maps-conj {:a 1, :b 2, :c 3})
[(= maps-conj (conj {:a 1} {:b 2} [:c 3]))]
```

## 12. Intro to Sequences

All Clojure collections support sequencing.
You can operate on sequences with functions like `first`

, `second`

, and `last`

.

```
(def intro-to-sequences 3)
[(= intro-to-sequences (first '(3 2 1)))
(= intro-to-sequences (second [2 3 4]))
(= intro-to-sequences (last (list 1 2 3)))]
```

## 13. Sequences: rest

The rest function will return all the items of a sequence except the first.

```
(def sequences-rest [20 30 40])
[(= sequences-rest (rest [10 20 30 40]))]
```

## 14. Intro to Functions

Clojure has many different ways to create functions.

```
(def intro-to-functions 8)
[(= intro-to-functions ((fn add-five [x] (+ x 5)) 3))
(= intro-to-functions ((fn [x] (+ x 5)) 3))
(= intro-to-functions (#(+ % 5) 3))
(= intro-to-functions ((partial + 5) 3))]
```

## 15. Double Down

Write a function which doubles a number.

```
(defn double-down [n]
(* 2 n))
[(= (double-down 2) 4)
(= (double-down 3) 6)
(= (double-down 11) 22)
(= (double-down 7) 14)]
```

## 16. Hello World

Write a function which returns a personalized greeting.

```
(defn hello-world [name]
(str "Hello, " name "!"))
[(= (hello-world "Dave") "Hello, Dave!")
(= (hello-world "Jenn") "Hello, Jenn!")
(= (hello-world "Rhea") "Hello, Rhea!")]
```

## 17. Sequences: map

The map function takes two arguments: a function (f) and a sequence (s). Map returns a new sequence consisting of the result of applying f to each item of s. Do not confuse the map function with the map data structure.

```
(def sequences-map '(6 7 8))
[(= sequences-map (map #(+ % 5) '(1 2 3)))]
```

## 18. Sequences: filter

The filter function takes two arguments: a predicate function (f) and a sequence (s). Filter returns a new sequence consisting of all the items of `s`

for which `(f item)`

returns `true`

.

`[(= '(6 7) (filter #(> % 5) '(3 4 5 6 7)))]`

## 35. Local bindings

Clojure lets you give local names to values using the special let-form.

```
[(= 7 (let [x 5] (+ 2 x)))
(= 7 (let [x 3, y 10] (- y x)))
(= 7 (let [x 21] (let [y 3] (/ x y))))]
```

## 36. Let it Be

Can you bind `x`

, `y`

, and `z`

so that these are all true?

```
[(= 10 (let [x 7, y 3, z 1] (+ x y)))
(= 4 (let [x 7, y 3, z 1] (+ y z)))
(= 1 (let [x 7, y 3, z 1] z))]
```

## 37. Regular Expressions

Regex patterns are supported with a special reader macro.

```
(def regular-expressions "ABC")
[(= regular-expressions (apply str (re-seq #"[A-Z]+" "bA1B3Ce ")))]
```

## 52. Intro to Destructuring

Let bindings and function parameter lists support destructuring.

`[(= [2 4] (let [[a b c d e] [0 1 2 3 4]] [c e]))]`

## 57. Simple Recursion

A recursive function is a function which calls itself. This is one of the fundamental techniques used in functional programming.

```
(def simple-recursion '(5 4 3 2 1))
[(= simple-recursion ((fn foo [x]
(when (> x 0)
(conj (foo (dec x)) x))) 5))]
```

## 64. Intro to Reduce

Reduce takes a 2 argument function and an optional starting value. It then applies the function to the first 2 items in the sequence (or the starting value and the first element of the sequence). In the next iteration the function will be called on the previous return value and the next item from the sequence, thus reducing the entire collection to one value. Don’t worry, it’s not as complicated as it sounds.

```
(def intro-to-reduce +)
[(= 15 (reduce intro-to-reduce [1 2 3 4 5]))
(= 0 (reduce intro-to-reduce []))
(= 6 (reduce intro-to-reduce 1 [2 3]))]
```

## 68. Recurring Theme

Clojure only has one non-stack-consuming looping construct: `recur`

. Either a function or a loop can be used as the recursion point. Either way, recur rebinds the bindings of the recursion point to the values it is passed. Recur must be called from the tail-position, and calling it elsewhere will result in an error.

```
(def recurring-theme [7 6 5 4 3])
[(= recurring-theme
(loop [x 5
result []]
(if (> x 0)
(recur (dec x) (conj result (+ 2 x)))
result)))]
```

## 71. Rearranging Code: - >

The - > macro threads an expression x through a variable number of forms. First, x is inserted as the second item in the first form, making a list of it if it is not a list already. Then the first form is inserted as the second item in the second form, making a list of that form if necessary. This process continues for all the forms. Using - > can sometimes make your code more readable.

```
(def rearranging-code last)
[(= (rearranging-code (sort (rest (reverse [2 5 4 1 3 6]))))
(-> [2 5 4 1 3 6] (reverse) (rest) (sort) (rearranging-code))
5)]
```

## 72. Rearranging Code: - >>

The - >> macro threads an expression x through a variable number of forms. First, x is inserted as the last item in the first form, making a list of it if it is not a list already. Then the first form is inserted as the last item in the second form, making a list of that form if necessary. This process continues for all the forms. Using - >> can sometimes make your code more readable.

```
(defn rearranging-code [s]
(reduce + s))
[(= (rearranging-code (map inc (take 3 (drop 2 [2 5 4 1 3 6]))))
(->> [2 5 4 1 3 6] (drop 2) (take 3) (map inc) (rearranging-code))
11)]
```

## 134. A nil key

Write a function which, given a key and map, returns true iff the map contains an entry with that key and its value is nil.

```
(defn a-nil-key [key map]
(if (contains? map key)
(= (key map) nil)
false))
[(true? (a-nil-key :a {:a nil :b 2}))
(false? (a-nil-key :b {:a nil :b 2}))
(false? (a-nil-key :c {:a nil :b 2}))]
```

## 145. For the win

Clojure’s for macro is a tremendously versatile mechanism for producing a sequence based on some other sequence(s). It can take some time to understand how to use it properly, but that investment will be paid back with clear, concise sequence-wrangling later. With that in mind, read over these for expressions and try to see how each of them produces the same result.

```
(def for-the-win [1 5 9 13 17 21 25 29 33 37])
[(= for-the-win (for [x (range 40)
:when (= 1 (rem x 4))]
x))
(= for-the-win (for [x (iterate #(+ 4 %) 0)
:let [z (inc x)]
:while (< z 40)]
z))
(= for-the-win (for [[x y] (partition 2 (range 20))]
(+ x y)))]
```

## 156. Map Defaults

When retrieving values from a map, you can specify default values in case the key is not found:
`(= 2 (:foo {:bar 0, :baz 1} 2))`

However, what if you want the map itself to contain the default values? Write a function which takes a default value and a sequence of keys and constructs a map.

```
(defn map-defaults [default keys]
(zipmap keys (repeat default)))
[(= (map-defaults 0 [:a :b :c]) {:a 0 :b 0 :c 0})
(= (map-defaults "x" [1 2 3]) {1 "x" 2 "x" 3 "x"})
(= (map-defaults [:a :b] [:foo :bar]) {:foo [:a :b] :bar [:a :b]})]
```

## 161. Subset and Superset

Set A is a subset of set B, or equivalently B is a superset of A, if A is "contained" inside B. A and B may coincide.

```
(def subset-and-superset #{1 2})
[(clojure.set/superset? subset-and-superset #{2})
(clojure.set/subset? #{1} subset-and-superset)
(clojure.set/superset? subset-and-superset #{1 2})
(clojure.set/subset? #{1 2} subset-and-superset)]
```

## 162. Logical falsity and truth

In Clojure, only nil and false represent the values of logical falsity in conditional tests - anything else is logical truth.

```
(def logical-falsity-and-truth 1)
[(= logical-falsity-and-truth (if-not false 1 0))
(= logical-falsity-and-truth (if-not nil 1 0))
(= logical-falsity-and-truth (if true 1 0))
(= logical-falsity-and-truth (if [] 1 0))
(= logical-falsity-and-truth (if [0] 1 0))
(= logical-falsity-and-truth (if 0 1 0))
(= logical-falsity-and-truth (if 1 1 0))]
```

These set of problems are pretty simple to solve which is excellent if you’re just getting started with a language. In future posts I will continue with harder problems. If you want to dive deeper into Clojure check out Daniel Higginbotham’s book: Clojure for the Brave and True.