इनपुट स्ट्रिंग में प्रत्येक वर्ण के लिए घटनाओं की संख्या प्रदर्शित करें

Question

कोड को कीबोर्ड से इनपुट के रूप में एक स्ट्रिंग लेनी चाहिए:

The definition of insanity is quoting the same phrase again and again and not expect despair.

आउटपुट इस तरह होना चाहिए (किसी विशेष क्रम में क्रमबद्ध नहीं):

  :  15
. :  1
T :  1
a :  10
c :  1
e :  8
d :  4
g :  3
f :  2
i :  10
h :  3
m :  1
o :  4
n :  10
q :  1
p :  3
s :  5
r :  2
u :  1
t :  6
y :  1
x :  1

सभी ASCII वर्ण यूनिकोड की आवश्यकता नहीं है, रिक्त स्थान, उद्धरण, आदि और इनपुट कीबोर्ड से आना चाहिए / स्थिरांक नहीं, विशेषताएँ, आउटपुट को प्रत्येक पंक्ति के बाद नई पंक्ति के साथ मुद्रित किया जाना चाहिए जैसे कि उपरोक्त उदाहरण में, इसे स्ट्रिंग के रूप में नहीं लौटाया जाना चाहिए। या के रूप में hashmap / शब्दकोश आदि फेंक दिया है, तो x : 1और x: 1ठीक हैं, लेकिन {'x':1,...और x:1नहीं कर रहे हैं।

प्रश्न: स्टड लेने और स्टडआउट लिखने का कार्य या पूरा कार्यक्रम?
ए: कोड को मानक का उपयोग करके इनपुट लेने वाला प्रोग्राम होना चाहिए और मानक आउट के माध्यम से परिणाम प्रदर्शित करना चाहिए।

स्कोरबोर्ड:

सबसे छोटा समग्र : 5 बाइट्स

सबसे छोटा समग्र : 7 बाइट्स

Comments

सभी ascii वर्ण इनपुट के रूप में? या सिर्फ मुद्रण योग्य? या यूनिकोड तक? क्या नए सिरे से होंगे?

— जस्टिन

क्या मैं एक फ़ंक्शन बना सकता हूं, या एक पूरा कार्यक्रम आवश्यक है? क्या मैं सभी आस्की पात्रों का उत्पादन कर सकता हूं और 0घटनाओं की संख्या के रूप में प्रिंट कर सकता हूं ?

— जस्टिन

क्या आउटपुट स्वरूप सख्त है, या यह अर्थ को संरक्षित करने के लिए पर्याप्त है?

— जॉन ड्वोरक

आपके संपादन ने मेरे प्रश्न का समाधान नहीं किया।

— जस्टिन

यदि आउटपुट को वर्णानुक्रम में क्रमबद्ध करने की आवश्यकता है तो आपने नहीं कहा। यदि विभाजक होने की आवश्यकता है, तो आपने यह नहीं कहा " : "(दो रिक्त स्थान नोट करने के बाद :) या यदि अन्य (कम) सेपरेटर ठीक हैं। आपने यूनिकोड / एन्कोडिंग समस्या को संबोधित नहीं किया।

— कोडइन्चोस

Answer 1

एपीएल (Dyalog यूनिकोड) , 5 बाइट्स ^SBCS

पूर्ण कार्यक्रम निकाय। एसटीडीआईएन से एक स्ट्रिंग के लिए संकेत और एसटीडीयूएसटी के लिए अलग-अलग तालिका को प्रिंट करता है। बायाँ स्तंभ सबसे बड़ा इनपुट वर्ण है, और मायने रखता है सही-संरेखित सबसे बड़ी संख्या के साथ एक ही स्थान से अपने चरित्र से अलग कर दिया।

,∘≢⌸⍞

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

⍞ STDIN से पाठ इनपुट के लिए संकेत

⌸ एक कुंजी 'बनाने से मिलकर तालिका
 , अद्वितीय तत्व पीछा
 ∘ द्वारा
 ≢ अपने घटना के सूचकांकों की संख्या (यानी कितनी बार यह होता है)

Comments

ऐसा लगता है कि :दुर्भाग्य से आउटपुट में आवश्यक है (आप इस उत्तर को हटा नहीं सकते हैं)।

— आउटगोल्फर

@EriktheOutgolfer आप कैसे घटा सकते हैं? स्पष्ट रूप से ओपी को यह उत्तर स्वीकार्य लगा, एक पुरानी टिप्पणी के अनुसार ।

— आदम

सवाल में ही कल्पना के लिए एक और कारण ...

— एरिक आउटगोल्फर

Answer 2

PHP - 68 (या 39) बाइट्स

<?foreach(count_chars(fgets(STDIN),1)as$k=>$v)echo chr($k)." : $v
";

उदाहरण पाठ के लिए आउटपुट:

  : 15
. : 1
T : 1
a : 10
c : 1
d : 4
e : 8
f : 2
g : 3
h : 3
i : 10
m : 1
n : 10
o : 4
p : 3
q : 1
r : 2
s : 5
t : 6
u : 1
x : 1
y : 1

यदि सटीक आउटपुट की आवश्यकता नहीं है, तो यह 39 बाइट्स के लिए काम करेगा :

<?print_r(count_chars(fgets(STDIN),1));

नमूना उत्पादन:

Array
(
    [32] => 15
    [46] => 1
    [84] => 1
    [97] => 10
    [99] => 1
    [100] => 4
    [101] => 8
    [102] => 2
    [103] => 3
    [104] => 3
    [105] => 10
    [109] => 1
    [110] => 10
    [111] => 4
    [112] => 3
    [113] => 1
    [114] => 2
    [115] => 5
    [116] => 6
    [117] => 1
    [120] => 1
    [121] => 1
)

जहां प्रत्येक संख्यात्मक सूचकांक उस चरित्र के क्रमिक मूल्य को दर्शाता है जो उसका प्रतिनिधित्व करता है।

मुझे बहुत दृढ़ता से संदेह है कि एक इन-बिल्ट फ़ंक्शन का उपयोग करना जो वास्तव में समस्या राज्यों को ठीक करता है।

Comments

$argv[1]के बजाय fgets(STDIN)4 बाइट बचाता है।

— टाइटस

Answer 3

k ( 7 8 )

#:'=0:0

उदाहरण

k)#:'=:0:0
The definition of insanity is quoting the same phrase again and again and not expect despair.
T| 1
h| 3
e| 8
 | 15
d| 4
f| 2
i| 10
n| 10
t| 6
o| 4
s| 5
a| 10
y| 1
q| 1
u| 1
g| 3
m| 1
p| 3
r| 2
x| 1
c| 1
.| 1

संपादित करें: डाउन टू सात, एच / टी आरोन डेविस

व्याख्या

कीबोर्ड से स्ट्रिंग लें:

k)0:0
text
"text"

अलग-अलग तत्वों को समूहित करें और एक नक्शे को दें जिसमें अलग-अलग अक्षर और मान हों, ऐसे सूचकांक हैं जहां अलग-अलग तत्व होते हैं।

k)=0:0
text
t| 0 3
e| ,1
x| ,2

अब मानचित्र में प्रत्येक प्रविष्टि के मानों की गणना करें।

k)#:'=0:0
text
t| 2
e| 1
x| 1

Comments

बहुत अविश्वसनीय है।

— प्यूरफेरेट

:में =:ज़रूरत से ज़्यादा है, k)#:'=0:0ठीक काम करता है (7 वर्ण)। (के बारे में जानने के लिए बोनस 0:0, मुझे पता नहीं था!)

— हारून डेविस

एक विस्तृत विवरण वास्तव में अच्छा होगा :)

— तिमवी

qअनुवाद को समझना आसान है -count each group read0 0

— कंकाल

Answer 4

GNU कोर के बर्तन - 29 22 20 वर्ण (स्वरूपण के साथ 53)

वम्पस का सुधार (20 वर्ण):

fold -1|sort|uniq -c

जुगनू का सुधार (22 वर्ण):

grep -o .|sort|uniq -c

joeytwiddle की मूल (29 वर्ण):

sed 's+.+\0\n+g'|sort|uniq -c

मूल रूप से मैंने इस्तेमाल किया sed प्रत्येक वर्ण के बाद बस एक नई पंक्ति जोड़ता था। जुगनू ने उस पर सुधार किया grep -o ., क्योंकि -oप्रत्येक मिलान पैटर्न को अपनी लाइन पर प्रदर्शित करता है। वम्पस ने fold -1इसके बजाय एक और सुधार की ओर इशारा किया। अच्छा काम!

uniq असली काम करता है, हालांकि यह केवल क्रमबद्ध सूचियों पर लागू होता है।

ध्यान दें कि आउटपुट प्रारूप प्रश्न में उदाहरण से बिल्कुल मेल नहीं खाता है। sedतर्कों की अदला-बदली के लिए एक अंतिम रन की आवश्यकता होती है । (यह देखने के लिए जन द्वारका के सवाल के जवाब का इंतजार है कि क्या यह आवश्यक है ...)

Sed के साथ रिफॉर्मेटिंग "केवल" एक और 33 अक्षर है! ( कुल अंक )

|sed 's/ *\(.*\) \(.\)/\2 :  \1/'

केवल 25 वर्णों को जोड़ते हुए, Awk लगभग काम कर सकता है , लेकिन यह पहला स्थान छुपाता है। सिली जाग!

|awk '{print $2" :  "$1}'

मुझे आश्चर्य है कि सुधार मंच में सुधार किया जा सकता है ...

Comments

सीड के लिए आप &इसके बजाय "पूरे मैच" के लिए उपयोग कर सकते हैं \0, हालांकि grep -o .अभी तक थोड़ा कम है। यह ध्यान देने योग्य है कि uniq -cप्रश्न में दिए गए से थोड़ा भिन्न होता है।

— FireFly

ओह थैंक यू! अपडेट किया गया। मुझे नहीं भूलना चाहिए grep -o; यह एक उपयोगी है।

— joeytwiddle

fold -1के रूप में एक ही बात करता हैgrep -o .

बहुत बढ़िया :) नई चाल सीखना!

— joeytwiddle

ptx -S.एक ही चाल है ।

— प्यूरफेरेट

Answer 5

रूबी 1.9.3: 53 अक्षर

(@ शिवा और @ डेनेरो की टिप्पणियों पर आधारित)

gets.split("").uniq.map{|x|puts x+" : #{$_.count x}"}

नमूना रन:

bash-4.1$ ruby -e 'a=gets;a.split("").uniq.map{|x|puts"#{x} : #{a.count x}"}' <<< 'Hello world'
H : 1
e : 1
l : 3
o : 2
  : 1
w : 1
r : 1
d : 1

 : 1

रूबी: 44 अक्षर

आउटपुट स्वरूप का सम्मान नहीं:

s=Hash.new 0;gets.chars{|c|s[c]+=1};pp s

नमूना रन:

bash-4.1$ ruby -rpp -e 's=Hash.new 0;gets.chars{|c|s[c]+=1};pp s' <<< 'Hello, world!'
{"H"=>1,
 "e"=>1,
 "l"=>3,
 "o"=>2,
 ","=>1,
 " "=>1,
 "w"=>1,
 "r"=>1,
 "d"=>1,
 "!"=>1,
 "\n"=>1}

Comments

63 वर्णa=gets.strip;a.split('').uniq.each{|x|puts"#{x} : #{a.count(x)}"}

— शिव

क्यों strip()? प्रश्न कहता है, "सभी वर्णों की गणना"।

— मैनटवर्क

ठीक है, \nभले ही आप न लौटें

— शिव

नहीं। केवल तभी लौटाता है \nजब यह वास्तव में पारित किया गया था। इसे पास करना यहां स्ट्रिंग का उपयोग करने का एक साइड-इफेक्ट है। pastebin.com/gCrgk9m1

— मैनटवर्क

हालांकि अभी भी साउंड का इस्तेमाल करना $_और खोदना aहै। और c+"...इसके बजाय"#{c}...

— daniero

Answer 6

पायथन 3: 76 वर्ण

76

import collections as c
for x,y in c.Counter(input()).items():print(x,':',y)

44

(एक ही अक्षर को कई बार छापें, वैध संस्करण के लिए वसी का जवाब देखें )

a=input()
for x in a:print(x,':',a.count(x))

Comments

45 चार संस्करण एक से अधिक बार वर्ण प्रिंट करते हैं।

— ugoren

ठीक है ... ध्यान देने योग्य है!

— ईव्यू

@evuez मैंने अभी आपके 45 चार संस्करण तय किए हैं। लेकिन, आपने इसे हटा दिया है इसलिए मैंने इसे एक बार फिर प्रस्तुत किया है। एक है देखो

— Wasi

Answer 7

पर्ल 6: 21 वर्ण

.say for get.comb.Bag

(आरईपीएल)
> .say for get.comb.Bag
पागलपन की परिभाषा एक ही वाक्यांश को बार-बार उद्धृत करना और निराशा की उम्मीद नहीं करना है।
"टी" => 1
"ह" => ३
"ई" => 8
"" => 15
"डी" => 4
"च" => २
"मैं" => 10
"एन" => 10
"t" => 6
"ओ" => 4
"s" => 5
"ए" => 10
"य" => 1
"क्ष" => १
"यू" => 1
"जी" => 3
"म" => १
"पी" => 3
"आर" => 2
"x" => 1
"ग" => 1
"।" => १

Answer 8

एपीएल (15)

M,⍪+⌿Z∘.=M←∪Z←⍞

यदि आपको वास्तव में इसकी आवश्यकता है :, तो यह 19 है (लेकिन इसमें अन्य लोग भी शामिल हैं, जो इसमें शामिल नहीं हैं):

M,':',⍪+⌿Z∘.=M←∪Z←⍞

आउटपुट:

      M,⍪+⌿Z∘.=M←∪Z←⍞
The definition of insanity is quoting the same phrase again and again and not expect despair. 
T  1
h  3
e  8
  16
d  4
f  2
i 10
n 10
t  6
o  4
s  5
a 10
y  1
q  1
u  1
g  3
m  1
p  3
r  2
x  1
c  1
.  1

Comments

अर्ध-गंभीर प्रश्न - यह विरासत एपीएल कोड को बनाए रखने की तरह क्या है?

— माइकल स्टर्न

@ मिचेल स्टर्न: कोई बात नहीं, मुझे कभी ऐसा नहीं करना पड़ा। लेकिन मुझे लगता है कि यह अन्य विरासत कोड को बनाए रखने से बदतर नहीं है। एपीएल वास्तव में पढ़ने के लिए काफी आसान है एक बार जब आप इसके लिए उपयोग किए जाते हैं।

— मारिनस

Answer 9

आर, 30 वर्ण

table(strsplit(readline(),""))

उदाहरण का उपयोग:

> table(strsplit(readline(),""))
The definition of insanity is quoting the same phrase again and again and not expect despair.

    .  a  c  d  e  f  g  h  i  m  n  o  p  q  r  s  t  T  u  x  y 
15  1 10  1  4  8  2  3  3 10  1 10  4  3  1  2  5  6  1  1  1  1 

Comments

अच्छा विचार! लेकिन सवाल यह है कि कोड को परिणाम प्रिंट करना होगा। आपका कोड सिर्फ परिणाम देता है। मुझे लगता है कि आप की जरूरत cat।

— स्वेन होनस्टीन

@SvenHohenstein अच्छी तरह से यह निर्दिष्ट नहीं किया गया था जब मैंने उत्तर दिया था (मैं प्रश्न के संशोधन 4 से पहले उत्तर दिया गया था) ... लेकिन तथ्य की बात के रूप में catकेवल मान नाम (अर्थात वर्ण) नहीं मानों को वापस कर देंगे। इसलिए इसे और अधिक जटिल समाधान की आवश्यकता होगी।

— प्लेनैपस

Answer 10

पर्ल 5, 54 वर्ण

map{$h{$_}++}split//,<>;print"$_ : $h{$_}\n"for keys%h

Comments

बहुत अच्छा समाधान, पढ़ने में आसान। sort keys%hहालांकि यह होना चाहिए ।

— प्रिमो

अरे @ मालकिन, अच्छा लग रहा है! मैं हालांकि @primo से सहमत हूँ! हालाँकि आप दो चार्टों का उपयोग करके $_=<>;s/./$h{$_}++/eg;या map{$h{$_}++}<>=~/./g;इसके बजाय बचा सकते हैंmap{$h{$_}++}split//,<>;

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

@DomHastings या $h{$_}++for<>=~/./g, जो मुझे लगता है कि इष्टतम हो सकता है। \nसाथ ही इसके बजाय शाब्दिक नई रूपरेखा ।

— प्राइमो

आह अच्छा, और भी अच्छा! हां, मैं शाब्दिक न्यूलाइन का उल्लेख करना भूल गया, यह मेरी नई पसंदीदा -1 बाइट बन गई है!

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

Answer 11

जावास्क्रिप्ट

1. 66 53 बाइट्स:

   prompt(a={}).replace(/./g,function(c){a[c]=-~a[c]}),a
   

2. 69 56 बाइट्स:

   b=prompt(a={});for(i=b.length;i--;){a[b[i]]=-~a[b[i]]};a
   

3. 78 65 बाइट्स:

   prompt().split('').reduce(function(a,b){return a[b]=-~a[b],a},{})
   

NB: सभी मामलों में हटाई गई बाइट्स की संख्या अतिरिक्त console.log()कॉल को संदर्भित करती है जो कंसोल में चलने पर व्यर्थ है। के साथ और महान कैच के लिए @imma को बड़ा धन्यवाद । यह निश्चित रूप से कुछ और बाइट्स को बचाता है।-~a[b]prompt(a={})

Comments

लूप के बजाय नक्शा थोड़ा भी मदद करता है ([[बी [आई]] || ०) +1 को घटाया जा सकता है - ~ [ए [बी [आई]] और कंसोल.लॉग शायद जा सकते हैं, बस अंतिम मूल्य लौटा सकते हैं। शीघ्र (a = {}) देने वाला। विभाजन ("")। नक्शा (कार्य (c) {a [c] = - ~ [a c]});

— ama im

आप बदल सकते हैं forमें for in- खाली टैब में परीक्षण एक ही परिणाम पैदा करता है। इसके अलावा, पिछले ;की जरूरत है नहीं, इस प्रकार:b=prompt(a={});for(i in b){a[b[i]]=-~a[b[i]]}a

— eithed

अच्छा :-) छड़ी के लिए बी = ... के लिए और एक के लिए {} के लिए स्वैप; एक और 2 बाइट्स के लिए: (i in b = prompt (a = {})) एक [b [i] = = - ~ [a [b [i]];

— ama im

हालाँकि वे सटीक टेक्स्ट आउटपुट चाहते हैं: - / जो इसे 36 / (79 से) वापस बाइट्स में डालता है: के लिए (i में b = प्रॉम्प्ट (a = {})) [b [i]] = - ~ a [b [i]]; (n a) कंसोल.लॉग (n + ":" + a [n]) के लिए

— imma

@VisioN केवल अगर आदिम अतिभारित हैं - for inवास्तव में आपको SO में फ़ंक्शंस देता है, लेकिन खाली

— पैनल

Answer 12

अजगर 2, सही ढंग से (58)

s=raw_input()
for l in set(s):print l+" : "+str(s.count(l))

आउटपुट:

python count.py
The definition of insanity is quoting the same phrase again and again and not expect despair.
  : 15
. : 1
T : 1
a : 10
c : 1
e : 8
d : 4
g : 3
f : 2
i : 10
h : 3
m : 1
o : 4
n : 10
q : 1
p : 3
s : 5
r : 2
u : 1
t : 6
y : 1
x : 1

अजगर 2, चीता शैली (41)

s=input()
print {l:s.count(l) for l in s}

आउटपुट:

python count.py
"The definition of insanity is quoting the same phrase again and again and not expect despair."
{' ': 15, '.': 1, 'T': 1, 'a': 10, 'c': 1, 'e': 8, 'd': 4, 'g': 3, 'f': 2, 'i': 10, 'h': 3, 'm': 1, 'o': 4, 'n': 10, 'q': 1, 'p': 3, 's': 5, 'r': 2, 'u': 1, 't': 6, 'y': 1, 'x': 1}

Comments

दूसरे एक में प्रिंट के बाद कोष्ठक को निकालना भूल गया, जिससे यह 41 हो गया

— तूनअल्प्रिंक

आप अपने पहले संस्करण के साथ 52 चार्ट तक नीचे जा सकते हैं for l in set(s):print l,":",s.count(l):। दूसरे के लिए, अनावश्यक रिक्त स्थान को हटाकर आप 2 print{l:s.count(l)for l in s}

— चार्ट

Answer 13

गणितज्ञ, 61 बाइट्स

Map[{#[[1]], Length@#} &, Gather@Characters[Input[]]] // TableForm

यह इस संवाद बॉक्स को पॉप अप करता है,

और नमूना वाक्य के लिए, आउटपुट के रूप में उत्पन्न होता है

Answer 14

अजगर 3, 49

Evuez से चोरी विचार

t=input()
for i in set(t):print(i,':',t.count(i))

इनपुट:

The definition of insanity is quoting the same phrase again and again and not expect despair.

उत्पादन:

  :  15
. :  1
T :  1
a :  10
c :  1
e :  8
d :  4
g :  3
f :  2
i :  10
h :  3
m :  1
o :  4
n :  10
q :  1
p :  3
s :  5
r :  2
u :  1
t :  6
y :  1
x :  1

Comments

अच्छा सुधार! आप सॉर्ट किए गए () को क्यों नहीं निकालते?

— 25

सही! वैसे भी, यदि आप एक सूची समझ का उपयोग नहीं करते हैं, तो यह 1 char कम है:for i in sorted(set(t)):print(i,':',t.count(i))

— evuez

@evuez धन्यवाद, मुझे इसे आपके कोड में एक टिप्पणी के रूप में जोड़ना चाहिए था। यदि आप चाहें तो इसे अपने समाधान में फिर से जोड़ सकते हैं (मैं ख़ुशी से इसे हटा दूंगा): डी

— वासी

उचित नहीं होगा, मैंने सोचा नहीं था set()! ;)

— 16

Answer 15

जावास्क्रिप्ट (69 68 अक्षर):

sस्ट्रिंग धारण करने की अपेक्षा करता है।

_={};for(x in s)_[a=s[x]]=-~_[a];for(x in _)console.log(x+': '+_[x])

यह नए नियमों का पूरी तरह से पालन करता है।

नोट: यह किसी भी मानक वस्तु प्रोटोटाइप पर कोई कस्टम गुण के साथ, एक स्वच्छ वातावरण मानता है।

संपादित करें: 1 वर्ण कम!

कंसोल आउटपुट:

T: 1
h: 3
e: 8
 : 15
d: 4
f: 2
i: 10
n: 10
t: 6
o: 4
s: 5
a: 10
y: 1
q: 1
u: 1
g: 3
m: 1
p: 3
r: 2
x: 1
c: 1
.: 1

---

पुराना उत्तर (44 अक्षर):

r={};[].map.call(s,function(e){r[e]=-~r[e]})

नियम बदलने से पहले यह मान्य था।

r इसमें आउटपुट होता है।

Answer 16

हास्केल, 93

import Data.List
main=getLine>>=mapM(\s->putStrLn$[head s]++" : "++show(length s)).group.sort

Answer 17

पॉवरशेल (49)

[char[]](read-host)|group|%{$_.Name+":"+$_.Count}

Answer 18

C # (178 220 वर्ण)

@ स्पोंजमैन की टिप्पणी के आधार पर मैंने इसे थोड़ा बदल दिया:

using C=System.Console;using System.Linq;class P{static void Main()
{C.WriteLine(string.Join("\n",C.ReadLine().GroupBy(x=>x)
.OrderBy(x=>x.Key).Select(g=>g.Key+":"+g.Count())));}}

---

Line breaks added for readability, my first feeble attempt at code golf! :)

class P {static void Main(){var d=new Dictionary<char,int>();
Console.ReadLine().ToList().ForEach(x=>{ if(d.ContainsKey(x))
{d[x]++;}else{d.Add(x,1);}});Console.WriteLine(string
.Join("\n",d.Keys.Select(x=>x+":" +d[x])));}}

Comments

संकलन नहीं है। यह एक करता है: 178 वर्ण System.Linq का उपयोग करके C = System.Console; वर्ग F {स्टेटिक शून्य मेन () {C.WriteLine (string.Join ("\ n", C.ReadLine) () का उपयोग करें। GroupBy (c = c) .Select () g => g.Key + ":" + g.Count ())। OrderBy (s =>)));)}}

— Spongman

168: C = System.Console का उपयोग करते हुए; System.Linq; class F {static void Main () {foreach (C.ReadLine में var g।) (GroupBy (c => c) .OrderBy (g => g.Key)। )) C.WriteLine (g.Key + ":" + g.Count ());}}

— स्पॉन्जमैन

जाहिरा तौर पर छँटाई अनावश्यक है, 150: C = System.Console का उपयोग करके। System.Linq; क्लास F {स्टेटिक शून्य मेन () {foreach (C.ReadLine में var g।) (GroupBy (c = c)) C.WriteLine। (g.Key + ":" + g.Count ());}}

— स्पॉन्जमैन

वाह। त्वरित या संयोग? आपने अपना उत्तर अपडेट करने के बाद बस एक सेकंड का उत्तर दिया: D बस देखा कि छँटाई का स्पष्ट उल्लेख नहीं किया गया था!

— गिदोन

148: namespace System{using Linq;class F{static void Main(){foreach(var g in Console.ReadLine().GroupBy(c=>c))Console.WriteLine(g.Key+" : "+g.Count());}}

— तिमवी

Answer 19

स्किलिंग , 19 वर्ण

梴要⓶銻꾠⓷❸虛變梴❶⓺減負겠⓸⓸終丟

उत्पादन

T:1
h:3
e:8
 :15
d:4
f:2
i:10
n:10
t:6
o:4
s:5
a:10
y:1
q:1
u:1
g:3
m:1
p:3
r:2
x:1
c:1
.:1

आप के आसपास रिक्त स्थान चाहते हैं :, परिवर्तन 꾠करने के लिए 긃똠, यह 20 वर्ण बना रही है।

व्याख्या

Get length of input string.
梴
Stack is now [ input, length ]
While {
要
    Get first character of string and push ":"
    ⓶銻꾠
    Stack is now [ length, input, firstchar, ":" ]
    Replace all occurrences of that character with empty string
    ⓷❸虛變
    Stack is now [ length, firstchar, ":", reducedinput ]
    Get the length of that, calculate difference to previous length, push "\n"
    梴❶⓺減負겠
    Stack is now [ firstchar, ":", reducedinput, newlength, diff, "\n" ]
    Move the input string and length back up, leaving output below it
    ⓸⓸
    Stack is now [ firstchar, ":", diff, "\n", reducedinput, newlength ]
                   `------------------------'                `-------'
                   Every iteration of the               The length provides
                   While loop generates                 the While loop's
                   a bit like this                      terminating condition
} End While
終
Discard the length which is now 0
丟

Answer 20

एफ # ( 66 59 49, 72 निर्धारित प्रारूपण के साथ)

let f s=s|>Seq.countBy(id)|>Seq.iter(printfn"%A")

आउटपुट:

> f The definition of insanity is quoting the same phrase again and again and not expect despair.
(' ', 15)
('.', 1)
('T', 1)
('a', 10)
('c', 1)
('d', 4)
('e', 8)
('f', 2)
('g', 3)
('h', 3)
('i', 10)
('m', 1)
('n', 10)
('o', 4)
('p', 3)
('q', 1)
('r', 2)
('s', 5)
('t', 6)
('u', 1)
('x', 1)
('y', 1)

निर्धारित प्रारूपण के साथ, यह बन जाता है:

let f s=s|>Seq.countBy(id)|>Seq.iter(fun(a,b)->printfn"\"%c\" :  %d"a b)

Comments

कुछ फंक्शन कॉल्स के लिए आप पाइप के सिंटैक्स से दूर जा कर किसी पात्र को छोड़ सकते हैं:let f s=Seq.countBy id (Seq.sort s)|>Seq.iter(printfn"%A")

— 1

वास्तव में, पहली जगह में भी क्यों छाँटें? let f s=Seq.countBy id s|>Seq.iter(printfn"%A")

— गोरिक

Answer 21

गणितज्ञ, ३४ २ ९ बाइट्स

निश्चित नहीं है कि अन्य गणितज्ञ उत्तर इतना जटिल क्यों है ...;)

Grid@Tally@Characters@Input[]

Answer 22

बैश ( 20 15 अक्षर)

 ptx -S.|uniq -c
 10                                        a
  1                                        c
  4                                        d
  8                                        e
  2                                        f
  3                                        g
  3                                        h
 10                                        i
  1                                        m
 10                                        n
  4                                        o
  3                                        p
  1                                        q
  2                                        r
  5                                        s
  6                                        t
  1                                        T
  1                                        u
  1                                        x
  1                                        y

ASCII एन्कोडिंग अब समर्थित है

बैश (23 अक्षर):

xxd -p -c1|sort|uniq -c

  1 0a
 15 20
  1 2e
  1 54
 10 61
  1 63
  4 64
  8 65
  2 66
  3 67
  3 68
 10 69
  1 6d
 10 6e
  4 6f
  3 70
  1 71
  2 72
  5 73
  6 74
  1 75
  1 78
  1 79

ASCII स्वरूपण समर्थित नहीं है

Comments

जिज्ञासा से बाहर, क्या तुम सच में जरूरत है | यहाँ, AFAIK ptx पहले से ही वर्णों की एक क्रमबद्ध सूची तैयार करेगा, जिसे आप सीधे "uniq -c"

— zeppelin

@ azppelin थोड़ा गुगली कर रहा है कि आपने क्या कहा है

— प्यूरफेरेट

Answer 23

जावा 8, 273 253 249 246 239 200 बाइट्स

interface I{static void main(String[]a){int m[]=new int[999],i=0;for(int c:new java.util.Scanner(System.in).nextLine().getBytes())m[c]++;for(;++i<999;)if(m[i]>0)System.out.printf("%c: %d%n",i,m[i]);}}

-24 के लिए धन्यवाद बाइट्स @Poke ।
-7 बाइट्स @ OlivierGrégoire को धन्यवाद ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

interface I{                        // Class
  static void main(String[]a){      //  Mandatory main-method
    int m[]=new int[999],           //  Integer-array to count the occurrences
        i=0;                        //  Index-integer, starting at 0
    for(int c:new java.util.Scanner(System.in).nextLine().getBytes())
                                    //   Loop over the input as bytes:
      m[c]++;                       //    Increase the occurrence-counter of the char by 1
    for(;++i<999;)                  //   Loop over the array:
      if(m[i]>0)                    //    If the current character occurred at least once:
        System.out.print("%c: %d%n",//     Print with proper formatting:
         i,                         //      The character
         m[i]);}}                   //      and the occurrence-count

Comments

249 बाइट्सimport java.util.*;class I{public static void main(String[]a){Map m=new HashMap();for(char c:new Scanner(System.in).nextLine().toCharArray()){m.put(c,m.get(c)!=null?(int)m.get(c)+1:1);}for(Object e:m.keySet()){System.out.println(e+": "+m.get(e));}}}

— प्रहार

m.compute(c,(k,v)->v!=null?(int)v+1:1);m.put(c,m.get(c‌​)!=null?(int)m.get(c‌​)+1:1);3 बाइट्स बचाने के बजाय ।

— ओलिवियर ग्राएगोइरे

Answer 24

पॉवरशेल, ६३

$a=@{};[char[]](read-host)|%{$a[$_]++};$a.Keys|%{"$_ :"+$a[$_]}

Comments

एक हैश में प्रत्येक कुंजी को उस हैश पर एक संपत्ति के रूप में एक्सेस किया जा सकता है, इसलिए आप प्रत्येक उदाहरण के $a[$_]साथ दो वर्णों को बंद कर सकते हैं $a.$_। देखेंhelp about_hash_tables

— गोरिक

Answer 25

विंडोज कमांड स्क्रिप्ट - 72 बाइट्स

set/p.=
:a
set/a\%.:~,1%=\%.:~,1%+1
set.=%.:~1%
%.%goto:b
goto:a
:b
set\

आउटपुट:

\=15 (space)
\.=1
\a=10
\c=1
\d=4
\e=8
\f=2
\g=3
\h=3
\i=10
\m=1
\n=10
\o=4
\p=3
\q=1
\r=2
\s=5
\T=7
\u=1
\x=1
\y=1

Comments

अच्छा! हालांकि यह फोल्ड केस करता है, लेकिन बैच फाइल प्रोग्रामिंग में वास्तविक चतुराई देखना हमेशा आश्चर्यजनक है।

— ब्रायन मिंटन

Answer 26

जे, 23 वर्ण

(~.;"0+/@|:@=)/:~1!:1]1

थोड़ा अलग आउटपुट स्वरूप (पंक्ति 2 स्टडिन):

   (~.;"0+/@|:@=)/:~1!:1]1
Mississippi
┌─┬─┐
│M│1│
├─┼─┤
│i│4│
├─┼─┤
│p│2│
├─┼─┤
│s│4│
└─┴─┘

Answer 27

जे, 22 अक्षर

(~.;"0+/@(=/~.))1!:1]1

उदाहरण:

   (~.;"0+/@(=/~.))1!:1]1
The definition of insanity is quoting the same phrase again and again and not expect despair.
+-+--+
|T|1 |
+-+--+
|h|3 |
+-+--+
|e|8 |
+-+--+
| |15|
+-+--+
|d|4 |
+-+--+
|f|2 |
+-+--+
|i|10|
+-+--+
|n|10|
+-+--+
|t|6 |
+-+--+
|o|4 |
+-+--+
|s|5 |
+-+--+
|a|10|
+-+--+
|y|1 |
+-+--+
|q|1 |
+-+--+
|u|1 |
+-+--+
|g|3 |
+-+--+
|m|1 |
+-+--+
|p|3 |
+-+--+
|r|2 |
+-+--+
|x|1 |
+-+--+
|c|1 |
+-+--+
|.|1 |
+-+--+

Answer 28

सी#

string str = Console.ReadLine(); // Get Input From User Here
char chr;
for (int i = 0; i < 256; i++)
{
    chr = (char)i; // Use The Integer Index As ASCII Char Value --> Convert To Char
    if (str.IndexOf(chr) != -1) // If The Current Char Exists In The Input String
    {
        Console.WriteLine(chr + " : " + str.Count(x => x == chr)); // Count And Display
    }
}
Console.ReadLine(); // Hold The Program Open.

हमारे मामले में, अगर इनपुट होगा " पागलपन की परिभाषा एक ही वाक्यांश को बार-बार उद्धृत कर रही है और निराशा की उम्मीद नहीं है। "

आउटपुट होगा:

  : 15
. : 1
T : 1
a : 10
c : 1
d : 4
e : 8
f : 2
g : 3
h : 3
i : 10
m : 1
n : 10
o : 4
p : 3
q : 1
r : 2
s : 5
t : 6
u : 1
x : 1
y : 1

Comments

प्रश्न कीबोर्ड से इनपुट मांगता है, इसलिए पहली पंक्ति होनी चाहिए string str = Console.ReadLine();। लेकिन यह कोड-गोल्फ है इसलिए यह वास्तव में होना चाहिए var str=Console.ReadLine();। अन्य टिप्पणियां जो मैं करना चाहता हूं, जब तक ओपी प्रश्न को सुधारता है, तब तक उसे रोकना होगा।

— पीटर टेलर

आप सही हैं, मैंने अपना उत्तर संपादित किया।

— अवीव

Answer 29

C #: 129

यह अवीव उत्तर है लेकिन कम है:

var s=Console.ReadLine();for(int i=0;i<256;i++){var ch=(char)i;Console.Write(s.Contains(ch)?ch+":"+s.Count(c=>c==ch)+"\r\n":"");}

यह मेरा है:

C #: 103

foreach(var g in Console.ReadLine().OrderBy(o=>o).GroupBy(c=>c))Console.WriteLine(g.Key+":"+g.Count());

Comments

संकलन नहीं होगा, usings / namespace / class / method परिभाषाओं के लिए लगभग 50 वर्ण जोड़ने की आवश्यकता है।

— पियरे-ल्यूक पाइनयाल्ट

ओह, नहीं पता था कि यह अनिवार्य था, मुझे क्षमा करें।

— अब्बास

Answer 30

पायथन 2 (90 वर्ण)

import collections as c;print"\n".join("%s %s"%i for i in c.Counter(raw_input()).items())

अपने स्रोत पर चलने पर आउटपुट:

  8
" 4
% 3
) 4
( 4
. 3
; 1
C 1
\ 1
_ 1
a 2
c 4
e 3
f 1
i 9
j 1
m 2
l 2
o 6
n 7
p 3
s 5
r 5
u 2
t 6
w 1