;ピタゴラス数判定 
(defn pytha? [a b c]
 (let [x (int c)]
    (= (* x x) (+ ( * a a) (* b b)))))
(assert (pytha? 3 4 5.0))

;直角三角形の周囲の長さを返す
(defn pytha-length [x y]
  (let [z (Math/sqrt (+ (* x x)(* y y)))]
    (if (pytha? x y z)  (int(+ x y z)) 0 )) )
(assert (= 12 (pytha-length 3 4)))

;周囲がｎ未満のピタゴラス数の総和の数列
(defn pytha-coll [n]
  (take-while #(> n %) (sort (filter #(not (zero? %))(for [x (range 3 n) y (range (inc x) n)] (pytha-length  x y ))))))
(assert (= 3  (count (drop-while #(< % 120) (pytha-coll 121)))))

;同じ値どおしをmapにまとめる
(defn make-count-map [c]
  (loop [map {} coll c]
    (cond
      (empty? coll) map
      :else (recur (assoc map (first coll) (inc (get map (first coll) 0))) (rest coll)))))

;secondが大きいほうのcollを返す
(defn max-second-col [c1 c2]
  (if (> (second c1) (second c2) ) c1 c2))
(assert ( = [0 2] (max-second-col [0 1] [0 2])))
;最大のValueをもつkeyとvalueを返す
(defn find-max-value [m]
  (loop [map m coll [-1 -1]]
    (cond
      (empty? map) coll
      :else (recur (dissoc map (key (first map))) (max-second-col coll  (first map)) ))))
(println (first (find-max-value (make-count-map (pytha-coll 1001))) ))

(def numbers (take 1000000 (flatten (map #(vec (str %)) (range 1 200000)))))    (assert (= 1000000 (count numbers) ))

;charをintに変換
(defn char-int[c] (- (int c) 48))
(assert (= 1 (char-int(nth numbers 11))))

(println (* (char-int(nth numbers 0)) (char-int(nth numbers 9)) (char-int(nth numbers 99))
           (char-int(nth numbers 999))(char-int(nth numbers 9999))(char-int(nth numbers 99999))(char-int(nth numbers 999999))))

(println (filter #(prime? (Integer/parseInt (apply str %))) (num-list) ))
()

(defn num-list7[]
  (for [c (range 7) d (range 6) e (range 5) f (range 4) g (range 3) h (range 2) ]
    (result-num [ c d e f g h 0] )))
(println (last (filter #(prime? (Integer/parseInt (apply str %))) (num-list7) )))

(def words-array (sort(re-seq #"\w+" (slurp "words.txt"))))

(defn word-value [s]
  (reduce + (map #(- (int %) 64) s)))
(assert = (55  (word-value "SKY")))
(def words-values (map #(word-value %) words-array ))
(println (first (sort > words-values )))

(defn tri [n] (quot (* n (inc n)) 2))
(def tri-until-192 (take-while #(< % 192) (map #(tri %) (iterate inc 1))))

(defn tri? [n]
  (loop [tri-coll tri-until-192 ]
    (cond
      (empty? tri-coll) false
      (= (first tri-coll) n) true
      :else (recur (next tri-coll) ))))

(println (count(filter #(tri? %) words-values )))

(defn delete [n coll]  (flatten (conj  (drop (inc n) coll)  (take n coll) )))
(defn result-num [coll]
  (loop [result-num-coll [] base-coll [0 1 2 3 4 5 6 7 8 9] src-coll coll]
    (if (not( empty?  src-coll ))
      (recur (conj result-num-coll (nth base-coll (first src-coll))) (delete (first src-coll) base-coll) (rest src-coll))
      (Long/parseLong (apply str result-num-coll)))))
(assert (= (result-num [1 0 0 0 0 0 0 0 0 0] ) 1023456789))

(defn num-list[]
  (for [i (range 1 10) a (range 9) b (range 8) c (range 7) d (range 6) e (range 5) f (range 4) g (range 3) h (range 2) ]
    (result-num [i a b c d e f g h 0] )))

(defn d234? [i] (zero? (rem ( quot (rem i 1000000000) 1000000) 2)))
(defn d345? [i] (zero? (rem ( quot (rem i 100000000) 100000) 3)))
(defn d456? [i] (zero? (rem ( quot (rem i 10000000) 10000) 5)))
(defn d567? [i] (zero? (rem ( quot (rem i 1000000) 1000) 7)))
(defn d678? [i] (zero? (rem ( quot (rem i 100000) 100) 11)))
(defn d789? [i] (zero? (rem ( quot (rem i 10000) 10) 13)))
(defn d8910? [i] (zero? (rem (rem i 1000) 17)))


(assert (d234? 1406357289))
(assert (d345? 1406357289))
(assert (d456? 1406357289))
(assert (d567? 1406357289))
(assert (d678? 1406357289))
(assert (d789? 1406357289))
(assert (d8910? 1406357289 ))
(defn d?[n] (and (d234? n) (d345? n) (d456? n) (d567? n) (d678? n) (d789? n )(d8910? n)))
(println (reduce +  (filter #(d? %) (num-list))))

(defn pentagonal [n] (/ (* n (- (* 3 n) 1)) 2))
(assert (= [1, 5, 12, 22, 35, 51, 70, 92, 117, 145] (map #(pentagonal %) (range 1 11))))

(defn pentagonal? [n]
  (let [x  (/ (+ 1 (Math/sqrt (+ 1 (* 24 n)))) 6)]
    (== x (int x))))
(assert (pentagonal? 145))

(defn add-pentagonals []
   (filter #(not (empty? %)) (for [x (iterate inc 1) y (range  1 x)] (if (pentagonal? (+ (pentagonal x) (pentagonal y))) [(pentagonal x)  (pentagonal y)] []))))

(defn sub-pentagolan? [c]
  (pentagonal? (-  (first c) (second c))))

(def result (first (take 1(filter #(sub-pentagolan? %) (add-pentagonals )))))
(println result)
(println (- (first result) (second  result)))

(defn triangle? [n]
  (let [x  (/ (- (Math/sqrt (+ 1 (* 8 n))) 1) 2)]
    (== x (int x))))

(defn hexagonal? [n]
  (let [x  (/ (+ 1 (Math/sqrt (+ 1 (* 8 n)))) 4)]
    (== x (int x))))

(assert (triangle? 40755))
(assert (hexagonal? 40755))

(println (first (filter #(and (triangle? %) (hexagonal? %)) (map #(pentagonal %) (iterate inc 166)))))

(defn frac [x y i]
  (if (= (/ x y) (/ (+ i (* x 10)) (+ y (* i 10))) )
    [(+ i (* x 10)) (+ y (* i 10))] nil))
;分数のサーチ
(defn search []
  (filter #(not (empty? %)) (for [x (range 1 10) y (range 1 10)
     i (range 1 10) :when (> y x)] (frac x y i))))
(assert (= 4 (count (search))))

user=> (/ 2 4)
1/2
user=> (class (/ 1 2))
clojure.lang.Ratio

;引数を分数のcolとみなして、掛け合わせる。
(defn mul-frac [coll]
  (reduce * (map #(/ (first %) (second %)) coll)))
(println (denominator (mul-frac (search))))

;階乗を求める
(defn fact[n] (reduce * (range 1 (inc n))))
; あとで何度も使うのでメモ化
(def fact (memoize fact))

;上限がどこまでか調べる
(println (last (take-while #(> (* % (fact 9)) (expt 10 %))
  (iterate  inc 3))))

(defn fact-each-digit[n] (reduce + (map #(fact (- (int %) 48))
    (vec (str n)))))
(assert (= 145 (fact-each-digit 145) ))

(defn is-answer [n](if (= n (fact-each-digit n)) n 0))

(println (reduce + (map #(is-answer %) (range 3 (expt 10 6)))))

(defn rotate-left [n]
     (str (apply str (next (str n)) ) (str (first (str n)))))
(assert (= "719" (rotate-left 971) ))

(defn all-rotate [n]
  (loop [result [(str n) ] next (rotate-left n) base (str n)]
    (if (= base next)
      result
      (recur (conj result next) (rotate-left next) base))))

(defn all-prime? [c] (every? true? (map #(prime? (Integer/parseInt %)) c )))
(assert (= 13 (count (filter #(all-prime? (all-rotate %)) (range 100) ))))

(println (count (filter #(all-prime? (all-rotate %)) (range 1000000) )))

;回文数判定
(defn kaibun? [n]
  (= (str n) (apply str (reverse (str n)))))
(assert (kaibun? 585 ))

;回文数判定(２進数)
(defn bin-kaibun? [n]
  (= (Integer/toBinaryString n)
      (apply str (reverse (Integer/toBinaryString n)))))
(assert (bin-kaibun? 585 ))

(defn kaibun-coll[]
  (filter kaibun? (range 1 1000000 2)))
(defn bin-kaibun-coll [c] (filter bin-kaibun? c))

(println (reduce + (bin-kaibun-coll (kaibun-coll ))))

;左から右に桁を除いた数列
(defn remove-to-right [n]
  (loop [result [] i n]
    (if (= 0 (quot i 10) )
      (conj result i)
      (recur (conj result i)
        (Integer/parseInt (apply str (next (str i))))))))
(assert (= [3797, 797, 97, 7] (remove-to-right 3797)))

;右から左に桁を除いた数列
(defn remove-to-left [n]
  (loop [result [] i n]
    (if (= 0 (quot i 10) )
      (conj result i)
      (recur (conj result i)
        (Integer/parseInt (apply str (take (dec(count (str i)))
          (str i)) ))))))
(assert (= [3797, 379, 37, 3] (remove-to-left 3797)))

(defn all-prime? [c] (every? true? (map #(prime? %) c )))

(defn two-sided-primes [n]
  (if (and (prime? n)(all-prime? (remove-to-right n))
    (all-prime? (remove-to-left n))) n 0))
(assert (= 3797  (two-sided-primes 3797)))

(println (reduce +(take 11 (filter #(not (zero? (two-sided-primes % )))
  (iterate inc 23)))))

(defn pandigital9? [n]
  (cond
    (< n 123456789) false
    (> n 987654321) false
    :else (= (sort (str n)) '(\1 \2 \3 \4 \5 \6 \7 \8 \9))))
(assert (pandigital9? 192384576 ))

(defn concatenated-num [n m]
  (Long/parseLong (apply str (flatten (map #(str (* % n))
    (range 1 (inc m)))))))
(assert (= 192384576 (concatenated-num 192 3) ))
(assert (= 918273645 (concatenated-num 9 5) ))

(def num1 (filter #(pandigital9? %) (map #(concatenated-num % 5)
  (range 1 10)) ))
(def num2 (filter #(pandigital9? %) (map #(concatenated-num % 5)
  (range 10 100)) ))
(def num3 (filter #(pandigital9? %) (map #(concatenated-num % 4)
  (range 10 100)) ))
(def num4 (filter #(pandigital9? %) (map #(concatenated-num % 3)
  (range 100 1000)) ))
(def num5 (filter #(pandigital9? %) (map #(concatenated-num % 2)
  (range 1000 10000)) ))

(println (reduce #(max %1 %2) (flatten (conj num1 num2 num3 num4 num5))))

(defn result [max  coll]
  (let [x (first coll) c (count coll)]
  (cond
    (and (= 1 c)(= 0 (rem max x))) 1
    (= 1 c) 0
    :else (reduce + (map #(result  (- max (* x %)) (next coll))
      (range 0 (inc(quot max x))))))))

def result(max:Int, list:List[Int]):Int = list match {
    case x::Nil if(max % x == 0) =>1
    case x::Nil => 0
    case x::xs =>( 0 to max/x).map{i=>result(max-x*i, xs)}.sum
  }

static final int[] coins=[200,100,50,20,10,5,2,1];
static int result(int max, int index) {
    if (index==coins.length-1) {
        if (max%coins[index] == 0) 1 else 0
    }
    else {
        int count=0
        for(int i=max ;i>=0; i-=coins[index]) {
            count += result(i,index+1)
        }
        count
    }
}

; 約数を返す
(defn div-coll  [^long n]
  (def sqrt-n (Math/sqrt n))
  (loop [result [] i 1  ]
    (cond
      (= 1 n ) [1]
      (> i sqrt-n) result
      (= (double i) sqrt-n) (conj result i)
      (zero? (rem n i)) (recur (conj result i (quot n i))(inc i) )
      :else              (recur result (inc i)))))
;nの真の約数の和を返す
(defn proper-divisors[n]  (reduce +(rest(sort >(div-coll n)))))

;過剰数判定
(defn abundant? [n] (> (proper-divisors n) n))

(defn abundant-seq  [n] (filter abundant? (range n )))

(def abundant-seq (memoize abundant-seq)) 
(defn abundant-sum-set [^long n]
  (set(for [x ^long (abundant-seq n) y ^long (abundant-seq n)
   :when (>= x y)  :when  (>= n (+ x y))] (+ x y))))

(println (reduce +(difference (set(range 1 28124))
                                    (abundant-sum-set 28123 ))))

(defn f [n]
  (loop [i n f 9 ret-con []]
    (cond
      (= f 0) (conj ret-con 0)
      (= 0 (rem i (fact f)))  (recur (rem i (fact f)) (dec f)
         (conj ret-con 1))
      :else (recur (rem i (fact f)) (dec f)
         (conj ret-con (quot i (fact f)))))))

(defn delete [n coll]  (flatten (conj  (drop (inc n) coll)
 (take n coll) )))
(defn result [coll]
  (loop [result-coll [] base-coll [0 1 2 3 4 5 6 7 8 9] src-coll coll]
  (if (not( empty?  src-coll ))
      (recur (conj result-coll (nth base-coll (first src-coll)))
      (delete (first src-coll) base-coll) (rest src-coll))
      result-coll)))

(println (apply str(result (f 1000000))))

;フィボナッチ数を求める
(defn fibo []
  (map first (iterate (fn [[a b]] [b (+' a b)]) [0 1])))
;べき乗を求める
(defn pow [n m] (reduce *' (repeat m n)))
(println (count (take-while #(< % (pow 10 999)) (fibo))))

(defn prime? [m]
  (if (>= m 2)
    (loop [n 2]
      (if (<= n (Math/sqrt m))
        (cond
          (= (mod m n) 0) false
          :else  (recur (inc n)))
        true ))
    false))
(defn prime [a b]  (take-while prime? (map #(+ (* % %) (* a %) b)
  (range (dec b)))))

(println (prime 1 41))
(println (prime -79 1601))

;素数列の数を返す
(defn prime-count [a b] (if (not= () (prime a b))
   [(count (prime a b)) a b] [] ))
;大きいほうの値を返す。
(defn max-vec [n] (reduce #(if (> (first %1) (first %2)) %1 %2) n))
(def prime-list (take-while #(> 999 %)(prime 1 41)))
(def max-prime-coll  (max-vec (for [x (range -999 999) y prime-list ]
  (prime-count x y))))
(println (* (second max-prime-coll ) (last max-prime-coll )))

(def square-size (* 1001 1001))
(defn upper-right [n]
  (take-while #(>= n %) (map #(* % %) (iterate #(+ 2 %) 1) )))


(defn down-right [n]
  (loop [result [] count 1 offset 1]
    (let [tail (last result)]
    (cond
      (= count 1 ) (recur [1] (inc count) 2)
      (= count 2 ) (recur (conj result 3 ) (inc count) (+ offset 8))
      (> n tail)      (recur (conj result (+ tail offset)) (inc count)
       (+ offset 8) )
      :else (take-while #(> n %) result)))))


(defn down-left-make [i n] (+ n (* 4 (inc i))) )
(defn down-left [n] (take-while #(> n %) (map-indexed down-left-make
(upper-right n) )))

(defn upper-left-make [i n] (- n (* 2 i)) )
(defn upper-left [n] (map-indexed upper-left-make (upper-right n) ))
(println (- (+ (reduce + (upper-right square-size))
           (reduce + (upper-left square-size))
           (reduce +(down-left square-size))
           (reduce + (down-right square-size)) ) 2 ))

;べき乗を求める
(defn pow [n m] (reduce *' (repeat m n)))
(assert (= '(4 8 9 16 25 27 32 64 81 125 243 256 625 1024 3125)
   (sort (set(for [x (range 2 6) y (range 2 6)] (pow x y)))) ))

;べき乗を求める
(defn pow [n m] (reduce *' (repeat m n)))
(def pow (memoize pow))

;指定した一桁を取得する
(defn int-take1 [n i]
  (- (int ((vec (str n)) i)) 48 ))
(defn pow4 [n]
  (reduce + (map #(pow (int-take1 n %) 4) (range 0 4))))
(assert (= 1634 (pow4 1634)))
(assert (= 8208 (pow4 8208 )))
(assert (= 9474 (pow4 9474 )))

;数値を6ケタの文字列に変換
(defn pad0-string [n] (format "%06d" n))
;指定された一桁を取得する
(defn int-take1 [n i]
  (- (int ((vec (pad0-string n)) i)) 48 ))
(defn pow5 [n]
  (reduce + (map #(pow (int-take1 n %) 5) (range 0 6))))
(def pow5-col (indexed (map #(pow5 %) (range 2 (inc (* 6 (pow 9 5)) )))))

;indexとの差が2であるか
(defn eq2?[n]  (= (+ (first n) 2) (last n)))
(println  (reduce + (map #(second %)(filter eq2? pow5-col ))))

(def coins [200 100 50 20 10 5 2 1])

(defn coin-list [ max  coin-coll]
    (cond
      (and (= 1 (count coin-coll))(= 0 (rem max (first coin-coll)))) true
      (= 1 (count coin-coll)) false
      :else (map #(coin-list (- max (* (first coin-coll) %))
            (next coin-coll))
         (range 0 (inc(quot max (first coin-coll)))))))
(println (count (filter #(true? %)(flatten(coin-list  200 coins)))))

(defn delete [n coll]  (flatten (conj (drop (inc n) coll) (take n coll) )))
(assert (= '(1 2 3 5 6) (delete 3 [1 2 3 4 5 6])))

(defn result-num [coll]
  (loop [result-num-coll [] base-coll [1 2 3 4 5 6 7 8 9] src-coll coll]
    (if (not( empty?  src-coll ))
      (recur (conj result-num-coll (nth base-coll (first src-coll)))
          (delete (first src-coll) base-coll) (rest src-coll))
    result-num-coll)))
(assert (= (result-num [0 0 0 0 0 0 0 0 0] ) [1 2 3 4 5 6 7 8 9] ))

(defn num-list[]
  (for [a (range 9) b (range 8) c (range 7) d (range 6) e (range 5)
       f (range 4) g (range 3) h (range 2) ]
    (result-num [a b c d e f g h 0] )))

(defn coll-to-num [coll]
  (apply + (map #(* %1 (expt 10 %2)) (reverse coll) (iterate inc 0))))
(defn check144? [coll]
  (def a (first  coll))
  (def b (take 4 (drop 1 coll)))
  (def c (drop 5 coll))
  (= (* a (coll-to-num b)) (coll-to-num c)))
(defn check233? [coll]
  (def a (take 2 coll))
  (def b (take 3 (drop 2 coll)))
  (def c (drop 5 coll))
 (= (* (coll-to-num a) (coll-to-num b)) (coll-to-num c)))
(assert (true? (check233? [3 9 1 8 6 7 2 5 4])))

; チェック関数実行後、trueなら積を返す
(defn result-mul [coll]
  (if (or (check233? coll) (check144? coll) )
     (coll-to-num (drop 5 coll)) 0 ))
(println (reduce + (set (filter #(not(zero? %))
     (map  #(result-mul %) (num-list))))))

(def array ( 8  2 22 97 38 …

(def tate (last (sort(map #(mul4 20 %)(range 0 (- 400 60))))))
(def yoko (last (sort(map #(mul4 1 %)(range 0 (- 400 3))))))
(def naname-migi (last (sort(map #(mul4 21 %)(range 0 (- 400 63))))))
(def naname-hidari (last (sort(map #(mul4 19 %)(range 3 (- 400 57 3))))))

(println (last (sort [tate yoko naname-hidari naname-migi ])))

(defn tri [n] (quot (* n (inc n)) 2))

(println (map #(tri %)(range 1 10000)))

(defn div-count [n]
  (def sqrt-n (Math/sqrt n))
  (loop [i 1 ret 0]
    (cond
      (> i sqrt-n) ret
      (= i sqrt-n) (inc ret)
      (zero? (rem n i)) (recur (inc i) (+ ret 2))
      :else              (recur (inc i) ret))))

(println (map div-count [1 3 6 10 15 21 28]))

(println (nth (map tri (iterate inc 1))  (count(tri-div-coll 500)) ))

user=> (class 53503534226472524250874054075591789781264330331690)
clojure.lang.BigInt

user=> (class 1)
java.lang.Long

user=> (class (int 1))
java.lang.Long

(def col [37107287533902102798797998220837590246510135740250
          46376937677490009712648124896970078050417018260538
          74324986199524741059474233309513058123726617309629
          91942213363574161572522430563301811072406154908250
（略)
(println (apply str (take 10 (str (reduce + col)))))

#include <stdio.h>
    long double array[]= {
    0.37107287533902102798797998220837590246510135740250,
    0.46376937677490009712648124896970078050417018260538,
    0.74324986199524741059474233309513058123726617309629,
(略）

    0.53503534226472524250874054075591789781264330331690
};

void main(int argc,char**argv) {
    int i;
    long double count = 0.0;
    for ( i=0 ; i<100 ; i++ ) {
        count += array[i];
    }
    printf("%10Le\n",count);
}

(defn collatz  [n]
  (loop [result [] x (int n)]
    (cond
     (= 1 x) (conj result 1)
     (even? x) (recur (conj result x) (quot x 2))
     (odd?  x) (recur (conj result x) (+ 1 (* 3 x))))))
(println  (collatz 13))

(defn collatz-count [n] (count (collatz n)))

;1から始まるインデックス付きのvecを返す。
(defn indexed  [c] (map vector (iterate inc 1) c))
;大きいほうの値を返す。
(defn max-vec [n] (reduce #(if (> (last %1) (last %2)) %1 %2) (indexed n)))

(println (max-vec (map #(collatz-count %)(range 1 1000000))))

(defn fact[n] (reduce *(range 1N (inc n))))

(defn c[n] (/ (fact (* 2 n)) (* (fact n) (fact n))))
(println (c 20))

(defn pow [n m] (reduce *' (repeat m n)))
(println (str(pow 2 1000)))

(defn str-add [s] (reduce + (map #(- (int % ) 48)(vec (seq s)))))
(println (str-add (str(pow 2 1000))))

(defn path [low col]
  (let [me (nth (nth triangle low) col)]
  (cond
    (= low 0) me
    (= low col)(+ me (path (dec low)(dec col)))
    (= col 0)  (+ me (path (dec low)col))
    :else (max (+ me (path (dec low)col))(+ me (path (dec low)(dec col)))
    ))))
(def path (memoize path))

(println (reduce max (map #(path 14 %)(range 14))))

(println(str-add(str (fact 100))))

(defn div-coll [n]
  (def sqrt-n (Math/sqrt n))
  (loop [result [] i 1 ]
    (cond
      (= 1 n ) [1]
      (> i sqrt-n) result
      (= (double i) sqrt-n) (conj result i)
      (zero? (rem n i)) (recur (conj result i (quot n i))(inc i) )
      :else              (recur result (inc i)))))

(println (sort(rest(sort >(div-coll 220)))))

(defn d[n]  (reduce +(rest(sort >(div-coll n)))))
(def d (memoize d))

(defn indexed  [c] (map vector (iterate inc 1) c))
(def col-a (indexed (map #(d %) (range 1 10000))))
(defn x-indexed  [c] (map vector c (iterate inc 1)))
(def col-b (x-indexed (map #(d %) (range 1 10000))))
;シーケンスから引数で与えられたターゲットと同じものを返す
(defn find-seq [src target] (first (filter  #(= target %) src)))
(def coll-c (map #(find-seq col-a %) col-b))

(def ans-col (filter #((comp not =) (first %)(last %)) coll-c))
(println (reduce +(map #(first %) ans-col )))

(use '[clojure.contrib.duck-streams :only (reader)])
(def names-array(with-open [rdr (reader "names.txt")]
                  (sort(re-seq #"\w+" (str(line-seq rdr))))))

(println (nth names-array  937))
(println (nth names-array  938))

COLIN
COLLEEN

;スコアを求める map-indexedに合わせて、引数はインデックスが先
(defn score [n s] (* (inc n) (reduce + (map #(- (int % ) 64)(seq s)))))

(println (score 0 (nth names-array 937)))

(println (reduce +(map-indexed score names-array )))

(defn prime? [m]
     (loop [n 2]
       (if (<= n (Math/sqrt m))
         (cond (= (mod m n) 0) false
             :else  (recur (inc n)))
         true )))
   (println (reduce * (filter prime? (range 1 20))))

(defn not-prime?
      [n] (not (prime? n)))
   (println (filter not-prime? (range 1 20)))

(defn every-divisible? [num divs]
      (every? #(zero? (rem num %)) divs))

(println (take 10 (map #(* 9699690 %) (iterate inc 1))))

(defn common-multiple [n coll]
      (filter #(every-divisible? % coll)   (map #(* n %) (iterate inc 1))))

(println
      (first
      (common-multiple
               (reduce * (filter prime? (range 1 20)))
               (vec (filter not-prime? (range 1 20)))
               )))

(def prime-map (group-by prime? (range 1 20)) ) 
    (println
      (first
        (common-multiple
          (reduce * (prime-map true))
          (prime-map false)
          )))

(def mm  (reduce + (map #(* % %) (range 1 101))))

(def nn (reduce + (range 1 101)))

(println (- (* nn nn) mm))

(println (last (take 10001 (filter prime? (iterate inc 2)))))

(def col [7 3 1 6 7 1 7 6 5 3 1 3 3 0 6 2 4 9 1 9 2 2 5 1 1 9 
               6 7 4 4 2 6 5 7 4 7 4 2 3 5 5 3 4 9 1 9 4 9 3 4
    以下略

(defn mul5 [ n ]
      (reduce * (take 5 (drop n col))))

(println (last(sort (map mul5 (range 1000) ))))

(defn pytha? [n a b c]
      (and
        (= n (+ a b c))
        (= (* c c) (+ ( * a a) (* b b)))))

(defn x-pytha [n a b c]
      (cond
        (pytha? n a b c) [n a b c]))

(println
      (filter coll? 
         (for [x (range 1 10 ) y (range 1 10) z (range 1 10)] 
                                           (x-pytha 12 x y z))))

(println
      (first 
        (filter coll? (for [x (range 1 1000 ) y (range 1 1000)] 
          (x-pytha 1000 x y (- 1000 x y)))))))

(println
      (reduce * (rest (first 
        (filter coll? (for [x (range 1 1000 ) y (range 1 1000)] 
           (x-pytha 1000 x y (- 1000 x y))))))))

(defn prime? [m]
      (loop [n 2]
        (if (<= n (Math/sqrt m))
          (cond
            (> 2 n) false
            (= (mod m n) 0) false
            :else  (recur (inc n)))
          true )))
    (println (reduce + (filter prime? (range 2 2000000))))

import com.google.common.base.CharMatcher
    import com.google.common.base.Splitter
    import org.apache.commons.lang3.math.NumberUtils
    import static com.google.common.collect.Lists.newArrayList

    class Problem11 {
        static String numsStr=
            "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 " +
            "49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 " +
            "81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 " +
            "52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 " +
            "22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 " +
            "24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 " +
            "32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 " +
            "67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 " +
            "24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 " +
            "21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 " +
            "78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 " +
            "16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 " +
            "86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 " +
            "19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 " +
            "04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 " +
            "88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 " +
            "04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 " +
            "20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 " +
            "20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 " +
            "01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48"
        public static void main(String[] args) {
            int[] nums = str2int(numsStr)
            println ((makeTate(nums)+makeYoko(nums)+makeNanameMigi(nums)+
                          makeNanameHidari(nums)).max())
        }

        static str2int = {String str ->
            CharMatcher matcher = CharMatcher.WHITESPACE
            Iterable splits = Splitter.on(matcher).split(str);
            List list = newArrayList()
            splits.each {list.add(NumberUtils.toInt(it))}

            return list
        }
        public static int[] getArray(){
            return str2int(numsStr)
        }

        static makeTate = {int[] nums ->
            List list = newArrayList()
            for (int i = 0; i < nums.length - 60; i++) {
                int mul = nums[i] * nums[i+20]*nums[i+40]*nums[i+60]
                list.add(mul)
            }
            return list
        }

        static makeYoko = {int[] nums ->
            List list = newArrayList()
            for (int i = 0; i < nums.length - 3; i++) {
    //            if (i % 20 >= 17) continue;
                int mul = nums[i]*nums[i+1]*nums[i+2]*nums[i+3]
                list.add(mul)
            }
            return list
        }

        static makeNanameMigi = {int[] nums ->
            List list = newArrayList()
            for (int i = 0; i < nums.length - 63; i++) {
    //            if (i % 20 >= 17) continue;
                int mul = nums[i]*nums[i+21]*nums[i+42]*nums[i+63]
                list.add(mul)
            }
            return list
        }

        static makeNanameHidari = {int[] nums ->
            List list = newArrayList()
            for (int i = 3; i < nums.length - 57; i++) {
    //            if (i % 20 <= 3) continue;
                int mul = nums[i]*nums[i+19]*nums[i+38]*nums[i+57]
                list.add(mul)
            }
            return list
        }
    }

Optional foo(String  str) {
    try {
        return Optional.of(Integer.parseInt(str));
    } catch(NumberFormatException e) {
        return Optional.absent();
    }
}

System.out.println(foo("123"));
System.out.println(foo("abc"));

import com.google.common.base.Optional;

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import static com.google.common.base.Optional.of;

public class OptionalSample {
    public static void main(String[] args ){
        Map<Integer,Optional<String>> map = makeMap();
        System.out.println(show(map.get(0)));
        System.out.println(show(map.get(1)));
        System.out.println(show(map.get(2)));
        System.out.println(show(map.get(-1)));

    }
    private static Map<Integer,Optional<String>> makeMap() {
        return Collections.unmodifiableMap(
                new HashMap<Integer,Optional<String>>() {
            {
                put(0, of("foo"));
                put(1,Optional.<String>absent());
                put(2, of("bar"));
            }
        });
    }

    private static String show(Optional<String> opt) {
        return opt== null ? "?" :opt.or("no value");
    }
}

(defn muitiple-3-5? [n]
 (cond
         (= (mod n 3) 0) true
         (= (mod n 5) 0) true
         :else false))

(println (reduce + (filter muitiple-3-5? (range 10))))

(println (reduce + (filter muitiple-3-5? (range 1000))))

(println (take 12 (fibo)))

(println (take-while #(<= % 4000000) (fibo)))

(println (filter even? (take-while #(<= % 4000000) (fibo))))

(println (reduce + (filter even? (take-while #(<= % 4000000) (fibo)))))

(defn prime? [m]
  (loop [n 2]
    (if (<= n (Math/sqrt m))
      (cond (= (mod m n) 0) false
          :else  (recur (inc n)))
      true )))
(println (filter prime? (range 1 60)))

(defn prime-factor [n]
  (filter #(= (mod n  %) 0)(filter prime? (range 2 (Math/sqrt n )))))

(println (prime-factor 13195))

(println (last(prime-factor 600851475143)))

(defn kaibun? [n]
  (= (str n) (apply str (reverse (str n)))))

(println (for [x (range 10 100) y (range 10 100)] (* x y)))

(println (last(sort (filter kaibun?
  (for [x (range 100 1000) y (range 100 1000)] (* x y))))))

(defn printx [n]
  (println "Hello World!")
  (cond
   (= n 1) nil
   n (printx (- n 1))))
(printx 5)

(defn printx2 [m]
  (loop [n m]
    (if (> n 0)
      (do (println "Hello World!")
      (recur (dec n))))))
(printx2 5)

(filter even? (range 10))

(defn prime? [m]
  (loop [n 2]
    (if (<= n (Math/sqrt m))
      (cond (= (mod m n) 0) false
             n  (recur (inc n)))
        true )))

(println (filter prime? (range 100)))

(defn leap? [y]
  (cond (= (mod y 400) 0) "leap year"
         (= (mod y 100) 0) "normal year"
         (= (mod y 4)   0) "leap year"
         y "normal year"))

(defn lcg [x a b m]
  (map #(/ % m) ;P103
          (rest ;P92
             (iterate (fn [n] (mod (+ b (* a n)) m)) x)))) ;P138

(println (take 100 (lcg 12345 997 1 65536.0)))

(println (/ (reduce + (take 100 (lcg 12345 997 1 65536.0))) 100.0))

(import '(java.io BufferedReader InputStreamReader ))

(defn ans [a n]
  (cond (> a n) "小さすぎます"
        (< a n) "大きすぎます"
        n "正解です"))

(let [answer (rand-int 100)]
(try
(with-open [reader (BufferedReader. (InputStreamReader. (System/in)))]
  (doseq [line (take-while (comp not nil?) (repeatedly #(.readLine reader)))]
    (println (ans answer (Integer/parseInt line)))))
(catch Exception e nil)
(finally (println "終了します"))))

(defn fizz-buzz [n]
 (map #(cond (=(mod % 15) 0) "FizzBuzz"
         (= (mod % 3) 0) "Fizz"
         (= (mod % 5) 0) "Buzz"
         :else %) (range 1 n))) ; P133

(println (fizz-buzz 100))

public class ShopListDemo extends ListActivity {
    private ArrayList<ShopInfo> arrayInfo;
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        arrayInfo=readFile();
        ArrayAdapter<ShopInfo> adapter=new ArrayAdapter<ShopInfo>(this,android.R.layout.simple_expandable_list_item_1, arrayInfo);
        setListAdapter(adapter);
    }


    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);

        ShopInfo info=arrayInfo.get(position);
        String sUrl=info.getUrl();
        showWeb(sUrl);
    }

    private void showWeb(String url){
        Intent intent=new Intent(
                "android.intent.action.VIEW",
                Uri.parse(url));
        startActivity(intent);
    }

    private ArrayList<ShopInfo> readFile() {
        ArrayList<ShopInfo> shopArray=new  ArrayList<ShopInfo> ();

        AssetManager as = getResources().getAssets();
        try {
            InputStream is = as.open("shop.txt");
            BufferedReader br= new BufferedReader(new InputStreamReader(is));

            String sShop;
            while((sShop = br.readLine())!= null) {
                String[] shopData=sShop.split(",",3);
                if (shopData.length >= 3){
                    ShopInfo info= new ShopInfo(shopData[0],shopData[1],shopData[2]);
                    shopArray.add(info);
                }else {
                    Toast.makeText(this, "不正なデータです", Toast.LENGTH_LONG).show();
                }
            }
        }catch(IOException e){
            e.printStackTrace();
        }
        return shopArray;
    }
}

public class ShopInfo {
    private String name=null;
    private String address=null;
    private String url=null;
    
    ShopInfo (String name,  String address,String url){
        this.name=name;
        this.address=address;
        this.url=url;
    }
    
    public String getName(){
        return name;
    }

    public String getAddress(){
        return address;
    }
    public String getUrl(){
        return url;
    }
    
    public String toString(){
        return name;
    }
}