## 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?

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") &&
}

val people = Seq("Baker", "Cooper", "Fletcher", "Miller", "Smith")
val result = people.permutations filter conditions
result foreach println
```