algorithms 0.0.1 → 0.1.0

data/lib/graphs/graph.rb

@@ -0,0 +1,25 @@
+class Graph
+  def initialize(string=nil, &block)
+    p block if block
+    @nodes = []
+  end
+  
+  def -(other)
+    @nodes << other
+  end
+  
+  def >(other)
+    @nodes << other
+  end
+end
+a = Graph.new
+b = []
+d = []
+
+a - b
+a > d
+
+Graph.new do
+  d - c
+  g - s
+end

data/spec/bst_spec.rb

@@ -0,0 +1,31 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require "algorithms"
+
+begin
+  Containers::CBst
+  describe "binary search tree" do
+    it "should let user insert new elements with key" do
+      @bst = Containers::CBst.new
+      100.times { |x| @bst.insert(x, "hello : #{x}") }
+      @bst.size.should eql(100)
+    end
+
+    it "should allow users to delete elements" do
+      @bst = Containers::CBst.new
+      @bst.insert(10, "hello world")
+      @bst.insert(11, "hello world")
+      @bst.delete(11)
+      @bst.size.should eql(1)
+      @bst.delete(10)
+      @bst.size.should eql(0)
+    end
+
+    it "should throw exception on invalid key delete" do
+      @bst = Containers::CBst.new
+      @bst.insert(10,"Hello world")
+      lambda { @bst.delete(20) }.should raise_error(ArgumentError)
+      @bst.size.should eql(1)
+    end
+  end
+rescue Exception
+end

data/spec/deque_spec.rb

@@ -0,0 +1,108 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+describe "(empty deque)", :shared => true do
+  it "should return nil when popping objects" do
+    @deque.pop_front.should be_nil
+    @deque.pop_back.should be_nil
+  end
+
+  it "should return a size of 1 when sent #push_front" do
+    @deque.push_front(1)
+    @deque.size.should eql(1)
+  end
+
+  it "should return a size of 1 when sent #push_back" do
+    @deque.push_back(1)
+    @deque.size.should eql(1)
+  end
+
+  it "should return nil when sent #front and #back" do
+    @deque.front.should be_nil
+    @deque.back.should be_nil
+  end
+
+  it "should be empty" do
+    @deque.should be_empty
+  end
+
+  it "should raise ArgumentError if passed more than one argument" do
+    lambda { @deque.class.send("new", Time.now, []) }.should raise_error
+  end
+end
+
+describe "(non-empty deque)", :shared => true do
+  before(:each) do
+    @deque.push_back(10)
+    @deque.push_back("10")
+  end
+
+  it "should return last pushed object with pop_back" do
+    @deque.pop_back.should eql("10")
+    @deque.pop_back.should eql(10)
+  end
+
+  it "should return first pushed object with pop_front" do
+    @deque.pop_front.should eql(10)
+    @deque.pop_front.should eql("10")
+  end
+
+  it "should return a size greater than 0" do
+    @deque.size.should eql(2)
+  end
+
+  it "should not be empty" do
+    @deque.should_not be_empty
+  end
+
+  it "should iterate in LIFO order with #each_backward" do
+    arr = []
+    @deque.each_backward { |obj| arr << obj }
+    arr.should eql(["10", 10])
+  end
+
+  it "should iterate in FIFO order with #each_forward" do
+    arr = []
+    @deque.each_forward { |obj| arr << obj }
+    arr.should eql([10, "10"])
+  end
+
+  it "should return nil after everything's popped" do
+    @deque.pop_back
+    @deque.pop_back
+    @deque.pop_back.should be_nil
+    @deque.front.should be_nil
+  end
+end
+
+describe "empty rubydeque" do
+  before(:each) do
+    @deque = Containers::RubyDeque.new
+  end
+  it_should_behave_like "(empty deque)"
+end
+
+describe "full rubydeque" do
+  before(:each) do
+    @deque = Containers::RubyDeque.new
+  end
+  it_should_behave_like "(non-empty deque)"
+end
+
+begin
+  Containers::CDeque
+  describe "empty cdeque" do
+    before(:each) do
+      @deque = Containers::CDeque.new
+    end
+    it_should_behave_like "(empty deque)"
+  end
+
+  describe "full cdeque" do
+    before(:each) do
+      @deque = Containers::CDeque.new
+    end
+    it_should_behave_like "(non-empty deque)"
+  end
+rescue Exception
+end

data/spec/heap_spec.rb

@@ -1,74 +1,119 @@
-require 'lib/algorithms'
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
 
-describe Containers::Heap do
+describe "empty heap" do
   before(:each) do
     @heap = Containers::MaxHeap.new
   end
-  
-  describe "(empty)" do
-  
-    it "should return nil when getting the maximum" do
-      @heap.get_max!.should eql(nil)
-    end
-    
-    it "should let you insert and remove one item" do
-      @heap.size.should eql(0)
-      
-      @heap.insert(1)
-      @heap.size.should eql(1)
-      
-      @heap.get_max!.should eql(1)
-      @heap.size.should eql(0)
-    end
-    
-    it "should let you initialize with an array" do
-      @heap = Containers::MaxHeap.new([1,2,3])
-      @heap.size.should eql(3)
-    end
 
+  it "should not let you merge with non-heaps" do
+    lambda { @heap.merge!(nil) }.should raise_error
+    lambda { @heap.merge!([]) }.should raise_error
   end
-  
-  describe "(non-empty)" do
-    before(:each) do
-      @random_array = []
-      @num_items = 100
-      @num_items.times { |x| @random_array << rand(@num_items) }
-      @heap = Containers::MaxHeap.new(@random_array)
-    end
-    
-    it "should display the correct size" do
-      @heap.size.should eql(@num_items)
-    end
-    
-    it "should be in max->min order" do
-      ordered = []
-      ordered << @heap.get_max! until @heap.size == 0
-      
-      ordered.should eql(@random_array.sort.reverse)
-    end
-    
-    it "should let you merge with another heap" do
-      numbers = [1,3,4,5]
-      otherheap = Containers::MaxHeap.new(numbers)
-      otherheap.size.should eql(4)
-      @heap.merge!(otherheap)
-      
-      ordered = []
-      ordered << @heap.get_max! until @heap.size == 0
-      
-      ordered.should eql( (@random_array + numbers).sort.reverse)
-    end
-    
-    describe "min-heap" do
-      it "should be in min->max order" do
-        @heap = Containers::MinHeap.new(@random_array)
-        ordered = []
-        ordered << @heap.get_min! until @heap.size == 0
-
-        ordered.should eql(@random_array.sort)
-      end
+
+  it "should return nil when getting the maximum" do
+    @heap.max!.should be_nil
+  end
+
+  it "should let you insert and remove one item" do
+    @heap.size.should eql(0)
+
+    @heap.push(1)
+    @heap.size.should eql(1)
+
+    @heap.max!.should eql(1)
+    @heap.size.should eql(0)
+  end
+
+  it "should let you initialize with an array" do
+    @heap = Containers::MaxHeap.new([1,2,3])
+    @heap.size.should eql(3)
+  end
+
+end
+
+describe "non-empty heap" do
+  before(:each) do
+    @random_array = []
+    @num_items = 100
+    @num_items.times { |x| @random_array << rand(@num_items) }
+    @heap = Containers::MaxHeap.new(@random_array)
+  end
+
+  it "should display the correct size" do
+    @heap.size.should eql(@num_items)
+  end
+
+  it "should delete random keys" do
+    @heap.delete(@random_array[0]).should eql(@random_array[0])
+    @heap.delete(@random_array[1]).should eql(@random_array[1])
+    ordered = []
+    ordered << @heap.max! until @heap.empty?
+    ordered.should eql( @random_array[2..-1].sort.reverse )
+  end
+
+  it "should delete all keys" do
+    ordered = []
+    @random_array.size.times do |t|
+      ordered << @heap.delete(@random_array[t])
     end
-    
+    @heap.should be_empty
+    ordered.should eql( @random_array )
+  end
+
+  it "should be in max->min order" do
+    ordered = []
+    ordered << @heap.max! until @heap.empty?
+
+    ordered.should eql(@random_array.sort.reverse)
+  end
+
+  it "should change certain keys" do
+    numbers = [1,2,3,4,5,6,7,8,9,10,100,101]
+    heap = Containers::MinHeap.new(numbers)
+    heap.change_key(101, 50)
+    heap.pop
+    heap.pop
+    heap.change_key(8, 0)
+    ordered = []
+    ordered << heap.min! until heap.empty?
+    ordered.should eql( [8,3,4,5,6,7,9,10,101,100] )
+  end
+
+  it "should not delete keys it doesn't have" do
+    @heap.delete(:nonexisting).should be_nil
+    @heap.size.should eql(@num_items)
+  end
+
+  it "should delete certain keys" do
+    numbers = [1,2,3,4,5,6,7,8,9,10,100,101]
+    heap = Containers::MinHeap.new(numbers)
+    heap.delete(5)
+    heap.pop
+    heap.pop
+    heap.delete(100)
+    ordered = []
+    ordered << heap.min! until heap.empty?
+    ordered.should eql( [3,4,6,7,8,9,10,101] )
+  end
+
+  it "should let you merge with another heap" do
+    numbers = [1,2,3,4,5,6,7,8]
+    otherheap = Containers::MaxHeap.new(numbers)
+    otherheap.size.should eql(8)
+    @heap.merge!(otherheap)
+
+    ordered = []
+    ordered << @heap.max! until @heap.empty?
+
+    ordered.should eql( (@random_array + numbers).sort.reverse)
+  end
+
+  it "min-heap should be in min->max order" do
+    @heap = Containers::MinHeap.new(@random_array)
+    ordered = []
+    ordered << @heap.min! until @heap.empty?
+
+    ordered.should eql(@random_array.sort)
   end
-  
-end
+end

data/spec/kd_tree_spec.rb

@@ -0,0 +1,89 @@
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
+
+#!/usr/bin/ruby
+# Small world puzzle
+# Kanwei Li, 2009
+
+# Make sure input file exists and read from it
+filename = ARGV[0]
+unless filename && File.exist?(filename)
+  puts "error: must specify a valid input file"
+  exit
+end
+input = File.open(filename)
+
+$points = [] # Store array of points as a global so we don't have to pass it around
+
+# Populate points array
+# while line = input.gets do
+#   break if line.empty?
+#   n, x, y = line.split(/\s+/)
+#   $points << [n.to_i, [x.to_f, y.to_f]]
+# end
+
+tree = Containers::KDTree.new($points)
+p tree
+
+$points.sort { |a, b| a[0] <=> b[0] }.each do |point|
+  nearest_4 = tree.find_nearest(point[1], 4)
+  puts "#{point[0]} #{nearest_4[1..-1].collect{ |n| n[1] }.join(',')}\n"
+end
+
+
+# describe "empty trie" do
+#   before(:each) do
+#     @trie = Containers::Trie.new
+#   end
+# 
+#   it "should not get or has_key?" do
+#     @trie.get("anything").should be_nil
+#     @trie.has_key?("anything").should be_false
+#   end
+# 
+#   it "should not have longest_prefix or match wildcards" do
+#     @trie.wildcard("an*thing").should eql([])
+#     @trie.longest_prefix("an*thing").should eql("")
+#   end
+# end
+# 
+# describe "non-empty trie" do
+#   before(:each) do
+#     @trie = Containers::Trie.new
+#     @trie.push("Hello", "World")
+#     @trie.push("Hilly", "World")
+#     @trie.push("Hello, brother", "World")
+#     @trie.push("Hello, bob", "World")
+#   end
+# 
+#   it "should has_key? keys it has" do
+#     @trie.has_key?("Hello").should be_true
+#     @trie.has_key?("Hello, brother").should be_true
+#     @trie.has_key?("Hello, bob").should be_true
+#   end
+# 
+#   it "should not has_key? keys it doesn't have" do
+#     @trie.has_key?("Nope").should be_false
+#   end
+# 
+#   it "should get values" do
+#     @trie.get("Hello").should eql("World")
+#   end
+# 
+#   it "should overwrite values" do
+#     @trie.push("Hello", "John")
+#     @trie.get("Hello").should eql("John")
+#   end
+# 
+#   it "should return longest prefix" do
+#     @trie.longest_prefix("Hello, brandon").should eql("Hello")
+#     @trie.longest_prefix("Hel").should eql("")
+#     @trie.longest_prefix("Hello").should eql("Hello")
+#     @trie.longest_prefix("Hello, bob").should eql("Hello, bob")
+#   end
+# 
+#   it "should match wildcards" do
+#     @trie.wildcard("H*ll.").should eql(["Hello", "Hilly"])
+#     @trie.wildcard("Hel").should eql([])
+#   end
+# end

data/spec/priority_queue_spec.rb

@@ -1,31 +1,75 @@
-require 'lib/algorithms'
+$: << File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib')
+require 'algorithms'
 
-describe Containers::RubyPriorityQueue do
+describe "empty priority queue" do
   before(:each) do
-    @q = Containers::RubyPriorityQueue.new
-  end
-  
-  describe "(empty)" do
-
-  end
-  
-  describe "(non-empty)" do
-    it "should give the correct length/size" do
-      20.times do | i |
-        @q.length.should eql(i)
-        @q[i] = i
-      end
-      10.times do | i |
-        @q.length.should eql(20-i)
-        @q.delete_min
-      end
-      10.times do | i |
-        @q.length.should eql(i+10)
-        @q[i] = i
-      end
-      @q.delete(5)
-      @q.length.should eql(19)
+    @q = Containers::PriorityQueue.new
+  end
+
+  it "should return 0 for size and be empty" do
+    @q.size.should eql(0)
+    @q.should be_empty
+  end
+
+  it "should not return anything" do
+    @q.next.should be_nil
+    @q.pop.should be_nil
+    @q.delete(1).should be_nil
+    @q.has_priority?(1).should be_false
+  end
+
+  it "should give the correct size when adding items" do
+    20.times do |i|
+      @q.size.should eql(i)
+      @q.push(i, i)
+    end
+    10.times do |i|
+      @q.size.should eql(20-i)
+      @q.pop
+    end
+    10.times do |i|
+      @q.size.should eql(i+10)
+      @q.push(i, i)
+    end
+    @q.delete(5)
+    @q.size.should eql(19)
+  end
+end
+
+describe "non-empty priority queue" do
+  before(:each) do
+    @q = Containers::PriorityQueue.new
+    @q.push("Alaska", 50)
+    @q.push("Delaware", 30)
+    @q.push("Georgia", 35)
+  end
+
+  it "should next/pop the highest priority" do
+    @q.next.should eql("Alaska")
+    @q.size.should eql(3)
+    @q.pop.should eql("Alaska")
+    @q.size.should eql(2)
+  end
+
+  it "should not be empty" do
+    @q.should_not be_empty
+  end
+
+  it "should has_priority? priorities it has" do
+    @q.has_priority?(50).should be_true
+    @q.has_priority?(10).should be_false
+  end      
+
+  it "should return nil after popping everything" do
+    3.times do 
+      @q.pop
     end
+    @q.pop.should be_nil
   end
-  
-end
+
+  it "should delete things it has and not things it doesn't" do
+    @q.delete(50).should eql("Alaska")
+    @q.delete(10).should eql(nil)
+  end
+
+end