代写Python基础作业，考察List用法，完成一个地图等高线 Elevation
应用程序。
Goals of this Assignment
In this assignment you will write functions that use lists and loops
(including nested lists ad nested loops). You can do this assignment with only
the concepts through Week 6 of PCRS. After completing this assignment, you
will:
- Understand how data can be represented as a nested list.
- Understand how to create, navigate through, and mutate lists of numerical values.
Elevation Map Analysis
In this assignment we will consider a section of the Earth’s surface. The
figures below show an example section of the Earth from a bird’s-eye-view. The
colours represent different elevations, notice how they vary greatly.
In this assignment, we are interested in analysing the elevation of a section
of the Earth’s surface. We will represent the section of Earth as a square
matrix of numerical values. A square matrix has equal dimensions: the number
of rows is the same as the number of columns. Each value in the matrix
corresponds to the elevation of the Earth at that particular location. For
example, an area the size of 1 square kilometre of Earth could be encoded as a
1000x1000 matrix. Each cell of the matrix contains the elevation of a single
square meter. Here, the value at cell [500, 500] of the matrix, would be the
elevation at approximately the middle of the original 1 square kilometre
section.
For this assignment, you will implement several functions which will allow
someone with such a matrix of values to perform meaningful analysis of the
Earth elevation data.
Assignment Terminology
You may find the following figure useful in understanding the terminology
below:
- elevation map: We will represent an elevation map in Python as a List[List[int]].
- An elevation map’s outer list and inner lists will be non-empty.
- An elevation map will be square. That is, the outer list List[List[int]] has the same length as each inner list List[List[int]], and the number of inner lists is equal to the length of the outer list. For example, in the figure above, the 3x3 elevation map is represented with a nested list of length 3, which contains 3 sub-lists, each of length 3.
- An elevation map will only contain positive integers.
An example of an elevation map is:
valid_map = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
You may find it more intuitive to view this elevation map as:
valid_map = [[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]
The following examples are not elevation maps (note the lengths of all the
lists in each list):
invalid_map1 = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
invalid_map2 = [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
invalid_map3 = [[]]
- cell: We will represent a cell in Python as a list of 2 non-negative integers (List[int]). Given an elevation map m, we say “cell [i, j]” as a shorthand for m[i][j].
- adjacent cell: We will say that cell [i, j] is adjacent to cell [k, l] if and only if [k, l] equals one of: [i-1, j-1], [i-1, j], [i-1, j+1], [i, j-1], [i, j+1], [i+1, j-1], [i+1, j], or [i+1, j+1].
- sink: Given an elevation map m, the cell [i, j] is a sink if m[i][j] [= m[k][l] for all adjacent cells [k, l]. With the physical interpretation of an elevation map in mind, water would collect in sinks, since there is no less elevated area in the immediate vicinity for the water to flow to. For example, in the elevation map below:
[[9, 6, 5, 6],
[4, 5, 6, 8],
[7, 2, 8, 1],
[4, 3, 7, 1]]
cells [0, 2], [2, 1], [2, 3], and [3, 3] are sinks (and all other cells are
not sinks).
Files to Download
Please download the Assignment 2 Files and extract the zip archive.
- Starter code: elevation.py
This file contains the header and the complete docstring (but not body!) for
each of the functions you will write. Your job is to complete this file. - Checker: a2_checker.py
We have provided a checker program that you should use to check your code. See
below for more information about a2_checker.py.
What to do
In the starter code file elevation.py, complete the following function
definitions. Use the Function Design Recipe that you have been learning in
class. We have included the type contracts in the following table; please read
through the table to understand how the functions will be used.
Function name: (Parameter types) -> Return type | Full Description
(paraphrase to get a proper docstring description)
—|—
compare_elevations_within_row: (List[List[int]], int, int) -> List[int] |
The first parameter represents an elevation map. The second parameter
represents a row number. The third parameter represents an elevation. This
function must return a three-item list that contains three counts: the number
of elevations that are less than, equal to, and greater than the given
elevation, in the given row number of the given elevation map. You may assume
that the given elevation map is valid, and that the given row number exists in
the given elevation map.
update_elevation: (List[List[int]], List[int], List[int], int) -> None | The
first parameter represents an elevation map, the second and third parameters
represent cells in the elevation map, and the fourth parameter represents a
change in elevation. This function must modify the given elevation map, so
that the elevation of each cell between the two given cells, inclusive,
changes by the given amount. You may assume that the given elevation map is
valid and that the given cells appear in the same row or column (or both) in
the elevation map. If they are in the same row, you may assume that the second
argument’s column value is less than or equal to the third argument’s column
value. Similarly, if they are in the same column, you may assume that the
second argument’s row value is less than or equal to the third argument’s row
value. You may also assume that the requested change in elevation will never
cause an elevation to go below 1.
get_average_elevation: (List[List[int]]) -> float | The parameter represents
an elevation map. The function must return the average elevation across all
the cells in it. You may assume that the given elevation map is valid.
find_peak: (List[List[int]]) -> List[int] | The parameter represents an
elevation map. This function must return the cell which contains the highest
elevation point in the given map. You may assume the given elevation map is
valid. You may assume that all values in the given map are unique (i.e., no
two locations have equal elevations).
is_sink: (List[List[int]], List[int]) -> bool | The first parameter
represents an elevation map. The second parameter represents a cell, which may
or may not exist in the given elevation map. You may assume that the given
elevation map is valid. The function must return True if and only if the given
location is a sink in the given elevation map. Note: if the given location
does not exist in the given elevation map (the cell values are outside the
elevation map’s dimensions, so it is not a valid cell in the elevation map),
this function must return False. See the Terminology section for the
definition of a sink.
find_local_sink: (List[List[int]], List[int]) -> List[int] | The first
parameter represents an elevation map. The second parameter represents a cell.
You may assume that the given elevation map is valid and that the given cell
exists in the elevation map. You may also assume that all values of the given
elevation map are unique (i.e., no two locations have equal elevations). The
function must return the local sink for the given cell. A local sink of a
given cell is the cell to which the water from this cell will flow. Here we
assume that if the given cell is not a sink, then water will always flow to
the adjacent cell with the lowest elevation.
can_hike_to: (List[List[int]], List[int], List[int], int) -> bool | The
first parameter represents an elevation map, the second represents a start
cell, the third represents a destination cell, and the fourth represents the
amount of available supplies. You may assume that the elevation map is valid,
the start cell and the destination cell exist in the elevation map, and the
amount of supplies is a non-negative integer. Under the interpretation that
the top of the elevation map (row number 0) is North, you may assume that the
destination cell is to the North-West of the start cell (this means it could
also be directly North, or directly West). If a hiker started at the start
cell with a given amount of supplies, could they reach the destination cell if
they used the following strategy: The hiker looks at the cell directly to the
North and the cell directly to the West, compares the elevation of the their
current cell to each of those cells, and then travels to the cell with the
smallest change in elevation. They keep repeating this strategy until they
reach the destination cell (return True) or they run out of supplies (return
False). Assume that to move from one cell to another takes an amount of
supplies equal to the change in elevation between the cells. If the change in
elevation is the same between going West and going North, the hiker will
always go North. Also, the hiker will never choose to travel North or West of
the destination (they won’t overshoot their destination). They will also not
choose to travel in either direction if there is no cell in that direction
(they won’t jump off the map). That is, if destination is directly to the West
of them, they will only travel West, and if destination is directly North,
they will only travel North. Look at the docstring for this function in the
starter code for several examples.
get_lower_resolution: (List[List[int]]) -> List[List[int]] | The parameter
represents an elevation map. You may assume the elevation map is valid. The
function must return a new elevation map, which is constructed from the values
of the given map by decreasing the number of elevation points within the map.
To do this, the function views the map as a series of 2x2 entries and
collapses the data into a single elevation point by taking the average of the
four original points. When taking the average the function rounds down. Here
are some example calls that illustrate the function’s behaviour. Note how the
the function behaves in example (2), where the number of row/columns is odd.
No Input or Output
Your elevation.py file should contain the starter code, the implementations of
the functions specified above, and any helper functions you may choose to
define. elevation.py must not include any calls to the print and input
functions. Do not add any import statements.
A2 Checker
We are providing a checker module (a2_checker.py) that tests two things:
- whether your code follows the Python Style Guidelines, and
- whether your functions are named correctly, have the correct number of parameters, and return the correct types.
To run the checker, open a2_checker.py and run it. Note: the checker file
should be in the same directory as your elevation.py, as provided in the
starter code zip file. Be sure to scroll up to the top and read all messages.
If the checker passes for both style and types: - Your code follows the style guidelines.
- Your function names, number of parameters, and return types match the assignment specification. This does not mean that your code works correctly in all situations. We will run a different set of tests on your code once you hand it in, so be sure to thoroughly test your code yourself before submitting.
If the checker fails, carefully read the message provided: - It may have failed because your code did not follow the style guidelines. Review the error description(s) and fix the code style. Please see the PyTA documentation (Links to an external site.) for more information about errors.
- It may have failed because:
- you are missing one or more function,
- one or more of your functions is misnamed,
- one or more of your functions has the incorrect number or type of parameters, or
- one of more of your function return types does not match the assignment specification.
Read the error message to identify the problematic function, review the
function specification in the handout, and fix your code.
Make sure the checker passes before submitting.
Running the checker program on Markus
In addition to running the checker program on your own computer, run the
checker on MarkUs as well. You will be able to run the checker program on
MarkUs once every 12 hours (note: we may have to revert to every 24 hours if
MarkUs has any issues handling every 12 hours). This can help to identify
issues such as uploading the incorrect file.
First, submit your work on MarkUs. Next, click on the “Automated Testing” tab
and then click on “Run Tests”. Wait for a minute or so, then refresh the
webpage. Once the tests have finished running, you’ll see results for the
Style Checker and Type Checker components of the checker program (see both the
Automated Testing tab and results files under the Submissions tab). Note that
these are not actually marks – just the checker results. If there are errors,
edit your code, run the checker program again on your own machine to check
that the problems are resolved, resubmit your assignment on MarkUs, and (if
time permits) after the 24 hour period has elapsed, rerun the checker on
MarkUs.
Marking
These are the aspects of your work that may be marked for A2:
- Coding style (20%):
- Make sure that you follow Python Style Guidelines that we have introduced and the Python coding conventions that we have been using throughout the semester. Although we don’t provide an exhaustive list of style rules, the checker tests for style are complete, so if your code passes the checker, then it will earn full marks for coding style with one exception: docstrings may be evaluated separately. For each occurrence of a For each occurrence of a PyTA (Links to an external site.) error, one mark (out of 20) deduction will be applied. For example, if a C0301 (line-too-long) error occurs 3 times, then 3 marks will be deducted.
- If you encounter PyTA error R0915 (too-many-statements), that indicates that your function is too long (more than 20 statements long). In that case, introduce helper functions to do some of the work – even if the helpers will only be called once. Your program should be broken down into functions, both to avoid repetitive code and to make the program easier to read.
- All functions, including helper functions, should have complete docstrings including preconditions when you think they are necessary.
- Also, your variable names and names of your helper functions should be meaningful. Your code should be as simple and clear as possible.
- Correctness (80%): Your functions should perform as specified. Correctness, as measured by our tests, will count for the largest single portion of your marks. Once your assignment is submitted, we will run additional tests not provided in the checker. Passing the checker does not mean that your code will earn full marks for correctness.
No Remark Requests
No remark requests will be accepted. A syntax error could result in a grade of
0 on the assignment. Before the deadline, you are responsible for running your
code and the checker program to identify and resolve any errors that will
prevent our tests from running.
What to Hand In
The very last thing you do before submitting should be to run the checker
program one last time. You should also run the checker program on MarkUs after
submitting.
Otherwise, you could make a small error in your final changes before
submitting that causes your code to receive zero for correctness.
Submit elevation.py on MarkUs by following the instructions on the course
website. Remember that spelling of filenames, including case, counts: your
file must be named exactly as above.
