• (1) Standard Python.org download of Python 3.14 for your computer. It can be operated on the command line or through the IDLE interface (simplest to set up and to learn, but does not have as many features as the other choices, but it is sufficient for CSE 415);
• (2) PyCharm (a commercially-developed, state-of-the-art Python development environment). In the past, some students have preferred this interface. However, if you use the free version, there are advertisements.
• (3) a Conda-managed installation of command-line Python, under Linux, Darwin, or Cygwin (advanced Python developers do this especially if they need to support alternative Python versions and package installations); most students will not need this;

The file a1_exercises.py is a starting template. Edit this file to develop your solutions for Part 1. The file test_functions.py contains a few simple tests that will help you in debugging your solutions. To run the tests, in bash or other Linux environment, type:

python -m unittest test_functions.py

def is_quintuple(n):
    """Return True if n is a multiple of 5; False otherwise."""
    pass

def last_prime(m):
    """Return the largest prime number p that is less than or equal to m.
    You might wish to define a helper function for this.
    You may assume m is a positive integer."""
    pass

def quadratic_roots(a, b, c):
    """Return the roots of a quadratic equation (real cases only).
    Return results in tuple-of-floats form, e.g., (-7.0, 3.0)
    Return the string "complex" if real roots do not exist."""
    pass

def new_quadratic_function(a, b, c):
    """Create and return a new, anonymous function (for example
    using a lambda expression) that takes one argument x and 
    returns the value of ax^2 + bx + c."""
    pass

def perfect_shuffle(even_list):
    """Assume even_list is a list of an even number of elements.
    Return a new list that is the perfect-shuffle of the input.
    For example, [0, 1, 2, 3, 4, 5, 6, 7] => [0, 4, 1, 5, 2, 6, 3, 7]"""
    pass

def list_of_5_times_elts_plus_1(input_list):
    """Assume a list of numbers is input. Using a list comprehension,
    return a new list in which each input element has been multiplied
    by 5 and then has 1 added to it."""
    pass

def double_vowels(text):
    """Return a new version of text, with all the vowels doubled.
    For example:  "The *BIG BAD* wolf!" => "Thee *BIIG BAAD* woolf!".
    For this exercise assume the vowels are 
    the characters A,E,I,O, and U (and a,e,i,o, and u).
    Maintain the case of the characters."""
    pass

In this part of the assignment, you'll write methods for classes that deal with state-space search. These methods are not implementations of search algorithms; those will come in the second assignment. Rather, they deal with the basic infrastructure needed for problem formulation.

In problem solving, a state is a data object that represents the components of a possible solution or partial construction in attempting to find a solution, in one particular configuration. For example, in Tic-Tac-Toe, a state is a representation of the board at one particular point in a game. At the beginning of the game, there is the initial state which represents the empty 3-by-3 grid. Each time a move is made in the game, one state is used to construct another. Consider the following class definition for states of Tic-Tac-Toe.

Define the following methods for this class.

    def __str__(self):
        '''Return a string representation of the
           state that show the Tic-Tac-Toe board as a 2-D ASCII display.'''
        pass      

    def copy(self):
        '''Return a new instance with the same board arrangement 
           and player to move.'''
        pass      

    def __eq__(self, other):
        '''Return True iff two states are equal.'''
        pass      
    

Consider the following class definition for operators of Tic-Tac-Toe.

class TTT_Operator:
    def __init__(self, who, row, col):
        self.who = who
        self.row = row
        self.col = col
    

Define the following methods for this class of operators.

    def is_applicable(self, state):
        '''Return True iff it would be legal to apply
           this operator to the given state.'''
        pass

    def apply(self, state):
        '''Return a new state object that represents the
           result of applying this operator to the given state.'''
        pass
    

In this part of the assignment, you'll prompt an AI agent such as Claude, Gemini, or ChatGPT to develop a text-processing program. The program should be written in Python (version 3.14). It may use any standard library that comes with the Python distribution and does not have to be separately installed.

Your program will provide answers to questions of the form "How common are the words used in webpage X?". (Note that it does NOT have to read and understand any question like this, but it will simply compute the answer when given a webpage address.) It should accept as input a text string (given on the command line) representing a URL for a web page. The program should access the page and read its contents into a text buffer (which can be a list of strings, where each string is one line of the file). It will process each word by looking it up in a special dictionary (linked below) that indicates how common the word is. It will use that information to update a running sum, and to update entries in a type of histogram structure, that keeps track of how many words seen are in each of one-hundred "bins" (ranges of commonness values).

At the end, your program will print out a report containing the overall indicator of the commonness of words on the web page, as well as the histogram normalized in terms of a list of percentages.

The special dictionary to use is a list of 10000 words compiled by Google and listed in order of commonness, starting with "the" in position 0. It's in this file.

Name your program file webpage_word_commonness.py.

The format of your output is suggested by the text below. This sample is not from an actual run of any code, but simply to show the desired format.

REPORT OF WEB-PAGE COMMONNESS OF VOCABULARY.

The analysis program was developed by John Doe
with assistance from Gemini for CSE 415.

Analysis and report created, April 1, 2026.

Webpage address:  https://www.warnerbros.com/movies/youve-got-mail

Overall commonness of words: 0.237, on a scale of 0 to 1.

Commonness Range     Example word    Bin percentage
----------------     ------------    --------------
0-99                 the             26 %
100-199              day             6 %
...
9900-9999            -               0 %

Each bin or range is shown in the left column. The word "the" has index 0, which falls within the range of the first bin. The example word should be that word seen in the document that has the lowest index within its bin. If there is a bin in which no word from the document falls, then a dash is put in the example word column. The third column shows what percentage of words in the webpage fell into each bin.

The example of the format above shows only 3 rows of data in table, with an additional line showing "...". Your program's actual output should have 100 rows, with one row per bin.

1. Q. Will we be graded on style?
   A. See the above.
2. Q. When I submit my code, will additional test cases be run on my functions, other than those distributed with the starter code?
   A. In general, yes. Also, you are encouraged to develop test cases of your own, to help you debug your code's behavior on possible edge cases.

1. a Python file, named as a1_exercises.py (50 points),
2. a Python file called webpage_word_commonness.py (10 points),
3. a sample commonness report file showing the output of your Part 3 program given the web address "https://courses.cs.washington.edu/courses/cse415/26sp/assign/a1/A1.html" (5 points), and
4. a pdf file Learning-Diary-Entry-for-A1.pdf. For what to include in the pdf file, see the separate page on Learning Diaries. (35 points).