Chapter 10 — Nested for loops

Definition and structure
A nested for loop is a for loop placed inside another for loop. The outer loop starts and, for each value it takes, the inner loop executes fully from its start to its end. After the inner loop completes, control returns to the outer loop which moves to its next value. This step-by-step execution order is the central idea: the inner loop runs multiple times for every single iteration of the outer loop.

Visualising flow
Think of the outer loop as rows and the inner loop as columns of a grid. For each row the program prints or computes the full set of columns. A simple example is printing a block of stars: outer loop repeats for each row, and the inner loop prints all stars in that row.

Choosing indices
Always use separate variable names like i for outer and j for inner. This prevents overwriting. Decide whether your language uses 0-based or 1-based ranges and set loop limits accordingly so that you generate the exact count you want. For example, to produce R rows and C columns, run outer loop R times and inner loop C times.

Common uses
Nested loops are used for structured output (patterns and tables), processing two-dimensional arrays or matrices, and generating pairs or combinations. Many pattern problems taught in school are simple nested-loop tasks and build the habit of clear loop control.

Readability and indentation
Indent the inner loop inside the outer loop and write short comments. Well-indented code is easier to trace and debug. When nested loops become complex, consider writing a small helper function for the inner task to keep the outer loop clear.

Small design checklist
Decide how many times each loop should run; pick distinct variable names; determine what must be done inside inner loop and what must be done after it (for example printing a newline). Trace the code for small values to confirm expected behaviour.

Counting exact iterations
For fixed-range nested for loops, you can count exactly how many times the inner body runs. If outer loop repeats m times and inner loop repeats n times each time, total body executions = m × n. This calculation helps predict how long a program will run for small inputs used in class exercises.

Variable inner bounds
Not all nested loops have constant inner limits. If the inner loop limit depends on the outer index, compute a sum. Example: outer i from 1..n and inner j from 1..i gives total iterations = 1 + 2 + ... + n = n(n+1)/2. This triangular count is smaller than n², and understanding it helps choose appropriate designs.

Multiple nested levels
With more levels, multiply the sizes of each loop when bounds are independent. For three nested loops with ranges a, b and c the total is a×b×c. This shows why deeper nesting quickly increases the number of operations and can become slow for larger sizes.

Practical examples
If you print a 100×100 grid, inner body runs 10,000 times. For many classroom programs this is acceptable; but as numbers grow (e.g., 1000×1000 = 1,000,000) the program may slow or exceed time limits. Estimating counts avoids surprises and teaches students about scalability.

Counting with conditional breaks
If the inner loop may break early (for example when an item is found), the total depends on data and the position of the found item. To reason about such cases describe best case (found immediately), worst case (not found), and average case if possible. For exams, practice computing exact counts when loops have clear bounds, and reason qualitatively when loops depend on data.

Care with inclusive/exclusive bounds
Decide whether loops are inclusive or exclusive at endpoints (i.e., 0..n-1 vs 1..n) and adjust counting accordingly. Small off-by-one mistakes change final counts and can cause wrong answers in trace questions.

Rectangle basics
Printing a rectangle uses two loops: outer for rows and inner for columns. If you must print R rows and C columns of a character (e.g., '*'), set the outer loop to run R times and the inner loop to run C times. Within the inner loop print the character without printing a newline; after the inner loop print a newline to move to the next row.

Hollow rectangles
To print a hollow rectangle print characters only on the border. Inside the inner loop, check if you are on the first row, last row, first column or last column and print the character only then; otherwise print a space. This uses a conditional expression combining checks with OR (||) or AND notation depending on language.

Character choice and spacing
You can print stars, hashes, numbers or other characters. For neat appearance, be careful about extra spaces and the default print behaviour of your language. If printing multi-character strings, adjust spacing so columns align. Many languages provide a print function that avoids newline; use it for inner loop printing.

Counting and loop variables
Always pick distinct loop variables like i for rows and j for columns. Decide index range carefully: if using 1-based i from 1..R and j from 1..C is clear. For 0-based ranges choose 0..R-1 and 0..C-1 so you still get R and C iterations respectively.

Examples and variations
Variations include printing numbers instead of characters, adding row or column labels, and mirroring rectangles. For a hollow rectangle with R=4 and C=6 your code should print stars on rows 1 and 4 entirely, and in rows 2 and 3 only at columns 1 and 6.

Debugging tips
If output has incorrect number of columns or rows, recheck inner and outer loop bounds. If spacing is off, examine whether you printed extra spaces inside inner loop or printed newline at wrong place. Test with small R and C to verify shape before generalising.

Left-aligned triangle and its logic
A left-aligned right-angled triangle prints row i containing i symbols for i from 1 to n. Use outer loop for rows and inner loop whose bound depends on the outer index. The inner loop prints the symbol repeatedly and then a newline after the inner loop ends. This simple dependency of inner bound on outer index is an important pattern: inner loop grows as outer loop advances.

Reverse triangle and decreasing inner bounds
To produce a reversed triangle that starts with n symbols and decreases, set the outer loop to run i from n down to 1 and set inner loop from 1 to i. The visual effect is the mirror of the left-aligned triangle but the control structure is the same; only the range direction changes.

Right-aligned triangle using spaces
Right alignment introduces an extra nested action: before printing the symbols you must print leading spaces. For each row i print (n - i) spaces, then print i symbols. Practically this is implemented with two inner loops: the first prints spaces from 1 to n-i, the second prints the symbols from 1 to i. This shows nested logic can include more than one inner loop executed sequentially for each outer iteration.

Hollow triangles and condition-based printing
Hollow triangles require printing symbols only on edges and base. Within the inner symbol loop include a condition: print symbol if column index is 1 or equals row length or if it is the final row; otherwise print a space. This demonstrates combining nested loops with conditional checks to produce more complex visual shapes.

Variations: numbers and patterns
Triangles need not use stars. You can print row numbers, increasing sequences, or repeated digits. For example, print i repeated i times or print 1..i on each row. Floyd-style numbering requires a counter that persists across rows instead of resetting at each row.

Testing and common errors
Test with small n (n=1,2,3) to ensure spacing and edge cases are correct. Common mistakes include wrong loop bounds (off-by-one), forgetting newline at the right place, and reusing variable names for both loops. Dry-run by listing i and j pairs and expected output for each to find mistakes quickly.

Centered pyramid structure
A centered pyramid of height n displays rows where the i-th row has 2i-1 symbols centred with leading spaces. Implement with an outer loop i=1..n, then an inner loop to print (n-i) spaces, another inner loop to print (2i-1) symbols, then a newline. This produces symmetric pyramids where each row grows by two symbols.

Adjusting for width and characters
If symbols are multi-character (e.g., numbers with width >1) you may need to adjust spacing so columns remain visually centred. Many classroom tasks use single-character symbols which simplify alignment. For non-square fonts, counting spaces approximates centre but may not be perfect in all editors.

Hollow centered pyramids
To make a hollow pyramid, print symbols only at the positions corresponding to left and right edges of the pyramid and print spaces elsewhere. For row i the left edge is at centre - (i-1) and right edge at centre + (i-1). On the final row print the full row of symbols. This requires a conditional check inside the stars loop to decide whether to print symbol or space.

Diamond patterns
A diamond is made by printing an increasing pyramid of height n and then a decreasing pyramid of height n-1. Combine loops carefully to avoid duplicating the middle row. For symmetry ensure space and symbol counts mirror across the centre line.

Programming details and pitfalls
Be careful with loops for spaces and symbols so that lines align perfectly. Off-by-one errors in space counts change centering. When computing 2i-1 ensure integer arithmetic is used. If using 0-based indexing convert formulas accordingly.

Educational value
Centered patterns teach students how to combine arithmetic with loop bounds and how to use multiple inner loops and conditional logic to achieve precise visual layouts. They also illustrate how small changes in bounds produce visibly different shapes, reinforcing attention to detail.

Number grids and basic rules
Instead of characters, nested loops can output numbers. A number grid with R rows and C columns uses outer loop for rows and inner loop for columns; inner loop can print the column index j, or some function of i and j, depending on the required pattern. Number outputs emphasise formatting as multi-digit values change column widths.

Floyd's triangle explained
Floyd's triangle produces consecutive integers across rows. Start with a counter set to 1 before the outer loop. For each row i from 1 to n run the inner loop j from 1 to i, print the current counter, then increment it. Because the counter is declared outside both loops it continues across rows, giving the consecutive numbering. This pattern shows the importance of variable placement and scope.

Variations and controls
Other numeric triangles include rows where each row prints the row number repeated i times, or where each row prints 1..i. You can also produce triangles where the number printed is a formula like i+j or i*j. Each variation is a small change in the inner loop expression or in where you initialise counters or accumulators.

Formatting and alignment
When numbers become multi-digit, columns can misalign. Use padding or fixed-width formatting if available in your language. For hand-written or console output exercises, keep spacing consistent by printing an extra space before single-digit numbers so that columns remain visually aligned for small n used in class.

Counter management and scope
Patterns like Floyd's triangle require a persistent counter that survives across iterations of the outer loop. If you initialise the counter inside the outer loop it will reset each row and produce different results. This teaches correct placement of initialisation lines and the concept of variable lifetime in simple programs.

Practice suggestions
Start with small n and write expected output by hand, then code it. Change the inner expression to experiment with different numeric patterns. Tracing by hand helps understand how numbers progress across rows and where counters must be placed for intended results.

Matrix representation and indexing
A matrix is a rectangular arrangement of elements in R rows and C columns. Nested loops correspond directly: outer loop over rows (i) and inner loop over columns (j) allow you to visit each element a[i][j]. Understanding this mapping is essential for input, output and processing of matrix data in programs.

Reading and displaying matrices
To read a matrix, prompt for R and C, then nest loops: for i from 1..R, for j from 1..C read element into matrix[i][j]. To print matrix, traverse with same nested loops and print each element with spacing between columns and a newline after each row.

Common matrix tasks
Summing all elements uses an accumulator initialised before loops and increased inside the inner loop. Row sums need resetting at start of each outer iteration; column sums can be accumulated into an array of length C during traversal. Transpose uses nested loops assigning transpose[j][i] = matrix[i][j]. Finding maximum requires comparing each element during the nested traversal and updating the max and its indices.

Boundary checks and memory
Always ensure indices i and j remain within declared sizes. When sizes are input at runtime, allocate storage accordingly. For class exercises matrices remain small but practising safe indexing prevents runtime errors in larger problems.

Applications and extensions
Matrix operations introduce ideas used in graphics, spreadsheets and scientific computing. Exercises like matrix addition, multiplication and transpose strengthen nested-loop logic. Matrix multiplication requires three nested loops: outer and middle for result positions and inner to compute dot product, demonstrating growth of operations with nesting depth.

Practical tips
Test matrix code on small examples and compare manual calculations. Label rows and columns in sample output to check orientation. When debugging, print indices along with values to trace mistakes in index order or assignment direction.

Searching for an element
To search an R×C grid for a value, nest loops over rows and columns and compare each element with the search key. If found, store its position and, if desired, break out of loops to avoid extra work. Many languages only break one loop at a time; use a flag variable to indicate found status and break the outer loop based on the flag.

Counting occurrences
Counting requires examining every position unless you can stop early. Initialise count = 0 before loops and increment it whenever matrix[i][j] equals the target value. After traversal the count holds total occurrences. This pattern is common for frequency analysis in grids of numbers or characters.

Finding extremes and positions
To find maximum or minimum, initialise the extreme to the first element and update when a larger/smaller element is found. Keep variables for position if you need to report where the extreme occurs. Update positions inside the inner loop when you update the extreme.

Pattern search inside grids
Looking for a small pattern (like a 2×2 subgrid) inside a larger matrix uses nested loops in two levels: outer loops for each potential starting position and inner loops to check the sub-pattern. Carefully handle boundaries so you do not check starting positions that would overflow the grid.

Performance and early exit
If you only need to know whether a value exists, break early when found to save work. For counting you must check all cells. Using flags and carefully placed breaks improves efficiency and clarity of code. Always handle the case when value is not found and report appropriate message.

Testing tips
Test with grids containing multiple occurrences, none, and at boundary positions to ensure your loops and checks handle all cases. Printing indices during debugging helps locate logic errors quickly.

Ordered pairs and Cartesian product
To generate all ordered pairs from two sets use nested loops: outer over first set and inner over second set. If first set has m items and second has n items, you produce m×n ordered pairs. This appears when combining options, making schedules, or forming coordinate pairs.

Unordered pairs without repetition
If you want unordered pairs from one set without duplicates or self-pairs, structure loops so inner starts from outer+1. For i from 1..n and j from i+1..n you generate each unique pair once. This produces n(n-1)/2 pairs. This trick prevents generating both (a,b) and (b,a) and avoids pairs like (a,a).

Including or excluding self-pairs
If rules allow pairing an item with itself include j starting from i; if not, start j from i+1. This choice changes counts: allowing self-pairs gives n(n+1)/2 unordered pairs if order does not matter and self-pairing is allowed, while excluding them gives n(n-1)/2.

Applications in simple problems
Pair and combination generation is used to check every pair for a property, to list all possible matches, and to compute pairwise statistics. For example, comparing students in a class for similar scores or computing pairwise distances between points uses nested loops with appropriate start and end indices to avoid duplicates.

Counting formulas and reasoning
Ordered pairs count = m×n. For unordered distinct pairs use n(n-1)/2. When writing these in code, the loop ranges convert these mathematical formulas into program loops. Verifying counts by listing pairs for small n helps confirm your loop ranges are correct.

Edge cases and testing
Test with very small sets (n=1,2,3) to ensure your loops produce the expected sets. If duplicates appear, inspect inner loop start. If missing pairs appear, check whether loops cover entire set. Clear variable names and comments help prevent mistakes when converting mathematical formulas into nested loops.

Why conditions appear inside loops
Most pattern and matrix problems require decisions at each cell. Inside the inner loop use conditionals to decide whether to print a symbol, update an accumulator, or skip processing. Conditional checks let you vary behaviour per (i,j) without changing loop ranges, which keeps loops simple while enabling complex output.

Common condition types
Conditions often test loop indices (for example i==1 or j==C), arithmetic relations (i+j even or i==j for diagonal), or values stored in arrays (matrix[i][j] > threshold). Combining checks with AND and OR yields precise selection rules, for example printing borders when (i==1 OR i==R OR j==1 OR j==C).

Using flags with conditions
When a condition met inside the inner loop should stop outer processing, set a boolean flag and break the inner loop. After the inner loop check the flag and break the outer loop if needed. This pattern emulates multi-level break in languages that only break one loop at a time and is useful when searching for the first match in a grid.

Minimising repeated work
If a condition requires expensive computation, compute it once outside the inner loop when possible. For example, if you need a value that depends only on i, compute it before the inner loop starts. This reduces repeated calculation and keeps the inner loop light and faster for larger sizes.

Conditional patterns and careful testing
Hollow shapes use conditions to print spaces vs characters; diagonals use equality checks of indices. Write down expected true/false results for small i and j pairs and compare with program output. Many exam questions give code with conditions and ask for output; practice tracing such examples regularly.

Readable conditions
Use parentheses to group logical terms and choose descriptive variable names where possible. Clear conditions make it easier to debug and to reason about which cells will be affected by the test.

Multiplication tables and layout
To print a multiplication table up to n use nested loops: outer i=1..n and inner j=1..n printing i×j. For neat display add spacing or tabs so columns align. Teachers often expect multiplication tables in row-major form where row i contains products i×1, i×2, ..., i×n. This exercise combines arithmetic calculation with nested traversal and output formatting.

Row and column sums in matrices
Row sums require a row accumulator initialised at the start of each outer loop and increased inside the inner loop. After finishing inner loop for a row, print or store the row sum. For column sums you may either loop columns as the outer loop and rows as inner, or use an array of column sums initialised before the nested traversal and updated inside the inner loop. Proper placement of initialisation is crucial.

Filtering pairs by arithmetic property
Use nested loops to list pairs (i,j) that satisfy conditions like i+j = k or i*j is even. The inner loop checks the arithmetic condition and prints matching pairs. This approach is a simple brute-force method but works well for small ranges taught in class.

Accumulation and scope
Accumulators must be placed correctly: cumulative totals that span the whole nested traversal must be initialised before the outer loop; totals that reset per row must be initialised inside the outer loop but before the inner loop. Misplacing these initialisations is a common source of incorrect results.

Formatting wide numbers
When numbers in a table grow into multiple digits, fixed-width formatting or padding keeps the table readable. For hand-coded console output use consistent spacing to separate columns. For exam answers, showing neatly aligned examples demonstrates understanding of correct algorithm and presentation.

Practice problems
Common tasks: print n×n multiplication table, compute row and column sums for a matrix, find pairs summing to target k. These exercises connect nested loops with arithmetic operations and teach precise placement of computations inside loop bodies.

Variable reuse and overwriting
Using the same variable name for outer and inner loops (for example using i for both) leads to unpredictable behaviour because the inner loop overwrites the outer index. Always pick distinct names like i, j, k for readability and correctness. This prevents accidental dependency between loops and makes tracing easier.

Off-by-one mistakes
Off-by-one errors are extremely common. Decide whether loop ranges are inclusive or exclusive and be consistent. For example for(i=0;i

Wrong initialisation and reset points
Placing an accumulator or counter inside the wrong loop resets it at incorrect times. For row sums initialisation must be inside the outer loop before the inner loop; for a global total it must be before the outer loop. Check variable placement carefully when results are wrong.

Index out-of-range errors
When accessing arrays like a[i][j], be sure indices match declared sizes. When checking sub-patterns ensure starting indices do not allow inner checks to access cells outside the matrix. Validate user-given sizes and avoid assumptions about maximum values when implementing loops that index arrays.

Infinite loops and incorrect increments
While nested for loops rarely loop forever, mixing for and while incorrectly or having wrong increment/decrement steps can lead to infinite loops. Ensure each loop variable changes in a way that will eventually break its loop condition.

Readability aids debugging
Clear indentation, descriptive variable names, and brief comments reduce mistakes. During debugging temporarily print loop indices and key variables to see how they change. Fix one issue at a time and re-test with small examples to confirm corrections.

Handling dynamic sizes
Many problems ask the user for sizes such as number of rows R, number of columns C, or triangle height n. Use input values to set loop bounds so your program can handle different cases without changing code. For example outer loop from 1..R and inner loop from 1..C prints an R×C grid of any size given by the user.

Validation and guard conditions
Validate user inputs to ensure they are positive integers and within acceptable limits. If R or C is zero or negative decide whether to print a message or handle it gracefully. Simple checks like if R<=0 then print "Invalid input" prevent runtime errors and make your program robust for classroom testing.

Memory allocation and dynamic structures
When reading matrices of runtime size, allocate arrays or lists according to the given dimensions. For languages requiring fixed sizes, choose sufficient limits or use dynamic structures. Avoid assumptions about maximum size; instead, check constraints and handle large inputs conservatively to avoid memory issues.

Formatting outputs for varying sizes
When shapes depend on n, ensure spacing and alignment scale correctly. For pyramids, leading spaces depend on n and row index i. Test small and larger values to verify that centering and spacing remain consistent. For numbers with many digits adjust padding to keep columns aligned.

Edge case testing
Always test programs with edge cases like n=1 and small matrices. Check behaviour for maximum expected inputs. When shapes should print nothing for zero input, ensure code path handles it without errors. Include user-friendly prompts and error messages for clarity during testing.

Separation of concerns
Keep input reading, validation, and nested-loop operations in separate code blocks or clear pseudocode steps. This separation simplifies debugging and allows reuse of the nested-loop logic with different input sources such as files or automated test data.

Why three levels appear
Three nested loops are required when data or tasks have three dimensions or when checking triplets among elements. Examples include 3D matrices, iterating through layers of a structure, or checking combinations of three items. Each additional loop level multiplies the total iterations and increases complexity, so keep ranges small for classroom examples.

Triplet generation and combinatorics
To generate unordered triplets without repetition use loops: for i=1..n-2, j=i+1..n-1, k=j+1..n. This ensures i

3D arrays and coordinate traversal
For a 3D array with dimensions a×b×c use loops i=1..a, j=1..b, k=1..c. Access elements as arr[i][j][k]. Common tasks: summing over all elements, finding the maximum, or printing coordinates. Visualising small cubes and labelling coordinates helps students understand the traversal order.

Performance considerations
Three-level nesting grows quickly: for ranges 100×100×100 you would have one million iterations, which may be slow or impractical. For class problems use small sizes and learn to reason about when a nested approach is acceptable versus when an alternative algorithm is required.

Clarity and naming
Name variables clearly (i, j, k or descriptive names) and add comments to describe what each loop controls. Consider breaking inner work into functions so the outer loops read more clearly. Testing with the smallest non-trivial sizes helps verify correctness before scaling up.

Counting formula
When loop bounds are independent, multiply them to get total iterations; when dependent, compute nested sums. For triplets with i

Dry-run as first step
Manual tracing or dry-running is the simplest and most reliable way to understand nested loops. Write a table with columns for each loop variable and for any accumulators or outputs. For each step fill in current values and the output produced. This works well for small values and reveals off-by-one errors, incorrect initialisations, and misplaced newlines.

Choose small examples
Always start tracing with very small sizes like n=2 or n=3. For patterns, draw the expected shape on paper and then map each printed character to a pair of indices (i,j). For matrices, compute sums or transpose by hand for a 2×3 example and compare with program output to detect indexing mistakes quickly.

Use debug prints sparingly
When running code insert temporary debug prints that show i and j and critical variables for the first few iterations. For example print "i=1 j=2 val=...". This pinpoints where values diverge from expectations. Remove or comment debug prints when the code works to keep output clean.

Flags and controlled exits
To exit nested loops when a condition is met set a flag inside the inner loop and break it; check the flag in the outer loop and break again if set. This method simulates multi-level break where the language does not offer it natively. It also keeps code explicit and easy to follow.

Systematic checklist
When debugging follow a checklist: verify distinct loop variables, confirm loop bounds and inclusive/exclusive endpoints, check where accumulators are initialised or reset, and ensure newline placement is correct for output. Re-test after each change with small inputs.

Practice to build skill
Teachers often give short code snippets and ask for output; practice tracing these frequently. Also practise fixing intentionally buggy pattern programs. Over time you will recognise common mistakes quickly and write correct nested-loop logic with fewer trial runs.