Engelberg

;; Ref-based Santa Claus solution, Written by Mark Engelberg
;; (start-simulation) to run

(def *num-elves* 10)
(def *num-reindeer* 9)

;; Santa is a ref containing either {:state :asleep} or {:state :busy, :busy-with <sequence-of-workers>}
(def santa (ref {:state :asleep}))

(defn waiting-room [capacity]

Engelberg

(defn solve-logic-puzzle []
  (let [people [:amaya :bailey :jamari :jason :landon]]
    (first    
      (for [[fortune time cosmopolitan us-weekly vogue] (permutations people) ; magazines
            [asiago blue-cheese mascarpone mozzarella muenster] (permutations people) ; cheeses
            ; We bind the reservations in two steps, so we have a name for the overall order
            reservations (permutations people)
            :let [[five six seven seven-thirty eight-thirty] reservations]

; THE CONSTRAINTS IN PLAIN ENGLISH            

Engelberg

(defn logic-puzzle []
  (let [people [:amaya :bailey :jamari :jason :landon]]
    (for [[fortune time cosmopolitan us-weekly vogue] (permutations people) ; magazines
          :when (not= fortune :jamari)
          
          [asiago blue-cheese mascarpone mozzarella muenster] (permutations people) ; cheeses
          :when (= blue-cheese fortune)
          :when (not= muenster vogue)
          
          reservations (permutations people)

Engelberg

S = #"\s*" "a" #"\s*"

Engelberg

(ns mark.grid)

; I'm working with grids that are primarily 3x4.  
; I get up and running with the following simple code.

(def rows 3)
(def cols 4)

(def cells (for [row (range rows), col (range cols)] [row col]))

Engelberg

; This is sort of a pseudo Clojure/Scala mash-up.

; In an OO language, you might start off with the following class as a namespace
; for all your functions that revolve around manipulating 3x4 grids.

class Grid {
  val rows = 3
  val cols = 4
  val cells = for [row in range(rows), col in range(cols)] yield [row,col]
  

Engelberg

(ns mark.loco.grants
  (:use loco.core loco.constraints))

; Use whatever scoring function you want for the various
; applicants, but ultimately, you want to assemble this
; information into a data structure.

(def applicants
  [{:name "Alex", :score 5, :grant-request 120}
   {:name "David", :score 4, :grant-request 100}

Engelberg

(ns mark.loco.grants2
  (:use loco.core loco.constraints))

; Use whatever scoring function you want for the various
; applicants, but ultimately, you want to assemble this
; information into a data structure.

(def applicants
  [{:name "Alex", :score 5, :grant-request 120}
   {:name "David", :score 4, :grant-request 100}

Engelberg

First, here is the cleverly concise version of freqs that I showed in class, which builds a bunch of maps that map each element to the number 1, and then merges them together using +:

(defn freqs [l]
  (apply merge-with + (for [item l] {item 1})))

Here is one way of coding it using loop-recur:

Engelberg

As we've seen, seq is the mechanism in Clojure for converting a collection into something that responds to first and rest, so that we can traverse it as we would a linked list. Sequences automatically print at the REPL like a list.

=> (seq '(1 2 3 4))
(1 2 3 4)
=> (seq [1 2 3 4])
(1 2 3 4)
=> (seq #{1 2 3 4})
(1 4 3 2)
=> (seq {:a 1, :b 2})