CareerCup

It depends on what operations on the data structure you are interested in. Two alternatives: hashmap , trie. If you just want the count then a hash map with value = count
time: amortized O(1)
space: depends on the hash function, best case: O(unique_words)

What do you mean by "unique words". If uniques words are one that appear once than their count will be one or is the unique word given as input by the user and you have to calculate its occurrence?

for example if text present in the file like "Hi Hello, bob. Hello Matt, Hi jully" so the output should be like

Hi-2
Hello-2
bob -1
Matt- 1
Jully -1 ..
hope you can understand the question now.

@blueskin.neo,
suppose I want to print both the word and their count. In that case how would u do that. Can you please write the algorithm for that?

#include <iostream>
#include <algorithm>
#include <vector>
#include <fstream>
#include <map>
#include <iterator>

using namespace std;

int main() {
string str;
ifstream in("input.txt");
map<string, int> m;
if (in.is_open()) {
while(in >> str) {
m[str]++;
}
}
for(map<string, int>::iterator it = m.begin(); it != m.end(); it++) {
cout << (*it).first <<"\t" << (*it).second << endl;
}


}


input.txt

abc abc abc abc abc abc abc abcdef abc abcd
abc abc abc abc abc abc abc abcdef abc abcd
abc abc abc abc abc abc abc abcdef abc abcd
abc abc abc abc abc abc abc abcdef abc abcd
count words in a file and print words with their count more words file

output

ajay@ubuntu:~/workspace$ ./a.out
a 1
abc 32
abcd 4
abcdef 4
and 1
count 2
file 2
in 1
more 1
print 1
their 1
with 1
words 3

cat $file | sort | uniq -c

How would you find the unique words and their count?
Unique!
So you just use ArrayList to put words as you read a word and remove it if already exists. So the count will always be one (remember unique words). we are not asked to list other words.

import java.util.HashMap;

public class TestTest {
	public static void main(String[] args){

		String inputString = "abc abc abc abc abc abc abc abcdef abc abcd abc abc abc abc abc abc abc abcdef abc abcd" +
				" abc abc abc abc abc abc abc abcdef abc abcd abc abc abc abc abc abc abc abcdef abc abcd" +
				" count words in a file and print words with their count more words file";

		HashMap<Object, Integer> myMap = new HashMap<Object, Integer>(){
			@Override
			public Integer put(Object arg0, Integer arg1) {
				Integer i = super.get(arg0);
				arg1 = i==null?1:i+1;
				return super.put(arg0, arg1);
			}
		};
		
		String[] splits = inputString.split(" ");
		for(String s : splits){
			myMap.put(s,1);
		}
		
		System.out.println(myMap);
	}
}

Also seems to be a perfect candidate for MapReduce.

import java.util.*;

public class Freq {
    public static void main(String[] args) {
        Map<String, Integer> m = new HashMap<String, Integer>();

        // Initialize frequency table from command line
        for (String a : args) {
            Integer freq = m.get(a);
            m.put(a, (freq == null) ? 1 : freq + 1);
        }

        System.out.println(m.size() + " distinct words:");
        System.out.println(m);
    }
}

String s = "Hi Hello bob Hello Matt Hi jully" ;
Map<String,Integer> numberOfWords = new HashMap<String,Integer>();
String[] allWords = s.split("\\s");
		for (String s1 : allWords) {
			if (numberOfWords.containsKey(s1)) {
				numberOfWords.put(s1, numberOfWords.get(s1) + 1);
			} else {
				numberOfWords.put(s1, 1);
			}
		}
		
		Iterator it = numberOfWords.entrySet().iterator();
	    while (it.hasNext()) {
	        Map.Entry pairs = (Map.Entry)it.next();
	        System.out.println(pairs.getKey() + " = " + pairs.getValue());
	    }

We can create a Trie based structure with one modification.
Every trie node will store the counts of the words that end with it ( the count will be 0 if it is not a leaf ).
Ex. Hi John ! How are you ? Hi Jane, I'm doing good. Hiya everybody, how's the party ?
will have a node structure for H(0) --> i (2) --> y (0) --> a (1)
This will conserve space and worst time complexity will be O(K) where K is the maximum number of alphabets in that structure.

Of course the author meant: find all the unique words and their count (i.e. how many unique words there are).
Use a binary tree or a hash table (i.e. std::map<string, int> or std::unordered_map<string, int>) to insert all the words with their counts. After this traverse this structure and print all words with count = 1 and also count them (i.e. those with count = 1).