Напишите программу, которая выводит список количества вхождений каждого уникального символа в его исходный код.

Например, эта гипотетическая программа {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}%}_~

Как это устроено

Сначала мы начнем с одного из стандартных Quine в 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

Попробуйте онлайн здесь

Python 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

Ничего фантастического. Все символы программы находятся в буквальном списке (String). Как и частоты. Застегните оба списка и распечатайте. Выход:

  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 .

Оригинал: стандартная тактика Куайн, и названия функций Дарт слишком длинны для хорошего игры в гольф.

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печатает каждую строку в списке с завершающей новой строкой.

Самым сложным было получить счет "правильно. Использование просто b<-"<code>"будет считать нулевые кавычки, потому что в строке нет ни одного. Использование show"<code>"добавляет "перед и конец строки, в результате чего счет четыре. Поэтому мне пришлось добавить в код две дополнительные кавычки, поэтому вместо (короче) a:' ':show sя использовал a:" "++show s.