Mars or bust!

Wait, what!? We've never learned how to do that! I don't know anything about space stuff!

Maybe we have learned how to do it. On the surface, this is about space, but let's look under the surface.

Is there a pattern we can use?

You know, the I/O looks like we could use the IPO pattern.

You're right. The I/O has input, processing, and output. We know how to do them.

I'd start with comments.

That OK?

I like making structure diagrams, showing the variables each chunk needs. It is OK if we do that?

Sounds like a plan.

If you think it will help. I'm still panicking a bit.

I think Adela's on the right track. Let's try making a structure diagram, and see where it takes us.

OK. I like Draw.IO for these tasks.

(Worky work)

Here's what I've got so far.

OK, now I'll add the variables that go from input to processing.

How did you know what to add?

I looked at the I/O. It asked the user for four things.

Oh, OK. I see it now.

(Worky work)

I see what you did there. You looked at the output part of the I/O, and made variables for the data the output code needs.

Are those variable names OK?

Yep. Lowercase, underscores, and the names tell you what we'll use the variables for.

Looks like we have a plan for the program.

Great! Now let's work on the input. How about these comments?

It might be cool if we used functions for this. We could even have one function to do all the input. What do you think?

Ooo! I like it! Let's give it a try.

We can call the funciton get_input, or something.

OK, but... we'll have code like goats = get_input(), something like that, right?

Kinda. Like this:

Oh, right! I forgot, you can get a bunch of things back from a function.

I like where this is going!

Hey, check out this I/O. The same pattern for each goat size.

The I/O's the same for each goat type, almost. Just the prompt's different.

The inputs have the same minimum and maximum values, too, 0 and 100.

Maybe... we could write one function to get one input, and call it three times? With different prompts?

Maybe like:

Nice!

What about the months?

Let's think this through, see what's different about goats and months. There's the prompt, goats vs. months. The minimum and maximum values are different, too. 0 to 100 for goats, 1 to 96 for months.

Oh... so... We could write a function that takes these three things: prompt, minimum valid, and maximum valid. As parameters, I mean.

Maybe like:

Dude, that's great! One function to rule them all.

So good, my precious. I likses it!

Anyone mind if I try writing the input function?

Let's see. I'll start with the stuff we wrote before.

We need to change is line 6, change the prompt. It's a parameter now...

OK, line 9 is meal_cost = float(user_input). We can't use meal_cost anymore. I'll just call it value for now.

Should it be a float?

Huh? Let's see... Oh! The spec says:

- - DOODLEE DOO, DOODLEE DOO (that's flashback music) - -

There'll be big, medium, and small goats on the ship. Valid values for each one are integers from 0 to 100.

...

Months is an integer from 1 to 96.

- - DOO DOODLEE, DOO DOODLEE - -

You're right. It should be:

The only other thing we need to change is here:

Should be:

Oh, and the return. Here's the whole function.

Could we put this in a test program? Just this function. Isolate it from the rest.

Maybe like this:

Good idea!

Scoobies FTW!

Processing looks hard. What do we do?

You know how we did the program's structure?

Oh, yeah. The thing Adela drew.

OK, if we make one processing function, we can call it as usual. But... we'll let me show you.

Wow, that's messy. It's be easy to mess up, too, get variables in the wrong order. I read earlier that's a common mistake.

Yeah. But... there's kinda two things going on. Two big steps to working everything out.

I see it now.

• Use number of goats to work out food, water, and oxy needed.
• Use food, water, and oxy needed to work out costs.

Think we should split them up?

Would that work?

It should. Let me give the calls a try.

Me again? Um, OK.

Let me check the specs.

- - DOODLEE DOO, DOODLEE DOO - -

Here's a table of requirements for each goat type per month:

- - DOO DOODLEE, DOO DOODLEE - -

We got goats, we got these numbers... I'll start with the signature.

Now the calcs. Use the table... here.

Add docstring... Umm, the parameters are ints, but there are things like 2.2 and 2.8 in the calcs. They're floats. food_needed and the others might be floats.

Yes! I'll do this one.

I'll put the code into a new program, and add a few lines.

I see what you did there. Put in a breakpoint on line 37. Then we check the Variable Explorer.

Yep! And I put simple values in the variables, easy to test.

Let's give it a try.

Let's see... 60 plus 130 plus...

Everything works!

Let's try some different values for the variables...

Yay! Works!

We have part 1 of the processing. Onto the next bit.

Can I give it a try?

Let's see... Here's the signature first.

Here's the specs:

- - DOODLEE DOO, DOODLEE DOO - -

Here's what the supplies cost:

Food: $32.50 per kilo Water: $17.23 per liter Oxygen: $31.84 per liter

- - DOO DOODLEE, DOO DOODLEE - -

OK, here's what I have, with the docstring.

Ya know, that was much easier than I thought.

For the test program, I'm using Georgina's method. Put a breakpoint at the end, and check the VE.

They're all good, except for total_cost. It's a tiny bit out.

Is that a problem, Kieran?

Could we round it to two decimal places if we like?

I put this in the console: round(23.13293993, 2) in the console. I got 23.13. That's a round down.

I tried this: round(23.666666, 2) in the console. I got 23.67. That's a round up.

Works!

Just output to go.

We can make a function for that, too. It's gonna have oodles of parameters, though!

I'll give it a try. Might as well use it in the final program.

It all worked, cowboys! Pow pow pow! We rock!