For Stepwise Refinement’s Sake

Announcements

• Homework
  • Have you swung by my office to visit yet? Many of you have not! Let’s make that happen by the end of the week!
  • Problem Set 1 posted and due on Monday night!
• You are meeting with your small section today or tomorrow!
  • You should have gotten an email with a time and place from me
  • I may be approaching a few of you in the coming days to see if you’d be willing to swap to another to help keep the numbers balanced
• Polling: polling.jedrembold.prof

Inception: Loops in Loops

• Whenever a loop ends, you just return to the same indentation level as when that loop began

• For loops inside other loops then, this means that the “inner-most” loop runs from start to finish for every single step of the outer loop

• What does the below chunk of code accomplish?

  while front_is_clear():
      move()
      while not_facing_north():
          turn_left()
      turn_left()
  put_beeper()

Loopy Example

while left_is_clear():
    while front_is_clear():
        move()
        if no_beepers_present():
            put_beeper()
    turn_left()

Now Your Turn

while no_beepers_present():
    while front_is_clear():
        move()
        if beepers_present():
            turn_left()
        else:
            turn_right()
    turn_left()

Counting Loops

• Sometimes we know the number of times we want to loop

  • It is not dependent on some condition

• In these circumstances, the iterative statement called a for loop is best used

• Syntax looks like:

  for i in range(|||desired count|||):
      |||commands to be repeated desired count times|||

  • |||desired count||| is an integer indicating the number of times you want the loop to repeat
  • The i is a name that we will later make more general, but for now you can always leave it as an i

An Example for you

A Potential Solution

import karel

def main():
    """Draw a 4x4 square in the world."""
    position()
    draw_box()

def position():
    """Move to starting corner of box."""
    move()
    move()
    turn_left()
    move()
    move()
    turn_right()

def turn_right():
    """Turns Karel 90 deg to the right."""
    turn_left()
    turn_left()
    turn_left()

def draw_box():
    """Draws a box with 4 equal sides in a CCW direction."""
    for i in range(4):
        draw_6_line()
        turn_left()

def draw_6_line():
    """Draws a straight line of 6 beepers, if space."""
    for i in range(5):
        if no_beepers_present():
            put_beeper()
        if front_is_clear():
            move()
    if no_beepers_present(): # Last beeper to make 6
        put_beeper()

Summary So Far

Excellent Decomposing

• A good problem decomposition should mean:

  The proposed pieces should be easy to explain

  One indication that you have succeeded is if it is easy to give them simple names

  The steps are as general as possible

  Each piece of code you can reuse is one less piece of code you need to write! If your steps solve general tasks, they are much easier to reuse.

  The steps should make logical sense for the problem you are solving

  If you have a function that will work to solve a step but was designed (and named) with something else entirely in mind, adopt it for the currently needed situation

Enter the Winter

• Suppose we want Karel to usher in the Fall/Winter by removing the “leaves” from the tops of all the trees

Understanding the Problem

• What are we guaranteed by the problem?
• How will we know when we are done?

Top-Level Decomposition

• We could break this problem into two main subproblems:
  1. Find the next tree
  2. Strip the leaves off that tree

Top-Level Decomposition

• We could break this problem into two main subproblems:
  1. Find the next tree
  2. Strip the leaves off that tree

Top-Level Decomposition

• We could break this problem into two main subproblems:
  1. Find the next tree
  2. Strip the leaves off that tree

Top-Level Decomposition

• We could break this problem into two main subproblems:
  1. Find the next tree
  2. Strip the leaves off that tree

Top-Level Decomposition

• We could break this problem into two main subproblems:
  1. Find the next tree
  2. Strip the leaves off that tree

Top-Level Decomposition

• We could break this problem into two main subproblems:
  1. Find the next tree
  2. Strip the leaves off that tree

Top-Level Decomposition

• We could break this problem into two main subproblems:
  1. Find the next tree
  2. Strip the leaves off that tree

Top-Level Decomposition

• We could break this problem into two main subproblems:
  1. Find the next tree
  2. Strip the leaves off that tree

Top-Level Decomposition

• We could break this problem into two main subproblems:
  1. Find the next tree
  2. Strip the leaves off that tree

Algorithms

• The process of designing a solution strategy to a problem is called algorithmic design
• An algorithm is just an approach or recipe for a method to solve a particular problem
  • Frequently language agnostic
• Algorithms are not a new concept
  • Euclid’s algorithm to find the greatest common factor between two numbers, for instance
• A large part of computer science is focused on the study or analysis of algorithms

Algorithm ⮕ Code

• You need to have an algorithm in place before you can write the code to tell the computer what you want to do
  • Imagine an alien asking me how to bake a cake. I need to understand the steps to baking the cake before I can even worry about the translation or communication
• Programming tools like conditional statements and loops will frequently play a role in your algorithm, but as general concepts
  • I can easily describe a loop to you without needing the exact syntax of Python
• The implementation of the algorithm is the act of translating it into Python (or whatever language you are using)

An Amazing Algorithm