El código debe ingresar un texto (no obligatorio puede ser cualquier archivo, stdin, cadena para JavaScript, etc.):

This is a text and a number: 31.

La salida debe contener las palabras con su número de ocurrencias, ordenadas por el número de ocurrencias en orden descendente:

a:2
and:1
is:1
number:1
This:1
text:1
31:1

Tenga en cuenta que 31 es una palabra, por lo que una palabra es cualquier cosa alfanumérica, el número no actúa como separador, por ejemplo, 0xAFcalifica como una palabra. Los separadores serán cualquier cosa que no sea alfanumérica, incluidos .(punto) y -(guión), i.e.o pick-me-upque resulten en 2 respectivamente 3 palabras. Debería distinguir entre mayúsculas Thisy minúsculas, y thisserían dos palabras diferentes, 'también sería un separador wouldny tserían 2 palabras diferentes de wouldn't.

Escriba el código más corto en su idioma de elección.

La respuesta correcta más corta hasta ahora:

• grep y coreutils - 42 bytes

grep y coreutils  44  42

grep -io '[a-z0-9]*'|sort|uniq -c|sort -nr

Prueba:

printf "This is a text and a number: 31." |
grep -io '[a-z0-9]*'|sort|uniq -c|sort -nr

Resultados en:

  2 a
  1 This
  1 text
  1 number
  1 is
  1 and
  1 31

Actualizar

• Use la opción que no distingue entre mayúsculas y minúsculas y expresiones regulares más cortas. Gracias tomas.

Java 8: 289

Lo cual es bastante bueno, ya que Java es un lenguaje muy ajeno al golf.

import java.util.stream.*;class C{static void main(String[]a){Stream.of(a).flatMap(s->of(s.split("[\\W_]+"))).collect(Collectors.groupingBy(x->x,Collectors.counting())).entrySet().stream().sorted(x,y->x.getValue()-y.getValue()).forEach(e->System.out.println(e.getKey()+":"+e.getValue()));}

Sin golf:

import java.util.stream.*;
class C {
    static void main(String [] args){
        Stream.of(args).flatMap(arg->Stream.of(arg.split("[\\W_]+")))
            .collect(Collectors.groupingBy(word->word,Collectors.counting()))
            .entrySet().stream().sorted(x,y->x.getValue()-y.getValue())
            .forEach(entry->System.out.println(entry.getKey()+":"+entry.getValue()));
    }
}

Ejecutar desde la línea de comando:

java -jar wordCounter.jar This is a text and a number: 31.

APL (57)

⎕ML←3⋄G[⍒,1↓⍉G←⊃∪↓Z,⍪+⌿∘.≡⍨Z←I⊂⍨(I←⍞)∊⎕D,⎕A,⎕UCS 96+⍳26;]

p.ej

      ⎕ML←3⋄G[⍒,1↓⍉G←⊃∪↓Z,⍪+⌿∘.≡⍨Z←I⊂⍨(I←⍞)∊⎕D,⎕A,⎕UCS 96+⍳26;]
This is a text and a number: 31.
 a       2
 This    1
 is      1
 text    1
 and     1
 number  1
 31      1

Explicación:

• ⎕D,⎕A,⎕UCS 96+⍳26: números, letras mayúsculas, letras minúsculas
• (I←⍞)∊: leer entrada, almacenar I, ver cuáles son alfanuméricos
• Z←I⊂⍨: dividido Ien grupos de caracteres alfanuméricos, almacenar enZ
• +⌿∘.≡⍨Z: para cada elemento en Z, vea con qué frecuencia ocurre
• Z,⍪: empareja cada elemento en Zpares con la cantidad de veces que ocurre
• G←⊃∪↓: seleccione solo los pares únicos, almacene en G
• ⍒,1↓⍉G: obtener índices ordenados para las ocurrencias
• G[... ;]: reordenar las líneas de Gpor los índices dados

C #: 153c 144c 142c 111c 115c 118c 114c 113c

(a través de LINQPad en modo "C # Statements", sin incluir la cadena de entrada)

Versión 1: 142c

var s = "This is a text and a number: 31."; // <- line not included in count
s.Split(s.Where(c=>!Char.IsLetterOrDigit(c)).ToArray(),(StringSplitOptions)1).GroupBy(x=>x,(k,e)=>new{s,c=e.Count()}).OrderBy(x=>-x.c).Dump();

Sin golf:

var s = "This is a text and a number: 31.";
s.Split(                                                     // split string on multiple separators
    s.Where(c => !Char.IsLetterOrDigit(c))                   // get list of non-alphanumeric characters in string
     .ToArray(),                                             // (would love to get rid of this but needed to match the correct Split signature)
    (StringSplitOptions)1                                    // integer equivalent of StringSplitOptions.RemoveEmptyEntries
).GroupBy(x => x, (k, e) => new{ s = k, c = e.Count() })     // count by word
 .OrderBy(x => -x.c)                                         // order ascending by negative count (i.e. OrderByDescending)
 .Dump();                                                    // output to LINQPad results panel

Resultados:

Versión 2: 114c

( [\w]incluye _, que es incorrecto; [A-z]incluye [ \ ] ^ _ `; establecerse [^_\W]+)

var s = "This is a text and a number: 31."; // <- line not included in count
Regex.Matches(s, @"[^_\W]+").Cast<Match>().GroupBy(m=>m.Value,(m,e)=>new{m,c=e.Count()}).OrderBy(g=>-g.c).Dump();

Sin golf:

Regex.Matches(s, @"[^_\W]+")                                   // get all matches for one-or-more alphanumeric characters
     .Cast<Match>()                                            // why weren't .NET 1 collections retrofitted with IEnumerable<T>??
     .GroupBy(m => m.Value, (m,e) => new{ m, c = e.Count() })  // count by word
     .OrderBy(g => -g.c)                                       // order ascending by negative count (i.e. OrderByDescending)
     .Dump();                                                  // output to LINQPad results panel

Resultados: (como la Versión 1)

R, 58 char

sort(table(unlist(strsplit(scan(,""),"[[:punct:]]"))),d=T)

Uso:

sort(table(unlist(strsplit(scan(,""),"[[:punct:]]"))),d=T)
1: This is a text and a number: 31.
9: 
Read 8 items

     a     31    and     is number   text   This 
     2      1      1      1      1      1      1 

perl6: 49 caracteres

.say for get.comb(/\w+/).Bag.pairs.sort(-*.value)

Peine la entrada para la coincidencia de cosas \w+, coloque la lista resultante de palabras en a Bag, solicite sus pares y ordénelos por valor negativo. (El *es una estrella Lo que sea , no es multiplicación aquí)

salida:

"a" => 2
"This" => 1
"is" => 1
"text" => 1
"and" => 1
"number" => 1
"31" => 1

Python 101 97

import re
a=re.split('[_\W]+',input())
f=a.count
for w in sorted(set(a),key=f)[::-1]:print w,f(w)

Ahora funciona con nueva línea:

$ python countword.py <<< '"This is    a text and a number: 31, and a\nnewline"'
a 3
and 2
31 1
number 1
newline 1
is 1
text 1
This 1

PHP - 84 bytes

<?$a=array_count_values(preg_split('/[_\W]+/',$argv[1],0,1));arsort($a);print_r($a);

La entrada se acepta como un argumento de línea de comando, por ejemplo:

$ php count-words.php "This is a text and a number: 31."

Salida para la cadena de muestra:

Array
(
    [a] => 2
    [number] => 1
    [31] => 1
    [and] => 1
    [text] => 1
    [is] => 1
    [This] => 1
)

PowerShell (40)

$s -split"\W+"|group -ca|sort count -des

$ s es una variable que contiene la cadena de entrada.

Perl 69

$h{$_}++for<>=~/\w+/g;print"$_: $h{$_}
"for sort{$h{$b}-$h{$a}}keys%h

Se agregaron recomendaciones de @primo y @protist

Powershell: 57 55 53 62 57

(sin incluir la cadena de entrada)

$s = "This is a text and a number: 31."    # <-- not counting this line...
[Regex]::Matches($s,"[^_\W]+")|group -ca|sort{-$_.Count}

devoluciones:

Count Name                      Group
----- ----                      -----
    2 a                         {a, a}
    1 and                       {and}
    1 31                        {31}
    1 number                    {number}
    1 This                      {This}
    1 is                        {is}
    1 text                      {text}

(con accesorios para @microbian para el grupo -ca)

EcmaScript 6

Versión 1 (108 caracteres)

s.split(_=/[^a-z\d]/i).map(x=>_[x]=-~_[x]);keys(_).sort((a,b)=>_[a]<_[b]).map(x=>x&&console.log(x+':'+_[x]))

Versión 2 (102 caracteres)

s.split(_=/[^a-z\d]/i).map(x=>_[x]=-~_[x]);keys(_).sort((a,b)=>_[a]<_[b]).map(x=>x&&alert(x+':'+_[x]))

Versión 3 (105 caracteres)

s.match(_=/\w+/g).map(x=>_[x]=-~_[x]);alert(keys(_).sort((a,b)=>_[a]<_[b]).map(x=>x+':'+_[x]).join('\n'))

Versión 4 (94 caracteres)

s.match(_=/\w+/g).map(x=>_[x]=-~_[x]);keys(_).sort((a,b)=>_[a]<_[b]).map(x=>alert(x+':'+_[x]))

Versión 5 (sin alerta; 87 caracteres)

s.match(_=/\w+/g).map(x=>_[x]=-~_[x]);keys(_).sort((a,b)=>_[a]<_[b]).map(x=>x+':'+_[x])

Versión 6 (100 caracteres)

keys(_,s.match(_=/\w+/g).map(x=>_[x]=-~_[x])).sort((a,b)=>_[a]<_[b]).map(x=>console.log(x+':'+_[x]))

Salida:

a:2
31:1
This:1
is:1
text:1
and:1
number:1

Maravilloso 77 82

Se modificó la expresión regular de [^\w]+a [^\d\p{L}]+para resolver el problema con el guión bajo

String s = 'This is a text and a number: 31'

def a=s.split(/[^\d\p{L}]+/) 
a.collectEntries{[it, a.count(it)]}.sort{-it.value}

sin primera línea, 82 caracteres

salida:

[a:2, This:1, is:1, text:1, and:1, number:1, 31:1]

GNU awk + coreutils: 71 69

gawk 'BEGIN{RS="\\W+"}{c[$0]++}END{for(w in c)print c[w],w}'|sort -nr

Aunque gawk asortfunciona en matrices asociativas, aparentemente no conserva los valores de índice, por lo que necesita el externosort

printf "This is a text and a number: 31." | 
gawk 'BEGIN{RS="\\W+"}{c[$0]++}END{for(w in c)print c[w],w}'|sort -nr
2 a
1 This
1 text
1 number
1 is
1 and
1 31

GNU awk 4.x: 100 93

Una solución gawk ligeramente más grande pero pura que se usa PROCINFOpara establecer el orden de clasificación predeterminado para la matriz asociativa (parece requerir un gawk relativamente reciente -> 4.x?)

BEGIN{RS="\\W+";PROCINFO["sorted_in"]="@val_num_desc"}
{c[$0]++}
END{for(w in c)print c[w],w}

Javascript - 132 126 caracteres!

(Código JS más corto)

o={},a=[]
for(i in s=s.split(/[\W_]+/))o[z=s[i]]=o[z]+1||1
for(j in o)a.push([j,o[j]])
a.sort(function(b,c){return c[1]-b[1]})

Se mejoró la expresión regular y algunas ediciones.

Sin golf

s = s.split(/[\W_]+/), o={}, a=[]; // split along non-char letters, declare object and array

for (i in s) { n = s[i]; o[n] = o[n] + 1 || 1 } // go through each char and store it's occurence

for (j in o) a.push( [j, o[j]] ); // store in array for sorting

a.sort(function (b, c){ return c[1] - b[1]; }); // sort !

<= // make s = "Lo brillante que es este día no lo es"

=> [['' es ', 3],
[' Cómo ', 1],
[' brillante ', 1],
[' esto ', 1],
[' día ', 1],
[' isn ', 1] ,
['t', 1]]

Viejo - 156 143 141 140 132 caracteres

s=s.split(/[^\w]+/g),o={}
for(i in s){n=s[i];o[n]=o[n]+1||1}a=[]
for(j in o)a.push([j,o[j]])
a.sort(function(b,c){return c[1]-b[1]})

Dio un primer intento en el golf. Comentarios apreciados.

EcmaScript 6, 115 100 87 (sin aviso y alerta)

Gracias a @eithedog:

s.match(/\w+/g,a={}).map(w=>a[w]=-~a[w]),keys(a).map(w=>[w,a[w]]).sort((a,b)=>b[1]-a[1])

Con aviso y alerta (100):

prompt(a={}).match(/\w+/g).map(w=>a[w]=-~a[w]);alert(keys(a).map(w=>[w,a[w]]).sort((a,b)=>b[1]-a[1]))

Ejecútalo en Firefox.

Rubí 58 82 65

h=Hash.new 0
gets.scan(/[\d\w]+/){h[$&]+=1}
p *h.sort_by{|k,v|-v}

Prueba de funcionamiento:

$ ruby counttext.rb <<< "This is a text and a number: 31."
["a", 2]
["text", 1]
["This", 1]
["is", 1]
["and", 1]
["number", 1]
["31", 1]

^{Editar 58-> 80: Ok, estaba muy lejos. Olvidé ordenar las palabras por ocurrencias. Además, Array#uniqno es un enumerador, pero usa un bloque dado para comparar elementos, por lo que pasarlo putsno filtró duplicados (no es que diga que deberíamos).}

F # - 169

let f s=(s+"").Split(set s-set(['a'..'z']@['A'..'Z']@['0'..'9'])|>Set.toArray)|>Seq.where((<>)"")|>Seq.countBy id|>Seq.sortBy((~-)<<snd)|>Seq.iter((<||)(printfn"%s:%d"))

Degolfed:

let count (s : string) =
    s.Split (set s - set (['a'..'z']@['A'..'Z']@['0'..'9']) |> Set.toArray)
 |> Seq.where ((<>) "")
 |> Seq.countBy id
 |> Seq.sortBy ((~-) << snd)
 |> Seq.iter ((<||) (printfn "%s:%d"))

Salida cuando se llama desde fsi:

> "This is a text and a number: 31." |> f
a:2
This:1
is:1
text:1
and:1
number:1
31:1
val it : unit = ()

Actualización: alguna explicación según lo solicitado en los comentarios.

Utiliza funciones de conjunto para generar una matriz de caracteres no alfanuméricos en la entrada para pasar a String.Split, luego usa funciones de secuencia para filtrar cadenas vacías, generar recuentos de palabras e imprimir el resultado.

Algunos trucos de golf: agrega una cadena vacía al argumento de función s para forzar la inferencia de tipo del argumento como una cadena en lugar de declarar explícitamente el tipo. Utiliza Seq.where en lugar de Seq.filter para guardar algunos caracteres (son sinónimos). Mezcla la aplicación de canalización hacia adelante y la función ordinaria en un intento de minimizar los caracteres. Utiliza curry y (op) sintaxis para tratar <> ~ - y <|| operadores como funciones regulares para evitar declarar lambdas para filtrar cadenas vacías, ordenar por conteo descendente e imprimir tuplas.

Python - 95 (ahora 87 gracias a @primo)

d=__import__('re').findall(r'\w+',raw_input())
print sorted(map(lambda y:(y,d.count(y)),d))

Entrada de muestra:

'This is a text and a number: 31'

Salida de muestra:

[('This', 1),('is', 1), ('a', 2),('text', 1),('and', 1),('a', 2),('number', 1),('31', 1)]

Cualquier mejora en la sugestión sería apreciada

JavaScript 160 144 (Editado: para cumplir con los requisitos)

f=Function;o={};s.replace(/\w+/g,f('a','o[a]=++o[a]||1'));Object.keys(o).sort(f('b,c','return o[c]-o[b]')).map(f('k','console.log(k+" "+o[k])'))

No minificado:

f=Function;
o = {};
s.replace(/\w+/g, f('a','o[a]=++o[a]||1'));
Object.keys(o).sort(f('b,c', 'return o[c]-o[b]')).map(f('k','console.log(k+" "+o[k])'))

Registra cada palabra en la consola en orden, pasando la siguiente cadena:

s="This is sam}}ple text 31to test the effectiveness of this code, you can clearly see that this is working-as-intended, but you didn't doubt it did you?.";

Salidas:

you 3
this 2
is 2
can 1
text 1
31to 1
test 1
the 1
effectiveness 1
of 1
This 1
code 1
sam 1
ple 1
clearly 1
see 1
that 1
working 1
as 1
intended 1
but 1
didn 1
t 1
doubt 1
it 1
did 1 

No tengo el corazón para usar alert().

k [71 caracteres]

f:{s:" ",x;`_k!m@k:|(!m)@<.:m:#:'=`$1_'(&~((),/:s)like"[a-zA-Z0-9]")_s}

Cualquier otro carácter, excepto los caracteres alfanuméricos, se considerará como delimitador.

ejemplo

f "This is a text and a number: 31."
a     | 2
31    | 1
number| 1
and   | 1
text  | 1
is    | 1
This  | 1

ejemplo

f "won't won won-won"
won| 4
t  | 1

Javascript (135)

u=/\w+/g
for(i=s.length;i--;)for(w in a=s.match(u))u[w=a[w]]=u[w]||a.reduce(function(p,c){return p+=w==c},0)==i&&!console.log(w+":"+i)

No minificado:

u=/\w+/g;for (i=s.length;i--;)
    for(w in a=s.match(u))
        u[w=a[w]] = u[w] || 
           a.reduce(function(p,c){return p+=w==c},0)==i && !console.log(w+":"+i)

Recorre cada número posible de coincidencias en orden descendente y genera palabras con ese número de ocurrencias. Solo para ser horrible.

Notas: La alerta habría reducido algo la longitud. Estrictamente hablando, alfanumérico debería ser[^\W_]

Haskell (153 = 104 código + 49 importación)

Función bastante sencilla y totalmente compuesta ... ¡ni siquiera es necesario un argumento! Este es mi primer golf, así que, ¿qué tal? :)

import Data.Char
import Data.List
import Data.Ord
so=reverse.(sortBy$comparing snd).(map(\t@(x:_)->(x,length t))).group.sort.(map$filter isAlphaNum).words

Salida:

*Main> so "This is a text and a number: 31."
[("a",2),("text",1),("number",1),("is",1),("and",1),("This",1),("31",1)]

q (50)

desc count each group" "vs ssr[;"[^0-9A-Za-z]";" "]

• ssr reemplaza no alfanumérico
• "" vs divide el resultado en una lista de símbolos
• contar cada grupo cuenta crea un dict que combina elementos distintos de la lista con el número de ocurrencias
• desc ordena el dict por valores descendentes

editar: arreglado accidentalmente ascii 58-64 y 91-96

Pure Bash (sin programas externos), 164

Esto es más largo de lo que esperaba, pero quería ver si el recuento y la ordenación necesarios (en la dirección correcta) se podían hacer exclusivamente con bashmatrices (asociativas y no asociativas):

declare -A c
for w in ${@//[[:punct:]]/ };{ ((c[$w]++));}
for w in ${!c[@]};{ i=${c[$w]};((m=i>m?i:m));s[$i]+=$w:;}
for((i=m;i>0;i--));{ printf "${s[i]//:/:$i
}";}

Guardar como un archivo de script chmod +x, y ejecutar:

$ ./countoccur Este es un texto y un número: 31.
a: 2
y 1
numero 1
Texto 1
31: 1
es: 1
Esto: 1
PS 

AWK

awk -vRS='[^A-Za-z0-9]' '$0{c[$0]++}END{for(i in c)print c[i]"\t"i": "c[i]|"sort -nr|cut -f2-"}'

¿El trabajo sin extensiones gawkish:

$ echo 'This is a text and a number: 31.' | awk -vRS='[^A-Za-z0-9]' '$0{c[$0]++}END{for(i in c)print c[i]"\t"i": "c[i]|"sort -nr|cut -f2-"}'
a: 2
This: 1
text: 1
number: 1
is: 1
and: 1
31: 1

Si imprime "count: word" en su lugar, sería un poco más corto, pero quería imitar el resultado del ejemplo dado ...

Tcl , 99 bytes

proc C s {lmap w [split [regsub -all \[^\\w|\ \] $s {}]] {dict inc D $w}
lsort -s 2 -inde 1 -de $D}

Pruébalo en línea!

Python 2.X (108 - Personajes)

print'\n'.join('{}:{}'.format(a,b)for a,b in __import__("collections").Counter(raw_input().split()).items())

Python 3.X (106 - Personajes)

print('\n'.join('{}:{}'.format(a,b)for a,b in __import__("collections").Counter(input().split()).items())

Haskell - 137

import Data.List
count text=let textS=(words(text\\".-\':")) in (sortBy (\(_,n) (_,m) -> compare m n)).nub$map(\t->(t,(length.(filter(==t)))textS)) textS

Python 3 - 76

Desafortunadamente, el requisito de división en caracteres no alfanuméricos extiende el código en 19 caracteres. El resultado de lo siguiente se muestra correctamente. Si no está seguro, agregue un .most_common()después de .Counter(...).

i=__import__
print(i('collections').Counter(i('re').findall('\w+',input())))

Entrada / salida

Dada la entrada de This is a text and a number: 31.usted obtiene la siguiente salida:

Counter({'a': 2, 'is': 1, 'This': 1, 'and': 1, '31': 1, 'number': 1, 'text': 1})

Lo probé con otros valores como

1 2 3 4 5 6 7 8 2 1 5 3 4 6 8 1 3 2 4 6 1 2 8 4 3 1 3 2 5 6 5 4  2 2 4 2 1 3 6

para garantizar, el orden de salida no depende del valor / hash de la clave. Este ejemplo produce:

Counter({'2': 8, '3': 6, '1': 6, '4': 6, '6': 5, '5': 4, '8': 3, '7': 1})

Pero como dije, print(i('collections').Counter(i('re').findall('\w+',input())).most_common())devolvería los resultados como una lista definitivamente ordenada de tuplas.

Python 3 - 57 (si un espacio fuera suficiente para dividir: P)

print(__import__('collections').Counter(input().split()))