W1_L1.6: Introduction to flowcharts | visualizing algorithms, decisions & loops

Main ideas and concepts

• Why stepwise procedures need formalization

  • After discussing iterations (initialization + repeating steps), the lecture emphasizes that these procedures must be written down in a formal way so they can be communicated to others before programming.

• Flowcharts as a method of formal description

  • Flowcharts are introduced as diagrammatic representations of algorithms (sequences of steps).
  • Only four basic symbols are used for this lecture:
    • Process / Activity (rectangle): write operations that change data (e.g., update variables like count or sum).
    • Arrow: shows the order of execution (control flow from one step to the next).
    • Decision (diamond): represents a condition that determines which path to follow (true/false branches).
    • Terminal (oval): indicates the start or end of the program.

• Using flowcharts to visualize iteration

  • The lecture demonstrates flowcharts using the example of:
    1. Counting cards
    2. Summing math marks
  • Both examples share the same overall iterative structure: initialize → repeatedly process unvisited items → stop when none remain.

---

Methodology / instructions presented (detailed)

A) Flowchart structure for counting cards (counting number of cards)

Goal: compute how many cards exist in a pile by processing each card exactly once.

• Start

  • Use Terminal symbol: Start
  • Move forward via an arrow.

• Initialization

  • In a Process/Activity (rectangle) set:
    • count = 0

• Decision / stopping condition

  • Use a Decision (diamond) to check:
    • “Are there any more cards in pile1?”
  • Two outcomes:
    • False (no more cards):
      • Go to End (Terminal)
      • At this point, count holds the number of cards
    • True (cards remain):
      • Continue into the iterative steps below

• Iterative steps (repeated while cards remain in pile1)

  • Repeat these steps:
    1. Pick a card
       • Choose a card from pile1 (called card x)
    2. Mark it as visited
       • Move card x from pile1 to pile2 (so it won’t be processed again)
    3. Update the accumulator
       • Increment count (since one more card has been seen)

• Return to decision

  • After updating, go back to the same decision check (“more cards in pile1?”).
  • Stop only when the decision becomes false.

---

B) Modifying the counting flowchart to sum math marks (accumulating total marks)

Goal: compute the sum of math marks on all cards.

• Start

  • Terminal symbol: Start

• Initialization (change from count to sum)

  • Replace the variable initialization:
    • sum = 0 (instead of count = 0)

• Decision / stopping condition

  • Keep the same structure:
    • Check whether there are more cards in pile1.
  • Outcomes:
    • False:
      • Go to End
      • At this point, sum holds the total of all math marks
    • True:
      • Continue with the iterative steps below

• Iterative steps (mostly the same as counting, but update differs)

  1. Pick a card
     • Pick card x from pile1
  2. Mark it as visited
     • Move card x from pile1 to pile2
  3. Accumulate the mark
     • Add the math score of card x to sum
     • In activity form: “add card x’s math score to sum”

• Return to decision

  • Loop back to the decision check until pile1 is empty.

---

C) Generic flowchart pattern for any iterator (generalization)

The lecture abstracts both examples into a general iterative flowchart:

• Start iterative process

  • Begin the iteration procedure.

• Initialization

  • Initialize the iteration-related state/status.
  • In the card examples, this is done by:
    • counting: initializing count
    • summing: initializing sum

• Decision: are there unvisited elements left?

  • Repeatedly check whether there exist elements not yet processed.
  • In the examples, this corresponds to:
    • “Are there any cards left in pile1?”

• Iterative body (while unvisited elements exist)

  • If unvisited elements remain:
    1. Pick an unvisited element
       • select one from the collection (e.g., pick from pile1)
    2. Mark it as visited
       • update state to ensure it won’t be re-selected (e.g., move it to pile2)
    3. Update some variables
       • counting: increment count
       • summing: accumulate into sum

• Stop

  • When no unvisited elements remain (decision becomes false), terminate the algorithm.

---

Speakers or sources featured

• No individual speakers named.
• A single unnamed lecturer/instructor (the narrator of the video) explains flowcharts and iterative algorithms.
• Music is present (background “[Music]”), but no named source is given.