Shape Rule
Jump sequence
Row 1 prints 1, row 2 prints 2 6, row 3 prints 3 7 10, and so on with shrinking jumps.
Increasing Jump Number Triangle in C
Overview
What You’ll Learn
The increasing jump number triangle starts each row at i and jumps forward with a decreasing step m — a natural step after the continuous counter in Program 20. This tutorial covers the shape rule, step logic, a live preview, algorithm steps, worked C examples, edge cases, and complexity.
Outer Loop
1..rows
for (i = 1; i <= rows; i++) makes row i print exactly i numbers.
Step Variable m
m-- each jump
Set m = rows - 1 and k = i + m; after each print do m-- then k = k + m.
printf vs newline
Same line / next line
Print i first, then k values in the inner loop; end each row with printf("\n").
Live Preview
1–15 rows
Pick a row count and draw the jump number triangle instantly in the browser.
O(n²)
Complexity
Total prints = rows(rows+1)/2; extra memory stays O(1).
Introduction
An increasing jump number triangle prints each row starting at the row index, then jumps forward using a step that shrinks after every print. With rows = 5, the output is 1, 2 6, 3 7 10, 4 8 11 13, 5 9 12 14 15.
In C you print i first, set m = rows - 1 and k = i + m, then in the inner loop print k, do m--, and update k = k + m before the next value.
Why it matters?
It combines nested loops with a changing step variable — a step up from Program 20’s simple counter.
Key Highlights
Row start i
Print i before the inner loop on every row.
Step m
Start at rows - 1 and decrease after each jump.
Update k
k = i + m first, then m-- and k = k + m in the loop.
Series Foundation
Follow Program 20; continue to Program 22 (odd-length rows) next.
In short: for each row i, print i, then use a decreasing step m to compute and print the remaining i - 1 values.
Foundation
📝 Problem & Approach
Given a positive integer rows, print an increasing jump number triangle: row i starts with i, then prints i - 1 more values computed by adding a decreasing step m.
c
// rows = 5 (conceptual shape)
// 1
// 2 6
// 3 7 10
// 4 8 11 13
// 5 9 12 14 15Inputs & Outputs
| Item | Type | Description |
|---|---|---|
rows | int | Number of triangle lines to print (typically ≥ 1). |
m | int | Step size — starts at rows - 1, decreases after each jump. |
k | int | Next value to print — set to i + m before the inner loop. |
| Printed output | text | Row i has i spaced numbers with shrinking jumps. |
Minimal workflow
Pseudocode
for i from 1 to rows:
print i
m = rows - 1
k = i + m
for j from 1 to i - 1:
print k
m = m - 1
k = k + m
print newlineApproach comparison
| Approach | Idea | Best for |
|---|---|---|
| Decreasing step m | 1, 2 6, 3 7 10, … | Learning and interviews |
| User-input rows | scanf("%d", &rows); | Flexible console programs |
| Custom initial step | m = 3 instead of rows - 1 | Tighter or wider jumps |
Cheat Sheet
⚡ Quick Reference
| Goal | Pattern |
|---|---|
| Walk each row | for (i = 1; i <= rows; i++) |
| Print row start | printf("%d ", i); |
| Init step | int m = rows - 1; |
| First jump value | int k = i + m; |
| Inner loop | for (j = 1; j < i; j++) |
| Update step | m--; k = k + m; after each print |
| User input | scanf("%d", &rows); |
Compare
📋 Fixed Rows vs User Input vs Custom Step
Same jump triangle — different ways to control rows and step size.
Row start
print iEvery row begins with the row index
Step m
m = rows-1Initial jump size — reset each row
Custom step
m = 3Override step in Example 3
Learning tip
m--Decrease m after each k print — jumps shrink
Context
When This Pattern Shows Up
Reach for this pattern when teaching variable step sizes and computed sequences inside nested loops.
Post-continuous exercise
Natural follow-up after Program 20 — introduces a decreasing step variable.
Nested-loop warm-up
Outer/inner bound practice with an immediate visual check.
Console I/O practice
Combine loops with
scanffor a flexible row count.Gateway to variants
Compare Program 20 (continuous counter) and Program 22 (odd-length rows) next.
Not a UI layout tool
This is a console teaching pattern — not how you build modern app screens.
Key benefit: one small program that locks in nested loops, output sequencing, and O(n²) thinking.
Interactive
🔮 Live Preview
Choose a row count between 1 and 15 and draw the jump number triangle in the browser.
Hands-On
Examples Gallery
Three complete C programs — fixed row count, user input, and custom initial step for m. Click View Output to reveal sample console results.
📚 Getting Started
Print five rows of the jump number triangle with a decreasing step.
Example 1 — Fixed rows = 5
Hard-coded height — ideal for first demos and screenshots.
c
#include <stdio.h>
int main() {
int i, j, k, m;
for (i = 1; i <= 5; ++i) {
printf("%d ", i);
m = 4;
k = i + m;
for (j = 1; j < i; ++j) {
printf("%d ", k);
m--;
k = k + m;
}
printf("\n");
}
return 0;
}How It Works
When i = 2, print 2, then m = 4 and k = 6 — the inner loop prints 6 once. When i = 3, print 3, then k = 7, m-- to 3, k = 10 — output 3 7 10. printf("\n") after the inner loop starts the next row.
📈 User Input
Read the row count with scanf instead of hard-coding 5.
Example 2 — User Input
Read rows with scanf("%d", &rows); set m = rows - 1 each row.
c
#include <stdio.h>
int main() {
int rows;
int i, j, k, m;
printf("Enter the number of rows: ");
scanf("%d", &rows);
for (i = 1; i <= rows; ++i) {
printf("%d ", i);
m = rows - 1;
k = i + m;
for (j = 1; j < i; ++j) {
printf("%d ", k);
m--;
k = k + m;
}
printf("\n");
}
return 0;
}How It Works
Same nested-loop core as Example 1; only the source of rows changes. m = rows - 1 scales the initial jump with triangle height. Non-numeric input leaves rows unset if you ignore scanf’s return value — always check it in safer labs.
⚡ Custom Step
Use a fixed initial step instead of rows - 1.
Example 3 — Custom Initial Step m = 3
Keep rows = 4 but start each row with m = 3 for tighter jumps.
c
#include <stdio.h>
int main() {
int rows = 4;
int i, j, k, m;
for (i = 1; i <= rows; ++i) {
printf("%d ", i);
m = 3;
k = i + m;
for (j = 1; j < i; ++j) {
printf("%d ", k);
m--;
k = k + m;
}
printf("\n");
}
return 0;
}How It Works
Change only the initial value of m — the inner loop and k = k + m logic stay the same. Smaller starting steps produce tighter jumps within each row.
🧠 How the Algorithm Prints Rows
1
Set up
#include <stdio.h> brings in printf / scanf. Set rows and loop variables i, j, k, m.
Setup
2
Outer loop + row start
for (i = 1; i <= rows; i++) then printf("%d ", i) — row i prints i numbers.
Row
3
Init step and jump
m = rows - 1 and k = i + m set up the first jump in that row.
Setup
4
Inner loop + m--
Print k, then m-- and k = k + m to compute the next jump.
Sequence
5
New line
printf("\n") ends the row so the next outer iteration starts fresh.
Break
=
Jump triangle complete
Total prints: rows(rows+1)/2 — O(n²) time, O(1) extra memory.
Trace
🔎 Worked Walkthrough — rows = 5
Trace each outer-loop value of i, the initial m, and the numbers printed on each row.
i | Init m | Jump sequence | Row output |
|---|---|---|---|
1 | 4 | 1 (no inner loop) | 1 |
2 | 4 → k=6 | 2, 6 | 2 6 |
3 | 4 → k=7, m=3 → k=10 | 3, 7, 10 | 3 7 10 |
4 | 4 → 8, 11, 13 | 4, 8, 11, 13 | 4 8 11 13 |
5 | 4 → 9, 12, 14, 15 | 5, 9, 12, 14, 15 | 5 9 12 14 15 |
Total number prints: 1 + 2 + 3 + 4 + 5 = 15 = 5×6/2.
Use Cases
Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.
1. Teaching Nested Loops
Clearest visual proof that outer and inner bounds interact.
Example: change j <= i and watch the shape change.
2. Pattern Series Base
Foundation for inverted, pyramid, diamond, and hollow variants.
Example: use (i + j) % 2 for row+column parity grids.
3. Console Formatting Drills
Practice printf vs row newline without complex math.
Example: put printf("\n") inside the inner loop by mistake.
4. Character Substitution
Swap digits for letters, stars, or spaced output once the loop works.
Example: print j + " " for spaced digits on each row.
5. Complexity Intuition
Triangular totals make O(n²) concrete for beginners.
Example: count printed digits for n = 10 still → 55.
6. Input Validation Labs
Pair the pattern with scanf return checks and positive-row checks.
Example: reject rows <= 0 and re-prompt.
Pro Tip: when an interviewer asks for patterns, explain the outer/inner roles first — then write the loops. The story matters as much as the code.
Advantages
Why this pattern earns a permanent spot in beginner C courses.
1. Instant Visual Feedback
Wrong bounds show up immediately as a broken staircase.
2. Minimal Concepts
Only loops and console output — no arrays or math libraries.
3. Easy to Extend
Invert, center, hollow, or change the fill character with small edits.
4. O(1) Extra Memory
Streaming output needs no storage beyond loop counters.
Pro Tip: learn m = rows - 1 and k = i + m first; compare with custom step in Example 3.
Usage Tips
Small habits that keep number-pattern code clean.
1. Name Bounds Clearly
Reset
m = rows - 1at the start of each row — not once before all loops.2. Prefer
scanfCheck the return value so bad input does not leave
rowsuninitialized.3. Keep printf("\n") Outside
Only call
printf("\n")after the inner loop finishes the row.4. Trace m and k on Paper
Write row
i, initialm, and eachkjump before coding.5. Dry-Run One Small n
Trace
rows = 5on paper before coding larger demos.
Pro Tip: if the output is a vertical list of single digits per line, you almost certainly put printf("\n") inside the inner loop.
Common Pitfalls
Mistakes that commonly break jump number patterns.
1. Newline Inside the Inner Loop
Each digit lands on its own line — you get a column, not a triangle.
→ Use
printf("%d ", i)andprintf("%d ", k);printf("\n")only after the inner loop.2. Wrong Inner Loop Bound
Using
j <= iprints one extra value per row.→ Use
for (j = 1; j < i; j++)— onlyi - 1jumps after printingi.3. Forgetting m-- Before k Update
Skipping
m--makes every jump the same size.→ Always do
m--thenk = k + mafter printingk.4. Forgetting the Row Break
Omitting
printf("\n")glues every number onto one endless line.→ Always end the row after the inner loop.
5. Unchecked scanf
Letters or empty input leave
rowsuninitialized.→ Check
scanfreturn value and re-prompt on failure.
Edge Cases
Check these inputs before calling the solution done.
rows = 1
Single digit
Output is just 1 on one line.
rows = 0
Empty pattern
Outer loop never runs — print nothing or show a message.
Negative
rows < 0
Treat as invalid; re-prompt instead of silent empty output.
Large n
Large width
Output grows as n² characters — fine for labs, noisy for huge n.
Bad input
Non-numeric scanf input
Unchecked scanf leaves rows unset — check the return value.
m not reset
m carries over rows
Declaring m once before all loops gives wrong jumps — reset inside each row.
i = 1
No inner loop
When i = 1, the inner loop runs zero times — only 1 prints.
Drill
🎯 Practice Problems
Try these variations to lock in the pattern.
1. Continuous counter
- Running
k++across rows - Review Program 20
2. Odd-length rows
- Rows with step of 2
- Continue with Program 22
3. Custom step size
- Try
m = 2orm = 6instead ofrows - 1 - Watch how jump spacing changes
4. No trailing space
- Print space only between numbers, not after the last
- Harder follow-up after this page
Important
Notes
- Triangular sum. Total prints =
rows(rows+1)/2— O(n²) fornrows. printf("%d ", k)stays on the line;printf("\n")advances — mix them carefully.- Validate
rows > 0for interactive programs;rows = 1should print a single1. - This page is left-aligned. Centered pyramids need leading spaces — covered later in the series.
Quick Takeaway: print i first, set m = rows - 1 and k = i + m, then loop with m-- and k = k + m.
Analysis
⏱️ Time and Space Complexity
| Program | Time | Extra space |
|---|---|---|
| Nested loops (Examples 1–2) | O(rows²) | O(1) |
| Custom step (Example 3) | O(rows²) | O(1) |
🎉 Conclusion
The increasing jump number triangle is a compact lesson in variable step sizes: print i, set m = rows - 1, compute jumps with k = i + m, and shrink m after each print. Master the fixed-rows version, then try user input and a custom step value.
Practice the three examples above, then continue to Program 22 for odd-length number rows.
Reset m each row — use j < i for the inner loop and validate rows when reading input.
Pro Tips
💡 Best Practices
✅ Do
- Print
ibefore the inner loop on every row - Reset
m = rows - 1inside each outer iteration - Use
for (j = 1; j < i; j++)for jump values - Check
scanfreturn value before usingrows - State O(n²) time when asked about complexity
❌ Don’t
- Call
printf("\n")inside the inner jump loop - Use
j <= i— that prints one extra value - Forget
m--before updatingk - Skip the newline after each row
- Ignore bad console input in user-facing demos
- Skip the
rows = 1edge case
Summary
Key Takeaways
Knowledge Unlocked
Five things to remember about this jump pattern
Print the pattern the beginner-friendly way.
5
Core concepts 01
Rule
Jump + m--
Definition 02
Print i
Row start first
Code 03
Step m
rows - 1, then m--
Code 04
Grow width
Row i prints i nums
Shape 05
Complexity
O(n²) time
Analysis❓ Frequently Asked Questions
Because the step variable m starts at rows - 1 and decreases after each printed number. Each next value is computed by adding the current m, so the jumps shrink across the row.
m is the step size used to compute the next printed number in the row. It decreases each time, changing the increment between consecutive outputs.
Row 2 prints i = 2 first. Then m = 4 and k = i + m = 6 — the inner loop prints k once, giving 2 6.
printf("%d ", i) stays on the same line with a trailing space. printf("\n") ends the current line. Numbers use printf; the row break uses printf("\n") after the inner loop.
Total prints are 1+2+...+n = n(n+1)/2 — row i prints exactly i values.
Yes. Set m to a custom value instead of rows - 1 (see Example 3) — smaller steps produce tighter jumps.
O(n²) for n rows because total printf calls equal n(n+1)/2.
Check scanf's return value: if (scanf("%d", &rows) != 1) handle bad input. Unchecked scanf leaves rows uninitialized on failure.
The outer loop never runs, so nothing is printed. Validate and prompt again if you want a clear user message.
Did you Know? 🔊
Each row starts at i, then adds a decreasing step m to compute the next value. As m shrinks after each print, the jumps get smaller toward the end of the row — total prints still equal n(n+1)/2 for n rows.
Continue to Program 22
Move on to the odd-length number rows pattern in the C number-pattern series.
About the author
12 people found this page helpful