hashset

I've got a list of bookmarks. Each bookmark has a list of keywords (stored as a HashSet). I also have a set of all possible keywords ("universe"). I want to find the keyword that appears in the most bookmarks. I have 1356 bookmarks with a combined total of 698,539 keywords, with 187,358 unique. If I iterate through every keyword in the universe and count the number of bookmarks it appears in, I'm doing 254,057,448 checks. This takes 35 seconds on my machine. The algorithm is pretty simple: var biggest = universe.MaxBy(kw => bookmarks.Count(bm => bm.Keywords.Contains(kw))); Using Jon Skeet's

Below is the code for finding duplicate objects from a list of object. But for some reason the hashset is storing even the equal objects. I am certainly missing out something here but when I check the size of hashset it comes out 5. import java.util.ArrayList; import java.util.HashSet; public class DuplicateTest { public static void main(String args[]){ ArrayList<Dog> dogList = new ArrayList<Dog>(); ArrayList<Dog> duplicatesList = new ArrayList<Dog>(); HashSet<Dog> uniqueSet = new HashSet<Dog>(); Dog a = new Dog(); Dog b = new Dog(); Dog c = new Dog(); Dog d = new Dog(); Dog e = new Dog(); a

I have a hashmap that maps strings keys to hashsets values, and I want to remove a key from the hashmap when the hashmaps's hashset value is empty. I'm having trouble approaching this. Here's what I've tried but I'm very stuck: for(Map.Entry<String, HashSet<Integer>> entr : stringIDMap.entrySet()) { String key = entr.getKey(); if (stringIDMap.get(key).isEmpty()) { stringIDMap.remove(key); continue; } //few print statements... } In order to avoid ConcurrentModificationException , you need to use the Iterator interface directly: Iterator<Map.Entry<String, HashSet<Integer>>> it = stringIDMap

What load factor should I use when I really know the maximum possible no of elements in a HashSet ? I had heard that the default load factor of 0.75 is recommended as it offers good performance trade-offs between speed & space. Is this correct ? However a larger size HashSet would also takes more time in creation and more space. I am using HashSet just inorder to remove duplicate integers from a list of integers. I spent some time playing around with load factors once, and it is shocking how little difference that setting really makes in practice. Even setting it to something high like 2.0

I was wondering whether the .Net HashSet<T> is based completely on hash codes or whether it uses equality as well? I have a particular class that I may potentially instantiate millions of instances of and there is a reasonable chance that some hash codes will collide at that point. I'm considering using HashSet's to store some instances of this class and am wondering if it's actually worth doing - if the uniqueness of an element is only determined on its hash code then that's of no use to me for real applications MSDN documentation seems to be rather vague on this topic - any enlightenment

I've got a HashSet, var universe = new HashSet<int>(); And a bunch of subsets, var sets = new List<HashSet<int>>(numSets); I want to subtract a chunk, which I can do like this: var remaining = universe.ExceptWith(sets[0]); But ExceptWith works in-place. I don't want to modify the universe . Should I clone it first, or is there a better way? I guess I should clone it first? How do I do that? var universe = new HashSet<int>(); var subset = new HashSet<int>(); ... // clone the universe var remaining = new HashSet<int>(universe); remaining.ExceptWith(subset); Not as simple as with the Except

Here is my Python code: len_sums = 0 for i in xrange(100000): set_1 = set(xrange(1000)) set_2 = set(xrange(500, 1500)) intersection_len = len(set_1.intersection(set_2)) len_sums += intersection_len print len_sums Here is my Rust code: use std::collections::HashSet; fn main() { let mut len_sums = 0; for _ in 0..100000 { let set_1: HashSet<i32> = (0..1000).collect(); let set_2: HashSet<i32> = (500..1500).collect(); let intersection_len = set_1.intersection(&set_2).count(); len_sums += intersection_len; } println!("{}", len_sums); } I believe these are roughly equivalent. I get the following