Hash it out

01-data-structures/04-hashes-part-1/hash_item.rb

@@ -1,7 +1,8 @@
 class HashItem
   attr_accessor :key
   attr_accessor :value
-
+ 
   def initialize(key, value)
+  	@key, @value = key, value
   end
 end

01-data-structures/04-hashes-part-1/hashclass.rb

@@ -1,27 +1,47 @@
+require_relative 'hash_item'
+
 class HashClass
 
   def initialize(size)
     @items = Array.new(size)
   end
 
   def []=(key, value)
+    item = HashItem.new(key, value)
+    i = index(key, size)
+
+    if @items[i].nil?
+      @items[i] = item
+    elsif @items[i].key != item.key
+      self.resize
+      self[key] = value
+    elsif @items[i].value != item.value
+      self.resize
+      @items[index(item.key, size)] = value
+    end
   end
 
 
   def [](key)
+    @items[self.index(key, self.size)].value
   end
 
   def resize
+    old_items = @items.compact
+    @items = Array.new(self.size * 2)    
+    old_items.each { |item| self[item.key] = item.value }
   end
 
   # Returns a unique, deterministically reproducible index into an array
   # We are hashing based on strings, let's use the ascii value of each string as
   # a starting point.
   def index(key, size)
+    key.each_byte.sum % size
   end
 
   # Simple method to return the number of items in the hash
   def size
+    @items.length
   end
 
 end

01-data-structures/04-hashes-part-1/hashes-1-answers.txt

@@ -0,0 +1 @@
+Doubling the size of the underlying array of my HashClass may be a poor idea because it'll increase the open slots in the array exponentially which may lead to more fragmentation. Doubling the size is also a slow process. Using prime numbers to resize is better as that'll reduce the number of collisions.