I actually have no idea of what to do with random test cases. It seems there is many many many non-alpha character that should be delim, and I don't know what to do.

Quite frustrating... Wish someone's help.

My code is written in Haskell.

Test Results:
A9n
abbreviate
should a8e abbreviation
should a8e internationalization
should a8e Accessibility
should a8e accessibility
should a8e 'elephant-ride'
should work for the example words
randomized tests
should return the same as the solution
Falsifiable (after 19 tests and 6 shrinks): 
expected: "a2a"
 but got: "aa\50892a"
"aa\50892a"

One should implement its own argmax.

Edited: Oh! One could do reverse before words.

This code is in fact not correct, because maximumBy will not return the first element with highest score but the final one.

For example, if we use the test "ab ba" (which should return "ab"), the code cannot pass.

Get it! I'll keep an eye on it :-).

Thanks for your quick reply! Maybe I should take some time to get more familiar with codewars community. It seems to me that codewars does not give a strong suggestion for users to write efficient code, for I haven't seen statistics about time & memory usage (about others' code)... (Maybe I could upgrade to red).

Back to this problem, I still think that algorithm design should stick to the problem itself. The impact caused by the input seems to be not so relevent to me though... (Although the private timer could not measure it as you have said :-))..

And I really appreciate your idea that we could "streamize" the array to accelerate the code.

Thanks again!

Binary Search!!!

Why shouldn't we use binary search? I haven't seen a sample code with it.

Accumulating or iterating all items does not seem to be efficent...