regex_golf.clj

(def winnersall (set (clojure.string/split 
               "washington adams jefferson jefferson madison madison monroe 
monroe adams jackson jackson vanburen harrison polk taylor pierce buchanan 
lincoln lincoln grant grant hayes garfield cleveland harrison cleveland mckinley
 mckinley roosevelt taft wilson wilson harding coolidge hoover roosevelt 
roosevelt roosevelt roosevelt truman eisenhower eisenhower kennedy johnson nixon 
nixon carter reagan reagan bush clinton clinton bush bush obama obama" #" ")))

(def losersall (set (clojure.string/split 
               "clinton jefferson adams pinckney pinckney clinton king adams 
jackson adams clay vanburen vanburen clay cass scott fremont breckinridge 
mcclellan seymour greeley tilden hancock blaine cleveland harrison bryan bryan 
parker bryan roosevelt hughes cox davis smith hoover landon wilkie dewey dewey 
stevenson stevenson nixon goldwater humphrey mcgovern ford carter mondale 
dukakis bush dole gore kerry mccain romney" #" ")))

(def winners (clojure.set/difference winnersall losersall))
(def losers (clojure.set/difference losersall winnersall))

(defn verify [regex, winners, losers]
  (let [missed-winners (remove (partial re-find regex) winners)
        matched-losers (filter (partial re-find regex) losers)]
    (when (seq missed-winners)
      (println "The following winners should've have matched") 
      (println (clojure.string/join " " (seq missed-winners)))
    (when (seq matched-losers)
      (println "The following losers shouldn't have matched")
      (println (clojure.string/join " " matched-losers))
    (not (or (seq missed-winners) (seq matched-losers)))))))


(defn subparts [word]
  (into #{}
    (for [beg (range (count word))
          end (map (partial + beg) [1 2 3 4])
          :when (<= end (count word))]
      (subs word beg end))))

(defn dotify* [wordseq]
       (when-let [xs (seq wordseq)]
         (if (next xs)
          (for [opts [(first xs) \.]
                rest (dotify (next xs))]
            (list* opts rest))
           [[(first xs)] [\.]])))

(defn dotify [word] (map #(apply str %) (dotify* word)))