From 752178587821d5fe0870b9b8031cdaed5a08f5f6 Mon Sep 17 00:00:00 2001 From: salads-source <85385326+salads-source@users.noreply.github.com> Date: Thu, 19 Aug 2021 11:09:11 +0800 Subject: [PATCH 1/2] homework submitted --- .DS_Store | Bin 6148 -> 8196 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/.DS_Store b/.DS_Store index bdd81b5114d49485504408404313a525b47aa874..4791d80031e7db085fd20c11f57048379d088a37 100644 GIT binary patch delta 368 zcmZoMXmOBWU|?W$DortDU;r^WfEYvza8E20o2aKKEC`YZ@)`1zlXCKtKvJ6pImB2t zD{%BPFJ|Z9nApI=C^*@JWj~*>rGbuup@ng+jzYD$`D9VnT1KPE6)gRHCWe+k2{Qw@ zgd?v}S#VKaPJUiG$oR>fton?`V5P?9Mmh?{hR8~dQIxJ{4P`XNWvVHP(%-C_?92=v z4B-rBxHOm{YuK#F_Kb02LxvzT&{04j!3`u_L16*(@ptCQ{34!{{dqVzfWZL@CWguJ RJX0qxXGy^3KWql40sxTkU6l^S9 z&TI>k;bZV%2xl;0Fl9iJWyoOAV<=##^vuamPRhwof*RQjG)V407%(tQ<`LM>XJlcj zqhMleS*xQ^ZD}+)K*Vvfl%UOIZy~kGX~I5}my0ND-Xr>$aWOjwhafZ16p%sOK*AN| dzKw<7nJ4qhc!FHZzyxtQ$TJL^<9X&V0{|M?E9?LO From 4ecd0156bce7daf01ebebb2140fd99818298b07d Mon Sep 17 00:00:00 2001 From: salads-source <85385326+salads-source@users.noreply.github.com> Date: Thu, 19 Aug 2021 11:30:37 +0800 Subject: [PATCH 2/2] Homework Submitted --- .DS_Store | Bin 6148 -> 6148 bytes HW1/hw01_ron.py | 88 ++++++++++ HW2/.DS_Store | Bin 0 -> 6148 bytes HW3/hw03_ron.py | 93 +++++++++++ HW4/ron_hw04.py | 115 +++++++++++++ HW5/ron_hw05.py | 427 ++++++++++++++++++++++++++++++++++++++++++++++++ HW6/ron_hw06.py | 49 ++++++ 7 files changed, 772 insertions(+) create mode 100755 HW1/hw01_ron.py create mode 100644 HW2/.DS_Store create mode 100755 HW3/hw03_ron.py create mode 100755 HW4/ron_hw04.py create mode 100755 HW5/ron_hw05.py create mode 100755 HW6/ron_hw06.py diff --git a/.DS_Store b/.DS_Store index bdd81b5114d49485504408404313a525b47aa874..3a2700e7f9c0fd055422891d479271f3382ac320 100644 GIT binary patch delta 56 zcmZoMXfc=&!Iht!l#`#tz`!7|S&(BTGb7h#50*WQyryNrMR_^-dFenI#?8N3d6*_P LsBLEF_{$Ff(vlE; delta 107 zcmZoMXfc=&!NU;G;Kh*7P|T3ZP_S8$V>z=e7Xt$WAA<)&ID-L$DY7&}27?|$0Yjx{ vPJVJyPJR+lod6IwGcYj9{RaaEhRr-Idl(tbCL6K}Z~nyko^dlf$6tN`Dq9>l diff --git a/HW1/hw01_ron.py b/HW1/hw01_ron.py new file mode 100755 index 0000000..655b6bc --- /dev/null +++ b/HW1/hw01_ron.py @@ -0,0 +1,88 @@ +""" Homework 1: Control """ + +# Q1 +from operator import add, sub + +def a_plus_abs_b(a, b): + if b < 0: + result= float(a+abs(b)) + return result + else: + result=float(a+b) + return result + + + +# Q2 +def two_of_three(a, b, c): + return x**2 + y**2 + z**2 - min(x, y, z) ** 2 + +def two_biggest(a, b, c): + if a>=b>=c: + return a**2+b**2 + elif b>=c>=a: + return b**2+c**2 + else: + return c**2 + a**2 +# Q3 +def largest_factor(n): + for i in range(n-1, 0, -1): + if n % i == 0: + return i +# Q4 +def if_function(condition, true_result, false_result): + if condition: + return true_result + else: + return false_result + + +def with_if_statement(): + """ + >>> result = with_if_statement() + 2 + >>> print(result) + None + """ + if c(): + return t() + else: + return f() + +def with_if_function(): + """ + >>> result = with_if_function() + 1 + 2 + >>> print(result) + None + """ + return if_function(c(), t(), f()) + +def c(): + "*** YOUR CODE HERE ***" + +def t(): + "*** YOUR CODE HERE ***" + +def f(): + "*** YOUR CODE HERE ***" + +# Q5 + def hailstone(n): + count = 1 + while n != 1: + if n % 2 == 0: + n = n / 2 + else: + n = ((n * 3) + 1) + print(n) + count += 1 + print(count) + + + +# Q6 +quine = """ +"*** YOUR CODE HERE ***" +""" \ No newline at end of file diff --git a/HW2/.DS_Store b/HW2/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6 GIT binary patch literal 6148 zcmeH~Jr2S!425mzP>H1@V-^m;4Wg<&0T*E43hX&L&p$$qDprKhvt+--jT7}7np#A3 zem<@ulZcFPQ@L2!n>{z**++&mCkOWA81W14cNZlEfg7;MkzE(HCqgga^y>{tEnwC%0;vJ&^%eQ zLs35+`xjp>T0>> accumulate(add, 0, 5, identity) # 0 + 1 + 2 + 3 + 4 + 5 + 15 + >>> accumulate(add, 11, 5, identity) # 11 + 1 + 2 + 3 + 4 + 5 + 26 + >>> accumulate(add, 11, 0, identity) # 11 + 11 + >>> accumulate(add, 11, 3, square) # 11 + 1^2 + 2^2 + 3^2 + 25 + >>> accumulate(mul, 2, 3, square) # 2 * 1^2 * 2^2 * 3^2 + 72 + """ + total, k = base, 1 + while k <= n: + total, k = combiner(total, term(k)), k + 1 + return total + +def filtered_accumulate(combiner, base, pred, n, term): + """Return the result of combining the terms in a sequence of N terms + that satisfy the predicate pred. combiner is a two-argument function. + If v1, v2, ..., vk are the values in term(1), term(2), ..., term(N) + that satisfy pred, then the result is + base combiner v1 combiner v2 ... combiner vk + (treating combiner as if it were a binary operator, like +). The + implementation uses accumulate. + + >>> filtered_accumulate(add, 0, lambda x: True, 5, identity) # 0 + 1 + 2 + 3 + 4 + 5 + 15 + >>> filtered_accumulate(add, 11, lambda x: False, 5, identity) # 11 + 11 + >>> filtered_accumulate(add, 0, odd, 5, identity) # 0 + 1 + 3 + 5 + 9 + >>> filtered_accumulate(mul, 1, greater_than_5, 5, square) # 1 * 9 * 16 * 25 + 3600 + >>> # Do not use while/for loops or recursion + >>> from construct_check import check + >>> check(HW_SOURCE_FILE, 'filtered_accumulate', + ... ['While', 'For', 'Recursion']) + True + """ + def combine_if(x, y): + "*** YOUR CODE HERE ***" + return accumulate(combine_if, base, n, term) + +def odd(x): + return x % 2 == 1 + +def greater_than_5(x): + return x > 5 \ No newline at end of file diff --git a/HW4/ron_hw04.py b/HW4/ron_hw04.py new file mode 100755 index 0000000..306d684 --- /dev/null +++ b/HW4/ron_hw04.py @@ -0,0 +1,115 @@ +HW_SOURCE_FILE = 'hw04.py' + +############### +# Questions # +############### + +def intersection(st, ave): + """Represent an intersection using the Cantor pairing function.""" + return (st+ave)*(st+ave+1)//2 + ave + +def street(inter): + return w(inter) - avenue(inter) + +def avenue(inter): + return inter - (w(inter) ** 2 + w(inter)) // 2 + +w = lambda z: int(((8*z+1)**0.5-1)/2) + +def taxicab(a, b): + return (max(street(a), street(b)) - min(street(a), street(b)) + max(avenue(a), avenue(b)) - max(avenue(a),avenue(b))) + +def squares(s): + """Returns a new list containing square roots of the elements of the + original list that are perfect squares. + + >>> seq = [8, 49, 8, 9, 2, 1, 100, 102] + >>> squares(seq) + [7, 3, 1, 10] + >>> seq = [500, 30] + >>> squares(seq) + [] + """ + "*** YOUR CODE HERE ***" + +def g(n): + def g(n): + if n<=3: + return n + else: + return g(n-1)+2*g(n-2)+3*g(n-3) + +def g_iter2(n): + i = 1 + curr, mid, next = 1, 2, 3 + while i < n: + curr, mid, next = mid, next, next + mid * 2 + curr * 3 + i += 1 + return curr + +def count_change(amount): + def largest_demon(n): + n=1 + while n<=amount: + if n//2==0: + return n + n*=2 + + def count_partition(amount, m): + if amount==0 or m==0: + return 1 + elif amount<0: + return 0 + else: + return count_partition(amount - m, m) + count_partition(amount, m // 2) + +def print_move(origin, destination): + """Print instructions to move a disk.""" + print("Move the top disk from rod", origin, "to rod", destination) + +def move_stack(n, start, end): + """Print the moves required to move n disks on the start pole to the end + pole without violating the rules of Towers of Hanoi. + + n -- number of disks + start -- a pole position, either 1, 2, or 3 + end -- a pole position, either 1, 2, or 3 + + There are exactly three poles, and start and end must be different. Assume + that the start pole has at least n disks of increasing size, and the end + pole is either empty or has a top disk larger than the top n start disks. + + >>> move_stack(1, 1, 3) + Move the top disk from rod 1 to rod 3 + >>> move_stack(2, 1, 3) + Move the top disk from rod 1 to rod 2 + Move the top disk from rod 1 to rod 3 + Move the top disk from rod 2 to rod 3 + >>> move_stack(3, 1, 3) + Move the top disk from rod 1 to rod 3 + Move the top disk from rod 1 to rod 2 + Move the top disk from rod 3 to rod 2 + Move the top disk from rod 1 to rod 3 + Move the top disk from rod 2 to rod 1 + Move the top disk from rod 2 to rod 3 + Move the top disk from rod 1 to rod 3 + """ + assert 1 <= start <= 3 and 1 <= end <= 3 and start != end, "Bad start/end" + "*** YOUR CODE HERE ***" + +################### +# Extra Questions # +################### + +from operator import sub, mul + +def make_anonymous_factorial(): + """Return the value of an expression that computes factorial. + + >>> make_anonymous_factorial()(5) + 120 + >>> from construct_check import check + >>> check(HW_SOURCE_FILE, 'make_anonymous_factorial', ['Assign', 'AugAssign', 'FunctionDef', 'Recursion']) + True + """ + return 'YOUR_EXPRESSION_HERE' diff --git a/HW5/ron_hw05.py b/HW5/ron_hw05.py new file mode 100755 index 0000000..ce3f5e5 --- /dev/null +++ b/HW5/ron_hw05.py @@ -0,0 +1,427 @@ +######### +# Trees # +######### + +def tree(label, branches=[]): + """Construct a tree with the given label value and a list of branches.""" + for branch in branches: + assert is_tree(branch), 'branches must be trees' + return [label] + list(branches) + +def label(tree): + """Return the label value of a tree.""" + return tree[0] + +def branches(tree): + """Return the list of branches of the given tree.""" + return tree[1:] + +def is_tree(tree): + """Returns True if the given tree is a tree, and False otherwise.""" + if type(tree) != list or len(tree) < 1: + return False + for branch in branches(tree): + if not is_tree(branch): + return False + return True + +def is_leaf(tree): + """Returns True if the given tree's list of branches is empty, and False + otherwise. + """ + return not branches(tree) + +def print_tree(t, indent=0): + """Print a representation of this tree in which each node is + indented by two spaces times its depth from the root. + + >>> print_tree(tree(1)) + 1 + >>> print_tree(tree(1, [tree(2)])) + 1 + 2 + >>> numbers = tree(1, [tree(2), tree(3, [tree(4), tree(5)]), tree(6, [tree(7)])]) + >>> print_tree(numbers) + 1 + 2 + 3 + 4 + 5 + 6 + 7 + """ + print(' ' * indent + str(label(t))) + for b in branches(t): + print_tree(b, indent + 1) + +def copy_tree(t): + """Returns a copy of t. Only for testing purposes. + + >>> t = tree(5) + >>> copy = copy_tree(t) + >>> t = tree(6) + >>> print_tree(copy) + 5 + """ + return tree(label(t), [copy_tree(b) for b in branches(t)]) + +###################### +# Required questions # +###################### + +def replace_leaf(t, old, new): + """Returns a new tree where every leaf value equal to old has + been replaced with new. + + >>> yggdrasil = tree('odin', + ... [tree('balder', + ... [tree('thor'), + ... tree('loki')]), + ... tree('frigg', + ... [tree('thor')]), + ... tree('thor', + ... [tree('sif'), + ... tree('thor')]), + ... tree('thor')]) + >>> laerad = copy_tree(yggdrasil) # copy yggdrasil for testing purposes + >>> print_tree(replace_leaf(yggdrasil, 'thor', 'freya')) + odin + balder + freya + loki + frigg + freya + thor + sif + freya + freya + >>> laerad == yggdrasil # Make sure original tree is unmodified + True + """ + "*** YOUR CODE HERE ***" + +# Mobiles + +def mobile(left, right): + """Construct a mobile from a left side and a right side.""" + assert is_side(left), "left must be a side" + assert is_side(right), "right must be a side" + return ['mobile', left, right] + +def is_mobile(m): + """Return whether m is a mobile.""" + return type(m) == list and len(m) == 3 and m[0] == 'mobile' + +def left(m): + """Select the left side of a mobile.""" + assert is_mobile(m), "must call left on a mobile" + return m[1] + +def right(m): + """Select the right side of a mobile.""" + assert is_mobile(m), "must call right on a mobile" + return m[2] + +def side(length, mobile_or_weight): + """Construct a side: a length of rod with a mobile or weight at the end.""" + assert is_mobile(mobile_or_weight) or is_weight(mobile_or_weight) + return ['side', length, mobile_or_weight] + +def is_side(s): + """Return whether s is a side.""" + return type(s) == list and len(s) == 3 and s[0] == 'side' + +def length(s): + """Select the length of a side.""" + assert is_side(s), "must call length on a side" + return s[1] + +def end(s): + """Select the mobile or weight hanging at the end of a side.""" + assert is_side(s), "must call end on a side" + return s[2] + +def weight(size): + """Construct a weight of some size.""" + assert size > 0 + "*** YOUR CODE HERE ***" + +def size(w): + """Select the size of a weight.""" + assert is_weight(w), 'must call size on a weight' + "*** YOUR CODE HERE ***" + +def is_weight(w): + """Whether w is a weight.""" + return type(w) == list and len(w) == 2 and w[0] == 'weight' + +def examples(): + t = mobile(side(1, weight(2)), + side(2, weight(1))) + u = mobile(side(5, weight(1)), + side(1, mobile(side(2, weight(3)), + side(3, weight(2))))) + v = mobile(side(4, t), side(2, u)) + return (t, u, v) + +def total_weight(m): + """Return the total weight of m, a weight or mobile. + + >>> t, u, v = examples() + >>> total_weight(t) + 3 + >>> total_weight(u) + 6 + >>> total_weight(v) + 9 + """ + if is_weight(m): + return size(m) + else: + assert is_mobile(m), "must get total weight of a mobile or a weight" + return total_weight(end(left(m))) + total_weight(end(right(m))) + +def balanced(m): + """Return whether m is balanced. + + >>> t, u, v = examples() + >>> balanced(t) + True + >>> balanced(v) + True + >>> w = mobile(side(3, t), side(2, u)) + >>> balanced(w) + False + >>> balanced(mobile(side(1, v), side(1, w))) + False + >>> balanced(mobile(side(1, w), side(1, v))) + False + """ + "*** YOUR CODE HERE ***" + +def totals_tree(m): + """Return a tree representing the mobile with its total weight at the root. + + >>> t, u, v = examples() + >>> print_tree(totals_tree(t)) + 3 + 2 + 1 + >>> print_tree(totals_tree(u)) + 6 + 1 + 5 + 3 + 2 + >>> print_tree(totals_tree(v)) + 9 + 3 + 2 + 1 + 6 + 1 + 5 + 3 + 2 + """ + "*** YOUR CODE HERE ***" + +# Mutable functions in Python + +def make_counter(): + m = {} + + def counter(string): + nonlocal string + m[string] = m.get(string, 0) + 1 + return m[string] + return counter + +def make_fib(): + current, next = 0, 1 + def fib(): + nonlocal current, next + result = current + current, next = next, current + next + return result + return fib + +def make_withdraw(balance, password): + password_attempts=[] + def withdraw(withdraw_amount, p): + nonlocal balance + if p!=password and len(password_attempts)>=3: + return ("Your Account is Locked.") + elif p!=password: + password_attempts.append(p) + return ("Incorrect Password") + else: + if withdraw_amount > balance: + return 'Insufficient funds' + else: + balance = balance - withdraw_amount + return balance + return withdraw + +def make_joint(withdraw, old_password, new_password): + """Return a password-protected withdraw function that has joint access to + the balance of withdraw. + + >>> w = make_withdraw(100, 'hax0r') + >>> w(25, 'hax0r') + 75 + >>> make_joint(w, 'my', 'secret') + 'Incorrect password' + >>> j = make_joint(w, 'hax0r', 'secret') + >>> w(25, 'secret') + 'Incorrect password' + >>> j(25, 'secret') + 50 + >>> j(25, 'hax0r') + 25 + >>> j(100, 'secret') + 'Insufficient funds' + + >>> j2 = make_joint(j, 'secret', 'code') + >>> j2(5, 'code') + 20 + >>> j2(5, 'secret') + 15 + >>> j2(5, 'hax0r') + 10 + + >>> j2(25, 'password') + 'Incorrect password' + >>> j2(5, 'secret') + "Your account is locked. Attempts: ['my', 'secret', 'password']" + >>> j(5, 'secret') + "Your account is locked. Attempts: ['my', 'secret', 'password']" + >>> w(5, 'hax0r') + "Your account is locked. Attempts: ['my', 'secret', 'password']" + >>> make_joint(w, 'hax0r', 'hello') + "Your account is locked. Attempts: ['my', 'secret', 'password']" + """ + "*** YOUR CODE HERE ***" + +# Generators + +def generate_paths(t, x): + """Yields all possible paths from the root of t to a node with the label x + as a list. + + >>> t1 = tree(1, [tree(2, [tree(3), tree(4, [tree(6)]), tree(5)]), tree(5)]) + >>> print_tree(t1) + 1 + 2 + 3 + 4 + 6 + 5 + 5 + >>> next(generate_paths(t1, 6)) + [1, 2, 4, 6] + >>> path_to_5 = generate_paths(t1, 5) + >>> sorted(list(path_to_5)) + [[1, 2, 5], [1, 5]] + + >>> t2 = tree(0, [tree(2, [t1])]) + >>> print_tree(t2) + 0 + 2 + 1 + 2 + 3 + 4 + 6 + 5 + 5 + >>> path_to_2 = generate_paths(t2, 2) + >>> sorted(list(path_to_2)) + [[0, 2], [0, 2, 1, 2]] + """ + "*** YOUR CODE HERE ***" + +################### +# Extra Questions # +################### + +def str_interval(x): + """Return a string representation of interval x.""" + return '{0} to {1}'.format(lower_bound(x), upper_bound(x)) + +def add_interval(x, y): + """Return an interval that contains the sum of any value in interval x and + any value in interval y.""" + lower = lower_bound(x) + lower_bound(y) + upper = upper_bound(x) + upper_bound(y) + return interval(lower, upper) + +def interval(a, b): + """Construct an interval from a to b.""" + return [a, b] + +def lower_bound(x): + """Return the lower bound of interval x.""" + "*** YOUR CODE HERE ***" + +def upper_bound(x): + """Return the upper bound of interval x.""" + "*** YOUR CODE HERE ***" + +def mul_interval(x, y): + """Return the interval that contains the product of any value in x and any + value in y.""" + p1 = x[0] * y[0] + p2 = x[0] * y[1] + p3 = x[1] * y[0] + p4 = x[1] * y[1] + return [min(p1, p2, p3, p4), max(p1, p2, p3, p4)] + +def sub_interval(x, y): + """Return the interval that contains the difference between any value in x + and any value in y.""" + "*** YOUR CODE HERE ***" + +def div_interval(x, y): + """Return the interval that contains the quotient of any value in x divided by + any value in y. Division is implemented as the multiplication of x by the + reciprocal of y.""" + "*** YOUR CODE HERE ***" + reciprocal_y = interval(1/upper_bound(y), 1/lower_bound(y)) + return mul_interval(x, reciprocal_y) + +def par1(r1, r2): + return div_interval(mul_interval(r1, r2), add_interval(r1, r2)) + +def par2(r1, r2): + one = interval(1, 1) + rep_r1 = div_interval(one, r1) + rep_r2 = div_interval(one, r2) + return div_interval(one, add_interval(rep_r1, rep_r2)) + +def check_par(): + """Return two intervals that give different results for parallel resistors. + + >>> r1, r2 = check_par() + >>> x = par1(r1, r2) + >>> y = par2(r1, r2) + >>> lower_bound(x) != lower_bound(y) or upper_bound(x) != upper_bound(y) + True + """ + r1 = interval(1, 1) # Replace this line! + r2 = interval(1, 1) # Replace this line! + return r1, r2 + +def multiple_references_explanation(): + return """The multiple reference problem...""" + +def quadratic(x, a, b, c): + """Return the interval that is the range of the quadratic defined by + coefficients a, b, and c, for domain interval x. + + >>> str_interval(quadratic(interval(0, 2), -2, 3, -1)) + '-3 to 0.125' + >>> str_interval(quadratic(interval(1, 3), 2, -3, 1)) + '0 to 10' + """ + "*** YOUR CODE HERE ***" diff --git a/HW6/ron_hw06.py b/HW6/ron_hw06.py new file mode 100755 index 0000000..f0c3f08 --- /dev/null +++ b/HW6/ron_hw06.py @@ -0,0 +1,49 @@ +# Object Oriented Programming + + + class Fib(): + def __init__(self, value=0): + self.value = value + + def next(self): + if self.value == 0: + result = Fib(1) + else: + result = Fib(self.value + self.previous) + result.previous = self.value + return result + + def __repr__(self): + return str(self.value) + +class VendingMachine: + def __init__(self,food_item,price): + self.item=food_item + self.cost=price + self.stock=0 + self.balance=0 + def deposit(self,amount): + self.balance=self.balance+amount + if self.stock==0: + self.balance=self.balance-amount + return("Machine is out of stock. " + " Here is your $" + str(amount)) + else: + return("Current balance: "+str(self.balance)) + def restock(self,quantity): + self.stock=self.stock+quantity + return("Current "+ str(self.item)+" stock: "+str(self.stock)) + def vend(self): + if self.stock==0: + return("Machine is out of stock.") + elif self.balance