Quel est le mot le plus fréquent?

Étant donné une phrase, votre programme doit la parcourir, compter les fréquences de chaque mot, puis sortir le mot le plus utilisé. Parce qu'une phrase n'a pas de longueur fixe et peut donc devenir très longue, votre code doit être aussi court que possible.

Règles / exigences

• Chaque soumission doit être soit un programme complet soit une fonction. S'il s'agit d'une fonction, elle doit pouvoir être exécutée en n'ajoutant que l'appel de fonction au bas du programme. Tout autre élément (par exemple en-têtes en C) doit être inclus.
• Un interprète / compilateur gratuit doit être disponible pour votre langue.
• Si c'est possible, fournissez un lien vers un site où votre programme peut être testé.
• Votre programme ne doit rien écrire STDERR.
• Votre programme doit prendre en compte STDIN(ou l'alternative la plus proche dans votre langue).
• Les failles standard sont interdites.
• Votre programme doit être insensible à la casse ( tHe, Theet thetous contribuent au nombre de the).
• S'il n'y a pas de mot le plus fréquent (voir cas de test n ° 3), votre programme ne devrait rien produire.

Définition d'un «mot»:

Vous obtenez la liste des mots en divisant le texte d'entrée sur les espaces. L'entrée ne contiendra jamais d'autre type d'espaces que des espaces simples (en particulier aucun retour à la ligne). Cependant, les derniers mots ne doivent contenir que des caractères alphanumériques (az, AZ, 0-9), des tirets (-) et des apostrophes ('). Vous pouvez le faire en supprimant tous les autres caractères ou en les remplaçant par un espace avant de séparer le mot. Pour rester compatible avec les versions précédentes des règles, il n'est pas nécessaire d'inclure des apostrophes.

Cas de test

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

Remarque: Les troisième et septième cas de test n'ont pas de sortie, vous pouvez choisir l'un ou l'autre sur le quatrième.

Notation

Les programmes sont notés en octets. Le jeu de caractères habituel est UTF-8, si vous en utilisez un autre, veuillez le préciser.

Lorsque le défi se termine, le programme avec le moins d'octets (appelé code-golf ), gagne.

Soumissions

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Classement

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

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

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

Essayez-le ici!

Ou 23 22 octets (non compétitif, ajouter un noeud où tue la pile si faux)

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

Essayez-le ici!

Ou avec ponctuation, 23 octets (je pense que cela est en concurrence? Commit était avant l'édition)

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

Essayez-le ici!

Ou 12 octets (certainement non compétitifs)

l1.cj.#jR/)e

Essayez-le ici!

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

Gelée , 25 octets

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

Essayez-le en ligne! ou vérifiez tous les cas de test .

Pyth - 23 30 octets

Il doit y avoir une meilleure façon d'inclure des chiffres et des tirets, mais je veux juste résoudre ce problème maintenant.

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

Suite de tests .

Octave, 115 94 octets

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

Tient compte du cas sans mot le plus fréquent en utilisant try. Dans ce cas, il ne produit rien et "prend une pause" jusqu'à ce que vous interceptiez l'exception.

Enregistrement de 21 (!) Octets grâce à la suggestion de Luis Mendo (en utilisant la troisième sortie de modepour obtenir le mot le plus courant).

_{Les règles ont beaucoup changé depuis que j'ai publié ma réponse d'origine. J'examinerai le regex plus tard.}

Perl 6, 80 octets

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

Divisons la réponse en deux parties ...

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

givenest une instruction de contrôle (comme ifou for). En Perl 6, ils sont autorisés en tant que suffixes. ( a if 1, ou comme ici, foo given 3). givenplace son sujet (côté droit) dans la variable spéciale $_pour son côté gauche.

Le "sujet" lui-même minuscule ( lc), se divise par mot ( words), place les valeurs dans un sac (défini avec le nombre d'occurrences), puis trie par valeur (DESC). Puisqu'il sortne sait que fonctionner sur des listes, le Bagest ici transformé en un Listde Pairs.

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

un conditionnel simple ( ?? !!utilisé en Perl 6, au lieu de ? :).

$_ > 1

Vérifie simplement que la liste a plus d'un élément.

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

Les accès à $_peuvent être raccourcis ... En ne spécifiant pas la variable. .aest exactement comme $_.a. Donc, c'est effectivement "les deux éléments supérieurs ont-ils le même nombre d'occurrences" - Si c'est le cas, alors nous imprimons '' (la chaîne vide).

Dans le cas contraire, nous imprimons la clé de l'élément supérieur (le comte): .[0].key.

05AB1E , 30 octets

Code:

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

Utilise l' encodage CP-1252 . Essayez-le en ligne! .

JavaScript (ES6), 155 octets

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)

Basé sur la réponse Python de @ Blue.

Python 3.5, 142 137 134 112 112 117 110 127 octets:

( +17 octets, car apparemment même s'il y a des mots plus fréquents que les autres, mais ils ont la même fréquence, rien ne doit quand même être retourné. )

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

Devrait maintenant remplir toutes les conditions. Cette soumission suppose qu'au moins 1 mot est entré.

Essayez-le en ligne! (Ideone)

De plus, si vous en voulez une, voici une autre version de ma fonction dépourvue d'expressions régulières au prix d'environ 43 octets, bien que celle-ci soit de toute façon non compétitive, donc cela n'a pas vraiment d'importance. Je viens de le mettre ici pour le diable:

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

Essayez cette nouvelle version en ligne! (Ideone)

Rubis, 94 92 102 octets

Je dois aller vite (réponse FGITW). Renvoie le mot en majuscule ou nils'il n'y a pas de mot le plus fréquent.

Maintenant mis à jour selon de nouvelles spécifications, je pense. Cependant, j'ai réussi à jouer un peu au golf, donc le nombre d'octets est le même!

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

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

Suite de tests.

JavaScript (ES6), 99 octets

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 octets

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

Essayez-le en ligne!

SQL Server 2016, 174 octets

Impossible de gérer des données comme cet exemple (en comptant les égaux comme 3 mots):

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 octets

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  

Sortie:

Entrez si quelqu'un est intéressé:

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

S'il n'y a pas de mot le plus fréquent (voir cas de test n ° 3), votre programme ne devrait rien produire.

MODIFIER:

Manipulation ':

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

Sortie:

╔═══════════════════════════════════════════════════════════════════════════════════════════════╦═══════════════╗
║                                              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 octets

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

Il s'agit d'une fonction qui accepte une chaîne et renvoie une chaîne si un seul mot apparaît plus souvent que les autres et NULLsinon. Pour l'appeler, affectez-le à une variable.

Non golfé:

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

Rétine, 97 octets

Les règles changent constamment ...

T`L`l
[^-\w ]

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

!`[-\w]+$

Essayez-le en ligne!

Suite de tests.

Python, 132 octets

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]

Le code ci-dessus suppose que l'entrée a au moins deux mots.

PHP, 223 octets

$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 octets

Suppose plus de 2 mots. Se débarrasser de la ponctuation m'a détruit ...

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)

• Règles 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 est nécessaire pour exécuter ceci.

• Comment cela fonctionne-t-il, l'un des plus beaux privilèges de regex remplacer dans matlab ce qu'il exécute sur le terrain des jetons en appelant des fonctions environnementales externes paramétrées par les jetons pris dans l'environnement interne, donc toute séquence de "Word_A Word_B .."est remplacée par des entiers "A0 A1 A2 B0 B1 B2 ..."où le premier entier est la signature numerica ascii du mot, la seconde est l'index de départ, la troisième est l'index de fin, ces deux derniers entiers ne se redoublent pas dans toute la séquence, j'ai donc profité de cet avantage pour le transposer dans un tableau, puis le moduler puis rechercher dans le résultat dans ce tableau, donc les indices de début / fin suivront par conséquent.

• Edit: après avoir modifié certains détails, le programme est appelé fonction par un paramètre de chaîne.

20 octets économisés grâce à @StewieGriffin, 30 octets ont ajouté des reproches aux failles communes.

05AB1E , 22 21 20 octets

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

Explication:

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

Remarque: Si vous êtes satisfait de la fin des sauts de ligne dans la sortie lorsque vous n'êtes pas censé produire quoi que ce soit, supprimez le ?à la fin pour enregistrer un octet.

Note # 2: Le programme ne fonctionnera pas avec un seul mot, mais je doute que ce soit un problème. Si vous souhaitez résoudre ce problème, remplacez #par ð¡pour un octet supplémentaire.

05AB1E utilise CP-1252 comme jeu de caractères, pas UTF-8.

Essayez-le en ligne!

Perl, 60 56 55 54 octets

Comprend +3 pour -p

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

Si un mot ne peut pas être simplement un nombre, vous pouvez également laisser tomber apour un score de 53.

PowerShell (v4), 117 octets

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

La première partie est assez simple:

• $input est ~ = stdin
• Regex remplace les caractères non pertinents par rien, garde les nouvelles lignes afin de ne pas écraser deux mots de la fin d'une ligne et du début de la ligne suivante en un par erreur. (Personne d'autre n'a discuté de plusieurs lignes, pourrait jouer au golf -2 si l'entrée est toujours une seule ligne).
• Regex divisé, Grouppar fréquence (~ = collections Python.Counter), Sortpour mettre les mots les plus fréquents à la fin.
• PowerShell est insensible à la casse par défaut pour tout.

Traitement s'il n'y a pas un mot le plus fréquent:

• Prenez les deux derniers éléments [-2, -1] dans $ y et $ z;
• une liste de N éléments, où N> = 2, fait de $ y et $ z les deux derniers éléments
• une liste à 1 élément fait de $ y le dernier élément et de $ z nul
• une liste vide les rend tous les deux nuls

Utilisez le bool-as-array-index fake-ternary-operator golf (0,1)[truthyvalue], nested, pour choisir "", $ z ou $ y en sortie, puis prenez .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 octets

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 ( -pindicateur) = 86 octets

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

En utilisant:

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

Python, 158 octets

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

Prend son entrée comme ceci:

g("Bird is the word")

Doit correspondre à toutes les exigences, bien qu'il échoue sur les chaînes vides, est-il nécessaire de les vérifier? Désolé pour le retard.

Les conseils / commentaires / astuces de magie noire pour économiser des octets sont toujours les bienvenus

Tcl 8.6, 196 octets

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

(Hélas, je ne sais pas comment l'obtenir plus petit que ça ...)

Explication

Il utilise plusieurs idiomes obscurs de Tcl pour faire des choses.

• [join [read stdin] " "] - chaîne d'entrée → liste de mots séparés par des espaces
• lmap ... - parcourir chaque élément de cette liste. (Plus court que foreachet effectivement identique puisque le résultat est rejeté.)
• [regsub ... [string tolower ...]] - Convertissez la chaîne en minuscules et supprimez tous les caractères à l'exception des mots et du tiret.
• [dict incr d ...] - Créer / modifier un dictionnaire / mot → compter l'histogramme.
• set y ... - Triez les valeurs du dictionnaire, prenez la plus grande et renvoyez toutes les paires (clé, valeur) qui lui correspondent.
• if... - Il doit y avoir exactement deux éléments: une seule paire (clé, valeur), sinon il n'y a rien à imprimer.
• puts... - Imprimez la clé dans la paire de valeurs de clé, le cas échéant. (Aucun mot n'a d'espaces.)

Vous pouvez jouer avec lui en utilisant CodeChef .

Rexx, 109 128 122 octets

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

Joli imprimé ...

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 octets

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

Opération:

déclarer un tableau associatif F d'entiers (déclarer -iA F)

f est une fonction qui, étant donné un paramètre de mot $ 1, incrémente le nombre de fréquences pour ce mot (T = ++ F [$ 1]) et se compare au nombre max jusqu'à présent (M).

Si égal, nous avons une égalité donc nous ne considérerons pas ce mot comme le plus fréquent (I =)

S'il est supérieur au nombre maximal jusqu'à présent (M), définissez le nombre maximal jusqu'à présent sur le nombre de fréquences de ce mot jusqu'à présent (M = $ T) et souvenez-vous de ce mot (I = $ 1)

Fonction de fin f

Lire une ligne (lire L) Faire des minuscules (L = $ {L ,,}) Supprimer tout caractère sauf az, 0-9, tiret (-) et espace (L = $ {L // [^ - a-z0- 9]}) Créez une séquence d'instructions bash qui appelle f pour chaque mot (printf -vA "f% s;" $ L). Ceci est enregistré dans la variable A. eval A et résultat d'impression (eval $ a; echo $ I)

Sortie:

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: CORRIGÉ J'ai un bug qui n'est pas révélé dans ces cas de test. Si l'entrée est

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

alors mon code ne devrait rien produire.

J'ai un correctif mais je semble avoir rencontré un bug bash ... J'ai un comportement très étrange si M n'est pas déclaré comme un entier: ++ F [$ 1] == M (après quelques mots répétés) incrémente les deux F [$ 1 ] et M!! - mon erreur.

Python 3, 76 98 100 octets

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

Essayez-le en ligne

Sort le mot le plus courant en minuscules. N'inclut pas les apostrophes car "les apostrophes ne doivent pas nécessairement être incluses".

statistics.mode nécessite Python 3.4

Malheureusement, aucune sortie vers stderrn'est autorisée, ou ce serait beaucoup plus court.

R, 96 octets

19 octets de moins que la réponse R existante , avec une approche quelque peu différente.

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

Lit à partir de stdin, donc l'entrée est automatiquement séparée par des espaces. Nous convertissons en minuscules et utilisons gsubpour supprimer tous les caractères non alphanumériques (plus -et '). Nous comptons les instances de chaque mot avec tableet enregistrons le résultat t. Ensuite, nous vérifions s'il y a plus d'un maximum dans t(en voyant s'il y a plus d'un élément qui est égal à max(t). Si oui, nous retournons la chaîne vide ''. Sinon, nous retournons le mot correspondant au maximum dans t.