Most candidates cannot solve this interview problem (twitter.com)

I agree with you; it is easy solving sitting at the computer, but in front of a group of interviewers might be stressful like that.

The method to solve it depends on the programming language. In this case, I would use Haskell; however, this would likely be a part of a larger program, and in that case the programming language that the larger program is written in would be used instead.

Given that those exact words are the first line of the tweet and that it is almost the entire point of the post, what alternative title would have been better?

If most candidates cannot solve it in 25 minutes (while being a simple task), then it is a valid test

    [(c, sum(1 for _ in same)) for c, same in itertools.groupby(s)]

    result = []
    prev, count = None, 0
    for c in s+"\0":  # note: assuming "\0" can't be in `s`
        if c != prev: # starting new sequence
           if count:  # save count for old sequence
              result.append((prev, count))
           prev, count = c, 1  # reset count
        else: # continuation of old sequence
           count += 1

Apparently, FizzBuzz (https://imranontech.com/2007/01/24/using-fizzbuzz-to-find-de.... A nice page about it: https://www.tomdalling.com/blog/software-design/fizzbuzz-in-...) is a useful test to weed out bad programmers.

If so, this can, too.

While most of the comments on the Twitter thread use fancy functions from common libraries, you should be able to solve this problem without the need for googling and without those fancy functions.

While I agree that this is way to basic to test AD skills, if it's really true that there is a sizable percentage of people that is unable to solve this problem, this might be a good way to weed those out, before starting with the 'real' questions.

If I gave a correct answers to a question like this and they responded as you suggest, I’d leave immediately. The purpose of this line of questioning is to weed out incompetent programmers, not be petty. If the latter is a priority, then working with them will undoubtedly be a trial.

possibly because it's much harder (maybe impossible?) to do in languages that don't have native tuples, which appear to be the ask.

The input string is quoted, so the output appears to be an array (not a string type).

My stab at it in Javascript resulted in:

    function collapse(a) {
      collapsedArray = [];
      for (let i=0; i<a.length; i++) {
        let count = 1;
        let currentchar = a[i];
        while (i+1 < a.length && a[i+1] == currentchar) {
          i++;
          count++;
        }
        collapsedArray.push([a[i], count]);
      }
      return (collapsedArray);
    }
    console.log(JSON.stringify(collapse("aabbcdde")));

This outputs `[["a",2],["b",2],["c",1],["d",2],["e",1]]`. Without native tuples in Javascript (or JSON), I could construct a string which replaces the inner brackets with parens, but that would be pretty contrived, as the output requested isn't quoted.

> module Main where

> input = "aaaabbbcca"

> r :: String -> (Char,Int) -> [(String, Int)]

> r [] (c,n) = [([c],n)]

> r (x:xs) (c,n)

> | c == x = r xs (c,n+1)

> | otherwise = (([c],n): r xs (x,1))

> main = putStrLn (show (r (tail input) (head input, 1) ))

4 minutes 42 seconds.

And no, I don't write code like this normally, but I guess this is me when I'm under time pressure... anyway, I could refactor it nicely afterwards in the 25 minutes allocated.

My own first idea was actually similar to yours, although I wrote:

  map (head &&& length) . group

(Also, it took me only a few seconds, because it just seemed obvious to me, even though Haskell is not the programming language I normally use for my projects, but it seems the right thing for this.)