编写一个程序，输出在其源代码中每个唯一字符出现次数的列表。

例如，此假设程序{Source_Print_1};应产生以下输出：

; 1
P 1
S 1
_ 2
c 1
e 1
i 1
n 1
o 1
p 1
r 2
t 1
u 1
{ 1
} 1

格式应与此示例匹配。除可选的最终换行符外，不允许使用多余的空格。

您的程序可能无法从源文件中读取其自己的源代码。

列出的字符必须是两个顺序之一。语言使用的字符编码中的字符值顺序（可能是ASCII），或者字符在源中出现的顺序。

这个问题受到Jan Dvorak的评论的启发。

CJam，14个字节

{S2N`/}`{S2N}/

在这里尝试。

输出按其首次出现的顺序：

{ 2
S 2
2 2
N 2
` 2
/ 2
} 2

它只是附加<SP>2<NL>到中的每个字符{S2N`/}。

///，12个字节

  4
4 4

 4

非常感谢@ user23013，他建议对我的CJam代码进行此改进，在此过程中超越了他自己得分最高的答案。

字符按外观排序。此代码可以在给定的情况下（PHP，ASP等）以仅打印自己的源代码的任何语言工作。

CJam，20个字节

''S5N'5S5N'NS5N'SS5N

这种方法不使用任何内置字符计数。

在CJam解释器中在线尝试。

怎么运行的

''S5N e# Push a single quote, a space, the integer 5 and a linefeed.
'5S5N e# Push the character 5, a space, the integer 5 and a linefeed.
'NS5N e# Push the character N, a space, the integer 5 and a linefeed.
'SS5N e# Push the character S, a space, the integer 5 and a linefeed.

CJam，20个字节

{`"_~"+$e`{)S@N}%}_~

怎么运行的

我们首先从CJam中的标准藜麦开始

{`"_~"}_~

它将第一个块压入堆栈，对其进行复制，然后运行该副本，从而使其最终打印出源代码本身。

然后，我们添加逻辑以根据源代码计算字符数：

{`"_~"+                         e# At this point, we have the full source code with us
       $e`                      e# Sort to get similar characters together and run RLE to
                                e# get count of each character as [count char] array
          {    }%               e# Run each array element through this loop
           )S@N                 e# Pop the character, put a space, rotate the count after
                                e# space and then finally put a newline after the trio
                 }_~            e# Second half of the standard quine explained above

在这里在线尝试

蟒3.5.0b1，107个 73字节

s="t='s=%r;exec(s)'%s;[print(c,t.count(c))for c in sorted({*t})]";exec(s)

而不是通常的字符串替换quine（需要将所有内容写两次），这里是execquine。

Mathematica，101个字节

Apply[Print[#1, " ", #2] &, Tally[Characters[StringJoin[ToString[#0, InputForm], "[];"]]], {1}] & [];

不幸的是，我不能使用任何正常的高尔夫技巧，如消除空白，<>为StringJoin，#而不是#1，@前缀函数调用或@@@代替的Apply[...,{1}]，因为ToString[...,InputForm]认为它有漂亮的打印一切...

这将按照字符首次出现在代码中的顺序打印字符。如果我可以假设这不是在REPL环境中运行的（这对于Mathematica来说是很不常见的），则可以通过省略两个字节来节省两个字节;。

Haskell，178个字节

main=putStr(unlines[s:' ':show t|(s,t)<-zip" \"'(),-0123456789:<=S[\\]aehilmnoprstuwz|"[3,3,3,3,3,41,4,1,6,19,12,5,5,2,2,2,2,3,2,2,2,3,3,3,2,2,2,4,2,2,4,2,3,2,5,5,3,2,2,2]])--178

没有什么花哨。程序的所有字符都在文字列表（字符串）中。频率也是如此。压缩列表并打印。输出：

  3
" 3
' 3
( 3
) 3
, 41
- 4
0 1
1 6
2 19
3 12
4 5
5 5
6 2
7 2
8 2
9 2
: 3
< 2
= 2
S 2
[ 3
\ 3
] 3
a 2
e 2
h 2
i 4
l 2
m 2
n 4
o 2
p 3
r 2
s 5
t 5
u 3
w 2
z 2
| 2 

飞镖- 214 127

直接版本：

main(){print("  22\n\" 3\n( 3\n) 3\n1 3\n2 15\n3 8\n4 1\n5 2\n8 2\n; 2\n\\ 23\na 2\ni 3\nm 2\nn 23\np 2\nr 2\nt 2\n{ 2\n} 2");}

“ 4”只是使数字相加的一个摆弄因素。在DartPad上查看/运行。

原文：标准的quine战术和Dart的功能名称对于高尔夫运动来说太长了。

main({m,v,q:r'''main({m,v,q:r''}'')''{m={};for(v in q.split(''))m[v]=m[v]==null?2:m[v]+2;m.forEach((k,v)=>print("$k $v"));}'''}){m={};for(v in q.split(''))m[v]=m[v]==null?2:m[v]+2;m.forEach((k,v)=>print("$k $v"));}

在DartPad上查看/运行它。

Haskell，146个字节

main=mapM putStrLn[a:" "++show s|a<-[' '..],s<-[sum[2|b<-show"main=mapM putStrLn[a: ++show s|a<-[' '..],s<-[sum[2|b<-show,a==b]],s>0]",a==b]],s>0]

在线尝试！

输出：

  8
" 4
' 4
+ 4
, 6
- 6
. 4
0 2
2 2
: 2
< 6
= 6
> 2
L 2
M 2
S 2
[ 8
] 8
a 10
b 4
h 4
i 2
m 6
n 4
o 4
p 4
r 2
s 12
t 4
u 4
w 4
| 4

（加上其他换行符）

说明：

该代码是

main=mapM putStrLn[a:" "++show s|a<-[' '..],s<-[sum[2|b<-show"<code>",a==b]],s>0]

哪里"<code>"是不带的程序代码字符串"。

a通过以空格开头的ascii字符。sum[2|b<-show"<code>",a==b]计算字符出现在字符串中的频率，每次出现两次。a:" "++show s构建当前字符的字符串，空格和字符数。最后mapM putStrLn用尾随换行符打印列表中的每个字符串。

最难的部分是获得"正确的计数。使用just b<-"<code>"将计数零引号，因为字符串中没有引号。使用show"<code>"将a添加"到字符串的前面和结尾，结果是四个。因此，我不得不在代码中加上两个引号，而不是a:' ':show s我使用的（较短的）a:" "++show s。