Alternating Number Triangle Pattern in C#

Beginner
⏱️ 10 min read
📚 Updated: Aug 2026
🎯 3 Code Examples
🚀 Live Preview
Nested Loops + Odd/Even Rows
Alternating number triangle output in C# (1, 3 2, 4 5 6, 10 9 8 7, 11 12 13 14 15)
Overview

What You’ll Learn

Program 51 prints an alternating number triangle: odd rows go left-to-right, even rows go right-to-left, with a continuous counter across all rows — a natural step after Program 50’s mixed number triangle. This tutorial covers running counters, odd/even row logic, a live preview, worked C# examples, edge cases, and complexity.

Shape Rule

Alternate direction

Row i prints i numbers — ascending on odd rows, descending on even rows.

Running Counter

next

next starts at 1 and increments once per printed value — never reset between rows.

Row End Value

end = next + i - 1

Compute end before each row — the last number that belongs on the current line.

Odd/Even Check

i % 2

Odd rows print next; even rows print end-- for the zig-zag effect.

Live Preview

rows = 3..9

Pick row count and draw the alternating number triangle in the browser.

O(n²)

Complexity

Total prints = 1+2+…+n = n(n+1)/2 — classic triangular growth.

Introduction

An alternating number triangle pattern prints row i with i continuous numbers — ascending on odd rows, descending on even rows. With rows = 5, you get 1, 3 2, 4 5 6, 10 9 8 7, 11 12 13 14 15.

In C# a running counter next tracks the next value, end = next + i - 1 sets the reverse start, and i % 2 picks print direction before WriteLine().

Why it matters?

It bridges Program 50’s mixed number triangle to zig-zag patterns — combining a running counter with odd/even row direction.

Key Highlights

Odd rows

Print next ascending left-to-right.

Even rows

Print end-- descending right-to-left.

vs Program 50

Program 50 uses fixed digit halves; Program 51 uses a continuous counter with alternating direction.

Series Foundation

Follow Program 50; continue to Program 52 next.

In short: track next, compute end = next + i - 1, print ascending on odd rows and end-- on even rows, increment next each time, then WriteLine().

Foundation

📝 Problem & Approach

Given row count rows = 5, print an alternating number triangle — row i shows i continuous numbers, alternating direction each row.

C#
// rows = 5
//1
//3 2
//4 5 6
//10 9 8 7
//11 12 13 14 15

Inputs & Outputs

ItemTypeDescription
rowsintHow many triangle rows to print.
i (outer)intCurrent row index — runs from 1 to rows.
nextintRunning counter — next number to assign; increments each print.
endintLast number on the row: next + i - 1; decremented on even rows.
j (inner)intPrint loop — runs 1..i values per row.
Row lengthintRow i prints exactly i numbers.

Minimal workflow

Pseudocode
next = 1
for i from 1 to rows:
    end = next + i - 1
    for j from 1 to i:
        if i is odd: print next
        else: print end; end--
        next++
    print newline

Approach comparison

ApproachIdeaBest for
Odd/even directioni % 2 picks ascending vs descending printLearning and interviews
Running counternext increments once per printed valueContinuous numbering across rows
User-input rowsint.TryParse(...)Flexible row count
Compact tracerows = 3 on paper firstQuick dry-runs before full demo
Spaced variantConsole.Write(j + " ")Easier reading per row
Cheat Sheet

⚡ Quick Reference

GoalPattern
Outer loopfor (i = 1; i <= rows; i++)
Init counterint next = 1;
Row end valueint end = next + i - 1;
Odd row printif (i % 2 == 1) Console.Write(next + " ");
Even row printelse Console.Write(end-- + " ");
Advance counternext++; once per printed value
Program 50 contrastProgram 50 uses fixed digit halves; Program 51 alternates direction with a running counter
Compare

📋 Fixed Rows vs User Input vs Compact Trace

Same triangle — three ways to set row count and format output.

Fixed rows
rows = 5

Hard-coded height for demos

User input
TryParse

Read row count from console

Compact trace
rows = 3

Quick dry-run on paper

Running counter
next = 1

Continuous numbering across rows

Odd/even
i % 2

Picks ascending vs descending

Context

When This Pattern Shows Up

Reach for this pattern when teaching running counters, odd/even row logic, and zig-zag print direction.

  1. Post Program 50 exercise

    Natural follow-up after Program 50’s mixed number triangle — introduces alternating print direction.

  2. Zig-zag traversal

    Similar logic appears in matrix serpentine traversals and boustrophedon ordering.

  3. Continuous counters

    Total prints = n(n+1)/2 — classic nested-loop complexity example.

  4. Gateway to variants

    Compare Program 50 (mixed number triangle) with this alternating pattern, then continue to Program 52.

  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 running counters, odd/even logic, and O(n²) thinking.

Interactive

🔮 Live Preview

Choose row count between 3 and 9 and draw the alternating number triangle in the browser.

Try 4, 5, or 7. Max up to 9 in this preview.

Live result
Press "Draw pattern".
Hands-On

Examples Gallery

Three complete C# programs — fixed rows, user input, and a compact trace demo. Click View Output to reveal sample console results.

📚 Getting Started

Print five rows of the alternating number triangle with a running counter and odd/even direction.

Example 1 — Fixed rows = 5

Hard-coded row count — odd rows print next ascending, even rows print end-- descending.

C#
using System;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int rows = 5;
            int next = 1;

            for (int i = 1; i <= rows; i++)
            {
                int end = next + i - 1;

                for (int j = 1; j <= i; j++)
                {
                    if (i % 2 == 1)
                        Console.Write(next + " ");
                    else
                        Console.Write(end-- + " ");

                    next++;
                }
                Console.WriteLine();
            }
        }
    }
}

How It Works

When i = 2, the row is even: end = 3, so it prints 3 2 in reverse. When i = 1, the odd row prints next = 1 ascending.

📈 User Input

Read row count from the console with safe parsing.

Example 2 — User Input Rows

Read rows from the console with int.TryParse — reject invalid input gracefully.

C#
using System;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.Write("Enter the number of rows: ");
            if (!int.TryParse(Console.ReadLine(), out int rows) || rows <= 0)
            {
                Console.WriteLine("Please enter a positive integer.");
                return;
            }

            int next = 1;

            for (int i = 1; i <= rows; i++)
            {
                int end = next + i - 1;

                for (int j = 1; j <= i; j++)
                {
                    if (i % 2 == 1)
                        Console.Write(next + " ");
                    else
                        Console.Write(end-- + " ");

                    next++;
                }
                Console.WriteLine();
            }
        }
    }
}

How It Works

Same counter and odd/even core as Example 1; only the source of rows changes from a literal to user input.

⚡ Compact Trace

Smaller row count for quick tracing on paper or in interviews.

Example 3 — Compact rows = 3

Use rows = 3 to trace the counter and odd/even logic quickly before scaling to 5 rows.

C#
using System;

namespace MyApp
{
    class Program
    {
        static void Main(string[] args)
        {
            int rows = 3;
            int next = 1;

            for (int i = 1; i <= rows; i++)
            {
                int end = next + i - 1;

                for (int j = 1; j <= i; j++)
                {
                    if (i % 2 == 1)
                        Console.Write(next + " ");
                    else
                        Console.Write(end-- + " ");

                    next++;
                }
                Console.WriteLine();
            }
        }
    }
}

How It Works

With only three rows you can trace every next increment and odd/even branch on paper before running the full rows = 5 demo.

🧠 How the Algorithm Prints Rows

1

Init running counter

Set next = 1 before the outer loop — it tracks the next number to assign.

Counter
2

Compute row end

end = next + i - 1 — the last number that belongs on row i.

Row math
3

Alternate print direction

Odd rows print next; even rows print end--. Increment next each time.

Odd/Even
4

New line per row

Console.WriteLine() after the inner loop finishes each row.

Break
=

Alternating number triangle complete

Total prints = 1+2+…+n — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — rows = 5

Trace each row’s counter values, print direction, and full line output.

inext at startendDirectionRow output
111odd / asc1
223even / desc3 2
346odd / asc4 5 6
4710even / desc10 9 8 7
51115odd / asc11 12 13 14 15

Row i always prints exactly i numbers — the counter never resets between rows.

Use Cases

Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.

1. Teaching Nested Loops

Inner bound grows with outer index — classic nested-loop exercise.

Example: trace row i = 4 in the walkthrough table.

2. Zig-Zag Traversal

Alternating direction mirrors serpentine matrix walks — a common interview pattern.

Example: row 5 ends with 11 12 13 14 15 — five ascending values on an odd row.

3. Console Formatting Drills

Practice Write vs WriteLine with multiple values per row.

Example: put WriteLine inside the inner loop by mistake.

4. Continuous Counters

Total prints = n(n+1)/2 — links loops to summation formulas.

Example: 10 rows print 55 values total.

5. Complexity Intuition

Growing inner bound makes O(n²) concrete — count prints for n rows.

Example: 5 rows = 1+2+3+4+5 = 15 prints.

6. Input Validation Labs

Pair the pattern with TryParse and positive-row checks.

Example: reject rows <= 0 and re-prompt.

Pro Tip: when an interviewer asks for patterns, explain 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 inner bounds show up immediately as a broken triangle.

  2. 2. Real Math Connection

    Alternating direction with a running counter — bridges loops to zig-zag logic.

  3. 3. Easy to Extend

    Change rows, use fixed-width format, or switch to full rectangular table.

  4. 4. O(1) Extra Memory

    Streaming output needs no storage beyond loop counters.

Pro Tip: trace row i = 2 on paper — watch end = 3 print 3 2 while next advances to 4.

Usage Tips

Small habits that keep number-pattern code clean.

  1. 1. Inner bound = i

    Row i prints exactly i values — use j <= i.

  2. 2. Prefer TryParse

    Avoid crashes when the user types letters instead of a number.

  3. 3. WriteLine After Inner Loop

    Only call WriteLine() after the inner loop finishes the row.

  4. 4. Fixed-Width Formatting

    Trace rows = 3 on paper before coding the full rows = 5 demo.

  5. 5. Dry-Run rows = 5

    Trace five rows on paper before coding the full 10-row demo.

Pro Tip: if the output is a vertical list of single numbers, you almost certainly put WriteLine inside the inner loop.

Common Pitfalls

Mistakes that commonly break alternating number triangle patterns.

  1. 1. WriteLine Inside Inner Loop

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

    → Use Console.Write(next + " ") or Console.Write(end-- + " "); WriteLine only after the inner loop.

  2. 2. Wrong Inner Bound

    Using j <= rows every row makes a full rectangle, not a triangle.

    → Use for (j = 1; j <= i; j++) — inner bound depends on outer i.

  3. 3. Resetting the Counter Each Row

    Numbers restart at 1 every line — the continuous sequence breaks.

    → Keep next outside the outer loop and only increment it inside the inner loop.

  4. 4. Forgetting WriteLine After Row

    All numbers print on one long line without row breaks.

    → Add Console.WriteLine() after each inner loop completes.

  5. 5. Blind Convert.ToInt32

    Letters or empty input throw FormatException.

    → Prefer int.TryParse and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

rows = 1

Single row

Output is just 1 on one line.

rows = 0

Empty output

Outer loop never runs — print nothing or show a message.

Negative

rows < 0

Treat as invalid; re-prompt instead of silent empty output.

rows = 5

Compact trace

Five rows ending with 11 12 13 14 15 — good for dry-runs.

Bad input

Non-numeric ReadLine

Convert.ToInt32 throws — use TryParse.

Large rows

Wide output

Row 9 has 9 numbers — total prints grow as n(n+1)/2.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Compare with Program 50

  • Program 50 uses fixed digit halves per row
  • Program 51 uses a continuous counter with alternating direction

2. Change rows

  • Try rows = 4 or rows = 8 in the live preview
  • Same counter logic, different triangle size

3. Next in series

  • Continue with Program 52
  • Build on alternating number patterns

4. Flip parity rule

  • Make odd rows print descending instead
  • Same loops, reversed direction check
Important

Notes

  • Running counter. Init next = 1. Compute end = next + i - 1 per row. Never reset next between rows.
  • Console.Write stays on the line; WriteLine advances — call it only after the inner loop finishes.
  • Validate rows > 0 for interactive programs; rows = 1 prints a single 1.
  • Total prints = 1+2+…+n = n(n+1)/2 for n rows — triangular growth, not a full square.

Quick Takeaway: init next = 1, compute end = next + i - 1, print ascending on odd rows and end-- on even rows, increment next each time, then WriteLine().

Analysis

⏱️ Time and Space Complexity

ProgramTimeExtra space
Nested loops (Examples 1–3)O(n²)O(1)
Total prints for n rowsn(n+1)/2 valuesi numbers on row i
Wrap Up

🎉 Conclusion

The alternating number triangle is a natural follow-up to Program 50: a running counter with odd/even row direction for zig-zag output. Master the fixed-rows version, then try user input and the compact 3-row trace.

Practice the three examples above, then continue to Program 52 for the next pattern in the series.

Row i prints i continuous numbers — ascending on odd rows, descending on even rows.

View Examples Gallery Continue to Program 52
Pro Tips

💡 Best Practices

✅ Do

  • Init int next = 1 before the outer loop
  • Compute end = next + i - 1 at the start of each row
  • Odd rows: Console.Write(next + " ")
  • Even rows: Console.Write(end-- + " ")
  • Increment next++ once per printed value

❌ Don’t

  • Reset next to 1 on every row
  • Forget to compute end before even rows
  • Call WriteLine inside the inner loop
  • Ignore bad console input in user-facing demos
  • Skip the rows = 3 dry-run before coding rows = 5
Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about this alternating number triangle

Print the pattern the beginner-friendly way.

5
Core concepts
△ 01

Rule

Odd rows asc, even rows desc

Definition
↻ 02

Counter

next = 1, never reset

Code
↓ 03

Row end

end = next + i - 1

Code
↵ 04

Odd/even

i % 2 picks direction

Logic
O 05

Complexity

O(n²) time

Analysis
🎯 You’re ready to print an alternating number triangle in C#
Review Quick Reference →

❓ Frequently Asked Questions

Row 2 is an even row, so it prints in reverse order. The row contains numbers 2 and 3, but they are printed as 3 2 using end--.
Even rows print right-to-left to create the alternating effect. We compute end = next + i - 1 and decrement while printing.
We use a running counter next that increments once per printed value. It is not reset between rows, so numbering continues across the whole triangle.
Before printing row i, the last number is next + i - 1. That gives the correct starting point when printing the row in reverse.
Change rows or read it from user input with TryParse — see Example 2.
O(n²) for n rows because the total printed numbers are 1+2+...+n = n(n+1)/2.
Program 50 concatenates fixed digit sequences per row. Program 51 uses a continuous counter and alternates print direction on odd/even rows.
Yes. Build a row string with StringBuilder and trim the final space before printing.
Prefer int.TryParse(Console.ReadLine(), out rows) so bad input does not throw FormatException.
One row prints 1 — a single ascending value on the first odd row.

Did you Know? 🔊

Numbers stay continuous across rows via a running counter next. Odd rows print ascending; even rows print descending using end = next + i - 1. Row 2 shows 3 2 — still O(n²) total prints for n rows.

Continue to Program 52

Move on to the next pattern in the C# number-pattern series.

Program 52 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 50 C# Number Pattern 52