Lessons 1-2 completed.

Author: linkel

1-intro/Basics.py

@@ -0,0 +1,15 @@
+# Write a function called "show_excitement" where the string
+# "I am super excited for this course!" is returned exactly
+# 5 times, where each sentence is separated by a single space.
+# Return the string with "return".
+# You can only have the string once in your code.
+# Don't just copy/paste it 5 times into a single variable!
+
+
+def show_excitement():
+    # Your code goes here!
+    here = ''
+    for i in range(5):
+        here += "I am super excited for this course! "
+    return here[:-1]
+print show_excitement()s

1-intro/Efficiency.py

@@ -0,0 +1,35 @@
+"""input manatees: a list of "manatees", where one manatee is represented by a dictionary
+a single manatee has properties like "name", "age", et cetera
+n = the number of elements in "manatees"
+m = the number of properties per "manatee" (i.e. the number of keys in a manatee dictionary)"""
+
+def example1(manatees):
+    for manatee in manatees:
+        print manatee['name']
+
+#O(n)
+
+def example2(manatees):
+    print manatees[0]['name']
+    print manatees[0]['age']
+
+#O(1)
+
+def example3(manatees):
+    for manatee in manatees:
+        for manatee_property in manatee:
+            print manatee_property, ": ", manatee[manatee_property]
+
+#O(n*m)
+
+def example4(manatees):
+    oldest_manatee = "No manatees here!"
+    for manatee1 in manatees:
+        for manatee2 in manatees:
+            if manatee1['age'] < manatee2['age']:
+                oldest_manatee = manatee2['name']
+            else:
+                oldest_manatee = manatee1['name']
+    print oldest_manatee
+
+#O(n^2)

1-intro/Practice.py

@@ -0,0 +1,51 @@
+"""You can use this class to represent how classy someone
+or something is.
+"Classy" is interchangable with "fancy".
+If you add fancy-looking items, you will increase
+your "classiness".
+Create a function in "Classy" that takes a string as
+input and adds it to the "items" list.
+Another method should calculate the "classiness"
+value based on the items.
+The following items have classiness points associated
+with them:
+"tophat" = 2
+"bowtie" = 4
+"monocle" = 5
+Everything else has 0 points.
+Use the test cases below to guide you!"""
+
+class Classy(object):
+    def __init__(self):
+        self.items = []
+    def addItem(self, item):
+        self.items.append(item)
+    def getClassiness(self):
+        totalClassiness = 0
+        classyDict = {"tophat":2,"bowtie":4,"monocle":5}
+        for item in self.items:
+            try:
+                totalClassiness += classyDict[item]
+            except KeyError:
+                pass
+        return totalClassiness
+
+# Test cases
+me = Classy()
+
+# Should be 0
+print me.getClassiness()
+
+me.addItem("tophat")
+# Should be 2
+print me.getClassiness()
+
+me.addItem("bowtie")
+me.addItem("jacket")
+me.addItem("monocle")
+# Should be 11
+print me.getClassiness()
+
+me.addItem("bowtie")
+# Should be 15
+print me.getClassiness()

2-list-based-collections/LinkedList-mine.py

@@ -0,0 +1,102 @@
+"""The LinkedList code from before is provided below.
+Add three functions to the LinkedList.
+"get_position" returns the element at a certain position.
+The "insert" function will add an element to a particular
+spot in the list.
+"delete" will delete the first element with that
+particular value.
+Then, use "Test Run" and "Submit" to run the test cases
+at the bottom."""
+
+class Element(object):
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+        
+class LinkedList(object):
+    def __init__(self, head=None):
+        self.head = head
+        
+    def append(self, new_element):
+        current = self.head
+        if self.head:
+            while current.next:
+                current = current.next
+            current.next = new_element
+        else:
+            self.head = new_element
+            
+    def get_position(self, position):
+        """Get an element from a particular position.
+        Assume the first position is "1".
+        Return "None" if position is not in the list."""
+        current = self.head
+        if current == None:
+            return None
+        pos = 1
+        while pos < position:
+            if current.next == None:
+                return None
+            current = current.next
+            pos += 1
+        return current
+    
+    def insert(self, new_element, position):
+        """Insert a new node at the given position.
+        Assume the first position is "1".
+        Inserting at position 3 means between
+        the 2nd and 3rd elements."""
+        current = self.head
+        pos = 1
+        while pos < position - 1:
+            current = current.next
+            pos += 1
+        new_element.next = current.next
+        current.next = new_element
+        
+    def delete(self, value):
+        """Delete the first node with a given value."""
+        current = self.head
+        if current.value == value:
+            if self.head.next:
+                self.head = self.head.next
+            else:
+                self.head = None
+        if self.head:
+            while current.next:
+                if current.next.value == value:
+                    current.next = current.next.next
+                    break
+                current = current.next
+
+# Test cases
+# Set up some Elements
+e1 = Element(1)
+e2 = Element(2)
+e3 = Element(3)
+e4 = Element(4)
+
+# Start setting up a LinkedList
+ll = LinkedList(e1)
+ll.append(e2)
+ll.append(e3)
+
+# Test get_position
+# Should print 3
+print ll.head.next.next.value
+# Should also print 3
+print ll.get_position(3).value
+
+# Test insert
+ll.insert(e4,3)
+# Should print 4 now
+print ll.get_position(3).value
+
+# Test delete
+ll.delete(1)
+# Should print 2 now
+print ll.get_position(1).value
+# Should print 4 now
+print ll.get_position(2).value
+# Should print 3 now
+print ll.get_position(3).value

2-list-based-collections/LinkedList.py

@@ -0,0 +1,55 @@
+class Element(object):
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+
+class LinkedList(object):
+    def __init__(self, head=None):
+        self.head = head
+
+    def append(self, new_element):
+        current = self.head
+        if self.head:
+            while current.next:
+                current = current.next
+            current.next = new_element
+        else:
+            self.head = new_element
+
+    def get_position(self, position):
+        counter = 1
+        current = self.head
+        if position < 1:
+            return None
+        while current and counter <= position:
+            if counter == position:
+                return current
+            current = current.next
+            counter += 1
+        return None
+
+    def insert(self, new_element, position):
+        counter = 1
+        current = self.head
+        if position > 1:
+            while current and counter < position:
+                if counter == position - 1:
+                    new_element.next = current.next
+                    current.next = new_element
+                current = current.next
+                counter += 1
+        elif position == 1:
+            new_element.next = self.head
+            self.head = new_element
+
+    def delete(self, value):
+        current = self.head
+        previous = None
+        while current.value != value and current.next:
+            previous = current
+            current = current.next
+        if current.value == value:
+            if previous:
+                previous.next = current.next
+            else:
+                self.head = current.next

2-list-based-collections/Queue-mine.py

@@ -0,0 +1,43 @@
+"""Make a Queue class using a list!
+Hint: You can use any Python list method
+you'd like! Try to write each one in as 
+few lines as possible.
+Make sure you pass the test cases too!"""
+
+class Queue:
+    def __init__(self, head=None):
+        self.storage = [head]
+
+    def enqueue(self, new_element):
+        self.storage.append(new_element)
+
+    def peek(self):
+        return self.storage[0]
+
+    def dequeue(self):
+        return self.storage.pop(0)
+    
+# Setup
+q = Queue(1)
+q.enqueue(2)
+q.enqueue(3)
+
+# Test peek
+# Should be 1
+print q.peek()
+
+# Test dequeue
+# Should be 1
+print q.dequeue()
+
+# Test enqueue
+q.enqueue(4)
+# Should be 2
+print q.dequeue()
+# Should be 3
+print q.dequeue()
+# Should be 4
+print q.dequeue()
+q.enqueue(5)
+# Should be 5
+print q.peek()

2-list-based-collections/Stack-mine.py

@@ -0,0 +1,81 @@
+"""Add a couple methods to our LinkedList class,
+and use that to implement a Stack.
+You have 4 functions below to fill in:
+insert_first, delete_first, push, and pop.
+Think about this while you're implementing:
+why is it easier to add an "insert_first"
+function than just use "append"?"""
+
+# insert first function is easier for a linked list based stack
+# because if you take out the first object, you only need to change the first,
+# whereas taking out the last object requires changing the .next of the previous node.
+
+class Element(object):
+    def __init__(self, value):
+        self.value = value
+        self.next = None
+        
+class LinkedList(object):
+    def __init__(self, head=None):
+        self.head = head
+        
+    def append(self, new_element):
+        current = self.head
+        if self.head:
+            while current.next:
+                current = current.next
+            current.next = new_element
+        else:
+            self.head = new_element
+
+    def insert_first(self, new_element):
+        "Insert new element as the head of the LinkedList"
+        new_element.next = self.head
+        self.head = new_element
+
+    def delete_first(self):
+        "Delete the first (head) element in the LinkedList as return it"
+        first = self.head
+        if self.head:
+            self.head = self.head.next
+            first.next = None
+        return first
+
+class Stack(object):
+    def __init__(self,top=None):
+        self.ll = LinkedList(top)
+
+    def push(self, new_element):
+        "Push (add) a new element onto the top of the stack"
+        self.ll.insert_first(new_element)
+
+    def pop(self):
+        "Pop (remove) the first element off the top of the stack and return it"
+        return self.ll.delete_first()
+        
+    def printme(self):
+        curr = self.ll.head
+        print curr.value
+        while curr.next:
+            curr = curr.next
+            print curr.value
+    
+# Test cases
+# Set up some Elements
+e1 = Element(1)
+e2 = Element(2)
+e3 = Element(3)
+e4 = Element(4)
+
+# Start setting up a Stack
+stack = Stack(e1)
+
+# Test stack functionality
+stack.push(e2)
+stack.push(e3)
+print stack.pop().value
+print stack.pop().value
+print stack.pop().value
+print stack.pop()
+stack.push(e4)
+print stack.pop().value