# HG changeset patch
# User Robert McIntyre <rlm@mit.edu>
# Date 1318925869 25200
# Node ID 307a81e460713d9a5e7db12d5b180b0bd011ea1a

initial committ

diff -r 000000000000 -r 307a81e46071 src/Collatz.class
Binary file src/Collatz.class has changed
diff -r 000000000000 -r 307a81e46071 src/Collatz.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/Collatz.java	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,37 @@
+package coderloop;
+
+import java.io.File;
+import java.util.Scanner;
+
+class Collatz {
+    public static void main(String[] args)throws java.io.FileNotFoundException{
+	File file = new File(args[0]);
+	Scanner scanner = new Scanner(file);
+	int n = scanner.nextInt();
+	System.out.println(search_collatz(n));}
+    
+    public static long collatz_next(long n){
+	if (0 == (n % 2)){
+	    return n/2;}
+	else {
+	    return (1 + (n * 3));}}
+    
+    public static int collatz_length(int n){
+	long t = n;
+	int d = 1;
+	while (t > 1){
+	    t = collatz_next(t);
+	    d++;}
+	return d;}
+    
+    public static int search_collatz(int n){
+	int max = 0;
+	int max_val = 0;
+	int temp_val = 0;
+	for (int i = 1; i<n; i++){
+	    temp_val = collatz_length(i);
+	    if (temp_val > max_val){
+		max = i;
+		max_val = temp_val;}}
+	return max;}
+}
diff -r 000000000000 -r 307a81e46071 src/Collatz.java.ant.xml
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/Collatz.java.ant.xml	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+      <project name="collatz" basedir="." default="default">
+      <property name="build" location=".build" />
+      <property name="srcfolder" value="src" />
+      <property name="code.classes" location="${build}/classes" />
+      <property name="code.sources" location="${srcfolder}" />
+      <dirset id="srcdir" dir="." includes="src" />
+      <path id="lib.path"><pathelement path="${code.classes}" /></path>
+      <target name="compile">
+      	      <mkdir dir="${code.classes}" />
+	      	     <javac srcdir="${code.sources}" destdir="${code.classes}" classpathref="lib.path" target="1.5" encoding="utf-8" />
+		     </target>
+		     <target name="default" >
+		     	     <antcall target="compile" />
+			     </target>
+</project>
diff -r 000000000000 -r 307a81e46071 src/Collatz.java.run
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/Collatz.java.run	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,4 @@
+#!/bin/bash
+MAINCLASS="coderloop.Collatz"
+CP=".build/classes"
+java -cp "${CP}" ${MAINCLASS} "$*"
diff -r 000000000000 -r 307a81e46071 src/collatz.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/collatz.c	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,40 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[]){
+  FILE *fp;
+  int n;
+  if((fp=fopen(argv[1] ,"r")) == NULL) {
+    printf("Cannot open file.\n");
+    exit(1);}
+  fscanf(fp, "%d", &n); /* read from file */
+  int answer = search_collatz(n);
+  printf("%d\n", answer); }
+
+long long collatz_next(long long n){
+  if (!(n % 2)){
+    return n/2;}
+  else {
+    return 1+(n*3);}}
+
+int collatz_length(int n){
+  long long t = n;
+  int d = 1;
+  while (t > 1){
+    t = collatz_next(t);
+    d++;}
+  return d;}
+  
+int search_collatz(int n){
+  int max = 0;
+  int max_val = 0;
+  int temp_val;
+  int i;
+  for (i = 1; i<n; i++){
+    temp_val = collatz_length(i);
+    if (temp_val > max_val){
+      max = i;
+      max_val = temp_val;}}
+  return max;}
+      
diff -r 000000000000 -r 307a81e46071 src/collatz.f
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/collatz.f	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,52 @@
+      program collatz
+      implicit none
+      character (len = 100) :: file_name  
+      integer, parameter :: big = selected_int_kind(11)
+      integer  :: n
+      call getarg( 1, file_name )  
+      OPEN(unit = 7, file = file_name)
+      read (7,*) n
+      write (unit = *, fmt = "(I0)") search_collatz(n)
+
+      contains
+
+      function collatz_next (n) result (r)
+      implicit none
+      integer (kind = big)  :: r,n
+      if (0 == mod(n,2)) then
+         r = n/2
+      else
+         r = 1 + 3*n
+      end if 
+      end function collatz_next
+      
+      function collatz_length (n) result (r)
+      implicit none
+      integer (kind = big)  :: t
+      integer :: n,r
+      r = 1
+      t = n
+      do 
+         if (1 == t) then
+         exit
+         end if
+         r = r + 1
+         t = collatz_next(t)
+      end do
+      end function collatz_length
+      
+      function search_collatz (n) result (r)
+      implicit none
+      integer n,r,i,max,max_val,temp_val
+      integer (kind = big) :: t
+      t = n
+      do i = 1,n-1
+         temp_val = collatz_length(i)
+         if (temp_val > max_val) then
+         max = i
+         max_val = temp_val
+      end if
+      end do
+      r = max
+      end function search_collatz
+      end program collatz
diff -r 000000000000 -r 307a81e46071 src/collatz.f.make
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/collatz.f.make	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,4 @@
+euler14: collatz.f
+	gfortran -Wall -o euler14 collatz.f
+
+
diff -r 000000000000 -r 307a81e46071 src/collatz.make
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/collatz.make	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,10 @@
+
+euler14 : collatz.c
+	gcc collatz.c -o euler14
+
+test : euler14
+	./euler14 euler14-a.in
+
+clean :
+	rm euler14
+
diff -r 000000000000 -r 307a81e46071 src/collatz.pl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/collatz.pl	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,69 @@
+#!/usr/bin/perl
+
+use bigint;
+$a = "/home/r/coderloop-test/euler14-a.in";
+$b = "/home/r/coderloop-test/euler14-b.in";
+
+sub read_integer{
+  ##reads an integer from a file
+  (my $file) = @_;
+  my $int;
+  open FILE, "<".$file or die $!;
+  for (<FILE>){ chomp; /^\W*(\d+)\W*$/; $int = $1;}
+  close FILE;
+  return $int;}
+
+
+@collatz = (1);
+
+
+sub collatz_next {
+  my $n = @_[0];
+  if (1 == $n) {return 1;}
+  if (0 == ($n % 2)){ return $n/2;}
+  if (1 == ($n % 2)){ return (($n*3)+1);}
+}
+
+sub different_collatz_length {
+  my $n = $_[0];
+  my $d = 1;
+  while ($n != 1){
+    $d++;
+    $n = collatz_next($n);}
+  return $d;}
+
+sub collatz_length {
+  ## calculate the length of the collatz sequence 
+  ## http://en.wikipedia.org/wiki/Collatz_conjecture
+  ## starting at n
+  my $n = @_[0];
+  #print $n,"\n";
+  #memoization
+  #print "***** ", $collatz[$n], " ********\n";
+  if (defined $collatz[$n]){return $collatz[$n];}
+  if (1 == $n) {return 1;}
+  if (0 == ($n % 2)){ return (1 + &collatz_length($n/2))}
+  if (1 == ($n % 2)){ return (1 + &collatz_length(($n*3)+1));}
+}
+
+
+sub max_collatz {
+    my $n = @_[0];
+    my $max_length = 1;
+    my $max_val = 1;
+    for (my $i = 1; $i < $n; $i++){
+	my $collatz = &different_collatz_length($i);
+	#push(@collatz, $collatz);
+	if ( $collatz >= $max_length){
+	    $max_length = $collatz ;
+	    $max_val = $i}}
+    print "\n number is : $max_length --- ";
+    print &collatz_length($max_val) . "\n";
+    return $max_val;
+}
+
+
+
+
+if (defined @ARGV){
+    print &max_collatz(read_integer($ARGV[0])), "\n";}
diff -r 000000000000 -r 307a81e46071 src/decrypt.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/decrypt.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,43 @@
+(ns coderloop.decrypt
+  (:use [clojure.contrib
+	 [duck-streams :only [read-lines]]
+	 [seq :only [find-first]]
+	 [string :only [map-str]]
+	 [combinatorics :only [cartesian-product]]])
+  (:use rlm.shell-inspect)
+  (:use [clojure [string :only [split]]])
+  (:import Crypt))
+
+(def t  "/home/r/coderloop-test/test.txt")
+
+(defn strcat [coll]
+  (apply str coll))
+
+(def numerals [0 2 4 8 ])
+
+(defn crypt [salt s]
+  (Crypt/crypt salt s))
+
+(defn cross-text [text]
+  (let [symbols   (filter
+		   (fn [s] (<= (count s) 8))
+		   (split (.toLowerCase text) #"[^a-z]+"))]
+    (filter
+     (fn [s]
+       (let [len (count s)]
+	 (and
+	  (>= len 5)
+	  (<= len 8))))
+     (map (partial apply str)
+	  (cartesian-product symbols numerals symbols)))))
+	  
+(defn process-file [f]
+  (let [file (read-lines f)
+	[salt pass] (map (partial apply str) (split-at 2 (first file)))
+	text (strcat (interleave (repeat \newline) (rest file)))]
+    (find-first (fn [s] (= (str salt pass) (crypt salt s)))
+		(cross-text text))))    
+
+
+(if (command-line?)
+ (println (process-file (first *command-line-args*))))
diff -r 000000000000 -r 307a81e46071 src/douglas_adams.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/douglas_adams.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,20 @@
+(ns coderloop.douglas-adams
+  (:refer-clojure :only [])
+  (:require rlm.ns-rlm rlm.light-base))
+(rlm.ns-rlm/ns-clone rlm.light-base)
+
+(use '[clojure [string :only [trim blank? split]]])
+
+
+
+(defn brute-force-life [coll]
+  (dorun (map println (take-while (comp not (partial = 42)) coll))))
+
+
+
+
+
+(if (command-line?)
+  (brute-force-life (read-integers (file-str (first *command-line-args*))))
+  nil)
+
diff -r 000000000000 -r 307a81e46071 src/euler6.f
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/euler6.f	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,18 @@
+      program euler6
+
+      implicit none
+      character (len = 100) :: file_name  
+      integer, parameter :: big = selected_int_kind(11)
+      integer (kind = big)  :: n,ans
+      call getarg( 1, file_name )  
+      OPEN(unit = 7, file = file_name)
+      read (7,*) n
+      
+      ans = ((n * (n + 1))/2)**2 - ((n * (n + 1) * (1 + ( 2 * n)))/6) 
+
+      write (unit = *, fmt = "(I0)") ans
+
+
+
+
+      end program euler6
diff -r 000000000000 -r 307a81e46071 src/euler6.f.make
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/euler6.f.make	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,4 @@
+euler6: euler6.f
+	gfortran -Wall -o euler6 euler6.f
+
+
diff -r 000000000000 -r 307a81e46071 src/export_files.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/export_files.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,246 @@
+(ns coderloop.export-files
+  (:use clojure.java.io)
+  (:use [clojure.contrib [duck-streams :only [file-str]]])
+  (:use [rlm
+	 [classpath-utils :only [classpath]]
+	 [shell-write :only [sw]]])
+  (:require clojure.string)
+  (:import java.io.File))
+
+(import '[org.apache.commons.io FileUtils])
+
+;;(use '[telmo.rlm [dist :only [dist]]])
+
+(def *nailgun* true)
+
+;;; put standard base-path on the classpath
+(def standard-base-directory (file-str "~/.clojure-exports/"))
+
+(defn better-export-files [namespace name]
+    (binding [*compile-path* (.getPath standard-base-directory)]
+    ;;clear out classes -- prepare temp directory
+    (FileUtils/forceMkdir standard-base-directory)
+    (FileUtils/deleteDirectory standard-base-directory)
+    (FileUtils/forceMkdir standard-base-directory)      
+      ;; make classes
+    (compile (symbol (str namespace)))
+    
+    ;; make jar
+;;    (jar {:jarfile jar-name :basedir temp-class-dir})
+    
+    ;; move jar
+;;    (FileUtils/copyFileToDirectory jar-name target-lib-dir)
+    ))
+
+(defmulti source-location class)
+
+(defmethod source-location clojure.lang.Var [sym]
+	   (let [source? (:file (meta sym))]
+	     (if source?
+	       (.getResource (clojure.lang.RT/baseLoader) source?)
+	       nil)))
+
+(defmethod source-location java.lang.Class [sym]
+	   (let [source? (.getCodeSource (.getProtectionDomain sym))]
+	     (if source?
+	       (.getLocation source?)
+	       nil)))
+
+(defn all-dependent-namespaces [namespace]
+  (set
+   (concat
+    [namespace]
+    
+    (vals (ns-aliases namespace))
+
+    (map #(.ns %)
+	 (filter #(= (class %) clojure.lang.Var)
+		 (concat 
+		  
+		  (vals (ns-map namespace))
+		  (vals (ns-refers namespace))
+		  
+		  ))))))
+
+(defn deep-dependent-namespaces [namespace-set]
+  (let [new-namespaces (set (mapcat all-dependent-namespaces namespace-set))]
+    ;;(println (count new-namespaces))
+    (if (= new-namespaces namespace-set)
+      namespace-set
+      (recur new-namespaces))))
+
+
+(defn dependencies-url
+  "returns all of the files necessary to succesfully run the namespace."
+  [namespace]
+  (set
+   (remove nil?
+	   (map source-location
+		(map second
+		     (mapcat ns-map (deep-dependent-namespaces #{namespace})))))))
+
+
+(defn trans-print [x] (println x) x) 
+
+(defn dependencies-file [namespace]
+  (map file-str
+       (set
+	(map #(.replaceFirst % "file:" "")
+	(map  #(if (.contains % ".jar!/")
+		 (clojure.string/replace % #"\.jar.*" ".jar")
+		 %)
+	      (map #(.getFile %) (dependencies-url namespace)))))))
+
+
+
+(defn classpath-files []
+  (map file-str (clojure.string/split (classpath) #":")))
+
+;;Every file that comes back from dependencies-file is also on the classpath.
+;;In order to recreate the right project structure, we need to copy the files 
+;;with the appropiate classpath nesting.
+
+(defn bifurcate
+  "split a collection between f and not f"
+  [f coll]
+  (list
+   (filter f coll)
+   (filter (comp not f) coll)))
+
+(defn jar? [#^java.io.File f]
+  (re-matches  #".*\.jar$" (.getCanonicalPath f)))
+
+(defn contains-file? [#^java.io.File parent #^java.io.File child]
+  (let [new-child (.getParentFile child)]
+    (cond (nil? new-child) false
+	  (= new-child parent) true
+	  true (recur parent new-child))))
+
+(defn destination [base-path-list #^java.io.File current-file #^java.io.File base-destination]
+  (let [base-path (last (filter #(contains-file? % current-file) base-path-list))]
+    (file-str
+     (.replaceFirst (.getCanonicalPath current-file)
+		    (.getCanonicalPath base-path)
+		    (.getCanonicalPath base-destination)))))
+
+(defn export-dependencies
+  ([namespace #^java.io.File target src* lib*]
+     (let [[jars sources] (bifurcate jar? (dependencies-file namespace))
+	   jars (if *nailgun*
+		  (conj jars (file-str "~/roBin/nailgun-0.7.1/nailgun-0.7.1.jar"))
+		  jars)
+	   
+	   lib (file-str (str (.getCanonicalPath target) File/separatorChar lib*))
+	   src (file-str (str (.getCanonicalPath target) File/separatorChar src*))]
+       (if *nailgun*
+	 (do
+	   (FileUtils/copyFileToDirectory (file-str "~/roBin/nailgun-0.7.1/ng") lib)
+	   (sw (str "chmod +x " (.getCanonicalPath target) File/separatorChar lib* "/ng"))))
+       (dorun (map #(FileUtils/copyFileToDirectory % lib) jars))
+       (dorun (map #(FileUtils/copyFile % (destination (classpath-files) % src)) sources))))
+  
+  ([namespace #^java.io.File target]
+     (export-dependencies namespace target "src" "lib")))
+
+(defn run-script-text
+  ([namespace]
+     (run-script-text namespace "src" "lib"))
+  ([namespace src lib] 
+     (if *nailgun*
+       (str
+	
+	"#!/usr/bin/perl
+
+if (`./"lib"/ng ng-alias 2>&1 1>/dev/null` eq \"connect: Connection refused\\n\"){
+	
+	$nailgun_init = 
+	\"java -Xmn500M -Xms2000M -Xmx2000M \" . 
+	\"-classpath ./"src"/:"lib"/*\" . \" -server \". 
+	\"com.martiansoftware.nailgun.NGServer \". 
+	\" >/dev/null 2>/dev/null &\";
+	`$nailgun_init`;
+	}\n\n"
+	
+	
+	"while (`./"lib"/ng ng-alias 2>&1 1>/dev/null` eq \"connect: Connection refused\\n\"){
+    }\n\n"
+	
+	"$command = "
+	
+	
+	"\"./"lib"/ng clojure.main "
+	"./"src"/"
+	(.replace (.replace (str *ns*) \. File/separatorChar) \- \_)
+	".clj "
+	" @ARGV\";\n"
+	
+	"print `$command`;\n")
+       (str
+	"#!/bin/bash\n"
+	"java -Xmn500M -Xms2000M -Xmx2000M -server -cp ./"lib"/*:./"src" clojure.main "
+	"./"src"/"
+	(.replace (.replace (str *ns*) \. File/separatorChar) \- \_)
+	".clj "
+	" $@\n"))))
+
+
+
+(defn make-run-script
+  ([namespace base-dir name]
+     (make-run-script namespace base-dir name "src" "lib"))
+  ([namespace base-dir name src lib]
+  (let [w (clojure.java.io/writer
+	   (str (.getCanonicalPath base-dir) File/separatorChar name))]
+    (.write w (run-script-text namespace src lib))
+    (.close w))
+  (let [f (file-str  (str (.getCanonicalPath base-dir) File/separatorChar name))]
+    (.setExecutable f true))))
+
+
+(defn bzip-folder [#^java.io.File destination #^java.io.File directory]
+  (apply (partial sw "tar" "-cvjf" (.getCanonicalPath destination))
+
+	  (concat
+	   (rest
+	    (map #(.replaceFirst
+		   %
+		   (str (.getCanonicalPath directory) File/separatorChar ) "")
+		 (map str (file-seq directory))))
+	    [:dir (.getCanonicalPath directory)])))
+
+
+(defn bzip-export-files
+  ([directory to name postfix]
+     (bzip-export-files directory to name postfix "src" "lib"))
+
+  ([directory to name postfix src lib]
+     (apply (partial sw "tar" "-cvjf"
+		     (str (.getCanonicalPath to) File/separatorChar (str name postfix)))
+	    (concat
+	     [name src lib]
+	     [:dir (.getCanonicalPath directory)]))))
+
+(defn export-archive
+  ([name]
+     (export-archive *ns* name))
+
+  ([namespace name nailgun?]
+     (binding [*nailgun* nailgun?]
+       (export-archive namespace name)))
+  
+  ([namespace name]
+     (FileUtils/forceMkdir standard-base-directory)
+     (FileUtils/forceDelete standard-base-directory)
+     (FileUtils/forceMkdir standard-base-directory)
+     (let [new-dir (file-str (str
+			      (.getCanonicalPath standard-base-directory)
+			      (File/separatorChar)
+			      name))]
+       (export-dependencies namespace new-dir)
+       (make-run-script namespace new-dir name)
+       (println (str name "-clojure.tar.bz2"))
+       (println name)
+       (bzip-export-files new-dir (file-str "~/coderloop/") name "-clojure.tar.bz2")
+       (FileUtils/copyFileToDirectory
+	(file-str (str "~/coderloop/" name "-clojure.tar.bz2"))
+	(file-str "~/coderloop-test")))))
diff -r 000000000000 -r 307a81e46071 src/export_files.clj.orig
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/export_files.clj.orig	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,225 @@
+(ns coderloop.export-files
+  (:use clojure.java.io)
+  (:use [clojure.contrib [duck-streams :only [file-str]]])
+  (:use [rlm
+	 [classpath-utils :only [classpath]]
+	 [shell-write :only [sw]]])
+  (:require clojure.string)
+  (:import java.io.File)
+  (:import [org.apache.commons.io FileUtils])
+  )
+
+
+(defn trans-print [x] (println x) x) 
+
+(def *nailgun* true)
+
+;;; put standard base-path on the classpath
+(def standard-base-directory (file-str "~/.clojure-exports/"))
+
+(defn better-export-files [namespace name]
+    (binding [*compile-path* (.getPath standard-base-directory)]
+    ;;clear out classes -- prepare temp directory
+    (FileUtils/forceMkdir standard-base-directory)
+    (FileUtils/deleteDirectory standard-base-directory)
+    (FileUtils/forceMkdir standard-base-directory)      
+      ;; make classes
+    (compile (symbol (str namespace)))
+    
+    ;; make jar
+;;    (jar {:jarfile jar-name :basedir temp-class-dir})
+    
+    ;; move jar
+;;    (FileUtils/copyFileToDirectory jar-name target-lib-dir)
+    ))
+
+(defmulti source-location class)
+
+(defmethod source-location clojure.lang.Var [sym]
+	   (let [source? (:file (meta sym))]
+	     (if source?
+	       (.getResource (clojure.lang.RT/baseLoader) source?)
+	       nil)))
+
+(defmethod source-location java.lang.Class [sym]
+	   (let [source? (.getCodeSource (.getProtectionDomain sym))]
+	     (if source?
+	       (.getLocation source?)
+	       nil)))
+
+(defn all-dependent-namespaces [namespace]
+  (set
+   (concat
+    [namespace]
+    (vals (ns-aliases namespace))
+    (map #(.ns %)
+	 (filter #(= (class %) clojure.lang.Var)
+		 (concat 
+		  (vals (ns-map namespace))
+		  (vals (ns-refers namespace))))))))
+
+(defn deep-dependent-namespaces [namespace-set]
+  (let [new-namespaces (set (mapcat all-dependent-namespaces namespace-set))]
+    ;;(println (count new-namespaces))
+    (if (= new-namespaces namespace-set)
+      namespace-set
+      (recur new-namespaces))))
+
+(defn dependencies-url
+  "returns all of the files necessary to succesfully run the namespace."
+  [namespace]
+  (set
+   (remove
+    nil?
+    (map source-location
+	 (map second
+	      (mapcat ns-map (deep-dependent-namespaces #{namespace})))))))
+
+(defn dependencies-file [namespace]
+  (map file-str
+       (set
+	(map #(.replaceFirst % "file:" "")
+	     (map  #(if (.contains % ".jar!/")
+		      (clojure.string/replace % #"\.jar.*" ".jar") %)
+		   (map #(.getFile %) (dependencies-url namespace)))))))
+
+(defn classpath-files []
+  (map file-str (clojure.string/split (classpath) #":")))
+
+;;Every file that comes back from dependencies-file is also on the classpath.
+;;In order to recreate the right project structure, we need to copy the files 
+;;with the appropiate classpath nesting.
+
+(defn bifurcate
+  "split a collection between f and not f"
+  [f coll]
+  (list
+   (filter f coll)
+   (filter (comp not f) coll)))
+
+(defn jar? [#^java.io.File f]
+  (re-matches  #".*\.jar$" (.getCanonicalPath f)))
+
+(defn contains-file? [#^java.io.File parent #^java.io.File child]
+  (let [new-child (.getParentFile child)]
+    (cond (nil? new-child) false
+	  (= new-child parent) true
+	  true (recur parent new-child))))
+
+(defn destination [base-path-list #^java.io.File current-file #^java.io.File base-destination]
+  (let [base-path (last (filter #(contains-file? % current-file) base-path-list))]
+    (file-str
+     (.replaceFirst (.getCanonicalPath current-file)
+		    (.getCanonicalPath base-path)
+		    (.getCanonicalPath base-destination)))))
+
+(defn export-dependencies [namespace #^java.io.File target]
+  (let [[jars sources] (bifurcate jar? (dependencies-file namespace))
+	jars (if *nailgun*
+	       (conj jars (file-str "~/roBin/nailgun-0.7.1/nailgun-0.7.1.jar"))
+	       jars)
+       
+	lib (file-str (str (.getCanonicalPath target) File/separatorChar "lib"))
+	src (file-str (str (.getCanonicalPath target) File/separatorChar "src"))]
+    (if *nailgun*
+      (do
+	(FileUtils/copyFileToDirectory (file-str "~/roBin/nailgun-0.7.1/ng") lib)
+	(sw (str "chmod +x " (.getCanonicalPath target) File/separatorChar "lib/ng"))))
+    (dorun (map #(FileUtils/copyFileToDirectory % lib) jars))
+    (dorun (map #(FileUtils/copyFile % (destination (classpath-files) % src)) sources))))
+
+(defn run-script-text [namespace]
+  
+  (if *nailgun*
+    (str
+     
+     "#!/usr/bin/perl
+
+if (`./lib/ng ng-alias 2>&1 1>/dev/null` eq \"connect: Connection refused\\n\"){
+	
+	$nailgun_init = 
+	\"java -Xmn500M -Xms2000M -Xmx2000M \" . 
+	\"-classpath ./src/:lib/*\" . \" -server \". 
+	\"com.martiansoftware.nailgun.NGServer \". 
+	\" >/dev/null 2>/dev/null &\";
+	`$nailgun_init`;
+	}\n\n"
+     
+     
+     "while (`./lib/ng ng-alias 2>&1 1>/dev/null` eq \"connect: Connection refused\\n\"){
+    }\n\n"
+     
+     "$command = "
+     
+     
+     "\"./lib/ng clojure.main "
+     "./src/"
+     (.replace (.replace (str *ns*) \. File/separatorChar) \- \_)
+     ".clj "
+     " @ARGV\";\n"
+     
+     "print `$command`;\n")
+    (str
+     "#!/bin/bash\n"
+     "java -Xmn500M -Xms2000M -Xmx2000M -server -cp ./lib/*:./src clojure.main "
+     "./src/"
+     (.replace (.replace (str *ns*) \. File/separatorChar) \- \_)
+     ".clj "
+     " $@\n")))
+
+
+
+(defn make-run-script [namespace base-dir name]
+  (let [w (clojure.java.io/writer
+	   (str (.getCanonicalPath base-dir) File/separatorChar name))]
+    (.write w (run-script-text namespace))
+    (.close w))
+  (let [f (file-str  (str (.getCanonicalPath base-dir) File/separatorChar name))]
+    (.setExecutable f true)))
+
+(defn export-files [namespace base-dir name]
+  (export-dependencies namespace base-dir)
+  (make-run-script namespace base-dir name))
+
+(defn bzip-folder [#^java.io.File destination #^java.io.File directory]
+  (apply (partial sw "tar" "-cvjf" (.getCanonicalPath destination))
+	 (concat
+	  (rest
+	   (map #(.replaceFirst
+		  %
+		  (str (.getCanonicalPath directory) File/separatorChar ) "")
+		(map str (file-seq directory))))
+	  [:dir (.getCanonicalPath directory)])))
+
+(defn bzip-export-files [directory target-dir name]
+  (apply (partial sw "tar" "-cvjf"
+		  (str (.getCanonicalPath target-dir) File/separatorChar name))
+	 (concat
+	  [name "lib" "src"]
+	  [:dir (.getCanonicalPath directory)])))
+
+(defn export-archive
+  ([name]
+     (export-archive *ns* name))
+  
+  ([namespace name nailgun?]
+     (binding [*nailgun* nailgun?]
+       (export-archive namespace name)))
+  
+  ([namespace name]
+     (FileUtils/forceMkdir standard-base-directory)
+     (FileUtils/forceDelete standard-base-directory)
+     (FileUtils/forceMkdir standard-base-directory)
+     (let [new-dir
+	   (file-str
+	    (str
+	     (.getCanonicalPath standard-base-directory)
+	     (File/separatorChar)
+	     name))]
+       
+       (export-files namespace new-dir name)
+
+       (bzip-export-files new-dir (file-str "~/coderloop/") (str name "-clojure.tar.bz2"))
+       (FileUtils/copyFileToDirectory
+	(file-str (str "~/coderloop/" name "-clojure.tar.bz2"))
+	(file-str "~/coderloop-test")))))
diff -r 000000000000 -r 307a81e46071 src/find_words.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/find_words.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,174 @@
+(ns coderloop.find-words
+  (:use [clojure.contrib def
+	 [seq :only [indexed]]
+	 [duck-streams :only [read-lines file-str]]]
+	[clojure.java io]
+	[rlm shell-inspect]))
+
+
+
+"I'm going to solve this using convolution because I like how the kernel
+ looks for this problem.  For each word, we build up an asterisk kernel
+ like so:
+
+ {:word \"Robert\"}
+ kernel:
+
+              t    t    t
+               r   r   r
+                e  e  e
+                 b b b
+                  ooo 
+              treboRobert       
+                  ooo           
+                 b b b          
+                e  e  e         
+               r   r   r   
+              t    t    t
+
+isn't it really cute-looking?
+
+Anyways,  I'll drag these asterisks along the word-matrix via convolution
+and use them to build up a transient structure that contains only the matches.
+
+Then, I'll use that transitnt structure to remove all matches from the original
+grid.
+
+I need stuff to do convolutions, to make kernels given a word, to create the
+transient structure, and to remove the entries in the transient structure
+from the original word-grid.  I also need a way to represent a word grid."
+
+(defvar strcat (partial apply str)
+  "flattens a list by glomming everything together in a string.")
+
+(defn word-grid
+  "create a mapping from elements in R^2 to chars"
+  [words]
+  (reduce
+   merge
+   (map (fn [[idx s]]
+	  (zipmap 
+	   (map #(vector (first %) idx) (indexed s))
+	   (seq s)))
+	(indexed words))))
+
+
+(defn bounding-square
+  "finds the minimal square it takes to bound the grid. works for all
+   geometries."
+  [grid]
+  (let [coords (keys grid)
+	xs (sort (map first coords))
+	ys (sort (map second coords))]
+    [(first xs) (last xs) (first ys) (last ys)]))
+
+;;I have no compunctinos with using mutable state in printing
+(defn print-grid* [grid]
+  (let [[x-min x-max y-min y-max] (bounding-square grid)
+	canvas (atom
+		(vec  (for [y  (range  (inc (- y-max y-min)))]
+			(vec  (repeat (inc (- x-max x-min))  ".")))))]
+    (dorun (map (fn [[[x y] c]]
+		  (swap! canvas #(assoc-in % [ (- y y-min) (- x x-min)] c))) grid))
+    @canvas))
+	
+(defn print-grid
+  "nice for debugging but irrelevant for the rest of the problem"
+  [grid]
+  (dorun
+   (for [line (print-grid* grid)]
+     (do (dorun (map print line))
+	 (println)))))
+
+(defn asterisk-kernel [word]
+  (let [span (range (inc (count word)))]
+    (vector
+     (zipmap (map #(vector 0 %)     span) word)
+     (zipmap (map #(vector 0 (- %)) span) word)
+     (zipmap (map #(vector % %)     span) word)
+     (zipmap (map #(vector % (- %)) span) word)
+     (zipmap (map #(vector % 0)     span) word)
+     (zipmap (map #(vector (- %) 0) span) word)
+     (zipmap (map #(vector (- %) %)     span) word)
+     (zipmap (map #(vector (- %)  (- %))     span) word))))
+
+;;this is not lazy :(
+(defn search-grid-at-point [kernel grid [point-x point-y]]
+  (let [shift-kernel
+	(zipmap 
+	 (map (fn [[x y]]
+		[(+ x point-x)
+		 (+ y point-y)])
+	      (keys kernel))
+	 (vals kernel))]
+    (if (= (select-keys grid (keys shift-kernel))
+	   shift-kernel)
+      shift-kernel nil)))
+    
+(defn search-word-kernel
+  "search the grid for a particular kernel and store the reusult in the
+   atom (matches)"
+  [grid kernel]
+  (reduce merge (map (fn [point]
+		       (search-grid-at-point kernel grid point))
+		     (keys grid))))
+
+(defn search-word [grid word]
+  (let [kernels (asterisk-kernel word)]
+    (reduce merge (map #(search-word-kernel grid %) kernels))))
+
+(defn search-words [grid words]
+  (reduce merge (map #(search-word grid %) words)))
+
+(defn remove-matches [grid matches]
+  (apply (partial dissoc grid) (keys matches)))
+
+(defn grid->str [grid]
+  (strcat (vals (apply sorted-map
+		       (interleave (map (comp vec reverse) (keys grid)) (vals grid))))))
+
+(defn read-wordsearch [#^java.io.File input]
+  (let [[crossword words] (split-with (comp not (partial = "")) (read-lines input)) 
+	words (rest words)]
+    [crossword words]))
+
+(defn process-wordsearch [[crossword words]]
+  (let [grid (word-grid crossword)]
+    (grid->str (remove-matches grid (search-words grid words)))))
+
+(defn doit [args]
+  (println
+   (process-wordsearch
+    (read-wordsearch
+     (file-str (first args))))))
+
+;;********************************************************************************
+(if (command-line?)
+  (doit *command-line-args*))
+
+
+(def input (file-str "/home/r/coderloop-test/input.txt"))
+(def a (file-str "/home/r/coderloop-test/findwords-a.in"))
+(def d (file-str "/home/r/coderloop-test/findwords-d.in"))
+(def c (file-str "/home/r/coderloop-test/findwords-c.in"))
+(def e (file-str "/home/r/coderloop-test/findwords-e.in"))
+
+(def test-grid
+      ["ELGOOGWWW"
+       "TIRXMAHIR"
+       "BATMANZNC"
+       "CMRVLTOLD"])
+
+(def test-words
+     ["MAIL"
+      "WIN"
+      "GOOGLE"
+      "TAR"
+      "BATMAN"
+      "CAR"
+      "WWW"
+      "TOLD"
+      "CD"])
+
+
+
diff -r 000000000000 -r 307a81e46071 src/hello_sql.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hello_sql.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,56 @@
+(ns coderloop.hello-sql
+  (:refer-clojure :only [])
+  (:require rlm.ns-rlm rlm.light-base))
+(rlm.ns-rlm/ns-clone rlm.light-base)
+(use 'coderloop.utils)
+
+(use 'clojure.contrib.sql)               ;;' satisfy prettify
+(import 'org.gjt.mm.mysql.Driver)
+
+(def *port* 3306)
+
+(def *host* "localhost")
+
+(defn doit []
+  (let [db-host "localhost"
+	db-port *port*
+	db-name "testdb"]
+    (def db {:classname "com.mysql.jdbc.Driver"
+	     :subprotocol "mysql"
+	     :subname (str "//" db-host ":" db-port "/" db-name)
+	     :user "root"
+	     :password "sql1005025"})
+    (with-connection db
+      (with-query-results rs ["select * from hello_data"]
+	(println rs)))))
+
+
+(defn read-hello-data [[username password db-name]]
+  (let [db-host *host*
+	db-port *port*]
+    (def db {:classname "com.mysql.jdbc.Driver"
+	     :subprotocol "mysql"
+	     :subname (str "//" db-host ":" db-port "/" db-name)
+	     :user username
+	     :password password})
+    (with-connection db
+      (with-query-results rs ["select * from hello_data"]
+	(vec rs)))))
+
+
+
+(defn print-result [args]
+  (let [results (read-hello-data args)]
+    (println
+     (apply str (interpose " " (map :text results))))))
+
+
+(defn slick-test [] (read-hello-data ["root" "sql1005025" "testdb"]))
+
+
+(if (command-line?)
+  (print-result *command-line-args*))
+  
+;; rs will be a sequence of maps,
+;; one for each record in the result set.
+
diff -r 000000000000 -r 307a81e46071 src/hello_world.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hello_world.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,11 @@
+(ns coderloop.hello-world
+  (:use rlm.shell-inspect))
+
+(defn hello-world []
+  (println "Hello World!"))
+
+(if (rlm.shell-inspect/command-line?)
+  (hello-world))
+
+
+	     
diff -r 000000000000 -r 307a81e46071 src/lying.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/lying.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,88 @@
+(ns coderloop.lying
+  (:use [clojure.contrib
+	 [duck-streams :only [read-lines]]
+	 [seq :only [find-first]]
+	 [str-utils :only [re-gsub]]])
+  (:use rlm.shell-inspect)
+  (:use rlm.map-utils)
+  (:use [clojure [string :only [split trim]]]))
+
+
+
+(comment
+6
+JohnDoe   -  1
+MisterBlanko
+JohnTitor -  2
+DirkWhatever
+BrunoJoeConner
+DirkWhatever -  1
+FooBar
+BrunoJoeConner -  2
+JohnTitor
+MisterBlanko
+MisterBlanko   -    1
+DirkWhatever
+FooBar - 3
+DirkWhatever
+BrunoJoeConner
+JohnDoe
+)
+
+
+(def witnesses
+     {:john-doe         [:mister-blanco]
+      :john-tator       [:dirk-whatever :bruno-joe-conner]
+      :dirk-whatever    [:foo-bar]
+      :bruno-joe-conner [:john-tator :mister-blanco]
+      :mister-blanco    [:dirk-whatever]
+      :foo-bar          [:dirk-whatever :bruno-joe-conner :john-doe]})
+
+(def t "/home/r/coderloop-test/test.txt")
+(def a "/home/r/coderloop-test/cluedo-a.in")
+
+(defn parse-file [f]
+  (let [lines (map clojure.string/trim (rest (read-lines f)))]
+    (map-keys
+     (comp (partial re-gsub #"\W*:\W*\d*\W*" "") first)
+     (apply hash-map
+	    (partition-by #(re-matches #".*:.*" %) lines)))))
+     
+
+(defrecord verdict [good bad])
+
+(def initial-verdict (verdict. #{} #{}))
+
+(defn valid-verdict? [num verdict]
+  (and
+   (>= num (+ (count (:good verdict)) (count (:bad verdict))))
+   (not (reduce #(or %1 %2)
+	   (map (:good verdict) (:bad verdict))))))
+
+(defn expand-verdict [judgements [person accuse]]
+  (let [y (flatten
+	   (for [record judgements]
+	     [(verdict. (into (:good record) (vector person))
+			(into (:bad  record) accuse))
+	      (verdict. (into (:good record) accuse)
+			(into (:bad  record) (vector person)))]))]
+;;    (println (count y))
+;;    (dorun (map println y))
+    y))
+
+(defn determine-guilt [witnesses]
+  (let [valid? (partial valid-verdict? (count witnesses))]
+    (filter valid?
+	    (reduce (comp
+		     (partial filter valid?)
+		     expand-verdict)
+		    [initial-verdict] witnesses))))
+
+(defn print-soln [witnesses]
+  (let [verdict  (first (determine-guilt witnesses))
+	group-nums (sort [(count (:good verdict)) (count (:bad verdict))])]
+    (println (str (first group-nums) \: (second group-nums)))))
+
+
+(if (command-line?)
+  (print-soln (parse-file (first *command-line-args*))))
diff -r 000000000000 -r 307a81e46071 src/make-collatz-java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/make-collatz-java	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,7 @@
+#!/bin/bash
+
+mkdir /home/r/coderloop-test/src;
+mkdir /home/r/coderloop-test/src/coderloop;
+cp Collatz.java /home/r/coderloop-test/src/coderloop/Collatz.java;
+cp Collatz.java.run /home/r/coderloop-test/euler14
+cp Collatz.java.ant.xml /home/r/coderloop-test/build.xml
diff -r 000000000000 -r 307a81e46071 src/meep_meep.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/meep_meep.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,5 @@
+(ns coderloop.meep-meep)
+
+(def include true)
+
+(println "Meep meep!")
diff -r 000000000000 -r 307a81e46071 src/meepmeep.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/meepmeep.py	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,2 @@
+#!/usr/bin/python
+print "Meep meep!"
diff -r 000000000000 -r 307a81e46071 src/parallel_io.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/parallel_io.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,158 @@
+(ns coderloop.parallel-io
+    (:refer-clojure :only [])
+  (:require rlm.ns-rlm rlm.light-base))
+(rlm.ns-rlm/ns-clone rlm.light-base)
+
+(import '[java.io FileInputStream RandomAccessFile])
+(use '(clojure.contrib   [str-utils2 :only [join]]))
+(import 'java.util.concurrent.atomic.AtomicLong)
+
+;;(set! *warn-on-reflection* true)
+
+
+
+
+
+;;;; Reading
+
+(defn chunk-file
+  "Partitions a file into n line-aligned chunks.  Returns a list of start and
+  end byte offset pairs."
+  [filename n]
+  (with-open [file (java.io.RandomAccessFile. filename "r")]
+    (let [offsets (for [offset (range 0 (.length file) (/ (.length file) n))]
+		    (do (when-not (zero? offset)
+			  (.seek file offset)
+			  (while (not= (.read file) (int \newline))))
+			(.getFilePointer file)))
+	  offsets (concat offsets [(.length file)])]
+      (doall (partition 2 (interleave offsets (rest offsets)))))))
+
+
+(defn read-lines-range [file start-byte end-byte]
+  "Returns a lazy sequence of lines from file between start-byte and end-byte."
+  (let [reader (-> (doto (java.io.FileInputStream. file)
+		     (.skip start-byte))
+		   (java.io.BufferedInputStream. (* 8 131072))
+		   (java.io.InputStreamReader. "US-ASCII")
+		   (java.io.BufferedReader. 131072))]
+    (letfn [(read-line [remaining]
+		       (lazy-seq
+			(if-let [line (and (pos? remaining) (.readLine reader))]
+			  (cons line (read-line (- remaining (.length line))))
+			  (.close reader))))]
+      (read-line (- end-byte start-byte)))))
+
+(defn #^"[Ljava.lang.String;" dumbest-split
+  [#^String s c #^"[Ljava.lang.String;" tokens]
+  (let [len (dec (int (alength tokens)))]
+    (loop [start (int 0)
+	   i (int 0)]
+      (let [idx (int (.indexOf s (int c) (int start)))]
+	(if (or (neg? idx) (>= i len))
+	  (do (aset tokens i (.substring s start))
+	      tokens)
+	  (do (aset tokens i (.substring s start idx))
+	      (recur (inc idx) (inc i))))))))
+
+(defn parse-lines [lines]
+  (let [ary (make-array String 12)]
+    (for [#^String line lines
+	  :let [fields (dumbest-split line \space ary)
+		status (aget fields 8)
+		bytes (aget fields 9)
+		#^String ref (aget fields 10)]
+	  :when (= (aget fields 5) "\"GET")
+	  :when ('#{"200" "304" "404"} status)]
+      {:client (aget fields 0)
+       :url (aget fields 6)
+       :status status
+       :bytes (if (= bytes "-") 0 (Long/parseLong bytes))
+       :ref (.substring ref 1 (dec (count ref)))})))
+
+;;;; Tallying
+
+(defn bump! [map-atom #^String key #^Long delta]
+  (if-let [#^AtomicLong counter (get @map-atom key)]
+    (.addAndGet counter delta)
+    (swap! map-atom #(assoc % (String. key)
+			    (if-let [#^AtomicLong counter (get % key)]
+			      (AtomicLong. (+ (.get counter) delta))
+			      (AtomicLong. delta))))))
+
+(def article-re #"^/ongoing/When/\d\d\dx/\d\d\d\d/\d\d/\d\d/[^ .]+$")
+
+(defn tally! [{:keys [url-hits url-bytes clients refs s404s]} records]
+  (doseq [{:keys [#^String url bytes client status #^String ref]} records]
+    (if (= status "404")
+      (bump! s404s url 1)
+      (do (bump! url-bytes url bytes)
+	  (when (when (.startsWith url "/ongoing/When/")
+		  (re-matches article-re url))
+	    (bump! url-hits url 1)
+	    (bump! clients client 1)
+	    (when-not (or (= ref "-")
+			  (.startsWith ref "http://www.tbray.org/ongoing/"))
+	      (bump! refs ref 1)))))))
+
+;;;; Reporting
+
+(defn truncate [s n]
+  (if (> (count s) n) (str (.substring s 0 n) "...") s))
+
+(defn print-top10 [results label & [shrink?]]
+  (println "Top" label)
+  (let [fmt (if shrink? " %9.1fM: %s" " %10d: %s")]
+    (doseq [[k v] (take 10 results)]
+      (let [v (if shrink? (/ v 1024.0 1024.0) (long v))]
+	(println (format fmt v (truncate k 60))))))
+  (println))
+
+(defn sort-by-vals-desc [m]
+  (sort-by #(- (val %)) m))
+
+
+
+(defn take-greatest-vals [n m]
+  (when-let [m (seq m)]
+    (reduce (fn [best x]
+	      (if (>= (val x) (val (last best)))
+		(vec (take n (sort-by-vals-desc (conj best x))))
+		best))
+	    [(first m)] (rest m))))
+
+(defn report [tallies state]
+  (->> state
+       (map (fn [[tally rows]] (str (count @rows) " " (name tally))))
+       (join ", ")
+       (println))
+  (println)
+  (->> tallies
+       (pmap (fn [[tally & options]]
+	       (cons (take-greatest-vals 10 (sort-by-vals-desc @(state tally)))
+		     options)))
+       (map #(apply print-top10 %))
+       (dorun)))
+
+						 ;;;; Main
+
+(def tallies [[:url-hits  "URIs by hit"]
+	      [:url-bytes "URIs by bytes" :shrink]
+	      [:s404s	   "404s"]
+	      [:clients   "client addresses"]
+	      [:refs	   "referrers"]])
+
+(defn wf-atoms [file]
+  (let [chunk-count (int (/ (.length (java.io.File. file)) (* 32 1024 1024)))
+	state (zipmap (map first tallies) (repeatedly #(atom {})))]
+    (dorun
+     (pmap (fn [[idx [start end]]]
+	     (println (str "Chunk " idx "/" chunk-count
+			   " (" start " -> " end ")"))
+	     (->> (read-lines-range file start end)
+		  (parse-lines)
+		  (tally! state)))
+	   (indexed (chunk-file file chunk-count))))
+    (time (report tallies state))))
+
+
diff -r 000000000000 -r 307a81e46071 src/reverse_sentence.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/reverse_sentence.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,28 @@
+(ns coderloop.reverse-sentence
+  (:refer-clojure :only [])
+  (:require rlm.ns-rlm rlm.light-base))
+(rlm.ns-rlm/ns-clone rlm.light-base)
+
+
+(undef partition)
+(use '[clojure.contrib [string :only [partition]]])
+(use '[clojure [string :only [blank?]]])
+
+(defn reverse-line [s]
+  (apply str
+	 (flatten 
+	  (map #(if (re-matches #"\w" (str (first %))) (reverse %) %)
+	       (filter (comp not (partial = ""))
+		       (partition #"\w+" s))))))
+
+
+(defn reverse-file [file]
+  (doall
+   (map println
+	(map reverse-line
+	     (read-lines file)))))
+
+
+(if (command-line?)
+  (reverse-file (first *command-line-args*)))
+  
diff -r 000000000000 -r 307a81e46071 src/reverse_seq.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/reverse_seq.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,43 @@
+(ns coderloop.reverse-seq
+  (:use [clojure.contrib
+	 [duck-streams :only [file-str read-lines]]
+	 [str-utils :only [re-split]]])
+  (:use rlm.shell-inspect)
+  (:use [clojure [string :only [trim]]]))
+
+(def c (file-str "/home/r/coderloop-test/reversesequence-c.in"))
+(def a (file-str "/home/r/coderloop-test/reversesequence-a.in"))
+(def b (file-str "/home/r/coderloop-test/reversesequence-b.in"))
+
+(defn test-trace-map []
+  (= [:a :b :c :d :e]
+       (trace-map {:a :b :d :e :c :d :b :c})))
+
+
+(defn read-name-map
+  "takes a file of pairs of names and returns a map from the first
+   element in those pairs to the second element in the pairs."   
+  [#^java.io.File file]
+  (let [pairs  (map #(re-split #"\W+" (trim %)) (read-lines file))]
+    (zipmap (map first pairs) (map second pairs))))
+
+(defn start-linked-map
+  "takes a map-representing-a-list and finds the beginning of that list"
+  [m]
+  (first (remove (set (vals m)) (keys m))))
+
+(defn trace-map
+  "chains through a map-representing-a-list, building a list along the way."
+  [m]
+  (loop [index (start-linked-map m)
+	 chain (vector index)]
+    (let [new-index (get m index ::sentinel)]
+      (if (= new-index ::sentinel)
+	chain
+	(recur  new-index (conj chain new-index))))))
+
+
+
+(if (command-line?)
+  (dorun
+   (map println (reverse (trace-map (read-name-map (file-str (first *command-line-args*))))))))
diff -r 000000000000 -r 307a81e46071 src/reverse_seq.pl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/reverse_seq.pl	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,43 @@
+#!/usr/bin/perl
+
+$a = "/home/r/coderloop-test/reversesequence-a.in";
+$b = "/home/r/coderloop-test/reversesequence-b.in";
+$c = "/home/r/coderloop-test/reversesequence-c.in";
+
+%test_map = ("a" => "b", "b" => "c");
+
+sub create_map{
+  ## creates a "linked map" from a string representing
+  ## the input file.
+  (my $file) = @_;
+  my %map;
+  open FILE, "<".$file or die $!;
+  for (<FILE>){ chomp; /^(\w+)\W+(\w+)$/; $map{$1} = $2;}
+  close FILE;
+  return %map;}
+
+sub find_beginning{
+  ## takes a map representing a linked list and
+  ## returns the beginning of that list.
+  (my %map) = @_;
+  my %val_set = map {$_ => 1} (values %map);
+  my $start;
+  foreach (keys %map){
+    if (!($val_set{$_})){$start = $_;last}}
+  return $start;}
+
+sub trace_map{
+  ## crawls through a map representing a linked-list
+  ## and converts it into an actual array structure.
+  (my %map) = @_;
+  my $position = &find_beginning(%map);
+  my @array = ($position);
+  while(my $new_position = $map{$position}){
+    push (@array, $new_position);
+    $position = $new_position;}
+  return @array;}
+
+
+
+if (defined @ARGV){
+  map {print;print"\n";} reverse(trace_map(create_map($ARGV[0])));}
diff -r 000000000000 -r 307a81e46071 src/reverse_sequence.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/reverse_sequence.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,36 @@
+(ns coderloop.reverse-sequence)
+(use 'clojure.contrib.str-utils)
+;;(use 'rlm.shell-inspect)
+
+;(def *command-line-args* (list "/home/ocsenave/reversesequence-a.in"))
+(def pairs (if (nil? *command-line-args*) '() (map #(re-split #" " %) (re-split #"\r\n" (slurp (first *command-line-args*))))))
+(def p(apply hash-map(reverse(flatten pairs))))
+(print(str-join "\n"((fn l[x](if(nil? x)x (cons x(l(p x))) ))
+		     (first (remove(set(keys p))(vals p))))) "\n")
+
+             
+
+
+
+
+
+;; (ns coderloop.reverse-sequence)
+;; (use 'clojure.contrib.str-utils)
+;; ;;(use 'rlm.shell-inspect)
+
+;; (defn extension[f ip op] (fn[x](if (= x ip) op (f x))))
+
+;; (let[
+;;      ;;*command-line-args* (list "/home/ocsenave/testfile.txt")
+;;      pairs (if (nil? *command-line-args*) '()  (map #(re-split #" " %) (re-split #"\n" (slurp(first *command-line-args*)))))
+;;      predecessor (reduce #(extension %1 (second %2)(first %2)) (fn[x]nil) pairs)
+;;      terminus (first(remove(set(map first pairs))(map second pairs)))
+;;      ]
+;;   (defn lineage[x](if(nil? x)nil (cons x(lineage (predecessor x)))))
+;;   (print (str-join "\n" (lineage terminus)))
+;;   )
+
+
+;;(if (command-line?)
+;;  (do-something-to *command-line-args*))
+
diff -r 000000000000 -r 307a81e46071 src/scientist2.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/scientist2.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,197 @@
+(ns coderloop.scientist2
+  (:refer-clojure :only [])
+  (:require rlm.ns-rlm rlm.light-base))
+(rlm.ns-rlm/ns-clone rlm.light-base)
+
+
+(use 'clojure.contrib.sql)
+(import 'org.gjt.mm.mysql.Driver)
+(use 'clojure.contrib.sql)
+(undef distinct case compile drop take sort)
+(use 'clojureql.core)
+(import 'java.io.File)
+(use '[clojure.java.io :only [copy]])
+(use '[clojure.contrib.shell-out :only [sh]])
+(use '[clojure.string :only [split]])
+(use '[coderloop [utils :only [md5]]])
+(import 'java.sql.Date)
+
+
+
+(def *port* 3306)
+
+(def *host* "localhost")
+
+(def *db-host* "localhost")
+
+(def *db-name* "clojure_rlm")
+
+(def *db* {:classname "com.mysql.jdbc.Driver"
+	   :subprotocol "mysql"
+	   :subname (str "//" *db-host* ":" *port* "/" *db-name*)
+	   :user "root"
+	   :password "sql1005025"})
+
+(def databases [:essay_scientists :scientists :ideas :scientist_whereabouts])
+
+
+
+
+(declare essays essay century contemps data eric scientists date->str date)
+
+(defn scientists []
+  @(table *db* :essay_scientists))
+
+
+(defn contemps [s birth death]
+  (sort-by (fn [s] [(:surname s) (:name s)])
+	   (map #(select-keys % [:name :surname])
+		@(select
+		  (table *db* :scientists)
+		  (where
+		   (and
+		    (< :birth_date death)
+		    (< birth :death_date)
+		    (not (= :name (:name s)))))))  ))
+	   
+(defn data [s]
+  (let [locations
+	(sort-by
+	 :immigration_date
+	 (map #(select-keys % [:immigration_date :emigration_date :country])
+		      @(select
+			(table *db* :scientist_whereabouts)
+			(where
+		 (and
+		  (= :scientist_whereabouts.surname (:surname s))
+		  (= :scientist_whereabouts.name (:name s)))))))
+	 ideas
+	(sort-by
+	 #(.toLowerCase %)
+	 (map :idea
+	      @(select
+		(table *db* :ideas)
+		(where
+		 (and
+		  (= :ideas.surname (:surname s))
+		  (= :ideas.name (:name s)))))))
+	data
+	(first
+	 @(select
+	   (table *db* :scientists)
+	   (where
+	    (and 
+	     (= :scientists.surname (:surname s))
+	     (= :scientists.name (:name s))))))
+	birth (:birth_date data)
+	death (:death_date data)
+	contemp (contemps s birth death)]
+    (merge data {:locations locations :contemps contemp  :ideas ideas})))
+     
+(defn date->str [#^java.sql.Date d]
+  (format "%02d/%02d/%04d"  (.getDate d) (inc (.getMonth d)) (+ 1900 (.getYear d))))
+
+(def strcat (partial apply str))
+
+(defn century [#^java.sql.Date d]
+  (* 100 (clojure.core/unchecked-divide (+ 1900 (.getYear d)) 100)))
+
+(defn essay-map [s]
+  (let [base (data s)
+	locations
+	(strcat
+	 (interpose
+	  ", "
+	  (map (fn [{:keys [emigration_date immigration_date country ]}]
+		 (str country " from " (date->str immigration_date) " to "
+		      (date->str emigration_date))) (:locations base))))
+	contemps
+	(strcat
+	 (interpose
+	  ", "
+	  (map (fn [{:keys [name surname]}]
+		 (str name " " surname))
+	       (:contemps base))))
+	birth-date (date->str (:birth_date base))
+	death-date (date->str (:death_date base))
+	century (century (:birth_date base))
+	lifespan
+	(str "["
+	     (:birth_place base) " " birth-date ", "
+	     (:death_place base) " " death-date
+	     "]")
+	ideas (strcat (interpose ", " (:ideas base)))
+	]
+    {:lifespan lifespan :name (:name base) :surname (:surname base)
+     :contemps contemps :locations locations :century century :ideas ideas}))
+
+(defn essay [s]
+  (let [{:keys [lifespan name surname contemps locations century ideas]} (essay-map s)]
+    (str name " " surname " " lifespan " is one of the most famous scientists of "
+	 century ". "
+	 "Between all " name "'s ideas we mention: " ideas ". "
+	 name " lived in: " locations ". "
+	 name " was a contemporary of " contemps ".\n\n"))) 
+	 
+(defn essays []
+  (map essay (scientists)))
+
+(defn print-essays []
+  (dorun (map print (essays))))
+
+(defn essays->str []
+  (strcat (essays)))
+
+(defn main [[username password db-name]]
+  (let [db-host *host*
+	db-port *port*
+	db {:classname "com.mysql.jdbc.Driver"
+	    :subprotocol "mysql"
+	    :subname (str "//" db-host ":" db-port "/" db-name)
+	    :user username
+	    :password password}]
+    (binding [*db* db]
+      (print-essays))))
+
+(if (command-line?)
+  (main *command-line-args*))
+    
+    
+
+
+
+(def eric {:name "Erik 3802" :surname "Green 3802"})
+(def date (java.sql.Date. 4564654645))
+
+
+
+(defvar error-person
+  {:name "Albert 3850" :surname "Newton 3850"}
+  "this is the person in in which John 5750 is supposedly
+   wrongly included my code says they're contempoaries,
+   but the expected output disaggrees ")
+
+(defvar wrong-include
+  {:name "John 5750" :surname  "Newton 5750"}
+  "this one is inculded and supposedly should not be.")
+
+;;coderloop.scientist2> (select-keys (data error-person) [:birth_date :death_date])
+;;{:death_date #<Date 0226-10-18>, :birth_date #<Date 0166-10-16>}
+;;coderloop.scientist2> (select-keys (data wrong-include) [:birth_date :death_date])
+;;{:death_date #<Date 0226-01-01>, :birth_date #<Date 0166-12-30>}
+
+;; these exibit the same problem. They appear to be contemps,
+;; but the expected output says that they're not!
+(defvar error-person2
+  {:name "Erik 3851" :surname "Smith 3851"})
+
+(defvar wrong-include2
+  {:name "Gil 5751" :surname "Smith 5751"})
+
+;;coderloop.scientist2> (select-keys (data error-person2) [:birth_date :death_date])
+;;{:death_date #<Date 0227-10-19>, :birth_date #<Date 0167-10-17>}
+;;coderloop.scientist2> (select-keys (data wrong-include2) [:birth_date :death_date])
+;;{:death_date #<Date 0227-01-02>, :birth_date #<Date 0167-12-31>}
+
+
+
diff -r 000000000000 -r 307a81e46071 src/scientist_sql.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/scientist_sql.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,317 @@
+(ns coderloop.scientist-sql
+  (:refer-clojure :only [])
+  (:require rlm.ns-rlm rlm.light-base))
+(rlm.ns-rlm/ns-clone rlm.light-base)
+
+
+(use 'clojure.contrib.sql)               ;;' satisfy prettify
+(import 'org.gjt.mm.mysql.Driver)
+(use 'clojure.contrib.sql)
+(import '[org.joda.time LocalDate ])
+(undef distinct case compile drop take sort)
+(use 'clojureql.core)
+(import 'org.joda.time.DateMidnight)
+(import 'java.io.File)
+(use '[clojure.java.io :only [copy]])
+(use '[clojure.contrib.shell-out :only [sh]])
+(use '[clojure.string :only [split]])
+(use '[coderloop [utils :only [md5]]])
+
+(defn sql-date [date]
+  "Convert any Joda-readable date object (including a string) to a java.sql.Date"
+    (java.sql.Date. (.. (LocalDate. date) toDateMidnight toInstant getMillis)))
+
+(def *port* 3306)
+
+(def *host* "localhost")
+
+(def *db-host* "localhost")
+
+(def *db-name* "clojure_rlm")
+
+(def *db* {:classname "com.mysql.jdbc.Driver"
+	   :subprotocol "mysql"
+	   :subname (str "//" *db-host* ":" *port* "/" *db-name*)
+	   :user "root"
+	   :password "sql1005025"})
+
+(def *db2* {:classname "com.mysql.jdbc.Driver"
+	    :subprotocol "mysql"
+	    :subname (str "//" *db-host* ":" *port* "/" "test_rlm")
+	    :user "root"
+	    :password "sql1005025"})
+
+
+(def databases [:essay_scientists :scientists :ideas :scientist_whereabouts])
+
+(defmacro no-exceptions
+  "Sweet relief like I never knew."
+  [& forms]
+  `(try ~@forms (catch Exception e# (.printStackTrace e#))))
+
+
+(defn make-essay-scientists []
+  (with-connection
+    *db2*
+    (no-exceptions (drop-table :essay_scientists))
+    (create-table
+     :essay_scientists
+     [:id "integer"]
+     [:name "varchar(255)"]
+     [:surname "varchar(255)"])
+    (insert-rows :essay_scientists
+		 [1 "Isaac" "Newton"]
+		 [2 "Albert" "Einstein"])))
+
+(defn make-scientists []
+  (with-connection
+    *db2*
+    (no-exceptions (drop-table :scientists))
+    (create-table
+     :scientists
+     [:name "varchar(255)"]
+     [:surname "varchar(255)"]
+     [:birth_place "varchar(255)"]
+     [:death_place "varchar(255)"]
+     [:birth_date "date"]
+     [:death_date "date"])
+    (insert-rows
+     :scientists
+     ["Albert" "Einstein" "Ulm" "Princeton" "1879-3-14" "1955-4-18"]
+     ["Galileo" "Galilei" "Pisa" "Arcetri" "1564-2-15" "1645-1-8"]
+     ["Enrico" "Fermi" "Roma" "Chicago" "1901-9-29" "1954-9-28"]
+     ["Isaac" "Newton" "Woolsthorpe-by-Colsterworth" "London" "1643-1-4" "1727-3-31"]
+     ["Marx" "Planck" "Kiel" "Göttingen" "1858-4-23" "1947-10-4"])))
+
+
+(defn make-scientist-whereabouts []
+  (with-connection *db2*
+    (no-exceptions (drop-table :scientist_whereabouts ))
+    (create-table
+     :scientist_whereabouts
+     [:name "varchar(255)"]
+     [:surname "varchar(255)"]
+     [:country "varchar(255)"]
+     [:immigration_date "date"]
+     [:emigration_date "date"])
+    (insert-rows
+     :scientist_whereabouts
+     ["Galileo" "Galilei" "France" "1602-2-18" "1604-4-20"]
+     ["Albert" "Einstein" "Uk" "1901-10-22" "1905-5-4"]
+     ["Marx" "Planck" "Denmark" "1901-1-31" "1945-7-4"]
+     ["Albert" "Einstein" "France" "1908-11-7" "1930-3-12"]
+     ["Enrico" "Fermi" "Us" "1924-12-19" "1954-9-28"]
+     ["Isaac" "Newton" "Uk" "1688-9-8" "1690-7-12"]
+     ["Albert" "Einstein" "US" "1935-10-22" "1955-4-18"]
+     ["Isaac" "Newton" "Germany" "1690-9-28" "1705-4-6"])))
+
+
+(defn make-ideas []
+  (with-connection *db2*
+    (no-exceptions (drop-table :ideas))
+    (create-table
+     :ideas
+     [:name     "varchar(255)"]
+     [:surname  "varchar(255)"]
+     [:idea     "varchar(255)"])
+    (insert-rows
+     :ideas
+     ["Albert" "Einstein" "Theory of relativity (general)"]
+     ["Enrico" "Fermi" "First nuclear reactor"]
+     ["Albert" "Einstein" "Photoelectric effect"]
+     ["Isaac" "Newton" "Gravity"]
+     ["Galileo" "Galilei" "Telescope"]
+     ["Albert" "Einstein" "Theory of relativity (special)"]
+     ["Isaac" "Newton" "Dark matter"])))
+
+(defn clear-tables []
+  (with-connection *db2* (dorun (map drop-table databases))))
+
+(defn fill-tables []
+  (make-ideas)
+  (make-essay-scientists)
+  (make-scientist-whereabouts)
+  (make-scientists))
+
+(defn make-empty-tables []
+  (with-connection *db2*
+    (create-table
+     :ideas
+     [:name     "varchar(255)"]
+     [:surname  "varchar(255)"]
+     [:idea     "varchar(255)"])
+    (create-table
+     :scientist_whereabouts
+     [:name "varchar(255)"]
+     [:surname "varchar(255)"]
+     [:country "varchar(255)"]
+     [:immigration_date "date"]
+     [:emigration_date "date"])
+    (create-table
+     :scientists
+     [:name "varchar(255)"]
+     [:surname "varchar(255)"]
+     [:birth_place "varchar(255)"]
+     [:death_place "varchar(255)"]
+     [:birth_date "date"]
+     [:death_date "date"])
+    (create-table
+     :essay_scientists
+     [:id "integer"]
+     [:name "varchar(255)"]
+     [:surname "varchar(255)"])))
+
+(def fill-tables-command  "mysql -u root -p clojure_rlm < scientists-a.in")
+
+    
+
+(defmethod < [java.sql.Date  java.sql.Date] [a b]
+	   ({-1 true 0 false 1 false}
+	   (.compareTo a b)))
+
+(defmethod > [java.sql.Date  java.sql.Date]
+  ([a b]
+     ({-1 true 0 false 1 false}
+      (.compareTo a b))))
+
+
+;; they can have the same date of birth and death!!!
+(defn contemps [birth death]
+  (with-connection *db*
+    @(select
+      (table :scientists)
+      (where
+       (or
+	(and (<= :birth_date birth) (< birth :death_date))
+	(and  (< :birth_date death) (<= death :death_date))
+	(and  (<=  birth :birth_date) (< :birth_date death))
+	(and  (<  birth :death_date) (<= :death_date death)))))))
+
+(defn essay-scientists []
+  @(table *db* :essay_scientists))
+
+(defn get-info [table-name s]
+  @(select 
+    (select (table *db* table-name)
+	    (where (= :name (:name s))))
+    (where(= :surname (:surname s)))))
+
+(defn century* [#^java.sql.Date d]
+  (* 100
+     (.getCenturyOfEra
+      (LocalDate. d))))
+
+
+(defn century [#^java.sql.Date d]
+  (* 100 (clojure.core/unchecked-divide (+ 1900 (.getYear d)) 100)))
+
+
+
+(defn get-scientist-data [s]
+  (let [data (first (get-info :scientists s))
+	locations (get-info :scientist_whereabouts s)
+	ideas (map :idea (get-info :ideas s))
+	birth (:birth_date data)
+	death (:death_date data)
+	name (:name data)
+	surname (:surname data)
+	contemps
+	(remove #(and (= (:name %) name) (= (:surname %) surname))
+		(map #(select-keys % [:name :surname])
+		     (contemps birth death)))
+	century (century birth)]
+    {:data data :ideas ideas :locations locations :contemps contemps :century century}))
+
+(defn essay-date* [#^java.sql.Date d]
+  (let [t (LocalDate. d)]
+    (format "%02d/%02d/%04d" (.getDayOfMonth t) (.getMonthOfYear t) (.getYear t))))
+
+(defn essay-date [#^java.sql.Date d]
+  (format "%02d/%02d/%04d" (.getDate d) (inc (.getMonth d)) (+ 1900 (.getYear d))))
+  
+(defn fucked-sort [m]
+  (let [surname (:surname m)
+	name (:name m)
+	[surname n1] (.split surname " ")
+	[name n2] (.split name " ")
+	n1 (Integer/parseInt n1)
+	n2 (Integer/parseInt n2)]
+    [surname n1 name n2]))
+
+(defn lexical-sort [m]
+  (let [surname (:surname m)
+	name (:name m)]
+    [surname name]))
+  
+
+(defn-memo essay [s]
+  (let [info (get-scientist-data s)
+	name (:name (:data info))
+	surname (:surname (:data info))]
+       (str name
+	    " "
+	    surname
+	    " ["
+	    (:birth_place (:data info))
+	    " "
+	    (essay-date (:birth_date (:data info)))
+	    ", "
+	    (:death_place (:data info))
+	    " "
+	    (essay-date (:death_date (:data info)))
+	    "]"
+	    " is one of the most famous scientists of "
+	    (:century info)". "
+	    "Between all " name "'s ideas we mention: "
+	    (apply str (interpose ", " (sort (:ideas info))))
+	    ". "
+	    name " lived in: "
+	    (apply
+	     str
+	     (interpose ", "
+			(map
+			 (fn [entry]
+			   (str (:country entry)
+				" from "
+				(essay-date (:immigration_date entry)) " to "
+				(essay-date (:emigration_date entry))))
+			 (sort-by :immigration_date  (:locations info)))))
+	    ". "
+	    name
+	    " was a contemporary of "
+	    (apply
+	     str
+	     (interpose
+	      ", "
+	      (map (fn [entry]
+		     (str (:name entry)
+			  " "
+			  (:surname entry)))
+		   
+		   (sort-by lexical-sort
+			    (:contemps info)))))
+	     ".\n\n" )))
+
+(defn essays []
+  (map essay (essay-scientists)))
+
+
+(defn main [[username password db-name]]
+  (let [db-host *host*
+	db-port *port*
+	db {:classname "com.mysql.jdbc.Driver"
+	    :subprotocol "mysql"
+	    :subname (str "//" db-host ":" db-port "/" db-name)
+	    :user username
+	    :password password}]
+    (binding [*db* db]
+      (print (apply str (essays))))))
+
+(def desired-md5 "e436d54f87c86bffb5d1b38d5f3e136b")
+
+(if (command-line?)
+  (main *command-line-args*))
+    
+    
+	    
+
diff -r 000000000000 -r 307a81e46071 src/shazoooooooo.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/shazoooooooo.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,20 @@
+(ns coderloop.shazoooooooo)
+(use 'coderloop.utils)
+
+
+
+
+
+(defn shazzooom [n]
+  (dorun 
+   (map #(cond (and (= 0 (rem % 3)) (= 0 (rem % 7)))
+	       (print"Shazoo!\n")
+	       (= 0 (rem % 3))
+	       (print "Moo\n")
+	       (= 0 (rem % 7))
+	       (print "Muu\n"))
+	(range 1 (inc n)))))
+
+
+(if *command-line-args*
+   (shazzooom (read-integer (first *command-line-args*))))
diff -r 000000000000 -r 307a81e46071 src/spy.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/spy.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,95 @@
+(ns coderloop.spy
+  (use rlm.ns-rlm)
+  (use [clojure.contrib [string :only [trim]]])
+  (use clojure.java.io)
+  (use rlm.shell-inspect)
+  (use [clojure.contrib [duck-streams :only [read-lines slurp*]]]))
+
+;;(rlm.ns-rlm/ns-clone rlm.light-base)
+
+
+
+(def data "Yvru hlrikvi, Dljbrjy zj jgvrbzex. Kyv jvtivk ivtzgv wfi kyv wrdflj Tfuvicffg vevixp uizeb zj efn befne.")
+
+(def rotate? 69)
+
+
+(def data-2 "71ds7
+!45DMUXLY?IQI9uYr MI2zQBhOQPzOx Hs2OfOVK8YV9W? gCF!UL9onPax,?AE1!U9wDTaCl6Dc vpM0EAMF?snpWCDpyTG1TIUGcq1x3
+GnNnon,t!wRERh o6DcD 4ElBLHSd3fOh1w FjnVJasWNYdIwmh2FfCy")
+
+
+
+(def data-3
+     "-80
+b1LxafSh9m
+SRKJy3FB5aHYVEyzYTUmvM!hrU1LS Onve!IW7LTyyVwgu gAhF?v9XzVMooq6SczGm. 1GeNd xMzSP8bFsce
+.sxcauv2G4e78UDdlit xHqCEIJ?mq7yXv!? lsneLk hq9HMqhZ?OF5 TwY0tyzeOM825myFL4r32!
+jzIzpRWDlFFl?f0VxNSpK6ASH6YZ 2IXPU.7oHBMOI!Fq1cdExFRsJm! o45gBS,zF.AO!PfYG q0DJF T
+jeZamr jLz1Y,0.1NoFwrPzXOejWV2x6W V0fsisEau4zhvrK3b3 !ObV!, tmmEb0D6qr
+xDyrh7cKGUnAgeR8!G.i2yK !JC.1wen12Tz,wl8GO0rwSn czJT!WSshzgzI0BA3WbtI sTTt9 ZoudC4?4RFn,iHNtIRxBrMw?TdI
+JJvK,ds2yi,rpafNlu7wYt! 8lhSBu7P4sesKJllvyOz1wode OhVDL qwowelZXTiEfvsDfFV40Gjf KvIj2y4
+IiUoIyBd6H8r2 I0cDYkrfN3O cF?X Y7AqEculz4jFxrS.Fa.t S7YkXc
+N?aPxe747sfXoDezv.M3LA TUhT67.rLpDdcm VkH27x9bJtOanedL?? Hwt8c5mkXDJ.bv UqvT
+8ByXq4!3urp4cW1 SffqmrfAzdzEMtPJ.ridlaWT ALlzEgsnZzMq5 EzsMnbe?MJzsx?DF8FWi cBRECtT.no5AWGq.
+iB17xp.1wv0FRklW3 dlAOMrIRAT 19h4?frfRi BkzWHAuZvM xd3epKg0Ky8vU?OZVjkonHD9TFu
+170r 3HDC ERCECa5VcO Z6iKYjhFR50N6pr,?.5f3Mm9 Z5pdLlgGGuG
+OPYKRPG966.t2UoG6mb9jE wt052uClYUnLo3Um,RbjKwMTt1xqz4 KmIEg5 E5gtHIld.a.MY99M qDDzg0
+tnt,Gp9Okg8trkMfA tAYuSTbzy!5zznCH K,bc 9bHqBWJ y3HyobsD2G7.jVznh21UUUuTw2
+!PI7p GDvl, d6wOhHqHrjZZ5VxOHrN96a8n DsPrfFGd4z CEIupKxlhi1sMFqJio.EvgWzBfkga9
+fEtMx4AXdkMI?U2Y4h.0PVXty4T6UT ?aICKEEjlt xhJphCJWEesfMDzhYw2ekRr gwxCXe5IYD,kJY6Sgp, uNTw0KPlf6OYuBF
+jZRmGFJSIEmrvbbfrxRq8iSdfid okWKno.vw8B5Dqm1FCX,1qg!O,S X,YYX NACZx1Z?.GhyZrfy XDYLW,iFMVIMvkex
+gjejzPt9suoM H PH?n0WvLs6ccf7OHe,p O8xMqg16sZg8J kIsVyaS!4,,I9R0pV
+o cToV UWxTjH3v2PG jYKW XWEWZbopjFYMcPk1B3zK,KBCTWnV
+ZI7XRVav DVDDlkVJaaD1o3 t7yDmwqn7oZMYcY9hV o6qYGGbM0CG .Dd4tNkUJ
+XbN?bNV,WYuAZ2JeFKkNPyVxTB 4zLI.rbmGs06B0rG jUi gI6, Rk2Um.
+17jgXKpFJkILPTP1 1gHYe8kwjbFJO3ZNdjorLv2?5EF z92OgAO0Z?vlS2.iv,xOya5mK cE5 WTjOjDT!EVp189vvjgkUw8xrl9e
+EaoeuKwTSDJzc?Rz!ZJyhvv sh0ShfWp5ZJrO6YiAJ9eAO52PDO!1Z lkJ3GqP.nS8 i5WD8iE mVadphvgywr
+X23f H LbPjYK5EJcMoBjDiNnTvYDb9cT393 PDfjofvln7A!nGbss TZcTG3TmMKkFO!
+vz4NJ 2IiuxrIdX!?aRIiKg auth9 xv0rZKH3VumHa,p?odN7px I5k4oE4M5pNkrawk,eL
+6YlwoD0 v,x4tV?Xcu WX?8 RtoFM!BI3q7iw6Ihw6dePR3vY GzWEfo!GvEY!R3gMaSJm27jUc!mUm
+!vDL2l2uvp1ve pZXFVjvLhThYJJWx1Li bziUJS9ZCeKwf 41HoBr7nrF?A4rPdnu5LBD CGniTXB5P6B7Yu3naAbe8Gxa.
+U0nbg mGO5iU?!O5 Prs5Fw mtgzIS9hRl0?Sl0igj5WaISN 86XDtwtcPHmmFI5sIv0vwkRVe
+wr90G77hBpRwEk4 JZ4EvB2x!pVF01?vi,vsxtM? hkfHf TgJbPOUADYzN0RBx13ijp ,d
+XCGgky FjSX?pb6r2IqHOcYGZl.RyR6wyDP0 GE cg3E71.1Ye0R6Za mNPAiK?6RG5.O
+1ujx1fn XpGX7DaWCCnUEIj7E2 ApVDhCoS8J5mimw7i!X67diPl ?h?tm2 774BnMY.JoUxyRTOqNKHxduf
+OUA3Ma IV5xk7lvk6i0L1N FbB56xzPBuS77wxHEt7spidOfANs3d Z4q61cXGfGcbDLN V9MCnwi4OkG9fmmihRgyw3gSY8w
+LAykYnorzLjr? rVWT33nySaS!tT!fcCh1okf P4e lUiPr4mi?M9HrS0Xo15E5d9iAd!SW I8ruOUr35gG5p,LrJ1iF9cl7Zpz4
+.NHx52BPj6JCCFw2UcCLYKJe,Hic bzWrkHke ")
+
+(defn decryptor [n]
+  (let [ALAPHABET (reverse (map char (range 65 91)))
+	alaphabet (reverse (map char (range 97 123)))
+	n (if (> 0 n) (+ 26 (rem n 26)) n)]
+    (fn [c]
+      (first
+       (drop n
+	     (drop-while
+	      (comp not #{c})
+	      
+	      
+	      (cond (Character/isUpperCase c) (cycle ALAPHABET)
+		    (Character/isLowerCase c) (cycle alaphabet)
+		    true                      (repeat c))))))))
+
+(defn decrypt [n s]
+  (apply str (map (decryptor n) (seq s))))
+
+(defn str->int [s]
+  (Integer/parseInt (trim s)))
+
+(def a ["/home/r/coderloop-test/spiesstory-a.in"])
+
+
+(defn doit [a]
+  (let [lines (read-lines (first a))
+	num (str->int (first lines))
+	text (rest lines)]
+    (dorun (map
+	   (fn [line]
+	     (println (decrypt num line)))
+	   text))))
+
+(if (command-line?)
+  (doit *command-line-args*))
+    
diff -r 000000000000 -r 307a81e46071 src/stalk.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/stalk.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,13 @@
+(ns coderloop.stalk
+  (:use rlm.shell-inspect)
+  (:require [clojure.contrib [duck-streams :as ds]])
+  (:use [clojure.contrib [def]])
+
+  )
+
+
+
+(defn info [username]
+
+  (ds/slurp*
+   (str "http://api.coderloop.com/1/users/show.json?username=" username)))
diff -r 000000000000 -r 307a81e46071 src/test_mega_tree.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/test_mega_tree.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,41 @@
+(ns coderloop.test-mega-tree)
+
+(rlm.ns-rlm/ns-clone rlm.light-base)
+(import '[com.coderloop.puzzles Megafasttree Megafasttree$Node])
+
+
+(defn node [n]
+  (Megafasttree$Node. n))
+
+
+(defn tree [root]
+  (doto (Megafasttree.)
+    (.addRoot root)))
+
+
+(defn make-counter []
+  (let [a (atom -1)]
+    (fn count [] (swap! a inc))))
+
+
+(defn make-big-ass-tree [depth]
+  (let [counter (make-counter)
+	root (node (counter))]
+    (loop [base [root]
+	   level 0]
+      (if (= level depth)
+	(tree root)
+	(do
+	  (dorun (map
+		  #(doto %
+		     (.setLeftChild (node (counter)))
+		     (.setRightChild (node (counter))))
+		  base))
+	  (recur
+	   (apply concat (map #(vector (.toLeft %) (.toRight %))
+			base))
+	   (inc level)))))))
+	   
+
+(defn test-shittiness [n]
+  (time (do (.bfs (make-big-ass-tree n)) nil)))
diff -r 000000000000 -r 307a81e46071 src/top_five.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/top_five.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,171 @@
+(ns coderloop.top-five)
+
+
+(use 'rlm.shell-inspect)
+(use 'clojure.contrib.profile)
+(use '[clojure.contrib [duck-streams :only [file-str read-lines *default-encoding*]]])
+(import '(java.nio ByteBuffer CharBuffer)
+	'(java.io PushbackReader InputStream InputStreamReader
+		  FileInputStream))
+
+
+
+;;  ^{:doc "Name of the default encoding to use when reading & writing.
+;;   Default is UTF-8."
+;;     :tag "java.lang.String"}
+;;  *default-encoding* "US-ASCII")
+;;(set! clojure.contrib.duck-streams/*default-encoding* "US-ASCII")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+ (def a (file-str "/home/r/coderloop-test/topfive-a.in"))
+ (def b (file-str "/home/r/coderloop-test/topfive-b.in"))
+ (def c (file-str "/home/r/coderloop-test/topfive-c.in"))
+ (def d (file-str "/home/r/coderloop-test/topfive-d.in"))
+ (def e (file-str "/home/r/coderloop-test/topfive-e.in"))
+ (def f (file-str "/home/r/coderloop-test/topfive-f.in"))
+
+(defn get-query-slow [s]
+     (nth (re-matches #"^.*, query=(.*)]$" s) 1))
+
+(defn #^java.lang.String get-query [#^java.lang.String s]
+   (.substring s (clojure.core/+ (.lastIndexOf s "query=") 6) (clojure.core/- (.length s) 1)))
+
+
+(defn chuncked-pmap
+  "helps with paralleization of functions that don't take
+   very much time to execute"  
+  [n f coll]
+  (apply concat
+   (pmap
+    (fn [coll]
+      (doall (map f coll)))
+    (partition-all n coll))))
+
+
+;; (def *main-map* (atom {}))
+
+;; (declare parse-lines tally!)
+
+;; (defn parse-lines [lines]
+;;   (map get-query lines))
+
+;; (defn tally! [state parsed-lines]
+;;   (doseq [element parsed-lines]
+;;     (bump! state element 1)))
+
+
+;; (defn analyze-log [file]
+;;   (let [chunk-count (int (/ (.length #^java.io.File file) (* 32 1024 1024)))
+;; 	state (atom {})]
+;;     (dorun
+;;      (pmap (fn [[idx [start end]]]
+;; 	     (println (str "Chunk " idx "/" chunk-count
+;; 			   " (" start " -> " end ")"))
+;; 	     (->> (read-lines-range file start end)
+;; 		  (parse-lines)
+;; 		  (tally! state)))
+;; 	   (indexed (chunk-file file chunk-count))))
+;;     state))
+
+
+
+
+;; (defn preduce-full
+;;   "a parallel reduce. Because it is parallel, the reducing
+;;    function must make sense in a tree-reducing context"
+;;   [num-chunks mapping-function f coll]
+;;   (loop [prev coll]
+;;     (let [new-coll
+;; 	  (concat
+;; 	   (mapping-function 
+;; 	    (partial apply f)
+;; 	    (partition-all num-chunks prev)))]
+;;       (if (not (next new-coll))
+;; 	(first new-coll)
+;; 	(recur new-coll)))))
+
+
+
+
+
+;;; correctness before speed:
+(defn top-five-0 [file]
+  (binding [*default-encoding* "US-ASCII"]
+    
+    (map
+     first
+     (take
+      5
+      (reverse
+       (sort-by second
+		(reduce
+		 (partial merge-with +)
+		 (map frequencies
+		      (partition-all 2 (map get-query (read-lines file)))))))))))
+"Elapsed time: 34440.153889 msecs"
+"Elapsed time: 21072.141885 msecs"
+"Elapsed time: 21041.711202 msecs"
+;; now let's do speed:
+(defn top-five-1 [file]
+  (map
+   first
+   (take
+    5
+    (sort-by (comp - second)
+	     (reduce
+	      (partial merge-with +)
+	      (map frequencies
+		   (partition-all
+		    800 (map get-query (read-lines file)))))))))
+
+
+(defn top-five-3 [file]
+  (map
+   first
+   (take 5
+	 (sort-by (comp - second)
+		  (frequencies
+		   (map get-query (read-lines file)))))))
+
+
+
+"Elapsed time: 12877.194194 msecs"
+"Elapsed time: 12282.975191 msecs"
+;; got a factor of 2x increase in speed from a larger partition and chuncked-pmap.
+;; still too slow....
+
+;;; let's try the "make it all one big function" approach
+;;(set! *warn-on-reflection* true)
+
+(defn top-five-2 [file]
+
+  (let [*top-5* (atom (vector :a :b :c :d :e))
+	*data* (atom {})]
+    
+    (letfn [(top-ten-helper
+	     [line]
+	     (let [query (get-query line)]
+	       (swap! *data* #(assoc % query (inc (get @*data* query 0))))
+	       (if (> (@*data* query 0) (get @*data* (nth @*top-5* 0) 0))
+		 (do
+
+		   (if-not (contains? (set @*top-5*) query)
+		     (do 
+		       (swap! *top-5* #(assoc % 0 query))
+		       (swap! *top-5*
+			      (fn [v] (vec (sort-by #(get @*data* % 0) v))))))))))]
+
+      (dorun (chuncked-pmap 800 top-ten-helper (read-lines file)))
+      (swap! *top-5*
+	     (fn [v] (vec (sort-by #(get @*data* % 0) v))))
+      (reverse @*top-5*))))
+"Elapsed time: 10735.897831 msecs" ;; with chuncked-pmap
+
+	
+    
+  
+(if (command-line?)
+  (do
+    (dorun (map println (top-five-3 (file-str (first *command-line-args*)))))
+    (System/exit 0)))
diff -r 000000000000 -r 307a81e46071 src/top_five2.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/top_five2.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,37 @@
+(ns coderloop.top-five2
+  (:refer-clojure :only [])
+  (:require rlm.ns-rlm rlm.light-base))
+(rlm.ns-rlm/ns-clone rlm.light-base)
+
+(use 'coderloop.parallel-io)
+
+(def a (file-str "/home/r/coderloop-test/topfive-a.in"))
+(def b (file-str "/home/r/coderloop-test/topfive-b.in"))
+(def c (file-str "/home/r/coderloop-test/topfive-c.in"))
+(def d (file-str "/home/r/coderloop-test/topfive-d.in"))
+(def e (file-str "/home/r/coderloop-test/topfive-e.in"))
+(def f (file-str "/home/r/coderloop-test/topfive-f.in"))
+
+(set! *warn-on-reflection* true)
+
+(defn #^"[Ljava.lang.String;" dumbest-split*
+  [#^String s c #^"[Ljava.lang.String;" tokens]
+  (let [len (dec (int (alength tokens)))]
+    (loop [start (int 0)
+	   i (int 0)]
+      (let [idx (int (.indexOf s (int c) (int start)))]
+	(if (or (neg? idx) (>= i len))
+	  (do (aset tokens i (.substring s start))
+	      tokens)
+	  (do (aset tokens i (.substring s start idx))
+	      (recur (inc idx) (inc i))))))))
+
+(defn get-query-1 [s]
+     (nth (re-matches #"^.*, query=(.*)]$" s) 1))
+
+
+(defn #^java.lang.String get-query-2 [#^java.lang.String s]
+   (.substring s (clojure.core/+ (.lastIndexOf s "query=") 6) (clojure.core/- (.length s) 1)))
+
+(defn #^java.lang.String get-query-3 [#^java.lang.String s]
+  )
diff -r 000000000000 -r 307a81e46071 src/university-output/delstudent.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/delstudent.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call remove_student (?, ?);
diff -r 000000000000 -r 307a81e46071 src/university-output/getcourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/getcourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call course_details (?);
diff -r 000000000000 -r 307a81e46071 src/university-output/getprofessor.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/getprofessor.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call professor_details (?);
diff -r 000000000000 -r 307a81e46071 src/university-output/getprofessorincourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/getprofessorincourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call get_professor (?);
diff -r 000000000000 -r 307a81e46071 src/university-output/getstudent.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/getstudent.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call student_details (?);
diff -r 000000000000 -r 307a81e46071 src/university-output/getstudentsincourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/getstudentsincourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call get_students (?);
diff -r 000000000000 -r 307a81e46071 src/university-output/newcourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/newcourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call add_course(?, ?, ?);
diff -r 000000000000 -r 307a81e46071 src/university-output/newprofessor.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/newprofessor.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call add_professor (?, ?, ?, ?, ?, ?);
diff -r 000000000000 -r 307a81e46071 src/university-output/newstudent.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/newstudent.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call add_student (?, ?, ?, ?, ?, ?);
diff -r 000000000000 -r 307a81e46071 src/university-output/professorincourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/professorincourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call assign_professor (?, ?);
diff -r 000000000000 -r 307a81e46071 src/university-output/replaceprofessor.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/replaceprofessor.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call replace_professor (?, ?);
diff -r 000000000000 -r 307a81e46071 src/university-output/setup.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/setup.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,155 @@
+create table professors (
+--     All the professors in the school.  The school uses the SSN of
+--     each professor as an identifying unique number. Each row of the
+--     table represents a unique professor.
+       name varchar(255) not null,
+       surname varchar(255) not null,
+       email varchar(255),
+       faculty varchar(255),
+       telephone varchar(255),
+       ssn decimal(9, 0) zerofill primary key)
+       ENGINE INNODB;              
+
+create table students (
+--     All the students in the school.  Each student has a unique ID
+--     number assigned by the school.  Each row of the table
+--     represents a unique student.
+       name varchar(255) not null,
+       surname varchar(255),
+       email varchar(255),
+       faculty varchar(255),
+       year int,
+       id decimal(9, 0) zerofill primary key)
+       ENGINE INNODB; 
+
+create table courses (
+--     Set of all classes offered by the school.  each row represents
+--     a different unique class.
+       name varchar(255) primary key,
+       professor_ssn decimal(9,0),
+       -- might be null, in which case a professor
+       -- will need to be assigned at some later time.
+       subject varchar(255),
+       credits int not null,
+       foreign key (professor_ssn) references professors (ssn)
+              on update cascade
+       	      on delete set null)
+       ENGINE INNODB;
+
+create table enrollments (
+--    Record of all student-class pairs which represent the current
+--    enrollment of the school.
+      coursename varchar(255) not null,
+      student_id decimal(9,0) not null references students (id),
+      foreign key (coursename) references courses (name)   
+      	      on update cascade
+	      on delete cascade,
+      foreign key (student_id) references students (id)   
+      	      on update cascade
+	      on delete cascade,
+      unique (coursename, student_id))
+      ENGINE INNODB;
+
+
+-- -----------------------------------------------------------------------------
+-- Stored Procedure Section.
+-- -----------------------------------------------------------------------------
+
+-- what do we need to be able to do?
+
+-- 1 - new professors, students, and courses     
+-- 2 - assign a professor to a course.           
+-- 3 - get a professor owning a course.          
+-- 4 - get the details of prof, student, course  
+-- 5 - remove a student from a course.           
+
+create procedure add_professor (in name varchar(255),
+       		 	       	in surname varchar(255),
+				in email varchar(255),
+				in faculty varchar(255),
+				in telephone varchar(255),
+				in ssn decimal(9, 0))
+	insert into professors values(name, surname, email, faculty, telephone, ssn);
+
+create procedure add_student (in name varchar(255),
+       		 	      in surname varchar(255),
+			      in email varchar(255),
+			      in faculty varchar(255),
+			      in year int,
+			      in id decimal(9,0))
+	insert into students values(name, surname, email, faculty, year, id);
+
+create procedure add_course 
+       -- courses are initially created without any professor attached.
+       	  	      	    (in name    varchar(255),
+ 			     in subject varchar(255),
+			     in credits int)
+	insert into courses values(name, null, subject, credits);
+
+create procedure assign_professor 
+       		 (in course varchar(255),
+		  in professor_ssn decimal(9,0))
+	update courses 
+	       set professor_ssn = professor_ssn
+	       where name = course;
+
+create procedure enroll_student (in course varchar(255),
+       		 		 in student_id decimal(9,0))
+	insert into enrollments values (course, student_id);
+
+create procedure get_students (in course varchar(255))
+       select name, surname from students where students.id in 
+	      (select student_id from enrollments
+	       where enrollments.coursename = course)
+       order by surname asc, name asc;
+
+create procedure get_professor (in course varchar(255))
+       select name, surname, ssn from professors 
+       where professors.ssn = 
+       (select professor_ssn from courses where courses.name = course);
+
+create procedure course_details (in course varchar(255))
+       select name, credits from courses where name = course;
+				
+create procedure professor_details (in ssn decimal(9,0))
+       select name, surname, email, faculty from professors
+       where professors.ssn = ssn;
+
+create procedure student_details (in id decimal(9,0))
+       select name, surname, email, faculty, year from students
+       where students.id = id;
+
+create procedure remove_student (in id decimal(9,0), course varchar(255))
+       delete from enrollments where 
+       enrollments.coursename = course AND
+       enrollemnts.student_id = id;
+
+create procedure replace_professor (in ssn decimal(9,0), course varchar(255))
+       update courses 
+       set professor_ssn = ssn
+       where name = course;
+
+-- --------------------------------------------------------------
+-- initialiaze database to test
+-- --------------------------------------------------------------
+call add_professor ('A', '1', 'email', 'CS', '012-345-6789', 0);
+call add_professor ('B', '2', 'email', 'CS', '012-345-6789', 1);
+call add_professor ('C', '3', 'email', 'CS', '012-345-6789', 2);
+call add_professor ('D', '4', 'email', 'CS', '012-345-6789', 3);
+
+call add_student ('a', '1', 'email', 'CS', '1964', 0);
+call add_student ('a', '2', 'email', 'CS', '1964', 5);
+call add_student ('b', '2', 'email', 'CS', '1964', 1);
+call add_student ('c', '3', 'email', 'CS', '1964', 2);
+call add_student ('d', '4', 'email', 'CS', '1964', 3);
+
+call add_course ('course A', 'science', 5);
+call add_course ('course B', 'science', 5);
+call add_course ('course C', 'science', 5);
+
+call enroll_student ('course A', 0);
+call enroll_student ('course A', 5);
+call enroll_student ('course A', 1);
+call enroll_student ('course A', 2);
+
+call assign_professor ('course A', 0);
diff -r 000000000000 -r 307a81e46071 src/university-output/studentincourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university-output/studentincourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call enroll_student (?, ?);
diff -r 000000000000 -r 307a81e46071 src/university/README.TXT
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/README.TXT	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,9 @@
+################################################################################
+#  Coderloop Coding Challenge
+#  Puzzle: university
+#  Author: Robert McIntyre
+################################################################################
+
+The main file is setup.sql, which defines the database schema and all
+the stored procedures to manupulate the tables. All other *.sql files
+are just thin wrappers around calls to these stored procedures.
diff -r 000000000000 -r 307a81e46071 src/university/create-database.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/create-database.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+create database university;
diff -r 000000000000 -r 307a81e46071 src/university/delete-database.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/delete-database.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+drop database if exists university;
diff -r 000000000000 -r 307a81e46071 src/university/delstudent.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/delstudent.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call remove_student (?, ?);
diff -r 000000000000 -r 307a81e46071 src/university/dist.sh
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/dist.sh	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,9 @@
+rm /home/r/roBin/src/coderloop/university-output/*
+
+cp delstudent.sql getcourse.sql getprofessor.sql getprofessorincourse.sql getstudent.sql getstudentsincourse.sql newcourse.sql newprofessor.sql newstudent.sql professorincourse.sql replaceprofessor.sql studentincourse.sql setup.sql  ../university-output
+
+cd /home/r/roBin/src/coderloop/university-output
+tar -cvjf university-SQL.tar.bz2 *
+mv university-SQL.tar.bz2 /home/r/coderloop
+rm /home/r/coderloop-test/*
+cp /home/r/coderloop/university-SQL.tar.bz2 /home/r/coderloop-test
diff -r 000000000000 -r 307a81e46071 src/university/getcourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/getcourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call course_details (?);
diff -r 000000000000 -r 307a81e46071 src/university/getprofessor.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/getprofessor.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call professor_details (?);
diff -r 000000000000 -r 307a81e46071 src/university/getprofessorincourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/getprofessorincourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call get_professor (?);
diff -r 000000000000 -r 307a81e46071 src/university/getstudent.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/getstudent.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call student_details (?);
diff -r 000000000000 -r 307a81e46071 src/university/getstudentsincourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/getstudentsincourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call get_students (?);
diff -r 000000000000 -r 307a81e46071 src/university/newcourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/newcourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call add_course(?, ?, ?);
diff -r 000000000000 -r 307a81e46071 src/university/newprofessor.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/newprofessor.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call add_professor (?, ?, ?, ?, ?, ?);
diff -r 000000000000 -r 307a81e46071 src/university/newstudent.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/newstudent.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call add_student (?, ?, ?, ?, ?, ?);
diff -r 000000000000 -r 307a81e46071 src/university/professorincourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/professorincourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call assign_professor (?, ?);
diff -r 000000000000 -r 307a81e46071 src/university/replaceprofessor.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/replaceprofessor.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call replace_professor (?, ?);
diff -r 000000000000 -r 307a81e46071 src/university/reset-sql.sh
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/reset-sql.sh	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,6 @@
+
+
+mysql -u root -psql1005025 < delete-database.sql
+mysql -u root -psql1005025 < create-database.sql
+
+mysql -u root -psql1005025 university < setup.sql
diff -r 000000000000 -r 307a81e46071 src/university/setup.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/setup.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,155 @@
+create table professors (
+--     All the professors in the school.  The school uses the SSN of
+--     each professor as an identifying unique number. Each row of the
+--     table represents a unique professor.
+       name varchar(255) not null,
+       surname varchar(255) not null,
+       email varchar(255),
+       faculty varchar(255),
+       telephone varchar(255),
+       ssn decimal(9, 0) zerofill primary key)
+       ENGINE INNODB;              
+
+create table students (
+--     All the students in the school.  Each student has a unique ID
+--     number assigned by the school.  Each row of the table
+--     represents a unique student.
+       name varchar(255) not null,
+       surname varchar(255),
+       email varchar(255),
+       faculty varchar(255),
+       year int,
+       id decimal(9, 0) zerofill primary key)
+       ENGINE INNODB; 
+
+create table courses (
+--     Set of all classes offered by the school.  each row represents
+--     a different unique class.
+       name varchar(255) primary key,
+       professor_ssn decimal(9,0),
+       -- might be null, in which case a professor
+       -- will need to be assigned at some later time.
+       subject varchar(255),
+       credits int not null,
+       foreign key (professor_ssn) references professors (ssn)
+              on update cascade
+       	      on delete set null)
+       ENGINE INNODB;
+
+create table enrollments (
+--    Record of all student-class pairs which represent the current
+--    enrollment of the school.
+      coursename varchar(255) not null,
+      student_id decimal(9,0) not null references students (id),
+      foreign key (coursename) references courses (name)   
+      	      on update cascade
+	      on delete cascade,
+      foreign key (student_id) references students (id)   
+      	      on update cascade
+	      on delete cascade,
+      unique (coursename, student_id))
+      ENGINE INNODB;
+
+
+-- -----------------------------------------------------------------------------
+-- Stored Procedure Section.
+-- -----------------------------------------------------------------------------
+
+-- what do we need to be able to do?
+
+-- 1 - new professors, students, and courses     
+-- 2 - assign a professor to a course.           
+-- 3 - get a professor owning a course.          
+-- 4 - get the details of prof, student, course  
+-- 5 - remove a student from a course.           
+
+create procedure add_professor (in name varchar(255),
+       		 	       	in surname varchar(255),
+				in email varchar(255),
+				in faculty varchar(255),
+				in telephone varchar(255),
+				in ssn decimal(9, 0))
+	insert into professors values(name, surname, email, faculty, telephone, ssn);
+
+create procedure add_student (in name varchar(255),
+       		 	      in surname varchar(255),
+			      in email varchar(255),
+			      in faculty varchar(255),
+			      in year int,
+			      in id decimal(9,0))
+	insert into students values(name, surname, email, faculty, year, id);
+
+create procedure add_course 
+       -- courses are initially created without any professor attached.
+       	  	      	    (in name    varchar(255),
+ 			     in subject varchar(255),
+			     in credits int)
+	insert into courses values(name, null, subject, credits);
+
+create procedure assign_professor 
+       		 (in course varchar(255),
+		  in professor_ssn decimal(9,0))
+	update courses 
+	       set professor_ssn = professor_ssn
+	       where name = course;
+
+create procedure enroll_student (in course varchar(255),
+       		 		 in student_id decimal(9,0))
+	insert into enrollments values (course, student_id);
+
+create procedure get_students (in course varchar(255))
+       select name, surname from students where students.id in 
+	      (select student_id from enrollments
+	       where enrollments.coursename = course)
+       order by surname asc, name asc;
+
+create procedure get_professor (in course varchar(255))
+       select name, surname, ssn from professors 
+       where professors.ssn = 
+       (select professor_ssn from courses where courses.name = course);
+
+create procedure course_details (in course varchar(255))
+       select name, credits from courses where name = course;
+				
+create procedure professor_details (in ssn decimal(9,0))
+       select name, surname, email, faculty from professors
+       where professors.ssn = ssn;
+
+create procedure student_details (in id decimal(9,0))
+       select name, surname, email, faculty, year from students
+       where students.id = id;
+
+create procedure remove_student (in id decimal(9,0), course varchar(255))
+       delete from enrollments where 
+       enrollments.coursename = course AND
+       enrollemnts.student_id = id;
+
+create procedure replace_professor (in ssn decimal(9,0), course varchar(255))
+       update courses 
+       set professor_ssn = ssn
+       where name = course;
+
+-- --------------------------------------------------------------
+-- initialiaze database to test
+-- --------------------------------------------------------------
+call add_professor ('A', '1', 'email', 'CS', '012-345-6789', 0);
+call add_professor ('B', '2', 'email', 'CS', '012-345-6789', 1);
+call add_professor ('C', '3', 'email', 'CS', '012-345-6789', 2);
+call add_professor ('D', '4', 'email', 'CS', '012-345-6789', 3);
+
+call add_student ('a', '1', 'email', 'CS', '1964', 0);
+call add_student ('a', '2', 'email', 'CS', '1964', 5);
+call add_student ('b', '2', 'email', 'CS', '1964', 1);
+call add_student ('c', '3', 'email', 'CS', '1964', 2);
+call add_student ('d', '4', 'email', 'CS', '1964', 3);
+
+call add_course ('course A', 'science', 5);
+call add_course ('course B', 'science', 5);
+call add_course ('course C', 'science', 5);
+
+call enroll_student ('course A', 0);
+call enroll_student ('course A', 5);
+call enroll_student ('course A', 1);
+call enroll_student ('course A', 2);
+
+call assign_professor ('course A', 0);
diff -r 000000000000 -r 307a81e46071 src/university/studentincourse.sql
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/university/studentincourse.sql	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,1 @@
+call enroll_student (?, ?);
diff -r 000000000000 -r 307a81e46071 src/utils.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/utils.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,52 @@
+(ns coderloop.utils
+  (:use [clojure.contrib
+	 [shell-out :only [sh]]
+	 [duck-streams :only [file-str read-lines copy]]])
+  (:use [clojure [string :only [trim blank? split]]]))
+
+
+
+  
+
+
+(defn read-integer [file]
+  (Integer/parseInt
+   (trim (slurp (file-str file)))))
+  
+(defn read-big-integer [file]
+  (java.math.BigInteger.
+   (trim (slurp (file-str file)))))
+
+
+(defn read-integer-line [#^java.lang.string s]
+  (map #(Integer/parseInt %)
+       (filter (comp not blank?)
+	       (split s #"\W"))))
+
+
+  
+(defn read-integers
+  "returns a lazy sequence of integers read from the file.
+   Integers are delimited by any sort of whitespace"
+  [#^java.io.File file]
+  (mapcat read-integer-line
+	  (filter (comp not blank?)
+		  (read-lines (file-str file)))))
+  
+
+(defn trans-print [x]
+  (println x )
+  x)
+
+
+(defn md5
+  "given a string, compute the md5 checksum"
+  [s]
+  (let [t (java.io.File/createTempFile "zzz" "zzz")]
+    (copy s t)
+    (.deleteOnExit t)
+      (sh "md5sum" (.getCanonicalPath t))))
+
+
+(defn digits [n]
+  (map #(Integer/parseInt (str %))  (seq (str n))))
diff -r 000000000000 -r 307a81e46071 src/web_ship.clj
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/web_ship.clj	Tue Oct 18 01:17:49 2011 -0700
@@ -0,0 +1,50 @@
+(ns coderloop.web-ship
+  (:use rlm.shell-inspect)
+  (:use [clojure.contrib.duck-streams :as ds :only []]))
+
+
+;;screw this ---- 
+
+(defn sail
+  ([]
+     (ds/slurp*
+      (str "http://localhost:3000/ship/sail")))
+  ([host]
+     (ds/slurp*
+      (str "http://localhost:3000/ship/sail?host=" host))))
+
+(comment -- this is the solution
+
+  WBL*|  start
+  WB|L*  move L
+  *WB|L  sail back
+  B|*WL  move W
+  LB*|W  move L
+  L|*WB  move B
+  *L|WB  sail back
+  |*WBL  move L
+
+  )
+
+;; translate into code
+
+
+(def B "bsd")
+(def L "linux")
+(def W "windows")
+
+
+(if (command-line?)
+  (do
+    (sail L)
+    (sail)
+    (sail W)
+    (sail L)
+    (sail B)
+    (sail)
+    (sail L)
+    (System/exit 0)))
+    
+	
+
+