Scrivi un programma che genera un elenco del numero di occorrenze di ciascun carattere univoco nel suo codice sorgente.

Ad esempio, questo ipotetico programma {Source_Print_1};dovrebbe produrre questo output:

; 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

La formattazione dovrebbe corrispondere a questo esempio. Non sono ammessi spazi bianchi estranei, tranne una nuova riga finale opzionale.

Il tuo programma potrebbe non leggere il proprio codice sorgente dal file sorgente.

I personaggi elencati devono essere in uno di due ordini. L'ordine dei valori dei caratteri nella codifica dei caratteri utilizzata dalla tua lingua (probabilmente ASCII) o l'ordine in cui i caratteri compaiono nella tua fonte.

Questa domanda si ispira a questo commento di Jan Dvorak .

CJam, 14 byte

{S2N`/}`{S2N}/

Provalo qui .

L'output è nell'ordine in cui appaiono per primi:

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

Si aggiunge semplicemente <SP>2<NL>a ciascun personaggio in {S2N`/}.

/// , 12 byte

  4
4 4

 4

Un grande ringraziamento va a @ user23013, che mi ha suggerito questo miglioramento rispetto al mio codice CJam, superando la sua risposta con il punteggio più alto nel processo.

I personaggi sono ordinati per aspetto. Questo codice funziona in qualsiasi lingua che stampa il proprio codice sorgente in determinate circostanze (PHP, ASP, ecc.).

CJam, 20 byte

''S5N'5S5N'NS5N'SS5N

Questo approccio non utilizza alcun conteggio dei caratteri incorporato.

Provalo online nell'interprete CJam .

Come funziona

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

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

Come funziona

Iniziamo con una delle quine standard in CJam

{`"_~"}_~

che spinge il primo blocco in pila, lo copia ed esegue la copia, il che lo rende infine il codice sorgente stesso.

Quindi aggiungiamo la logica per calcolare il conteggio dei caratteri dal codice sorgente:

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

Provalo online qui

Python 3.5.0b1 , 107 73 byte

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

Invece del solito quine di sostituzione delle stringhe, che richiede di scrivere tutto due volte, ecco un execquine.

Mathematica, 101 byte

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

Sfortunatamente, non posso usare nessuno dei normali trucchi da golf come la rimozione di spazi bianchi, <>per StringJoin, #invece di #1, @per le chiamate di funzione prefisso o @@@invece di Apply[...,{1}], perché ToString[...,InputForm]pensa che debba stampare piuttosto tutto ...

Ciò stampa i caratteri nell'ordine in cui compaiono per la prima volta nel codice. Se posso presumere che questo non sia eseguito in un ambiente REPL (cosa piuttosto insolita per Mathematica), posso salvare due byte omettendoli ;.

Haskell, 178 byte

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

Nulla di bello. Tutti i caratteri del programma sono in un elenco letterale (String). Così sono le frequenze. Comprimi entrambi gli elenchi e stampa. Produzione:

  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 versione diretta:

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

Il "4" è solo un fattore di manipolazione per far sommare i numeri. Vedi / esegui su DartPad .

Originale: tattica quine standard e i nomi delle funzioni di Dart sono un po 'troppo lunghi per un buon 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"));}

Vedi / eseguilo su DartPad .

Haskell , 146 byte

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]

Provalo online!

Produzione:

  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

(Più una nuova riga aggiuntiva)

Spiegazione:

Il codice è

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

dove "<code>"è una stringa del codice del programma senza il ".

apassa attraverso i caratteri ASCII iniziando con uno spazio. sum[2|b<-show"<code>",a==b]conta la frequenza con cui il carattere appare nella stringa, con ogni occorrenza contata due volte. a:" "++show screa una stringa del carattere corrente, uno spazio e il conteggio dei caratteri. mapM putStrLnStampa infine ogni stringa nell'elenco con una nuova riga finale.

La parte più difficile era ottenere il conto di "giusto. Usando just b<-"<code>"si contano zero virgolette perché non ce ne sono nella stringa. Usando si show"<code>"aggiunge a "in primo piano e fine alla stringa, risultando in un conteggio di quattro. Quindi ho dovuto inserire due virgolette aggiuntive nel codice, quindi al posto del (più corto) che a:' ':show sho usato a:" "++show s.