Kaynak kodundaki her bir benzersiz karakterin oluşum sayısının listesini çıkaran bir program yazın.

Örneğin, bu varsayımsal program {Source_Print_1};bu çıktıyı üretmelidir:

; 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

Biçimlendirme bu örnekle eşleşmelidir. İsteğe bağlı bir son satırsonu dışında herhangi bir yabancı alana izin verilmez.

Programınız, kaynak dosyadan kendi kaynak kodunu okuyamayabilir.

Listelenen karakterler iki sıradan birinde olmalıdır. Diliniz tarafından kullanılan karakter kodlamasındaki karakter değerlerinin sırası (muhtemelen ASCII) ya da karakterlerin kaynağınızda görünme sırası.

Esinlenerek bu soru Bu yoruma göre Jan Dvorak .

CJam, 14 bayt

{S2N`/}`{S2N}/

Burada deneyin .

Çıktı ilk göründükleri sırayla:

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

Sadece <SP>2<NL>her karaktere eklenir {S2N`/}.

/// , 12 bayt

  4
4 4

 4

CJam kodum üzerinde bu gelişmeyi öneren ve bu işlemdeki kendi en yüksek puanlı cevabını geride bırakan @ user23013'e büyük bir teşekkür ederiz.

Karakterler görünüşe göre sıralanır. Bu kod, belirtilen koşullar altında kendi kaynak kodunu yazdıran herhangi bir dilde çalışır (PHP, ASP, vb.).

CJam, 20 bayt

''S5N'5S5N'NS5N'SS5N

Bu yaklaşım yerleşik karakter sayımı kullanmaz.

CJam yorumlayıcısında çevrimiçi deneyin .

Nasıl çalışır

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

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

Nasıl çalışır

İlk olarak CJam'deki standart fiyatlardan biriyle başlıyoruz

{`"_~"}_~

ilk bloğu yığına iter, kopyalar ve kopyayı çalıştırır, bu da sonunda kaynak kodun kendisini yazdırmasını sağlar.

Sonra kaynak kodundan karakter sayısını hesaplamak için mantık ekliyoruz:

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

Buradan çevrimiçi deneyin

Python 3.5.0b1 , 107 73 bayt

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

Her şeyi iki kez yazmayı gerektiren normal dize değiştirme quine'den ziyade, bir execquine.

Mathematica, 101 bayt

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

Ne yazık ki, ben boşluk kaldırma gibi normal bir golf hileler herhangi kullanamazsınız <>için StringJoin, #yerine #1, @önek işlev çağrıları için veya @@@yerine Apply[...,{1}]çünkü ToString[...,InputForm]oldukça baskı her şeye sahip olduğunu düşünür ...

Bu, karakterleri kodda ilk görüntülendikleri sırayla yazdırır. Bunun bir REPL ortamında (Mathematica için alışılmadık bir şekilde) çalışmadığını varsayabilirim, ikisini atlayarak iki bayt kaydedebilirim ;.

Haskell, 178 bayt

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

Hiçbir şey fantezi. Programın tüm karakterleri değişmez bir listededir (Dize). Frekanslar da öyle. Her iki listeyi de sıkıştırın ve yazdırın. Çıktı:

  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

Doğrudan sürüm:

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" sayıları toplamak için sadece bir uğraş faktörüdür. DartPad üzerinde bakın / çalıştırın .

Orijinal: Standart quine taktiği ve Dart'ın fonksiyon isimleri iyi golf oynamak için biraz fazla.

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'de görün / çalıştırın .

Haskell , 146 bayt

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]

Çevrimiçi deneyin!

Çıktı:

  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

(Artı ek bir yeni satır)

Açıklama:

Kod

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

Burada "<code>", program kodunun ".

aboşluktan başlayarak ascii karakterlerinden geçer. sum[2|b<-show"<code>",a==b]karakterin dizede ne sıklıkta göründüğünü sayar ve her bir oluşum iki kez sayılır. a:" "++show sgeçerli karakterin bir dizesini, bir boşluğu ve karakter sayısını oluşturur. Son olarak mapM putStrLnlistedeki her bir dizgeyi sondaki bir yeni satırla yazdırır.

En zor kısmı "doğru sayımı elde etmekti . Sadece kullanmak b<-"<code>"sıfır tırnak işareti sayar çünkü dizede hiçbiri yoktur. Kullanımı , dize bir ön ve son show"<code>"ekleyerek "dört sayıyla sonuçlanır. Bu yüzden (kısa) kadar yerine, kod iki ek tırnak işareti koymak zorunda a:' ':show skullandığım a:" "++show s.