Uploading whole MIT Course file

Author: codenigma1

Final_Exam/Problem_3.py

@@ -0,0 +1,34 @@
+# Problem 3
+# 10/10 points (graded)
+# Numbers in Mandarin follow 3 simple rules.
+
+# There are words for each of the digits from 0 to 10.
+# For numbers 11-19, the number is pronounced as "ten digit", so for example, 16 would be pronounced (using Mandarin) as "ten six".
+# For numbers between 20 and 99, the number is pronounced as “digit ten digit”, so for example, 37 would be pronounced (using Mandarin) as
+# "three ten seven". If the digit is a zero, it is not included.
+# Here is a simple Python dictionary that captures the numbers between 0 and 10.
+trans = {'0':'ling', '1':'yi', '2':'er', '3':'san', '4': 'si', '5':'wu', '6':'liu', '7':'qi', '8':'ba', '9':'jiu', '10': 'shi'}
+
+# We want to write a procedure that converts an American number (between 0 and 99), written as a string, into the equivalent Mandarin.
+
+# Example Usage
+# convert_to_mandarin('36') will return san shi liu
+# convert_to_mandarin('20') will return er shi
+# convert_to_mandarin('16') will return shi liu
+
+# Paste your function here
+def convert_to_mandarin(us_num):
+    '''
+    us_num, a string representing a US number 0 to 99
+    returns the string mandarin representation of us_num
+    '''
+    if int(us_num) <= 10:
+        return trans[us_num]
+    elif int(us_num) <= 19:
+        return 'shi ' + trans[us_num[1]]
+    elif int(us_num[1]) == 0:
+        return trans[us_num[0]] + ' shi'
+    else:
+        return trans[us_num[0]] + ' shi ' + trans[us_num[1]]
+        
+# Correct

Final_Exam/Problem_4.py

@@ -0,0 +1,18 @@
+def primes_list(N):
+    '''
+    N: an integer
+    '''
+    # Your code here
+    primes_no = []
+    for i in range(2, N+1):
+        for j in range(2, i):
+            if i % j == 0:
+                break
+        else:
+        	primes_no.append(i)        
+        	        
+    primes_no.sort()
+    return primes_no
+    
+
+print(primes_list(20))

Final_Exam/Problem_5.py

@@ -0,0 +1,33 @@
+# def uniqueValues(aDict):
+#     '''
+#     aDict: a dictionary
+#     returns: a sorted list of keys that map to unique aDict values, empty list if none
+#     '''
+#     # Your code here
+#     # old_aDict = aDict.values()
+#     # for keys, values in aDict.items():
+#     #     uniqList.append(values)
+#     # print (uniqList)
+
+#     # # Remove duplicates from uniqList
+#     # uniqList = list(set(uniqList))
+#     # print (uniqList)
+
+# from collections import Counter
+# def uniqueValues(aDict):
+#     count = Counter(aDict.values())
+#     print(count)
+#     # print(list_count)
+#     return sorted(k for k, v in count.items() if count[v] == 1)
+
+from collections import Counter
+def uniqueValues(aDict):
+    '''
+    aDict: a dictionary
+    returns: a sorted list of keys that map to unique aDict values, empty list if none
+    '''
+    unique_values = [k for k,v in aDict.items() if list(aDict.values()).count(v)==1]
+    return unique_values
+
+aDict = {1: 1, 2: 1, 3: 1}
+print(uniqueValues(aDict))

Final_Exam/Problem_6.py

@@ -0,0 +1,59 @@
+## DO NOT MODIFY THE IMPLEMENTATION OF THE Person CLASS ##
+class Person(object):
+    def __init__(self, name):
+        #create a person with name name
+        self.name = name
+        try:
+            firstBlank = name.rindex(' ')
+            self.lastName = name[firstBlank+1:]
+        except:
+            self.lastName = name
+        self.age = None
+    def getLastName(self):
+        #return self's last name
+        return self.lastName
+    def setAge(self, age):
+        #assumes age is an int greater than 0
+        #sets self's age to age (in years)
+        self.age = age
+    def getAge(self):
+        #assumes that self's age has been set
+        #returns self's current age in years
+        if self.age == None:
+            raise ValueError
+        return self.age
+    def __lt__(self, other):
+        #return True if self's name is lexicographically less
+        #than other's name, and False otherwise
+        if self.lastName == other.lastName:
+            return self.name < other.name
+        return self.lastName < other.lastName
+    def __str__(self):
+        #return self's name
+        return self.name
+        
+class USResident(Person):
+    """ 
+    A Person who resides in the US.
+    """
+    def __init__(self, name, status):
+        """ 
+        Initializes a Person object. A USResident object inherits 
+        from Person and has one additional attribute:
+        status: a string, one of "citizen", "legal_resident", "illegal_resident"
+        Raises a ValueError if status is not one of those 3 strings
+        """
+        # Write your code here
+        Person.__init__(self, name)
+        if status == "citizen" or status == "legal_resident" or status == "illegal_resident":
+            self.status = status
+        else:
+            raise ValueError    
+        
+    def getStatus(self):
+        """
+        Returns the status
+        """
+        # Write your code here
+        return self.status
+

Final_Exam/Problem_6/Problem_6-1.py

@@ -0,0 +1,68 @@
+# Problem 6-1
+# 10.0/10.0 points (graded)
+# This question has 3 parts
+
+# Consider the following hierarchy of classes:
+
+class Person(object):     
+    def __init__(self, name):         
+        self.name = name     
+    def say(self, stuff):         
+        return self.name + ' says: ' + stuff     
+    def __str__(self):         
+        return self.name  
+
+class Lecturer(Person):     
+    def lecture(self, stuff):         
+        return 'I believe that ' + Person.say(self, stuff)  
+
+class Professor(Lecturer): 
+    def say(self, stuff): 
+        return self.name + ' says: ' + self.lecture(stuff)
+
+class ArrogantProfessor(Professor): 
+    def say(self, stuff): 
+        return 'It is obvious that ' + self.say(stuff)
+        
+# As written, this code leads to an infinite loop when using the Arrogant Professor class.
+
+# Change the definition of ArrogantProfessor so that the following behavior is achieved:
+
+# e = Person('eric') 
+# le = Lecturer('eric') 
+# pe = Professor('eric') 
+# ae = ArrogantProfessor('eric')
+
+# >>> e.say('the sky is blue')
+# eric says: the sky is blue
+
+# >>> le.say('the sky is blue')
+# eric says: the sky is blue
+
+# >>> le.lecture('the sky is blue')
+# I believe that eric says: the sky is blue
+
+# >>> pe.say('the sky is blue')
+# eric says: I believe that eric says: the sky is blue
+
+# >>> pe.lecture('the sky is blue')
+# I believe that eric says: the sky is blue
+
+# >>> ae.say('the sky is blue')
+# eric says: It is obvious that eric says: the sky is blue
+
+# >>> ae.lecture('the sky is blue')
+# It is obvious that eric says: the sky is blue
+
+# For this question, you will not be able to see the test cases we run. This problem will test your ability to come up with your own
+# test cases.
+
+
+# Paste your class here
+class ArrogantProfessor(Person): 
+    def say(self, stuff): 
+        return self.name + ' says: ' + 'It is obvious that ' + self.name + ' says: ' + stuff
+    def lecture(self, stuff):
+        return 'It is obvious that ' + self.name + ' says: ' + stuff
+
+# Correct

Final_Exam/Problem_6/Problem_6-2.py

@@ -0,0 +1,26 @@
+# Problem 6-2
+# 10.0/10.0 points (graded)
+# You change your mind, and now want the behavior as described in Part 1, except that you want:
+
+# >>> ae.say('the sky is blue')
+# eric says: It is obvious that I believe that eric says: the sky is blue
+
+# >>> ae.lecture('the sky is blue')
+# It is obvious that I believe that eric says: the sky is blue
+
+# Change the definition of ArrogantProfessor so that the behavior described above is achieved.
+
+# Paste ONLY your ArrogantProfessor class in the box below. Do not leave any debugging print statements.
+
+# For this question, you will not be able to see the test cases we run. This problem will test your ability to come up with your own test
+# cases.
+
+
+# Paste your class here
+class ArrogantProfessor(Person): 
+    def say(self, stuff): 
+        return self.name + ' says: ' + 'It is obvious that I believe that ' + self.name + ' says: ' + stuff
+    def lecture(self, stuff):
+        return 'It is obvious that I believe that ' + self.name + ' says: ' + stuff
+
+# Correct

Final_Exam/Problem_6/Problem_6-3.py

@@ -0,0 +1,25 @@
+# Problem 6-3
+# 15.0/15.0 points (graded)
+# You change your mind once more. You want to keep the behavior from Part 2, but now you would like:
+
+# >>> pe.say('the sky is blue')
+# Prof. eric says: I believe that eric says: the sky is blue 
+
+# >>> ae.say('the sky is blue')
+# Prof. eric says: It is obvious that I believe that eric says: the sky is blue 
+
+# Change the Professor class definition in order to achieve this. You may have to modify your implmentation for a previous part to get
+# this to work.
+
+# Paste ONLY the Professor class in the box below. Do not leave any debugging print statements.
+
+# For this question, you will not be able to see the test cases we run. This problem will test your ability to come up with your own test
+# cases.
+
+
+# Paste your class here
+class Professor(Lecturer): 
+    def say(self, stuff): 
+        return 'Prof. ' + self.name + ' says: ' + self.lecture(stuff)
+
+# Correct

Final_Exam/Problem_7.py

@@ -0,0 +1,75 @@
+class Container(object):
+    """ Holds hashable objects. Objects may occur 0 or more times """
+    def __init__(self):
+        """ Creates a new container with no objects in it. I.e., any object 
+            occurs 0 times in self. """
+        self.vals = {}
+    def insert(self, e):
+        """ assumes e is hashable
+            Increases the number times e occurs in self by 1. """
+        try:
+            self.vals[e] += 1
+        except:
+            self.vals[e] = 1
+    def __str__(self):
+        s = ""
+        for i in sorted(self.vals.keys()):
+            if self.vals[i] != 0:
+                s += str(i)+":"+str(self.vals[i])+"\n"
+        return s
+
+class Bag(Container):
+    def remove(self, e):
+        """ assumes e is hashable
+            If e occurs in self, reduces the number of 
+            times it occurs in self by 1. Otherwise does nothing. """
+        if e in self.vals.keys():
+            self.vals[e] -= 1
+
+    def count(self, e):
+        """ assumes e is hashable
+            Returns the number of times e occurs in self. """
+        if e in self.vals.keys():
+            return self.vals[e]
+        else:
+            return 0
+    
+    def __add__(self, other):
+        """ assumes e is hashable
+            if bag 1 + bag 2 represent new bag """
+        new_bag = Bag()
+        
+        for item in self.vals.keys():
+            if item in new_bag.vals.keys():
+                new_bag.vals[item] += self.vals[item]
+            else:
+                new_bag.vals[item] = self.vals[item]
+        for element in other.vals.keys():
+            if element in new_bag.vals.keys():
+                new_bag.vals[element] += other.vals[element]
+            else:
+                new_bag.vals[element] = other.vals[element]
+        
+        return new_bag
+
+class ASet(Container):
+    def remove(self, e):
+        """assumes e is hashable, then remove"""
+        if e in self.vals.keys():
+            del self.vals[e]
+
+    def is_in(self, e):
+        """assumes e is hashable
+           returns True if subsequently in self and False otherwise."""
+        if e in self.vals.keys():
+            return True
+        else:
+            return False
+
+d1 = ASet()
+d1.insert(4)
+print(d1.is_in(4))
+d1.insert(5)
+print(d1.is_in(5))
+d1.remove(5)
+print(d1.is_in(5))

MidTerm_Exam/Problem_1.py

@@ -0,0 +1,24 @@
+def myLog(x, b):
+    '''
+    x: a positive integer
+    b: a positive integer; b >= 2
+
+    returns: log_b(x), or, the logarithm of x relative to a base b.
+    '''
+    # Your Code Here
+    # Here I am checking exponential value what it will be. run the program!
+
+    exp = 2;
+    if b**exp < x:
+    	while b**exp < x:
+    		exp = exp + 1
+    	if b**exp == x:	
+    		return exp
+    	else:
+    		return exp-1    		
+    else:
+    	return 0
+
+
+
+print(myLog(15, 3))