Am I thinking functionally in these simple Haskell functions?

I'm surprised nobody mentioned the thing that stood out to me the most: the definition of triples:

triples :: [a] -> [[a]]
triples (x:xs)
  | length (x:xs) < 3 = []
  | otherwise = (x:take 2 xs) : triples xs

This is tremendously inefficient: an O(N²) algorithm instead of O(N) just because of the repeated calls to length. Instead, you should just use pattern matching:

triples :: [a] -> [[a]]
triples (x:y:z:xs) = [x,y,z] : triples (y:z:xs)
triples _ = []

You can additionally use an as-pattern to avoid re-building the list (y:z:xs):

triples :: [a] -> [[a]]
triples (x:more@(y:z:xs)) = [x,y,z] : triples more
triples _ = []

Relatedly, another of the answers pointed out the inexhaustive pattern match in isMiddleMax: it only works for lists of length exactly 3. A workaround was proposed, but the real answer is: use a 3-tuple instead of a list! This means changing the type of triples to [a] -> [(a,a,a)], and then isMiddleMax is super easy to write. You need a small change to localMaxima as well, to consume the new type:

triples :: [a] -> [(a,a,a)]
triples (x:more@(y:z:xs)) = (x,y,z) : triples more
triples _ = []

isMiddleMax :: Ord a => (a,a,a) -> Bool
isMiddleMax (x,y,z) = y > x && y > z

localMaxima :: [Integer] -> [Integer]
localMaxima xs = map middle . filter isMiddleMax $ triples xs
  where middle (x,y,z) = y

Definitely a good start, what's left to improve will come with familiarity and practice. Here are a couple of iterative improvements you might make to everyNth that show where your mental model might differ from a more experienced Haskeller's.

The parentheses around zip are unnecessary. As are, e.g., the parentheses around snd in an argument to map in your definition of maxInstances. Excess parentheses while syntactically harmless are gratuitous line noise, and common Haskell style strongly favors concision and cleanliness.

everyNth xs n = [snd x | x <- zip [1..] xs, fst x `mod` n == 0]

Notice that you use both fst x and snd x in the same scope. Use pattern matching instead, instead of using x as an intermediary identifier you can directly expose the components of the tuple and probably give them names that help your code be self-documenting and thus clearer.

everyNth xs n = [x | (i, x) <- zip [1..] xs, i `mod` n == 0]

Performing math on indices definitely implies an imperative-programmer mindset to me. Instead of indices, use the value you really care about! In this case, pair each x value with a Boolean that indicates whether it should be included in the output. This is easy to do because the pattern of inclusions are a simply repeating cycle.

everyNth xs n = [x | (include, x) <- zip (cycle includes) xs, include]
    where includes = [i `mod` n == 0 | i <- [1..n]]

The above version is contrived to (hopefully) show just what went where without piling on too many changes at once. This version introduces cycle :: [a] -> [a], which creates an infinite list out of a finite one by repeatedly appending the list to itself (in effect). We restrict the range of our indices to [1..n] because we know they're completely predictable and periodic after that range. To take it a step further we can directly pattern match on the value of include :: Bool in our tuple. This usually is non-obvious to beginners and so is worth showing on its own.

everyNth xs n = [x | (True, x) <- zip (cycle includes) xs]
    where includes = [i `mod` n == 0 | i <- [1..n]]

Notice that we've eliminated the predicates from our first list comprehension! I'll get back to that in a bit. Our next step is to lose the contrivance from the definition of includes, this bit of functionality would obviously be better expressed by mapping over the range instead of using a list comprehension (again I only did so to minimize the changes between steps).

everyNth xs n = [x | (True, x) <- zip (cycle includes) xs]
    where includes = map (\i -> i `mod` n == 0) [1..n]

Performing any modulus operations at all is unnecessary though, it's obvious that in the range [1..n] only the final element will satisfy the modulus operation. Instead we can directly build the list of booleans from what we know about the length of the period.

everyNth xs n = [x | (True, x) <- zip (cycle includes) xs]
    where includes = replicate (n - 1) False ++ [True]

This is probably as far as I would take it having started out at your original version. There aren't any real further improvements that I can see, just matters of personal style. If I were to write this from scratch though I'd probably produce something that looked more like this.

everyNth :: Int -> [a] -> [a]
everyNth n = map snd . filter fst . zip (cycle (replicate (n-1) False ++ [True]))

Or if I was feeling particularly flashy, I'd write this, and then spend 30 minutes arguing myself out of it for being hopelessly overwrought.

import Data.Maybe (catMaybes)

everyNth :: Int -> [a] -> [a]
everyNth n = catMaybes . zipWith (\b x -> if b then Just x else Nothing)
                                 (cycle (replicate (n-1) False ++ [True]))

Just for fun, these are my implementations:

Edit: These implementations take advantage of recursive function definitions. I think the ease of writing recursive functions is one of Haskell's many great features, so I thought I would show it off a little. It's part of "thinking functionally", and I think you should use it more often.

-- Exercise 1: Skips
skip :: Int -> [a] -> [a]
skip n x
    | length x >= n = last (take n x) : skip n (drop n x)
    | otherwise     = []

skips :: [a] -> [[a]]
skips x = map ((flip skip) x) [1..length x]

A minor difference here is that I implemented skip (everyNth in your solution) as (Int -> [a] -> [a]), since I think (skip n) is more adaptable to other contexts than (skip x) with partial function application.

Just for demonstration purposes, could also implement skips recursively. Here's an implementation of map:

map :: (a -> b) -> [a] -> [b]
map _ []     = []
map f (x:xs) = f x : map f xs

So, instead of using map in skips:

skipsR :: [a] -> [[a]]
skipsR x = skipsR' [1..length x]
  where
    skipsR' []     = []
    skipsR' (n:ns) = skip n x : skipsR' ns

Here's a recursive implementation of localMaxima:

-- Exercise 2: Local Maxima
localMaxima :: [Integer] -> [Integer]
localMaxima []       = []
localMaxima (_:[])   = []
localMaxima (_:_:[]) = []
localMaxima (x0:x1:xs)
    | x1 > x0 && x1 > head xs = x1 : localMaxima (x1:xs)
    | otherwise               = localMaxima (x1:xs)

You were really close to this one with your isMiddleMax function. Going a little further from there, we can use Haskell's pattern matching system to adapt the same function to any size of list. The resulting code has a lot fewer lines, and I suspect runs a little faster. Personally, I find recursive definitions to be more readable in many cases than mapping and filtering (pipeline approach), but that's just a preference.

For the histogram, I iterate over the list 10 times to count the number of occurrences of {0..9}, which is O(n). I then make a row of stars for each number in {1..maximum (counts)}, which is also O(n). I'll get back to you with a performance comparison with your code later.

-- Exercise 3: Histogram
count :: Integer -> [Integer] -> Int
count _ [] = 0
count n (x:xs)
    | x == n    = 1 + count n xs
    | otherwise = count n xs

This one recursively counts the number of occurrences of Integer n.

counts :: (Integer, Integer) -> [Integer] -> [Int]
counts (min, max) x = map ((flip count) x) [min..max] 

This one returns a list of counts for integers in {min..max}.

Again, we can unroll this into a recursive definition:

countsR :: (Integer, Integer) -> [Integer] -> [Int]
countsR (min, max) x = countsR' [min..max]
  where
    countsR' []     = []
    countsR' (n:ns) = count n x : countsR' ns

The idea of starString is to turn counts (0, 9) x into a row of stars. If starString gets and empty list, we can assume that we've reached the end of the line, and can add a newline character.

starString :: [Int] -> Int -> String
starString []     n = "\n"
starString (x:xs) n
    | x >= n    = '*' : starString xs n
    | otherwise = ' ' : starString xs n

This is equivalent to:

starString' xs n = map (star n) x ++ "\n"
  where 
    star n x | x >= n    = '*'
             | otherwise = ' '

You could do it either way. The map might actually be faster, but I haven't checked.

Finally:

histogram :: [Integer] -> String
histogram x = (map (starString cs) $ reverse [1..maximum cs])
              ++ "==========\n0123456789\n"
  where
    cs = counts (0, 9) x

The reverse ensures that the histogram isn't displayed upside down. You could apply it to (map (starString cs) [1..maximum cs]), but I reasoned that a list of integers is easier to reverse than a list of strings. I haven't checked though. I leave it as an exercise for you to unspool histogram into histogramR.