```(println "Midterm Exam 2")

(defn juggle [v n] (let [x1 (get v 0) x2 (get v 1) x3 (get v 2)]
                        (if(=(mod n 2) 0)
                            (print(replace [x1 x2 x3] [1 0 2]))
                            (print(replace [x1 x2 x3] [0 2 1]))
                        )
                    )
                )

(defn generate-multiples [q n]
    (if (> n 0)
         (loop [x 0 sum [q]]
             (if (< x (dec n))
                (recur (inc x) (conj sum (+ (last sum) q)))sum
             )
         )
        [];return blank vector if n is 0
     )
)
 
(defn make-multi-applicator [f n]
  (fn [times]
    (apply f (repeat n times)))) 

(defn count-matching [pred a-seq]
    (loop [x 0 sum 0]
        (if (< x (count a-seq))
            (recur (inc x) (+ sum (if (pred (get a-seq x)) 1 0)))sum ;this returns sum
        )
    )
)


(println "-- Executing Question 1 --")
(println "-----------------------")
(juggle [:a :b :c] 0) (println " => [:b :a :c]")
(juggle [:b :a :c] 1) (println " => [:b :c :a]")
(juggle [:b :c :a] 2) (println " => [:c :b :a]")
(juggle [:c :b :a] 3) (println " => [:c :a :b]")
(juggle ["red" "green" "blue"] 49) (println " => [red blue green]")
(println "DONE Executing Question 1 >>")
(println "-----------------------")


(println "-- Executing Question 2 --")  
(println "-----------------------")
(print(generate-multiples 3 4)) (println" => [3 6 9 12]")
(print(generate-multiples 2 10)) (println " => [2 4 6 8 10 12 14 16 18 20]")
(print(generate-multiples 5 1)) (println " => [5]")
(print(generate-multiples 11 5)) (println " => [11 22 33 44 55]")
(print(generate-multiples -4 5)) (println " => [-4 -8 -12 -16 -20]")
(print(generate-multiples 9 0)) (println " => []")
(println "DONE Executing Question 2 >>")
(println "-----------------------")


(println "-- Executing Question 3 --")
(println "-----------------------")
(print((make-multi-applicator list 4) :a)) (println " => (:a :a :a :a)")
(print((make-multi-applicator vector 4) :a)) (println " => [:a :a :a :a]")
(print((make-multi-applicator + 3) 2)) (println " => 6")
(print((make-multi-applicator * 3) 2)) (println " => 8")
(println "DONE Executing Question 3 >>")
(println "-----------------------")


(println "-- Executing Question 4 --")
(println "-----------------------")
(print(count-matching even? [1 2 3 4 5])) (println " => 2")
(print(count-matching (fn [x] (= x :spam)) [:spam :spam :eggs :spam :baked-beans :spam :spam])) (println " => 5")
(print(count-matching sequential? [:a :b [:c] :d [:e :f] '(:g)])) (println " => 3")
(println "DONE Executing Question 4 >>")
(println "-----------------------")
```