#!/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)))))