Loops – Comprehensive Study Notes

Loop Concept

• A loop is a program construct that repeatedly executes a list of statements (the loop body) while a Boolean expression (the loop condition) is $\text{true}$.

  • When the expression becomes $\text{false}$, control proceeds to the first statement after the loop.

  • Each execution of the body is called an iteration.

• Real-life analogy: Parents driving a baby “around the block” until the baby falls asleep.

  • Decision point: each time the car reaches a landmark (top or bottom of the street) parents check Awake?

  • If baby is awake $\Rightarrow$ drive another loop; if asleep $\Rightarrow$ exit.

• Key vocabulary

  • Loop body – statements inside the loop.

  • Loop condition / expression – Boolean test that controls repetition.

  • Iteration – one pass through the body.

  • Sentinel – special value that signals loop termination when processing lists.

Loop Basics

• Structure (generic):

  initialization
  while (expression) {      // decision statement
      statements            // loop body
      update                // prepares next test
  }
  continuation

• Three canonical components for a counter-controlled (N-times) loop:

  1. Initialization of loop variable (before loop).

  2. Condition using relational operator (top of loop).

  3. Update of loop variable (end of body).

• Once control enters the body, execution continues to the body’s end even if the expression would become false mid-body (one-entry, one-exit discipline).

• Flow-chart example (powers of 2 until user enters 0):

  • Variables: $\text{curPower}=2$, $\text{userNum}=\text{input}$.

  • Condition: $\text{userNum}==1$ $\rightarrow$ print $\text{curPower}$ $\rightarrow$ $\text{curPower}=\text{curPower}\times2$ $\rightarrow$ get next input.

Loop Examples

Summation & Average with Sentinel

• Task: read non-negative integers terminated by $-1$, output average.

  • Initialize: $\text{sum}=0$, $\text{num}=0$, $\text{val}=\text{input}$.

  • Condition: \text{val} > -1.

  • Body:

  • $\text{sum}=\text{sum}+\text{val}$.

  • $\text{num}=\text{num}+1$.

  • $\text{val}=\text{input}$ (get next).

  • After loop: $\text{avg}=\dfrac{\text{sum}}{\text{num}}$.

• Critical points from participation Q&A:

  • First input fetched before loop; if negative, body never runs.

  • $\text{sum}$ initialized to $0$; each iteration adds the current input value.

  • $\text{num}$ counts how many actual values processed (not sentinel).

Counting Negatives

• Goal: count how many negative numbers appear in a list ending with $0$.

  • Condition (A) should be \text{val} < 0.

  • Counting statement (B): $\text{count}=\text{count}+1$ when negative detected.

Finding Maximum in a Positive List (ending with 0)

• Initialize $\text{max}=-1$ so that every positive input is >\text{max} first time.

• Condition: \text{val} > 0 (loop until 0).

• Update rule (B): if \text{val} > \text{max} then $\text{max}=\text{val}$.

• Order of inputs does not affect final max.

Looping Until Done (User-Controlled)

• Pattern: get initial input before loop, repeat body, get new input at end.

• Celsius to Fahrenheit example

  • Menu choice $\text{userChoice}$ controls continuation; loop exits when choice $\neq 1$.

  • Each iteration: output current $\text{celsiusValue}$ and computed $\text{fahrenheitValue}$, then increment Celsius by $5$.

  • Loop iterates at least once because initial value forces true.

Loop Expressions & Relational Operators

• Common relational forms: <, \le, >, \ge, ==, \neq.

• Design rule: expression describes when to iterate, not when to stop.

• Practice prompts:

  1. Iterate while $\text{cVal}==5$ $\Rightarrow$ expression $\text{cVal}==5$.

  2. Iterate while x < 100, $x \ge 0$, $cVal \neq 10$, etc.

• Horizontal bar chart program: subtract $10$ per loop to print one “-”.

Common Loop Errors

• Reversed condition (using $==0$ instead of $\neq0$).

• Forgetting to update loop variable $\Rightarrow$ infinite loop.

• Missing new input in body also causes infinite loop (example with doubling $\text{numKids}$).

• Detecting infinite loops: Coral simulator stalls or floods output; user must Pause/Exit.

Looping $N$ Times

• Typical for counter variable $i$ starting at $0$.

  • Condition for 10 iterations: i<10 (values $0\dots9$).

  • For 99 iterations starting at $1$: init $i=1$; condition i<=99.

• Savings account example

  • For loop executes 10 times, printing balance each year.

  • Each pass: output $\text{currSavings}$, then update $\text{currSavings}=\text{currSavings}\times(1+\text{interestRate})$.

More Complex Examples

Euclid’s GCD (while version)

• If \text{numA}<\text{numB} swap.

• Loop while \text{numA} \bmod \text{numB} > 0:

  • $\text{rem}=\text{numA} \bmod \text{numB}$.

  • $\text{numA}=\text{numB}$; $\text{numB}=\text{rem}$.

• When remainder $=0$, $\text{numB}$ (or $\text{numA}$) is $\text{GCD}$.

Generational Ancestor Counter

• Start $\text{curYear}=2020$, $\text{numAncestors}=2$.

• Loop while $\text{curYear} \ge \text{userYear}$.

  • Output $\text{curYear}: \text{numAncestors}$.

  • $\text{numAncestors}=2\times\text{numAncestors}$ (each ancestor has 2 parents).

  • $\text{curYear}=\text{curYear}-20$ (one generation back).

Temperature Table (-10 to 40 by 5)

• For \text{currC}=-10; \; \text{currC}<=40; \; \text{currC}+!+=5:

  • $\text{F}=\dfrac{9}{5}\times\text{currC}+32$.

  • Print table row.

Nested Loops

• Inner loop executes fully for each outer-loop iteration.

• Bar-chart example: outer while reads value; inner for prints that many asterisks.

• Counting inner executions: $\text{outerIterations}\times\text{innerIterations}$.

Programming Constructs for Loops

while Loop

• Syntax (C-style):

  while (condition) {
      // body
  }

• Use when number of iterations cannot be determined a priori (e.g., sentinel, user quits with 'q').

do-while Loop

• Guarantees at least one execution.

  do {
      // body
  } while (condition);

• Example variable $\text{curCount}$ increments before first test.

for Loop

• Compact counter-controlled form:

  for (i = start; i < end; i = i + step) {
      // body
  }

• Preferred when iterations pre-computable (loop 100 times, loop $\text{numItems}$ times).

• Every for can be rewritten as equivalent while; choose for readability.

• Example transformations shown side-by-side in transcript.

Choosing Loop Type (Guidelines)

• Pre-known count $\Rightarrow$ for.

• Unknown until runtime / sentinel / convergence $\Rightarrow$ while.

• Need at least one run regardless $\Rightarrow$ do-while.

Code Patterns & Conversions

• Converting for $\rightarrow$ while:

  for (i=0; i<N; i++) {...}
  // equivalent
  i = 0;
  while (i < N) {
      ...
      i = i + 1;
  }

• Loop to iterate $\text{userNum}$ times after reading input $\Rightarrow$ use for.

• Loop to keep halving $\text{userNum}$ until result < 10 $\Rightarrow$ use while (condition unknown in advance).

Lab Overviews (Tasks to Practice)

• Convert integer to binary by repeatedly outputting $x \% 2$, updating $x=\lfloor x/2 \rfloor$.

• Read arbitrary non-negative integers, output average (integer division) and max, sentinel <0.

• Output range [first, second] in steps of $10$, with error if second < first.

• Countdown from 20–98 until both digits equal (e.g., $93,92,\dots,88$); validate input range.

Loops Summary (Key Points)

• Loops let programs process data repetitively: averages, counts, maxima.

• Infinite loops arise from incorrect conditions or missing updates.

• Counter-controlled loop requires init, condition, update.

• while, do-while, and for offer specialized syntax but equivalent power.

• Nested loops enable multi-dimensional tasks (tables, charts).

• Choosing the correct loop type improves readability and maintainability.