#!/usr/bin/env ruby
 
f = open('names.txt')
  names_orig = f.read
f.close
 
def score_base(name)
  name.unpack("C*").inject(0){|s,x| s + x - 64}
end
 
names = names_orig.split(',').map{|name| name.tr('"','')}.sort
 
p names.enum_for(:each_with_index).map{|name,i| score_base(name) * (i+1)}.inject(:+)

(ns euler.p022)
 
(def names (slurp "names.txt"))
 
(defn name-score
  "Return name score.
   ex) COLIN at 938th in list
       -> 938 * (3 + 15 + 12 + 9 + 14) = 49714"
  [pos name]
  (* pos
     (reduce + (map #(-> % int (- 64)) name))))
 
(println "Anster : "
 (reduce + (map name-score
		(iterate inc 1)
		(sort (re-seq #"\w+" names)))))

#!/usr/bin/env ruby
 
require 'mathn'
 
def divisor(n)
  result=[1]
  n.prime_division.each do |i|
    result = result + result.map {|x| (1..i[1]).map{|n| x*(i[0]**n)}}.flatten
  end
  result.flatten.sort
end
 
def sum_of_divisors(n)
  divisor(n)[0..-2].inject(:+)
end
 
sum = 0
 
(1...10000).each do |n|
  sod = sum_of_divisors(n)
  next if sod.nil?
  next if n == sod
  sum += n if n == sum_of_divisors(sum_of_divisors(n))
end
 
p sum

(ns euler.p021
  (:use clojure.contrib.seq-utils))
 
(defn prime-division
  "Return prime factors of N."
  [number]
  (loop [n number d 2 factors []]
    (cond (<= n d) (frequencies (conj factors d))
	  (zero? (rem n d)) (recur (/ n d) d (conj factors d))
	  :else (recur n (inc d) factors))))
 
(defn exp-prime-factor
  "Expand prime factor exponentially.
   Usage: (exp-prime-factor prime-factor index)
   Example: (exp-prime-factor 3 4) -> [1 3 9 27 81]"
  [pf idx]
  (map #(apply * (replicate % pf)) (range (inc idx))))
 
(defn composite-factors
  "Composite factors collection.
   Usage: (composite-factors coll [prime-factor index])
   Example: (composite-factors [1 2 4] [5 2])
            -> (1 2 4 5 10 20 25 50 100)"
  [last-coll coll]
  (for [x (apply exp-prime-factor coll)
	y last-coll]
    (* x y)))
 
(defn sum-of-proper-divisors
  "Return sum of proper divisor of N."
  [n]
  (apply + (drop-last
	    (reduce composite-factors [1] (prime-division n)))))
 
(def sum-of-proper-divisors (memoize sum-of-proper-divisors))
 
(defn amicable?
  "Return true if N has amicable pair."
  [n]
  (let [candidate (sum-of-proper-divisors n)]
    (if (not= candidate n)
      (= n (sum-of-proper-divisors candidate)))))
 
(println "Answer : "
	 (apply + (filter amicable? (range 10000))))

(ns euler.p021
  (:use clojure.contrib.seq-utils))
 
(defn prime-division
  "Return prime factors of N."
  [number]
  (loop [n number d 2 factors []]
    (cond (<= n d) (frequencies (conj factors d))
	  (zero? (rem n d)) (recur (/ n d) d (conj factors d))
	  :else (recur n (inc d) factors))))
 
(defn sum-of-proper-divisors
  "Return sum of proper divisor of N."
  [n]
  (apply + (drop-last
	    (reduce (fn [m-coll coll]
	       (mapcat (fn [m-factor]
		  (map (fn [idx]
		     (* m-factor (. (bigint (first coll)) pow idx)))
		   (range (inc (second coll)))))
		m-coll))
	     [1] (prime-division n)))))
 
(def sum-of-proper-divisors (memoize sum-of-proper-divisors))
 
(defn amicable?
  "Return true if N has amicable pair."
  [n]
  (let [candidate (sum-of-proper-divisors n)]
    (if (not= candidate n)
      (= n (sum-of-proper-divisors candidate)))))
 
(println "Answer : "
	 (apply + (filter amicable? (range 10000))))

#!/usr/bin/env ruby
 
p 1.upto(100).inject(:*).to_s.split('').inject(0){|s,x| s + x.to_i}

(ns euler.p020)
 
(defn fact
  "Return factorial of N."
  [n]
  (apply * (range 1 (inc n))))
 
(defn sum-of-digits
  "Return the sum of each digits of N."
  [n]
  (apply + (map #(Integer. (str %)) (str n))))
 
(println "Answer : " (sum-of-digits (fact 100)))

#!/usr/bin/env ruby
 
days_of_month = [[31,28,31,30,31,30,31,31,30,31,30,31],
                 [31,29,31,30,31,30,31,31,30,31,30,31]]
 
Monday = 1
Sunday = 0
 
def is_leap(year)
  year % 4 == 0 && year % 100 != 0 || year % 400 == 0
end
 
count = 0
days_total = Monday + 365 # 1900 is not leap
(1901..2000).each do |year|
  leap = is_leap(year) ? 1 : 0
  (1..12).each do |month|
    count += 1 if days_total % 7 == 0
    days_total += days_of_month[leap][month-1]
  end
end
p count

(ns euler.p019)
 
(def days-of-month
     [31 28 31 30 31 30 31 31 30 31 30 31])
 
(defn leap-year?
  "Return true if leap year."
  [year]
  (cond
    (zero? (rem year 400)) true
    (zero? (rem year 100)) false
    (zero? (rem year 4)) true
    :else false))
 
(defn leaps-from-origin
  "Return number of leap days form Jan-0 0000."
  [year month day]
  (+ (quot year 4)
     (- (quot year 100))
     (quot year 400)
     (if (leap-year? year)
       (if (< month 3) -1 0)
       0)))
 
(defn days-total-from-origin
  "Return number of days from Jan-0 0000."
  [year month day]
  (+ (* 365 year)
     (apply + (take (dec month) days-of-month))
     day
     (leaps-from-origin year month day)))
 
(defn sunday?
  "Return true if date is sunday."
  [year month day]
  (let [sunday (rem (dec (days-total-from-origin 1900 1 1)) 7)]
       (= sunday
	  (rem (days-total-from-origin year month day) 7))))
 
(println "Answer : "
	 (count
	  (filter #(apply sunday? %)
		  (for [year (range 1901 2001)
			month (range 1 13)]
		    [year month 1]))))

(ns euler.p019
  (:import (java.util GregorianCalendar)))
 
(defn sunday?
  "Return true if date is sunday."
  [year month day]
  (let [date (doto (GregorianCalendar.) (.set year (dec month) day))]
    (= (. date get GregorianCalendar/DAY_OF_WEEK)
       GregorianCalendar/SUNDAY)))
 
(println "Answer : "
	 (count
	  (filter #(apply sunday? %)
		  (for [year (range 1901 2001)
			month (range 1 13)]
		    [year month 1]))))

#!/usr/bin/env ruby
 
Rows = 15
tri = []
tri << %w(75)
tri << %w(95 64)
tri << %w(17 47 82)
tri << %w(18 35 87 10)
tri << %w(20 04 82 47 65)
tri << %w(19 01 23 75 03 34)
tri << %w(88 02 77 73 07 63 67)
tri << %w(99 65 04 28 06 16 70 92)
tri << %w(41 41 26 56 83 40 80 70 33)
tri << %w(41 48 72 33 47 32 37 16 94 29)
tri << %w(53 71 44 65 25 43 91 52 97 51 14)
tri << %w(70 11 33 28 77 73 17 78 39 68 17 57)
tri << %w(91 71 52 38 17 14 91 43 58 50 27 29 48)
tri << %w(63 66 04 68 89 53 67 30 73 16 69 87 40 31)
tri << %w(04 62 98 27 23 09 70 98 73 93 38 53 60 04 23)
Tri = tri.map{|line| line.map{|num| num.to_i}}
$cache = tri.map{|line| line.map{|num| nil}}
 
def pick_grater(depth, pos)
  current = Tri[depth][pos]
  return current if depth == Rows - 1
  $cache[depth+1][pos] ||= pick_grater(depth + 1, pos)
  $cache[depth+1][pos+1] ||= pick_grater(depth + 1, pos + 1)
  left  = $cache[depth+1][pos]
  right = $cache[depth+1][pos+1]
  (left > right ) ? (left + current) : (right + current)
end
 
p pick_grater(0, 0)

(ns euler.p018)
 
(def triangle-text
  "75
   95 64
   17 47 82
   18 35 87 10
   20 04 82 47 65
   19 01 23 75 03 34
   88 02 77 73 07 63 67
   99 65 04 28 06 16 70 92
   41 41 26 56 83 40 80 70 33
   41 48 72 33 47 32 37 16 94 29
   53 71 44 65 25 43 91 52 97 51 14
   70 11 33 28 77 73 17 78 39 68 17 57
   91 71 52 38 17 14 91 43 58 50 27 29 48
   63 66 04 68 89 53 67 30 73 16 69 87 40 31
   04 62 98 27 23 09 70 98 73 93 38 53 60 04 23")
 
(def triangle
     (for [row (map #(re-seq #"[0-9]+" %)
		     (.split triangle-text "\n"))]
       (map #(Integer. %) row)))
 
(defn merge-rows
  "Return maximum values for upper row."
  [last-row current-row]
  (map +
       current-row
       (map #(apply max %) (partition 2 1 last-row))))
 
(println "Answer : "
	 (first (reduce merge-rows (reverse triangle))))

#!/usr/bin/env ruby
 
One_to_Nine = %W(#{} one two three four five six seven eight nine)
Teen = %W(#{} #{} #{} thir four fif six seven eigh nine)
Ty = %W(#{} #{} twen thir for fif six seven eigh nine)
Ten_to_Twelve = %w(ten eleven twelve)
Handred = " handred"
Thousand = " thousand"
 
def spell(num)
  r = []
  d = []
  (0..3).each do |digit|
    d[digit] = num % 10**(digit+1) / 10**digit
  end
 
  r << One_to_Nine[d[3]] + Thousand if d[3] > 0
  r << One_to_Nine[d[2]] + Handred  if d[2] > 0
  r << "and" if (d[3] + d[2]) * (d[1] + d[0]) > 0
  if d[1] == 1
    r << Teen[d[0]] + "teen" if d[0] > 2
    r << Ten_to_Twelve[d[0]] if d[0] <= 2
  else
    r << Ty[d[1]] + "ty" if d[1] > 1
    r << One_to_Nine[d[0]] if d[0] > 0
  end
 r.join(" ").sub("ty ", "ty-")
end
 
def count_letter(num)
  spell(num).tr(" -", "").size
end
 
p 1.upto(1000).inject(0){|s,n| s + count_letter(n)}

(ns euler.p017)
 
(def one-to-nineteen
     ["" "one" "two" "three" "four" "five" "six" "seven" "eight" "nine"
      "ten" "eleven" "twelve" "thirteen" "fourteen" "fifteen"
      "sixteen" "seventeen" "eighteen" "nineteen"])
 
(def twenty-to-ninety
     ["twenty" "thirty" "forty" "fifty" "sixty" "seventy" "eighty" "ninety"])
 
(defn spell-num
  "Return number as english-word."
  ([n] (spell-num n ""))
  ([n preword]
     (cond
       (= n 0) ""
       (< n 20) (str preword (nth one-to-nineteen n))
       (< n 100) (str preword
		      (nth twenty-to-ninety (/ (- n 20) 10))
		      (spell-num (rem n 10) "-"))
       (< n 1000) (str preword
		       (spell-num (/ n 100)) " hundred"
		       (spell-num (rem n 100) " and "))
       (< n 10000) (str (spell-num (/ n 1000)) " thousand"
			(spell-num (rem n 1000) " ")))))
 
(defn remove-spaces-and-hyphens
  [word]
  (apply str (re-seq #"\w+" word)))
 
(println "Answer : "
	 (count
	  (apply str
		 (map #(remove-spaces-and-hyphens (spell-num %))
		      (range 1 1001)))))

#!/usr/bin/env ruby
 
p (2**1000).to_s.split('').inject(0){|s,x| s + x.to_i}

(ns euler.p016)
 
(defn pow
  "Return the N-th power of A."
  [a n]
  (apply * (replicate n a)))
 
(defn sum-of-digits
  "Return the sum of each digits of N."
  [n]
  (apply + (map #(Integer. (str %)) (str n))))
 
(println "Answer : " (sum-of-digits (pow 2 1000)))

#!/usr/bin/env ruby
 
# 40C20
p 21.upto(40).inject(1){|s,x| s*x} / 1.upto(20).inject(1){|s,x| s*x}

(ns euler.p015)
 
(defn fact
  "Return factorial of N."
  [n]
  (apply * (range 1 (inc n))))
 
(defn comb
  "Return number of combinations from N choose M."
  [n m]
  (/ (fact n)
     (fact m)
     (fact (- n m))))
 
(println "Answer : " (comb (* 20 2) 20))

#!/usr/bin/env ruby
 
def next_collatz(n)
  return 1 if n == 1
  return n / 2 if n.even?
  3 * n + 1
end
 
def get_chains_num(n)
  c = 1
  until n == 1
    n = next_collatz(n)
    c += 1
  end
  c
end
 
def (Chains = [0, 1]).[](n)
  return super if super
  if n < 2_000_000
    return Chains[n] = Chains[next_collatz(n)] + 1
  else 
    return get_chains_num(n)
  end
end
 
max = 0
point = 1
1.upto(1_000_000 - 1).each do |n|
  val = Chains[n]
  if val > max
    max = val 
    point = n
  end
end
 
p "At #{point} : chain length = #{max}"

(ns euler.p014)
 
(defn collatz-length
  "Return chain length of Collatz sequence of N."
  [n]
  (cond (= n 1) 1
	(even? n) (inc (collatz-length (/ n 2)))
	:else (inc (collatz-length (inc (* 3 n))))))
 
(defn memoize-under
  "Apply memoize when arg is under limit."
  [limit f]
  (let [mem (atom {})]
    (fn [arg]
      (if (> arg limit)
	(f arg)
	(if-let [e (find @mem arg)]
	  (val e)
	  (let [ret (f arg)]
	    (swap! mem assoc arg ret)
	    ret))))))
 
(def collatz-length (memoize-under 400000 collatz-length))
 
(defn pick-grater-last
  "Pick coll of which last value is greater."
  [coll-1 coll-2]
  (if (> (last coll-1)
	 (last coll-2))
    coll-1
    coll-2))
 
(println "Answer : "
	 (first
	  (reduce pick-grater-last
		  (map #(vector % (collatz-length %))
		       (range 1 1000000)))))

#!/usr/bin/env ruby
 
ans = 37107287533902102798797998220837590246510135740250
ans += 46376937677490009712648124896970078050417018260538
ans += 74324986199524741059474233309513058123726617309629
# ------------------------ SNIP ------------------------ 
ans += 20849603980134001723930671666823555245252804609722
ans += 53503534226472524250874054075591789781264330331690
 
p ans.to_s[0..9]

(def big-nums
     [37107287533902102798797998220837590246510135740250
      46376937677490009712648124896970078050417018260538
      74324986199524741059474233309513058123726617309629
; ------------------------ SNIP ------------------------
      20849603980134001723930671666823555245252804609722
      53503534226472524250874054075591789781264330331690])
 
(println "Answer : " (apply str (take 10 (str (apply + big-nums)))))