def add_to_back(alist, val): """ Purpose Insert val into alist at the end of the node chain Preconditions: :param alist: a list created by create() :param val: a value of any kind Post-conditions: The list increases in size. The new value is last in the list. Return: :return None """ if size(alist) == 0: new_node = node.create(val, None) alist['head'] = new_node alist['tail'] = new_node alist['size'] += 1 else: cur_last_node = alist['tail'] new_node = node.create(val, None) node.set_next(cur_last_node, new_node) alist['tail'] = new_node alist['size'] += 1 return None
def add_to_front(alist, val): """ Purpose Insert val into alist at the front of the node chain Preconditions: :param alist: a list created by create() :param val: a value of any kind Post-conditions: The list increases in size. The new value is at index 0. The values previously in the list appear after the new value. Return: :return None """ if size(alist) == 0: new_node = node.create(val, None) alist['head'] = new_node alist['tail'] = new_node alist['size'] += 1 else: new_node = node.create(val, alist['head']) alist['head'] = new_node alist['size'] += 1 return None
def copy(node_chain, new_chain=None, head=None): """ Purpose: Create a new node-chain Pre-conditions: :param node_chain: a node chain, possibly empty return: :return: a seperate distinct chain that has the same values as node-chain """ if node_chain is None: if new_chain is None: return None node.set_next(new_chain, None) return head else: value = node.get_data(node_chain) if new_chain is None: new_chain = node.create(value, None) head = new_chain return copy(node.get_next(node_chain), new_chain, head) else: node.set_next(new_chain, node.create(value)) return copy(node.get_next(node_chain), node.get_next(new_chain), head)
def copy_chain(node_chain): """ Purpose: Make a new node chain with the same values as in node_chain. Pre-conditions: :param node_chain: a node chain, possibly None Return: :return: A copy of node chain, with new nodes, but the same data. """ # special case: empty node chain if node_chain is None: return None else: walker = node_chain # remember the first node result = node.create(node.get_data(walker)) walker = node.get_next(walker) walker2 = result # walk along the first chain, making copies of each node while walker is not None: node.set_next(walker2, node.create(node.get_data(walker))) walker2 = node.get_next(walker2) walker = node.get_next(walker) # return the anchor to the copy return result
def insert_value_sorted(node_chain, number_value): """ Purpose: Insert the given number_value into the node-chain so that it appears after a previous value that is <= value. If the node_chain was empty, new value is simply placed at the front. Pre-conditions: :param node_chain: a node-chain, possibly empty, containing only numbers :param number_value: a numerical value to be inserted Assumption: node_chain only contains numbers (which can be compared to the given number_value) Post-condition: The node-chain is modified to include a new node with number_value as its data after a previous node's data value is <= number_value. Return :return: the node-chain with the new value in it """ #if the node chain is empty, add the new node if a5q2.count_chain(node_chain) < 1: node_chain = node.create(number_value, None) #if chain is not empty, find the proper place else: cur_node = node_chain prev_node = None next_node = node.get_next(node_chain) while True: cur_val = node.get_data(cur_node) #check if the value should be placed in front of current node if cur_val == number_value + 1: #check if the target node is the first node if prev_node == None: node_chain = node.create(number_value, cur_node) else: new_node = node.create(number_value, cur_node) node.set_next(prev_node, new_node) break #check if the value should be placed after the current node if cur_val == number_value - 1: #check if target node is the last node in chain if next_node == None: new_node = node.create(number_value, None) node.set_next(cur_node, new_node) else: new_node = node.create(number_value, next_node) node.set_next(cur_node, new_node) break #break if at the end of the node chain if next_node == None: break #move to next node if not at the end of the chain else: prev_node = cur_node cur_node = next_node next_node = node.get_next(next_node) return node_chain
def copy(node_chain): """ purpose: create a new node chain that is identical to node_chain Preconditions: node_chain: a node chain post-conditions: an identical node chain is created return: the newly created node chain """ if node_chain == None: return None if node.get_next(node_chain) == None: #base case, 1 node return node.create(node.get_data(node_chain)) else: value = node.get_data(node_chain) return node.create(value, copy(node.get_next(node_chain)))
def create(cloud_name, size, machine_name=None, key_name=None, svc=None, \ location=None, security_group=None, network=None, data_gb=None): machine_id = launch(cloud_name, size, machine_name, key_name, \ location=None, security_group=None, network=None, data_gb=None) if machine_id == None: return node.create(cloud_name, machine_id) if svc == None: return component = None if svc in ('pg95', 'pg96', 'pg10', 'pg11', 'pg12', 'pg13'): component = svc svc = 'postgres' service.install(cloud_name, machine_id, svc, component) return
def add_to_front(alist, val): """ Purpose Insert val into alist at the front of the node chain Preconditions: :param alist: a list created by create() :param val: a value of any kind Post-conditions: The list increases in size. The new value is at index 0. The values previously in the list appear after the new value. Return: :return None """ new = node.create(val) if alist["head"] is None: alist["head"] = new alist["tail"] = new else: alist["head"] = node.create(val, alist["head"]) alist["size"] += 1
def insert_at(node_chain, value, index): """ Purpose: Insert the given value into the node-chain so that it appears at the the given index. Pre-conditions: :param node_chain: a node-chain, possibly empty :param value: a value to be inserted :param index: the index where the new value should appear Assumption: 0 <= index <= n where n is the number of nodes in the chain Post-condition: The node-chain is modified to include a new node at the given index with the given value as data. Return :return: the node-chain with the new value in it """ # special case: insert at index 0 if index == 0: return node.create(value, node_chain) # walk along the chain until the indicated index walker = node_chain counter = 0 prev = None while walker is not None and counter < index: prev = walker walker = node.get_next(walker) counter += 1 # If there is a node at the index if counter == index: # insert a new node node.set_next(prev, node.create(value, walker)) else: # insert at the very end node.set_next(prev, node.create(value, None)) return node_chain
def insert_value_sorted(node_chain, number_value): """ Purpose: Insert the given number_value into the node-chain so that it appears after a previous value that is <= value. If the node_chain was empty, new value is simply placed at the front. Pre-conditions: :param node_chain: a node-chain, possibly empty, containing only numbers :param number_value: a numerical value to be inserted Assumption: node_chain only contains numbers (which can be compared to the given number_value) Post-condition: The node-chain is modified to include a new node with number_value as its data after a previous node's data value is <= number_value. Return :return: the node-chain with the new value in it """ if node_chain == None: return node.create(number_value) #1 node anode = node_chain current = node.get_data(anode) if number_value <= current: #add to front, regardless of node size return node.create(number_value, anode) if node.get_next(anode) == None: #add after node.set_next(anode, node.create(number_value)) return anode #2 nodes next1 = node.get_data(node.get_next(anode)) if node.get_next(node.get_next(anode)) == None: if number_value <= next1: #add in middle node.set_next(anode, node.create(number_value, node.get_next(anode))) return anode if number_value > next1: node.set_next(node.get_next(anode), node.create(number_value)) return anode #3+ next1 = node.get_data(node.get_next(anode)) while node.get_next( node.get_next(anode)) != None: #step until the second last one if number_value > current and number_value <= next1: #if larger than current and smaller than next node.set_next(anode, node.create(number_value, node.get_next(anode))) return node_chain anode = node.get_next(anode) current = node.get_data(anode) next1 = node.get_data(node.get_next(anode)) if number_value <= next1: #check last 2 values node.set_next(anode, node.create(number_value, node.get_next(anode))) return node_chain node.set_next(node.get_next(anode), node.create(number_value)) return node_chain
def reverse_chain(node_chain): """ Purpose: Completely reverses the order of the given node_chain. Pre-conditions: :param node_chain: a node chain, possibly empty Post-conditions: The front of the node_chain is altered to be the back, with all nodes now pointing next the opposite direction. Return: :return: The resulting node chain that has had its order reversed """ if node_chain == None: return None if node.get_next == None: # only 1 data, return node chain return node_chain anode = node_chain new_node = node.create(node.get_data(anode)) # end of new node while node.get_next( anode ) != None: # step through original and create new node in reverse new_node = node.create(node.get_data(node.get_next(anode)), new_node) anode = node.get_next(anode) return new_node
def push(stack, value): """ Purpose adds the given data value to the given stack Pre-conditions: stack: a stack created by create() value: data to be added Post-condition: the value is added to the stack Return: (none) """ new_node = node.create(value, stack['top']) stack['top'] = new_node stack['size'] += 1
def insert_value_at_index(alist, val, idx): """ Purpose Insert val into alist at index idx Preconditions: :param alist: a list created by create() :param val: a value of any kind :param idx: a valid index for the list Post-conditions: The list increases in size. The new value is at index idx. The values previously in the list at idx or later appear after the new value. Return: :return If the index is valid, insert_value_at_index returns True. :return If the index is not valid, insert_value_at_index returns False. """ #check if idx beyond alist['size'] + 1 or idx is negative, return False if alist['size'] - idx < 0 or idx < 0: return False #if index is the first index or is empty, add new val at the front if idx == 0 or is_empty(alist): add_to_front(alist, val) return True #if index is immediately after the last index of alist, add new val to back elif idx == alist['size']: add_to_back(alist, val) return True #general case else: cur_node = alist['head'] next_node = node.get_next(cur_node) next_idx = 1 #index of next_node while next_node is not None: if next_idx == idx: new_node = node.create(val, next_node) node.set_next(cur_node, new_node) alist['size'] += 1 return True else: cur_node = next_node next_node = node.get_next(next_node) next_idx += 1
def copy(chain): """ Purpose Make a completely new copy of the given node-chain. Preconditions: :param chain: a node-chain Post-conditions: None Return: :return: A new copy of the chain is returned """ if chain == None: return None else: newnode = node.create(node.get_data(chain)) newnext = copy(node.get_next(chain)) node.set_next(newnode, newnext) return newnode
def add_to_back(alist, val): """ Purpose Insert val into alist at the end of the node chain Preconditions: :param alist: a list created by create() :param val: a value of any kind Post-conditions: The list increases in size. The new value is last in the list. Return: :return None """ anode = node.create(val) if is_empty(alist): alist['head'] = anode else: node.set_next(alist['tail'], anode) alist['tail'] = anode alist['size'] += 1
def insert_value_at_index(alist, val, idx): """ Purpose Insert val into alist at index idx Preconditions: :param alist: a list created by create() :param val: a value of any kind :param idx: a valid index for the list Post-conditions: The list increases in size. The new value is at index idx. The values previously in the list at idx or later appear after the new value. Return: :return If the index is valid, insert_value_at_index returns True. :return If the index is not valid, insert_value_at_index returns False. """ if idx > alist["size"] or idx < 0: #if index out of range return False new = node.create(val) if alist["head"] is None and idx is 0: #if empty list add_to_front(alist, val) return True else: if idx is 0: #if add to front add_to_front(alist, val) return True if idx is size(alist): #if add to rear: idx is the same as size add_to_back(alist, val) return True walker = node.get_next(alist["head"]) previous = alist["head"] index = 1 while True: #add in between if index == idx: node.set_next(previous, new) node.set_next(new, walker) alist["size"] += 1 return True walker = node.get_next(walker) previous = node.get_next(previous) index += 1
def add_to_back(alist, val): """ Purpose Insert val into alist at the end of the node chain Preconditions: :param alist: a list created by create() :param val: a value of any kind Post-conditions: The list increases in size. The new value is last in the list. Return: :return None """ new = node.create(val) if alist["tail"] is None: alist["head"] = new alist["tail"] = new else: node.set_next(alist["tail"], new) alist["tail"] = new alist["size"] += 1
def enqueue(queue, value): """ Purpose adds the given data value to the given queue Pre-conditions: queue: a queue created by create() value: data to be added Post-condition: the value is added to the queue Return: (none) """ new_node = node.create(value, None) if is_empty(queue): queue['front'] = new_node queue['back'] = new_node else: prev_last_node = queue['back'] node.set_next(prev_last_node, new_node) queue['back'] = new_node queue['size'] += 1
def insert_value_at_index(alist, val, idx): """ Purpose Insert val into alist at index idx Preconditions: :param alist: a list created by create() :param val: a value of any kind :param idx: a valid index for the list Post-conditions: The list increases in size. The new value is at index idx. The values previously in the list at idx or later appear after the new value. Return: :return If the index is valid, insert_value_at_index returns True. :return If the index is not valid, insert_value_at_index returns False. """ if idx < 0 or idx > size(alist): return False if idx == 0: add_to_front(alist, val) return True if idx == size(alist): add_to_back(alist, val) return True # general case anode = alist['head'] i = 1 while anode is not None and i < idx: anode = node.get_next(anode) i += 1 new_node = node.create(val, node.get_next(anode)) node.set_next(anode, new_node) alist['size'] += 1 return True
import node as node # create the chain of nodes # chain-->[ 3 | *-]-->[ 2 | *-]-->[ 1 | *-]-->[ 5 | *-]-->[ 4 | / ] chain = node.create(4, next=None) chain = node.create(5, chain) chain = node.create(1, chain) chain = node.create(2, chain) chain = node.create(3, chain) # Exercises: # Remove the 3 from the sequence chain = node.get_next(chain) # Add 6 to the front chain = node.create(6, chain) # add 7 to the end anode = node.create(7) bnode = chain while node.get_next(bnode) != None: bnode = node.get_next(bnode) node.set_next(bnode, anode) # Extra exercises: # Exercise 1
#Course: CMPT 145-01 #Lab: L03 # CMPT 145: Assignment 5 Question 3 # test script import a5q1 as a5q1 import a5q3 as a5q3 import node as node test_contains_duplicates = [{ 'inputs': None, 'outputs': False, 'reason': 'Empty node chain' }, { 'inputs': node.create(1), 'outputs': False, 'reason': 'node chain with one node' }, { 'inputs': node.create('two', node.create('two')), 'outputs': True, 'reason': 'node chain with two nodes that are duplicates' }, { 'inputs': node.create(1, node.create('two', node.create(1))), 'outputs': True, 'reason':
#Name: Jason Tran #NSID: jat687 #Student Number: 11101081 #Course: CMPT 145-01 #Lab: L03 import node as node import a7q6 as a7q6 ##################################################################### # test a7q6.average() # Unit testing # Nodes for testing empty_node = None single_node = node.create(1) several_node = node.create(0) for i in range(1, 5): several_node = node.create(i, several_node) test_average = [ { 'inputs': [empty_node], 'outputs': [0], 'reason': 'empty node' }, { 'inputs': [single_node], 'outputs': [1], 'reason': 'single node'
:return: None """ print(counter['reason']+'\t', counter['successes'], 'of', counter['tests'], 'tests passed') # end of the counter ADT ############################################################################################### split_counter = createCounter('A5Q3 split()\t') test_split_chain = [ {'inputs' : None, 'outputs': ["EMPTY","EMPTY"], 'reason' : 'Empty node chain'}, {'inputs' : node.create(1), 'outputs': ["EMPTY", "[ 1 | / ]"], 'reason' : 'node chain with one node'}, {'inputs' : node.create(1, node.create('two')), 'outputs': ["[ 1 | / ]","[ two | / ]"], 'reason' : 'node chain with two nodes'}, {'inputs' : node.create(1, node.create('two', node.create(3))), 'outputs': ["[ 1 | / ]", "[ two | *-]-->[ 3 | / ]"], 'reason' : 'node chain with three nodes'}, {'inputs' : node.create(1, node.create('two', node.create(3,node.create('four')))), 'outputs': ["[ 1 | *-]-->[ two | / ]","[ 3 | *-]-->[ four | / ]"], 'reason' : 'node chain with four nodes'},
Post_conditions: Displays a string to the console Return: None """ print(to_string(node)) test_subst = [ { 'inputs': [None, 3, 5], 'outputs': None, 'reason': 'empty chain' }, { 'inputs': [node.create('one', None), 1, 2], 'outputs': node.create('one', None), 'reason': 'short chain no target' }, { 'inputs': [node.create('one', None), 'one', 'two'], 'outputs': node.create('two', None), 'reason': 'short chain with target' }, { 'inputs': [ node.create('a', node.create('b', node.create('c', node.create(1)))), 'one', 'two' ], 'outputs':
value = node.get_data(walker) # represent the next with an arrow-like figure result += ' *-]-->[ '+str(value)+' |' # at the end of the chain, use '/' result += ' / ]' return result test_count_chain = [ {'inputs' : None, 'outputs': 0, 'reason' : 'Empty node chain'}, {'inputs' : node.create(1), 'outputs': 1, 'reason' : 'node chain with one node'}, {'inputs' : node.create(1, node.create('two')), 'outputs': 2, 'reason' : 'node chain with two nodes'}, {'inputs' : node.create(1, node.create('two', node.create(3))), 'outputs': 3, 'reason' : 'node chain with three nodes'}, ] count_chain_counter = createCounter('A5Q2 count_chain()') for t in test_count_chain:
""" print(counter['reason'] + '\t', counter['successes'], 'of', counter['tests'], 'tests passed') # end of the counter ADT ############################################################################################### test_to_string = [ { 'inputs': None, 'outputs': 'EMPTY', 'reason': 'Empty node chain' }, { 'inputs': node.create(1), 'outputs': '[ 1 | / ]', 'reason': 'node chain with one node' }, { 'inputs': node.create(1, node.create('two')), 'outputs': '[ 1 | *-]-->[ two | / ]', 'reason': 'node chain with two nodes' }, { 'inputs': node.create(1, node.create('two', node.create(3))), 'outputs': '[ 1 | *-]-->[ two | *-]-->[ 3 | / ]', 'reason': 'node chain with three nodes' }, ]
def no_join(): node.create()
#a7q6_testing enz889 Enhan Zhao cmpt145 import a7q6 import node #test to_string test_to_string = [ {'inputs' : None, 'outputs': "EMPTY", 'reason' : 'Empty node chain'}, {'inputs' : node.create(1), 'outputs': "[ 1 | / ]", 'reason' : 'node chain with one node'}, {'inputs' : node.create(1, node.create(2, node.create(3))), 'outputs': "[ 1 | * -]-->[ 2 | * -]-->[ 3 | / ]", 'reason' : 'node chain with multiple nodes'},] for t in test_to_string: inputs = t['inputs'] expected = t['outputs'] result = a7q6.to_string(inputs) assert result == expected, 'to_string(): got '\ +str(result)+' expected '+str(expected)+' -- ' +t['reason'] #test copy() test_copy = [ {'inputs' : None, 'outputs': None, 'reason' : 'Empty node chain'}, {'inputs' : node.create(1), 'outputs': node.create(1),
Display the final count for the number of successful tests. :param counter: a counter. :return: None """ print(counter['reason'] + '\t', counter['successes'], 'of', counter['tests'], 'tests passed') test_to_string = [ { 'inputs': None, 'outputs': 'EMPTY', 'reason': 'Empty node chain' }, { 'inputs': node.create(1), 'outputs': '[ 1 | / ]', 'reason': 'node chain with one node' }, { 'inputs': node.create(1, node.create('two')), 'outputs': '[ 1 | *-]-->[ two | / ]', 'reason': 'node chain with two nodes' }, { 'inputs': node.create(1, node.create('two', node.create(3))), 'outputs': '[ 1 | *-]-->[ two | *-]-->[ 3 | / ]', 'reason': 'node chain with three nodes' }, ]
# CMPT 145: Assignment 5 Question 2 # test script import a5q1 as a5q1 import a5q2 as a5q2 import node as node test_count_chain = [ { 'inputs': None, 'outputs': 0, 'reason': 'Empty node chain' }, { 'inputs': node.create(1), 'outputs': 1, 'reason': 'node chain with one node' }, { 'inputs': node.create(1, node.create('two')), 'outputs': 2, 'reason': 'node chain with two nodes' }, { 'inputs': node.create(1, node.create('two', node.create(3))), 'outputs': 3, 'reason': 'node chain with three nodes' }, ]
TOPO = Topology_Service.Topology() node.add_service(TOPO) if len(sys.argv) > 2: node_name = sys.argv[2] node_port = int(sys.argv[3]) othernode = node.Node_Info(node_name, node_port) node.join(othernode) print node.thisNode print othernode #f = lambda : node.join(othernode) #t = Thread(target=f) #t.start() else: node.create() #t = Thread(target = node.create) #t.start() node.startup() while True: cmd = raw_input(">>") if cmd[:6] == "get f ": x = int(cmd[6:]) print node.fingerTable[x] elif cmd == 'q' or cmd == 'Q' : node.my_polite_exit() exit() elif cmd == 'g' or cmd == 'G': print "estimate:", node.estimate_ring_density() elif cmd[:4] == "get ": database.get_record(cmd[4:])