CSE 163, Spring 2020: Homework 1: Python Crash Course

Learning Objectives

After this homework, students will be able to:

• Follow a Python development workflow for this course, including:
  • Writing a Python script from scratch and turning in the assignment.
  • Use the course infrastructure (flake8, test suites, course resources).
• Use Python to review CS1 programming concepts implement programs that follow a specification, including:
  • Use/manipulation of various data types including numbers and strings.
  • Control structures (conditional statements, loops, parameters, returns) to implement basic functions provided by a specification.
  • Basic text file processing.
  • Documenting code.
• Write unit tests to test each function written including their edge cases.

Expectations

Here are some baseline expectations we expect you to meet:

• Follow the course collaboration policies

• In hw1.py you should not use any import statements or features in Python we have not yet discussed in class, section, or HW specs. All of these problems should be solved using the basic constructs we've learned in class so far. However, for the test program you may import anything you want that is provided by the cse163 environment (using something outside will not work on turn-in)

Format

In this document and future homework specs, you will see teal boxes like the ones below that provide extra information. You should read all of these unless they are indicated as Optional.

For example:

Problem 1: count_divisible_digits

Write a function called count_divisible_digits that takes two integer numbers n and m as an arguments and returns the number of digits in n that are divisible by m. If m is 0, then count_divisible_digits should return 0. For this problem, any digit in n that is 0 is divisible by any number. You may assume m is a single digit (i.e., \(0 \le m < 10\)). Here are some example calls:

count_divisible_digits(650899, 3) # returns 4 because 0, 6, 9 are divisible by 3
count_divisible_digits(-204, 5) # returns 1 because 0 is divisible by 5
count_divisible_digits(24, 5) # returns 0
count_divisible_digits(1, 0) # returns 0

To receive full credit on this problem, you should avoid building up a string containing the digits of the number. Instead, you should solve this problem by manipulating the number itself. You can assume m is not negative.

x = max(1, 7)  # x will store 7

Hint: You will likely want to use a strategy that involves integer division and the mod operator. A common pattern when working with digits is to use n // 10 and n % 10 to pull a number apart, digit by digit.

Problem 2: is_relatively_prime

Write a function called is_relatively_prime that takes two integer numbers n and m and returns True if n and m are relatively prime to each other, returning False otherwise. Two numbers are relatively prime if they share no common factors besides 1. 1 is relatively prime with every number. You may assume that n and m are at least 1 for this problem.

Some example calls are shown below where the comment underneath the call shows the factors for each of the given numbers:

is_relatively_prime(12, 13)  # True
# factors of 12 = [1, 2, 3, 4, 6, 12] and factors of 13 = [1, 13]
is_relatively_prime(4, 24)   # False, shares 2 and 4 as common factors
# factors of 4 = [1, 2, 4] and factors of 24 = [1, 2, 3, 4, 6, 8, 12, 24]
is_relatively_prime(5, 9)    # True
# factors of 5 = [1, 5] and factors of 9 = [1, 3, 9]
is_relatively_prime(8, 9)    # True
# factors of 8 = [1, 2, 4, 8] and factors of 9 = [1, 3, 9]
is_relatively_prime(8, 1)    # True
# factors of 8 = [1, 2, 4, 8] and factors of 1 = [1]

Requirements:

• You should not create any data structures (e.g. list) to actually store these factors. You can solve this problem without needing to store all the factors.

Problem 3: travel

Write a function travel which takes a string of North, East, South, West directions, a starting location on a grid x, and a starting location on a grid y. Your function should return a string that indicates the new position after following the directions starting from the given x, y. The returned string should be in the format '(x_new, y_new)'.

The directions string will use 'N' to indicate increasing the y-coordinate, 'E' to indicate increasing the x-coordinate, 'S' to indicate decreasing the y-coordinate, and 'W' to indicate decreasing the x-coordinate. The case of the characters should be ignored. Any characters that are not 'N', 'E', 'W', or 'S' (ignoring letter-casing) should be ignored.

travel('NW!ewnW', 1, 2)  # '(-1, 4)'

# 'N', (1,2) => (1,3)
# 'W', (1,3) => (0,3)
# '!', ignored
# 'e', (0,3) => (1,3)
# 'w', (1,3) => (0,3)
# 'n', (0,3) => (0,4)
# 'W', (0,4) => (-1,4)

Problem 4: swip_swap

Write a function called swip_swap that takes a string source and characters c1 and c2 and returns the string source with all occurrences of c1 and c2 swapped. You may assume that the c1 and c2 are single characters. Here are some example calls:

swip_swap('foobar', 'f', 'o')  # 'offbar'
swip_swap('foobar', 'b', 'c')  # 'foocar'
swip_swap('foobar', 'z', 'c')  # 'foobar'

Problem 5: compress

Write a function compress which takes a string as an argument and returns a new string such that each character is followed by its count, and any adjacent duplicate characters are removed (replaced by the single character). You may assume the string only contains letters. Here is an example call

compress('cooooooooooooooooolkangaroo')  # 'c1o17l1k1a1n1g1a1r1o2'
compress('aaa') # 'a3'
compress('')  # ''

Problem 6a: longest_line_length

Write a function longest_line_length that takes a string file_name and returns the length of the longest line in the file. The length of the line is just the number of characters in it (whitespace or not). If the file is empty, the function should return None. You may assume the file exists for the given file name.

Suppose we had a file called poem.txt with the contents:

she sells
sea
shells by
the sea shore

Then the following call would return:

longest_line_length('poem.txt')  # 13

In this file, line 2 would have 4 characters because of the new-line character at the end. This is not something you need to think about though since len will return the proper thing for the strings. Because the last line has 13 characters (there is no new-line), the return of this function is 13.

x = 3
y = None
z = x + y
# TypeError: unsupported operand type(s) for +: 'int' and 'NoneType'

x = some_method_that_might_return_none()
if x is None:
    # do whatever you need to do in this case
else:
    # you know x is not None, so it will be a valid value!

Problem 6b: longest_word

Write a function longest_word that takes a string file_name and returns the longest word in the file with which line it appears on. If there are ties for the longest word, it should return the one that appears first in the file. If the file is empty or there are no words in the file, the function should return None. You may assume that the file_name describes a file that exists.

Suppose we had a file called poem.txt with the contents:

she sells
sea
shells by
the sea shore

Then the following call would return:

longest_word('poem.txt')  # '3: shells'

Because the longest word is "shells" and appears on line 3.

Problem 7: mode_digit

Write a function mode_digit that takes an integer number n and returns the digit that appears most frequently in that number. The given number may be positive or negative, but the most frequent digit returned should always be non-negative. If there is a tie for the most frequent digit, the digit with the greatest value should be returned.

To receive full credit, your solution must not use any nested loops or recursion (if you don't know what that is, you aren't using it), and you must have no more than 4 if/elif/else branches. You are allowed to use extra storage to solve this problem. Here are some example calls

mode_digit(12121)       # 1
mode_digit(0)           # 0
mode_digit(-122)        # 2
mode_digit(1211232231)  # 2

a = [0] * N,
# If N = 3, then a = [0, 0, 0]