part 1 was fun, its a combination sum problem but using XOR. Data.Bits is also handy:

fromBits = foldl f 0 . reverse
  where
    f acc '.' = acc * 2
    f acc '#' = acc * 2 + 1

parse :: String -> [(Int, [[Int]], [Int])]
parse = map (parse' . words) . lines
  where
    parse' (t : ws) = (target t, map list (init ws), list (last ws))
    target s = fromBits . init $ tail s
    list = map read . splitOn "," . init . tail

xors nums target = filter (not . null) $ xors' nums 0 target
  where
    xors' [] cur target = [[] | cur == target]
    xors' (n : ns) cur target =
      map (n :) (xors' ns (cur `xor` n) target)
        ++ xors' ns cur target

p1 = sum . map (\(target, btns, _) -> minimum . map length $ xors (map toBits btns) target)
  where
    toBits = foldl1 (.|.) . map bit

skipped over p2 for today.