CSE 2050 Final Exam

deque

- a doubly ended queue - acts like both a stack and a queue, storing an ordered collection of items with the ability to add or remove from both the beginning and the end

unit tests

- are supposed to test a specific -This means you will have many tests and you will run them all, every time you change the code

dequeue

- remove and return the next item in First In First Out (FIFO) ordering def dequeue(self): return self._L.pop(0) (This isn't the best way to do it tho)

peek

- return the next item in LIFO ordering. def peek(self): return self._L[-1]

size

- returns the number of items in the stack def __len__(self): reutrn len(self._L)

Red-Green-Refactor

-Red: The tests fail. They better! You haven't written the code yet! -Green: You get the tests to pass by changing the code. -Refactor: You clean up the code, removing duplication.

class

-a data type -object constructor -ex. python has a list class. If I make a list called mylist . Then, mylist is an object of type list .

method

-a function defined in a class -It is a standard convention to use self as the name of the first parameter to a ______. This parameter is object that will generally be operated on by the _______. -When, calling the _______, you don't have to pass a parameter explicitly for self. Instead, the dot notation fills in this parameter for you.

strings

-a sequences of characters and can be used to store texts of all kinds -can concatenate strings to create a new string using the plus sign -can access the individual characters using square brackets and an index

enqueue

-add a new item to the queue def enqueue(self, item): self._L.append(item)

push

-add a new item to the stack def push(self, item): self._L.append(item)

lists

-an ordered sequence of objects (objects don't have to be the same types) -elements are separated by a comma -L.append(newitem) adds newitem to end of list

public interface

-collection of public attributes -what the user of a class should interact with

encapsulation

-combining into a single thing, data and the methods that operate on that data (ex. classes) - the boundary between the inside and the outside of the class, specifying what is visible to the users of a class

object

-has an identity, a type, and a value -cannot change identity and type -can't change type but it might seem like you did -an instance of class

name of a function

-is just the name and it refers to an object -functions can be treated like objects If you run the module directly (i.e. as a script), then the __name__ variable is automatically set to __main__ .defaults to the module name. If the module is being imported, the __name__ defaults to the module name.

composition

-mean "has a" - where one class stores an instance of another class and it allows us to produce more complex objects

polymorphism

-means we can pass any type of object we want to a function -based on duck typing

duck typing

-name comes from an old expression that if something walks like a duck and quacks like a duck, then it is a duck -The idea is that you don't need a type in order to invoke an existing method on an object

ADT

-not a data structure but tells us about data structure -answers two main questions: 1. What is the data to be stored or represented? 2. What can we do with the data? -may also describe error situations and what should happen if they occur -tells us what methods the data structure will implement

type

-often determines what you can do with the variable type()

control flow

-refers to the commands in a language that affect the order or what operations are executed -for loops, while loops, if statements, try blocks, function calls

pop

-remove and return the next item in Last in First Out (LIFO) ordering def pop(self): return self._L.pop()

isempty

-return True if the stack has no items and return False otherwise def isempty(self): return len(self) == 0

yield

-sometimes used instead of return -the result will be something called a generator and not a function

assert

-statement will raise an error if the predicate that follows it is False. Otherwise, the program just continues as usual. -are much better than just printing because you don't have to manually check to see that it printed what you expected it to print

dictionaries

-store key-value pairs -known as maps, mapping, or hash tables -if you have the key, you can get the value -keys are immutable types b/ you don't wanna change them -We use curly braces to denote them and commas to separate elements -consequential collections -S = {2, 1}

cost

-the ______ of the whole program will be the sum of the _____s of all the operations executed by the program -Often, the _____ will be a function of the input size, rather than a fixed number.

variable

-where information is stored -created by an assignment statement

symmetric differences in a set

A ^ B cost = nA + nB

linked list

A linear data structure, much like an array, that consists of nodes, where each node contains data as well as a link to the next node, but that does not use contiguous memory.

doubly linked list

A linked list in which each node is linked to both its successor and its predecessor

union in a set

A | B cost = nA + nB

add a new item to a set

A.add(newitem) cost = 1

delete an item in a set

A.delete(item) cost = 1

semantic

function behavior

expressions

get evaluated and produce a value

big-O

gives a very convenient way of grouping this (running time) functions into classes that can easily be compared

abstraction

hiding details (the user of our code does not have to know anything about our implementation in order to use the class)

insert at index i

insert(i, newitem) cost = n - i

atomic types

integers, floats, booleans

membership testing

item in L cost = n

(key) membership testing for dictionary

key in D cost = 1

if __name__ == '__main__'

makes sure that the tests will not run when the module is imported from somewhere else

inheritance

means 'is a'

magic/dunder methods

name for methods that start and end with two underscores

mutable

object's value can be cahnged

immutable

object's value cannot be changed

order of precedence

order of operations

sequence

performing operations one at a time in a specified order

object oriented programming

primary goal is to make it possible to write code that is close to the way you think about the things your code represents.

selection

using conditional statements such as if to select which operations to execute

instance

when you make your own object that is like a python class (mylist is a list)

intersection in a set

A & B cost = min{nA, nB}

set differences

A - B cost = nA

features of big-O usage

1. The big-O hides constant factors. Any term that does not depend on the size of the input is considered a constant and will be suppressed in the big-O. 2. The big-O tells us about what will eventually be true when the input is sufficiently large.

private

Any attribute that starts with an underscore is considered _________

get item in dictionary

D[key] cost = 1

set item in dictionary

D[key] = value cost = 1

DRY

Don't Repeat Yourself

Binary Search

Iterative: def bs(L, item): left, right = 0, len(L) while right - left > 1: median = (right + left) // 2 if item < L[median]: right = median else: left = median return right > left and L[left] == item Recursive: def bs(L, item): if len(L) == 0: return False median = len(L) // 2 if item == L[median]: return True elif item < L[median]: return bs(L[:median], item) else: return bs(L[median + 1:], item)

append

L.append(newitem) cost = 1

pop (from end of list)

L.pop() cost = 1

pop (from index i)

L.pop(i) cost = n - i

sort

L.sort() cost = nlogbase2n

concatenate two lists

L1 + L2 cost = n1 + n2

slice

L[a:b} cost = b - a

index access

L[i] cost = 1

index assignment

L[i] = newvalue cost = 1

n Log n

O (n log n)

constant functions

O(1)

exponential functions

O(2^n)

logarithmic functions

O(log n)

factorial functions

O(n!)

linear functions

O(n)

linear time

O(n) ex. 2n + 3

quadratic functions

O(n^2)

quadratic time

O(n^2) ex. 3n^2 + 2

polynomial functions

O(n^k)

TDD

Test-Driven Development -you can write the tests before you write the code -Red, Green, Refactor = three phases of testing process

interface

The classes have public methods. We call these public methods the ___________ to the class.

factoring out a superclass

The process of removing duplication by putting common code into a superclass

Recursion

When a function calls itself. Use a base case to begin execution after evaluation

initalizer

__init__ method

subclass

a class defined in another class (ex baby_class(parent_class):)

data structure

an implementation of ADT (aka concrete data structure)

Mergesort

def merge(L1, L2, L): n = len(L1) i, j = 0, 0 while i < n and j < n: if j == n or (i < len(L1) and L1[i] < L2[j]): L[i + j] = L1[i] i += 1 else: L[i + j] = L2[j] j += 1

Quicksort

def quickSort(L, left = 0, right = None): if right is None: right = len(L) if right - left > 1: middle = partition(L, left, right) quickSort(L, left, middle) quickSort(L, middle + 1, right)

Quickselect

def quickselect(L, k, left = 0, right = None): if right is None: right = len(L) pivot = partition(L, left, right) if k <= pivot: return quickselect(L,k,left,pivot) elif k == pivot + 1: return L[pivot] else: return quickselect(L,k,pivot+1, right)

delete an item by its key for dictionaries

del D[key] cost = 1

delete an item (at index i)

del(item) cost = n - i

The Queue ADT

enqueue, dequeue, len, isempty

The Stack ADT

push, pop, peek, size, isempty

iteration

repeating some operations using loops or recursion

state

stored information

refactoring

the process of cleaning up code, most often referring to the process of removing duplication

method resolution order

the search for the correct function

public

there is no formal mechanism to keep one from accessing attributes of a class from outside that class so everything is ____________