mandarin converter

Author: slanj

class_hashable.py

@@ -0,0 +1,42 @@
+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 ASet(Container):
+    def remove(self, e):
+        """assumes e is hashable
+           removes e from self"""
+        try:
+            del(self.vals[e])
+        except:
+            return None
+
+    def is_in(self, e):
+        """assumes e is hashable
+           returns True if e has been inserted in self and
+           not subsequently removed, and False otherwise."""
+        return e in self.vals
+
+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))

class_resident.py

@@ -0,0 +1,62 @@
+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
+        """
+        Person.__init__(self, name)
+        statuses = ["citizen", "legal_resident", "illegal_resident"]
+        if status in statuses:
+            self.status = status
+        else:
+            raise ValueError
+
+    def getStatus(self):
+        """
+        Returns the status
+        """
+        # Write your code here
+        return self.status
+
+a = USResident('Tim Beaver', 'citizen')
+print(a.getStatus())
+b = USResident('Tim Horton', 'illegal_resident')
+print(b.getStatus())

dict_interdiff.py

@@ -0,0 +1,39 @@
+def dict_interdiff(d1, d2):
+    '''
+    d1, d2: dicts whose keys and values are integers
+    Returns a tuple of dictionaries according to the instructions above
+    '''
+    interselect = {}
+    difference = {}
+
+    for key1, value1 in d1.items():
+        for key2, value2 in d2.items():
+             if key1 == key2:
+                 interselect[key1] = f(value1, value2)
+
+    for key1, value1 in d1.items():
+        uniq = True
+        for key2, value2 in d2.items():
+             if key1 == key2:
+                 uniq = False
+        if uniq:
+            difference[key1] = value1
+
+    for key2, value2 in d2.items():
+        uniq = True
+        for key1, value1 in d1.items():
+             if key1 == key2:
+                 uniq = False
+        if uniq:
+            difference[key2] = value2
+
+    return interselect, difference
+
+
+def f(a, b):
+    return a + b
+
+d1 = {1:30, 2:20, 3:30, 5:80}
+d2 = {1:40, 2:50, 3:60, 4:70, 6:90}
+
+print(dict_interdiff(d1, d2))

mandarin_num.py

@@ -0,0 +1,21 @@
+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
+    '''
+    trans = {'0':'ling', '1':'yi', '2':'er', '3':'san', '4': 'si',
+          '5':'wu', '6':'liu', '7':'qi', '8':'ba', '9':'jiu', '10': 'shi'}
+    num = int(us_num)
+
+    if num < 11:
+        mandarin = trans[us_num]
+    elif num < 20:
+        mandarin = trans['10'] + " " + trans[str(num % 10)]
+    elif num % 10 == 0:
+        mandarin = trans[str(num // 10)] + " " + trans['10']
+    else:
+        mandarin = trans[str(num // 10)] + " " + trans['10'] + " " + trans[str(num % 10)]
+
+    return mandarin
+
+print(convert_to_mandarin("36"))

odd_times.py

@@ -0,0 +1,24 @@
+def largest_odd_times(L):
+    """ Assumes L is a non-empty list of ints
+        Returns the largest element of L that occurs an odd number
+        of times in L. If no such element exists, returns None """
+    odd = 0
+    nums = {}
+    odd_times = {}
+    for num in L:
+        nums[num] = nums.get(num, 0) + 1
+
+    for key, num in nums.items():
+        if num % 2 != 0:
+            odd_times[key] = num
+
+    for num in odd_times.keys():
+        if num > odd:
+            odd = num
+
+    if odd == 0:
+        return None
+
+    return odd
+
+print(largest_odd_times([6, 8, 6, 8, 6, 8, 6, 8, 6, 8]))