Problem:
Counting Characters Write a program which counts and reports the number of each alphabetical letter. Ignore the case of characters. Input A sentence in English is given in several lines. Output Prints the number of alphabetical letters in the following format: a : The number of 'a' b : The number of 'b' c : The number of 'c' .
  .
z : The number of 'z'  Constraints  The number of characters in the sentence < 1200  Sample Input This is a pen. Sample Output a : 1
b : 0
c : 0
d : 0
e : 1
f : 0
g : 0
h : 1
i : 2
j : 0
k : 0
l : 0
m : 0
n : 1
o : 0
p : 1
q : 0
r : 0
s : 2
t : 1
u : 0
v : 0
w : 0
x : 0
y : 0
z : 0

Solution (Python):
import sys

def count_chars(str):
    lst = [0 for x in range(26)]
    a = ord("a")

    for c in str:
        n = ord(c) - a
        if 0 <= n < 26:
            lst[n] += 1

    return lst

a = ord("a")
str = ""

for line in sys.stdin:
    str += " " + line.lower()

lst = count_chars(str)

for i, x in enumerate(lst):
        print(chr(i+a), ":", x)

Solution (Python):

count = {}
for i in range(26):
    count[chr(ord('a') + i)] = 0


list = []
try:
    while True:
        inp = input().lower()
        if inp == "":
            break
        list += inp
except EOFError:
    pass


for i in range(len(list)):
    for j in range(len(list[i])):
        if list[i][j] in count.keys():
            count[list[i][j]] += 1

for k, v in count.items():
    print(k,":",v)

Solution (Python):
import sys
from collections import Counter
from string import ascii_lowercase

counter = Counter()
for s in sys.stdin:
    counter.update(s.lower())

for c in ascii_lowercase:
    print(f'{c} : {counter[c]}')

Solution (Python):
ctlist = [0 for i in range(26)]
str1 = open(0).read()

for i in str1:
    if i.isupper():
        ctlist[ord(i) - ord('A')] += 1
    elif i.islower():
        ctlist[ord(i) - ord('a')] += 1

for i in range(26):
    print(chr(i + ord('a')), ":", ctlist[i])

Solution (Python):
s = ''
while True:
    try:
        i = input()
        s += i
    except:
        break

letters = 'abcdefghijklmnopqrstuvwxyz'

for l in letters:
    print('{0} : {1}'.format(l, s.lower().count('{}'.format(l))))

Solution (Python):
import sys

table = [0]*26
 
letters = "abcdefghijklmnopqrstuvwxyz"

sentence = sys.stdin.read()


for A in sentence:
    index = int(0)
    
    for B in letters:

        if A == B or A == B.upper():
            table[index]  += 1
            break
        index += 1


for i in range(len(letters)):

    print("%s : %d" %( letters[i], table[i]) )

Solution (Python):
inp=""

while True:
    try:
        in1 = input()
        inp =inp + in1
    except EOFError:
        break

s = "abcdefghijklmnopqrstuvwxyz"
l = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
count=[0]*26

for i in inp:
    if i in s:
        count[s.index(i)]+=1
    if i in l:
        count[l.index(i)]+=1

for i in range(len(count)):
    print(s[i]+" : "+str(count[i]))

Solution (Python):
s = ''
while True:
    try:
        s += input().lower()
    except EOFError:
        break
alpha = 'abcdefghijklmnopqrstuvwxyz'
c = {}
for _ in alpha:
    c[_] = 0
for ch in s:
    
    if ch.isalpha():
        c[ch] += 1
        
for key in c:
    print(key,':', c[key])

Solution (Python):
import sys
moji = sys.stdin.read().lower()
for i in range(97, 97+26):
    print(f'{chr(i)} : {moji.count(chr(i))}')

Solution (Python):
n = ""
while True:
    try:
        n += input().lower()
    except:
        break
for i in range(97, 97+26):
    print(chr(i),":",n.count(chr(i)),sep=" ")

Solution (Python):
di = { chr(i):0 for i in range(97,97+26)}
try:
    while 1:
        l = [x for x in input().lower()]
        for i in range(len(l)):
            if l[i] in di:
                di[l[i]] += 1
except EOFError:
    pass
for a, b in di.items():
    print(a ,":" , b)

Solution (Python):
str = ''
count = {}
for c in [chr(i) for i in range(97, 123)]:
  count[c] = 0

while True:
  try:
    tmp = input()
    str += tmp
  except:
    break

for char in str:
  for c in count:
    if char.upper() == c.upper():
      count[c] += 1

for c, n in count.items():
  print(c, ':', n)

Solution (Python):
import collections

sentence = ""
while True:
  try:
    line = input().lower()
    sentence += line
  except EOFError:
    break

c = collections.Counter(sentence)

print("a : {}".format(c['a']))
print("b : {}".format(c['b']))
print("c : {}".format(c['c']))
print("d : {}".format(c['d']))
print("e : {}".format(c['e']))
print("f : {}".format(c['f']))
print("g : {}".format(c['g']))
print("h : {}".format(c['h']))
print("i : {}".format(c['i']))
print("j : {}".format(c['j']))
print("k : {}".format(c['k']))
print("l : {}".format(c['l']))
print("m : {}".format(c['m']))
print("n : {}".format(c['n']))
print("o : {}".format(c['o']))
print("p : {}".format(c['p']))
print("q : {}".format(c['q']))
print("r : {}".format(c['r']))
print("s : {}".format(c['s']))
print("t : {}".format(c['t']))
print("u : {}".format(c['u']))
print("v : {}".format(c['v']))
print("w : {}".format(c['w']))
print("x : {}".format(c['x']))
print("y : {}".format(c['y']))
print("z : {}".format(c['z']))

Solution (Python):
import sys

cnt = {}

for line in sys.stdin:
    for letter in line:
        if letter.isalpha():
            c = letter.lower()
            cnt[c] = cnt.get(c, 0)+1
            
for i in range(26):
    c = chr(ord("a")+i)
    print(c, ":", cnt.get(c, 0), sep=" ")

Solution (Python):
count=[0]*26
while True:
    try:
        s=input().lower()
        for i in s:
            if 96<ord(i)<124:
                count[ord(i)-97]+=1
    except:
        break
for i in range(26):
    print(f"{chr(i+97)} : {count[i]}")

Solution (Python):

import sys
ans = {"a":0,"b":0,"c":0,"d":0,"e":0,"f":0,"g":0,"h":0,
    "i":0,"j":0,"k":0,"l":0,"m":0,"n":0,"o":0,"p":0,
    "q":0,"r":0,"s":0,"t":0,"u":0,"v":0,"w":0,"x":0,
    "y":0,"z":0}
lines = sys.stdin.readlines()
for line in lines:
    chars = list(line)
    for ch in chars:
        if ch == 'A' or ch =='a':
            ans["a"] += 1
        elif ch == 'B' or ch == 'b':
            ans["b"] += 1
        elif ch == 'C' or ch == 'c':
            ans["c"] += 1
        elif ch == 'D' or ch == 'd':
            ans["d"] += 1
        elif ch == 'E' or ch == 'e':
            ans["e"] += 1
        elif ch == 'F' or ch == 'f':
            ans["f"] += 1
        elif ch == 'G' or ch == 'g':
            ans["g"] += 1
        elif ch == 'H' or ch == 'h':
            ans["h"] += 1
        elif ch == 'I' or ch == 'i':
            ans["i"] += 1
        elif ch == 'J' or ch == 'j':
            ans["j"] += 1
        elif ch == 'K' or ch == 'k':
            ans["k"] += 1
        elif ch == 'L' or ch == 'l':
            ans["l"] += 1
        elif ch == 'M' or ch == 'm':
            ans["m"] += 1
        elif ch == 'N' or ch == 'n':
            ans["n"] += 1
        elif ch == 'O' or ch == 'o':
            ans["o"] += 1
        elif ch == 'P' or ch == 'p':
            ans["p"] += 1
        elif ch == 'Q' or ch == 'q':
            ans["q"] += 1
        elif ch == 'R' or ch == 'r':
            ans["r"] += 1
        elif ch == 'S' or ch == 's':
            ans["s"] += 1
        elif ch == 'T' or ch == 't':
            ans["t"] += 1
        elif ch == 'U' or ch == 'u':
            ans["u"] += 1
        elif ch == 'V' or ch == 'v':
            ans["v"] += 1
        elif ch == 'W' or ch == 'w':
            ans["w"] += 1
        elif ch == 'X' or ch == 'x':
            ans["x"] += 1
        elif ch == 'Y' or ch == 'y':
            ans["y"] += 1
        elif ch == 'Z' or ch == 'z':
            ans["z"] += 1

for al, count in ans.items():
    print(al + " : " + str(count))

Solution (Python):
from string import ascii_lowercase
from collections import defaultdict


dic = defaultdict(int)

    
while True:
    try:
        for st in input():
            dic[st.lower()] += 1
        

    except EOFError:
        break

for a in ascii_lowercase:
    print(f'{a} : {dic[a]}')

Solution (Python):
cnt = [0 for i in range(26)]
while True:
    try:
        s = input()
    except:
        break
    if s == '':
        break
    for cdfix in range(26):
        cnt[cdfix] += s.count(chr(ord('a') + cdfix))
        cnt[cdfix] += s.count(chr(ord('A') + cdfix))
for r in range(26):
    print('{} : {}'.format(chr(ord('a') + r), cnt[r]))

Solution (Python):
str = ""
upperStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
lowerStr = "abcdefghijklmnopqrstuvwxyz"
count = [0] * 26

while True:
        try:
                str += input()
        except:
                break

for n in range(len(str)):
        for i in range(26):
                if str[n] == upperStr[i] or str[n] == lowerStr[i]:
                        count[i] += 1
                        break

for i in range(26):
        print(lowerStr[i], ":", count[i])

Solution (Python):
sum = [0] * 26

sent = open(0).read()
for c in sent:
    if ord('a') <= ord(c) and ord(c) <= ord('z'):
        sum[ord(c) - ord('a')] += 1
    elif ord('A') <= ord(c) and ord(c) <= ord('Z'):
        sum[ord(c) - ord('A')] += 1

for x in range(26):
    print(chr(x + ord('a')), ":", sum[x])

Solution (Python):
import sys

string = 'abcdefghijklmnopqrstuvwxyz'
_list = []
for l in sys.stdin:
    _list.append(l)
for i in string:
    print(i + ' : ' + str(','.join(_list).lower().count(i)))

Solution (Python):
import sys

alphabet = {"a": 0, "b": 0, "c": 0, "d": 0, "e": 0, "f": 0, "g": 0, "h": 0, "i": 0, "j": 0, "k": 0, "l": 0, "m": 0,
            "n": 0, "o": 0, "p": 0, "q": 0, "r": 0, "s": 0, "t": 0, "u": 0, "v": 0, "w": 0, "x": 0, "y": 0, "z": 0}
text = sys.stdin.read().lower()
for character in text:
    if character.lower() in alphabet.keys():
        alphabet[character.lower()] += 1

for key in alphabet.keys():
    print("%s : %i" % (key, alphabet[key]))

Solution (Python):
s1 = ""
try:
	while True:
		t = input()
		if t == "":
			break
		s1 += t
except EOFError:
	pass
n = [0] * 26
s = s1.lower()
for i in range(len(s)):
	j = ord(s[i]) - 97
	if j >= 0 and j < 26:
		n[j] += 1
for i in range(26):
	print('%s : %d' %(chr(i + 97), n[i]))

Solution (Python):
import sys

ch = (chr(i) for i in range(97, 97+26))
sentence = sys.stdin.read().lower()
for c in ch:
    print(c, ':', sentence.count(c))

Solution (Python):
import sys

S = ""

while True:
    try:
        s = input()
        S += s.lower()
        if s == "":
            break
    except:
        break

dic = dict()

for c in S:
    dic[c] = dic[c] + 1 if c in dic else 1

for i in range(ord("z") - ord("a") + 1):
    c = chr(i + ord("a"))
    v = dic[c] if c in dic else 0

    print("{} : {}".format(c, v))

Solution (Python):
import sys
str = sys.stdin.read().lower()
for i in range(97, 97+26):
    print("%s : %s" % (chr(i), str.count(chr(i))))

Solution (Python):
import sys
 
s = ""
for line in sys.stdin:
    s+=line
s=s.lower()
for str in list("abcdefghijklmnopqrstuvwxyz"):
    print(*[str,":",s.count(str)])

Solution (Python):
alp = list("abcdefghijklmnopqrstuvwxyz")
ALP = list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
tex = []
dic2 = dict(zip(ALP,alp))
while(1):
    try:
        t = list(input())
        tex.extend(t)
    except EOFError:
        break
dic = dict(zip(alp,[0 for i in range(26)]))
for i in tex:
    if i in alp:
        dic[i] += 1
    elif i in ALP:
        dic[dic2[i]] += 1
for i in alp:
    print("{} : {}".format(i,dic[i]))

Solution (Python):
countResultList = []
index = 0
inStrNum = 0
inStrLowList = []
inStr = str()
sample = 0
try:
    while True:
        sample +=1
        if inStrNum < 10 or sample < 1200:
            inStr = input()
            inStrLowList.append(inStr.lower())
            inStrNum += len(inStr)
        else:
            break
except EOFError:
    pass
inStrLow = str(inStrLowList)
for alphabet in range(ord("a"),ord("z")+1):
    countResultList.append(inStrLow.count(chr(alphabet)))
    index += 1
indexOrder = 0
for alphabet in range(ord("a"),ord("z")+1):
    print("%s : %s"%(chr(alphabet),countResultList[indexOrder]))
    indexOrder += 1

Solution (Python):
import sys
from collections import Counter
c=Counter(sys.stdin.read().lower())
for i in [chr(ord('a') + i) for i in range(26)]:
    print('{} : {}'.format(i,c[i]))

Solution (Python):
import sys

occurrences = [0] * 26

for c in sys.stdin.read():
    al = c.lower()
    if 'a' <= al <= 'z':
        occurrences[ord(al) - ord('a')] += 1

for i, oc in enumerate(occurrences):
    print(f"{chr(ord('a') + i)} : {oc}")

Solution (Python):



import sys
from string import ascii_lowercase
from collections import Counter

in_lines = ''.join(sys.stdin.readlines())
counts = Counter(in_lines.lower())

for key in ascii_lowercase:
    print(key, ':', counts[key])

Solution (Python):
alphabet=list("abcdefghijklmnopqrstuvwxyz")
bun=""
while 1:
    try:
        string=input().lower()
        bun+=str(string)
    except:
        break
    
for i in range(len(alphabet)):
    alp=alphabet[i]
    print(alp,":",bun.count(alp))

Solution (Python):
def get_input():
    while True:
        try:
            yield ''.join(input())
        except EOFError:
            break

s = list(get_input())

d = {char:0 for char in [chr(ord('a')+i) for i in range(26)]}
for line in s:
    for x in line.lower():
        if(x in d):
            d[x] += 1

for k in d:
    print(k + " : " + str(d[k]))

Solution (Python):
import sys
import string

sentence = sys.stdin.read().lower()
for c in string.ascii_lowercase:
    print('{} : {}'.format(c, sentence.count(c)))

Solution (Python):
import sys
from collections import defaultdict
alphabets = defaultdict(int)
lines = sys.stdin.readlines()
for line in lines:
    for ch in line.rstrip():
        if ch.isalpha():
            ch = ch.lower()
            alphabets[ch] += 1

for i in range(26):
    ch = chr(ord('a')+i)
    print(f'{ch} : {alphabets[ch]}')

Solution (Python):
alpha = 'abcdefghijklmnopqrstuvwxyz'
text = ''

while True:
    try:
        text += input().lower()
    except EOFError:
        break

for a in alpha:
    print('{} : {}'.format(a, text.count(a)))

Solution (Python):
import sys;s=sys.stdin.read().lower()
for c in map(chr,range(97,123)):print(c,':',s.count(c))

Solution (Python):
alpha = "abcdefghijklmnopqrstuvwxyz"
t = ""
while True:
    try:
        n  =  str(input()).lower()
    except EOFError:
        break
    t = t + n

for i in alpha:
    print (i,":",t.count(i))

Solution (Python):
import collections
import sys
def countString (str):
    alphalist = [chr(ord('a') + i) for i in range(26)] 
    strlist = list(str.lower())
    c = collections.Counter(strlist)
    for s in alphalist:
        print('{0} : {1}'.format(s, c[s]))

if __name__ == '__main__':
    mojiretsu = ""
    for line in sys.stdin:
        mojiretsu += line
    countString(mojiretsu)

Solution (Python):
import sys
l=sys.stdin.read().lower()
a=list("abcdefghijklmnopqrstuvwxyz")
for item in a:
    print(item,":",l.count(item))

Solution (Python):
alpha = "abcdefghijklmnopqrstuvwxyz"
string = ""
a = input().strip().lower()
try:
    while len(a) > 0:
        string +=a
        a = input().strip().lower()
except:
    pass

word_l = dict()
for a in alpha:
    word_l[a] = 0
for i in string: 
    if i in word_l:
        word_l[i] += 1
for val,ind in word_l.items():
    print("{} : {}".format(val,ind ))

Solution (Python):
import sys

s = ""
for line in sys.stdin:
    s += line

char = "abcdefghijklmnopqrstuvwxyz"

for c in char:
    n1 = s.count(c)
    n2 = s.count(c.upper())
    print(c + " : " + str(n1 + n2))

Solution (Python):
import sys
s=sys.stdin.read().lower()
for i in range(97,123):
    print(chr(i),':',s.count(chr(i)))

Solution (Python):
import sys

a_to_z = [chr(i) for i in range(ord('a'),ord('z')+1)]
s = sys.stdin.read()
lower_s = s.lower()

for chr in a_to_z:
    print('{} : {}'.format(chr,lower_s.count(chr)))

Solution (Python):
from collections import Counter
x="abcdefghijklmnopqrstuvwxyz"
X=list(x)
let=[]
while(1):
    try:
        A=input().split()
    except EOFError:
        break
    A="".join(A)
    let.append(A)
Let="".join(let)
Let=Let.lower()
count=Counter(Let)
for st in X:
    print(f"{st} : {count[st]}")

Solution (Python):
alphabet = [chr(i) for i in range(ord("a"), ord("z")+1)]
import collections
alphabet_d = collections.OrderedDict()
for a in alphabet:
    alphabet_d[a] = 0

import sys
S = sys.stdin.readlines()
for s in S:
    sl = s.lower()
    for c in sl:
        if c in alphabet:
            alphabet_d[c] += 1
for k, v in alphabet_d.items():
    print("{0} : {1}".format(k, v))

Solution (Python):
import sys
s=sys.stdin.read().lower()
for i in range(97,123):print(chr(i),':',s.count(chr(i)))

Solution (Python):



import sys


alphabet={chr(i) : 0 for i in range(97, 97+26)}
R=""
for text in sys.stdin:
    R += text.lower()
    
for j in R:
    if j in alphabet:
        alphabet[j] += 1

for alpha in sorted(alphabet.items(), key = lambda x: x[0]):
    print(" : ".join(list(map(str,alpha))))

Solution (Python):
from sys import stdin

cnt = {}
for line in stdin:
    for c in line:
        d = chr(ord(c)|0x20)
        if 'a'<=d<='z':
            cnt[d] = cnt.get(d, 0) + 1

for i in range(ord('z')-ord('a')+1):
    c = chr(ord('a')+i)
    print(c, ':', cnt.get(c, 0))

Solution (Python):
import sys

strn = []
for s in sys.stdin:
    strn.append(s)

strng = ''.join(strn).lower()

a = 'abcdefghijklmnopqrstuvwxyz'

strng_lower = strng.lower()

for i in range(26):
    print("{} : {}".format(a[i], strng_lower.count(a[i])))

Solution (Python):
result = []
for i in range(0, 26):
    result.append(0)

sentinel = "\r\n" 

while 1:
    try:
        str_in = input()
        for i in str_in:
            i = ord(i)
            if (i >= 65 and i <= 90):
                result[i - 65] += 1
            if (i >= 97 and i <= 122):
                result[i - 97] += 1
    except :
        break

for i in range(0, 26):
    print(chr(i + 97) + ' : ' + str(result[i]))

Solution (Python):
alphabet = 'a b c d e f g h i j k l m n o p q r s t u v w x y z'
alpList = list(map(str, alphabet.split()))
countList = [0] * 26
message = ''

while True:
    try:
        message += str(input()).lower()
    except:
        break
        
for i in range(len(message)):
    for j in alpList:
        if message[i] == j:
            countList[alpList.index(j)] += 1

for i in alpList:
    print(i + ' : ', end = '')
    print(countList[alpList.index(i)])

Solution (Python):
import sys, string

lines = sys.stdin.read().lower()
for x in string.ascii_lowercase:
    print('{} : {}'.format(x, lines.count(x)))

Solution (Python):
str = ""

while True:
    try:
        str += input().lower()
    except EOFError:
        break

for i in range(ord("a"), ord("z")+1):
    print(chr(i), ":", str.count(chr(i)))

Solution (Python):
sentence = ""
while True:
    try:
        sentence += input()
    except EOFError:
        break

sentence = sentence.lower()
for c in range(ord("a"), ord("z")+1):
    print("{} : {}".format(chr(c), sentence.count(chr(c))))

Solution (Python):
import sys

BIG_NUM = 2000000000
MOD = 1000000007
EPS = 0.000000001


table = [0]*26

letters = "abcdefghijklmnopqrstuvwxyz"
input_str = sys.stdin.read()

for A in input_str:
    index = 0
    for B in letters:
        if A == B or A == B.upper():
            table[index] += 1
            break
        index += 1

for i in range(len(letters)):
    print("%s : %d"%(letters[i],table[i]))

Solution (Python):
import sys

sentence = sys.stdin.read().lower()

alphabet = []
for i in range(26):
    alphabet.append(chr(ord('a') + i))

for j in alphabet:
    print(j, ':', sentence.count(j))

Solution (Python):
S  = ""
while True:
    try:
        S = S + input().lower()
    except: break



def count(arg1):
    count = S.count(arg1)+S.count(arg1.upper())
    print(arg1+" : ", end="")
    print(count)

count("a")
count("b")
count("c")
count("d")
count("e")
count("f")
count("g")
count("h")
count("i")
count("j")
count("k")
count("l")
count("m")
count("n")
count("o")
count("p")
count("q")
count("r")
count("s")
count("t")
count("u")
count("v")
count("w")
count("x")
count("y")
count("z")

Solution (Python):
count = [0 for _ in range(26)]

while True:
    try:
        s = input()
    except:
        break
    for i in range(len(s)):
        m = ord(s[i]) - ord('A')
        if m >= 0 and m < 26:
            count[m] += 1
        m = ord(s[i]) - ord('a')
        if m >= 0 and m < 26:
            count[m] += 1

for i in range(26):
    print(chr(i + ord('a')),":",count[i])

Solution (Python):
list1=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
list2=["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"]

list3=[0]*26
while True:
    try:
        S=input()
        for i in range(len(S)):
            for j in range(26):
                if S[i]==list1[j]:
                    list3[j]+=1
                if S[i]==list2[j]:
                    list3[j]+=1
        
    except EOFError:
        break
for k in range(26):
    print(list1[k]+" : "+str(list3[k]))

Solution (Python):
import sys

a = sys.stdin.readlines()
input = map(str, a)
lines = ','.join(input)
lines.replace('\n','')

i = 1
n = ord('a') - 1
m = ord('A') - 1
while n != ord('z'):
    n += 1
    m += 1
    counter = lines.count(chr(n)) + lines.count(chr(m))
    print('{} : {}'.format(chr(n),counter))

Solution (Python):
a=''
while True:
    try:
        str = input().lower()
        a+=str
    except:
        break
for i in range(97, 97 + 26):
    count = 0
    for j in a:
        if chr(i) == j:
            count += 1
    print(chr(i), ':', count)

Solution (Python):

import sys

if __name__ == '__main__':
    s = reduce(lambda a,b : a+b, sys.stdin).lower()

    for c in [chr(i) for i in range(0x61, 0x7b)]:
        print '{} : {}'.format(c, len(filter(lambda x: x==c, s)))

Solution (Python):
from string import ascii_lowercase
from collections import defaultdict
d = defaultdict(int)
s = ""
while True:
  try:
    s+=input()
  except EOFError:
    break
for ele in s:
  d[ele.lower()] += 1
for c in ascii_lowercase:
  print(c+" : "+str(d[c]))

Solution (Python):
sss = input().lower()
alphas = [chr(i) for i in range(97, 97+26)]
counter = [0 for _ in range(len(alphas))]
while True:
	for i, a in enumerate(alphas):
		counter[i] += sss.count(a)
	try: sss = input().lower()
	except EOFError:
		break
for i, num in enumerate(counter):
	print(alphas[i], ':', num)