LINQ Ruined My Favorite Interview Question

You definitely can do a hash-based solution in a single expression in Ruby. Here's a very ugly and kludgy example that you could probably improve on if you wanted to. I don't think it's n^2 because the group_by just counts the occurrences of each word and returns a hash where the count is the key:

str.split.group_by{|w| str.split.count(w)}.sort_by{|k,v| k}.reverse.flatten.uniq.keep_if{|w| w.is_a?(String)}.take(10)

I'm also trying to work out a better way to do this using "chunk" because although hashes are fast to access, they are not fundamentally sortable, and sort_by returns a 2d array just like chunk does anyway.

I say this as someone who has built a 'word counter' as part of a commercial product. We tried Linq, but had to abandon it due to speed issues as well the sheer number of edge cases.

"var words = s.Split(' ');"

Example edge case: Words separated by an em, en, or ordinary dash. In the first and second cases, they're two words, in the third, a single word. The basic Split by space function is insufficient for all but the most basic interpretation of a 'word'.

In terms of speed, that 20% becomes significant when you're processing millions of words, not a short Wikipedia article.

Expand the 'word counter' function to become a unique 'phrase counter' and you have to toss Linq out the window.

    (take 10 (reverse (sort-by (comp first rest) (frequencies (string/split ... #"\+s")))) ; llambda Clojure

    // haakon Scala
    s.split(' ').groupBy(identity).mapValues(_.size).toList.sortBy(-_._2).take(10).map(_._1)

    (->> (string/split s #"\s+") frequencies (sort-by val) reverse (take 10)) ; aphyr Clojure

    var top = (from w in text.Split(' ')  // louthy C# LINQ
               group w by w into g 
               orderby g.Count() descending 
               select g.Key).Take(10);

    collections.Counter(s1.split()).most_common(10) # shill Python

    d = {}  # shill Python without collections library
    for word in s1.split(): d[word] = d.get(word, 0) + 1
    print [(x, d[x]) for x in sorted(d, key=d.get, reverse=True)][:10]

    words = s.split()    # spenuke and abecedarius probably O(N²) Python
    sorted(set(words), key=words.count, reverse=True)[:10]

    d3.entries((s.split(" ").reduce(function(p, v){  // 1wheel JS with d3
        v in p ? p[v]++ : p[v] = 1;
        return p;}, {})))
      .sort(function(a, b){ return a.value > b.value; })
      .map(function(d){ return d.key;})
      .slice(-10)

    # kenuke O(N²) Ruby:
    str.split.sort_by{|word| str.split.count(word)}.uniq.reverse.take(10)

    counts = Hash.new { 0 } # my Ruby
    str.split.each { |w| counts[w] += 1; }
    counts.keys.sort_by { |w| -counts[w] }.take 10

    # aaronbrethorst ruby
    str.split(/\W+/).inject(Hash.new(0)) {|acc, w| acc[w] += 1; acc}.sort {|a,b| b.last  a.last }[0,10]

    Commonest[StringSplit[string], 10]  # carlob Mathematica

    Reverse[SortBy[Tally[StringSplit[#]], #[[2]] &]][[;; 10, 1]] &  # superfx old Mathematica

    $a = array_count_values(preg_split('/\b\s+/', $s)); arsort($a); array_slice($a, 0, 10) // Myrth PHP

    tr -cs a-zA-Z '\n' | sort | uniq -c | sort -nr | head  # mzs and me sh

    -- lelf in Haskell
    take 10 . map head . reverse . sortBy (comparing length) . group . sort . words

    # prakashk Perl6
    .say for (bag($text.words) ==> sort {-*.value})[^10]

    # navinp1912 C++
     string s,f;
     map M;
     set > S;
     while(cin >> s) {
             M[s]++;
             int x=M[s];
             if(x>1) S.erase(make_pair(x-1,s));
             S.insert(make_pair(x,s));
     }
     set >::reverse_iterator it=S.rbegin();
     int topK=10;
     while(topK-- && (it!=S.rend())) {
             cout secondfirst

    &group=word;count(*)
    &order=-count(*)
    &limit=10

    perl -wle 'local $/; $_ = ; $, = " "; $w{$_}++ for split; print @{[sort {$w{$b}  $w{$a}} keys %w]}[0..9]'

    perl -wlne '$w{$_}++ for split; END { $, = " "; print @{[sort {$w{$b}  $w{$a}} keys %w]}[0..9]}'