## Variables & Control Flow

• ##### Converting numbers to binary
```              ```
def convert_to_binary(n):
ret = ""
while n > 0:
remainder = n % 2
ret = str(remainder) + ret
n = n // 2
return ret
```
```
• ##### Fibonacci Numbers
```                ```
def find_fibonacci_number(n):
lower = 0
higher = 1

iter = 0
while iter < n:
iter += 1
tmp = lower + higher
lower = higher
higher = tmp

return higher
```
```
5
[1, 1, 2]

## Images: Blur

```          ```
def average(in_list):
return sum(in_list)//len(in_list)

def get_average_neighbors(x,y, image):
"""
This function loops through the neighbors of the pixel and the given x,y coordinates and calculates the
average of the red, green, and blue values of all neighbor pixels. It returns a tuple where the first
value is the average of the red components, the second if the average of the green components, and the third value
is the average of the blue components.
"""

#create the lists for all red, green, and blue componenets respectively
reds = []
greens = []
blues = []

#loop through neighbors to get list of all color components for all 9 pixels
for i in range(y-1, y+2):
for j in range(x-1, x+2):
if image.in_bounds(j,i):
in_pixel = image.get_pixel(j,i)
reds.append(in_pixel.red)
greens.append(in_pixel.green)
blues.append(in_pixel.blue)

#calculate the average of each component
average_red = average(reds)
average_green = average(greens)
average_blue = average(blues)

#return a tuple with the three color components
return (average_red, average_green, average_blue)

def blur(image):
#create a new image that you will update and return rather than modifying given image in place
out_image = SimpleImage.blank(image.width, image.height)

#loop through given image
for y in range(image.height):
for x in range(image.width):
in_image_pixel = image.get_pixel(x, y)
out_image_pixel = out_image.get_pixel(x,y)
blur_pixel = get_average_neighbors(x,y, image)
out_image.set_pix(x,y,blur_pixel)

return out_image
```
```

## Drawing

• ```              ```
def draw_diagonals(canvas, width, height, n):
for i in range(n):
x_dist = (i / (n - 1)) * (width - 1)
y_dist = (i / (n - 1)) * (height - 1)
canvas.create_line(0, y_dist, x_dist, 0)
```
```
• ```              ```
def draw_grid(canvas, width, height, n):
for i in range(n):
x_dist = (i / (n - 1)) * (width - 1)
y_dist = (i / (n - 1)) * (height - 1)
canvas.create_line(x_dist, 0, x_dist, height - 1)
canvas.create_line(0, y_dist, width - 1, y_dist)
```
```

## Strings

```              ```
if char.isdigit():
return True
return False

if ch.isupper():
return True
return False

if ch.islower():
return True
return False

if number and upper and lower:
return True
return False
```
```
• ##### Binary Checker
```              ```
def is_valid_binary(test_string):
if(len(test_string) % 8 != 0):
return False
else:
for char in test_string:
if char != '0' and char != '1':
return False
return True
```
```

## Grids

• ##### Muddying the Waters
```              ```
def do_sand_move(grid, x1, y1, x2, y2):
# make sure that there's a row below
if y1 == grid.height - 1:
return grid

if grid.get(x2, y2) == 'w':
grid.set(x2, y2, 'm')
grid.set(x1, y1, None)
if grid.get(x2, y2) == None:
grid.set(x2, y2, 's')
grid.set(x1, y1, None)

return grid

```
```
• ##### Fogging the air
```              ```
def do_fog_move(grid, x, y):
# make sure that there's a row to descend to
if y == grid.height - 1:
return grid

if grid.in_bounds(x - 1, y + 1):
grid.set(x - 1, y + 1, 'f')

if grid.in_bounds(x + 1, y + 1):
grid.set(x + 1, y + 1, 'f')

# we know the square right below is in bounds
grid.set(x, y + 1, 'f')

grid.set(x, y, None)

return grid

```
```

## Lists: Camel Casing

```          ```
def make_first_char_upper(s):
return s.upper() + s[1:].lower()

def make_camel_case(phrases):

#create list to store all updated phrases
cameled_phrases = []

#loop through each phrase
for phrase in phrases:
split_by_space = phrase.split()

#store the first word because it will remain all lower case
lower_case_word = split_by_space

#change the first char in each remaining word to uppercase
updated = [make_first_char_upper(s) for s in split_by_space[1:]]

#add all updated words to a single string
cameled_phrase = lower_case_word
for word in updated:
cameled_phrase += word

#add updated phrase to the output list
cameled_phrases.append(cameled_phrase)

return cameled_phrases
```
```

## Parsing

```              ```
def words_that_starts_with(s, ch):
words = []
search = 0

while True:
start = search
while start < len(s) and not (s[start].lower() == ch.lower() and (start == 0 or s[start-1] == ' ')):
start += 1

if start >= len(s):
break

end = start + 1
while end < len(s) and s[end] != " ":
end += 1

word = s[start:end]
ret.append(word)

search = end + 1

return words
```
```
• ##### Finding questions
```              ```
def find_questions(s):
questions = []
search = 0

while True:
end = s.find("?", search)

if end == -1:
break

start = end - 1
while start >= 0 and s[start] not in PUNCTUATION:
start -= 1

question = s[start + 1:end + 1]
questions.append(question)

search = end + 1

return questions

```
```

• ##### Word Counter
```              ```
def word_count(filename):
num_lines = 0
num_words = 0
num_chars = 0

with open(filename, 'r') as f:
for line in f:
line = line.strip()
num_lines += 1
num_words += len(line.split())
num_chars += len(line)

print(num_chars, num_words, num_lines)
```
```
• ##### Removing Repeated Lines
```              ```
def remove_repeated_lines(filename):
lines = []
with open(filename, 'r') as f:
for line in f:
line = line.strip()
if line not in lines:
lines.append(line)
return lines
```
```
```              ```
rows = []
with open(filename, 'r') as f:
for line in f:
line = line.strip()
rows.append(line.split(","))
return rows
```
```

## Dictionaries

• ##### Recipes
```              ```
def is_sub_list(curr_ingredients, recipe_ingredients):
for ingredient in recipe_ingredients:
if ingredient not in curr_ingredients:
return False
return True

def find_recipes(curr_ingredients, recipe_book):
possible_recipes = []
for recipe in recipe_book:
recipe_ingredients = recipe_book[recipe]
if is_sub_list(curr_ingredients, recipe_ingredients):
possible_recipes.append(recipe)

return possible_recipes
```
```
• ##### Building a glossary
```              ```
def make_glossary(filename):
glossary = {}

with open(filename, 'r') as f:
line_num = 0
for line in f:
line_num += 1
line = line.strip()
for word in line.split():
if word not in glossary:
glossary[word] = []
glossary[word].append((line_num, line))

return glossary
```
```
• ##### Calculating enrollments
```              ```
def compute_enrollments(individuals):
enrollments = {}

for year, course in individuals:
if course not in enrollments:
enrollments[course] = {}

course_nums = enrollments[course]

if year not in course_nums
course_nums[year] = 0

course_nums[year] += 1

return enrollments
```
```

## Tuples: student residences

```          ```
def map_students_to_dorms(all_housing_assignments):
student_living_locations = {}

for name, dorm in all_housing_assignments:
if name not in student_living_locations:
student_living_locations[name] = []
student_residences = student_living_locations[name]
student_residences.append(dorm)

return student_living_locations
```
```

## Sorting, `lambdas` and List Comprehensions

• Construct a list of all the numbers 1-1000 inclusive that are divisible by 8.
• ```            ```
[num for num in range(1, 1001) if num % 8 == 0]
```
```
• Construct a list of all the numbers 1-1000 that contain 3 as a digit at least once
• ```            ```
[num for num in range(1, 1000) if '3' in str(num)]     # option 1
[num for num in range(1, 1000) if str(num).find('3') != -1]  # option 2
```
```
• Find the number of spaces in a string `s`
• ```            ```
len([char for char in s if char == " "])
```
```
• Given a string `s`, construct a list of all the non-vowel characters in the string, regardless of their case. You may assume you have a constant `VOWELS`, which is a list of all the vowels in the english alphabet in lowercase.
• ```            ```
[char for char in text_string if char.lower() not in VOWELS]
```
```
• Given a list `tups` which contains an arbitrary number of tuples of 2 integers each, sort the tuples by the absolute difference between the first and second element. You might find the `abs` function, which takes in as a parameter a number and returns its absolute value, helpful.
• ```            ```
sorted(tups, key=lambda t: abs(t - t))
```
```
• Given a list of strings `strs`, sort it in reverse alphabetical order of last character, case-insensitively (i.e. lowercase and uppercase 'Z's are equal). Break ties by the length of the string.
• ```            ```
sorted(strs, key=lambda s: (s[len(s) - 1], len(s)), reverse=True)
```
```

## More sorting: stock prices

```          ```
def find_first_and_last(stock_prices, a,b):
within_time_interval = sorted([pair for pair in stock_prices if pair >= a and pair <= b])
first = within_time_interval
last = within_time_interval[len(within_time_interval)-1]
return (first, last)

def find_lowest_price(stock_prices, a,b):
lowest = min([pair for pair in stock_prices if pair >= a and pair <= b], key=lambda t: t)
return lowest
```
```

## Weather Map

```          ```
def help_weatherman(img):

#list of all places affected
places_affected = []

#loop through each pixel to check if it represents the type of weather
#we need to use the double for loop because we need the x,y coordinates to get the actual location
for y in range(img.height):
for x in range(img.width):
pixel = img.get_pixel(x,y)
if pixel.blue >= MINIMUM_BLUE_THRESHOLD:
location = translate_coordinate_to_location(x,y)