the answer of 4clojure 1-100

1.Nothing but the Truth    true

2.Simple Math    4

3.Intro to Strings    “HELLO WORLD"

4.Intro to Lists     :a :b :c

5.Lists conj      '(1 2 3 4)

6.Intro to Vectors    :a :b :c

7.Vectors conj     [1 2 3 4]

8.Intro to Sets   #{:a :b :c :d} 

9.Sets conj    2

10.Intro to Maps   20

11.Maps conj   {:b 2}

12.Intro to Sequences   3

13.Sequences rest     [20 30 40]

14.Intro to Functions   8

15.Double Down    

好几个方法呢   看help里面一次为例子  (partial * 2)

(fn double [x] (* 2 x))

(fn [x] (* 2 x))

#(* 2 %)

(partial * 2)

16.Hello World    (#(str "Hello, " % "!") 

17.Sequences map   '(6 7 8)

18.Sequences filter   '(6 7)

19.Last Element  #(first(reverse %))

20.Penultimate Element   #(first(rest(reverse %)))

21.Nth Element     #(first (drop %2 %1))

22.Count a Sequence    

one for example:

#(loop [result 0 c %]
    (if(empty? c) result
    (recur (inc result) (rest c))))
others' excellent anser
#(reduce (fn [x y] (inc x)) 0 %)

23.Reverse a Sequence    #(into () %)

24.Sum It All Up      #(apply + %)

25.Find the odd numbers    #(filter odd? %)

26.Fibonacci Sequence   #(take % (map first(iterate (fn [[x y]] [y (+ x y)]) [ 1 1])))  or   #(take % (map last(iterate (fn [[x y]] [y (+ x y)]) [ 0 1])))

http://www.iteye.com/topic/624085

27.Palindrome Detector   

#(= (seq %) (reverse %))
;;(seq "abc") result in (\a \b \c)
;; reverse will not evaluated as string ether.

28.Flatten a Sequence 

#(filter (complement sequential?) (tree-seq sequential? identity %))
;; complement
;; tree-seq

29.Get the Caps  #(apply str (re-seq #"[A-Z]" %))

re-seq 寻找序列中包含的#“。。。”    %是序列     任意序列     (re-seq #"[A-Z]" %)得到的是单个的序列    str转换为str类型   apply将单词组合起来

30.Compress a Sequence   

one for example

(fn [input]
  (loop [i input res []]
    (if (empty? i)
      res
      (if (= (last res) (first i))
        (recur (rest i) res)
        (recur (rest i) (conj res (first i))))
  )))
  another answer for example
  ;; use partition-by
  #(map first (partition-by identity %))  其中partition-by是将序列相同的为一组，关键字identity，

(partition-by identity "Leeeeeerrroyyy")

((\L) (\e \e \e \e \e \e) (\r \r \r) (\o) (\y \y \y))

用map取first或者last

31.Pack a Sequence

 

 #(partition-by identity %)

类似于上一题   

e.g.

(partition-by identity [1 1 1 2 2 3 3 1 1 2 3])
((1 1 1) (2 2) (3 3) (1 1) (2) (3))

32.Duplicate a Sequence    #(interleave % %)

32.Pack a Sequence   

【1】#(apply concat (map (fn [input](repeat %2 input)) %1))
【2】#(mapcat (fn [input](repeat %2 input)) %1)

34. Implement range     #(take  (- %2 %1) (iterate inc %))  （- %2 %1）是个数   （iterate inc %）是从%这个数值开始递增

http://clojuredocs.org/clojure_core/clojure.core/iterate

35.Local bindings     7

36.Let it Be      [x 7,y 3 ,z 1]

37.Regular Expressions      "ABC"

38.Maximum value   

39.Interleave Two Seqs       mapcat vector

40.Interpose a Seq        #(-> (interleave %2 (repeat %1)) drop-last vec)

41Drop Every Nth Item 

 (fn [vec n]
  (mapcat #(take (dec n) %) (partition-all n vec))
  )

42.Factorial Fun     #(reduce * (range 1 (inc %)))  阶乘

43. Reverse Interleave    

(fn rev-int [v n]
  (apply map vector (partition n v)))

44. Rotate Sequence

 (fn rotate [n v]
  (->> (concat v v)
    (drop (mod n (count v)))
    (take (count v))
    )
)

n为个数，v为verctor，   concat连接两个集合，drop去掉前(mod n (count v))个元素，take取前(take (count v)个元素

eg.(= (__ -2 [1 2 3 4 5]) '(4 5 1 2 3))

(concat v v)[1 2 3 4 5 1 2 3 4 5 ]，(count v )为5，(mod -2 5)为3，(drop 3 )为[4 5 1 2 3 4 5 ]，(take 5）为[4 5 1 2 3 ]

45.Intro to Iterate   '(1 4 7 10 13)

46. Flipping out

#(fn [a b] (% b a))

47.Contain Yourself

    4

48.Intro to some

    6

49.Split a sequence

#(vector 
       (vec (take %1 %2)) 
       (vec (drop %1 %2)))

50. Split by Type

(fn split-by-type [v]
  (for [[key value] (group-by class v)]
    value))

51.Advanced Destructuring

[1 2 3 4 5]
54. Partition a Sequence

(fn my-partition [n v]
  (if (>= (count v) n)
    (cons (take n v) (my-partition n (drop n v)))))

55. Count Occurrences

#(into {}
  (map (fn [[k v]] [k (count v)]) (group-by identity %)))

56. Find Distinct Items

reduce (fn [s e]
  (if (some #(= % e) s)
    s
    (conj s e)))
[] 

58. Function Composition

(fn comb [& funcs]
  (fn [& args]
    (first
      (reduce #(vector (apply %2 %1)) args (reverse funcs )))))

59. Juxtaposition

(fn my-juxt [& funcs]
  (fn [& args]
    (map #(apply % args) funcs )))

60. Sequence Reductions

(fn my-reduce
 
  ([op input] (my-reduce op (first input) (rest input)))
 
  ([op result input]
 
  (lazy-seq
    (if (empty? input) (list result)
      (cons result
            (my-reduce op
                 (op result (first input))
                 (rest input)))))))

61.Map Construction

#(into {} (map vector %1 %2))

62.Re-implement Iterate

(fn it [f x]
  (lazy-seq (cons x (it f (f x)))))
63.Group a Sequence

(fn grp-seq [func vals]
  (into {}
        (map #(vector (func (first % )) (vec %))
             (partition-by func (sort vals)))))

64.Intro to Reduce

+

65. Black Box Testing

#({{} :map #{} :set} (empty %) (if (reversible? %) :vector :list)) 

66.Greatest Common Divisor

(fn [a b]
  (let [get-divisor (fn [n] (into #{}
                              (filter #(zero? (rem n %))
                                      (range 1 (inc n)))
                              ))
        a-divisor (get-divisor a)
        b-divisor (get-divisor b)
        commom-divisor (clojure.set/intersection a-divisor b-divisor)]
    (apply max commom-divisor)))
67. Prime Numbers
(fn [n]
  (take n(filter 
(fn is-prime [n]
  (nil?
  (some
    #(zero? (mod n %))
    (range 2 n))))
(range 2 1000))))
68.Recurring Theme
'(7 6 5 4 3)
69. Merge with a Function
(fn [f & args]
  (reduce (fn[map1 map2]
            (reduce (fn [m [k v]]
                      (if-let [vv (m k)]
                        (assoc m k (f vv v))
                        (assoc m k v)))
                    map1 map2))
          args))

70. Word Sorting

#(sort-by (fn [v](.toLowerCase v))  (re-seq #"\w+" %))

71.Rearranging Code

last

72.Rearranging Code-->>

reduce +

74. Filter Perfect Squares

(fn perf-square [s]
  (let [nums (map #(Integer/valueOf %)  (clojure.string/split s #","))
        all-perf-sq  (set (map #(* % %) (range 100)))
        sq-nums (filter all-perf-sq nums)]
(apply str (interpose "," sq-nums))))

76. Intro to Trampoline

[1 3 5 7 9 11]

77.Anagram Finder

(fn [v]
  (into #{}
    (map set
      (filter #(> (count %) 1)
        (map val (group-by sort v))))))

78. Reimplement Trampoline

 (fn
  [f & args]
  (loop [res (apply f args)]
    (if (fn? res)
      (recur (res))
      res)))

80. Perfect Numbers

(fn is-perf-num [n]
  (= n
     (apply + (filter #(zero? (mod n %)) (range 1 n)))))

81.Set Intersection

(fn doset [sa sb]
  (set (filter #(sa %) sb))
  )

83.A Half-Truth

#(true? 
  (and
    (some true? %&)
    (some false? %&)))
86. Happy Numbers

(letfn [(num->digits [num]
          (loop [n num res []]
            (if (zero? n)
              res
              (recur (long (/ n 10)) (cons (mod n 10) res)))))
        (change [n]
          (apply + (map #(* % %) (num->digits n))))]
  (fn [init]
    (loop [curr init results #{}]
      (println curr " - " results)
      (cond
       (= 1 curr) true
       (results curr) false
       :else (let [new-n (change curr)]
               (println curr new-n)
               (recur new-n (into results [curr])))
       )))
  )

88.Symmetric Difference

(fn set-diff [sa sb]
  (set
    (concat
      (filter (complement sb) sa)
      (filter (complement sa) sb))))

90.Cartesian Product

(fn [a b]
  (set (for [x a y b]
         [x y])))
 95.To Tree, or not to Tree

(fn istree? [root]
  (or (nil? root)
      (and (sequential? root)
           (= 3 (count root))
           (every? istree? (rest root)))))

96. Beauty is Symmetry

(fn symmetry [[root left right]]
  (let [mirror? (fn mirror? [a b]
                  (cond
                    (not= (sequential? a) (sequential? b)) false
                    (sequential? a) (let [[ra La Ra] a
                                          [rb Lb Rb] b]
                                      (and (= ra rb) (mirror? La Rb) (mirror? Lb Ra)))
                    :else (= a b)))]
  (mirror? left right)))

97.Pascal's Triangle

(fn pascal-tri [n]
  (condp = n
    1 [1]
    (let [last (pascal-tri (dec n))
          last-a (concat [0] last)
          last-b (concat last [0])
          ]
      (vec(map + last-a last-b)))))

99.Product Digits

;; the math way
(fn [a b]
  (drop-while zero? 
    (reverse 
      (map #(mod (int(/ (* a b) %)) 10)
           (take 10 (iterate #(* 10 %) 1))))))
  
;; the trick way
(fn [a b]
  (map #(Integer/parseInt (str %))  (str (* a b))))

100. Least Common Multiple.clj

(fn [& args]
  (letfn [(gcd [x y]
            (let [a (max x y)
                  b (min x y)
                  m (mod a b)]
              (if (zero? m)
                b
                (recur b m))))
          (lcm [a b]
            (/ (* a b) (gcd a b)))]
    (reduce lcm args)
    ))