;; list comprehension with all constraints in the :when clause
(for [b (range 5) c (range 5) f (range 5) m (range 5) s (range 5)
      :let [sf (- s f) fc (- f c)]
      :when (and (= 5 (count (distinct [b c f m s])))
                 (not= b 4)
                 (not= c 0)
                 (< 0 f 4)
                 (> m c)
                 (not= 1 (* sf sf))
                 (not= 1 (* fc fc)))]
  [:Baker b :Cooper c :Fletcher f :Miller m :Smith s])

;; result: ([:Baker 2 :Cooper 1 :Fletcher 3 :Miller 4 :Smith 0])

import Data.List
import Data.Map (fromList, toList, (!))

people = ["Baker", "Cooper", "Fletcher", "Miller", "Smith"]
assignments = [ fromList (zip people floors) | floors <- permutations [0,1,2,3,4] ]

-- Return True if the given floor assignments obey the constraints
constrain assign =
    let b = assign ! "Baker"
        c = assign ! "Cooper"
        f = assign ! "Fletcher"
        m = assign ! "Miller"
        s = assign ! "Smith"
    in b /= 4                    -- Baker is not on top floor
    && c /= 0                    -- Cooper is not on bottom floor
    && f `notElem` [0, 4]        -- Fletcher is not on top or bottom floor
    && m > c                     -- Miller is above Cooper
    && s `notElem` [f-1, f+1]    -- Smith is not adjacent to Fletcher
    && f `notElem` [c-1, c+1]    -- Fletcher is not adjacent to Cooper

-- Return all floor assignments that fit the constraints
solutions = head $ filter constrain assignments

main = putStrLn $ show $ toList solutions
-- [("Baker",2),("Cooper",1),("Fletcher",3),("Miller",4),("Smith",0)]

import Data.Map (fromList, (!))
import Data.List

data Person = Baker | Cooper | Fletcher | Miller | Smith deriving (Enum, Eq, Ord, Show)

main = print . filter conditions . map (fromList . flip zip [0 :: Int ..]) $ permutations [Baker ..]

conditions xs | xs ! Baker    == 4                     = False
              | xs ! Cooper   == 0                     = False
              | xs ! Fletcher == 0                     = False
              | xs ! Fletcher == 4                     = False
              | xs ! Miller < xs ! Cooper              = False
              | abs (xs ! Smith - xs ! Fletcher) == 1  = False
              | abs (xs ! Cooper - xs ! Fletcher) == 1 = False
              | otherwise                              = True

P!