## Description

Part 1: Geometry and breathing!

This problem is a warm up of the use of functions. You will be asked to write a few simple functions.

A number of countries and companies are planning manned trips to Mars in the next few decades.

Let’s think ahead to one of the more important considerations for the trip – breathable air. Now,

the space station gets most of its oxygen from the electrolysis of water and I expect that a trip to

Mars will use a similar method, but what if we needed to carry all the oxygen needed along with

the astronauts? How much oxygen would we need to carry?

We will make some simplifying assumptions: the capsule is a sphere, 41% of the oxygen in the

capsule is used each day, and oxygen is stored in a set of cylindrical tanks (essentially SCUBA

tanks). These tanks are pressurized to 3000 psi, which means that each reservoir tank holds 210

times its internal volume of gas. Your problem is to determine the total volume of oxygen needed

for the trip, the amount of oxygen per tank, and therefore the number of oxygen tanks.

Your program will ask the user for the dimensions of the spherical capsule (radius) and the

dimensions of the reservoir cylinder, again (radius, height), reading these through input. The

program will then produce the results as follows

Calculate and output the total amount of oxygen needed during the journey to Mars. This

is the volume in the spherical capsule times the amount of oxygen in the air (21%) times the

percent of the oxygen used each day (41%) times 300 days for the one way trip.

Remember the volume of a sphere is given by pi* radius**3 * 4/3. You must write a

function volume_sphere(radius) to compute this and use it in your computation. You

must use the math module for the value of pi.

Calculate and output the amount of oxygen held in each cylindrical tank with the given dimensions radius, height. Remember, the volume of a cylinder is given by pi* radius**2 * height.

Write a function volume_cylinder(radius, height) that finds and returns the volume of a

cylinder with the given measurements. (Here you are welcome to make use of the code from

the lecture notes!) Output the amount of oxygen the cylinder holds at 3000 psi (210 times

the volume of the cylindrical tank). You must use the math module for the value of

pi.

Calculate and output the number of oxygen tanks the capsule will need to carry with it on

the journey. Always choose the next largest whole number, so 0.2 tanks becomes 1 tank,

while 1 tank remains 1 tank. Look at the ceil function in the math module to help you do

this.

As a final note, assume that all of the oxygen needed is contained in the reservoirs. In other words,

you do not need to account for the oxygen already in the capsule at the start of the journey, nor

do you need to be concerned with the amount of oxygen left in the tank at the end.

Here is example output of your program (how it will look on Wing IDE):

Radius of capsule (m) ==> 2.5

2.5

Radius of oxygen reservoir (m) ==> 0.093

0.093

Height of oxygen reservoir (m) ==> 0.633

0.633

Oxygen needed for the trip is 1690.570m^3.

Each cylinder holds 3.612m^3 at 3000 psi.

The trip will require 469 reservoir tanks.

Remember, you will need to use formating strings to generate the output in exactly the form we

have shown it above. This is necessary to match our output.

When you have tested your code, please submit it as Part 1 of HW 2.

Part 2: A simple trick (numerical functions)!

The original of this simple parlor trick is attributed to Albert Einstein, but it probably dates to

an earlier date! We’ve modified it a little to test a few more math functions and give a little more

challenge.

The trick: First, write the number 1089 on a piece of paper, fold it, and put it away. Next, ask

your friend to write down a five-digit number, emphasizing that the first and third digits must

differ by at least two. Don’t watch your friend doing the arithmetic. After your friend has written

down the five-digit number, ask them to reverse it, take the first three digits of the original number

and the last three digits of the reversed number, then subtract the smaller from the larger.

Example: 32156 reversed is 65123

321 – 123 = 198.

Tell your friend to reverse the new number.

Example: 198 becomes 891.

Next ask your friend to add the new number and its reverse together.

Example: 198 + 891 = 1089.

If all goes as planned, your friend will be amazed. The number you wrote down at the start –1089–

will always be the same as the end result of this mathematical trick.

Your job is to write a program that mimics this parlor trick by first predicting the outcome, then

requesting a five-digit number from the user, applying the steps above, outputing the steps as it

goes, and checking the result to make sure it is indeed 1089.

When looking at a problem like this, it is important to try to think about the central issue —

the most challenging question — and try to solve it first and check your solution. Here, the most

difficult question for us is reversing the digits in an integer. There are a number of ways to do this,

but we want you to think about it by making use of integer division and integer remainders (the

// and % operators). Here is code that will help you get started and help you understand as well

how to grab the first three digits:

>>> x = 14926

>>> x // 100 # Gets the first three digits

149

>>> x % 100 # Gets the last two digits

26

>>> y = 75 # We are going to reverse a two digit number

>>> tens = y//10 # Gets the tens digit

>>> tens

7

>>> ones = y%10 # Gets the ones digit

>>> ones

5

>>> ones*10 + tens # Gives us the reversed number

57

Start your programming effort by writing and testing a function called reverse3 that calculates

and returns the reverse of a three digit number. Test this function carefully. For example

>>> reverse3(123)

321

Next, write and test a function called reverse5 that calculates and returns the reverse of a five

digit number. Test this function carefully. For example,

>>> reverse5(26417)

71462

With these two functions done, write the complete program to mimic the parlor trick. The program

should the produce output given below by asking the user for a five-digit integer, and then carrying

out the computation outlined above, using the two reverse functions as needed. The program should

output the steps of the computation. Then, add a print statement at the end of your program to

say “You see, I told you”.

Your output must match the following (this is how it will look on Wing):

Enter a 5 digit number whose first and third digits must differ by at least 2.

The answer will be 1089, if your number is valid

Enter a value ==> 29467

29467

Here is the computation:

29467 reversed is 76492

492 – 294 = 198

198 + 891 = 1089

You see, I told you.

When you have tested your code, please submit it as Part 2 of HW 2.

Part 3: Find the hidden message! (string functions and an if)

Write a program that either encrypts or decrypts a string, depending on the choice that the user

makes. First, the program should ask the user whether they want to encrypt (’E’) or decrypt

(’D’), then it should ask the user for a sentence using (input) written in a cipher to decrypt, or in

clear text to either encrypt (if ’E’ was input) or decrypt. The program should then carry out the

encrypt or decrypt operation using the rules described below and print the resulting sentence. For

both encrypt and decrypt, the program should print the difference in length between the cipher

and clear text versions. The difference should always be printed as a positive number. The ’E’

for encrypt, or ’D’ for decrypt should be case insensitive, which means that ’e’ means encrypt,

just like ’E’ does. If something other than ’E’ or ’D’ is entered in respone to the first query, just

print “I didn’t understand … exiting” and exit the program. Processing the input will require

an if/elif/else block. We will cover if/elif/else on Monday. Until then, you can write the

encrypt and decrypt functions and apply both to any string that is given. Do not let the fact

that we have not covered if keep you from getting a jump on this homework. All of

parts 1 and 2 can be completed as well as most of part 3.

Here is a series of examples running of the program (what you will see on Wing):

Run 1:

Enter ‘E’ for encrypt or ‘D’ for decrypt ==> d

d

Enter cipher text ==> wh*%$ s7654 s2(*2(ri7654@@@s

wh*%$ s7654 s2(*2(ri7654@@@s

Deciphered as ==> why so serious

Difference in length ==> 14

Run 2:

Enter ‘E’ for encrypt or ‘D’ for decrypt ==> e

e

Enter regular text ==> back off man I am a scientist

back off man I am a scientist

Encrypted as ==> back 7654ff m-? I%4%m%4% sci2(*2(ntist

Difference in length ==> 9

Run 3:

Enter ‘E’ for encrypt or ‘D’ for decrypt ==> D

D

Enter cipher text ==> wh*%$ s7654 s2(*2(ri7654@@@s

wh*%$ s7654 s2(*2(ri7654@@@s

Deciphered as ==> why so serious

Difference in length ==> 14

Run 4:

Enter ‘E’ for encrypt or ‘D’ for decrypt ==> E

E

Enter regular text ==> back off man I am a scientist

back off man I am a scientist

Encrypted as ==> back 7654ff m-? I%4%m%4% sci2(*2(ntist

Difference in length ==> 9

Run 5:

Enter ‘E’ for encrypt or ‘D’ for decrypt ==> a

a

I didn’t understand … exiting

The encryption rules are based on a set of string replacements, they should be applied in this order

exactly:

‘ a’ => ‘%4%’ replace any a after a space with %4%.

‘he’ => ‘7!’ replace all occurrences of string he with 7!

‘e’ => ‘9(*9(‘ replace any remaining e with 9(*9(

‘y’ => ‘*%$’ replace all occurrences of string y with *%$

‘u’ => ‘@@@’ replace all occurrences of string u with @@@

‘an’ => ‘-?’ replace all occurrences of string an with -?

‘th’ => ‘!@+3’ replace all occurrences of string th with !@+3

‘o’ => ‘7654’ replace all occurrences of string o with 7654

‘9’ => ‘2’ replace all occurrences of string 9 with 2

For example the cipher for methane is m2(*2(!@3-?2(*2(+. Here is how we get this:

>>> ‘methane’.replace(‘e’,’9(*9(‘)

‘m9(*9(than9(*9(‘

>>> ‘m9(*9(than9(*9(‘.replace(‘an’,’-?’)

‘m9(*9(th-?9(*9(‘

>>> ‘m9(*9(th-?9(*9(‘.replace(‘th’,’!@+3′)

‘m9(*9(!@+3-?9(*9(‘

‘m9(*9(!@+3-?9(*9(‘.replace(‘9’, ‘2’)

‘m2(*2(!@+3-?2(*2(‘

Decrypting will involve using the rules in reverse order.

Your program must use two functions:

Write one function encrypt(word) that takes as an argument a string in plain English, and

returns a ciphered version of it as a string.

Write a second function decrypt(word) that does the reverse: takes a string in cipher and

returns the plain English version of it.

Both functions will be very similar in structure, but they will use the string replacement rules in

different order. You can now test whether your functions are correct by first encrypting a string,

and then decrypting. The result should be identical to the original string (assuming the replacement

rules are not ambiguous).

Use these functions to implement the above program. When you have tested your code, please

submit it as Part 2 of HW 2.

Finished and still want extra challenges to sharpen your programming skills? These

are not extra credit but for you to do additional practice.

Revise part 2 so that if the person enters a number that is not valid (i.e. first and third

digit do not differ by two), you immediately print a statement informing the user and do not

compute anything. Otherwise, you carry out the above computation.

Revise part 3 so that it takes an input sentence, encrypts it and then decrypts it, and then

checks whether the result is the same. It should print “same” if they are the same and

“different” otherwise.