Schreiben Sie ein Programm, das eine Liste der Vorkommen jedes einzelnen Zeichens im Quellcode ausgibt.

Zum Beispiel sollte dieses hypothetische Programm {Source_Print_1};diese Ausgabe erzeugen:

; 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

Die Formatierung sollte mit diesem Beispiel übereinstimmen. Außer einem optionalen letzten Zeilenumbruch sind keine zusätzlichen Leerzeichen zulässig.

Ihr Programm liest möglicherweise keinen eigenen Quellcode aus der Quelldatei.

Die aufgelisteten Zeichen müssen in einer von zwei Reihenfolgen sein. Entweder die Reihenfolge der Zeichenwerte in der von Ihrer Sprache verwendeten Zeichenkodierung (wahrscheinlich ASCII) oder die Reihenfolge, in der die Zeichen in Ihrer Quelle angezeigt werden.

Diese Frage inspiriert durch diesen Kommentar von Jan Dvorak .

CJam, 14 Bytes

{S2N`/}`{S2N}/

Probieren Sie es hier aus .

Die Ausgabe erfolgt in der Reihenfolge, in der sie zuerst angezeigt wird:

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

Es wird einfach <SP>2<NL>an jedes Zeichen in angehängt {S2N`/}.

/// , 12 Bytes

  4
4 4

 4

Ein großes Dankeschön geht an @ user23013, der diese Verbesserung gegenüber meinem CJam-Code vorgeschlagen hat und dabei seine eigene, am höchsten bewertete Antwort übertroffen hat.

Die Zeichen sind nach Erscheinungsbild sortiert. Dieser Code funktioniert in jeder Sprache, die unter den gegebenen Umständen (PHP, ASP usw.) nur ihren eigenen Quellcode ausgibt.

CJam, 20 Bytes

''S5N'5S5N'NS5N'SS5N

Dieser Ansatz verwendet keine eingebaute Zeichenzählung.

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

''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}%}_~

Wie es funktioniert

Wir beginnen zuerst mit einem der Standard-Quines in CJam

{`"_~"}_~

Dadurch wird der erste Block auf den Stapel verschoben, kopiert und die Kopie ausgeführt, wodurch der Quellcode selbst schließlich gedruckt wird.

Dann fügen wir die Logik hinzu, um die Zeichenanzahl aus dem Quellcode zu berechnen:

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

Probieren Sie es hier online aus

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)

Anstelle des üblichen String-Ersatz-Quines, bei dem alles zweimal geschrieben werden muss, ist hier ein execQuine.

Mathematica, 101 Bytes

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

Leider kann ich nicht wie Leerzeichen entfernt eine der normalen Golf Tricks, <>für StringJoin, #statt #1, @für Anrufe Präfix Funktion oder @@@statt Apply[...,{1}], weil ToString[...,InputForm]denkt , dass es zu ziemlich Druck alles hat ...

Dies druckt die Zeichen in der Reihenfolge, in der sie zuerst im Code erscheinen. Wenn ich davon ausgehen kann, dass dies nicht in einer REPL-Umgebung ausgeführt wird (was für Mathematica eher ungewöhnlich ist), kann ich zwei Bytes sparen, indem ich die beiden weglasse ;.

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

Nichts Besonderes. Alle Zeichen des Programms befinden sich in einer Literalliste (String). So sind die Frequenzen. Zippen Sie beide Listen und drucken Sie sie aus. Ausgabe:

  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 

Dart - 214 127

Eine direkte Version:

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

Die "4" ist nur ein fummeliger Faktor, um die Zahlen zu addieren. Siehe / laufen auf DartPad .

Original: Standard-Quine-Taktik, und Darts Funktionsnamen sind etwas zu lang für gutes Golfen.

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

Siehe / starte es auf 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]

Probieren Sie es online!

Ausgabe:

  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

(Plus eine zusätzliche Newline)

Erläuterung:

Der Code ist

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

wo "<code>"ist eine Zeichenfolge des Programmcodes ohne das ".

aDurchläuft die ASCII-Zeichen und beginnt mit einem Leerzeichen. sum[2|b<-show"<code>",a==b]zählt, wie oft das Zeichen in der Zeichenfolge vorkommt, wobei jedes Vorkommen zweimal gezählt wird. a:" "++show sErstellt eine Zeichenfolge aus dem aktuellen Zeichen, einem Leerzeichen und der Anzahl der Zeichen. Zum Schluss wird mapM putStrLnjede Zeichenfolge in der Liste mit einem nachgestellten Zeilenumbruch gedruckt.

Das Schwierigste war, den "richtigen Wert zu ermitteln . Die Verwendung von just b<-"<code>"würde null Anführungszeichen zählen, da die Zeichenfolge keine enthält. Durch Verwenden von wird show"<code>"ein "vor und ein Ende der Zeichenfolge hinzugefügt, was zu einer Anzahl von vier führt. Also musste ich zwei zusätzliche Anführungszeichen in den Code setzen, also anstelle der (kürzeren), die a:' ':show sich verwendete a:" "++show s.