该代码应使用字符串作为键盘输入：

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字符都计数unicode，空格，引号等，并且输入应来自键盘/而不是常量，属性，输出应在每个字符之后用新行打印，如上例所示，不应作为字符串返回或倾倒作为HashMap中/字典等，所以x : 1和x: 1是好的，但 {'x':1,...并x:1没有。

问：函数或完整程序采用stdin并编写stdout？
答：代码必须是使用标准输入输入并通过标准输出显示结果的程序。

记分板：

整体最短：5个字节

整体最短：7个字节

APL（Dyalog Unicode），5 字节^SBCS

完整的程序主体。提示输入来自STDIN的字符串，并将换行符分隔的表格输出到STDOUT。最左边的列是输入字符，计数以右对齐，最大的数字与其字符分开一个空格。

,∘≢⌸⍞

在线尝试！

⍞ 提示从STDIN输入文本

⌸ 创建一个键的表组成的
 , 独特的元件，随后
 ∘ 通过
 ≢ 其发生的指数的帐簿（即多少次发生）

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
)

其中每个数字索引均表示其代表的字符的序号。

我强烈怀疑使用内置功能完全能够解决问题所指出的问题，这将很快被禁止。

k（8 7）

#:'=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

编辑：减少到七，H / T亚伦戴维斯

说明

从键盘上取一个字符串：

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

GNU核心实用程序-29 22 20个字符（53个带格式）

Wumpus的改进（20个字符）：

fold -1|sort|uniq -c

萤火虫的改进（22个字符）：

grep -o .|sort|uniq -c

joeytwiddle的原文（29个字符）：

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

最初，我sed以前只是在每个字符后添加换行符。Firefly通过改进了此功能grep -o .，因为-o它在自己的行上显示了所有匹配的模式。Wumpus指出了使用的进一步改进fold -1。干得好！

uniq 确实可以完成工作，尽管它仅适用于排序列表。

请注意，输出格式与问题中的示例不完全匹配。这需要最后一次sed交换参数。（等待Jan Dvorak问题的答案，看是否需要...）

用sed重新格式化只是另外33个字符！（共53）

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

Awk 几乎可以完成这项工作，而只添加25个字符，但隐藏了第一个空格。愚蠢的awk！

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

我想知道是否可以在重新格式化阶段进行改进。

Ruby 1.9.3：53个字符

（基于@shiva和@daneiro的评论。）

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

Ruby：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}

Python 3：76个字符

76

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

44

（多次打印相同的字符，请参阅Wasi的答案以获取有效版本）

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

Perl 6：21个字符

.say for get.comb.Bag

（REPL）
> .say for get.comb.Bag
精神错乱的定义是一遍又一遍地引用同一短语，并且不要指望绝望。
“ 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

APL（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

R，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 

Perl 5，54个字符

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

的JavaScript

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},{})
   

注意：在所有情况下，已删除的字节数都是指额外的console.log()调用，如果在控制台中运行，则没有意义。非常感谢@imma与-~a[b]and 取得的巨大成功prompt(a={})。这肯定节省了更多的字节。

Python 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

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

Mathematica，61个字节

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

然后会弹出此对话框，

对于例句，将其作为输出

蟒蛇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

JavaScript（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 包含输出。

哈斯克尔（93）

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

PowerShell（49）

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

C＃（178 220个字符）

基于@Spongeman的评论，我对其进行了一些更改：

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

滑行，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
丟

F＃（具有指定格式的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)

Mathematica，34个 29字节

Not sure why the other Mathematica answer is so complicated... ;)

Grid@Tally@Characters@Input[]

Bash (20 15 characters)

 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 encoding now supported

Bash (23 characters):

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 formatting not supported

Java 8, 273 253 249 246 239 200 bytes

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 bytes thanks to @Poke.
-7 bytes thanks to @OlivierGrégoire.

Explanation:

Try it here.

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

Powershell, 63

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

Windows Command Script - 72 Bytes

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

Outputs:

\=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

J, 23 chars

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

Slightly different output format (line 2 is stdin):

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

J, 22 characters

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

Example:

   (~.;"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 |
+-+--+

C#

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.

In Our Case, If The Input Will Be "The definition of insanity is quoting the same phrase again and again and not expect despair."

The Output Will Be:

  : 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

C#: 129

This is Avivs answer but shorter:

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

This is mine:

C#: 103

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

Python 2 (90 chars)

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

Output when run on its own source:

  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