코드는 키보드에서 입력으로 문자열을 가져와야합니다.

The definition of insanity is quoting the same phrase again and again and not expect despair.

출력은 다음과 같아야합니다 (특정 순서로 정렬되지 않음).

  :  15
. :  1
T :  1
a :  10
c :  1
e :  8
d :  4
g :  3
f :  2
i :  10
h :  3
m :  1
o :  4
n :  10
q :  1
p :  3
s :  5
r :  2
u :  1
t :  6
y :  1
x :  1

모든 ASCII 문자 수 유니 코드는 요구 사항이 아니며 공백, 따옴표 등이 필요하며 입력은 키보드 / 상수가 아닌 속성에서 가져와야합니다. 속성, 출력은 위의 예와 같이 각 문자 다음에 새 줄로 인쇄되어야합니다. 문자열로 반환해서는 안됩니다 정도, 해시 맵 / 사전 등으로 덤프 x : 1및 x: 1확인 있지만 {'x':1,...및 x:1수 없습니다.

Q : stdin을 작성하고 stdout을 작성하는 기능 또는 완전한 프로그램?
A : 코드는 표준 입력을 사용하여 입력을 받고 표준 출력을 통해 결과를 표시하는 프로그램이어야합니다.

스코어 보드 :

가장 짧은 전체 : 5 바이트

가장 짧은 전체 : 7 바이트

APL (Dyalog Unicode) , 5 바이트 ^SBCS

전체 프로그램 본문. STDIN에서 문자열을 프롬프트하고 개행으로 구분 된 테이블을 STDOUT에 인쇄합니다. 가장 왼쪽 열은 입력 문자이며 개수는 문자와 구분 된 가장 큰 숫자를 단일 공백으로 오른쪽 정렬합니다.

,∘≢⌸⍞

온라인으로 사용해보십시오!

⍞ STDIN에서 텍스트 입력을위한 프롬프트

⌸ 이루어진 만들 키 '표
 , 유일한 요소는 다음
 ∘ 에 의해
 ≢ 그 발생 지표의 탈리 (즉 그 발생 횟수)

PHP-68 (또는 39) 바이트

<?foreach(count_chars(fgets(STDIN),1)as$k=>$v)echo chr($k)." : $v
";

예제 텍스트의 출력 :

  : 15
. : 1
T : 1
a : 10
c : 1
d : 4
e : 8
f : 2
g : 3
h : 3
i : 10
m : 1
n : 10
o : 4
p : 3
q : 1
r : 2
s : 5
t : 6
u : 1
x : 1
y : 1

정확한 출력이 필요하지 않으면 39 바이트에서 작동 합니다 .

<?print_r(count_chars(fgets(STDIN),1));

샘플 출력 :

Array
(
    [32] => 15
    [46] => 1
    [84] => 1
    [97] => 10
    [99] => 1
    [100] => 4
    [101] => 8
    [102] => 2
    [103] => 3
    [104] => 3
    [105] => 10
    [109] => 1
    [110] => 10
    [111] => 4
    [112] => 3
    [113] => 1
    [114] => 2
    [115] => 5
    [116] => 6
    [117] => 1
    [120] => 1
    [121] => 1
)

여기서 각 숫자 색인은 그것이 나타내는 문자의 서수 값을 나타냅니다.

문제 상태를 곧 정확하게 수행하는 내장 함수를 사용하는 것이 곧 허용되지 않을 것입니다.

k ( 8 7)

#:'=0:0

예

k)#:'=:0:0
The definition of insanity is quoting the same phrase again and again and not expect despair.
T| 1
h| 3
e| 8
 | 15
d| 4
f| 2
i| 10
n| 10
t| 6
o| 4
s| 5
a| 10
y| 1
q| 1
u| 1
g| 3
m| 1
p| 3
r| 2
x| 1
c| 1
.| 1

편집 : 7 / H까지, Aaron Davies

설명

키보드에서 문자열을 가져옵니다.

k)0:0
text
"text"

고유 한 요소를 그룹화하고 키를 포함하는 맵을 고유 한 문자로 표시하고 값은 고유 한 요소가 발생하는 인덱스입니다.

k)=0:0
text
t| 0 3
e| ,1
x| ,2

이제 맵에서 각 항목의 값을 계산하십시오.

k)#:'=0:0
text
t| 2
e| 1
x| 1

GNU 핵심 유틸리티 -29 22 20 자 (53 형식)

Wumpus의 개선 (20 자) :

fold -1|sort|uniq -c

반딧불의 개선 (22 자) :

grep -o .|sort|uniq -c

joeytwiddle의 원본 (29 자) :

sed 's+.+\0\n+g'|sort|uniq -c

원래 sed각 문자 뒤에 줄 바꿈을 추가하는 데 사용 했습니다. Firefly 는 일치하는 모든 패턴을 자체 라인에 표시하기 grep -o .때문에으로 개선되었습니다 -o. Wumpus는 fold -1대신 사용하여 추가 개선을 지적했습니다 . 잘 하셨어요!

uniq 정렬 된 목록에만 적용되지만 실제 작업은 수행합니다.

출력 형식이 해당 질문의 예와 정확히 일치하지 않습니다. 이를 위해서는 최종 실행이 필요합니다sed인수를 바꾸려면 . (Jan Dvorak의 질문에 대한 답변을 기다리는 것이 이것이 필요한지 ...)

sed로 다시 포맷하는 것은 또 다른 33 자 "단지"입니다! ( 합계 53 )

|sed 's/ *\(.*\) \(.\)/\2 :  \1/'

Awk는 25 자만 추가하는 동안 거의 작업을 수행 할 수 있지만 첫 번째 공백은 숨 깁니다. 바보 같은!

|awk '{print $2" :  "$1}'

재 포맷 단계에서 개선이 가능한지 궁금합니다 ...

루비 1.9.3 : 53 자

(@shiva와 @daneiro의 의견을 바탕으로 함)

gets.split("").uniq.map{|x|puts x+" : #{$_.count x}"}

샘플 실행 :

bash-4.1$ ruby -e 'a=gets;a.split("").uniq.map{|x|puts"#{x} : #{a.count x}"}' <<< 'Hello world'
H : 1
e : 1
l : 3
o : 2
  : 1
w : 1
r : 1
d : 1

 : 1

루비 : 44 자

출력 형식을 고려하지 않은 경우 :

s=Hash.new 0;gets.chars{|c|s[c]+=1};pp s

샘플 실행 :

bash-4.1$ ruby -rpp -e 's=Hash.new 0;gets.chars{|c|s[c]+=1};pp s' <<< 'Hello, world!'
{"H"=>1,
 "e"=>1,
 "l"=>3,
 "o"=>2,
 ","=>1,
 " "=>1,
 "w"=>1,
 "r"=>1,
 "d"=>1,
 "!"=>1,
 "\n"=>1}

파이썬 3:76 자

76

import collections as c
for x,y in c.Counter(input()).items():print(x,':',y)

44

(같은 문자를 여러 번 인쇄하십시오 . 유효한 버전 은 Wasi 의 답변을 참조하십시오 )

a=input()
for x in a:print(x,':',a.count(x))

펄 6 : 21 자

.say for get.comb.Bag

(REPL)
get.comb.Bag에 대한 .say
광기의 정의는 동일한 문구를 반복해서 인용하며 절망을 기대하지 않습니다.
"T"=> 1
"h"=> 3
"e"=> 8
""=> 15
"d"=> 4
"f"=> 2
"i"=> 10
"n"=> 10
"t"=> 6
"o"=> 4
"s"=> 5
"a"=> 10
"y"=> 1
"q"=> 1
"u"=> 1
"g"=> 3
"m"=> 1
"p"=> 3
"r"=> 2
"x"=> 1
"c"=> 1
"." => 1

APL (15)

M,⍪+⌿Z∘.=M←∪Z←⍞

당신이 정말로 필요하면 :, 그건 19 (그러나 그것을 포함하지 않는 다른 사람이있다)

M,':',⍪+⌿Z∘.=M←∪Z←⍞

산출:

      M,⍪+⌿Z∘.=M←∪Z←⍞
The definition of insanity is quoting the same phrase again and again and not expect despair. 
T  1
h  3
e  8
  16
d  4
f  2
i 10
n 10
t  6
o  4
s  5
a 10
y  1
q  1
u  1
g  3
m  1
p  3
r  2
x  1
c  1
.  1

R, 30 자

table(strsplit(readline(),""))

사용법 예 :

> table(strsplit(readline(),""))
The definition of insanity is quoting the same phrase again and again and not expect despair.

    .  a  c  d  e  f  g  h  i  m  n  o  p  q  r  s  t  T  u  x  y 
15  1 10  1  4  8  2  3  3 10  1 10  4  3  1  2  5  6  1  1  1  1 

펄 5, 54 자

map{$h{$_}++}split//,<>;print"$_ : $h{$_}\n"for keys%h

자바 스크립트

1. 66 53 바이트 :

   prompt(a={}).replace(/./g,function(c){a[c]=-~a[c]}),a
   

2. 69 56 바이트 :

   b=prompt(a={});for(i=b.length;i--;){a[b[i]]=-~a[b[i]]};a
   

3. 78 65 바이트 :

   prompt().split('').reduce(function(a,b){return a[b]=-~a[b],a},{})
   

주의 : 모든 경우에 삭제 된 바이트 수 console.log()는 콘솔에서 실행될 경우 무의미한 추가 호출을 나타냅니다. 빅 덕분에 @imma 와 큰 캐치 -~a[b]와 prompt(a={}). 이것은 확실히 더 많은 바이트를 절약했습니다.

파이썬 2, 올바르게 (58)

s=raw_input()
for l in set(s):print l+" : "+str(s.count(l))

산출:

python count.py
The definition of insanity is quoting the same phrase again and again and not expect despair.
  : 15
. : 1
T : 1
a : 10
c : 1
e : 8
d : 4
g : 3
f : 2
i : 10
h : 3
m : 1
o : 4
n : 10
q : 1
p : 3
s : 5
r : 2
u : 1
t : 6
y : 1
x : 1

파이썬 2, 치타 스타일 (41)

s=input()
print {l:s.count(l) for l in s}

산출:

python count.py
"The definition of insanity is quoting the same phrase again and again and not expect despair."
{' ': 15, '.': 1, 'T': 1, 'a': 10, 'c': 1, 'e': 8, 'd': 4, 'g': 3, 'f': 2, 'i': 10, 'h': 3, 'm': 1, 'o': 4, 'n': 10, 'q': 1, 'p': 3, 's': 5, 'r': 2, 'u': 1, 't': 6, 'y': 1, 'x': 1}

Mathematica, 61 바이트

Map[{#[[1]], Length@#} &, Gather@Characters[Input[]]] // TableForm

그런 다음이 대화 상자가 나타납니다.

샘플 문장의 경우 출력으로 생성

파이썬 3, 49

Evuez의 아이디어 훔치기

t=input()
for i in set(t):print(i,':',t.count(i))

입력:

The definition of insanity is quoting the same phrase again and again and not expect despair.

산출:

  :  15
. :  1
T :  1
a :  10
c :  1
e :  8
d :  4
g :  3
f :  2
i :  10
h :  3
m :  1
o :  4
n :  10
q :  1
p :  3
s :  5
r :  2
u :  1
t :  6
y :  1
x :  1

자바 스크립트 (69 68 자) :

s문자열을 보유 할 것으로 예상 됩니다.

_={};for(x in s)_[a=s[x]]=-~_[a];for(x in _)console.log(x+': '+_[x])

이것은 새로운 규칙을 완벽하게 따릅니다.

참고 : 표준 객체 프로토 타입에 사용자 정의 속성이없는 깨끗한 환경을 가정합니다.

편집 : 1 자 미만!

콘솔 출력 :

T: 1
h: 3
e: 8
 : 15
d: 4
f: 2
i: 10
n: 10
t: 6
o: 4
s: 5
a: 10
y: 1
q: 1
u: 1
g: 3
m: 1
p: 3
r: 2
x: 1
c: 1
.: 1

기존 답변 (44 자) :

r={};[].map.call(s,function(e){r[e]=-~r[e]})

규칙이 변경되기 전에 유효했습니다.

r 출력을 포함합니다.

하스켈, 93

import Data.List
main=getLine>>=mapM(\s->putStrLn$[head s]++" : "++show(length s)).group.sort

PowerShell (49)

[char[]](read-host)|group|%{$_.Name+":"+$_.Count}

C 번호 (178 개 220 문자)

@Spongeman의 의견을 바탕으로 약간 변경했습니다.

using C=System.Console;using System.Linq;class P{static void Main()
{C.WriteLine(string.Join("\n",C.ReadLine().GroupBy(x=>x)
.OrderBy(x=>x.Key).Select(g=>g.Key+":"+g.Count())));}}

Line breaks added for readability, my first feeble attempt at code golf! :)

class P {static void Main(){var d=new Dictionary<char,int>();
Console.ReadLine().ToList().ForEach(x=>{ if(d.ContainsKey(x))
{d[x]++;}else{d.Add(x,1);}});Console.WriteLine(string
.Join("\n",d.Keys.Select(x=>x+":" +d[x])));}}

클리핑 , 19 자

梴要⓶銻꾠⓷❸虛變梴❶⓺減負겠⓸⓸終丟

산출

T:1
h:3
e:8
 :15
d:4
f:2
i:10
n:10
t:6
o:4
s:5
a:10
y:1
q:1
u:1
g:3
m:1
p:3
r:2
x:1
c:1
.:1

의 주위에 공백이 필요한 :경우로 변경 꾠하여 긃똠20 자로 만드십시오.

설명

Get length of input string.
梴
Stack is now [ input, length ]
While {
要
    Get first character of string and push ":"
    ⓶銻꾠
    Stack is now [ length, input, firstchar, ":" ]
    Replace all occurrences of that character with empty string
    ⓷❸虛變
    Stack is now [ length, firstchar, ":", reducedinput ]
    Get the length of that, calculate difference to previous length, push "\n"
    梴❶⓺減負겠
    Stack is now [ firstchar, ":", reducedinput, newlength, diff, "\n" ]
    Move the input string and length back up, leaving output below it
    ⓸⓸
    Stack is now [ firstchar, ":", diff, "\n", reducedinput, newlength ]
                   `------------------------'                `-------'
                   Every iteration of the               The length provides
                   While loop generates                 the While loop's
                   a bit like this                      terminating condition
} End While
終
Discard the length which is now 0
丟

F # ( 규정 된 포맷팅을 사용한 66 59 49, 72)

let f s=s|>Seq.countBy(id)|>Seq.iter(printfn"%A")

산출:

> f The definition of insanity is quoting the same phrase again and again and not expect despair.
(' ', 15)
('.', 1)
('T', 1)
('a', 10)
('c', 1)
('d', 4)
('e', 8)
('f', 2)
('g', 3)
('h', 3)
('i', 10)
('m', 1)
('n', 10)
('o', 4)
('p', 3)
('q', 1)
('r', 2)
('s', 5)
('t', 6)
('u', 1)
('x', 1)
('y', 1)

규정 된 형식을 사용하면 다음과 같습니다.

let f s=s|>Seq.countBy(id)|>Seq.iter(fun(a,b)->printfn"\"%c\" :  %d"a b)

매스 매 티카, 34 29 바이트

다른 Mathematica 답변이 왜 그렇게 복잡한 지 잘 모르겠습니다 ...;)

Grid@Tally@Characters@Input[]

배쉬 ( 20 15 자)

 ptx -S.|uniq -c
 10                                        a
  1                                        c
  4                                        d
  8                                        e
  2                                        f
  3                                        g
  3                                        h
 10                                        i
  1                                        m
 10                                        n
  4                                        o
  3                                        p
  1                                        q
  2                                        r
  5                                        s
  6                                        t
  1                                        T
  1                                        u
  1                                        x
  1                                        y

ASCII 인코딩 지원

배쉬 (23 자) :

xxd -p -c1|sort|uniq -c

  1 0a
 15 20
  1 2e
  1 54
 10 61
  1 63
  4 64
  8 65
  2 66
  3 67
  3 68
 10 69
  1 6d
 10 6e
  4 6f
  3 70
  1 71
  2 72
  5 73
  6 74
  1 75
  1 78
  1 79

지원되지 않는 ASCII 형식

자바 8, 273 253 249 246 239 200 바이트

interface I{static void main(String[]a){int m[]=new int[999],i=0;for(int c:new java.util.Scanner(System.in).nextLine().getBytes())m[c]++;for(;++i<999;)if(m[i]>0)System.out.printf("%c: %d%n",i,m[i]);}}

@Poke 덕분에 -24 바이트 . @ OlivierGrégoire
덕분에 -7 바이트 .

설명:

여기에서 시도하십시오.

interface I{                        // Class
  static void main(String[]a){      //  Mandatory main-method
    int m[]=new int[999],           //  Integer-array to count the occurrences
        i=0;                        //  Index-integer, starting at 0
    for(int c:new java.util.Scanner(System.in).nextLine().getBytes())
                                    //   Loop over the input as bytes:
      m[c]++;                       //    Increase the occurrence-counter of the char by 1
    for(;++i<999;)                  //   Loop over the array:
      if(m[i]>0)                    //    If the current character occurred at least once:
        System.out.print("%c: %d%n",//     Print with proper formatting:
         i,                         //      The character
         m[i]);}}                   //      and the occurrence-count

Powershell, 63

$a=@{};[char[]](read-host)|%{$a[$_]++};$a.Keys|%{"$_ :"+$a[$_]}

Windows Command Script - 72 Bytes

set/p.=
:a
set/a\%.:~,1%=\%.:~,1%+1
set.=%.:~1%
%.%goto:b
goto:a
:b
set\

Outputs:

\=15 (space)
\.=1
\a=10
\c=1
\d=4
\e=8
\f=2
\g=3
\h=3
\i=10
\m=1
\n=10
\o=4
\p=3
\q=1
\r=2
\s=5
\T=7
\u=1
\x=1
\y=1

J, 23 chars

(~.;"0+/@|:@=)/:~1!:1]1

Slightly different output format (line 2 is stdin):

   (~.;"0+/@|:@=)/:~1!:1]1
Mississippi
┌─┬─┐
│M│1│
├─┼─┤
│i│4│
├─┼─┤
│p│2│
├─┼─┤
│s│4│
└─┴─┘

J, 22 characters

(~.;"0+/@(=/~.))1!:1]1

Example:

   (~.;"0+/@(=/~.))1!:1]1
The definition of insanity is quoting the same phrase again and again and not expect despair.
+-+--+
|T|1 |
+-+--+
|h|3 |
+-+--+
|e|8 |
+-+--+
| |15|
+-+--+
|d|4 |
+-+--+
|f|2 |
+-+--+
|i|10|
+-+--+
|n|10|
+-+--+
|t|6 |
+-+--+
|o|4 |
+-+--+
|s|5 |
+-+--+
|a|10|
+-+--+
|y|1 |
+-+--+
|q|1 |
+-+--+
|u|1 |
+-+--+
|g|3 |
+-+--+
|m|1 |
+-+--+
|p|3 |
+-+--+
|r|2 |
+-+--+
|x|1 |
+-+--+
|c|1 |
+-+--+
|.|1 |
+-+--+

C#

string str = Console.ReadLine(); // Get Input From User Here
char chr;
for (int i = 0; i < 256; i++)
{
    chr = (char)i; // Use The Integer Index As ASCII Char Value --> Convert To Char
    if (str.IndexOf(chr) != -1) // If The Current Char Exists In The Input String
    {
        Console.WriteLine(chr + " : " + str.Count(x => x == chr)); // Count And Display
    }
}
Console.ReadLine(); // Hold The Program Open.

In Our Case, If The Input Will Be "The definition of insanity is quoting the same phrase again and again and not expect despair."

The Output Will Be:

  : 15
. : 1
T : 1
a : 10
c : 1
d : 4
e : 8
f : 2
g : 3
h : 3
i : 10
m : 1
n : 10
o : 4
p : 3
q : 1
r : 2
s : 5
t : 6
u : 1
x : 1
y : 1

C#: 129

This is Avivs answer but shorter:

var s=Console.ReadLine();for(int i=0;i<256;i++){var ch=(char)i;Console.Write(s.Contains(ch)?ch+":"+s.Count(c=>c==ch)+"\r\n":"");}

This is mine:

C#: 103

foreach(var g in Console.ReadLine().OrderBy(o=>o).GroupBy(c=>c))Console.WriteLine(g.Key+":"+g.Count());

Python 2 (90 chars)

import collections as c;print"\n".join("%s %s"%i for i in c.Counter(raw_input()).items())

Output when run on its own source:

  8
" 4
% 3
) 4
( 4
. 3
; 1
C 1
\ 1
_ 1
a 2
c 4
e 3
f 1
i 9
j 1
m 2
l 2
o 6
n 7
p 3
s 5
r 5
u 2
t 6
w 1