Increasing Jump Number Triangle in C++

Beginner
⏱️ 8 min read
📚 Updated: Aug 2026
🎯 3 Code Examples
🚀 Live Preview
Decreasing Step
Increasing jump number triangle output (1, 2 6, 3 7 10, 4 8 11 13, 5 9 12 14 15) in C++ programming
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.

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.

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.

cout vs newline

Same line / next line

Print i first, then k values in the inner loop; end each row with cout << "\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 15

Inputs & Outputs

ItemTypeDescription
rowsintNumber of triangle lines to print (typically ≥ 1).
mintStep size — starts at rows - 1, decreases after each jump.
kintNext value to print — set to i + m before the inner loop.
Printed outputtextRow 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 newline

Approach comparison

ApproachIdeaBest for
Decreasing step m1, 2 6, 3 7 10, …Learning and interviews
User-input rowscin >> rows;Flexible console programs
Custom initial stepm = 3 instead of rows - 1Tighter or wider jumps
Cheat Sheet

⚡ Quick Reference

GoalPattern
Walk each rowfor (i = 1; i <= rows; i++)
Print row startcout << i << " ";
Init stepint m = rows - 1;
First jump valueint k = i + m;
Inner loopfor (j = 1; j < i; j++)
Update stepm--; k = k + m; after each print
User inputcin >> rows;
Compare

📋 Fixed Rows vs User Input vs Custom Step

Same jump triangle — different ways to control rows and step size.

Row start
print i

Every row begins with the row index

Step m
m = rows-1

Initial jump size — reset each row

Custom step
m = 3

Override 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.

  1. Post-continuous exercise

    Natural follow-up after Program 20 — introduces a decreasing step variable.

  2. Nested-loop warm-up

    Outer/inner bound practice with an immediate visual check.

  3. Console I/O practice

    Combine loops with cin for a flexible row count.

  4. Gateway to variants

    Compare Program 20 (continuous counter) and Program 22 (odd-length rows) next.

  5. 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.

Try 4, 5, or 7. Larger values still work up to 15.

Live result
Press "Draw pattern".
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 <iostream>
using namespace std;

int main() {
    int i, j, k, m;

    for (i = 1; i <= 5; ++i) {
        cout << i << " ";

        m = 4;
        k = i + m;

        for (j = 1; j < i; ++j) {
            cout << k << " ";
            m--;
            k = k + m;
        }

        cout << "\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. cout << "\n" after the inner loop starts the next row.

📈 User Input

Read the row count with cin instead of hard-coding 5.

Example 2 — User Input

Read rows with cin >> rows (check cin.fail() in real apps); set m = rows - 1 each row.

C++
#include <iostream>
using namespace std;

int main() {
    int rows;
    int i, j, k, m;

    cout << "Enter the number of rows: ";
    cin >> rows;

    for (i = 1; i <= rows; ++i) {
        cout << i << " ";

        m = rows - 1;
        k = i + m;

        for (j = 1; j < i; ++j) {
            cout << k << " ";
            m--;
            k = k + m;
        }

        cout << "\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 sets cin’s fail bit if you ignore errors — always validate 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 <iostream>
using namespace std;

int main() {
    int rows = 4;
    int i, j, k, m;

    for (i = 1; i <= rows; ++i) {
        cout << i << " ";

        m = 3;
        k = i + m;

        for (j = 1; j < i; ++j) {
            cout << k << " ";
            m--;
            k = k + m;
        }

        cout << "\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 <iostream> brings in cout and cin. Set rows and loop variables i, j, k, m.

Setup
2

Outer loop + row start

for (i = 1; i <= rows; i++) then cout << 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

cout << "\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.

iInit mJump sequenceRow output
141 (no inner loop)1
24 → k=62, 62 6
34 → k=7, m=3 → k=103, 7, 103 7 10
44 → 8, 11, 134, 8, 11, 134 8 11 13
54 → 9, 12, 14, 155, 9, 12, 14, 155 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 cout vs row newline without complex math.

Example: put cout << "\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 cin.fail() 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. 1. Instant Visual Feedback

    Wrong bounds show up immediately as a broken staircase.

  2. 2. Minimal Concepts

    Only loops and console output — no arrays or math libraries.

  3. 3. Easy to Extend

    Invert, center, hollow, or change the fill character with small edits.

  4. 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. 1. Name Bounds Clearly

    Reset m = rows - 1 at the start of each row — not once before all loops.

  2. 2. Prefer cin

    Check cin.fail() so bad input does not leave rows unset.

  3. 3. Keep cout << "\n" Outside

    Only call cout << "\n" after the inner loop finishes the row.

  4. 4. Trace m and k on Paper

    Write row i, initial m, and each k jump before coding.

  5. 5. Dry-Run One Small n

    Trace rows = 5 on paper before coding larger demos.

Pro Tip: if the output is a vertical list of single digits per line, you almost certainly put cout << "\n" inside the inner loop.

Common Pitfalls

Mistakes that commonly break jump number patterns.

  1. 1. Newline Inside the Inner Loop

    Each digit lands on its own line — you get a column, not a triangle.

    → Use cout << i << " " and cout << k << " "; cout << "\n" only after the inner loop.

  2. 2. Wrong Inner Loop Bound

    Using j <= i prints one extra value per row.

    → Use for (j = 1; j < i; j++) — only i - 1 jumps after printing i.

  3. 3. Forgetting m-- Before k Update

    Skipping m-- makes every jump the same size.

    → Always do m-- then k = k + m after printing k.

  4. 4. Forgetting the Row Break

    Omitting cout << "\n" glues every number onto one endless line.

    → Always end the row after the inner loop.

  5. 5. Unchecked cin

    Letters or empty input leave rows unset.

    → Check cin.fail() 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 cin input

Unchecked cin leaves rows unset — check cin.fail().

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

2. Odd-length rows

3. Custom step size

  • Try m = 2 or m = 6 instead of rows - 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²) for n rows.
  • cout << k << " " stays on the line; cout << "\n" advances — mix them carefully.
  • Validate rows > 0 for interactive programs; rows = 1 should print a single 1.
  • 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

ProgramTimeExtra space
Nested loops (Examples 1–2)O(rows²)O(1)
Custom step (Example 3)O(rows²)O(1)
Wrap Up

🎉 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.

View Examples Gallery Continue to Program 22
Pro Tips

💡 Best Practices

✅ Do

  • Print i before the inner loop on every row
  • Reset m = rows - 1 inside each outer iteration
  • Use for (j = 1; j < i; j++) for jump values
  • Check cin.fail() before using rows
  • State O(n²) time when asked about complexity

❌ Don’t

  • Call cout << "\n" inside the inner jump loop
  • Use j <= i — that prints one extra value
  • Forget m-- before updating k
  • Skip the newline after each row
  • Ignore bad console input in user-facing demos
  • Skip the rows = 1 edge 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
O 05

Complexity

O(n²) time

Analysis
🎯 You’re ready to print a jump number triangle in C++
Review Quick Reference →

❓ 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.
cout << i << " " stays on the same line with a trailing space. cout << "\n" ends the current line. Numbers use cout; the row break uses cout << "\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 cout digit outputs equal n(n+1)/2.
After cin >> rows, check cin.fail() or use if (!(cin >> rows)) to handle bad input. Unchecked cin leaves rows unset 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.

Program 22 tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

12 people found this page helpful

C++ Number Pattern 20 C++ Number Pattern 22 — Odd-Length Number Rows