Escriba un programa que genere una lista del número de ocurrencias de cada carácter único en su código fuente.

Por ejemplo, este programa hipotético {Source_Print_1};debería producir esta salida:

; 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

El formato debe coincidir con este ejemplo. No se permiten espacios en blanco extraños, excepto una nueva línea final opcional.

Es posible que su programa no lea su propio código fuente del archivo fuente.

Los caracteres enumerados deben estar en uno de dos órdenes. O el orden de los valores de caracteres en la codificación de caracteres utilizada por su idioma (probablemente ASCII), o el orden en que aparecen los caracteres en su fuente.

Esta pregunta inspirada en este comentario de Jan Dvorak .

CJam, 14 bytes

{S2N`/}`{S2N}/

Pruébalo aquí .

La salida está en el orden en que aparecen primero:

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

Simplemente se agrega <SP>2<NL>a cada personaje en {S2N`/}.

/// , 12 bytes

  4
4 4

 4

Un gran agradecimiento a @ user23013, quien sugirió esta mejora con respecto a mi código CJam, superando su propia respuesta de mayor puntaje en el proceso.

Los personajes están ordenados por apariencia. Este código funciona en cualquier lenguaje que solo imprima su propio código fuente en las circunstancias dadas (PHP, ASP, etc.).

CJam, 20 bytes

''S5N'5S5N'NS5N'SS5N

Este enfoque no utiliza ningún recuento de caracteres incorporado.

Pruébelo en línea en el intérprete de CJam .

Cómo 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}%}_~

Cómo funciona

Primero comenzamos con una de las quine estándar en CJam

{`"_~"}_~

que empuja el primer bloque en la pila, lo copia y ejecuta la copia, lo que hace que finalmente imprima el código fuente.

Luego agregamos la lógica para calcular el recuento de caracteres del código fuente:

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

Pruébalo en línea aquí

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)

En lugar de la quine de reemplazo de cadena habitual, que requiere escribir todo dos veces, aquí hay una execquine.

Mathematica, 101 bytes

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

Desafortunadamente, no puedo usar ninguno de los trucos normales de golf, como eliminar espacios en blanco, <>para StringJoin, en #lugar de #1, @para llamadas de función de prefijo o en @@@lugar de Apply[...,{1}], porque ToString[...,InputForm]cree que tiene que imprimir todo ...

Esto imprime los caracteres en el orden en que aparecen por primera vez en el código. Si puedo suponer que esto no se ejecuta en un entorno REPL (lo cual es bastante inusual para Mathematica), puedo guardar dos bytes omitiendo los dos ;.

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 sofisticado. Todos los caracteres del programa están en una lista literal (String). Así son las frecuencias. Comprime ambas listas e imprime. Salida:

  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

Una versión directa:

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

El "4" es solo un factor de violín para que los números sumen. Ver / ejecutar en DartPad .

Original: táctica de quine estándar, y los nombres de las funciones de Dart son demasiado largos para un buen golf.

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

Ver / ejecutarlo en 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]

Pruébalo en línea!

Salida:

  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

(Más una nueva línea adicional)

Explicación:

El código es

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

donde "<code>"es una cadena del código del programa sin el ".

apasa por los caracteres ascii comenzando con un espacio. sum[2|b<-show"<code>",a==b]cuenta con qué frecuencia aparece el carácter en la cadena, con cada aparición contada dos veces. a:" "++show sconstruye una cadena del carácter actual, un espacio y el recuento de caracteres. Finalmente mapM putStrLnimprime cada cadena en la lista con una nueva línea final.

La parte más difícil fue contar el "derecho. Usar solo b<-"<code>"contaría comillas cero porque no hay ninguno en la cadena. El uso show"<code>"agrega "a al frente y al final de la cadena, lo que resulta en un conteo de cuatro. Así que tuve que poner dos comillas adicionales en el código, así que en lugar del (más corto) a:' ':show sque usé a:" "++show s.