Exploring Control Flow: Harnessing While Loops in Python

Control Flow with While
Loops in Python
For Any Homework Related Queries,
Text/ WhatsApp Us At : - +1(315) 557-6473
You Can Mail Us At : - support@programminghomeworkhelp.com or
Reach Us At : - https://www.programminghomeworkhelp.com/

Control Flow with
While Loops in Python
In this presentation, we delve into the concept of control flow in
Python with a focus on while loops. Control flow is a
fundamental aspect of programming that allows developers to
dictate the order in which instructions are executed. Among the
various control flow constructs, while loops are particularly
useful for repeating a block of code as long as a specified
condition remains true. We will explore practical applications of
while loops through two distinct problems: creating a secure
login system and developing a two-player game of Nim. These
examples will illustrate the versatility and power of while loops
in solving real-world problems.
https://www.programminghomeworkhelp.com/

Problem 1 - Login Security
One important aspect of security in computer science is the
concept of hashing: taking some text, and somehow
converting it to a number. This is needed because many
security algorithms work through math, so numbers are
needed.
Another important aspect is the use of the modulo operator
(%). You've seen this -- it returns the remainder portion of a
division. This is useful because unlike most other math
operators, modulo is one-way. That is, I can tell you that I'm
thinking of a number x, and when I mod it by 5, I get 3, but
from this information alone, you don't know whether x is 3 or 8
or 13 or 18, or ...
In this problem, we'll create a login screen, where the user

must enter a password in order to see a secret message. We
will give the user 3 chances to get the password right, and
either print the secret message or a failure message (after 3
chances).
First, define a function encrypt that takes one string. It will
hash the string using the built-in Python function hash (try it on
the shell) and modulo the value by a prime number (e.g. 541 --
this is very small in the computer science world but good
enough for us). The function should then return this number.
e.g. encrypt("mypassword") -> 283 (if you use 541 as the
prime, for example)
At the top of the file, define a variable _KEY to be the result,
e.g. _KEY = 283.

Now, write the rest of the program. Each time you ask the user
for the password, call encrypt with the user's input, and
compare the value to _KEY. If the two match, the user (most
likely) entered the correct password, otherwise he loses one
chance.
Problem 2 - The Game of Nims / Stones
In this game, two players sit in front of a pile of 100 stones.
They take turns, each removing between 1 and 5 stones
(assuming there are at least 5 stones left in the pile). The
person who removes the last stone(s) wins.
Write a program to play this game. This may seem tricky, so
break it down into parts. Like many programs, we have to use
nested loops (one loop inside another).

In the outermost loop, we want to keep playing until we are out
of stones.
Inside that, we want to keep alternating players. You have the
option of either writing two blocks of code, or keeping a
variable that tracks the current player. The second way is
slightly trickier since we haven't learned lists yet, but it's
definitely do-able!
Finally, we might want to have an innermost loop that checks if
the user's input is valid. Is it a number? Is it a valid number
(e.g. between 1 and 5)? Are there enough stones in the pile to
take off this many? If any of these answers are no, we should
tell the user and re-ask them the question.
So, the basic outline of the program should be something like
this:

TOTAL = 100
MAX = 5
pile = TOTAL # all stones are in the pile to start
while [pile is not empty]:
while [player 1's answer is not valid]:
[ask player 1]
[check player 1's input... is it valid?]
[same as above for player 2]
Note how the important numbers 100 and 5 are stored in a
single variable at the top. This is good practice -- it allows you
to easily change the constants of a program. For example, for
testing, you may want to start with only 15 or 20 stones.
Be careful with the validity checks.

Specifically, we want to keep asking player 1 for their choice
as long as their answer is not valid, BUT we want to make sure
we ask them at least ONCE. So, for example, we will want to
keep a variable that tracks whether their answer is valid, and
set it to False initially.
When you're finished, test each other's programs by playing
them!
# login.py
# Example solution for Lab 4, problem 1
#
# Some constants...
LARGE_PRIME = 541
_KEY = 171 # to get this number, I used the password
"solution"

MAX_FAILURES = 3 # stop when we hit this many failures
# The encrypt function. Remember, functions shouldn't be
asking for input or
# printing their result. Any input a function needs (in this case,
a string to
# encrypt) should be passed in, and the output should be
returned.
def encrypt(text):
return hash(text) % LARGE_PRIME
# Main program code
num_failures = 0
# We'll keep looping until we hit the max number of failures...
# We need to break out of the loop when we get it correct also,
see below.

while num_failures < MAX_FAILURES:
login = raw_input("Please enter the password: ")
if encrypt(login) == _KEY:
print "Correct!"
break # remember, this breaks out of the current loop
else:
num_failures = num_failures + 1
print "Incorrect! You have failed", num_failures, "times."
# When we get here, it's either because num_failures ==
MAX_FAILURES, or
# because we hit the break statement (i.e. we got the correct
login), so...
if num_failures >= MAX_FAILURES:
print "Sorry, you have hit the maximum number of failures
allowed."

print
print
# get a valid initial pile size
pile_size = int(raw_input("How many stones would you like to
start with?n"))
while pile_size <= 0:
pile_size = int(raw_input("You need to start with at least one
stone in the pile!n"))
# 2 players; player 1 and player 2. Start with player 1
player = 1
# main game loop
while pile_size > 0:
prompt = "Player " + str(player) + ", there are " +

str(pile_size) + " stones in front of you. " +
"How many stones would you like to remove (1-5)?n"
move = int(raw_input(prompt))
if move <= 0:
print "Hey! You have to remove at least one stone!"
elif move > pile_size:
print "There aren't even that many stones in the pile..."
elif move > 5:
print "You can't remove more than five stones."
else:
# if we're here, they gave a valid move
pile_size = pile_size - move
player = 2 - (player - 1) # this is kind of cute: changes 1
to 2 and 2 to 1.
# If we've exited the loop, the pile size is 0.

The player whose turn it is NOW just lost the game..
print "Player", 2 - (player - 1), "has won the game!“
# nims.py
# Example solution for Lab 4, problem 2.
#
#
TOTAL = 100
MAX = 5
pile = TOTAL # number of stones in the pile at any given time

def is_valid(x):
# returns True iff x is between 1 and MAX, and there's also
enough stones,
# otherwise returns False
return (x >= 1) and (x <= MAX) and (x <= pile)
while pile > 0:
# player 1 turn
print "Player 1's turn. There are", pile, "stones in the pile."
x = 0
while not is_valid(x):
# ask
x = int(raw_input("Player 1, how many? "))
# check
if not is_valid(x):
print "That's not valid, it has to be between 1 and 5,
and",

"you can't pick up more than there are in the pile."
pile = pile - x
if pile == 0:
# win -- do something
print "Congratulations, Player 1, you win!"
break
# player 2 turn
print "Player 2's turn. There are", pile, "stones in the pile."
y = 0
while not is_valid(y):
y = int(raw_input("Player 2, how many? "))
if not is_valid(x):
print "That's not valid, it has to be between 1 and 5,
and",

"you can't pick up more than there are in the pile."
pile = pile - y
if pile == 0:
# win -- do something
print "Congratulations, Player 2, you win!"
break
print "Game over."

Conclusion:
In conclusion, while loops are a crucial tool in a programmer's
arsenal, enabling the execution of repetitive tasks with
dynamic conditions. Through our exploration of the login
security system and the game of Nim, we have demonstrated
how while loops can manage repeated user inputs and control
game flow effectively. Understanding and utilizing while loops
empowers developers to build more robust and interactive
applications. As you continue to refine your programming
skills, mastering control flow constructs like while loops will be
instrumental in tackling increasingly complex challenges and
creating efficient solutions.

Exploring Control Flow: Harnessing While Loops in Python

More Related Content

Similar to Exploring Control Flow: Harnessing While Loops in Python (20)

More from Programming Homework Help (20)

Recently uploaded (20)

Exploring Control Flow: Harnessing While Loops in Python