最常用的词是什么？

给定一个句子，您的程序必须遍历整个句子，计算每个单词的出现频率，然后输出最常用的单词。由于句子没有固定的长度，因此可能会很长，因此您的代码必须尽可能短。

规则/要求

• 每个提交应该是完整的程序或功能。如果它是一个函数，则只需将函数调用添加到程序底部即可使其可运行。其他任何内容（例如C中的标头）都必须包括在内。
• 您的语言必须有免费的口译/编译器。
• 如果可能，请提供指向可以测试您的程序的站点的链接。
• 您的程序不得向写入任何内容STDERR。
• 您的程序应从STDIN（或使用您语言中最接近的替代语言）输入。
• 禁止出现标准漏洞。
• 你的程序必须是不区分大小写（tHe，The和the所有有助于计数the）。
• 如果没有最常见的单词（请参见测试案例3），则您的程序应不输出任何内容。

“单词”的定义：

您可以通过在空格处分割输入文本来获得单词列表。输入将永远不包含任何其他类型的空格，而不是普通空格（特别是没有换行符）。但是，最后的单词应仅包含字母数字（az，AZ，0-9），连字符（-）和撇号（'）。您可以通过在拆分单词之前删除所有其他字符或将它们替换为空格来实现此目的。为了保持与规则的先前版本兼容，不需要包括撇号。

测试用例

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.
==>

注意：第三和第七个测试用例没有输出，您可以选择第四个。

计分

根据字节对节目评分。通常的字符集是UTF-8，如果使用其他字符集，请指定。

挑战结束后，字节数最少的程序（称为code-golf）将获胜。

意见书

为确保您的答案显示出来，请使用以下Markdown模板以标题开头。

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，则可以通过打败旧分数来保持标题。例如：

# Ruby, <s>104</s> <s>101</s> 96 bytes

如果要在标头中包含多个数字（例如，因为您的分数是两个文件的总和，或者您想单独列出解释器标志罚分），请确保实际分数是标头中的最后一个数字：

# Perl, 43 + 2 (-p flag) = 45 bytes

您还可以将语言名称设置为链接，然后该链接将显示在页首横幅代码段中：

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

排行榜

这是一个堆栈片段，用于按语言生成常规排行榜和获胜者概述。

/* 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>

Pyke，26 25字节

l1dcD}jm/D3Sei/1qIi@j@
(;

在这里尝试！

或23 22字节（非竞争，如果为false，则添加节点，杀死堆栈）

l1cD}jm/D3Sei/1q.Ii@j@

在这里尝试！

或标点符号为23个字节（我认为这很竞争？提交是在编辑之前进行的）

l1.cD}jm/D3Sei/1q.Ii@j@

在这里尝试！

或12个字节（绝对不竞争）

l1.cj.#jR/)e

在这里尝试！

l1           -     input.lower()
  .c         -    punc_split(^)
    j        -   j = ^
     .#   )  -  sort(V(i) for i in ^)
       jR/   -   j.count(i)
           e - ^[-1]

果冻，25 个字节

ṣ⁶f€ØB;”-¤Œl©Qµ®ċЀĠṪịµẋE

在线尝试！或验证所有测试用例。

Pyth- 23 30字节

必须有一种更好的方式来包含数字和连字符，但我现在只想解决此问题。

Kc@s+++GUTd\-rzZ)I!tJ.M/KZ{KhJ

测试套件。

八度，115 94字节

[a,b,c]=unique(regexp(lower(input('')),'[A-z]*','match'));[~,~,d]=mode(c); try disp(a{d{:}})

使用来解释单词不频繁出现的情况try。在这种情况下，它什么也不输出，并且“暂停”，直到捕获到异常为止。

感谢Luis Mendo的建议，节省了21（！）个字节（使用第三个输出mode来获得最普通的单词）。

_{自从我发布原始答案以来，规则已经发生了很大变化。稍后我将研究正则表达式。}

Perl 6，80字节

{$_>1&&.[0].value==.[1].value??""!!.[0].key given .lc.words.Bag.sort:{-.value}}

让我们将答案分为两个部分...

given .lc.words.Bag.sort:{-.value}

given是控制语句（如if或for）。在Perl 6中，允许将它们作为后缀。（a if 1或类似此处的foo given 3）。given将其主题（右侧）放入$_左侧的特殊变量中。

“主题”本身是小写字母（lc），被单词（words）分割，然后将值放入Bag（由出现次数设置），然后按值排序（DESC）。由于sort只知道如何在列表上操作，将Bag被改造成List的Pair这里秒。

$_>1&&.[0].value==.[1].value??""!!.[0].key

一个简单的条件（?? !!在Perl 6中使用代替? :）。

$_ > 1

只需检查列表中是否包含多个元素即可。

.[0].value==.[1].value

$_可以缩短对...的访问...通过不指定变量。.a就像$_.a。因此，这实际上是“两个顶部元素都具有相同的出现次数” –如果是这样，则我们打印“”（空字符串）。

否则，我们打印顶部元素的键（计数）.[0].key。

05AB1E，30个字节

码：

lžj¨„ -«Ãð¡©Ùv®yQOˆ}®¯MQÏDg1Q×

使用CP-1252编码。在线尝试！。

JavaScript（ES6），155个字节

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)

基于@Blue的Python答案。

蟒3.5，142个 137 134 112 117 110 127字节：

（+17字节，因为显然即使有比其他单词更频繁的单词，但它们具有相同的频率，仍然不应返回任何内容。）

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)]

现在应该满足所有条件。此提交假设输入至少1个字。

在线尝试！（爱迪生）

另外，如果您想要一个函数，这是我函数的另一版本，它不包含任何正则表达式，但大约花费了43个字节，尽管这无论如何都是非竞争性的，因此并不重要。我只是把它放在这里：

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)]

在线尝试此新版本！（爱迪生）

露比（94） 92102字节

得快点（FGITW答案）。以全部大写形式返回单词，或者nil如果没有最常见的单词则单词。

我认为现在已更新为新规格。但是，我确实设法减少了打球次数，因此字节数相同！

->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}

Pyth，32个字节

p?tlJeM.MhZrS@Ls++\-GUTcrz0d8ksJ

测试套件。

JavaScript（ES6），99个字节

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>

SQLServer 2008，250字节

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

在线尝试！

SQLServer 2016，174个字节

无法像下面的示例一样处理数据（等于3个字）：

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

PostgreSQL，246，245字节

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  

输出：

输入是否有人感兴趣：

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');

如果没有最常见的单词（请参见测试案例3），则您的程序应不输出任何内容。

编辑：

处理方式'：

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

输出：

╔═══════════════════════════════════════════════════════════════════════════════════════════════╦═══════════════╗
║                                              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            ║
╚═══════════════════════════════════════════════════════════════════════════════════════════════╩═══════════════╝

R，115字节

function(s)if(sum(z<-(y=table(tolower((x=strsplit(s,"[^\\w']",,T)[[1]])[x>""])))==max(y))<2)names(which(z))else NULL

这是一个接受字符串并在单个单词出现频率高于其他单词时返回字符串的函数NULL。要调用它，请将其分配给变量。

取消高尔夫：

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
    }
}

视网膜，97字节

规则不断变化...

T`L`l
[^-\w ]

O`[-\w]+
([-\w]+)( \1\b)*
$#2;$1
O#`[-\w;]+
.*\b(\d+);[-\w]+ \1;[-\w]+$

!`[-\w]+$

在线尝试！

测试套件。

Python，132个字节

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]

上面的代码假定输入至少有两个单词。

PHP，223字节

$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]:'')):'');

Python 2，218字节

假设超过2个字。摆脱标点符号破坏了我...

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''

Matlab（225）

• 修改规则：/

。

      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

• 工具箱是运行此工具所必需的。

• 工作原理是regex最好的特权之一，它是在matlab中替换的，它通过调用内部环境中捕获的令牌参数化的外部环境函数来现场执行令牌，因此，其中的任何序列都"Word_A Word_B .."将替换为整数"A0 A1 A2 B0 B1 B2 ..."，其中第一个整数为该单词的numerica ascii签名，第二个是起始索引，第三个是结束索引，这最后两个整数在整个序列中不会重复，因此我利用此优势将其转置为数组，然后对其进行 模式化然后搜索结果在该数组中，因此起始/结束索引将随之跟随。

• 编辑：更改一些细节后，该程序通过字符串参数调用函数。

@StewieGriffin节省了20个字节，为共同商定的漏洞增加了30个字节的指责。

05AB1E，22 21 20字节

žK„- JÃl#{D.MDgiJëõ?

说明：

ž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.

注意：如果您不希望输出任何内容时可以在输出中尾随换行符，请删除 ?在末尾以保存一个字节。

注意＃2：该程序将无法使用单个单词，但是我怀疑这将是一个问题。如果要解决此问题，请替换#为ð¡一个额外的字节。

05AB1E使用CP-1252作为字符集，而不是UTF-8。

在线尝试！

Perl，60 56 55 54字节

包括+3 -p

#!/usr/bin/perl -p
s/[\pL\d'-]+/$;[$a{lc$&}++]++or$\=$&/eg}{$\x=2>pop@

如果一个单词不能只是一个数字，您也可以将其取值a为53。

PowerShell（v4），117字节

$y,$z=@($input-replace'[^a-z0-9 \n-]'-split'\s'|group|sort Count)[-2,-1]
($y,($z,'')[$y.Count-eq$z.Count])[!!$z].Name

第一部分很简单：

• $input 是〜= stdin
• 正则表达式将不相关的字符替换为空，保留换行符，这样我们就不会将行尾和下一行开头的两个单词误混为一。（没有其他人讨论过多行，如果输入始终为一行，则可以打-2）。
• 正则表达式Group按频率（〜= Python的collections.Counter）分割，Sort以将最常用的词放在最后。
• 默认情况下，PowerShell对于所有内容都不区分大小写。

处理是否没有最常见的单词：

• 将最后两项[-2，-1]分别放入$ y和$ z；
• 一个N项列表，其中N> = 2，使$ y和$ z为最后两项
• 一个1项列表使$ y成为最后一项，而$ z为null
• 空列表会使它们都为空

使用(0,1)[truthyvalue]嵌套的bool-as-array-index假三元运算符golf 选择“”，$ z或$ y作为输出，然后取.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

Lua中，232个 199 175字节

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)

Perl 5，96 92 84 + 2（-p标志）= 86字节

++$h{+lc}for/\w(?:\S*\w)?/g}{$m>$e[1]||$e[1]>$m&&(($_,$m)=@e)||($_="")while@e=each%h

使用：

> echo "The man walked down the road." | perl -p script.pl

Python，158个字节

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())]

接受这样的输入：

g("Bird is the word")

尽管在空字符串上确实失败，但应该符合所有要求，是否有必要检查这些要求？抱歉耽搁了。

总是欢迎您提供建议/反馈/黑魔法提示来节省字节

Tcl 8.6，196字节

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]"

（A，我想不出如何使它更小……）

说明

它使用一些晦涩的Tcl惯用法来做事。

• [join [read stdin] " "] —输入字符串→用空格分隔的单词列表
• lmap ... -遍历该列表的每个元素。（比foreach结果小得多，并且实际上是相同的，因为结果被丢弃了。）
• [regsub ... [string tolower ...]] —将字符串转换为小写并去除所有字符，但单词字符和连字符除外。
• [dict incr d ...] —创建/修改字典/单词→计数直方图。
• set y ... —对字典值进行排序，取最大的一个，然后返回与之对应的所有（键，值）对。
• if... —必须正好有两个元素：一对（键，值）对，否则没有任何内容可打印。
• puts... —在键值对中打印键（如果有）。（没有单词可以有空格。）

您可以使用CodeChef玩它。

的Rexx，109个 128 122字节

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

漂亮的印刷...

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

bash中，153个 146 131 154 149 137字节

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

操作方式：

声明一个整数的关联数组F（声明-iA F）

f是一个函数，给定字参数$ 1，此函数将递增该字的频率计数（T = ++ F [$ 1]），并与到目前为止的最大计数（M）比较。

如果相等，则我们有平局，因此我们不会认为该词是最常见的（I =）

如果大于当前的最大计数（M），则将到目前为止的最大计数设置为该词到目前为止的频率计数（M = $ T），并记住该词（I = $ 1）

结束功能f

读一行（读L）小写（L = $ {L ,,}）删除除az，0-9，破折号（-）和空格（L = $ {L // [^-a-z0- 9]}）制作一系列bash语句，每个单词调用f（printf -vA“ f％s;” $ L）。这将保存到变量A。eval A和打印结果（eval $ a; echo $ I）

输出：

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

错误：已修复我有一个在这些测试用例中未发现的错误。如果输入为

This sentence with words has at most two equal most frequent words.

那么我的代码应该什么也不输出。

我有一个修复程序，但我似乎遇到了一个bash错误...我得到一个非常奇怪的行为，即M未声明为整数：++ F [$ 1] == M（在重复输入几句话之后）都将F [$ 1 ]和M！- 我的错。

Python 3，76 98 100字节

import re,statistics as S
try:print(S.mode(re.split("([a-z0-9-]+)",input().lower())[1::2]))
except:1

在线尝试

将最常见的单词输出为小写。不包含撇号，因为“不需要包含撇号”。

statistics.mode 需要Python 3.4

不幸的是，不允许输出to stderr，否则它会更短。

R，96个字节

比现有的R Answer短19个字节，但方法有所不同。

t=table(gsub("[^a-z0-9'-]","",tolower(scan(,''))))
`if`(sum(t==max(t))-1,'',names(which.max(t)))

从stdin读取，因此输入自动由空格分隔。我们将其转换为小写字母，并用于gsub删除所有非字母数字（加号-和'）。我们用计算每个单词的实例，table并将结果保存到中t。接下来，我们检查in中是否有大于1的最大值t（通过查看是否有多个元素等于max(t)。如果是，我们返回空字符串''。否则，我们返回与in中的最大值对应的单词t。