Escreva um programa que produz uma lista do número de ocorrências de cada caractere exclusivo em seu código-fonte.

Por exemplo, este programa hipotético {Source_Print_1};deve produzir esta saída:

; 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

A formatação deve corresponder a este exemplo. Nenhum espaço em branco estranho é permitido, exceto uma nova linha final opcional.

Seu programa pode não ler seu próprio código fonte no arquivo fonte.

Os caracteres listados devem estar em um de dois pedidos. A ordem dos valores dos caracteres na codificação de caracteres usada pelo seu idioma (provavelmente ASCII) ou a ordem em que os caracteres aparecem na sua fonte.

Esta pergunta foi inspirada neste comentário de Jan Dvorak .

CJam, 14 bytes

{S2N`/}`{S2N}/

Experimente aqui .

A saída está na ordem em que aparecem pela primeira vez:

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

Ele simplesmente anexa <SP>2<NL>a cada caractere em {S2N`/}.

/// , 12 bytes

  4
4 4

 4

Um grande obrigado a @ user23013, que sugeriu essa melhoria no meu código CJam, superando sua própria resposta de maior pontuação no processo.

Os caracteres são classificados por aparência. Este código funciona em qualquer linguagem que apenas imprima seu próprio código-fonte nas circunstâncias especificadas (PHP, ASP, etc.).

CJam, 20 bytes

''S5N'5S5N'NS5N'SS5N

Essa abordagem não usa nenhuma contagem de caracteres interna.

Experimente on-line no intérprete CJam .

Como funciona

''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 bytes

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

Como funciona

Começamos com um dos quine padrão no CJam

{`"_~"}_~

que coloca o primeiro bloco na pilha, copia e executa a cópia, o que faz com que ela imprima o próprio código-fonte finalmente.

Em seguida, adicionamos a lógica para calcular a contagem de caracteres a partir do código fonte:

{`"_~"+                         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

Experimente online aqui

Python 3.5.0b1 , 107 73 bytes

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

Em vez da substituição usual de seqüência de caracteres, que exige que você escreva tudo duas vezes, aqui está um execresumo.

Mathematica, 101 bytes

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

Infelizmente, não posso usar nenhum dos truques normais de golfe, como remover espaços em branco, <>para StringJoin, em #vez de #1, @para chamadas de função de prefixo ou em @@@vez de Apply[...,{1}], porque ToString[...,InputForm]acha que precisa imprimir tudo ...

Isso imprime os caracteres na ordem em que aparecem pela primeira vez no código. Se eu puder assumir que isso não é executado em um ambiente REPL (o que é bastante incomum para o Mathematica), posso salvar dois bytes, omitindo os dois ;.

Haskell, 178 bytes

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

Nada chique. Todos os caracteres do programa estão em uma lista literal (String). O mesmo acontece com as frequências. Feche as duas listas e imprima. Resultado:

  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 

Dardo - 214 127

Uma versão direta:

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

O "4" é apenas um fator delicado para somar os números. Veja / execute no DartPad .

Original: tática padrão para quine, e os nomes das funções de Dart são um pouco longos para um bom jogo de golfe.

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

Veja / execute-o no DartPad .

Haskell , 146 bytes

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]

Experimente online!

Resultado:

  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

(Mais uma nova linha)

Explicação:

O código é

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

onde "<code>"é uma sequência do código do programa sem o ".

apassa pelos caracteres ascii começando com um espaço. sum[2|b<-show"<code>",a==b]conta com que frequência o caractere aparece na string, com cada ocorrência contada duas vezes. a:" "++show scria uma cadeia de caracteres atual, um espaço e a contagem de caracteres. Finalmente, mapM putStrLnimprime cada sequência da lista com uma nova linha à direita.

A parte mais difícil foi acertar as contas ". Usar apenas b<-"<code>"contaria aspas zero porque não há nenhuma na sequência. Usar show"<code>"adiciona "a à frente e final à sequência, resultando em uma contagem de quatro. Então eu tive que colocar duas aspas adicionais no código, então, em vez das (mais curtas) que a:' ':show seu usei a:" "++show s.