[Question]
  [
# What is the most frequent word?
Given a sentence, your program must make its way through it, counting the frequencies of each word, then output the most used word. Because a sentence has no fixed length, and so can get very long, your code must be as short as possible.
## Rules/Requirements
* Each submission should be either a full program or function. If it is a function, it must be runnable by only needing to add the function call to the bottom of the program. Anything else (e.g. headers in C), must be included.
* There must be a free interpreter/compiler available for your language.
* If it is possible, provide a link to a site where your program can be tested.
* Your program must not write anything to `STDERR`.
* Your program should take input from `STDIN` (or the closest alternative in your language).
* [Standard loopholes](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* Your program must be case-insensitive (`tHe`, `The` and `the` all contribute to the count of `the`).
* If there is no most frequent word (see test case #3), your program should output nothing.
### Definition of a 'word':
You get the list of words by splitting the input text on spaces. The input will never contain any other type of whitespace than plain spaces (in particular no newlines). However, the final words should only contain alphanumerics (a-z, A-Z, 0-9), hyphens (-) and apostrophes ('). You can make that so by removing all other characters or by replacing them by space before doing the word splitting. To remain compatible with previous versions of the rules, apostrophes are not required to be included.
## Test Cases
```
The man walked down the road.
==> the
-----
Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy.
==> he
-----
This sentence has no most frequent word.
==> 
-----
"That's... that's... that is just terrible!" he said.
==> that's / thats
-----
The old-fashioned man ate an old-fashioned cake.
==> old-fashioned
-----
IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses.
==> IPv6
-----
This sentence with words has at most two equal most frequent words.
==>
```
Note: The third and seventh test cases have no output, you may choose either on the fourth.
## Scoring
Programs are scored according to bytes. The usual character set is UTF-8, if you are using another please specify.
When the challenge finishes, the program with the least bytes (it's called [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'")), will win.
## Submissions
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
# Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
# Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
# Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the leaderboard snippet:
```
# [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
## Leaderboard
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
```
/* Configuration */
var QUESTION_ID = 79576; // Obtain this from the url
// It will be like https://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
var OVERRIDE_USER = 53406; // This should be the user ID of the challenge author.
/* App */
var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page;
function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
  return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}
function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      data.items.forEach(function(c) {
        if (c.owner.user_id === OVERRIDE_USER)
          answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });  
}
getAnswers();
var SCORE_REG = /<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
var OVERRIDE_REG = /^Override\s*header:\s*/i;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];
  
  answers.forEach(function(a) {
    var body = a.body;
    a.comments.forEach(function(c) {
      if(OVERRIDE_REG.test(c.body))
        body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>';
    });
    
    var match = body.match(SCORE_REG);
    if (match)
      valid.push({
        user: getAuthorName(a),
        size: +match[2],
        language: match[1],
        link: a.share_link,
      });
    
  });
  
  valid.sort(function (a, b) {
    var aB = a.size,
        bB = b.size;
    return aB - bB
  });
  var languages = {};
  var place = 1;
  var lastSize = null;
  var lastPlace = 1;
  valid.forEach(function (a) {
    if (a.size != lastSize)
      lastPlace = place;
    lastSize = a.size;
    ++place;
    
    var answer = jQuery("#answer-template").html();
    answer = answer.replace("{{PLACE}}", lastPlace + ".")
                   .replace("{{NAME}}", a.user)
                   .replace("{{LANGUAGE}}", a.language)
                   .replace("{{SIZE}}", a.size)
                   .replace("{{LINK}}", a.link);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
    var lang = a.language;
    if (/<a/.test(lang)) lang = jQuery(lang).text();
    
    languages[lang] = languages[lang] || {lang: a.language, user: a.user, size: a.size, link: a.link};
  });
  var langs = [];
  for (var lang in languages)
    if (languages.hasOwnProperty(lang))
      langs.push(languages[lang]);
  langs.sort(function (a, b) {
    if (a.lang > b.lang) return 1;
    if (a.lang < b.lang) return -1;
    return 0;
  });
  for (var i = 0; i < langs.length; ++i)
  {
    var language = jQuery("#language-template").html();
    var lang = langs[i];
    language = language.replace("{{LANGUAGE}}", lang.lang)
                       .replace("{{NAME}}", lang.user)
                       .replace("{{SIZE}}", lang.size)
                       .replace("{{LINK}}", lang.link);
    language = jQuery(language);
    jQuery("#languages").append(language);
  }
}
```
```
body { text-align: left !important}
#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}
#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}
table thead {
  font-weight: bold;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<div id="language-list">
  <h2>Winners by Language</h2>
  <table class="language-list">
    <thead>
      <tr><td>Language</td><td>User</td><td>Score</td></tr>
    </thead>
    <tbody id="languages">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
```
  
[Answer]
# [Jelly](http://github.com/DennisMitchell/jelly), 25 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ṣ⁶f€ØB;”-¤Œl©Qµ®ċÐ€ĠṪịµẋE
```
[Try it online!](http://jelly.tryitonline.net/#code=4bmj4oG2ZuKCrMOYQjvigJ0twqTFkmzCqVHCtcKuxIvDkOKCrMSg4bmq4buLwrXhuotF&input=&args=JycnVGhhdCdzLi4uIHRoYXQncy4uLiB0aGF0IGlzIGp1c3QgdGVycmlibGUhIiBoZSBzYWlkLicnJw) or [verify all test cases](http://jelly.tryitonline.net/#code=4bmj4oG2ZuKCrMOYQjvigJ0twqTFkmzCqVHCtcKuxIvDkOKCrMSg4bmq4buLwrXhuotFCsOH4oKsauKBtw&input=&args=WycnJ1RoZSBtYW4gd2Fsa2VkIGRvd24gdGhlIHJvYWQuJycnLCAnJydTbG93bHksIGhlIGF0ZSB0aGUgcGllLCBzYXZvcmluZyBlYWNoIGRlbGljaW91cyBiaXRlLiBIZSBmZWx0IGxpa2UgaGUgd2FzIHRydWx5IGhhcHB5LicnJywgJycnVGhpcyBzZW50ZW5jZSBoYXMgbm8gbW9zdCBmcmVxdWVudCB3b3JkLicnJywgJycnVGhhdCdzLi4uIHRoYXQncy4uLiB0aGF0IGlzIGp1c3QgdGVycmlibGUhIiBoZSBzYWlkLicnJywgJycnVGhlIG9sZC1mYXNoaW9uZWQgbWFuIGF0ZSBhbiBvbGQtZmFzaGlvbmVkIGNha2UuJycnLCAnJydJUHY2IGxvb2tzIGdyZWF0LCBtdWNoIGJldHRlciB0aGFuIElQdjQsIGV4Y2VwdCBmb3IgdGhlIGZhY3QgdGhhdCBJUHY2IGhhcyBsb25nZXIgYWRkcmVzc2VzLicnJ10).
[Answer]
# Pyth - ~~23~~ 30 bytes
There has to be a better way to include digits and hyphens, but I just want to fix this right now.
```
Kc@s+++GUTd\-rzZ)I!tJ.M/KZ{KhJ
```
[Test Suite](http://pyth.herokuapp.com/?code=Kc%40s%2B%2B%2BGUTd%5C-rzZ%29I%21tJ.M%2FKZ%7BKhJ&test_suite=1&test_suite_input=The+man+walked+down+the+road.%0ASlowly%2C+he+ate+the+pie%2C+savoring+each+delicious+bite.+He+felt+like+he+was+truly+happy.%0AThis+sentence+has+no+most+frequent+word.%0AIPv6+looks+great%2C+much+better+than+IPv4%2C+except+for+the+fact+that+IPv6+has+longer+addresses.&debug=0).
[Answer]
## Pyke, ~~26~~ 25 bytes
```
l1dcD}jm/D3Sei/1qIi@j@
(;
```
[Try it here!](http://pyke.catbus.co.uk/?code=l1dcD%7Djm%2FD3Sei%2F1qIi%40j%40%0A%28%3B&input=The+man+walked+down+the+road.)
Or ~~23~~ 22 bytes (noncompeting, add node where kills stack if false)
```
l1cD}jm/D3Sei/1q.Ii@j@
```
[Try it here!](http://pyke.catbus.co.uk/?code=l1cD%7Djm%2FD3Sei%2F1q.Ii%40j%40&input=The+man+walked+down+the+road.)
Or with punctuation, 23 bytes (I think this competes? Commit was before the edit)
```
l1.cD}jm/D3Sei/1q.Ii@j@
```
[Try it here!](http://pyke.catbus.co.uk/?code=l1.cD%7Djm%2FD3Sei%2F1q.Ii%40j%40&input=The+man+walked+down+the+road...+road%3F+Road%21)
Or 12 bytes (definitely noncompeting)
```
l1.cj.#jR/)e
```
[Try it here!](http://pyke.catbus.co.uk/?code=l1.cj.%23jR%2F%29e&input=The+man+walked+down+the+road...+road%3F+Road%21&warnings=0)
```
l1           -     input.lower()
  .c         -    punc_split(^)
    j        -   j = ^
     .#   )  -  sort(V(i) for i in ^)
       jR/   -   j.count(i)
           e - ^[-1]
```
[Answer]
# Octave, ~~115~~ 94 bytes
```
[a,b,c]=unique(regexp(lower(input('')),'[A-z]*','match'));[~,~,d]=mode(c); try disp(a{d{:}})
```
Accounts for the case with no most frequent word by using `try`. In this case it outputs nothing, and "takes a break" until you catch the exception.
Saved 21(!) bytes thanks to Luis Mendo's suggestion (using the third output from `mode` to get the most common word).
---
The rules have changed quite a bit since I posted my original answer. I'll look into the regex later.
[Answer]
# Perl 6, 80 bytes
```
{$_>1&&.[0].value==.[1].value??""!!.[0].key given .lc.words.Bag.sort:{-.value}}
```
Let's split the answer into two parts...
```
given .lc.words.Bag.sort:{-.value}
```
`given` is a control statement (like `if` or `for`). In Perl 6, they're allowed as postfixes. (`a if 1`, or like here, `foo given 3`). `given` puts its topic (right-hand side) into the special variable `$_` for its left-hand side.
The "topic" itself lowercases (`lc`), splits by word (`words`), puts the values into a Bag (set with number of occurences), then sorts by value (DESC). Since `sort` only knows how to operate on lists, the `Bag` is transformed into a `List` of `Pair`s here.
```
$_>1&&.[0].value==.[1].value??""!!.[0].key
```
a simple conditional (`?? !!` are used in Perl 6, instead of `? :`).
```
$_ > 1
```
Just checks that the list has more than one element.
```
.[0].value==.[1].value
```
Accesses to `$_` can be shortened... By not specifying the variable. `.a` is exactly like `$_.a`. So this is effectively "do both top elements have the same number of occurences" – If so, then we print '' (the empty string).
Otherwise, we print the top element's key (the count): `.[0].key`.
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 30 bytes
Code:
```
lžj¨„ -«Ãð¡©Ùv®yQOˆ}®¯MQÏDg1Q×
```
Uses **CP-1252** encoding. [Try it online!](http://05ab1e.tryitonline.net/#code=bMW-asKo4oCeIC3Cq8ODw7DCocKpw5l2wq55UU_Lhn3CrsKvTVHDj0RnMVHDlw&input=VGhlIG1hbiB3YWxrZWQgZG93biB0aGUgcm9hZC4).
[Answer]
## JavaScript (ES6), 155 bytes
```
s=>(m=new Map,s.toLowerCase().replace(/[^- 0-9A-Z]/gi,'').split(/\ +/).map(w=>m.set(w,-~m.get(w))),[[a,b],[c,d]]=[...m].sort(([a,b],[c,d])=>d-b),b==d?'':a)
```
Based on @Blue's Python answer.
[Answer]
# Python 3.5, 142 137 134 112 117 ~~110~~ 127 bytes:
(*+17 bytes, because apparently even if there are words more frequent than the rest, but they have the same frequency, nothing should still be returned.*)
```
def g(u):import re;q=re.findall(r"\b['\-\w]+\b",u.lower());Q=q.count;D=[*map(Q,{*q})];return['',max(q,key=Q)][1in map(D.count,D)]
```
Should now satisfy all conditions. This submission assumes that at least 1 word is input.
[Try It Online! (Ideone)](http://ideone.com/mDHfbA)
Also, if you want one, here is another version of my function devoid of any regular expressions at the cost of about 43 bytes, though this one is non-competitive anyways, so it does not really matter. I just put it here for the heck of it:
```
def g(u):import re;q=''.join([i for i in u.lower()if i in[*map(chr,range(97,123)),*"'- "]]).split();Q=q.count;D=[*map(Q,{*q})];return['',max(q,key=Q)][1in map(D.count,D)]
```
[Try this New Version Online! (Ideone)](http://ideone.com/TiYyKP)
[Answer]
# Ruby, ~~94~~ ~~92~~ 102 bytes
Gotta go fast (FGITW answer). Returns the word in all uppercase, or `nil` if there is no most frequent word.
Now updated to new specs, I think. However, I did manage to golf down a little so the byte count is the same!
```
->s{w=s.upcase.tr("_'",'').scan /[-\w]+/;q=->x{w.count x};(w-[d=w.max_by(&q)]).all?{|e|q[e]<q[d]}?d:p}
```
[Answer]
# Pyth, 32 bytes
```
p?tlJeM.MhZrS@Ls++\-GUTcrz0d8ksJ
```
[Test suite.](http://pyth.herokuapp.com/?code=p%3FtlJeM.MhZrS%40Ls%2B%2B%5C-GUTcrz0d8ksJ&test_suite=1&test_suite_input=The+man+walked+down+the+road.%0ASlowly%2C+he+ate+the+pie%2C+savoring+each+delicious+bite.+He+felt+like+he+was+truly+happy.%0AThis+sentence+has+no+most+frequent+word.%0A%22That%27s...+that%27s...+that+is+just+terrible!%22+he+said.%0AThe+old-fashioned+man+ate+an+old-fashioned+cake.%0AIPv6+looks+great%2C+much+better+than+IPv4%2C+except+for+the+fact+that+IPv6+has+longer+addresses.&debug=0)
[Answer]
# JavaScript (ES6), 99 bytes
```
F=s=>(f={},w=c='',s.toLowerCase().replace(/[\w-']+/g,m=>(f[m]=o=++f[m]||1)-c?o>c?(w=m,c=o):0:w=''),w)
```
```
#input { width: 100%; }
```
```
<textarea id="input" oninput="output.innerHTML=F(this.value)"></textarea>
<div id="output"></div>
```
[Answer]
# Sqlserver 2008, 250 bytes
```
DECLARE @ varchar(max) = 'That''s... that''s... that is just terrible!" he said.';
WITH c as(SELECT
@ p,@ x
UNION ALL
SELECT LEFT(x,k-1),STUFF(x,1,k,'')FROM
c CROSS APPLY(SELECT patindex('%[^a-z''-]%',x+'!')k)k
WHERE''<x)SELECT max(p)FROM(SELECT top 1with ties p
FROM c WHERE p>''GROUP BY p
ORDER BY count(*)DESC
)j HAVING count(*)=1
```
[Try it online!](https://data.stackexchange.com/stackoverflow/query/483878/count-words)
# Sqlserver 2016, 174 bytes
Unable to handle data like this example(counting the equals as 3 words):
```
DECLARE @ varchar(max) = 'That''s... that''s... that is just terrible!" he said. = = ='
SELECT max(v)FROM(SELECT TOP 1WITH TIES value v
FROM STRING_SPLIT(REPLACE(REPLACE(REPLACE(@,'"',''),',',''),'.',''),' ')GROUP
BY value ORDER BY count(*)DESC)x HAVING count(*)=1
```
[Answer]
# PostgreSQL, 246, 245 bytes
```
WITH z AS(SELECT DISTINCT*,COUNT(*)OVER(PARTITION BY t,m)c FROM i,regexp_split_to_table(translate(lower(t),'.,"''',''),E'\\s+')m)
SELECT t,CASE WHEN COUNT(*)>1 THEN '' ELSE MAX(m)END
FROM z WHERE(t,c)IN(SELECT t,MAX(c)FROM z GROUP BY t)
GROUP BY t  
```
Output:
[![enter image description here](https://i.stack.imgur.com/TfzXn.png)](https://i.stack.imgur.com/TfzXn.png)
Input if anyone is interested:
```
CREATE TABLE i(t TEXT);
INSERT INTO i(t)
VALUES ('The man walked down the road.'), ('Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy.'),
       ('This sentence has no most frequent word.'), ('"That''s... that''s... that is just terrible!" he said. '), ('The old-fashioned man ate an old-fashioned cake.'), 
       ('IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses.'), ('a   a            a b b b c');
```
---
Normally I would use `MODE() WITHIN GROUP(...)` and it will be much shorter, but it will violate:
> 
> If there is no most frequent word (see test case #3), your program should output nothing.
> 
> 
> 
---
**EDIT:**
Handling `'`:
```
WITH z AS(SELECT DISTINCT*,COUNT(*)OVER(PARTITION BY t,m)c FROM i,regexp_split_to_table(translate(lower(t),'.,"!',''),E'\\s+')m)
SELECT t,CASE WHEN COUNT(*)>1 THEN '' ELSE MAX(m)END
FROM z WHERE(t,c)IN(SELECT t,MAX(c)FROM z GROUP BY t)
GROUP BY t  
```
`**[`SqlFiddleDemo`](http://sqlfiddle.com/#!15/7639f/1/0)**`
Output:
```
╔═══════════════════════════════════════════════════════════════════════════════════════════════╦═══════════════╗
║                                              t                                                ║      max      ║
╠═══════════════════════════════════════════════════════════════════════════════════════════════╬═══════════════╣
║ a a a b b b c                                                                                 ║               ║
║ The old-fashioned man ate an old-fashioned cake.                                              ║ old-fashioned ║
║ IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses.  ║ ipv6          ║
║ This sentence has no most frequent word.                                                      ║               ║
║ "That's... that's... that is just terrible!" he said.                                         ║ that's        ║
║ The man walked down the road.                                                                 ║ the           ║
║ Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy.        ║ he            ║
╚═══════════════════════════════════════════════════════════════════════════════════════════════╩═══════════════╝
```
[Answer]
# R, 115 bytes
```
function(s)if(sum(z<-(y=table(tolower((x=strsplit(s,"[^\\w']",,T)[[1]])[x>""])))==max(y))<2)names(which(z))else NULL
```
This is a function that accepts a string and returns a string if a single word appears more often than others and `NULL` otherwise. To call it, assign it to a variable.
Ungolfed:
```
f <- function(s) {
    # Create a vector of words by splitting the input on characters other
    # than word characters and apostrophes
    v <- (x <- strsplit(s, "[^\\w']", perl = TRUE))[x > ""]
    # Count the occurrences of each lowercased word
    y <- table(tolower(v))
    # Create a logical vector such that elements of `y` which occur most
    # often are `TRUE` and the rest are fase
    z <- y == max(y)
    # If a single word occurs most often, return it, otherwise `NULL`
    if (sum(z) < 2) {
        names(which(z))
    } else {
        NULL
    }
}
```
[Answer]
# Retina, 97 bytes
The rules keep changing...
```
T`L`l
[^-\w ]
O`[-\w]+
([-\w]+)( \1\b)*
$#2;$1
O#`[-\w;]+
.*\b(\d+);[-\w]+ \1;[-\w]+$
!`[-\w]+$
```
[Try it online!](http://retina.tryitonline.net/#code=VGBMYGwKW14tXHcgXQoKT2BbLVx3XSsKKFstXHddKykoIFwxXGIpKgokIzI7JDEKTyNgWy1cdztdKwouKlxiKFxkKyk7Wy1cd10rIFwxO1stXHddKyQKCiFgWy1cd10rJA&input=cGkgcGllIHBpZQ)
[Test suite.](http://retina.tryitonline.net/#code=JShUYExgbApbXi1cdyBdCgpPYFstXHddKwooWy1cd10rKSggXDFcYikqCiQjMjskMQpPI2BbLVx3O10rCi4qXGIoXGQrKTtbLVx3XSsgXDE7Wy1cd10rJAoKIWBbLVx3XSsk&input=VGhlIG1hbiB3YWxrZWQgZG93biB0aGUgcm9hZC4KU2xvd2x5LCBoZSBhdGUgdGhlIHBpZSwgc2F2b3JpbmcgZWFjaCBkZWxpY2lvdXMgYml0ZS4gSGUgZmVsdCBsaWtlIGhlIHdhcyB0cnVseSBoYXBweS4KVGhpcyBzZW50ZW5jZSBoYXMgbm8gbW9zdCBmcmVxdWVudCB3b3JkLgoiVGhhdCdzLi4uIHRoYXQncy4uLiB0aGF0IGlzIGp1c3QgdGVycmlibGUhIiBoZSBzYWlkLgpUaGUgb2xkLWZhc2hpb25lZCBtYW4gYXRlIGFuIG9sZC1mYXNoaW9uZWQgY2FrZS4KSVB2NiBsb29rcyBncmVhdCwgbXVjaCBiZXR0ZXIgdGhhbiBJUHY0LCBleGNlcHQgZm9yIHRoZSBmYWN0IHRoYXQgSVB2NiBoYXMgbG9uZ2VyIGFkZHJlc3Nlcy4)
[Answer]
# Python, 132 bytes
```
import collections as C,re
def g(s):(a,i),(b,j)=C.Counter(re.sub('[^\w\s-]','',s.lower()).split()).most_common(2);return[a,''][i==j]
```
Above code assumes that input has at least two words.
[Answer]
# PHP, 223 bytes
```
$a=array_count_values(array_map(function($s){return preg_replace('/[^A-Za-z0-9]/','',$s);},explode(' ',strtolower($argv[1]))));arsort($a);$c=count($a);$k=array_keys($a);echo($c>0?($c==1?$k[0]:($a[$k[0]]!=$a[$k[1]]?$k[0]:'')):'');
```
[Answer]
# Python 2, 218 bytes
Assumes more than 2 words. Getting rid of punctuation destroyed me...
```
import string as z
def m(s):a=[w.lower()for w in s.translate(z.maketrans('',''),z.punctuation).split()];a=sorted({w:a.count(w)for w in set(a)}.items(),key=lambda b:b[1],reverse=1);return a[0][0]if a[0][1]>a[1][1]else''
```
[Answer]
## Matlab (225)
* Rules chaneged :/
.
```
      function c=f(a),t=@(x)feval(@(y)y(y>32),num2str(lower(x)-0));f=@(x)num2str(nnz(x)+1);e=str2num(regexprep(a,'([\w''-]+)',' ${t($1)} ${f($`)} ${f([$`,$1])}'));[u,r,d]=mode(e);try c=find(e==d{:});c=a((e(c(1)+1)):(e(c(1)+2)));end
```
* Toolbox is necessary to run this.
* How does this work, one of the nicest privileges of regex replace in matlab this it field-executes tokens by calling external-environmental functions parameterized by the tokens caught in the inner environment, so any sequence of `"Word_A Word_B .."` is replaced by integers `"A0 A1 A2 B0 B1 B2 ..."` where the first integer is the numerica ascii signature of the word, the second is the starting index, the third is the ending index, these last two integers dont reduplicate in the whole sequence so i took this advantage to transpose it to an array, then [mode](https://codegolf.stackexchange.com/a/42550/38337) it then search the result in that array, so the starting/ending indices will consequently follow.
* **Edit:** after changing some details, the program is called function by a string parameter.
---
**20** bytes saved thanks to @StewieGriffin, **30** bytes added reproaches to common-agreed loopholes.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~22~~ ~~21~~ 20 bytes
```
žK„- JÃl#{D.MDgiJëõ?
```
Explanation:
```
žK                     # Push [a-zA-Z0-9]
  „-                   # Push 2-char string containing a hyphen and a space
     J                 # Join the stack into a single element
      Ã                # Removes all characters from implicit input except those specified above
       l               # Converts to lowercase
        #              # Split string by spaces
         {             # Sorts array
          D            # Duplicates
           .M          # Finds most common element
             Dg        # Gets length of string without popping
                 iJ    # If length == 1, then convert the array to a string (otherwise the output would be ['example'] instead of example
                   ëõ? # Else push an empty string.
```
Note: If you're fine with trailing newlines in the output for when you're not supposed to output anything, remove the `?` at the end to save a byte.
Note #2: The program will not work with a single word, but I doubt this would be a problem. If you want to fix this, replace `#` with `ð¡` for an extra byte.
05AB1E uses CP-1252 as the charset, not UTF-8.
[Try it online!](https://tio.run/nexus/05ab1e#@390n/ejhnm6Cl6Hm3OUq130fF3SDQMzvQ6vPrz1//@M1JycfIXy/KKcFAUw@2tevm5yYnJGKgA)
[Answer]
# Shell, ~~89~~ ~~86~~ 82 bytes
```
grep -Po "[\w'-]+"|sort -f|uniq -ci|sort -nr|awk 'c>$1{print w}c{exit}{c=$1;w=$2}'
```
This lists all words in the input, then sorts them with counts from most common to least common. The `awk` call merely ensures that the #2 word doesn't have the same count as the #1 word.
Unwrapped:
```
grep -Po "[\w'-]+"      # get a list of the words, one per line
  |sort -f              # sort (case insensitive, "folded")
  |uniq -ci             # count unique entries while still ignoring case
  |sort -nr             # sort counted data in descending order
  |awk '
    count > $1 {        # if count of most common word exceeds that of this line
      print word        # print the word saved from it
    }
    count {             # if we have already saved a count (-> we are on line 2)
      exit              # we always exit on line 2 since we have enough info
    }
    {                   # if true (run on line 1 only due to the above exit)
      count = $1        # save the count of the word on this first line
      word = $2         # save the word itself
    }'
```
`grep -o` is the magic tokenizer here. It takes each word (as defined by a regex accepting word characters (letters, numbers, underscore), apostrophe, or hyphen using PCRE given `-P`) and puts it on its own line. This accepts underscores, as to many other answers here. To disallow underscores, add four characters to turn this portion into `grep -oi "[a-z0-9'-]*"`
`alias cnt='sort -f |uniq -ci |sort -nr'` is an old standby of mine. Without regards to case, it alphabetizes (erm, asciibetizes) the lines of the input counts occurrences of each entry, then reverse-sorts by the numeric occurrences so the most popular is first.
`awk` only looks at the first two lines of that descending ranked list. On line one, `count` is not yet defined, so it is evaluated as zero and therefore the first two stanzas are skipped (zero == false). The third stanza sets `count` and `word`. On the second line, `awk` has a defined and nonzero value for `count`, so it compares that count to the second best count. If it's not tied, the saved `word` is printed. Regardless, the next stanza exits for us.
Test implemented as:
```
for s in "The man walked down the road." "Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy." "This sentence has no most frequent word." "\"That's... that's... that is just terrible\!\" he said." "The old-fashioned man ate an old-fashioned cake." "IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses." "This sentence with words has at most two equal most frequent words."; do printf "%s\n==> " "$s"; echo "$s" |grep -io "[a-z0-9'-]*"|sort -f|uniq -ci|sort -nr|awk 'c>$1{print w}c{exit}{c=$1;w=$2}'; echo; done
```
[Answer]
# Perl, ~~60~~ ~~56~~ ~~55~~ 54 bytes
Includes +3 for `-p`
```
#!/usr/bin/perl -p
s/[\pL\d'-]+/$;[$a{lc$&}++]++or$\=$&/eg}{$\x=2>pop@
```
If a word cannot be just a number you can also drop the `a` for a score of 53.
[Answer]
# [Julia 1.0](http://julialang.org/), ~~140~~ 133 bytes
```
~s=(d=Dict();split(replace(lowercase(s),r"[^\' 0-9a-z-]"=>"")).|>w->d[w]=get(d,w,0)+1;(x,y)=findmax(d);sum(x.==values(d))<2 ? y : "")
```
[Try it online!](https://tio.run/##fZBBb9QwEIXv/IohlzoiiVqEkKBkuXCAGxK9dVtpNp5s3HXs4HHWCUL968skHGCrqqdEnvfevPkeRmvwajqdHrlWuv5imqjyax6siSrQYLEhZX2i0CCT4rwI2e399gIuyw9Y/irvsnqTZXle/d6kcqNv0129p6h0kYrL/M3VtZqKOa9b43SPk9KSPPZqqur6iHYklpf801v4DDN8BMk5DcG4aJ16zG46gh4dJLQH0qB9chDlLXjUVZa/@qf8If3sXIAMMdIqGgwVwHj0ItoDYdOBJmsa40eGnYlUwVeClmwEaw60WBMyxDDaGTochvl8xU1nGJhcJNeIWqTOQ@85Qhvo5ygDSD486bUVG8YLrqpKSv3/B5L2MIo7UghmZ@n1Nls6MBr9dDGBt7pskTvjnYBYmCxnyud80OCBzs3fvh/fg/X@wLAPhLGAfhQSO4qydyniQCTvCqCpoUFu8WGl12IT//ZcE5ZzrXd78aDWgZiJX8KTTOxWHLxaJWYlFZMHYYX2GXBL3ukP "Julia 1.0 – Try It Online")
-7 bytes thanks to MarcMush: replace `count(i->d[i]==x,keys(d))` with `sum(x.==values(d))`
[Answer]
# PowerShell (v4), 117 bytes
```
$y,$z=@($input-replace'[^a-z0-9 \n-]'-split'\s'|group|sort Count)[-2,-1]
($y,($z,'')[$y.Count-eq$z.Count])[!!$z].Name
```
The first part is easy enough:
* `$input` is ~= stdin
* Regex replace irrelevant characters with nothing, keep newlines so we don't mash two words from the end of a line and the beginning of the next line into one by mistake. (Nobody else has discussed multiple lines, could golf -2 if the input is always a single line).
* Regex split, `Group` by frequency (~= Python's collections.Counter), `Sort` to put most frequent words at the end.
* PowerShell is case insensitive by default for everything.
Handling if there isn't a most frequent word:
* Take the last two items [-2,-1] into $y and $z;
* an N-item list, where N>=2, makes $y and $z the last two items
* a 1-item list makes $y the last item and $z null
* an Empty list makes them both null
Use the bool-as-array-index fake-ternary-operator golf `(0,1)[truthyvalue]`, nested, to choose "", $z or $y as output, then take .Name.
```
PS D:\> "The man walked down the road."|.\test.ps1
The
PS D:\> "Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy."|.\test.ps1
he
PS D:\> "`"That's... that's... that is just terrible!`" he said."|.\test.ps1
Thats
PS D:\> "The old-fashioned man ate an old-fashioned cake."|.\test.ps1
old-fashioned
PS D:\> "IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses."|.\test.ps1
IPv6
```
[Answer]
# Lua, ~~232~~ ~~199~~ 175 bytes
```
w,m,o={},0;io.read():lower():gsub("[^-%w%s]",""):gsub("[%w-]+",function(x)w[x]=(w[x]or 0)+1 end)for k,v in pairs(w)do if m==v then o=''end if(v>m)then m,o=v,k end end print(o)
```
[Answer]
# Perl 5, ~~96~~ ~~92~~ 84 + 2 (`-p` flag) = 86 bytes
```
++$h{+lc}for/\w(?:\S*\w)?/g}{$m>$e[1]||$e[1]>$m&&(($_,$m)=@e)||($_="")while@e=each%h
```
Using:
```
> echo "The man walked down the road." | perl -p script.pl
```
[Answer]
# Python, 158 bytes
```
def g(s):import collections as c,re;l=c.Counter(re.sub('[^\w\s-]',"",s.lower()).split());w,f=l.most_common(1)[0];return[w,""][all(f==i[1]for i in l.items())]
```
Takes its input like this:
```
g("Bird is the word")
```
Should match all the requirements, although it does fail on empty strings, is it necessary to check for those? Sorry for the delay.
Advice / feedback / black magic tips for saving bytes are always welcome
[Answer]
# Tcl 8.6, 196 bytes
```
lmap s [join [read stdin] \ ] {dict incr d [regsub -all {[^\w-]} [string tol $s] {}]}
set y [dict fi $d v [lindex [lsort [dict v $d]] end]]
if {[llength $y]!=2} {set y {}}
puts "==> [lindex $y 0]"
```
(Alas, I can't figure out how to get it any smaller than that...)
**Explanation**
It uses several obscure Tcl idioms to do stuff.
* `[join [read stdin] " "]`
— input string→list of whitespace-separated words
* `lmap ...`
— iterate over every element of that list. (Shorter than `foreach` and effectually identical since the result is discarded.)
* `[regsub ... [string tolower ...]]`
— Convert the string to lowercase and strip all characters except for word characters and the hyphen.
* `[dict incr d ...]`
— Create/modify a dictionary/word→count histogram.
* `set y ...`
— Sort the dictionary values, take the largest one, and return all (key,value) pairs corresponding to it.
* `if...`
— There must be exactly two elements: a single (key,value) pair, else there is nothing to print.
* `puts...`
— Print the key in the key value pair, if any. (No word has spaces.)
You can play with it using [CodeChef](https://www.codechef.com/ide).
[Answer]
# Rexx, ~~109~~ ~~128~~ 122 bytes
```
pull s;g.=0;m=0;do i=1 to words(s);w=word(s,i);g.w=g.w+1;if g.w>=m then do;m=g.w;g.m=g.m+1;r=w;end;end;if g.m=1 then say r
```
Pretty printed...
```
pull s
g.=0
m=0
do i=1 to words(s)
  w=word(s,i)
  g.w=g.w+1
  if g.w>=m
  then do
    m=g.w
    g.m=g.m+1
    r=w
  end
end
if g.m=1 then say r
```
[Answer]
bash, ~~153~~ ~~146~~ ~~131~~ ~~154~~ ~~149~~ ~~137~~ bytes
```
declare -iA F
f(){ (((T=++F[$1])==M))&&I=;((T>M))&&M=$T&&I=$1;}
read L
L=${L,,}
L=${L//[^- a-z0-9]}
printf -vA "f %s;" $L
eval $A;echo $I
```
Operation:
declare an associative array F of integers (declare -iA F)
f is a function that, given a word parameter $1, increments frequency count for this word (T=++F[$1]) and compares to max count so far (M).
If equal, the we have a tie so we will not consider this word to be most frequent (I=)
If greater than max count so far (M), then set max count so far to frequency count of this word so far (M=$T) and remember this word (I=$1)
End function f
Read a line (read L)
Make lowercase (L=${L,,})
Remove any character except a-z, 0-9, dash(-) and space (L=${L//[^- a-z0-9]})
Make a sequence of bash statements that calls f for each word (printf -vA "f %s;" $L). This is saved to variable A.
eval A and print result (eval $a;echo$I)
Output:
```
This quick brown fox jumps over this lazy dog.
-->this
This sentence with the words has at most two equal most frequent the words.
-->
The man walked down the road.
-->the
This sentence has no most frequent word.
-->
Slowly, he ate the pie, savoring each delicious bite. He felt like he was truly happy.
-->he
"That's... that's... that is just terrible!" he said.
-->thats
The old-fashioned man ate an old-fashioned cake.
-->old-fashioned
IPv6 looks great, much better than IPv4, except for the fact that IPv6 has longer addresses.
-->ipv6
```
Bug: FIXED
I have a bug that is not revealed in these test cases.
If input is
```
This sentence with words has at most two equal most frequent words.
```
then my code should output nothing.
~~I have a fix but I seem to have hit a bash bug... I get very odd behaviour is M is not declared an integer: ++F[$1]==M (after a few repeated words) increments both F[$1] and M!!~~ - my mistake.
]