Код повинен вводити текст (не обов'язковим може бути будь-який файл, stdin, рядок для JavaScript тощо):

This is a text and a number: 31.

Вихідні дані повинні містити слова з їх кількістю виникнення, відсортовані за кількістю подій у порядку зменшення:

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

Зауважте, що 31 - це слово, тож слово є будь-яким алфавітно-числовим числом, число не виступає як роздільники, наприклад, 0xAFкваліфікується як слово. Роздільниками буде все, що не буває алфавітно-числовим, включаючи .(крапка) і -(дефіс) таким чином i.e.або pick-me-upпризведе до 2 відповідно 3 слів. Якщо має бути чутливим до регістру, Thisі thisце два різні слова, 'також буде роздільником, wouldnі tбуде 2 різних слова від wouldn't.

Напишіть найкоротший код своєю мовою.

Найкоротша правильна відповідь поки:

• grep та coreutils - 42 байти

греп і основні  44  42

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

Тест:

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

Призводить до:

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

Оновлення

• Використовуйте нечутливий до регістру варіант і коротший вираз. Спасибі Томаш.

Ява 8: 289

Що досить добре, оскільки java - це дуже не гофрована мова.

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

Безголівки:

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

Запустити з командного рядка:

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

напр

      ⎕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

Пояснення:

• ⎕D,⎕A,⎕UCS 96+⍳26: цифри, великі літери, малі літери
• (I←⍞)∊: читати введення, зберігати I, бачити, які буквено-цифрові
• Z←I⊂⍨: розділити Iна групи буквено-цифрових символів, зберігати вZ
• +⌿∘.≡⍨Z: для кожного елемента в Z, подивіться, як часто це відбувається
• Z,⍪: збігайте кожен елемент Zпопарно з кількістю разів
• G←⊃∪↓: виберіть лише унікальні пари, зберігайте G
• ⍒,1↓⍉G: отримати відсортовані індекси для подій
• G[... ;]: впорядкувати рядки Gза поданими індексами

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

(через LINQPad в режимі "C # Заяви", не включаючи рядок введення)

Версія 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();

Безголівки:

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

Результати:

Версія 2: 114c

( [\w]включає _, що неправильно !; [A-z]включає [ \ ] ^ _ `; поселення [^_\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();

Безголівки:

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

Результати: (як версія 1)

R, 58 char

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

Використання:

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 символів

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

Розчісуйте введення для відповідності матеріалів \w+, покладіть отриманий список слів в а Bag, запитайте їх пари та сортуйте їх за від’ємним значенням. (The *є Безвідносно зірка, це не множення тут)

вихід:

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

Пітон 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)

Зараз працює з новим рядком:

$ 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 байти

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

Введення приймається як аргумент командного рядка, наприклад:

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

Виведення для вибіркового рядка:

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 - це змінна, яка містить вхідний рядок.

Перл 69

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

Додано рекомендації від @primo та @protist

Потужність: 57 55 53 62 57

(не включаючи рядок введення)

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

повертає:

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}

(з реквізитом до @microbian для групи -ca)

EcmaScript 6

Версія 1 (108 символів)

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

Версія 2 (102 символи)

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

Версія 3 (105 символів)

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

Версія 4 (94 символи)

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

Версія 5 (без попередження; 87 символів)

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

Версія 6 (100 символів)

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

Вихід:

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

Groovy 77 82

змінив регулярний вираз з [^\w]+на [^\d\p{L}]+, щоб вирішити проблему з підкресленням

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}

без першого рядка, 82 символи

вихід:

[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

Хоча gawk asortпрацює на асоціативних масивах, але, очевидно, не зберігає значення індексу, що вимагає зовнішніхsort

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

Трохи більший, але чистий рішення gawk, використовуючи PROCINFOдля встановлення порядку сортування за замовчуванням асоціативний масив (схоже, потрібен порівняно недавній gawk -> 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 символів!

(Найкоротший код JS)

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

Покращено регулярне вираження та деякі зміни.

Безумовно

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 = "Як блискучим є цей день, не є"

=> [['є', 3],
['Як', 1],
['блискучий', 1],
['цей', 1],
['день', 1],
['isn', 1] ,
['t', 1]]

Старий - 156 143 141 140 132 символів

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

Першу спробу в гольфі. Відгуки оцінені.

EcmaScript 6, 115 100 87 (без підказки та попередження)

Завдяки @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])

З оперативним та попередженням (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]))

Запустити його у Firefox.

Рубін 58 82 65

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

Пробіг:

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

^{Редагувати 58-> 80: Гаразд, я пішов. Я забув сортувати слова за випадками. Крім того, Array#uniqне є нумератором, але використовує заданий блок для порівняння елементів, тому перехід putsдо нього не фільтрував дублікати (не те, що він говорить, що ми повинні).}

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

Дегольф:

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

Вихідні дані при виклику з 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 = ()

Оновлення: Деякі пояснення, як вимагається в коментарях.

Використовує встановлені функції для створення масиву не алфавітно-цифрових символів на вході для переходу до String.Split, потім використовує функції послідовності для фільтрації порожніх рядків, генерації підрахунків слів та друку результату.

Деякі прийоми з гольфу: додає порожній рядок до аргументу функції s, щоб примусити виводити аргумент як рядок, а не явно декларувати тип. Для збереження кількох символів використовується Seq.where, а не Seq.filter (вони є синонімами). Змішує передню трубу та звичайну функціональну програму, намагаючись мінімізувати символи. Використовує currying і (op) синтаксис для лікування <> ~ - та <|| оператори як регулярні функції, щоб уникнути декларування лямбда для фільтрації порожніх рядків, сортування за зменшенням кількості та друку кортежів.

Python - 95 (зараз 87 завдяки @primo)

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

Зразок введення:

'This is a text and a number: 31'

Вибірка зразка:

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

Буде вдячний будь-який поліпшення застосувань

JavaScript 160 144 (Відредаговано: відповідати вимогам)

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

Без обмежень:

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

Реєструє кожне слово для консолі за порядком, передаючи наступний рядок:

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

Виходи:

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 

Я не маю серця користуватися alert().

k [71 символів]

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

Будь-який інший символ, крім буквено-цифрових знаків, буде розглядатися як роздільник.

приклад

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

приклад

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)

Без обмежень:

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)

Переглядає кожну можливу кількість збігів у порядку зменшення та виводить слова з такою кількістю входів. Просто щоб бути жахливим.

Примітки. Оповіщення зменшило б довжину. Строго кажучи, буквено-цифрові повинні бути[^\W_]

Haskell (153 = 104 код + 49 імпорт)

Досить пряма, повністю складена функція ... Аргумент навіть не потрібен! Це мій перший гольф, так що, їдьте легко, можливо? :)

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

Вихід:

*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 замінює не буквено-цифрові
• "" Розбиває результат на список символів
• підрахунок кожної групи підрахунків створює дікт, що відповідає різним елементам списку з кількістю випадків
• desc сортує дікт за низхідними значеннями

редагувати: виправлено випадково відповідність ascii 58-64 та 91-96

Pure Bash (без зовнішніх програм), 164

Це довше, ніж я сподівався, але хотів побачити, чи можна підрахувати та сортувати (у правильному напрямку) суто bashмасиви (асоціативні та неасоціативні):

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

Збережіть як файл сценарію chmod +x, та запустіть:

$ ./countoccur Це текст і число: 31.
a: 2
і: 1
номер 1
текст: 1
31: 1
є: 1
Це: 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-"}'

Робота виконує без гострих розширень:

$ 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

Якщо надрукувати "count: word" замість цього, це було б трохи коротше, але я хотів би імітувати даний приклад виводу ...

Tcl , 99 байт

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

Спробуйте в Інтернеті!

Python 2.X (108 - символи)

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

Python 3.X (106 - символи)

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

Хаскелл - 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

Пітон 3 - 76

Вимога розщеплення на не алфавітно-цифрові символи, на жаль, розширює код на 19 знаків. Вихід із наведеного нижче відображається правильно. Якщо ви не впевнені, додайте .most_common()після .Counter(...).

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

Вхід / Вивід

З огляду на вхід, This is a text and a number: 31.ви отримуєте наступний вихід:

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

Я спробував це з іншими цінностями, як

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

щоб переконатися, що вихід-порядок не покладається на значення / хеш ключа. Цей приклад дає:

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

Але, як я вже говорив, print(i('collections').Counter(i('re').findall('\w+',input())).most_common())результати повертаються як остаточно впорядкований список кортежів.

Python 3 - 57 (якщо місця для розбиття буде достатньо: P)

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