print 'number of paths of length 2 between a and b: ', g.num_paths('a', 'b', 2)

@@import HW2@@

@@g = HW2.load_dot(file_name)@@

returns the number of paths of length k between node1 and
node2

def num_paths(node1, node2, k) :

The graph is loaded from a file in @@dot@@ format. An example graph is provided [[Path:../../data/test.dot|here]], and the provided function should work for the limited subset of @@dot@@ markup that we will use. Make sure your graph class implements the interface required for it to work.

returns the number of paths of length k between node1 and node2

!!Programming Assignment 1 - Heaps

!!!Due: 1/30 at 5pm.

In this assignment you will program a heap. A heap is a complete binary tree that satisfies the ''heap property'', namely that the value stored in a given node in the tree is smaller than the values in the children. Your heap class should support the following methods:

* @@h = Heap()@@ - construct an empty heap
* @@insert(item)@@ - insert an item
* @@delete()@@ - remove the item at the root of the heap
* @@find_min()@@ - return the item at the root of the heap

The heap operations are implemented with the help of the @@heapify_down@@ and @@heapify_up@@ methods. These are described in pages 59-64 of the textbook. The items in the heap should be stored in a Python list. In your implementation please use 0-based indexing instead of the 1-based indexing used in the book. You may find it useful to implement the methods @@parent(i)@@, @@left_child(i)@@, and @@right_child(i)@@.

In addition to be above methods, you need to implement a @@__len__@@ method that returns the number of items in the heap. When this method is implemented, the @@len@@ operator will return the number of elements in the heap.

Your code should be contained in a single python file called @@hw1.py@@, and its structure should follow the skeleton code below. In addition to the @@Heap@@ class, your module should include a method called @@heap_sort@@ that sorts a list using the heap-sort algorithm. Some of comments are place-holders for your own comments.

"""
Assignment 1 - heaps

Your name goes here
"""
import math

class Heap (object) :
"""
A comment describing the class that you are implementing
"""
def __init__(self) :
"""
This is the constructor
"""
pass # the keyword "pass" means do nothing

def __len__(self) :
"""
This method should return the number of items in the heap
"""
return 0

def __repr__(self) :
"""
This method returns a string representation of a heap instance.
Useful for both debugging purposes, and for providing the user
with information about the instance.
"""
width = max([len(str(item)) for item in self.items])
if width%2==1:
width+=1
rows=math.floor(math.log(len(self),2))
output = []
length=math.pow(2,math.floor(math.log(len(self),2)))*(width+2)
for i in range(len(self)):
s='%'+str(length/2-(width+2)/2)+'s %'+str(width)+'s '+'%'+str(length/2-(width+2)/2)+'s'
output.append(s % ('',self.items[i],'') )
if math.floor(math.log(i+2,2))==math.log(i+2,2):
output.append("\n")
length=length/2

return ''.join(output)

def find_min(self) :
"""
return the smallest element in the heap
"""
raise NotImplemented
def insert(self, item) :
"""
insert item into the heap
"""
raise NotImplemented
def delete(self) :
"""
delete the smallest element from the heap
"""
raise NotImplemented
def heapify_up(self) :
"""
performs a heapify-up operation that starts at the last element in the heap
"""
self.recursive_heapify_up(len(self) - 1)

def recursive_heapify_up(self, i) :
"""
recursively heapify-up
"""
raise NotImplemented

def heapify_down(self) :
"""
Perform heapify-down starting from the root of the tree
"""
self.recursive_heapify_down(0)

def recursive_heapify_down(self, i) :
"""
recursively heapify-down starting from a given node
"""
raise NotImplemented

def heap_sort(in_list) :
"""
returns a sorted version of the list given as input; sorting is performed
using the heap-sort algorithm
Usage:
out_list = heap_sort(in_list)
in_list should be unchanged as a result of the operation
"""
if type(in_list) != list :
raise ValueError, "expecting a list as input"
return

if __name__ == '__main__' :

items = [3, 5, 8, 1, 4, 9, 10, 2, 6, 7, 11]
h = Heap()
for item in items :
print 'adding ', item
h.insert(item)
h.delete()
print h
print heap_sort(items)

(:sourceend:)

The heap operations are implemented with the help of the @@heapify_down@@ and @@heapify_up@@ methods. These are described in pages 60-64 of the textbook. In your implementation please use 0-based indexing instead of the 1-based indexing used in the book. You may find it useful to implement the methods @@parent(i)@@, @@left_child(i)@@, and @@right_child(i)@@.

h.delete(7)

!!!Due: Feb 4th at 5pm.

In this assignment you will program a heap. A heap is a complete binary tree that satisfies the ''heap property'', namely that the value stored in a given node in the tree is smaller than the values in the children. Your heap should support the following operations:

The heap operations are implemented with the help of the @@heapify_down@@ and @@heapify_up@@ methods. These are described in pages 60-64 of the Kleinberg and Tardos book. In your implementation please use 0-based indexing instead of the 1-based indexing used in the book. You may find it useful to implement the methods @@parent(i)@@, @@left_child(i)@@, and @@right_child(i)@@.

Your code should be structured as a single python file called @@heapy.py@@, and its structure should follow the skeleton code below. In addition to the @@Heap@@ class, your module should include a method called @@heap_sort@@ that sorts a list using the heap-sort algorithm. Some of comments are place-holders for your own comments.

pwr = 0
row = []
row_size = 0
for i in range(len(self)) :
row.append(str(self.items[i]))
row_size += 1
if row_size == int(math.pow(2, pwr)) :
output.append(' '.join(row))
row = []
pwr += 1
row_size = 0
if len(row) > 0 :
output.append(' '.join(row))
return '\n\n'.join(output)

Your code should be structured as a single python file called @@heapy.py@@, and its structure should follow the skeleton code below. In addition to the @@Heap@@ class, your module should include a method called @@heap_sort@@ that sorts a list using the heap-sort algorithm.

!Due: Feb 4th at 5pm.

The following is skeleton code that will help you in implementing your class:

def heap_sort(l) :

if type(l) != list :