Euler : Problem 17

Posted by TAKAIY On 2011年4月24日日曜日 0 コメント

パターンがあるので、それを数えるのがいいかなと思ったんだけど、それだと、手で計算できちゃうので、なんならということで、1000までの数字を読み下ろす関数を作ってみた。

user> (writedown 999)
"nine hundred and ninety nine"

ということで、あえて力ずく。

関係ないけど、four で fourteen なのに forty なんだね。「u」はどこへいっちゃうんだろ。
この問題を解くまで気づかなかったというか、忘れていたというか、ねぇ。

;;
;; Problem 17 : 2011/4/22
;; "Elapsed time: 106.548179 msecs"
(def number-table
'{ 1 "one"
2 "two"
3 "three"
4 "four"
5 "five"
6 "six"
7 "seven"
8 "eight"
9 "nine"
10 "ten"
11 "eleven"
12 "twelve"
13 "thirteen"
14 "fourteen"
15 "fifteen"
16 "sixteen"
17 "seventeen"
18 "eihgteen"
19 "nineteen"
20 "twenty"
30 "thirty"
40 "forty"
50 "fifty"
60 "sixty"
70 "seventy"
80 "eighty"
90 "ninety"
100 "hundred" })

(defn writedown-tys [n]
(cond (<= n 0) nil
(< n 20)
(number-table n)
:else
(apply str (interpose " "
(list (number-table (* 10 (floor (/ n 10))))
(number-table (rem n 10)))))))

(defn writedown-hdrs [n]
(cond (<= n 0) nil
:else (apply str (interpose " "
(list (number-table n)
"hundred")))))

(defn writedown [n]
(if (= n 1000)
"one thousand"
(let [hundreds (floor (/ n 100))
tys (rem n 100)]
(apply str
(interpose " "
(filter #(not (nil? %))
(list
(writedown-hdrs hundreds)
(if (and (> hundreds 0) (> tys 0))
"and"
nil)
(writedown-tys tys))))))))


(loop [nums (range 1 1001) total 0]
(if (empty? nums)
total
(recur (rest nums)
(+ total
(.length (.replace (writedown (first nums)) " " ""))))))

;;
READ MORE

Euler : Problem 16

Posted by TAKAIY On 0 コメント

2の1000乗に出てくる数字を全部足すといくつ? って問題です。
とりあえず作ってみたら動いちゃったので、そのまま。

計算して、各桁足してます。
芸が無い。


;;
;; Problem 16 : 2011/4/22
;; "Elapsed time: 16.475557 msecs"
(use 'clojure.contrib.math)

(loop [num (expt 2 1000)
result 0]
(if (< num 1)
result
(recur (floor (/ num 10))
(+ result (rem num 10)))))

;;
READ MORE

Euler : Problem 15

Posted by TAKAIY On 0 コメント

碁盤の目の通路の問題です。
まあ、普通にやるんだったら、組み合わせで解くんだけれども、やってみたら、すごく時間がかかる。

んで、交差点ごとの数を数えあげる方法を実装してみた。
動的計画法にあたるかな?

3x3だと

1 1 1
1 2 3
1 3 6

てな感じ。

実際の計算で使っているのは update-child と 最後のループのところだけ。
あとは、データ作成のためのもの。

;;
;; Problem 15 : 2011/4/22
;;"Elapsed time: 32.748855 msecs"

;; too long time
(use 'clojure.contrib.combinatorics)
(count (combinations (range 40) 20))

;; grid parameter
(def *grid-x-max* 21)
(def *grid-y-max* 21)

;; data structure
;; [x y] {:val :next-node }
(defstruct grid-node
:val :next-node)

;; create child node list
(defn get-grid-child [x y]
(filter #(not (nil? %))
(vector (if (< x (dec *grid-x-max*))
[(inc x) y])
(if (< y (dec *grid-y-max*))
[x (inc y)]))))

;; create new *nodes* table
(def *nodes*
(loop [val-list (for [i (range *grid-x-max*) j (range *grid-y-max*)]
(let [data (struct grid-node (atom 0)(get-grid-child i j))]
[[i j] data]))
res-map {}]
(if (empty? val-list)
res-map
(recur (rest val-list)
(assoc reset!
(first (first val-list))
(second (first val-list)))))))

;; display *nodes* :val data
(defn disp-node-table [table]
(partition *grid-x-max*
(for [i (range *grid-x-max*) j (range *grid-y-max*)]
@(:val (table [i j])))))

;; update child
(defn update-child [parent-val child-list]
(if (not (empty? child-list))
(let [target-child (first child-list)]
(do
(swap! (:val (*nodes* target-child)) #(+ parent-val %))
(update-child parent-val (rest child-list))))))


;; set initial val
(reset! (:val (*nodes* [0 0])) 1)

;; calc all nodes
(loop [nodes-in-my-hand [[0 0]]]
(if (not (empty? nodes-in-my-hand))
(let [target (first nodes-in-my-hand)
child-node (:next-node (*nodes* target))]
(do
(update-child @(:val (*nodes* target)) child-node)
(recur (distinct (into (apply vector (rest nodes-in-my-hand)) child-node)))))))

;;
READ MORE

Euler : Problem 14

Posted by TAKAIY On 2011年4月16日土曜日 0 コメント
角谷の予想(コラッツの予想)の問題です。
この問題、中学生ぐらいのころに手計算でノートいっぽいに数字を書いてみたりしてたので、ちょっとなつかしい。

1から逆にたどって系統樹を作ってやればいいかなと思ったんだけど、「途中で百万を超えてもかまわない」という条件があるので、逆にたどるのは戻ってくる可能性を考慮しなければならないということなんだけれど、そこのところがうまく表現できなくて断念。
1から順にしらべることになっちゃいました。

;;
;; Problem 14 : 2011/4/15
;; "Elapsed time: 54894.586881 msecs"

;; momoise : from clojure.org
(defn memoize [f]
(let [mem (atom {})]
(fn [& args]
(if-let [e (find @mem args)]
(val e)
(let [ret (apply f args)]
(swap! mem assoc args ret)
ret)))))


;; hotpo step count
(defn hotpo-count
([n] (hotpo-count n 0))
([n count]
(cond (= n 1) (inc count)
(even? n) (hotpo-count (/ n 2) (inc count))
:else (hotpo-count (+ (* n 3) 1) (inc count)))))

(def hotpo-count (memoize hotpo-count))


(loop [n 1 max-list [0 0]]
(if (> n 1000000)
max-list
(let [hotpo (hotpo-count n)]
(if (< (nth max-list 1) hotpo)
(recur (inc n) [n hotpo])
(recur (inc n) max-list)))))
;;
結局つかわなかった関数
;;
(defn half-or-triple-plus-one [n]
(if (= n 1) (list 1)
(let [next-num (if (even? n) (/ n 2) (+ (* n 3) 1))]
(lazy-seq
(cons n (half-or-triple-plus-one next-num))))))

(defn hotpo-prev-node
([] (rev-ho31 1))
([n]
(let [tpo (/ (- n 1) 3)]
(if (or (<= tpo 1)
(not (zero? (mod (- n 1) 3))))
(list (* n 2))
(list (* n 2)
(/ (- n 1) 3))))))

;;
READ MORE

Euler : Problem 13

Posted by TAKAIY On 2011年4月14日木曜日 0 コメント
でかい数の足し算。

前の13桁だけ足して答を出した。 まあ、もとのデータを文字列で読んじゃったから、なんのことはない。
;;
;; Problem 13 : 2011/4/14
;; "Elapsed time: 4.569016 msecs"

(reduce + (map #(new BigInteger (apply str (take 13 %))) target-list))

(def target-list [
"37107287533902102798797998220837590246510135740250"
"46376937677490009712648124896970078050417018260538"
"74324986199524741059474233309513058123726617309629"
"91942213363574161572522430563301811072406154908250"
"23067588207539346171171980310421047513778063246676"
"89261670696623633820136378418383684178734361726757"
--- crop ---
"77158542502016545090413245809786882778948721859617"
"72107838435069186155435662884062257473692284509516"
"20849603980134001723930671666823555245252804609722"
"53503534226472524250874054075591789781264330331690"])

;;

READ MORE

Euler : Problem 12

Posted by TAKAIY On 0 コメント
三角数に関する問題。 だけど、三角数の性質とは関係ないのかな?

始めは逆の探索で、約数が500個以上ある数を求めて、それが三角数かどうか確認するって方法をやろうとしたんだけど、挫折した。三角数かどうか確認する関数も作ったけど、使わなかった。挫折した方法のときに必要だね。
結局、小さいほうから全調べ方式。

いつかリベンジしてやる。

factorsは前につくったやつで、そこで素数の一覧も使ってる。
時間には素数を作る時間は入ってない。

三角数を作る方法を2通り試したけど、とくに時間は変らないみたい。



;;
;; Problem 12 : 2011/4/14
;; "Elapsed time: 1954.309557 msecs"
;; pre defined func : factors [n]
;; (foctors 12) => (2 2 3)


;; count divisor
;; when n = f1^a * f2^b * ... * fn^x
;; divisor count = (a+1)*(b+1)* ... (x+1)
(defn count-divisor [n]
(let [ ftr (factors n)]
(reduce *
(for [tgt (distinct ftr)]
(inc (count (filter #(= % tgt) ftr)))))))


;; nth triangle num
(defn nth-triangle-num [n]
(/ (* n (inc n)) 2))


(loop [n 1]
(let [triangle-num (nth-triangle-num n)
divisor-num (count-divisor triangle-num)]
(if (> divisor-num 500)
(list n triangle-num divisor-num)
(recur (inc n)))))

;; triangle num seq
;;"Elapsed time: 1933.932106 msecs"
(defn triangle-num
([] (tri 2 1))
([n sum]
(lazy-seq
(cons sum (tri (inc n) (+ n sum))))))

(loop [triangle-num-list (triangle-num)]
(if (> (count-divisor (first triangle-num-list)) 500)
(first triangle-num-list)
(recur (rest triangle-num-list)))))


;; did not use
;; check triangle num
(defn triangle-num? [n]
(let [double-square-int (int (sqrt (* n 2)))
num-1 double-square-int
num-2 (inc num-1)]
(= (/ (* num-1 num-2) 2) n)))

;;

READ MORE

Google Code Jam

Posted by TAKAIY On 2011年4月13日水曜日 0 コメント
Project Eulerはちょっと前から知ってたけれど、Google Code Jamはしらなかった。

やってみようかなぁ。
READ MORE

KINESIS キーボードのマッピング

Posted by TAKAIY On 0 コメント
別のブログから移動。 Kinesisのキーボードのリマップの情報。

ただの自分用メモ

READ MORE

Euler : Problem 11

Posted by TAKAIY On 2011年4月11日月曜日 0 コメント
コンセプトはすぐに思いついたんだけど、実現するのに時間がかかってしまった。
Clojureにもだいぶ慣れてきたんだけどねぇ。

あと、しばらく「5つ」だと思いこんでやってて、結果が合わなくて、なんでだー!ってしばらく騒いでしまった。 あほ。

17msec。 いいんじゃない?
でも、最後の計算のところがちょっときれいじゃないなぁ。


;; Problem 11  : 2011/4/11
;; "Elapsed time: 16.602669 msecs"
(def target-grid
[[ 8 2 22 97 38 15 0 40 0 75 4 5 7 78 52 12 50 77 91 8]
[49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 4 56 62 0]
[81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 3 49 13 36 65]
[52 70 95 23 4 60 11 42 69 24 68 56 1 32 56 71 37 2 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 3 45 2 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 2 62 12 20 95 63 94 39 63 8 40 91 66 49 94 21]
[24 55 58 5 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72]
[21 36 23 9 75 0 76 44 20 45 35 14 0 61 33 97 34 31 33 95]
[78 17 53 28 22 75 31 67 15 94 3 80 4 62 16 14 9 53 56 92]
[16 39 5 42 96 35 31 47 55 58 88 24 0 17 54 24 36 29 85 57]
[86 56 0 48 35 71 89 7 5 44 44 37 44 60 21 58 51 54 17 58]
[19 80 81 68 5 94 47 69 28 73 92 13 86 52 17 77 4 89 55 40]
[ 4 52 8 83 97 35 99 16 7 97 57 32 16 26 26 79 33 27 98 66]
[88 36 68 87 57 62 20 72 3 46 33 67 46 55 12 32 63 93 53 69]
[ 4 42 16 73 38 25 39 11 24 94 72 18 8 46 29 32 40 62 76 36]
[20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 4 36 16]
[20 73 35 29 78 31 90 1 74 31 49 71 48 86 81 16 23 57 5 54]
[ 1 70 54 71 83 51 54 69 16 92 33 48 61 43 52 1 89 19 67 48]])

;; add all 4 series
(defn product-of-4-line [target-lst]
(loop [[n1 n2 n3 n4 :as tgt] target-lst
res []]
(if (< (count tgt) 4)
res
(recur (rest tgt) (conj res (* n1 n2 n3 n4) )))))

(defn product-of-4-grid [tgt-grid]
(map #(product-of-4-line %) tgt-grid))

;; test data
(def target-grid
[[ 1 2 3 4]
[11 12 13 14]
[21 22 23 24]
[31 32 33 34]])

;; transpose
;; -->
;; ((1 11 21 31)
;; (2 12 22 32)
;; (3 13 23 33)
;; (4 14 24 34))
;; function ver
(defn transpose-grid [grid]
^{:doc "Transpose grid. "}
(apply map list grid))
;; macro ver
(defmacro transpose-grid [grid]
`(map list ~@grid))


;; stagger
;; right-->
;; ((1 2 3 4 x x x)
;; (x 11 12 13 14 x x)
;; (x x 21 22 23 24 x)
;; (x x x 31 32 33 34))
;; left-->
;; (( x x x 1 2 3 4)
;; ( x x 11 12 13 14 x)
;; ( x 21 22 23 24 x x)
;; (31 32 33 34 x x x))
(defn stagger-right [grid]
(let [add-x (fn [n m lst] (concat (repeat n 'x) lst (repeat m 'x)))]
(for [line-num (range (count grid))]
(add-x line-num (dec (- (count grid) line-num)) (nth grid line-num)))))

(defn stagger-left [grid]
(let [add-x (fn [n m lst] (concat (repeat n 'x) lst (repeat m 'x)))]
(for [line-num (range (count grid))]
(add-x (dec (- (count grid) line-num)) line-num (nth grid line-num)))))

;; remove-x
;; ( x x 11 12 13 14 x) -> (11 12 13 14)
(defn remove-x [coll]
(remove #(= % 'x) coll))

(apply max
(map #(apply max %)
(filter #(not (= % []))
(concat
(product-of-4-grid target-grid)
(product-of-4-grid (transpose-grid target-grid))
(product-of-4-grid
(map #(remove-x %)
(transpose-grid (stagger-right target-grid))))
(product-of-4-grid
(map #(remove-x %)
(transpose-grid (stagger-left target-grid))))))))
;;


READ MORE

Euler : Problem 10

Posted by TAKAIY On 0 コメント
10番目に到達です。
そしてまた素数の問題です。

前に作ったやつを使ったら、あっさりとオーバーフローしたので、やっぱり作りなおし。
こんどはatomを使って作ったデータを保存してみた。
これならかなりでかいのでも大丈夫でしょう。

13秒かかりました。
遅いのか? 速いのか?

;;
;; Problem 10 : 2011/4/9
;; "Elapsed time: 13662.498447 msecs"
(def *prime-list* (atom []))

(defn is-prime? [target]
(loop [plist @*prime-list*]
(let [check-num (first plist)]
(cond (empty? plist) true
(> check-num (Math/sqrt target)) true
(zero? (rem target check-num)) false
true (recur (rest plist))))))

(defn create-prime-list-under [n]
(loop [target 2]
(if (>= target n)
true
(if (is-prime? target)
(do
(reset! *prime-list* (conj @*prime-list* target))
(recur (inc target)))
(recur (inc target))))))

(do
(reset! *prime-list* [])
(create-prime-list-under 2000000)
(reduce + @*prime-list*))


;;


READ MORE

Euler : Problem 9

Posted by TAKAIY On 2011年4月9日土曜日 0 コメント

三平方の定理の問題だぁ。

足して1000になる、小さい順になった数列全部を作って、後はしらみつぶし。

しらみつぶしが多いなぁ。
どうしたもんか。

;;
;; Problem 9 : 2011/4/8
;; a^2 + b^2 = c^2
;; a + b + c = 1000

(use 'clojure.contrib.math)

(defn third+1 [n]
(if (zero? (rem n 3))
(inc (/ n 3))
(inc (int (/ n 3)))))

(defn half+1 [n]
(if (zero? (rem n 2))
(inc (/ n 2))
(inc (int (/ n 2)))))

(let [max-num 1000]
(filter #(not (= % nil))
(for [a (range 1 (third+1 max-num))
b (range (inc a) (half+1 (- max-num a)))]
(let [c (- max-num (+ a b))]
(if (= (+ (expt a 2) (expt b 2))
(expt c 2))
(list (* a b c) [a b c]))))))

;;
READ MORE

Euler : Problem 8

Posted by TAKAIY On 0 コメント

でかい数列の問題。
文字列で読みこんで、1桁の数のリストにして処理。
0のところで分割するとか、構成している数をチェックするとかやってみたらよさそうなことは思い浮かぶけれど、たいして速くならないような気がしたので、力ずくでやった。

;;
;; Problem 8 : 2011/4/8

(def target1000num
"73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450")

(defn char-to-num [ch]
(Character/digit ch 10))

(def target-num-list (map #(char-to-num %)
(filter #(not (= % \newline)) target1000num)))

(loop [tgt-num-list (rest target-num-list)
result-list (list (reduce * (take 5 target-num-list))
(take 5 target-num-list))]
(if (> 5 (count tgt-num-list))
result-list
(let [next-5 (take 5 tgt-num-list)
product-of-5 (reduce * next-5)]
(if (< product-of-5 (first result-list))
(recur (drop 1 tgt-num-list) result-list)
(recur (drop 1 tgt-num-list) (list product-of-5 next-5))))))

;;
READ MORE

Euler : Problem 7

Posted by TAKAIY On 0 コメント

また出た。素数。

素数かどうかの判定を作った。
見つけた素数を取っておいて、判定に使うようにした。これいいんじゃないかなぁ。
10000までは作れた。 その後はわからない。

;; Problem 7  : 2011/4/8
(defn is-prime-sub? [target prm-list]
(zero? (count (filter #(zero? (rem target %))
(take-while (< % (Math/sqrt target) prm-list))))))

(defn find-prime [n]
(loop [prime-list '(2 3 5)
target 6]
(if (>= (count prime-list) n)
prime-list
(if (is-prime-sub? target prime-list)
(recur (concat prime-list (list target)) (inc target))
(recur prime-list (inc target))))))

(drop 10000 (find-prime 10001))

;;

READ MORE

Euler : Problem 6

Posted by TAKAIY On 0 コメント
これは書いてあるとおりにやっただけ。
こんな処理はClojureならではかなぁ。

;;
;; Problem 6 : 2011/4/7
;
(- (expt (reduce + (range 1 101)) 2)
(reduce + (map #(expt % 2) (range 1 101))))

;;
READ MORE

Euler : Problem 5

Posted by TAKAIY On 0 コメント
また出てきた素数。
素因数分解して解の員数を出して解いているんだけど、素数列をその度に作っているので非効率。
今後のためにも、素数列は取っておけるようにしようかなぁ。

;;
;; Problem 5 : 2011/4/7
;; prime-nums-under : defined above

(defn factors [n]
;; (foctors 12) => (2 2 3)
(loop [factor-list ()
target n
prime-list (prime-nums-under target)]
(if (or (= target 1) (empty? prime-list))
(reverse factor-list)
(let [one-prime (first prime-list)]
(if (zero? (rem target one-prime))
(recur (cons one-prime factor-list) (/ target one-prime) prime-list)
(recur factor-list target (rest prime-list)))))))


(defn fusion
;; (fusion '(2 3 3) '(3 4 4)) => (2 3 3 4 4)
([list1 list2]
(fusion list1 list2 ()))
([list1 list2 res-list]
(cond
(empty? list1) (sort (concat res-list list2))
(empty? list2) (sort (concat res-list list1))
true
(let [top-of-1 (first list1)
top-of-2 (first list2)]
(cond
(= top-of-1 top-of-2)
(recur (rest list1) (rest list2) (cons top-of-1 res-list))
(< top-of-1 top-of-2)
(recur (rest list1) list2 (cons top-of-1 res-list))
(> top-of-1 top-of-2)
(recur list1 (rest list2) (cons top-of-2 res-list)))))))

(reduce * (reduce fusion (map #(factors %) (range 2 21))))

;;
READ MORE

Euler : Problem 4

Posted by TAKAIY On 0 コメント
回文数の問題

10秒考えて戦略決定。
数字を作ってから3けたで割りきれるか確認する。

6桁だけでいいだろうと思ったけど、5桁の処理も作った。

;;
;; Problem 4 : 2011/4/7
(* 999 999) ;998001
(* 100 100) ;10000

(use 'clojure.contrib.math)

(defn palindromic-5-digit-num []
(for [one (range 9 1 -1) two (range 9 0 -1) three (range 9 0 -1)]
(sort (+ (* 10000 one) (* 1000 two) (* 100 three) (* 10 two) one))))

(defn palindromic-6-digit-num []
(for [one (range 9 0 -1) two (range 9 -1 -1) three (range 9 -1 -1)]
(+ (* 100000 one) (* 10000 two) (* 1000 three)
(* 100 three) (* 10 two) one)))

(defn is-multiple-of-three-digits? [n]
(loop [tester (range 100 1000)]
(let [target (first tester)]
(cond (empty? tester) false
(and (zero? (rem n target))
(>= (/ n target) 100 )
(< (/ n target) 1000)) (list target (/ n target))
true (recur (rest tester))))))

(loop [digit-list (palindromic-6-digit-num)]
(let [ans (is-multiple-of-three-digits? (first digit-list))]
(if (seq? ans)
[(first digit-list) ans]
(recur (rest digit-list)))))

(loop [digit-list (palindromic-5-digit-num)]
(let [ans (is-multiple-of-three-digits? (first digit-list))]
(if (seq? ans)
[(first digit-list) ans]
(recur (rest digit-list)))))
;;
READ MORE

Euler : Problem 3

Posted by TAKAIY On 0 コメント
問題3は、素数の問題。
この後にも何個か出て来たし、これからも沢山出てくるんだろうけど、これは手強い。

まずは、できなかったやつ。 10000位でメモリーオーバーフローになっちまった

;;
;; overflow with 10000
(defn prime-nums-under [n]
(let [limt (inc (int (sqrt n)))]
(loop [prm-nums () candidate (range 2 (inc n))]
(let [target (first candidate)]
(if (>= target limt)
(concat prm-nums candidate)
(recur (concat prm-nums (list target))
(filter #(not (zero? (rem % target)))
(rest candidate))))))))
;;

で、作りなおしたのがこれ。

;;
;; java.lang.OutOfMemoryError: Java heap space
(loop [tester 600851475143
target-prim (prime-nums-under (floor(sqrt tester)))
successor 1]
(cond (empty? target-prim) successor
(zero? (rem tester (first target-prim)))
(recur tester (drop 1 target-prim) (first target-prim))
true (recur tester (drop 1 target-prim) successor)))
;;

でもだめ。

しょうがないから、素数を作るのじゃなくて、素数かどうか1つずつ確認してみた。

;;
;; SUCCESS
(defn is-prime? [n]
(zero? (count (filter #(= (rem n %) 0) (range 2 (inc (int (sqrt n))))))))

(loop [tester 600851475143
target-num (floor (sqrt tester))]
(if (and (zero? (rem tester target-num))
(is-prime? target-num))
target-num
(recur tester (- target-num 1))))
;;


できた。
でもなぁ。
なんか気に入らない。 そのうち直す。


READ MORE

Euler : Problem 2

Posted by TAKAIY On 0 コメント
問題2です。

フィボナッチ数列の問題なんですけど、これ、自力じゃない。
この間、どこかのサイトでみつけたやりかたなんだよね。

;;
;; Problem 2 2011/4/4
(defn my-fibo
([]
(concat [1 2] (my-fibo 1 2)))
([x y]
(let [next-num (+ x y)]
(lazy-seq
(cons next-num (my-fibo y next-num))))))

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

;;
この数列の構築のしかた、なるほどなぁ。だな。
READ MORE

Euler : Problem 1

Posted by TAKAIY On 0 コメント
さて、問題1です。
まあ、そんなに難しくはないね。

;;
;; Problem 1 : 2011/4/4
(defn is-3x-or-5x? [x]
(or (zero? (rem x 3))
(zero? (rem x 5))))

(reduce + (filter is-3x-or-5x? (range 1 10000)))

;;
READ MORE

Project Euler はじめました

Posted by TAKAIY On 0 コメント
プロジェクト オイラーってのがありまして、かなり前にみつけて「おや?」っと思ってたのですが、そのときは乗り気にならなかったので無視してましたが、Clojureに手をつけたこともあり、練習にいいかなと思って、今週から初めました。

ところが、これが、はまってしまうわけですよ。

昼休みとか終ってからとかやってるんですけど、食べたかどうかわからなくなるは、帰りがさらに遅くなるはで、ちょっと迷惑。


迷惑ついでに新しいブログを作って載せていこうというわけ。

とは言っても、それだけじゃもたないだろうから、コンピュータ関連の話題で埋めていこうかと思っております。

READ MORE