Clojure Course - Code Coach Easy Solutions

Clojure Course

Interlude - Code Coach Easy Solutions

Let's put our knowledge to the test, and try some of the features we have learned in the previous section. The Code Coach challenges will be perfect for this exercise. Of course there is no Clojure playground in SoloLearn, so you cannot gain any in-app benefit by copying these codes. But they can demonstrate really well the basic concepts. Maybe we'll learn some new tricks along the way!

Clojure is a functional language, so we'll follow the pattern to write a function for each task, that returns the result. Then we test the function with some inputs.

Fruit Bowl

The fruit bowl contains half apples and half bananas. How many apple pies can you make, if 3 apples are needed for each pie? Input is the total number of fruits.

(defn make-pies
"Calculate how many pies you can make"
[fruits]
(quot (/ fruits 2) 3))

(do
  (println (make-pies 26))
  (println (make-pies 4))
  (println (make-pies 12)))

Note: the function quot gives the quotient of an integer division.

Popsicles

Give your siblings a box of popsicles, if you can distribute them evenly among them. Otherwise keep them for yourself, so they won't fight over it. Inputs are number of siblings and number of popsicles.

(defn popsicles
"Decide if you can distribute the popsicles evenly"
[siblings popsicles]
(if (zero? (rem popsicles siblings))
  "give away"
  "eat them yourself"))

(do
  (println (popsicles 3 9))
  (println (popsicles 2 5))
  (println (popsicles 10 20)))

Note: the function rem is the remainder of an integer division. Another similar function is mod (modulo), the only difference between the two is they handle negative numbers differently.

Halloween Candy

Trick or treating with a friend, you collect candies from all houses, except one house gives toothbrushes and two houses give dollar bills. Given the total number of houses, what is the percentage chance (rounded up to next integer) that a random item you pull from the bag, is a dollar?

(defn halloween
"Calculate the chance that you pull a dollar bill"
[houses-visited]
(Math/ceil (* 100 (/ 2 houses-visited))))

(do
  (println (halloween 4))
  (println (halloween 3))
  (println (halloween 10)))

Note: the function Math/ceil is calling the ceil function of the Math package/library of the host platform, in this case Javascript: Math.ceil(x) rounds up a number in JS.

Cheer Creator

You are cheering for your favorite team. Chant an appropriate cheer based on the team's performance. When they move more than 10 yards, the cheer is "High Five". When less than 1 yard, stay quiet: "shh". When inbetween, chant "Ra!" as many times as the number of yards moved.

(defn cheer
"Chant an appropriate cheer for your team"
[yards]
(cond
  (< yards 1) "shh"
  (> yards 10) "High Five"
  :else (apply str (repeat yards "Ra!")))) 

(do
  (println (cheer 4))
  (println (cheer 0))
  (println (cheer 13)))

Note: the repeat function creates a sequence from the same elements. The apply function kind of unpacks this collection of strings, so that all its elements become the arguments of the str function, which combines them to a single string.
(apply str ["a" "b" "c"])) is the same as (str "a" "b" "c").

Extra-Terrestrials

Communicate with the aliens who say every English word backwards.

(defn speak-alien
"Talk with aliens by saying the word in reverse"
[word]
(clojure.string/reverse word))

(do
  (println (speak-alien "howdy"))
  (println (speak-alien "welcome"))
  (println (speak-alien "extra-terrestrial")))

Note: we can access many standard Clojure functions, for example those that deal with strings, are located in the clojure.string namespace. We either prefix the function name with the namespace, like in the example here, or we can also "import" and "alias" a namespace at the beginning of the program, which is a topic for another time :)

Jungle Camping

Identify the animal noises you hear in the jungle.

(def noises {"Grr" "Lion"
"Rawr" "Tiger"
"Ssss" "Snake"
"Chirp" "Bird"})
    
(defn identify-noises
  "Figure out which animals make the listed noises"
  [unidentified-noises]
  (map #(get noises %) unidentified-noises))

(do
  (println (identify-noises ["Rawr" "Chirp" "Ssss"]))
  (println (identify-noises ["Rawr" "Rawr"]))
  (println (identify-noises ["Grr"])))

Note: this time we look up values from a hash-map, using the get function, and we iterate this lookup over a vector of sounds with the map function. Nifty!

Note: you can check the Clojure Cheat Sheet to get a quick glance of all the functions available in clojure.core and other built-in libraries.

[Clojure] Code Coach - Easy