Laboratory Exercise 2
CSci 227: Programming Methods
Department of Computer Science
Hunter College, City University of New York
Spring 2024

Learning Objectives:

Refresh knowledge of Python string methods.
Introduce string formatting (f-strings).
Gain familiarity with list comprehensions and zips.
Use standard file I/O to read and write files.

Software Tools Needed: Web browser to access textbook and an IDE (on-line or on computer) with core Python 3.6+ loaded.

Lab Notes: Download the outline and focus questions to guide you while working through this lab. These are a useful tool for note taking and as well as studying for the quizzes and final exam.

String Methods

To start this week's lab, work through the textbook's Chapter 1 which recaps string methods. Test yourself on the interactive code examples.

If you're a bit rusty on string methods, you can also work through the introductory Python textbook's sections (Chapter 9) on strings.

Try these two LeetCode challenges on strings. Work through as much as possible before looking at the hints:

66. Plus One (hint: get it working without the carry, and then think about how to add that in)
1903. Largest Odd Number in String (hint: read all the examples to see what the expected output is & think about how you would do this with a single loop)

Let's work through the first one:

A good way to get started on technical challenges is to add in the return statement. Since almost all the challenges are structured as a "fill-in-the-function", it's a good first step. What to return? Let's look at the function:

To start, just return a dummy value that matches the type needed. Great dummy values are 0, "" (empty string), or one of the input parameters. The expected return type is a list of integers which happens to match that of the input parameter, digits. So, start by returning it:
```
return digits
```
Click run to make sure there's no syntax errors. It won't pass the tests, but we can let it run while we read more of the challenge description.
Our current return value is exactly the input, but the challenge asks that it be one more. When the last digit is less than 9, then we just add one to it (otherwise, we need to "carry" to the next digit). We can do the easy case, make sure it works on go on to the next. Python has an easy way to get the last item in a list or string-- index of -1:
```
digits[-1] = digits[-1] + 1 
return digits
```
Make sure that runs with no errors. It will also pass the easy tests when there's no carry.
Next, let's worry about the case where the digit is 9 and when we add one to it, we need to carry to next place.
If digits[-1]
is 9, then we need to set it to 0 and add one to digits[-1]
:
```
if digits[-1] < 9:
    #Code from before:
    digits[-1] = digits[-1] + 1 
else:
    digits[-1] = 0
    digits[-2] = digits[-2] + 1
return digits
```
That will take care of large numbers that end in [...,9,9], but what about more generally?
To generalize to large numbers with any number of 9's at the end, we need a loop. Here's the outline to fill out with your code:
1. Initialize pos = -1 and carry = True.
2. While pos > 0 and carry:
3. If digits[pos] < 9:
4. Increment digits[pos] and set carry to False.
5. else:
6. Set digits[pos] & decrement position.
7. If carry flag is still set, then pos must be 0, and insert a new element at the front of the list with '1'.
8. return digits

Translate the pseudocode into Python and try running it against the test cases on LeetCode. See also Program 5 (Hexidecimal Plus One.

String Formatting

Python has several way to format strings. In lecture, we briefly covered one way (f-strings). If you didn't work through the textbook's overview of the ways to format strings (in particular the f-strings towards the end of the section are very useful), do so now:

Test your understanding by completing the interactive coding exercises embedded in the textbook chapter.

List Comprehensions and Zips

Python has some nice tools for lists. Work through the quick tutorials on list comprehensions and zips below:

A list comprehension is a compact way of creating a new list from an existing one. Work through the W3 Schools tutorial on list comprehensions.
The zip function combines lists (or more generally iterators) into a single object and are very useful when writing for loops. Work through the W3 Schools tutorial on zips.

File I/O

Working with files follows a similar format in most programming languages:

Open the file and create a file descriptor variable that keeps track of where you are in the file.
Read or write to the file (via the file descriptor).
When done, close the file.

Work through the chapter on File I/0 from the CSCI 127 textbook:

There's a way in Python to combine the opening and closing of a file into a single step, with a with, covered in Section 11.7 above. This approach is very popular, since it handles the "bookkeeping" of accessing files.

For classwork, we sketched an algorithm for double spacing a file. Using that same approach, sketch algorithms to:

Copy the first letter of each line of the old file to the new file.
Copy the first word of each line of the old file to the new file.
Copy the longest word of each line of the old file to the new file (see Program 6).

Quizzes and Code Reviews

There are weekly written quizzes and code reviews in 1001G, 11:30-5:30, Mondays-Fridays when classes are in session. No appointments are needed for CSCI 227 students. Make sure to complete Quiz 2 and Code Review 2 by Thursday, 15 February.

Additional Practice

For additional practice on core Python, see the HackerRank prepare series:

HackerRank: Prepare Python

Work through the challenges on Lists and List Comprehensions.

For more practice on using string methods to solve problems, here are some popular ones from LeetCode where using dictionaries is an efficient approach: