¿Cuál es la palabra más frecuente?

Dada una oración, su programa debe atravesarla, contando las frecuencias de cada palabra, luego generar la palabra más utilizada. Debido a que una oración no tiene una longitud fija y, por lo tanto, puede ser muy larga, su código debe ser lo más corto posible.

Reglas / requisitos

• Cada presentación debe ser un programa completo o una función. Si es una función, debe ser ejecutable solo necesitando agregar la llamada a la función al final del programa. Cualquier otra cosa (por ejemplo, encabezados en C), debe incluirse.
• Debe haber un intérprete / compilador gratuito disponible para su idioma.
• Si es posible, proporcione un enlace a un sitio donde se pueda probar su programa.
• Su programa no debe escribirle nada STDERR.
• Su programa debe recibir información de STDIN(o la alternativa más cercana en su idioma).
• Las lagunas estándar están prohibidas.
• Su programa debe ser sensible a las mayúsculas ( tHe, They thecontribuir a la cuenta de the).
• Si no hay una palabra más frecuente (vea el caso de prueba # 3), su programa no debería generar nada.

Definición de una 'palabra':

Obtiene la lista de palabras dividiendo el texto de entrada en espacios. La entrada nunca contendrá ningún otro tipo de espacio en blanco que los espacios simples (en particular, no hay líneas nuevas). Sin embargo, las palabras finales solo deben contener caracteres alfanuméricos (az, AZ, 0-9), guiones (-) y apóstrofes ('). Puede hacerlo eliminando todos los demás caracteres o reemplazándolos por espacios antes de dividir la palabra. Para seguir siendo compatible con versiones anteriores de las reglas, no es necesario incluir apóstrofes.

Casos de prueba

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

Nota: Los casos de prueba tercero y séptimo no tienen salida, puede elegir cualquiera de los cuatro.

Tanteo

Los programas se puntúan según los bytes. El juego de caracteres habitual es UTF-8; si está utilizando otro, especifíquelo.

Cuando finalice el desafío, el programa con la menor cantidad de bytes (se llama code-golf ), ganará.

Envíos

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

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

Tabla de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

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

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

Pruébalo aquí!

O 23 22 bytes (sin competencia, agregue el nodo donde mata la pila si es falso)

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

Pruébalo aquí!

O con puntuación, 23 bytes (creo que esto compite? Comprometerse antes de la edición)

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

Pruébalo aquí!

O 12 bytes (definitivamente sin competencia)

l1.cj.#jR/)e

Pruébalo aquí!

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

Jalea , 25 bytes

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

Pruébalo en línea! o verificar todos los casos de prueba .

Pyth - 23 30 bytes

Tiene que haber una mejor manera de incluir dígitos y guiones, pero solo quiero arreglar esto ahora.

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

Test Suite .

Octava, 115 94 bytes

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

Cuentas para el caso sin palabras más frecuentes mediante el uso try. En este caso, no genera nada y "toma un descanso" hasta que detecta la excepción.

Ahorró 21 (!) Bytes gracias a la sugerencia de Luis Mendo (usando la tercera salida de modepara obtener la palabra más común).

_{Las reglas han cambiado bastante desde que publiqué mi respuesta original. Veré la expresión regular más tarde.}

Perl 6, 80 bytes

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

Dividamos la respuesta en dos partes ...

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

givenes una declaración de control (como ifo for). En Perl 6, están permitidos como postfixes. ( a if 1o como aquí foo given 3) givenpone su tema (lado derecho) en la variable especial $_para su lado izquierdo.

El "tema" en minúsculas ( lc), se divide por palabra ( words), coloca los valores en una bolsa (conjunto con número de ocurrencias), luego se ordena por valor (DESC). Como sortsolo sabe cómo operar en listas, aquí Bagse transforma en una Listde Pairs.

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

un condicional simple ( ?? !!se usa en Perl 6, en lugar de ? :).

$_ > 1

Simplemente verifica que la lista tenga más de un elemento.

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

Los accesos a $_se pueden acortar ... Al no especificar la variable. .aes exactamente igual $_.a. Entonces esto es efectivamente "¿tienen los dos elementos superiores el mismo número de ocurrencias? - Si es así, imprimimos" (la cadena vacía).

De lo contrario, es la impresión de la clave del elemento superior (la cuenta): .[0].key.

05AB1E , 30 bytes

Código:

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

Utiliza la codificación CP-1252 . Pruébalo en línea! .

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)

Basado en la respuesta de Python de @ Blue.

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

( +17 bytes, porque aparentemente, incluso si hay palabras más frecuentes que el resto, pero tienen la misma frecuencia, todavía no se debe devolver nada ) .

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

Ahora debe satisfacer todas las condiciones. Esta presentación supone que se ingresa al menos 1 palabra.

¡Pruébelo en línea! (Ideone)

Además, si desea una, aquí hay otra versión de mi función desprovista de expresiones regulares a un costo de aproximadamente 43 bytes, aunque esta no es competitiva de todos modos, por lo que realmente no importa. Solo lo puse aquí por el gusto de hacerlo:

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

¡Prueba esta nueva versión en línea! (Ideone)

Ruby, 94 92 102 bytes

Tengo que ir rápido (respuesta FGITW). Devuelve la palabra en mayúsculas, o nilsi no hay una palabra más frecuente.

Ahora actualizado a nuevas especificaciones, creo. Sin embargo, me las arreglé para jugar golf un poco, ¡así que el conteo de bytes es el mismo!

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

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

Banco de pruebas.

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>

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

Pruébalo en línea!

Sqlserver 2016, 174 bytes

No se pueden manejar datos como este ejemplo (contando los iguales como 3 palabras):

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

Salida:

Ingrese si alguien está interesado:

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

Si no hay una palabra más frecuente (vea el caso de prueba # 3), su programa no debería generar nada.

EDITAR:

Manejo ':

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

Salida:

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

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

Esta es una función que acepta una cadena y devuelve una cadena si una sola palabra aparece con más frecuencia que otras y de lo NULLcontrario. Para llamarlo, asígnelo a una variable.

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

Retina, 97 bytes

Las reglas siguen cambiando ...

T`L`l
[^-\w ]

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

!`[-\w]+$

Pruébalo en línea!

Banco de pruebas.

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]

El código anterior supone que la entrada tiene al menos dos palabras.

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

Python 2, 218 bytes

Asume más de 2 palabras. Deshacerme de la puntuación me destruyó ...

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)

• Reglas cambiadas: /

.

      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 es necesario para ejecutar esto.

• ¿Cómo funciona esto? Uno de los mejores privilegios de regex reemplaza en matlab: ejecuta tokens en el campo llamando a funciones ambientales externas parametrizadas por los tokens capturados en el entorno interno, por lo que cualquier secuencia de "Word_A Word_B .."se reemplaza por enteros "A0 A1 A2 B0 B1 B2 ..."donde el primer entero es la firma numerica ascii de la palabra, el segundo es el índice inicial, el tercero es el índice final, estos dos últimos enteros no se reduplican en toda la secuencia, así que aproveché esta ventaja para transponerlo a una matriz, luego lo modelé y luego busqué el dar como resultado esa matriz, por lo que los índices iniciales / finales seguirán en consecuencia.

• Editar: después de cambiar algunos detalles, el programa se llama función mediante un parámetro de cadena.

20 bytes guardados gracias a @StewieGriffin, 30 bytes añadieron reproches a las lagunas comunes acordadas.

05AB1E , 22 21 20 bytes

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

Explicación:

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

Nota: Si está de acuerdo con las nuevas líneas finales en la salida para cuando se supone que no debe generar nada, elimine ?al final para guardar un byte.

Nota # 2: El programa no funcionará con una sola palabra, pero dudo que esto sea un problema. Si desea solucionar este problema, reemplace #con ð¡un byte adicional.

05AB1E usa CP-1252 como el juego de caracteres, no UTF-8.

Pruébalo en línea!

Perl, 60 56 55 54 bytes

Incluye +3 para -p

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

Si una palabra no puede ser solo un número, también puede soltar aun puntaje de 53.

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

La primera parte es bastante fácil:

• $input es ~ = stdin
• Regex reemplaza los caracteres irrelevantes con nada, mantenga líneas nuevas para que no mezclemos dos palabras del final de una línea y el comienzo de la siguiente línea en una por error. (Nadie más ha discutido varias líneas, podría jugar golf -2 si la entrada es siempre una sola línea).
• Regex dividido, Grouppor frecuencia (~ = colecciones de Python. Contador ), Sortpara poner las palabras más frecuentes al final.
• PowerShell no distingue entre mayúsculas y minúsculas por defecto para todo.

Manejo si no hay una palabra más frecuente:

• Tome los dos últimos elementos [-2, -1] en $ y y $ z;
• una lista de N elementos, donde N> = 2, hace que $ y y $ z sean los dos últimos elementos
• una lista de 1 elemento convierte $ y en el último elemento y $ z nulo
• una lista vacía hace que ambos sean nulos

Use el campo bool-as-array-index fake-ternary-operator golf (0,1)[truthyvalue], anidado, para elegir "", $ z o $ y como salida, luego tome .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 ( -pbandera) = 86 bytes

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

Utilizando:

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

Toma su entrada así:

g("Bird is the word")

Debe coincidir con todos los requisitos, aunque falla en cadenas vacías, ¿es necesario verificarlos? Perdón por el retraso.

Consejos / comentarios / consejos de magia negra para guardar bytes son siempre bienvenidos

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

(Por desgracia, no puedo entender cómo hacerlo más pequeño que eso ...)

Explicación

Utiliza varios modismos oscuros de Tcl para hacer cosas.

• [join [read stdin] " "] - cadena de entrada → lista de palabras separadas por espacios en blanco
• lmap ... - iterar sobre cada elemento de esa lista. (Más corto que foreachy efectivamente idéntico ya que el resultado se descarta).
• [regsub ... [string tolower ...]] - Convierta la cadena en minúsculas y elimine todos los caracteres, excepto los caracteres de palabras y el guión.
• [dict incr d ...] - Crear / modificar un diccionario / palabra → contar histograma.
• set y ... - Ordene los valores del diccionario, tome el más grande y devuelva todos los pares (clave, valor) correspondientes.
• if... - Debe haber exactamente dos elementos: un solo par (clave, valor), de lo contrario no hay nada que imprimir.
• puts... - Imprima la clave en el par de valores clave, si corresponde. (Ninguna palabra tiene espacios).

Puedes jugar con él usando 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

Bastante impreso ...

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

golpe, 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

Operación:

declarar una matriz asociativa F de enteros (declarar -iA F)

f es una función que, dado un parámetro de palabra $ 1, incrementa el conteo de frecuencia para esta palabra (T = ++ F [$ 1]) y se compara con el conteo máximo hasta ahora (M).

Si es igual, tenemos un empate, por lo que no consideraremos que esta palabra sea más frecuente (I =)

Si es mayor que el recuento máximo hasta ahora (M), establezca el recuento máximo hasta el momento en el recuento de frecuencia de esta palabra hasta el momento (M = $ T) y recuerde esta palabra (I = $ 1)

Función final f

Leer una línea (leer L) Hacer minúsculas (L = $ {L ,,}) Eliminar cualquier carácter excepto az, 0-9, guión (-) y espacio (L = $ {L // [^ - a-z0- 9]}) Haga una secuencia de sentencias bash que invoque f para cada palabra (printf -vA "f% s;" $ L). Esto se guarda en la variable A. eval A e imprime el resultado (eval $ a; echo $ I)

Salida:

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

Error: CORREGIDO Tengo un error que no se revela en estos casos de prueba. Si la entrada es

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

entonces mi código no debería mostrar nada.

Tengo una solución, pero parece que he encontrado un error bash ... Tengo un comportamiento muy extraño si M no se declara un entero: ++ F [$ 1] == M (después de algunas palabras repetidas) incrementa ambos F [$ 1 ] ¡¡y M!! - mi error.

Python 3, 76 98100 bytes

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

Pruébalo en línea

Emite la palabra más común en minúsculas. No incluye apóstrofes porque "no es necesario incluir apóstrofes".

statistics.mode requiere Python 3.4

Desafortunadamente, no stderrse permite la salida a , o sería mucho más corto.

R, 96 bytes

19 bytes más corto que la respuesta R existente , con un enfoque algo diferente.

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

Lee desde stdin, por lo que la entrada se separa automáticamente por espacios. Convertimos a minúsculas y las usamos gsubpara eliminar todos los caracteres no alfanuméricos (más -y '). Contamos las instancias de cada palabra con tabley guardamos el resultado en t. A continuación, verificamos si hay más de 1 máximo en t(al ver si hay más de un elemento que es igual a max(t). Si es así, devolvemos la cadena vacía ''. Si no, devolvemos la palabra correspondiente al máximo en t.