एक पाठ में शब्दों को गिनें और उन्हें प्रदर्शित करें

Question

कोड को एक पाठ लेना चाहिए (जावास्क्रिप्ट, आदि के लिए अनिवार्य कुछ भी फ़ाइल, स्टडिन, स्ट्रिंग नहीं हो सकता है):

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-up2 क्रमशः 3 शब्दों में परिणाम होगा। मामला संवेदनशील होना चाहिए, Thisऔर thisदो अलग-अलग शब्द होंगे, 'इसलिए विभाजक भी होगा wouldnऔर tइससे 2 अलग शब्द होंगे wouldn't।

अपनी पसंद की भाषा में सबसे छोटा कोड लिखें।

अब तक का सबसे छोटा सही उत्तर:

• ग्रेप और कोरुटिल्स - 42 बाइट्स

Comments

क्या मामला मायने रखता है (यानी Thisजैसा है thisऔर जैसा है tHIs)?

— गारेथ

यदि कुछ भी गैर-अल्फ़ान्यूमेरिक एक विभाजक के रूप में गिना जाता है, तो wouldn't2 शब्द ( wouldnऔर t) है?

— गारेथ

@ गैरेथ मामला संवेदनशील होना चाहिए, Thisऔर thisवास्तव में दो अलग-अलग शब्द होंगे, समान wouldnऔर t।

— एडुआर्ड फ्लोरिंसकु

यदि 2 शब्द नहीं हैं, तो क्या यह "विल" और "एनटी" नहीं होना चाहिए, क्योंकि इसके लिए छोटा नहीं होगा, या यह कि ज्यादा ग्रामर नाज़ी-ईश है?

— त्यूं प्रैंक

@TeunPronk मैं इसे सरल रखने की कोशिश करता हूं, कुछ नियमों को रखने से व्याकरण के साथ अपवादों को बढ़ावा मिलेगा, और बहुत सारे अपवाद हैं। अंग्रेजी i.e.में एक शब्द है, लेकिन अगर हम डॉट को सभी बिंदुओं पर दें वाक्यांशों का अंत, उद्धरण या एकल उद्धरण, आदि के साथ लिया जाएगा

— एडुआर्ड फ्लोरिनेसस्कु

Answer 1

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

अद्यतन करें

• केस-असंवेदनशील विकल्प और छोटे रेगेक्स का उपयोग करें। धन्यवाद टॉमस।

Comments

नुथ की पुस्तक लिटरेट प्रोग्रामिंग के बारे में मैकलेरॉय की प्रतिक्रिया लगभग यही है । एकमात्र अंतर यह है कि इसमें headअंत में एक पाइप शामिल नहीं है ।

— AJMansfield

यह बहुत ज्यादा मेरा पहला विचार भी था।

— रॉब

काम नहीं करेगा?

— सिल्वेस्टर

41 वर्ण :grep -io \[A-Z0-9]*|sort|uniq -c|sort -nr

— टॉमस

@ टॉमस: इस जवाब के लिए जोड़ा, धन्यवाद। मैं तारांकन के लिए सुरक्षा में छोड़ दिया, क्योंकि यह कुछ गोले में फ़ाइल नाम का विस्तार कर रहा था।

— थोर

Answer 2

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

Ungolfed:

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.

Comments

बंटवारे के लिए गलत rexx। यह होना चाहिए"[^\\W_]"

— n shouldh̷͉̃a̷̭̿h bed

@ n @h methoda̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳, String.split(String regex)पद्धति एक ऐसा पैटर्न लेती है जो सीमांकक से विभाजित होने पर मेल खाता है । इसलिए, उदाहरण के लिए, "aababba".split("b")सरणी का उत्पादन होगा {"aa", "a", "", "a"}। मेरे रेगेक्स का [^\\w\\d]अर्थ है 'चरित्र में न तो वर्ण चरित्र और न ही अंक वर्ण वर्ग'। [^\\W_]इसके बजाय 'एक ऐसा चरित्र है जो न तो अंडरस्कोर है और न ही गैर-शब्द-वर्ण वर्ग में है' और अंडरस्कोर को छोड़कर किसी भी शब्द के चरित्र से मेल खाएगा।

— AJMansfield

क्षमा करें, मेरी पिछली टिप्पणी गलत थी। \wशामिल है \d, इसलिए \dबेमानी है। \wअंडरस्कोर शामिल है, जिसे प्रश्न के अनुसार एक विभाजक माना जाना चाहिए। तो बंटवारे के लिए सही रेगेक्स होना चाहिए "[\\W_]+"।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ 16

@ n @h thanksa̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ ठीक है, धन्यवाद; मैंने समस्या ठीक कर दी है।

— AJMansfield

Answer 3

एपीएल (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दिए गए सूचकांकों द्वारा लाइनों को फिर से व्यवस्थित करें

Comments

क्या ... द फ ..... .....

— ओज

यही कारण है कि मेरे पास बुरे सपने हैं।

— Thebluefish

@ Thebluefish: APL को एक नोटेशन से डिजाइन किया गया था, इस इरादे से कि मैथ्स की तरह, एक कॉनसेप्ट नोटेशन आपको स्पष्ट रूप से सोचने के लिए स्वतंत्र करता है। मैथ्स की तरह, जब आप पहली बार उस संकेतन को देखते हैं, तो आपको लगता है कि यह बिल्कुल भी स्पष्ट नहीं है, लेकिन भाषाएं हमेशा से शुरू होती हैं। यह आसान होगा यदि यह सब एक लाइन पर नहीं था, हालांकि ...

— फिल एच

एपीएल में आप जो भी आते हैं, मैं केवल कुछ यूनिकोड कचरा, दिशाओं में इंगित तीर और देवदार के पेड़ को उल्टा देखता हूं। यह J

— bebe

⎕s( Help.dyalog.com/latest/Content/Language/System%20Functions/… ) और नए प्रमुख ऑपरेटर ( help.dyalog.com/latest/Content/Language/jigative%20Operators/… ) के साथ कम हो सकता है :g⌷⍨⊂⍒2⌷⍉g←{⍺,≢⍵}⌸('\w+'⎕s'\0')⍞

— ngn

Answer 4

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

(LINQPad के माध्यम से "सी # स्टेटमेंट" मोड में, इनपुट स्ट्रिंग सहित नहीं)

संस्करण 1: 142 सी

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

Ungolfed:

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: 114 सी

( [\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();

Ungolfed:

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 के रूप में)

Comments

वैसे, संस्करण 2 के लिए, आपका अनगोल्डेड संस्करण आपके गोल्फ संस्करण से मेल नहीं खाता है। और जब से आप शाब्दिक स्ट्रिंग का उपयोग कर रहे हैं, आप लिख सकते हैं@"[^_\W]"

— ñ̷͉h̷̭̿a̸̡̅ẗ̵̨́h̷̰̀ĥ̷̳d are

@ n @h thea̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ - टाइपो को ठीक किया और 1-चर बचत के लिए अतिरिक्त `` को हटा दिया - धन्यवाद !!

— जंबोस्मैगे

Answer 5

आर, 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 

Comments

यह छोटा है (49 वर्ण) sort(table(gsub("[[:punct:]]","",scan(,""))),d=T)। दुर्भाग्य से दोनों समाधान के लिए सही ढंग से काम नहीं करता है wouldn't।

— djhurio

Answer 6

perl6: 49 अक्षर

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

सामान मिलान के लिए इनपुट मिलाएँ \w+, शब्दों की परिणामी सूची डालें Bag, उनके जोड़े माँगें और उन्हें ऋणात्मक मान के आधार पर छाँटें। ( *है एक जो कुछ भी स्टार, है ना गुणा है यहाँ)

उत्पादन:

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

Comments

पर्ल 6 मुझे डराता है।

— प्रिमो

हर बार जब मैं एक शांत भाषा की सुविधा के बारे में सोचता हूं, तो मैं इसे खोजता हूं और यह कहीं न कहीं पर्ल 6 में है। इसलिए यह लंबा समय ले रहा है ...

— फिल एच

आप :) के .wordsबजाय का उपयोग करके 6 वर्णों को ट्रिम कर सकते हैं.comb(/\w+/)

— Mouq

@Mouq: दुर्भाग्य से या इनपुट से आवश्यक के रूप में .wordsपट्टी नहीं करता है :(:.

— Ayiko

-1। _समस्या कथन के तहत एक शब्द में शामिल नहीं होना चाहिए।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Answer 7

अजगर 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)

अब newline के साथ काम करता है:

$ 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

Comments

यह तब काम नहीं करता है जब पाठ में एक से अधिक स्थान या एक से अधिक लगातार स्थान हों।

— klingt.net

@ klingt.net तय।

— डेनिएरो

Answer 8

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
)

Comments

यह कहता है कि इनपुट आप चाहते हैं। तो आप इसे कमांड लाइन पैरामीटर के रूप में उपयोग कर सकते हैं$argv[1]

— Einacio

@Einacio अच्छी कॉल।

— प्रिमो

-1। अंडरस्कोर _को एक शब्द में शामिल नहीं किया जाना चाहिए।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

@ n @h̴̖̋a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳ तय की।

— प्रिमो

Answer 9

पॉवरशेल (40)

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

$ s एक चर है जिसमें इनपुट स्ट्रिंग शामिल है।

Comments

[\W]यह काफी अच्छा नहीं है - यह मेरे परीक्षण में एक स्थान से मेल खा रहा है। और इसकी गिनती के आदेश के द्वारा नहीं किया गया है ...

— jimbobmcgee

$s -split"[\W]"|group -ca|where{$_.Name -ne ""}|sort{-$_.Count}आप (लागत के साथ, निश्चित रूप से) के करीब हो जाता है

— jimbobmcgee

ऊओप्स I छँटाई वाला भाग छूट गया। शीघ्र ही मेरे उत्तर को ठीक कर देंगे।

— माइक्रोबियन

वैकल्पिक रूप से:$s -split"\W+"|group -ca |sort count -des

— नसीमोटा

-split"\W+"स्ट्रिंग के अंतिम .और अंत के बीच एक खाली स्ट्रिंग मिलान कर रहा है ; यह भी \W+मेल खाता है _कि तकनीकी रूप से अनुमति नहीं है

— jimbobmcgee 1

Answer 10

पर्ल 69

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

@Primo और @protist से जोड़े गए सुझाव

Comments

छँटाई के बारे में क्या?

— डेनियरो

@daniero, उत्कृष्ट बिंदु! यह अब प्रकार!

— डोम हेस्टिंग्स

मुझे लगता है कि यह जितना हो सकता है उतना ही कठिन है। यदि आपको किसी डिप्रेशन की चेतावनी से ऐतराज नहीं है, तो बीच में geऔर जगह की आवश्यकता नहीं है for। इसके अलावा, <=>ऑपरेटर द्वारा प्रतिस्थापित किया जा सकता है -।

— प्राइमो

@primo अह्ह के -बजाय <=>प्रतिभा है, यकीन है कि पर्ल धागे के लिए गोल्फ युक्तियाँ पर नहीं है। मैं इसे बाद में अपडेट करूंगा, धन्यवाद!

— डोम हेस्टिंग्स

अरे @ प्रोटिस्ट, \wइसमें नंबर भी शामिल हैं ( perl -e 'print for"a 1 2 3 4 b"=~/\w/g'प्रिंट a1234b), लेकिन शब्दों को प्रसारित करने के लिए आपका तंत्र एक और चरित्र बचाता है इसलिए मैं अपडेट करूंगा। धन्यवाद!

— डोम हेस्टिंग्स

Answer 11

पॉवर्सशैल: 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 के लिए सहारा के साथ)

Answer 12

एक्मास्क्रिप्ट 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

Comments

आप बदल सकते हैं _[a]और _[b], _.aऔर _.b। इसके अलावा बदलने के /\w+/g,_={}लिए _=/\w+/gएक ही परिणाम का उत्पादन होगा।

— eithed

@eithedog धन्यवाद! हालाँकि, मैं इसे बदल नहीं _[a]सकता _.aक्योंकि यह संपत्ति "a"के उपयोग की कोशिश करता है, संपत्ति का _नहीं a।

— टूथब्रश

आह, सही - आदेश नहीं रखा जाएगा। पर ले जाएँ :)

— eithed

ओह, मैंने आपका जवाब नहीं देखा .. अच्छा। लेकिन .. Object.keysES6 में एक वैश्विक बन रहा है? आपका उत्तर यह मान सकता है, लेकिन मुझे यह याद नहीं है कि ES6 के लिए निर्धारित है।

— फायरफली

@ पूरी तरह से मुझे कोई दस्तावेज नहीं मिल रहा है, लेकिन यह फ़ायरफ़ॉक्स में ठीक काम करता है। मैंने इसे Chrome / Opera / IE में परीक्षण नहीं किया है।

— टूथब्रश

Answer 13

ग्रूवी 77 82

से regex बदल [^\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]

Comments

nu_berअल्फ़ान्यूमेरिक नहीं है। यह शूल 2 शब्द है

— क्रंचर

के nu_berबजाय का उपयोग क्यों करें number?

— केविन फ़गन

मुझे कुछ अन्य पोस्टों से गुमराह किया गया;) अब मैंने इनपुट से "_" हटा दिया, लेकिन इसे संभालने के लिए rexx तय किया

— कामिल मिकोलाज़िक

Answer 14

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साहचर्य सरणी के लिए डिफ़ॉल्ट सॉर्ट क्रम सेट करने के लिए थोड़ा बड़ा लेकिन शुद्ध गॉक् सॉल्यूशन का उपयोग करके (अपेक्षाकृत हाल ही के गॉव की आवश्यकता प्रतीत होती है -> 4.x?)

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

Comments

Oooooh। मैं PROCINFO के बारे में नहीं जानता था। जैसे कि मुझे अपने जीवन में जाग का उपयोग करने के लिए एक और बहाना चाहिए। तुम्हें श्राप लगे!

— dmckee

@dmckee TBH मैं जब तक मैं चारों ओर poking शुरू कर दिया PROCINFO के बारे में पता नहीं था - मैं वहाँ आश्वस्त था था ); - तरह मूल रूप से करने के लिए एक तरीका हो करने के लिए सिर्फ एक दया पहचानकर्ता इतने लंबे समय के हैं

— steeldriver

बुरे पुराने दिनों में बस एक रास्ता नहीं था। जिससे मेरा यह पुराना उत्तर जैसी चीजें सामने आती हैं ।

— dmckee

-1। अंडरस्कोर _को एक शब्द में शामिल नहीं किया जाना चाहिए।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Answer 15

जावास्क्रिप्ट - 132 126 वर्ण!

(सबसे छोटा जेएस कोड)

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

रेगेक्स और कुछ संपादन में सुधार हुआ।

---

Ungolfed

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 !

---

<= // मेक s = "यह दिन कितना चमकदार है यह नहीं है"

=> [[
How ’, ३],
[ , कैसे’, १], [’चमकदार’, १],
[’यह’, १],
[’दिन’, १],
[n इस् ’’, १] ,
['टी', १]]

---

पुराना - 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]})

---

गोल्फ में पहली कोशिश दी। प्रतिक्रिया की सराहना की।

Answer 16

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

इसे फ़ायरफ़ॉक्स में चलाएं।

Comments

आप की जरूरत नहीं है var । इसके अलावा, आप a={}अंदर स्थानांतरित कर सकते हैं prompt- prompt(a={})। तुम भी छोड़ सकते हैं Object.और परिवर्तन w=>a[w]=a[w]+1||1करने के लिएw=>a[w]=-~a[w]

— eithed

बहुत अच्छा। अब काम कर रहे पायथन को

— हरा देता है

@ टूथब्रश के उत्तर के लिए भी - aप्रांजल से रीजैक्सपी की घोषणा को आगे बढ़ाते हुए दो और वर्णों को छोड़ दिया जाएगा।

— eithed

यह अच्छा और साफ है। बहुत बढ़िया!

— टूथब्रश

-1। अंडरस्कोर _को एक शब्द में शामिल नहीं किया जाना चाहिए।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Answer 17

रूबी 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इसे पास करना डुप्लिकेट को फ़िल्टर नहीं करता है (यह नहीं कि यह कहता है कि हमें चाहिए)।}

Comments

शायद (अप्राप्त) के split(/\W+/)बजाय scan?

— हॉवर्ड

@ हावर्ड धन्यवाद। \Wको बाहर करता है _ताकि इसे ठीक किया जा सके, लेकिन इसने अभी भी 2 वर्णों को बचाया (तब मैंने उस छँटाई को ठीक करने के लिए 20 जोड़ा जिसमें मैंने उपेक्षा की थी)।

— डेनियरो

में हल नहीं किया जाना चाहिएreverse (a=gets.split(/[_\W]+/)).uniq.map{|w|[w,a.count(w)]}.sort_by(&:last).reverse.map{|x|p x}

— एडवर्ड Florinescu

@EduardFlorinescu नाह। reverseवैसे भी क्रिया है;) Btw, यह उचित नहीं है कि सवाल बदल जाए।

— डानिएरो

यदि आप आउटपुट नमूने में देखते हैं तो इसे केवल इस तरह से उतारा गया कि मैं इसे निर्दिष्ट करना भूल गया।

— एडुआर्ड फ्लोरिंसकु

Answer 18

एफ # - 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"))

उत्पादन जब एफएसआई से कहा जाता है:

> "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 को पास करने के लिए इनपुट में गैर अल्फ़ान्यूमेरिक वर्णों की एक सरणी उत्पन्न करने के लिए सेट फ़ंक्शंस का उपयोग करता है, फिर खाली स्ट्रिंग्स को फ़िल्टर करने, शब्द गणना उत्पन्न करने और परिणाम प्रिंट करने के लिए अनुक्रम फ़ंक्शंस का उपयोग करता है।

कुछ गोल्फिंग ट्रिक्स: फ़ंक्शन तर्क के लिए एक खाली स्ट्रिंग जोड़ता है तर्क के प्रकार को स्पष्ट रूप से घोषित करने के बजाय एक स्ट्रिंग के रूप में तर्क को मजबूर करने के लिए। कुछ वर्ण (वे समानार्थी हैं) को बचाने के लिए Seq.filter के बजाय Seq.where का उपयोग करता है। पात्रों को कम करने के प्रयास में आगे पाइप और साधारण फ़ंक्शन अनुप्रयोग को मिलाता है। इलाज के लिए करी और (ऑप) सिंटैक्स का उपयोग करता है <> ~ - और <|| संचालक नियमित कार्य के रूप में खाली स्ट्रिंग्स को फ़िल्टर करने के लिए लैम्बडा घोषित करने से बचने के लिए, गिनती और प्रिंट ट्यूपल्स को छांटते हैं।

Comments

आपको किसी प्रकार का स्पष्टीकरण निश्चित रूप से सम्मिलित करना चाहिए; इस तरह हम आपके कोड को समझ सकते हैं।

— जस्टिन

एक नीच संस्करण और कुछ स्पष्टीकरण जोड़ा गया।

— 5

Answer 19

पायथन - 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)]

किसी भी सुधार sugestion की सराहना की जाएगी

Comments

समाधान अच्छा है लेकिन उत्पादन हल नहीं है।

— एडुआर्ड फ्लोरिंसकु

छांटे से आपका क्या मतलब है? टिप्पणी के लिए धन्यवाद।

— एज़रॉ

\wमेल खाता है [a-zA-Z0-9_]। आपके पूरे रेगेक्स को प्रतिस्थापित किया जा सकता है r'\w+'। इसके अलावा, xचर की जरूरत नहीं है, बस raw_input()दूसरे पैरामीटर के रूप में उपयोग करें findall।

— प्राइमो

क्रमबद्ध करके, ओपी का अर्थ है कि जो शब्द सबसे अधिक बार दिखाई देते हैं उन्हें पहले सूचीबद्ध करने की आवश्यकता होती है। इसके अलावा, आपके कार्यक्रम में एक printबयान (यानी print map(...) शामिल होना चाहिए , अन्यथा यह एक पूर्ण कार्यक्रम नहीं है।

— प्राइमो

मेरे पास अभी इसे छांटने का समय नहीं है :( मैं जल्दबाज़ी में हूँ, सुझाव और टिप्पणियों के लिए धन्यवाद।

— अज़रॉ जने

Answer 20

जावास्क्रिप्ट 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])'))

unminified:

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

Comments

क्रमांक संख्या के अनुसार होना चाहिए। की घटनाओं youको पहले होना चाहिए।

— एडुआर्ड फ्लोरिनेसस्कु

@EduardFlorinescu मूर्खतापूर्ण ... मैं इसे बाद में ठीक करूँगा।

— जॉर्ज रीथ

@EduardFlorinescu तय

— जॉर्ज रीथ

-1। अंडरस्कोर _को एक शब्द में शामिल नहीं किया जाना चाहिए।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

++o[a]||1=>-~o[a]

— l4m2

Answer 21

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

Answer 22

जावास्क्रिप्ट (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)

unminified:

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

Answer 23

हास्केल (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)]

Answer 24

q (50)

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

• ssr नॉन अल्फ़ान्यूमेरिक की जगह लेता है
• "" बनाम परिणाम को एक प्रतीक सूची में विभाजित करता है
• गिनें कि प्रत्येक समूह मायने रखता है सूची की संख्या के साथ एक तानाशाह मिलान अलग तत्व बनाता है
• अवरोही मानों को अवरोही प्रकार से हटाता है

संपादित करें: गलती से मेल खाते हुए एएससीआई 58-64 और 91-96

Comments

मुझे कोई ज्ञान नहीं है, qलेकिन regex [0-z]ASCII- आधारित है? यदि ऐसा है, तो क्या यह ASCII के चार्ट में 58-64 भी शामिल नहीं होगा? क्योंकि वे हैं : ; < = > ? @।

— १२:०२ पर jimbobmcgee

ग्रेट कैच

— जंबो

आपका स्वागत है; केवल देखा क्योंकि मुझे C # में समान पाया गया। अफसोस की बात है, [A-z]जो ASCII 91-96 से मेल खाता है, जो `[\] ^

— _`

आह ठीक है तुम हो, वहाँ अच्छा सा ascii सबक!

— रात के पहर

मैंने सिर्फ [^_\W]+मेरा खोजा , जो "गैर-शब्द वर्णों और अंडरस्कोर को बाहर करना " होना चाहिए , अगर आपका सिंटैक्स \Wकक्षा का समर्थन करता है ...

— jimbobmcgee 23

Answer 25

शुद्ध बैश (कोई बाहरी कार्यक्रम नहीं), 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।
एक: 2
और 1
संख्या 1
पाठ: 1
31: 1
: 1
यह: 1
$ 

Answer 26

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

यदि मुद्रण "गणना: शब्द" के बजाय, यह थोड़ा छोटा होगा लेकिन मैं दिए गए उदाहरण आउटपुट की नकल करना चाहता था ...

Answer 27

Tcl , 99 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 28

अजगर 2.X (108 - वर्ण)

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

अजगर 3.X (106 - वर्ण)

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

Comments

Separators will be anything that is not alpha-numeric- आप केवल व्हाट्सएप पर विभाजित हैं।

— डानिएरो

Answer 29

हास्केल - 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

Comments

इस शर्त को पूरा नहीं करता है कि गैर-अल्फ़ान्यूमेरिक विभाजक होना चाहिए।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Answer 30

पायथन 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())एक निश्चित रूप से क्रमबद्ध ट्यूपल्स की सूची के रूप में परिणाम लौटाएगा ।

---

पायथन 3 - 57 (यदि विभाजन के लिए एक स्थान पर्याप्त होगा: P)

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

Comments

यदि आपने मान लिया है कि स्ट्रिंग कुछ चर s में है, जैसा कि कुछ अन्य उत्तर करते हैं, तो आप इनपुट () को बदलकर 6 वर्ण खो सकते हैं।

— फिल एच

@PHH कु। आप सही हैं, लेकिन मैं आवश्यकताओं के बाहर कभी नहीं पढ़ूंगा। सुनिश्चित करें कि "स्ट्रिंग फॉर जावास्क्रिप्ट" -पार्ट इसे सुझा सकती है, लेकिन मैं स्पष्ट विवेक के साथ, एक स्ट्रिंग "वैरिएबल" की वैध "इनपुट" के रूप में व्याख्या नहीं कर सकता। लेकिन आप सही हैं। वह इसे और भी छोटा कर देगा। : पी

— डेव जे

-1। अंडरस्कोर _को एक शब्द में शामिल नहीं किया जाना चाहिए।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

वैसे यह अल्फा-न्यूमेरिक की परिभाषा पर निर्भर करता है। पायथन में, "\ w" को अल्फा-न्यूमेरिक वर्णों को स्वीकार करने के लिए परिभाषित किया गया है। आप सही हो सकते हैं लेकिन नियमों की इस तरह की व्याख्या के साथ, मेरा समाधान सही है। :)

— डेव जे