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):
s = ""
try:
	while True:
		t = input()
		if t == "":
			break
		s += t
except EOFError:
	pass

s = str.lower("".join(s))

al_list = [chr(i) for i in range(97,97+26)]
ans = []

for i in range(len(s)):
    ans.append(s[i:i+1])

for i in range(26):
    if al_list[i] in ans:
        x = ans.count(al_list[i])
        print(al_list[i], ":", x)
    else:
        print(al_list[i], ":", 0)

Solution (Python):
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,
}

import sys

def main():
  sentence = ''

  for line in sys.stdin:
    for l in line:
      if l.lower() in alphabet:
        alphabet[l.lower()] += 1

  for key, value in alphabet.items():
    print('{} : {}'.format(key, value))

if __name__ == '__main__':
  main()

Solution (Python):
import sys
s=sys.stdin.read().lower()
for c in map(chr,range(ord('a'),ord('z')+1)):
    print(c,':',s.count(c))

Solution (Python):
import sys
cnt = [0]*26

for line in sys.stdin:
    for c in line:
        c_ord = ord(c)
        if 65<=c_ord<=90:
            cnt[c_ord-65] += 1
        elif 97<=c_ord<=122:
            cnt[c_ord-97] += 1
            
for i in range(26):
    print(chr(i+97),":",cnt[i])

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

for i in range(len(ref_list)):
    print('{0:s} : {1:d}'.format(ref_list[i], S.count(ref_list[i])))

Solution (Python):
alphabet = map(chr, range(97, 123))
s = []

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

for i in alphabet:
    print(i + ' : ' + str(s.count(i)))

Solution (Python):
import sys


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

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

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

for a in range(0, len(text)):
    for b in range(0, 26):
        if letters[b] == text[a] or letters[b].upper() == text[a]:
            table[b] += 1

for i in range(0, len(letters)):
    print(str(letters[i]) + " : " + str(table[i]))

Solution (Python):
alpha_dict = {}
for i,c in enumerate(range(ord('a'),ord('z')+1)):
    alpha_dict[chr(c)] = 0

input_str = []

while True:
    try:
        input_value = input().lower()
        input_str.append(input_value)
    except:
        break
    

for input_row in input_str:
    for i in input_row:
        if i in alpha_dict.keys():
            alpha_dict[i] += 1

for key,value in alpha_dict.items():
    print("%s : %d" %(key,value))

Solution (Python):
import string
from collections import Counter

alphabet_list = string.ascii_lowercase

sentences = []
while True:
    try:
        sentence = input().lower()
        sentences.append(sentence)
    except EOFError:
        break

sentence_flatten = ''.join(sentences)

count_list = Counter(sentence_flatten)

for alphabet in alphabet_list:
    print(f'{alphabet} : {count_list[alphabet]}')

Solution (Python):
import sys
alphabet = "abcdefghijklmnopqrstuvwxyz"
s = "".join(sys.stdin.readlines()).lower()

for t in list(alphabet):
    print("{} : {}".format(t, s.count(t)))

Solution (Python):
import sys

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('{} : {}'.format(letters[i], table[i]))

Solution (Python):
A = []
while True:
    try:
        S = input()
        for s in S:
            if 'a' <= s <= 'z' or 'A' <= s <= 'Z':
                A.append(s.lower())
    except EOFError:
        break

D = {}
for s in A:
    if s in D:
        D[s] += 1
    else:
        D[s] = 1

Str = [chr(i) for i in range(97, 97+26)]
for s in Str:
    print(s, end=" ")
    print(":", end=" ")
    if s in D:
        print(D[s])
    else:
        print(0)

Solution (Python):
A = [chr(ord('a') + i) for i in range(26)]
x = open(0).read()



for i in range(len(A)):
    print(A[i] + " : ", end = "" )
    print(x.lower().count(A[i]))

Solution (Python):
l=[0 for i in range(26)]
a="abcdefghijklmnopqrstuvwxyz"
while True:
    try:
        tex = input()
    except :
        break
    tex=tex.lower()
    for i in tex:
        count=0
        for j in a:
            if i==j:
                l[count]+=1
            count+=1
    count=0
for k in a:
    print(k+" : "+str(l[count]))
    count+=1

Solution (Python):

char_dict = {'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,}
char_array = ['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']
while 1:
    try:
        string = input().lower()
    except:
        break
    l = list(string)

    for i in range(len(l)):
        if l[i] in char_dict:
            char_dict[l[i]] += 1
            
for i in range(26):
    print(f'{char_array[i]} : {char_dict[char_array[i]]}')

Solution (Python):
import sys
text = sys.stdin.read()
text=text.lower()
alf = list('abcdefghijklmnopqrstuvwxyz')
cnt=[0]*26
for i in text:
    c=0
    for j in alf:
        if i == j:
            cnt[c]+=1
        c+=1
for i in range(26):
    print(alf[i]+' : '+str(cnt[i]))

Solution (Python):
strings=[]

while(1):
    try:
        s=input()
    except:
        break
    
    strings.append(s)

pattern=['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']
ans=[0 for i in range(26)]

for string in strings:
    s=list(string.lower())
    for letter in s:
        try:
            
            ans[ord(letter)-97]+=1
        except Exception:
            pass

for i in range(26):
    print(pattern[i]+" : "+str(ans[i]))

Solution (Python):
import string
import sys

str = ''
for s in sys.stdin:
    str += s

dict = {e: 0 for e in string.ascii_lowercase}

for e in str:
    if e.lower() in string.ascii_lowercase:
        dict[e.lower()] += 1

for k, v in dict.items():
    print('{} : {}'.format(k, v))

Solution (Python):
import sys

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

table = [0] * 26

for i in sentence:
	count = 0
	for j in letters:
		if i == j or i == j.upper():
			table[count] += 1
		count += 1


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

Solution (Python):
import sys
sentence = sys.stdin.readlines()
a=""
for s in sentence:
  a += s.strip("\n")

a = a.lower()

data = dict()  
alpha = "abcdefghijklmnopqrstuvwxyz"
for key in alpha:
  data[key] = 0

for key in a:
  if key in alpha:
    data[key] += 1

for key in alpha:
  print("{} : {}".format(key,data[key]))

Solution (Python):
alphabet = [chr(i) for i in range(97,123)]
f = open(0)
alphabet_list = [0]*26

for line in f.readlines():
    for ch in alphabet:
        ch_count = line.lower().count(ch)
        alphabet_list[alphabet.index(ch)] += ch_count

for i in range(26):
    print("{} : {}".format(alphabet[i],alphabet_list[i]))

Solution (Python):
import sys

result_alphabet = [0] * 26

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

for x in range(len(input_str)):
    alpha_str = input_str[x:x+1]
    alpha_num = ord(alpha_str) - 97
    if alpha_num > -1 and alpha_num < 27:
        result_alphabet[alpha_num] += 1

for i in range(26):
    alphabet = chr(i+97)
    print(f'{alphabet} : {result_alphabet[i]}')

Solution (Python):
list_alpha = [x for x in 'abcdefghijklmnopqrstuvwxyz']
c_list = ''
    
while True:
    try:
        c_list += input().lower()
    except EOFError:
        break

for l in list_alpha:
    print('{} : {}'.format(l,c_list.lower().count(l)))

Solution (Python):


import sys
lines = sys.stdin.read()
line= str.lower(lines)
line2=["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"]

for i in line2:
    print(str(i)+" : "+str(line.count(i)))

Solution (Python):
import sys

S = sys.stdin.read().lower()
ABC = [chr(ord('a') + i) for i in range(26)]

for abc in ABC:
    print(abc, ':', S.count(abc))

Solution (Python):
chr_dict = {chr(ord('a') + i) : 0 for i in range(26)}

import sys
input_lines = sys.stdin.readlines()
for line in input_lines:
    for s in line:
        if s.lower() in chr_dict:
            chr_dict[s.lower()] += 1

print(*[f"{key} : {value}" for key,value in chr_dict.items()],sep="\n")

Solution (Python):
import sys
str_in = ""
for e in sys.stdin:
    str_in += e
str_in_lower = str_in.lower()
print("a : " + str(str_in_lower.count("a")))
print("b : " + str(str_in_lower.count("b")))
print("c : " + str(str_in_lower.count("c")))
print("d : " + str(str_in_lower.count("d")))
print("e : " + str(str_in_lower.count("e")))
print("f : " + str(str_in_lower.count("f")))
print("g : " + str(str_in_lower.count("g")))
print("h : " + str(str_in_lower.count("h")))
print("i : " + str(str_in_lower.count("i")))
print("j : " + str(str_in_lower.count("j")))
print("k : " + str(str_in_lower.count("k")))
print("l : " + str(str_in_lower.count("l")))
print("m : " + str(str_in_lower.count("m")))
print("n : " + str(str_in_lower.count("n")))
print("o : " + str(str_in_lower.count("o")))
print("p : " + str(str_in_lower.count("p")))
print("q : " + str(str_in_lower.count("q")))
print("r : " + str(str_in_lower.count("r")))
print("s : " + str(str_in_lower.count("s")))
print("t : " + str(str_in_lower.count("t")))
print("u : " + str(str_in_lower.count("u")))
print("v : " + str(str_in_lower.count("v")))
print("w : " + str(str_in_lower.count("w")))
print("x : " + str(str_in_lower.count("x")))
print("y : " + str(str_in_lower.count("y")))
print("z : " + str(str_in_lower.count("z")))

Solution (Python):
import sys
count = [0 for i in range(26)]

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




for i in s:
    if 0 <= ord(i)-97 <= 25:
        count[ord(i)-97] += 1


for index, num in enumerate(count):
    print(f"{chr(index+97)} : {num}")

Solution (Python):
str = ""
while True:
  try:
    line = input()
  except EOFError:
    break
  str += line.lower()
for c in range(ord('a'), ord('z') + 1):
  print(chr(c), ":", str.count(chr(c)))

Solution (Python):
import string
import sys

table = sys.stdin.read()
for ch, CH in zip(string.ascii_lowercase, string.ascii_uppercase):
    c = table.count(ch)
    C = table.count(CH)
    print(ch+" : "+str(c+C))

Solution (Python):
import sys
import string
import functools


def count_alphabet(counter, letter):
    if letter.lower() in counter:
        counter[letter.lower()] += 1

    return counter


if __name__ == "__main__":
    sentence = sys.stdin.read()

    alphabet_counter = {}

    for c in string.ascii_lowercase:
        alphabet_counter[c] = 0

    alphabet_counter = functools.reduce(
        count_alphabet,
        sentence,
        alphabet_counter
    )

    for letter, num_contains in alphabet_counter.items():
        print('{c} : {n}'.format(c=letter, n=num_contains))

Solution (Python):
import sys
string=sys.stdin.read().lower()
cnt=[0]*26
alphabet = "abcdefghijklmnopqrstuvwxyz"

for i in range(len(string)):
  for j in range(len(alphabet)):
    if string[i]==alphabet[j]:
      cnt[j]+=1
      
for i in range(len(alphabet)):
  print(str(alphabet[i])+" : "+str(cnt[i]))

Solution (Python):
s = open(0).read()
sum = [0 for _ in range(26)]
for i in range(len(s)):
    for j in range(97,97+26):
        if s[i] == chr(j):
            sum[j-97] += 1
    for j in range(65,65+26):
        if s[i] == chr(j):
            sum[j-65] += 1
for i in range(26):
    print(f'{chr(i+97)} : {sum[i]}')

Solution (Python):
import sys
s = []
for line in sys.stdin:
    s.append (list(line.rstrip()))

alphabet = [chr(i) for i in range(ord('a'), ord('z')+1)]
for x in alphabet:
    t = 0
    for l in s:
        t += l.count(x)+l.count(str.upper(x))
    print (x,":",t)

Solution (Python):
import sys

nums = list()

o = 'abcdefghijklmnopqrstuvwxyz'

for i in range(26):
    nums.append(0)

mylist1 = sys.stdin.read()










for i in mylist1:
    for q in range(len(o)):
        if i.lower() == o[q]:
            nums[q] = nums[q] + 1

for q in range(len(o)):
    print('{} : {}'.format(o[q], nums[q]))

Solution (Python):
from collections import Counter
import string

counter = Counter()
while True:
    try:
        s = input().lower()
        counter += Counter(s)
    except EOFError:
        break

for c in string.ascii_lowercase:
    count = counter[c]
    print(f'{c} : {count}')

Solution (Python):
import sys

S = sys.stdin.read()
alphabet = [chr(i) for i in range(0x61,0x7b)]
cnt = [0] * len(alphabet)

for s in S:
    s = s.lower()
    if s in alphabet:
        cnt[ord(s)-0x61] += 1

for alpha,num in zip(alphabet,cnt):
    print('{} : {}'.format(alpha,num))

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
texts=sys.stdin.read()
texts=texts.lower()
cnt=[0]*26

letters=list('abcdefghijklmnopqrstuvwxyz')
for x in texts:
    i=0
    for y in letters:
        if x==y:
            cnt[i]+=1
        i+=1
for i in range(26):
    print(letters[i]+" : "+str(cnt[i]))

Solution (Python):
judge="abcdefghijklmnopqrstuvwxyz"
results=[0]*26
while True:
    try:
        str=input()
    except:
        break
    for i in range(len(str)):
        for j in range(0,26):
            if str[i]==judge[j] or str[i]==judge[j].upper():
                results[j]+=1
for i in range(0,26):
    print(judge[i],":",results[i])

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

Solution (Python):
dict = {}
for alpha in [ chr(code) for code in range(ord('a'), ord('z') + 1) ]:
    dict[alpha] = 0

s = ''
while True:
    try:
        s += input()
    except EOFError:
        break

for c in s:
    if c.isalpha():
        dict[c.lower()] += 1

for alpha in [ chr(code) for code in range(ord('a'), ord('z') + 1) ]:
    print('{0} : {1}'.format(alpha, dict[alpha]))

Solution (Python):
import sys
cnt = {}
for line in sys.stdin:
    for l in line:
        if l.isalpha():
            c = l.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):


alp = list(__import__('string').ascii_lowercase)

d = {}

for i in alp:
	d[i] = d.get(i, 0) + 0



s = ''

while True:
    try:
        
        s += input()
        
        
    except:
        break;

for i in range(len(s)):
	c = s[i].lower()
	if c in alp:
		d[c] = d.get(c, 0) + 1



for k,v in d.items():
	print(k,':',v)

Solution (Python):
import sys

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

char_dict = {}
for i in range(97, 97+26):
    char_dict[chr(i)] = 0

for i in S:
    if 97 <= ord(i) < 97+26:
        char_dict[i] += 1

for i in range(97, 97+26):
    print("{} : {}".format(chr(i), char_dict[chr(i)]))

Solution (Python):
import sys
s = sys.stdin.read().lower()
for ch in map(chr,range(ord('a'), ord('z') + 1)):
    print(ch, ':', s.count(ch))

Solution (Python):



S = ''
while True:
    try:
        line = input().lower()
        S += line
    except EOFError:
        break


S_dic = {}
for i in range(26):
    tmp = chr(ord('a') + i)
    S_dic[tmp] = 0
for i in range(len(S)):
    c = S[i]
    if c>='a' and c<='z':
        S_dic[c] += 1


for k, item in S_dic.items():
    print("%s : %d"%(k, item))

Solution (Python):
s_list = []
while True:
	try:
		s_list.append(input().lower())
	except:
		break
s = ''.join(s_list)
for t in ['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']:
	print('{0} : {1}'.format(t, s.count(t)))

Solution (Python):
import collections
import string
s = ''
_s = ''
while True:
    try:
        s += str(input())
    except:
        break
s = s.lower()
c = collections.Counter(s)
for ch in string.ascii_lowercase:
    print('{} : {}'.format(ch,c[ch]))

Solution (Python):
from collections import Counter, defaultdict
line = ""
while True:
    try:
        line += input()
    except:
        break
S = defaultdict(int, Counter(line.lower()))
for a in range(ord("a"), ord("z")+1):
    print(chr(a),":",S[chr(a)])

Solution (Python):
cnt = [0]*100
while 1:
    try:
        S = input()
    except:
        break
    S = S.lower()
    for i in S:
        tmp = ord(i)%97
        cnt[tmp] += 1

for i in range(26):
    print(chr(97+i),":",cnt[i])

Solution (Python):
alphabet = dict([(chr(i), 0) for i in range(97, 123)])

while True:
    try:
        text = list(map(str.lower, input()))
        for c in text:
            if c.isalpha():
                alphabet.update({c: alphabet[c]+1})
    except:
        break

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

Solution (Python):
cnt = [0 for i 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):
                  cnt[m]+=1
            m = ord(s[i])-ord('a')
            if(m >= 0 and m < 26):
                  cnt[m]+=1
for i in range(26):
      print(chr(i+ord('a')),":",cnt[i])

Solution (Python):
alp = list("abcdefghijklmnopqrstuvwxyz")
text = str()

while True:
    
    try:

        num = str(input().lower())
        
    except EOFError:
        break
    
    text += num

text = list(text)
for i in alp:
    x = text.count(i)
    print(f"{i} : {x}")

Solution (Python):
import sys 
cnt = {} 
for line in sys.stdin:
    for l in line:
        if l.isalpha():
            c = l.lower()
            cnt[c] = cnt.get(c,0)+1
for i in range(26):
    c = chr(ord('a')+i)
    print(f'{c} : {cnt.get(c,0)}')

Solution (Python):
import sys
dic={}
for alp in [chr(i) for i in range(ord('a'), ord('z')+1)]:
    dic[alp]=0
s=sys.stdin.read()
for m in s:
    if m.isalpha():
        if m.isupper()==True:
            m_=m.lower()
            dic[m_]+=1
        else:
            dic[m]+=1
for k in dic:
    print("{} : {}".format(k,dic[k]))

Solution (Python):
import sys

count = [0]*26
lines = sys.stdin.readlines()

for line in lines:
    for c in line.lower():
        if 97 <= ord(c) <= 123:
            count[ord(c) - 97] += 1
            
for i in range(26):
    print(chr(i + 97), ':', count[i])

Solution (Python):
import sys
lstlet = ["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"]
lstint = [0] * 26
moji = ""
while True:
  try:
    moji = moji + str(input())
  except:
    break;
lstin = list(moji)
length = len(lstin)
for i in range(length):
  if str(lstin[i]) == "a" or str(lstin[i]) == "A":
    lstint[0] += 1
  elif str(lstin[i]) == "b" or str(lstin[i]) == "B":
    lstint[1] += 1
  elif str(lstin[i]) == "c" or str(lstin[i]) == "C":
    lstint[2] += 1
  elif str(lstin[i]) == "d" or str(lstin[i]) == "D":
    lstint[3] += 1
  elif str(lstin[i]) == "e" or str(lstin[i]) == "E":
    lstint[4] += 1 
  elif str(lstin[i]) == "f" or str(lstin[i]) == "F":
    lstint[5] += 1
  elif str(lstin[i]) == "g" or str(lstin[i]) == "G":
    lstint[6] += 1
  elif str(lstin[i]) == "h" or str(lstin[i]) == "H":
    lstint[7] += 1
  elif str(lstin[i]) == "i" or str(lstin[i]) == "I":
    lstint[8] += 1
  elif str(lstin[i]) == "j" or str(lstin[i]) == "J":
    lstint[9] += 1
  elif str(lstin[i]) == "k" or str(lstin[i]) == "K":
    lstint[10] += 1
  elif str(lstin[i]) == "l" or str(lstin[i]) == "L":
    lstint[11] += 1
  elif str(lstin[i]) == "m" or str(lstin[i]) == "M":
    lstint[12] += 1
  elif str(lstin[i]) == "n" or str(lstin[i]) == "N":
    lstint[13] += 1
  elif str(lstin[i]) == "o" or str(lstin[i]) == "O":
    lstint[14] += 1
  elif str(lstin[i]) == "p" or str(lstin[i]) == "P":
    lstint[15] += 1
  elif str(lstin[i]) == "q" or str(lstin[i]) == "Q":
    lstint[16] += 1
  elif str(lstin[i]) == "r" or str(lstin[i]) == "R":
    lstint[17] += 1
  elif str(lstin[i]) == "s" or str(lstin[i]) == "S":
    lstint[18] += 1
  elif str(lstin[i]) == "t" or str(lstin[i]) == "T":
    lstint[19] += 1
  elif str(lstin[i]) == "u" or str(lstin[i]) == "U":
    lstint[20] += 1
  elif str(lstin[i]) == "v" or str(lstin[i]) == "V":
    lstint[21] += 1
  elif str(lstin[i]) == "w" or str(lstin[i]) == "W":
    lstint[22] += 1
  elif str(lstin[i]) == "x" or str(lstin[i]) == "X":
    lstint[23] += 1
  elif str(lstin[i]) == "y" or str(lstin[i]) == "Y":
    lstint[24] += 1
  elif str(lstin[i]) == "z" or str(lstin[i]) == "Z":
    lstint[25] += 1
for j in range(26):
  print(str(lstlet[j]) + " : " + str(lstint[j]))

Solution (Python):
import sys

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

Solution (Python):
from collections import defaultdict

abc = ["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"]
d = defaultdict(int)

while True:
    try:
        s = input()
    except:
        break
    s = s.lower()
    s = list(s)
    
    for i in range(len(s)):
        if s[i] in abc:
            d[s[i]] += 1
    
for i in abc:
    print(i + " : " + str(d[i]))

Solution (Python):
cnt = [0 for i 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):
                  cnt[m]+=1
            m = ord(s[i])-ord('a')
            if(m >= 0 and m < 26):
                  cnt[m]+=1
for i in range(26):
      print(chr(i+ord('a')),":",cnt[i])

Solution (Python):

import sys

f = sys.stdin
res = [0]*26

for l in f:
    line = l.lower()
    for i in range(26):
        res[i]+=line.count(chr(ord('a')+i))

for i in range(26):
    c = str(chr(ord('a')+i))
    print (c+" : ",end='')
    print (res[i])

Solution (Python):
cnt = [0 for i 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):
                  cnt[m]+=1
            m = ord(s[i])-ord('a')
            if(m >= 0 and m < 26):
                  cnt[m]+=1
for i in range(26):
      print(chr(i+ord('a')),":",cnt[i])

Solution (Python):
alphabet='abcdefghijklmnopqrstuvwxyz'
dic={ch:0 for ch in alphabet}
while True:
    try:
        inp=input()
        if inp=="":break
        inp=inp.lower()
        for ch in inp:
            if ch in alphabet:
                dic[ch]+=1
    except EOFError:
        break

for k, v in dic.items():
    print("{} : {}".format(k,v))

Solution (Python):
dict = {}
init = 'abcdefghijklmnopqrstuvwxyz'
for s in init:
    dict[s] = 0

list_sentence = []
while True:
    try:
        list_sentence.append(input())
    except:
        break;

for sentence in list_sentence:
    for s in sentence:
        if s.lower() in dict:
            dict[s.lower()] += 1

for k, v in dict.items():
    print(k, ':', v)

Solution (Python):
import sys
input = sys.stdin.readline

def main():
    dic = {}
    for i in range(ord("a"), ord("z")+1):
        dic[chr(i)] = 0
    for line in sys.stdin.readlines():
        for c in line.strip():
            c = c.lower()
            if c in dic:
                dic[c] += 1
    
    for c, count in sorted(dic.items(), key=lambda x: x[0]):
        print(c, ":", count)

if __name__ == "__main__":
    main()

Solution (Python):
import sys

str = ""
for e in sys.stdin:
    str += e

alphabets = "abcdefghijklmnopqrstuvwxyz"

for c in list(alphabets):
    print("{} : {}".format(c, list(str.lower()).count(c)))

Solution (Python):
import string
import sys

input_str = sys.stdin.read()

for i in range(26):
    char = string.ascii_lowercase[i]
    CHAR = string.ascii_uppercase[i]
    cnt = input_str.count(char) + input_str.count(CHAR)
    print("{0} : {1}".format(char, cnt))

Solution (Python):

a=''
while True:
    try:
        a += input().lower()
    except :
        break

for c in 'abcdefghijklmnopqrstuvwxyz':
    print('{} : {}'.format(c, a.count(c)))

Solution (Python):
import sys



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):
cnt = [0 for i 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):
                  cnt[m]+=1
            m = ord(s[i])-ord('a')
            if(m >= 0 and m < 26):
                  cnt[m]+=1
for i in range(26):
      print(chr(i+ord('a')),":",cnt[i])

Solution (Python):
import string

def get_input():
  while True:
    try:
      line = input()
      if line == '':
        break
      else:
        yield line
    except EOFError:
      break

ans = []
sentence_list = list(get_input())
sentence = "".join(sentence_list).lower()

alphabet = list(string.ascii_lowercase)
for i in alphabet:
  ans.append(sentence.count(i))
for j, k in zip(alphabet, ans):
  print("{} : {}".format(j, k))

Solution (Python):
cnt_al = {"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}

word_list = list()
while True:
    try:
        words = input().lower()
        word_list.append(words)
    except:
        break

for words in word_list:
    for word in words:
        if word in cnt_al:
            cnt_al[word] += 1

for al,cnt in cnt_al.items():
    print(al,':',cnt)

Solution (Python):
import sys
sys.setrecursionlimit(10 ** 7)
read = sys.stdin.buffer.read
inp = sys.stdin.buffer.readline
def inpS(): return inp().rstrip().decode()
readlines = sys.stdin.buffer.readlines
MOD = 10**9+7

S = sys.stdin.read()
S = S.lower()
dic_alpha = {s: 0 for s in "abcdefghijklmnopqrstuvwxyz"}

for s in S:
    if s in dic_alpha:
        dic_alpha[s] += 1
[print(k, ":", v) for k, v in dic_alpha.items()]

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):
cnt = [0 for i 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:
                  cnt[m]+=1
            m = ord(s[i])-ord('a')
            if m >= 0 and m < 26:
                  cnt[m] += 1
for i in range(26):
      print(chr(i+ord('a')), ":", cnt[i])

Solution (Python):
st=[]

while True:
  try:
    n=input()
    if n=="":
      break
    st += n.lower()
  except:
    break
   
char = "abcdefghijklmnopqrstuvwxyz"
for i in range(len(char)):
  print(char[i],":",st.count(char[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"]
a = [0 for i in range(26)]
s = ""
while True:
    try:
        s += input().lower()
    except EOFError:
        break

for i in range(len(s)):
    if s[i] in alphabet:
        a[alphabet.index(s[i])] += 1

for i in range(26):
    print(alphabet[i], ":", a[i])

Solution (Python):
dic={}
alp_lst=list('abcdefghijklmnopqrstuvwxyz')

for alp in alp_lst:
    dic[alp]=0
try:
    while True:
        sen=input()
        if sen=='':
            break
        sen=sen.lower()
        for i in sen:
            if i in alp_lst:
                dic[i]+=1
except EOFError:
    pass
for i in alp_lst:
    print(i+' : '+str(dic[i]))

Solution (Python):
import sys
s = []
for e in sys.stdin:
    if e != "\n":
        s += list(e.lower().replace(" ", ""))
    else:
        break
alfa = [chr(i) for i in range(97, 97+26)]
d = {}
for i in alfa:
    if i in s:
        d[i] = s.count(i)
    else:
        d[i] = 0
for k,v in d.items():
    print("{} : {}".format(k, v))

Solution (Python):
import string
import sys

input_str = sys.stdin.read()

for i in range(26):
    char = string.ascii_lowercase[i]
    CHAR = string.ascii_uppercase[i]
    cnt = input_str.count(char) + input_str.count(CHAR)
    print("{0} : {1}".format(char, cnt))

Solution (Python):
b = []
while True:
    try:
        s = input()
        b += list(s.lower())
    except:
        break

a = list("abcdefghijklmnopqrstuvwxyz")
for i in a:
    print("{} : {}".format(i, b.count(i)))

Solution (Python):

al="abcdefghijklmnopqrstuvwxyz"
count=[0]*26
while True:
    try:
        s=input()
    except:
        break
    for i in range(len(s)):
        for j in range(len(al)):
            if s[i]==al[j] or s[i]==al[j].upper():
                count[j]+=1

for i in range(len(al)):
    print("{0} : {1}".format(al[i],count[i]))

Solution (Python):
import sys
import _collections

def sa(Type= int):
  return [Type(x) for x in input().split()]

def solve():
  ff = _collections.defaultdict(int)

  mn = ord('a')
  mx = ord('z')

  s = sys.stdin.read()
  for ch in s:
    ch = ch.lower()
    chc = ord(ch)

    if mn <= chc <= mx:
      ff[ch]+= 1

  for chc in range(mn, mx+1):
    ch = chr(chc)
    print('{} : {}'.format(ch, ff[ch]))

if __name__ == '__main__':
  

  solve()

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

cnt = 0
s = []
while True:
    try:
        s.append(input().lower())
    except EOFError:
        break
    cnt += 1

for i in range(cnt):
    for st in s[i]:
        if ord('a') <= ord(st) and ord(st) <= ord('z'):
            alf[ord(st)-ord('a')] += 1
        

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

Solution (Python):
count = [0]*26
while True:
         try:
                  sample = (input())
         except:
                  break
         for i in range(len(sample)):
                  case = ord(sample[i])
                  if 65 <= case <= 90:
                           count[case-65] += 1
                  elif 97 <= case <= 122:
                           count[case-97] += 1
for i in range(26):
         print(chr(i+97)+" : "+str(count[i]))

Solution (Python):
import sys
s = sys.stdin.read()

alpha = "abcdefghijklmnopqrstuvwxyz"
cnt = [0] * len(alpha)
for i in s:
    for j in range(len(alpha)):
        if str.lower(i) == alpha[j]:
            cnt[j] += 1
for i in range(len(alpha)):
    print(alpha[i], ":", cnt[i])