Did you get the job?

Same. Until I discovered those parser combinator libraries which are THE way to do parsing in Haskell. It makes parsing so pleasant you'll never need a regex again. A parser for that CSV file probably looks like this:

    line = decimal `sepBy` char ','
    
    file = line `sepBy` newline

That's it. It almost reads like prose.

<input runhaskell -e 'interact (oneliner . parse . drop 1 . lines)'

Haskell's default `String` type is a singly-linked list of `Char` values[0] so it takes O(n) time to access the end of the string. Hence I think the solution using `reverse` is probably the best there is, since any attempt to be "smarter" would just be more complicated for no real performance gain. Though I agree that we could ask someone to also write their own reverse function.

[0] https://hackage.haskell.org/package/base-4.21.0.0/docs/Prelu...

It does discuss performance and points out some places where the Haskell implementation makes the natural naive solutions performant.

> While it's true that sort has an O(nlogn) performance profile, one interesting thing here is that sorting is lazy in Haskell! This means that if our two strings are unequal, they will only be sorted far enough to determine inequality!

I don't understand exactly how this works - don't all O(n log n) sorting algorithms still have to do some work on the other elements of the list before pulling out the smallest one? If you just scanned and pulled the smallest one to the front each time that is O(n^2). And there's an implementation detail here that differences at the start of the sorted string will be caught more quickly than at the end, so real-world behaviour is dependent on your choice of sort order.

Agreed that the performance analysis is quite superficial and that some of the solutions like sum NToTotal must be very sub-optimal.

As much as I find Haskell elegant for many things, I have to agree. It reminds me of the infamous Haskell "quicksort" which isn't actually quicksort because it's not in place.

I think not every piece of code needs to be hyper-optimised and in those cases, higher-level (declarative) languages where you don't specify every detail of the algorithm can give rise to very elegant code. But writing very performant Haskell code is a bit trickier.

In the anagram case, there's a straightforward O(n) solution where you count the occurrence of each letter in a hash map for both words and compare those. That can be written in Haskell too, of course, but it's not going to be as short.

The matchesSum check is constant in the length of the input list. The filter adds an iteration over all results of (combinations n xs). If the complexity of (combinations n) is T(n) in xs, then by analogy of its recursive definition we have two recursive calls that are T(n-1), we have an fmap that is O(1) and a concatenation that is O(1). That sets up the recurrence T(n) = 2T(n-1) making the (combinations n) function O(n) in xs.

Thus the whole thing is O(n²). It's not like this is particularly hard for Haskell. If anything, it's often easier because we can set up the recurrence by analogy with the definition.

The execution order, or the order of the output list? The latter should be self-evident from the function body (first elements get collected first), and the former holds no tricks either since filters are evaluated from the head first, and concat (<>) allows lazy access to the first list's elements.

This is just a beginner's Haskell post. If an interviewer really meant to test optimization knowledge, I would hope they wouldn't ask me to optimize one O(n) utility function into another.

with N as the length of the subsets and X as the length of input, `combinations n xs` basically walks through list xs and at each element, conses that element onto each combination of size n-1 of later elements in the list then appends those resulting lists together. this is on the order of N * nCr(X, N) aka O(NX!/(N!(X-N)!)) which dominates the overall runtime. the final filter walks through each combination and does O(N) work at each element to find the ones that sum to the desired amount, again O(NX!/(N!(X-N)!))

which is nice with the laziness because you only eval what you need, e.g.

    fizzle :: Int -> String
    fizzle n
      | fizz && baz = "Fizz Baz!" -- if this branch is taken, buzz is never evaluated
      | fizz && buzz = "Fizz Buzz!"
      | fizz = "Fizz!"
      | buzz = "Buzz!"
      | otherwise = show n
      where
        fizz = n `mod` 3 == 0
        buzz = n `mod` 5 == 0
        baz = n `mod` 7 == 0

    {-# LANGUAGE MonadComprehensions #-}
    import Data.Maybe (catMaybes)
    import Data.List (intercalate)

    fizz :: Int -> String
    fizz n = case zub of
               [] -> show n
               otherwise -> intercalate " " zub ++ "!"
     where
        f :: Int -> String -> Maybe String
        f d msg = [msg | n`rem`d == 0]
        zub = catMaybes . map (uncurry f) 
              $ [(3,"Fizz"), (5,"Buzz"), (7, "Bazz")]

    main = mapM_ putStrLn [fizz n | n <- [1..110]]