Mã phải nhập văn bản (không bắt buộc có thể là bất kỳ tệp nào, stdin, chuỗi cho JavaScript, v.v.):

This is a text and a number: 31.

Đầu ra phải chứa các từ có số lần xuất hiện của chúng, được sắp xếp theo số lần xuất hiện theo thứ tự giảm dần:

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

Lưu ý rằng 31 là một từ, vì vậy một từ là bất kỳ số alpha, số nào không đóng vai trò là dấu phân cách, ví dụ như 0xAFđủ điều kiện là một từ. Dấu phân cách sẽ là bất cứ thứ gì không phải là số alpha bao gồm .(dấu chấm) và -(dấu gạch nối) do đó i.e.hoặc pick-me-upsẽ dẫn đến 2 từ tương ứng 3 từ. Nên phân biệt chữ hoa chữ thường Thisvà thissẽ là hai từ khác nhau, 'cũng sẽ là dấu phân cách wouldnvà tsẽ là 2 từ khác nhau wouldn't.

Viết mã ngắn nhất trong ngôn ngữ của bạn lựa chọn.

Câu trả lời đúng ngắn nhất cho đến nay:

• grep và coreutils - 42 byte

grep và coreutils  44  42

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

Kiểm tra:

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

Kết quả trong:

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

Cập nhật

• Sử dụng tùy chọn không phân biệt chữ hoa chữ thường và regex ngắn hơn. Cảm ơn anh.

Java 8: 289

Điều này là khá tốt, vì java là một ngôn ngữ không phải là 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()));}

Ung dung:

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()));
    }
}

Chạy từ dòng lệnh:

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

ví dụ

      ⎕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

Giải trình:

• ⎕D,⎕A,⎕UCS 96+⍳26: số, chữ hoa, chữ thường
• (I←⍞)∊: đọc đầu vào, lưu trữ I, xem cái nào là chữ và số
• Z←I⊂⍨: chia Ithành các nhóm ký tự chữ và số, lưu trữ trongZ
• +⌿∘.≡⍨Z: cho mỗi phần tử trong Z, xem tần suất xảy ra
• Z,⍪: khớp từng phần tử Ztheo cặp với số lần xuất hiện
• G←⊃∪↓: chỉ chọn các cặp duy nhất, lưu trữ trong G
• ⍒,1↓⍉G: nhận các chỉ số được sắp xếp cho các lần xuất hiện
• G[... ;]: Sắp xếp lại các dòng của Gcác chỉ số đã cho

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

(thông qua LINQPad trong chế độ "Báo cáo C #", không bao gồm chuỗi đầu vào)

Phiên bả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();

Ung dung:

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

Các kết quả:

Phiên bản 2: 114c

( [\w]bao gồm _, không chính xác!; [A-z]bao gồm [ \ ] ^ _ `; giải quyết [^_\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();

Ung dung:

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

Kết quả: (như Phiên bản 1)

R, 58 char

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

Sử dụng:

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 ký tự

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

Kết hợp đầu vào cho công cụ khớp \w+, đặt danh sách các từ kết quả vào a Bag, yêu cầu các cặp của chúng và sắp xếp chúng theo giá trị âm. (Ngôi sao *là gì , nó không nhân lên ở đây)

đầu ra:

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

Con trăn 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)

Bây giờ hoạt động với dòng mới:

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

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

Đầu vào được chấp nhận làm đối số dòng lệnh, ví dụ:

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

Đầu ra cho chuỗi mẫu:

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 là một biến chứa chuỗi đầu vào.

Perl 69

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

Đã thêm đề xuất từ ​​@primo và @protist

Quyền hạn: 57 55 53 62 57

(không bao gồm chuỗi đầu vào)

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

trả về:

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}

(có đạo cụ cho @microbian cho nhóm -ca)

EcmaScript 6

Phiên bản 1 (108 ký tự)

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

Phiên bản 2 (102 ký tự)

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

Phiên bản 3 (105 ký tự)

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

Phiên bản 4 (94 ký tự)

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

Phiên bản 5 (không có cảnh báo; 87 ký tự)

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

Phiên bản 6 (100 ký tự)

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

Đầu ra:

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

Groovy 77 82

thay đổi regex từ [^\w]+sang [^\d\p{L}]+để giải quyết vấn đề với dấu gạch dưới

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}

không có dòng đầu tiên, 82 ký tự

đầu ra:

[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

Mặc dù gawk asorthoạt động trên các mảng kết hợp, nhưng rõ ràng nó không bảo toàn các giá trị chỉ mục, đòi hỏi bên ngoàisort

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

Một giải pháp gawk lớn hơn một chút nhưng thuần túy sử dụng PROCINFOđể đặt thứ tự sắp xếp mặc định cho mảng kết hợp (dường như yêu cầu một gawk tương đối gần đây -> 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 ký tự!

(Mã JS ngắn nhất)

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

Cải thiện regex và một số chỉnh sửa.

Bị đánh cắp

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 = "Ngày này không sáng bóng như thế nào"

=> [['là', 3],
['Làm thế nào', 1],
['sáng bóng', 1],
['này', 1],
['ngày', 1],
['isn', 1] ,
['t', 1]]

Cũ - 156 143 141 140 132 ký tự

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

Đã thử một lần đầu tiên tại golf. Phản hồi đánh giá cao.

EcmaScript 6, 115 100 87 (không có lời nhắc & cảnh báo)

Cảm ơn @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])

Với lời nhắc và cảnh báo (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]))

Chạy nó trong Firefox.

Hồng ngọc 58 82 65

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

Chạy thử nghiệm:

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

^{Chỉnh sửa 58-> 80: Ok, tôi đã tắt. Tôi quên sắp xếp các từ theo sự xuất hiện. Ngoài ra, Array#uniqkhông phải là một điều tra viên, nhưng sử dụng một khối nhất định để so sánh các phần tử, vì vậy việc chuyển putssang nó không lọc ra các bản sao (không phải là nó nói rằng chúng ta nên).}

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

Bị thoái hóa:

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

Đầu ra khi được gọi từ 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 = ()

Cập nhật: Một số giải thích theo yêu cầu trong các ý kiến.

Sử dụng các hàm để tạo một mảng các ký tự không phải là chữ và số trong đầu vào để chuyển đến String.Split, sau đó sử dụng các hàm chuỗi để lọc ra các chuỗi trống, tạo ra số từ và in kết quả.

Một số thủ thuật đánh gôn: Thêm một chuỗi rỗng vào đối số hàm s để buộc suy luận kiểu của đối số là một chuỗi thay vì khai báo rõ ràng loại. Sử dụng Seq.where thay vì Seq.filter để lưu một vài ký tự (chúng là từ đồng nghĩa). Trộn đường ống chuyển tiếp và ứng dụng chức năng thông thường trong nỗ lực giảm thiểu các ký tự. Sử dụng cú pháp currying và (op) để xử lý <> ~ - và <|| toán tử như các hàm thông thường để tránh khai báo lambdas để lọc các chuỗi rỗng, sắp xếp theo số lượng giảm dần và in các bộ dữ liệu.

Python - 95 (hiện 87 nhờ @primo)

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

Đầu vào mẫu:

'This is a text and a number: 31'

Đầu ra mẫu:

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

Bất kỳ sự cải thiện đường sẽ được đánh giá cao

JavaScript 160 144 (Đã chỉnh sửa: để đáp ứng yêu cầu)

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

Chưa hoàn thành:

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

Ghi nhật ký từng từ vào bảng điều khiển theo thứ tự, chuyển qua chuỗi sau:

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?.";

Đầu ra:

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 

Tôi không có trái tim để sử dụng alert().

k [71 ký tự]

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

Bất kỳ ký tự nào khác ngoại trừ ký tự chữ và số sẽ được coi là dấu phân cách.

thí dụ

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

thí dụ

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)

Chưa hoàn thành:

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)

Vòng lặp trên mỗi số lượng trận đấu có thể theo thứ tự giảm dần và xuất ra các từ có số lần xuất hiện đó. Chỉ để được kinh khủng.

Ghi chú: Thông báo sẽ giảm một số chiều dài. Nói đúng chữ và số nên được[^\W_]

Haskell (153 = 104 mã + 49 nhập)

Khá đơn giản, chức năng hoàn toàn bao gồm ... không cần tranh luận! Đây là golf đầu tiên của tôi, vì vậy đi dễ dàng, có thể? :)

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

Đầu ra:

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

(50)

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

• ssr thay thế không chữ và số
• "" vs chia kết quả thành một danh sách ký hiệu
• đếm từng nhóm đếm tạo ra một dict phù hợp với các yếu tố riêng biệt của danh sách với số lần xuất hiện
• desc sắp xếp dict bằng cách giảm giá trị

chỉnh sửa: cố định vô tình khớp ascii 58-64 và 91-96

Pure Bash (không có chương trình bên ngoài), 164

Điều này dài hơn tôi mong đợi, nhưng tôi muốn xem liệu việc đếm và sắp xếp cần thiết (đúng hướng) có thể được thực hiện hoàn toàn với bashcác mảng (kết hợp và không liên kết):

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

Lưu dưới dạng tệp tập lệnh chmod +xvà chạy:

$ ./countoccur Đây là văn bản và số: 31.
a: 2
và 1
số 1
Văn bản 1
31: 1
là: 1
Đây: 1
$ 

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

Có công việc mà không có phần mở rộng 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

Thay vào đó, nếu in "Count: word", nó sẽ ngắn hơn một chút nhưng tôi muốn bắt chước đầu ra ví dụ đã cho ...

Tcl , 99 byte

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

Hãy thử trực tuyến!

Python 2.X (108 - Ký tự)

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

Python 3.X (106 - Ký tự)

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

Trăn 3 - 76

Yêu cầu tách trên các ký tự không chữ và số không may mở rộng mã thêm 19 ký tự. Đầu ra của sau đây được hiển thị chính xác. Nếu bạn không chắc chắn, hãy thêm một .most_common()sau .Counter(...).

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

Vào / ra

Cho đầu vào của This is a text and a number: 31.bạn nhận được đầu ra sau:

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

Tôi đã thử nó với các giá trị khác như

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

để đảm bảo, thứ tự đầu ra không phụ thuộc vào giá trị / hàm băm của khóa. Ví dụ này tạo ra:

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

Nhưng như tôi đã nói, print(i('collections').Counter(i('re').findall('\w+',input())).most_common())sẽ trả về kết quả dưới dạng một danh sách các bộ dữ liệu được sắp xếp chắc chắn .

Python 3 - 57 (nếu một không gian đủ để chia tách: P)

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