가장 빈번한 단어는 무엇입니까?

문장이 주어지면 프로그램은 각 단어의 빈도를 세어 가장 많이 사용되는 단어를 출력해야합니다. 문장의 길이는 고정되어 있지 않으므로 매우 길어질 수 있으므로 코드는 가능한 짧아야합니다.

규칙 / 요구 사항

• 각 제출물은 전체 프로그램 또는 기능이어야합니다. 함수 인 경우 프로그램 맨 아래에 함수 호출을 추가하기 만하면 실행 가능해야합니다. 다른 것 (예 : 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입니다. 다른 문자를 사용하는 경우 지정하십시오.

챌린지가 끝나면 가장 적은 바이트를 가진 프로그램 ( 코드 골프 라고 함 )이 이길 것입니다.

제출물

답변이 표시되도록하려면 다음 마크 다운 템플릿을 사용하여 헤드 라인으로 답변을 시작하십시오.

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

파이크, 26 25 바이트

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

여기 사용해보십시오!

또는 23 22 바이트 (비경쟁, 거짓이면 스택을 죽이는 노드 추가)

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가장 일반적인 단어를 얻기 위해의 세 번째 출력 사용 ).

_{원래 답변을 게시 한 이후 규칙이 약간 변경되었습니다. 나중에 정규식을 살펴 보겠습니다.}

펄 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)로 나누고 값을 백에 넣고 (발생 횟수로 설정) 값 (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 인코딩을 사용합니다 . 온라인으로 사용해보십시오!.

자바 스크립트 (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)]

이제 모든 조건을 충족해야합니다. 이 제출은 적어도 하나의 단어가 입력되었다고 가정합니다.

온라인으로 사용해보십시오! (아이디어)

또한 하나를 원한다면 약 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]+$

온라인으로 사용해보십시오!

테스트 스위트.

파이썬, 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]:'')):'');

파이썬 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

• 이를 실행하려면 도구 상자가 필요합니다.

• 의 순서 어떻게이 일, 정규 표현식의 가장 좋은 특권 중 하나는 MATLAB이 IT 분야 - 실행하는 대체됩니까은, 내부 환경에서 잡은 토큰에 의해 파라미터 외부 환경 함수를 호출하여 토큰을 "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는 UTF-8이 아닌 CP-1252를 문자 세트로 사용합니다.

온라인으로 사용해보십시오!

펄, 60 56 55 54 바이트

에 +3 포함 -p

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

단어가 숫자가 될 수없는 경우 a53 점으로 떨어 뜨릴 수도 있습니다 .

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의 컬렉션. 카운터),Sort to put most frequent words at the end.
• PowerShell은 기본적으로 대소 문자를 구분하지 않습니다.

가장 빈번한 단어가없는 경우 처리 :

• 마지막 두 항목 [-2, -1]을 $ y 및 $ z로 가져갑니다.
• N> = 2 인 N- 항목 목록은 $ y와 $ z를 마지막 두 항목으로 만듭니다.
• 1 항목 목록은 $ y를 마지막 항목으로 만들고 $ z는 null로 만듭니다.
• 빈 목록은 둘 다 null로 만듭니다.

bool-as-array-index 색인 가짜 삼항 연산자 골프 (0,1)[truthyvalue]를 사용하여 "", $ 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 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)

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

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

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.

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

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.

Python 3, 76 98 100 bytes

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

Try it online

Outputs the most common word as lowercase. Does not include apostrophes because "apostrophes are not required to be included."

statistics.mode requires Python 3.4

Unfortunately, no output to stderr is allowed, or it'd be much shorter.

R, 96 bytes

19 bytes shorter than the existing R answer, with a somewhat different approach.

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

Reads from stdin, so the input is automatically separated by spaces. We convert to lowercase and use gsub to remove all non-alphanumerics (plus - and '). We count the instances of each word with table and save the result to t. Next, we check if there is more than 1 maximum in t (by seeing if there is more than one element which is equal to max(t). If so, we return the empty string ''. If not, we return the word corresponding to the maximum in t.