Multiple Dwellings

February 20, 2009

Baker, Cooper, Fletcher, Miller and Smith live on different floors of an apartment house that contains only five floors. Baker does not live on the top floor. Cooper does not live on the bottom floor. Fletcher does not live on either the top or the bottom floor. Miller lives on a higher floor than does Cooper. Smith does not live on a floor adjacent to Fletcher’s. Fletcher does not live on a floor adjacent to Cooper’s. Where does everyone live?

About these ads

Pages: 1 2

8 Responses to “Multiple Dwellings”

  1. Pied said

    In an appartment house?

    P!

  2. FalconNL said

    Haskell (assuming 0 = bottom floor):

    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
    
  3. [...] Multiple Dwellings Baker, Cooper, Fletcher, Miller and Smith live on different floors of an apartment house that contains only five floors. Baker does not live on the top floor. Cooper does not live on the bottom floor. Fletcher does not live on either the top or the bottom floor. Miller lives on a higher floor than does Cooper. Smith does not live on a floor adjacent to Fletcher’s. Fletcher does not live on a floor adjacent to Cooper’s. Where does everyone live? [...]

  4. Eric Pierce said

    After some false starts, I came up with Haskell solution that isn’t half bad. Here’s mine:

    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)]
    
  5. kawas said

    Clojure code using only a list comprehension for this particular problem.
    nb: in my country floors start at zero

    ;; 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])
    
  6. j0sejuan said

    package main

    import "fmt"

    func pass(b, c, f, m, s int) bool {
    return b < 5 && c > 1 && f > 1 && f < 5 && m > c && f-s != 1 && f-s != -1 && f-c != 1 && f-c != -1 &&
    b != c && b != f && b != m && b != s && c != f && c != m && c != s && f != m && f != s && m != s &&
    b >= 1 && c >= 1 && f >= 1 && m >= 1 && s >= 1 && b <= 5 && c <= 5 && f <= 5 && m <= 5 && s <= 5
    }

    func main() {
    for l := 0; l < 55555; l++ {
    if pass(l%10,l/10%10,l/100%10,l/1000%10,l/10000%10) {
    fmt.Printf("lives %d\n", l)
    }
    }
    }

  7. Great problem! I used to do these logic puzzles as a kid by marking off squares on a grid. Here’s my solution in Scala:

    def conditions(combo: Seq[String]) = {
      def floor(person: String) = combo.indexOf(person)
      def adjacent(person1: String, person2: String) = 
        math.abs(floor(person1) - floor(person2)) == 1
    
      floor("Baker")    != 4 &&
      floor("Cooper")   != 0 &&
      floor("Fletcher") != 0 &&
      floor("Fletcher") != 4 &&
      floor("Miller") > floor("Cooper") &&
      !adjacent("Smith",  "Fletcher") &&
      !adjacent("Cooper", "Fletcher")
    }
      
    val people = Seq("Baker", "Cooper", "Fletcher", "Miller", "Smith")
    val result = people.permutations filter conditions
    result foreach println
    

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Follow

Get every new post delivered to your Inbox.

Join 615 other followers

%d bloggers like this: