코드는 텍스트를 입력해야합니다 (필수는 아니지만 파일, 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 개의 단어를 생성합니다. 대소 문자이어야 This하고 this두 개의 다른 단어 것, '또한 이렇게 구분 것 wouldn및 t2 개 가지 단어 것이다 wouldn't.

선택한 언어로 가장 짧은 코드를 작성하십시오.

지금까지 가장 짧은 정답 :

• grep 및 coreutils-42 바이트

grep 및 coreutils  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

자바는 골퍼가 아닌 언어이기 때문에 꽤 좋습니다.

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

(입력 문자열을 제외하고 "C # 문"모드에서 LINQPad를 통해)

버전 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 자

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쌍을 요청한 다음 음수 값으로 정렬하십시오. (는 *A는 무엇이든을 , 여기 곱셈 스타 아니다)

산출:

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

(그룹 -ca를 위해 @microbian에 소품 포함)

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

그루비 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

PROCINFO연관 배열의 기본 정렬 순서를 설정하는 데 사용하는 약간 더 크지 만 순수한 gawk 솔루션 (상대적으로 gawk-> 4.x?

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

자바 스크립트 - (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 = "오늘은 얼마나 반짝이지 않습니까?"

=> [[ 'is', 3],
[ 'How', 1],
[ 'shiny', 1],
[ 'this', 1],
[ 'day', 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]})

골프를 처음 시도해보십시오. 의견 감사합니다.

ECMA 스크립트 (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 = ()

업데이트 : 의견에서 요청한 설명.

set 함수를 사용하여 입력에 영숫자가 아닌 문자 배열을 생성하여 String에 전달한 다음 시퀀스 함수를 사용하여 빈 문자열을 필터링하고 단어 수를 생성하고 결과를 인쇄합니다.

일부 골프 트릭 : 함수 인수에 빈 문자열을 추가하여 명시 적으로 형식을 선언하지 않고 인수의 형식 유추를 문자열로 강제합니다. Seq.filter 대신 Seq.where를 사용하여 몇 개의 문자를 저장합니다 (동의어 임). 문자를 최소화하기 위해 앞으로 파이프와 일반 기능 응용 프로그램을 혼합합니다. 커링 및 (op) 구문을 사용하여 <> ~-및 <|| 빈 문자열을 필터링하고 내림차순으로 정렬하고 튜플을 인쇄하도록 람다를 선언하지 않도록하는 연산자를 일반 함수로 사용하십시오.

파이썬-95 ( @primo 덕분에 87 )

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

개선 개선에 감사드립니다.

자바 스크립트 (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

자바 스크립트 (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_]

하스켈 (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은 영숫자가 아닌 것을 대체합니다
• ""vs 결과를 기호 목록으로 분할
• 각 그룹 수를 세어 목록의 고유 한 요소를 발생 수와 일치시키는 dict를 만듭니다.
• desc는 값을 내림차순으로 받아쓰기를 정렬합니다.

편집 : 실수로 일치하는 ASCII 58-64 및 91-96 수정

퓨어 배쉬 (외부 프로그램 없음), 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()))