CareerCup

void printcount(int a[])
{
int i,b[256];
for(i=0;i<255;i++)
{
b[i]=0;
}
for(i=0;i<a.length;i++)
{
if(!b[a[i]])
{
b[a[i]]++;
}
else
{
printf("\n Element at index %d and its count is %d",a[i],b[a[i]]);
}
}
}

#include <iostream>
#include <string>
#include <map>

using namespace std;

int main() {
        map< char, int > charCount;
        string s( "amazon.com" );

        string::const_iterator end = s.end();
        string::const_iterator i = s.begin();

        for ( ; i != end; ++i )
                if ( ( *i >= 'a' && *i <= 'z' ) || ( *i >= 'A' && *i <= 'Z' ) )
                        ++charCount[ *i ];

        map< char, int >::const_iterator end1 = charCount.end();
        map< char, int >::const_iterator j = charCount.begin();

        for ( ; j != end1; ++j )
                cout << j->first << ", " << j->second << "\n";

        return 0;
}

You can make use of the concept explained in geeksforgeeks.org/?p=16

If its only about alphabets then we can have a array of 26 integers and increment the count for the character each time a character occurs.
But i assume the question is not restricted to alphabets.
Then we have maintain a Dictionary and doubly linked list.(like any simple cache algo)

We can use a Hashtable with the alphabetsa as key and the objects intially to 0.
Now for every alphabet we see increment the count in the hash table and finally we end up having the counts...

public class count {

public static void main(String args[])
{
String str="amazon.com";
char[] ele=str.toCharArray();
Hashtable<Character, Integer> elements=new Hashtable<Character, Integer>();

for(int i=0;i<ele.length;i++)
elements.put(ele[i], 0);

for(int i=0;i<ele.length;i++)
{
elements.put(ele[i], (elements.get(ele[i])+1));

}

for(int i=0;i<ele.length;i++)
System.out.println(ele[i]+"count"+elements.get(ele[i]));

}

}

i guess its optimal to use a technique which can give us a solution in O(n) complexity. i think thts the sole purpose of the interviewer to test your skills and see if you can do it in O(n) complexity.