3. Exercises: The Loop Tightens¶
These exercises are starting to approach the territory of so-called real programs. In particular the new things we learned in the material removes the previous limitation of having to use fixed number for data handled by the program, and for how many times instructions are done in the code. Repetition opens up a whole world of possibilities, but also requires new patterns of thought. The course project exercises in this page are particularly challenging but at the same time they do provide rather concrete building blocks for the project.
Learning Goals¶
Using loops and lists in problem solving. Solving even larger problems than before as we're released from the restrictions we had last time. Central concepts this time around are lists and loops. For the latter, both for and while loops will have their uses, and our hope is that these exercises will demonstrate the purpose of each. When it comes to lists, one important aspect is to learn how to design useful data structures.
Example¶
At the end of the second material we had an idea about a program that converts measurements from US customary the-radius-of-dumbledores-robe-hem-after-extinguishing-a-fire type of units to sane SI system units. We just didn't have the capability to handle measurements en masse because we didn't know anything about lists. Well, now we know! Let's make a program where the user can input multiple measurements results, unit and everything, and the program converts them to the corresponding SI units. Because the program has been designed for processing measurement data, navigating in menus should be minimized - therefore all units should be converted automatically regardless of what quantity they are. We are going to ditch temperature though because it doesn't fit the same factor-unit pattern with the rest.
We have no idea how to handle files yet so the program itself is going to be just a temporary solution. Although, technically, we could use
terminal
input/output control to take measurements from a file and even save the results into a file...At the end of the second material we had something along these lines and it worked for length:
LENGTH_FACTORS = {
"in": 0.0254,
"\"": 0.0254,
"ft": 0.3048,
"'": 0.3048,
"yd": 0.9144,
"mi": 1609.344
}
def convert_to_meters(measurement):
value = measurement["value"]
unit = measurement["unit"]
try:
meters = value * LENGTH_FACTORS[unit]
except KeyError:
measurement["invalid"] = True
else:
measurement["unit"] = "m"
measurement["value"] = meters
measurement = {"unit": "donkey", "value": 4.64}
print("{measurement['value']:.3f} {measurement['unit']}")
print("is")
convert_to_meters(measurement)
if not measurement.get("invalid", False):
print("{measurement['value']:.3f} {measurement['unit']}")
else:
print("Invalid unit")
Solution¶
The first problem to solve is: how to determine both the conversion factor and the target unit from the source unit? This could be done with a colossal
conditional structure
but ain't no one got the patience to maintain that. In the original example we took the factors from a dictionary
. Nothing prevents us from using data structures
as dictionary values - instead of just a factor we can therefore put a tuple
that includes both conversion factor and target unit. At the same time we can add all units to the same dictionary.UNITS = {
"in": (2.54, "cm"),
"\"": (2.54, "cm"),
"ft": (30.48, "cm"),
"'": (30.48, "cm"),
"yd": (0.9144, "m"),
"mi": (1.609344, "km"),
"oz": (28.349523125, "g"),
"lb": (0.45359237, "kg"),
"cp": (2.365882365, "dl"),
"pt": (4.73176473, "dl"),
"qt": (0.946352946, "l"),
"gal": (3.785411784, "l")
}
We can get the conversion factor from this structure by casting the following spell:
UNITS[unit][0], and the target unit with: UNITS[unit][1]. In other words we first find the tuple that corresponds with a key
, and then from within the tuple the value we wanted with index subscription
. Using this information, the above function can be changed into convert_to_si as follows:def convert_to_si(measurement):
value = measurement["value"]
unit = measurement["unit"]
try:
# first item in the tuple is the factor
si_value = value * UNITS[unit][0]
except KeyError:
measurement["invalid"] = True
else:
# second item in the tuple is the new unit
measurement["unit"] = UNITS[unit][1]
measurement["value"] = si_value
This function still modifies an existing dictionary and therefore doesn't need to return anything. Next we need to actually get measurements from somewhere. Because we want to make a program that can eventually process actual data files, we'll make a function that creates a list of measurements by prompting them from the user. We could also do the conversion immediately after
input
but because manual input is not the ultimate goal of the program, calling the conversion function should not be placed into the input function. The input function is just a data source. Input is processed with split like we learned in the material.def read_measurements():
print("Input measured values and units separated with spaces. Leave empty to quit.")
measurements = []
while True:
value_unit = input("Input measurement: ").strip()
if not value_unit:
return measurements
try:
value, unit = value_unit.split(" ")
value = float(value)
except ValueError:
print("Enter measurements in the specified format")
else:
measurements.append({
"unit": unit,
"value": value
})
This function implements something that was skipped in the material: how to handle quitting the program when the input is splitted. This usually requires handling the input in two phases - first the entire input is taken into a variable which can show whether it's empty, and only after that we try to convert into a usable form. Conveniently both lines in the try
branch
produce ValueError if they go wrong, so we can get away with just one except statement. Valid measurements are appended to the measurements list
as dictionaries that have the same structure as the previous example. These functions can be combined in the main function:def main()
measurements = read_measurements()
for measurement in measurements:
convert_to_si(measurement)
One interesting aspect with this solution is that the list that actually contains the measurements is never modified - only the dictionaries within it are changed. This shows quite nicely how
mutable
types work. We still need some way to show the results. Because this program is intended for bigger plans, printing should also be done in its own function.def print_measurements(measurements):
for measurement in measurements:
if measurement.get("invalid"):
print("Invalid measurement {value:.3f} {unit}".format(**measurement))
else:
print("{value:.3f} {unit}".format(**measurement))
Because the function itself doesn't do anything special, we've thrown in a trick that we didn't show in the material. It's possible to unpack the dictionary to act as format method
keyword arguments
. In other words the dictionary keys will become keywords, and they can be used as placholders
in the format template. **measurement could be replaced with value=measurement["value"], units=measurement["unit"]. Of course if you use this trick you have to make sure the dictionary actually contains the keys to match the placholders.As a final touch we add a call to this print function to the main function, and then we call the main function itself from the actual main program with a familiar structure:
try:
main()
except KeyboardInterrupt:
print("Measurement processing interrupted")
The whole program:
As a bonus trick we'll show how you could enter a batch of measurements to the program, at least on the Linux command line. Let's say we have the following file of measurements. The empty line at the end is very important!
This could be fed to our program like this:
/some/folder$ python3 converter.py < measurements.txt Input measured values and units separated with spaces. Leave empty to quit. Input measurement: Input measurement: Input measurement: Input measurement: Input measurement: Input measurement: 58.420 cm 351.534 g 86.905 km 2.240 m 20.101 l
The only eyesore here is how the input prompt is printed for each line in the file. But not to worry, in the next material we learn to read files properly with Python.
General Exercises¶
All of these are required.
Warmup Exercise¶
The Downward Spiral¶
Loops allow programmers to unleash their artistic talents (or lack of). Loops can be used in combination with some simple arithmetics to draw shapes and lines that change based on a pattern. In this example we're drawing some pleasantly patterned spirals.
Learning goals: How to do a predetermined number of iterations with a
loop
. We also recall how to define optional arguments
for functions.Goal: Make a program that draws patterned spirals that have adjustable parameters: color, radius, radius growth and pen weight.
Function Specification:
draw_spiral- Parameters:
- spiral's color (color string or three value tuple)
- number of arcs (quarter circle) to draw (integer)
- spiral's starting radius (integer)
- radius growth (float)
- pen weight (integer) - default value1
First thing to do in the function is to set the color and pen weight. Rest of the drawing commands are done inside a loop with a number of iterations equal to number of arcs. Each iteration draws a 90 degree arc after which the radius is incremented by radius growth. Note that the
loop variable
is not necessarily used for anything.Main Program:
The main program should consist of the following lines:
draw_spiral("black", 20, 10, 3)
draw_spiral("red", 10, 20, 4, 3)
draw_spiral("blue", 10, -20, -4, 3)
done()
These should draw the piece of art shown in the example.
List of Turtle Commands:
forward(x) # makes the turtle move forward x pixels, e.g. forward(42)
left(a) # makes a left turn of a degrees, where a is an integer, e.g.. left(40)
right(a) # makes a right turn of a degrees, where a is an integer, e.g.. right(40)
color(c) # sets color. c is a color value. In this exercise, you can use basic values such as "red", "yellow", "blue", e.g. color("red")
begin_fill() # begins a fill; any lines drawn after this are treated as boundaries for the fill
end_fill() # stops a fill; this command indicates that we're happy with our boundaries, and it's ok to pour the selected color (by the color command) inside
reset() # if you make a mistake, you can use this command to clear everything and return the Turtle to its origin.
up() # lifts the pen up so that it can be moved without drawing
down() # puts the pen back down
setx(x) # sets the pen's x coordinate to the given value
sety(y) # sets the pen's y coordinate to the given value
circle(r) # draws a circle with radius r; this happens by moving the pen a full 360 degree circle from its current position constantly steering to the left
pensize(w) # sets the pen's weight to w
In addition we're now going to use the first optional argument of the circle function:
circle(r, a) # draws an arc with radius r and sector angle a
Examples:
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Main Exercises¶
Prompt Automata¶
A whole lot of unnecessary work goes into creating and maintaining prompt loops for all inputs in a program just to check whether the user's actually given numbers. Let's automate this process a bit by creating one function that can be used whenever an integer needs to be prompted in a program, and we need to check that the input really was an integer. The function we create in this exercise is a very handy tool, and we will use it in the other exercises as a base. We even recommend using it in the course project.
Learning goals: Making a
loop
that is repeated until the user gives a valid input
. Writing a reusable function.Goal: A function that prompts the user for an integer until it gets one. The function has customizable prompt and error messages that can be given as
arguments
.Function Specification:
prompt_input- Docstring:
"""
Prompts the user for an integer using the prompt parameter.
If an invalid input is given, an error message is shown using
the error message parameter. A valid input is returned as an
integer.
"""
- Parameters:
- the input prompt message to display (string)
- error message to display for invalid input (string)
- Returns:
- The user's input as an integer (integer)
The function must present an input prompt with the given message until the user gives a valid integer. Whenever the user gives an invalid input, the error messages receives as the second parameter is printed, and the prompt is repeated. When the user's input is valid, it is returned as an integer. There's a particular example in the material you may find helpful.
Main Program:
In the main program we want to call the function twice with different arguments in order to show neatly it handles prompts using different messages. We've saved you the trouble of coming up with one by providing this code:
number = prompt_input(
"Give an integer: ",
"You did not give an integer"
)
print(f"You gave the {number} integer! Good job!")
moogles = prompt_input(
"How many moogles are in the Moogle Village? ",
"This is not a valid number of moogles!"
)
print(f"There are {moogles} moogles in the village.")
Use Examples:
When the above main program is executed, you should get the something like this if your function woks correctly:
Give an integer: donkey You did not give an integer Give an integer: sixtynine kappa You did not give an integer Give an integer: 5 You gave the 5 integer! Good job! How many moogles are in the Moogle Village? 7.5 This is not a valid number of moogles! How many moogles are in the Moogle Village? 1 There are 1 moogles in the village
Give feedback on this content
Was this task useful for learning?
Comments about the task?
A Prime Exercise¶
This is an exercise about prime numbers. That said. the more important part of this exercise is to use functions as tools and to reuse existing code. Both functions that will form the solution to this exercise could easily be taken out and used in another program without modifications. This is possible because well-designed tool functions don't do anything extra - they only do exactly what they promise, and return a value that can be used in further processing.
Learning goals: Using
loop variable
with the range function and ending a loop
with return. Reusing and modifying an existing function
.Goal: A program that prompts the user for an integer and tells whether it's a prime.
Introduction:
You need the
prompt_input function from the previous exercise. Copy it to your code file. You also need to slightly modify it.Function Modification:
prompt_input- Docstring:
"""
Prompts the user for an integer using the prompt parameter.
If an invalid input is given, an error message is shown using
the error message parameter. A valid input is returned as an
integer. Only accepts integers that are bigger than 1.
"""
- Parameters:
- the input prompt message to display (string)
- error message to display for invalid input (string)
- Returns:
- the user' input as integer (integer)
In addition to what it did previously, the function must also repeat the prompt if the given integer is smaller than or equal to 1. The same error message is used in all error scenarios.
Function Specification:
check_prime- Docstring:
Checks whether an integer is a prime number. Returns False
if the number isn't a prime; if it is a prime, returns True
- Parameters:
- number to check (integer)
- Returns:
- whether the number is a prime (boolean)
The function has to use some suitable method to determine whether the given number is a prime. You can investigate suitable methods with Google or Wikipedia!. You may find out that modulus (%) is a useful operator for this task. You may also find it useful to know that range accepts more than one
argument
. You can try stuff out in the Python console
!As the above specification should show, this function returns a value that indicates whether the number was a prime - it does not print the information!
Main Program:
The main program prompts the user for a number using the modified promp function. Then it uses the check function to determine whether the number was prime, and prints a statement based on the
return value
.Use Examples:
Give an integer that's bigger than 1: 1 You had one job Give an integer that's bigger than 1: four You had one job Give an integer that's bigger than 1: 9 This is not a prime
Give an integer that's bigger than 1: 7 This is a prime
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Course Project Exercises 1¶
Do one of these, preferably the one that matches your course project topic. These tasks are not required for minimal course completion.
Mine Assignment: Field Day¶
Grids are usually represented as two-dimensional lists, i.e. as a list that contains other lists where each inner list corresponds to a row in the grid, and each item in the inner lists is one the content of one square or tile. In this exercise we'll take our first proper look at such lists, and particularly at what kinds of loops are required for iterating through them. We'll take a short break from sweeping mines, and instead head into the countryside to examine what kinds of animals can be found from the nearby fields... Even so, the princples here very much apply in the Minestomper course project.
Learning goals: Using nested
for loops
to iterate through 2-dimensional lists.Goal: A program that examines all tiles in a field and tells what animals were there.
Introduction:
We're going to use a dictionary once again. The reason is that in the field lists, animals are marked with single characters, but we want to print their actual names in the output. The following dictionary connects the identifiers to the animals:
ANIMALS = {
"s": "sloth",
"d": "doggo",
"@": "cat",
"m": "moogle",
"c": "chocobo"
}
1st Function Specification:
explore_tile- Docstring:
"""
Explore a tile - if there is an animal, prints the
location and name of the animal
"""
- Parameters:
- the character in the tile (string)
- row number
- column number
Information about the animal is printed if its identifier character is found from the dictionary. If it's not there, nothing is printed. The print is in the form "Tile (5, 6) contains donkey" where 5 is the x coordinate and 6 is the y coordinate. It's almost like we've seen this before... Note that y matches the row number, and x matches column number.
The checker reserves the rights to modify the given dictionary, which must be taken into account in your implementation.
2nd Function Specification:
explore_field- Docstring:
"""
This function explores an entire field by calling the explore_tile
function for each tile in the field.
"""
- Parameters:
- 2-dimensional list that represents a field
The function must go through all tiles is in the field. This is best done with for loops. Because we need each tile's coordinates for the
check_tile function, we need both the contents of rows and tiles along with their indices
. Keep in mind that the outer index is used to select the rows, and therefore corresponds to the y coordinate.Main Program:
Define an example field, and call the explore_grid function. We've given you a field. We trust your ability to write a
function call
at this point.field = [
[" ", "s", " ", " ", "m"],
[" ", "d", "@", "d", " "],
["c", " ", "s", "d", " "]
]
Example Use:
Running the main program with the given field should print:
Tile (1, 0) contains sloth Tile (4, 0) contains moogle Tile (1, 1) contains doggo Tile (2, 1) contains cat Tile (3, 1) contains doggo Tile (0, 2) contains chocobo Tile (2, 2) contains sloth Tile (3, 2) contains doggo
Not that if you have gotten the coordinates mixed in both functions, you will get the correct print but your functions individually don't work correctly.
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Spectral Assignment: A Pointed Line¶
In this exercise you'll get to work on the process of creating a new list based on an existing one. This technique is typically needed e.g. when some formula needs to be applied to all values in a list. This might also be useful for the Spectral Matters course project.
Learning goals: Creating a new
list
by using items
of an existing list.Goal: A program that calculates intermediate points of a line between two endpoints.
Introduction:
The
calculate_parameters function that was created in last time's exercises is needed again. Go grab it from your answer.1st Function Specification:
prompt_two_numbers- Docstring:
"""
Prompts two floats from the user, separated by a space. The prompt
is repeated until the user gives a valid input. Both numbers are
returned as floats.
"""
- Parameters:
- prompt string (string)
- Returns:
- x coordinate of the point (float)
- y coordinate of the point (float)
Prompts the user to
input
two floats separated by a space, using the given prompt string. The prompt is repeated until the user gives a valid input. If there is an error, the function prints "Give two numbers separated by a space". When the input is valid, both numbers are returned as floats.2nd Function Specification:
determine_points- Docstring:
"""
Produces a list of values that are the y values of a line with
the given slope and y intercept, from a list of x values.
"""
- Parameters:
- line slope (float)
- line y intercept (float)
- list of x values (list of floats)
- Returns:
- list of y values (list of floats)
The function must create a new list with the calculated y coordinate values.
Main Program:
The program prompts the user for two points aby using the brand new prompt_two_numbers function. You can see the
argument
string in the examples below. After prompting, the program prints a list of y coordinates that are calculated from a list of x coordinates and the line parameters. The following list of x coordinates is used in testing the main program:
x_axis = [
0.0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5,
2.75, 3.0, 3.25, 3.5, 3.75, 4.0, 4.25, 4.5, 4.75, 5.0
]
The checker will naturally test your functions with other lists as well. In order to get a print that matches the examples, you can use the loop shown below. It uses the end keyword argument of print to swap the newline at the end of each print to a single space. We can't use the join method here because the lists don't contain strings.
for y in line:
print(f"{y:.4f}", end=" ")
Use Examples:
Input first point: donkey Give two numbers separated by a space Input first point: 0 0 Input second point: 1 1 Line y values are: 0.0000 0.2500 0.5000 0.7500 1.0000 1.2500 1.5000 1.7500 2.0000 2.2500 2.5000 2.7500 3.0000 3.2500 3.5000 3.7500 4.0000 4.2500 4.5000 4.7500 5.0000
Input first point: 0.0 1.0 Input second point: 0 Give two numbers separated by a space Input second point: 1.0 0.0 Line y values are: 1.0000 0.7500 0.5000 0.2500 0.0000 -0.2500 -0.5000 -0.7500 -1.0000 -1.2500 -1.5000 -1.7500 -2.0000 -2.2500 -2.5000 -2.7500 -3.0000 -3.2500 -3.5000 -3.7500 -4.0000
Input first point: 0 0 Input second point: 2 1 Line y values are: 0.0000 0.1250 0.2500 0.3750 0.5000 0.6250 0.7500 0.8750 1.0000 1.1250 1.2500 1.3750 1.5000 1.6250 1.7500 1.8750 2.0000 2.1250 2.2500 2.3750 2.5000
Input first point: -5 5 Input second point: 0 0 Line y values are: 0.0000 -0.2500 -0.5000 -0.7500 -1.0000 -1.2500 -1.5000 -1.7500 -2.0000 -2.2500 -2.5000 -2.7500 -3.0000 -3.2500 -3.5000 -3.7500 -4.0000 -4.2500 -4.5000 -4.7500 -5.0000
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Circuit Assignment: Engineer's Little Helper¶
In this exercise you get to create a function that will immensely enhance the user experience in the Run, Circuit! Run! course project: inputting components and their values using unit prefixes (kilo, mega, milli, micro etc.)
Learning goals: Separating unit prefix from a
string
. Retrieving a multiplier from a dictionary
.Goal: A program that can convert a unit prefix into its corresponding multiplier.
Introduction:
In order to make the conversion smooth, it's best to define a dictionary at the beginning of the program. The dictionary should have unit prefix symbols as
keys
and their corresponding multipliers as values. You can find the unit prefixes from here. We want a dictionary that has all units from the table in the link except deca (i.e. all with one character symbol). Use "u" for micro because it's easier to type than "μ".Function Specification:
convert_prefix- Docstring:
"""
Converts the given number and (optional) unit prefix into the
corresponding float.
"""
- Parameters:
- number to convert (string)
- Returns::
- converted number (float)
This
function
takes the value from its parameter and returns the corresponding float value, or None if the value wasn't valid. The conversion should be done using the dictionary we asked you to define. The checker will reject solutions with as many branches
as there are unit prefixes. There are a couple of problems to solve here: how to take out the (optional) unit prefix from the string, and how to convert the whole thing into a float.Main Program:
The main program should prompt the user for a value to convert until they provide a valid one. The main program also prints the result of the conversion. If the value is not valid (i.e. your function returns None), the program prints
"Input was not valid" and prompts again. Note that the program should end after one valid input as you can see from the examples.Use Examples:
Input value to convert: 2k 2000.0
Input value to convert: 1.5G 1500000000.0
Input value to convert: 220 220.0
Input value to convert: 2B Input was not valid Input value to convert: iceT Input was not valid Input value to convert: 0.1m 0.0001
Note also that if a value is very big or small, Python automatically converts it to exponential notation. The following happens automatically:
Input value to convert: -560p -5.6e-10
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Duck Assignment: Inner Circle¶
Being part of the inner circle is cool. From a definition point of view it can be regarded as being inside a certain perimeter. This is something we can do with a program as well! It should also be helpful when slinging birds into the sky.
Learning goals: Calculating the distance between two points. Positioning a point from outside a circle to the perimeter of the circle without changing the angle in regards to the cenral point.
Goal: A program that finds the correct position for a point inside a circle or on its perimeter.
Introduction:
The Sinful Function task from the very first exercise has a function that can be useful in this exercise. Depending on what kind of solution you go for.
1st Function Specification:
calculate_distance- Docstring:
"""
Calculates the distance between two points and returns it.
"""
- Parameters:
- X coordinate of the first point (float)
- Y coordinate of the first point (float)
- X coordinate of the second point (float)
- Y coordinate of the second point (float)
- Returns:
- Distane between the points (float)
Figuring out the formula to calculate the distance is part of the assignment.
2nd Function Specification:
clamp_inside_circle- Parameters:
- X coordinate of a point (float)
- Y coordinate of a point (float)
- X coordinate of a circle's center (float)
- Y coordinate of a circle's center (float)
- Radius of the circle (float)
- Returns:
- Clamped x coordinate for the point (float)
- Clamped y coordinate for the point (float)
First the function needs to find out whether the given point is already inside the circle. If it is, its coordinates are simple returned as they are. However, if the point is outside the circle, it needs to be "pulled" to the circle's perimeter. In doing so, the angle from the circle's center must be maintained while the distance is set exactly to the circle's radius.
Main Program:
The following circle will be used in testing:
center_x = 10
center_y = 20
radius = 100
Write a main program that prompts the user for a point with two inputs that accept floats. The program will then fit the point inside the above circle and print the final coordinates. You can find examples below.
Examples:
The point will be clamped within 100 radius from the point (10, 20) Input x coordinate: -140 Input y coordinate: -40 Coordinates within the circle: (-82.85, -17.14)
The point will be clamped within 100 radius from the point (10, 20) Input x coordinate: 50.0 Input y coordinate: 80.0 Coordinates within the circle: (50.00, 80.00)
The point will be clamped within 100 radius from the point (10, 20) Input x coordinate: 30 Input y coordinate: -30 Coordinates within the circle: (30.00, -30.00)
The point will be clamped within 100 radius from the point (10, 20) Input x coordinate: 40.0 Input y coordinate: -110.0 Coordinates within the circle: (32.49, -77.44)
The point will be clamped within 100 radius from the point (10, 20) Input x coordinate: -50 Input y coordinate: 40 Coordinates within the circle: (-50.00, 40.00)
You can also see these examples visualized in the image below.
Course Project Exercises 2¶
Do one of these as well. These tasks are not required for minimal course completion.
Mine Assignment: B Class Action¶
The followers of the path of the Minestomper will find mastering the secrets of this exercise useful. Your task is to assist a brave hero in counting the amount of ninjas surrounding them. In order to attain the rank of apprentice in the Minestomper skill tree, you'll get to implement this function that could also be used for counting mines...
Learning goals: Handling surrounding cells in a 2-dimensional
list
and counting certain characters from them.Goal: A program that counts the number of ninjas surrounding a tile.
Function Specification:
count_ ninjas- Doctstring:
"""
Counts the ninjas surrounding one tile in the given room and
returns the result. The function assumes the selected tile does
not have a ninja in it - if it does, it counts that one as well.
"""
- Parameters:
- x coordinate of the selected tile (integer)
- y coordinate of the selected tile (integer)
- a data structure representing a room (list that contains lists that contain single character strings)
- Returns:
- number of ninjas (integer)
There are at most 8 surrounding tiles - diagonals are counted. You always need to make sure you're not trying to count ninjas from out of bounds (nor should you count ones from opposite walls if the index goes negative). Those desiring to become master minestompers should implement the counting with
loops
. The function must work with rooms of any size. This means that you have to measure the boundaries inside the function from the list structure that represents a room (using the len function).
Main Program Specification:
The main program should use the following room:
room = [
['N', ' ', ' ', ' ', ' '],
['N', 'N', 'N', 'N', ' '],
['N', ' ', 'N', ' ', ' '],
['N', 'N', 'N', ' ', ' '],
[' ', ' ', ' ', ' ', ' '],
[' ', ' ', ' ', ' ', ' ']
]
The program needs to print the room, prompt the user for coordinates, and then output the number of ninjas surrounding those coordinates. You can use the following code snippet to print the room.
print(" ", "- " * 5)
for row in room:
print("|", " ".join(row), "|")
print(" ", "- " * 5)
Examples:
- - - - -
| N |
| N N N N |
| N N |
| N N N |
| |
| |
- - - - -
Input x coordinate: 1
Input y coordinate: 2
The tile is surrounded by 8 ninjas
}}}
{{{
- - - - -
| N |
| N N N N |
| N N |
| N N N |
| |
| |
- - - - -
Input x coordinate: 4
Input y coordinate: 0
The tile is surrounded by 1 ninjas
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Spectral Assignment: Walker - Measurement Ranger¶
This exercise should be helpful in dealing with Spectral Matters. This is a relatively common problem where we have two lists with data - one contains measurement points, and the other the corresponding measured values - and we want to select a matching slice from both of them. In order to succeed, a reverse index lookup is needed - you need to figure out the indices of measurement points.
Learning goals: Finding
indices
from lists
with boundary values that are not among the list's items
. Goal: A program that finds the desired slice from a list of measurement points, and the corresponding slice from the measured values list.
Introduction:
The
prompt_two_numbers function from the previous exercise can be used in this one as well. This time we're not prompting for a coordinate pair, but rather two points from the same axis. But hey, it doesn't matter because we can just change the prompt thanks to making the function flexible enough. No need to modify this function.Function Specification:
find_indices- Docstring:
"""
Finds two endpoints from a list of numerical data so that the resulting
the values between the selected indices are between the given minimum
and maximum boundaries. Returns the two indices.
"""
- Parameters:
- measurement point series (list of floats)
- selected minimum boundary (float)
- selected maximum boundary (float)
- Returns:
- starting index for the selection (integer)
- end index for the selection (integer)
The function must find the index for the first
item
that's bigger than (or equal to) the minimum boundary - this is the start index. It also needs to find the first item that's bigger than the maximum - the index of this item is the end index. In accordance with how slicing
works in Python, the end index is the first index that will not be included. If the maximum is bigger than the last item in the list, use the list's length for the end index. If both are bigger, return the list's length for both.Main Program:
The main program needs two lists: first list contains the measurement points, and second list contains measured values. The lists are shown below.
m_points = [
10.000, 10.244, 10.429, 10.576, 10.589, 10.606, 10.714, 10.794, 10.879, 10.99,
11.263, 11.448, 11.596, 11.836, 11.869, 11.936, 12.174, 12.182, 12.243, 12.282,
12.285, 12.297, 12.363, 12.417, 12.629, 12.71, 12.816, 13.138, 13.153, 13.215,
13.27, 13.32, 13.367, 13.368, 13.923, 13.97, 14.171, 14.204, 14.235, 14.382,
14.481, 14.581, 14.588, 14.645, 14.7, 14.704, 14.711, 14.803, 14.936, 15.000
]
m_values = [
30.4, 74.165, 118.615, 54.293, 174.187, 162.399, 25.643, 181.571, 151.84, 147.307,
85.115, 81.337, 65.852, 127.676, 10.409, 131.279, 32.595, 89.49, 40.263, 32.712,
114.974, 7.967, 131.166, 124.827, 172.936, 145.234, 156.433, 118.446, 2.253, 69.263,
99.249, 23.344, 119.2, 169.069, 187.976, 113.63, 173.847, 193.978, 54.206, 60.27,
199.026, 167.434, 138.631, 3.259, 23.886, 88.825, 49.804, 109.179, 62.388, 126.052
]
You should use the prompt_two_numbers function to get the minimum and maximum boundaries from the user, and then print the corresponding slice of measurement values.
Use Examples:
Give two measurement points separated by space: harry Give two numbers separated by a space Give two measurement points separated by space: 11 Give two numbers separated by a space Give two measurement points separated by space: 11 13 Measured values in the selected range: [85.115, 81.337, 65.852, 127.676, 10.409, 131.279, 32.595, 89.49, 40.263, 32.712, 114.974, 7.967, 131.166, 124.827, 172.936, 145.234, 156.433]
Give two measurement points separated by space: 10.606 11.936 Measured values in the selected range: [162.399, 25.643, 181.571, 151.84, 147.307, 85.115, 81.337, 65.852, 127.676, 10.409, 131.279]
Give two measurement points separated by space: 10 15 Measured values in the selected range: [30.4, 74.165, 118.615, 54.293, 174.187, 162.399, 25.643, 181.571, 151.84, 147.307, 85.115, 81.337, 65.852, 127.676, 10.409, 131.279, 32.595, 89.49, 40.263, 32.712, 114.974, 7.967, 131.166, 124.827, 172.936, 145.234, 156.433, 118.446, 2.253, 69.263, 99.249, 23.344, 119.2, 169.069, 187.976, 113.63, 173.847, 193.978, 54.206, 60.27, 199.026, 167.434, 138.631, 3.259, 23.886, 88.825, 49.804, 109.179, 62.388, 126.052]
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Cirtuict Assignment: Overwhelming Resistance¶
Handling resistors is one of the more simple calculations when it comes to electric circuits. They'll be a good first step towards the Run, Circuit! Run! course project. In this exercise you'll get to calculate simple serial and parallel connections.
Learning goals: Gathering user
inputs
to lists
and using these lists in calculations.Goal: A program that can calculate the total impedance of serial and parallel connections for resistors.
1st Function Specification:
prompt_values- Docstring:
""" Prompts floats from the user until an empty input is given. Given values are returned as a list. """
- Returns:
- given values as list of floats (list)
The function must implement a
loop
that is repeated until the user's input is empty ("", i.e. its truthfulness is False). You should initialize an empty list at the beginning of the function, and then collect all valid floats given by the user into it. Invalid inputs are rejected with an error message.2nd Function Specification:
calculate_serial- Docstring:
""" Calculates the serial total resistance for the list of given resistor values. """
- Parameters:
- list of resistor values (list of floats)
- Returns:
- total resistance (float)
Calculates the total resistance for the given list of resistors and returns it. Simple.
3rd Function Specification:
calculate_parallel- Docstring:
""" Calculates the parallel total resistance for the list of given resistor values. """
- Parameters:
- list of resistor values (list of floats)
- Returns:
- total resistance (float)
Calculates the parellel total resistance. This is not as simple. You must calculate the inverse values for each resistor inside your function, because the values inside the list it receives have not been inverted yet.
Main Program Specification:
The program must use the
prompt_values function to get resistors from the user and finally report the total serial and parallel resistances for these resistors. If the user doesn't input any resistors, you need to skip the calculations - parallel calculation would cause an exception
in this case.Use Examples:
Input resistor value: 0 Component value must be bigger than zero Input resistor value: 100 Input resistor value: 200 Input resistor value: 300 Input resistor value: Serial resistance: 600.0 Parallel resistance: 54.54545454545455
Input resistor value: One Ohm Component value must be bigger than zero Input resistor value: 1.00 Input resistor value: Two Ohms Component value must be bigger than zero Input resistor value: 2.00 Input resistor value: Serial resistance: 3.0 Parallel resistance: 0.6666666666666666
Input resistor value: You didn't input any resistors
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Give feedback on this content
Comments about these exercises