Thread: adding objects to a unordered map:

I am trying to solve some random puzzles so I do not lose/forget c++. I never used hashtables in C++ and decided I needed to brush up. I am having in creating a hashmap that holds objects with a string as a key:

Code:

#pragma once
#include <iostream>
#include <unordered_map>


class WordCount
{
private:


	struct Word{
		int count;


		int wordOccurrance(){
			return count++;
		}
	}


	std::unordered_map<std::string, Word> words; //error


	std::unordered_map<std::string,std::string> mymap; //works fine
public:
	WordCount(void);
	~WordCount(void);
};

Ahhhh..... Don't I look silly.....

This what I am trying to do:

1) Get occurrence of a word in a sentence, and count how many times that word occurred. For example if you were writing a ransom letter could you get all the words you need from a paragraph. I could do a loop but that would be O(n^2) but if I use a hashtable it would be O(Log N).

Here is what I already did in Java:

Code:

package frequency;


import java.util.Hashtable;




public class CheckFrequency {


	Hashtable<String, Word> words = new Hashtable<String, Word>();


	class Word {
		String word;
		int counter=1;


		Word(String word) {
			this.word = word;
		}


		public void plusOne() {
			counter++;	
		}


		String getWord(){
			return word;
		}
	}


	public void checkWords(String s) {


		if (words.containsKey(s)) {
			words.get(s).plusOne();
		} else {
			words.put(s, new Word(s));
		}
	}
	
	public void printFrequency(String s) {
		
		if(words.containsKey(s)) {
			System.out.println(words.get(s).counter);
			System.out.println(words.get(s).getWord());
		}
		else{
			System.out.println("Word does not exist");
		}
		
	}


	public static void main(String[] args) {
		
		 String[] word = new String[4];
		 word[0]="Drew";
		 word[1]="Drew";
		 word[2]="Drew"; 
		 word[3]="Mike";
		 
		 CheckFrequency checker = new CheckFrequency();
		 
		 for(int i=0; i<4;i++){
		 checker.checkWords(word[i]);
		 }
		 
		checker.printFrequency("Drew"); 
		 
	}


}

I just playing around and finding little programs to learn how to use Hashtables a little better.

With a hash table it would be in O(n), not O(log n), because you need to process every word in the input.

You're right...

Speaking of map, since you are only using the Map interface, you might as well code to an interface by having words be a Map<String, Word> (or Map<String, Integer> if you take my previous suggestion).

I used the Word object because I was thinking the collisions would cause an issue. Meaning "Mike" and "Mike" have the same key and the countOccurrence function in the Word Struct would keep track that there are two objects named "Mike". However lets say "Alex" for whatever reason had the same key and was but in the same bucket. Now the bucket size will be 3, but really the value "mike" occurred twice.

I thought it would be a easier way to store the values but it seems I am wrong.

I will try to with a binary tree...

It is not working but this is what I have. If this what you were referring too. I am taking your advice, or at least attempting to. I am going to try the map<string,int> myMap approach after I get this way to work.

Code:

#include "WordCount.h"


int main(void){


	WordCount count;


	std::string names[] = {"Drew","Mike","Alex","Drew","Mike"};


	for(auto name: names){
		count.checkWords(name);
	}
	
	count.checkWords(names[0]);
	
	return 0;
}

Code:

#pragma once
#include <iostream>
#include <map>


class WordCount
{
private:


	struct Word{
		int count;


		int wordOccurrance(){
			return count++;
		}
	};


	std::map<std::string, Word> words;


public:
	WordCount(void);
	~WordCount(void);


	void checkWords(std::string s);
	void printFrequency(std::string s);
};

Code:

#include "WordCount.h"
#include <unordered_map>
#include <string>


WordCount::WordCount(void)
{
}


WordCount::~WordCount(void)
{
}


void WordCount::checkWords(std::string s){
	
		if(words.count(s)>0){


			words.at(s).wordOccurrance;
		}
		else{
			words.emplace (s,new Word);
		}
}


void WordCount::printFrequency(std::string s){


	if(words.at(s).wordOccurrance > 0){
		int value = words.at(s).wordOccurrance;


		std::cout<<"Word: "<<s<<" occurred "<<value<<" times.";
	}else{
		std::cout<<"The word does not exist.\n";
	}


}

Got it to work!!! Thank you Elysia....

Code:

#include "WordCount.h"




WordCount::WordCount()
{
    
}


void WordCount::checkWords(std::string s){
    
    if(words.count(s)>0){
        
        words.at(s).wordOccurrance();
    }
    else{
        words[s];
    }
}


void WordCount::printFrequency(std::string s){
    
    if(words.at(s).wordOccurrance() >= 0){
        int value = words.at(s).wordOccurrance();
        
        std::cout<<"Word: "<<s<<" occurred "<<value<<" times.";
    }else{
        std::cout<<"The word does not exist.\n";
    }
    
}

Code:

#include <iostream>
#include <array>
#include "WordCount.h"


int main(int argc, const char * argv[]) {
    
    WordCount count;
    
    std::array<std::string, 5> names = {"Drew","Mike","Alex","Drew","Mike"};
    
    for (const auto& name: names) {
        
        count.checkWords(name);
    }
    
    count.printFrequency("Drew");
    
    return 0;}

You need to insert and increment, which would be exactly the same as the case where it exists.

I handled that in the print function. Just to make sure I did what you said and I got an out of 2 for Alex when I know it is 1. I get one when way I have written it below:

Code:

void WordCount::printFrequency(std::string s){
    
    if(words.at(s).wordOccurrance() >= 0){
        int value = words.at(s).wordOccurrance();
        
        std::cout<<"Word: "<<s<<" occurred "<<value<<" times.";
    }else{
        std::cout<<"The word does not exist.\n";
    }
    
}