# Discussion 2: Control, Environment Diagrams

If your group has fewer than 3 people, feel free to merge with another group in the room.

Now switch to Pensieve, a shared editing app that has this same worksheet in a format that makes it easy to collaborate with your group and ask questions of an AI tutor.

**Everyone**: Go to pensieve.co, log in with your @berkeley.edu email, and**enter your group number**as the room number (which was in the email that assigned you to this lab).

Once you're on Pensieve, you don't need to return to this page; Pensieve has all the same content (but more features). If for some reason Penseive doesn't work, return to this page and continue with the discussion.

# Ice Breaker

Say your name and a city (or place) that you like, which is not Berkeley and is not where you have lived. Feel free to share why you like it.

# While and If

Learning to use `if`

and `while`

is an essential skill. During this discussion,
focus on what we've studied in the first three lectures: `if`

, `while`

,
assignment (`=`

), comparison (`<`

, `>`

, `==`

, ...), and arithmetic. Please don't
use features of Python that we haven't discussed in class yet, such as `for`

,
`range`

, and lists. We'll have plenty of time for those later in the course, but
now is the time to practice the use of `if`

(textbook section
1.5.4)
and `while`

(textbook section
1.5.5).

### Q1: Fizzbuzz

Implement the classic *Fizz Buzz*
sequence. The `fizzbuzz`

function
takes a positive integer `n`

and prints out a *single line* for each integer
from 1 to `n`

. For each `i`

:

- If
`i`

is divisible by both 3 and 5, print`fizzbuzz`

. - If
`i`

is divisible by 3 (but not 5), print`fizz`

. - If
`i`

is divisible by 5 (but not 3), print`buzz`

. - Otherwise, print the number
`i`

.

Try to make your implementation of `fizzbuzz`

concise.

`if`

and `elif`

clauses: try first checking if the current number is divisible by both 3 and 5, then check for just divisibility by 3 and just divisibility by 5.
# Problem Solving

A useful approach to implementing a function is to:

- Pick an example input and corresponding output.
- Describe a process (in English) that computes the output from the input using simple steps.
- Figure out what additional names you'll need to carry out this process.
- Implement the process in code using those additional names.
- Determine whether the implementation really works on your original example.
- Determine whether the implementation really works on other examples. (If not, you might need to revise step 2.)

Importantly, this approach doesn't go straight from reading a question to writing code.

For example, in the `is_prime`

problem below, you could:

- Pick
`n`

is 9 as the input and`False`

as the output. - Here's a process: Check that
`9`

(`n`

) is not a multiple of any integers between 1 and`9`

(`n`

). - Introduce
`i`

to represent each number between 1 and 9 (`n`

). - Implement
`is_prime`

(you get to do this part with your group). - Check that
`is_prime(9)`

will return`False`

by thinking through the execution of the code. - Check that
`is_prime(3)`

will return`True`

and`is_prime(1)`

will return`False`

.

Try this approach together on the next two problems.

**Important:** It's highly recommended that you **don't** check your work using
a computer right away. Instead, talk to your group and think to try to figure
out if an answer is correct. On exams, you won't be able to guess and check
because you won't have a Python interpreter. Now is a great time to practice
checking your work by thinking through examples. You could even draw an
environment diagram!

If you're not sure about how something works or get stuck, ask for help from the course staff.

### Q2: Is Prime?

Write a function that returns `True`

if a positive integer `n`

is a prime
number and `False`

otherwise.

A prime number n is a number that is not divisible by any numbers other than 1 and n itself. For example, 13 is prime, since it is only divisible by 1 and 13, but 14 is not, since it is divisible by 1, 2, 7, and 14.

Use the `%`

operator: `x % y`

returns the remainder of `x`

when divided by `y`

.

`while`

statement that goes through all numbers above 1 and below `n`

:
```
i = 2
while i < n:
...
i = i + 1
```

You can use `n % i == 0`

to check whether `i`

is a factor of `n`

. If it is, `return False`

.

### Q3: Unique Digits

Write a function that returns the number of unique digits in a positive integer.

Run in 61A Code

Hints:You can use`//`

and`%`

to separate a positive integer into its one's digit and the rest of its digits.You may find it helpful to first define a function

`has_digit(n, k)`

, which determines whether a number`n`

has digit`k`

.

`n`

has the digit. Count up the ones it has.
# Document the occasion

Please all fill out the attendance form (one submission per person per week).