Repeated Number Triangle Pattern in Java

Beginner
⏱️ 8 min read
📚 Updated: Aug 2026
🎯 3 Code Examples
🚀 Live Preview
Inner loop prints i
Repeated number triangle pattern output (1, 22, 333, 4444, 55555) in Java programming
Overview

What You’ll Learn

The repeated number triangle prints 1, 22, 333, 4444, 55555 — row i repeats digit i exactly i times. This tutorial covers nested-loop logic, live preview, worked Java examples, edge cases, and O(n²) complexity.

Repeat Digit

print(i)

Row i prints the digit i exactly i times — e.g. row 3 → 333.

Outer Loop

i = 1..rows

Outer loop picks the digit for each row — grows from 1 to rows.

Inner Loop

j = 1..i

Inner loop controls repeat count — row length equals outer index i.

vs Program 5

print j vs i

Program 5 prints ascending digits; this repeats the row digit instead.

Live Preview

1–20 rows

Pick a row count and draw the repeated triangle instantly in the browser.

O(n²)

Complexity

Total digits ≈ n(n+1)/2 — quadratic time; extra memory stays O(1).

Introduction

A repeated number triangle grows each row by one more copy of the same digit: 1, 22, 333, up to 55555 for five rows.

In Java: outer loop for (i = 1; i <= rows; i++), inner loop for (j = 1; j <= i; j++) System.out.print(i), then println().

Why it matters?

It teaches the difference between printing loop index j (Program 5) and repeating row digit i — then continue to Program 10 for the descending repeat variant.

Key Highlights

print(i)

Inner loop prints the row digit, not j.

Row length = i

Inner loop runs i times on row i.

vs Program 5

Program 5: 1, 12, 123. Program 9: 1, 22, 333.

O(n²)

Total prints grow as n(n+1)/2.

In short: for each i from 1 to rows, print i exactly i times, then System.out.println().

Foundation

📝 Problem & Approach

Given a positive integer rows (e.g. 5), print a repeated number triangle: row i repeats digit i exactly i times (e.g. row 3 → 333).

Java
// rows = 5 (conceptual shape)
// 1
// 22
// 333
// 4444
// 55555

Inputs & Outputs

ItemTypeDescription
rowsintNumber of triangle lines — outer loop runs from 1 up to rows.
iintOuter loop — current row digit; grows from 1 to rows.
jintInner loop — runs j from 1 to i; prints i each time.

Minimal workflow

Pseudocode
for i from 1 to rows:
    for j from 1 up to i:
        print i
    print newline

Approach comparison

ApproachIdeaBest for
Nested loops1, 22, 333, …Learning and interviews
User-input rowssc.nextInt();Flexible console programs
Spaced outputSystem.out.print(i + " ")Easier reading per row
Cheat Sheet

⚡ Quick Reference

GoalPattern
Walk rowsfor (i = 1; i <= rows; i++)
Repeat digit ifor (j = 1; j <= i; j++) System.out.print(i);
End the rowSystem.out.println();
Spaced digitsSystem.out.print(i + " ");
User inputsc.nextInt();
Program 5 contrastProgram 5 prints ascending digits (print j); Program 9 repeats row digit (print i)
Compare

📋 Outer Loop vs Inner Loop vs Combined

How outer i and inner repeat count j = 1..i with print(i) work together.

Outer loop
for (i = 1; i <= rows; i++)

Selects row digit — grows from 1 to rows.

Inner loop
for (j = 1; j <= i; j++)

Repeats digit i exactly i times.

Cell value
print(i)

Print row digit i each iteration — 333 not 123.

Learning tip
trace i=3

Dry-run when i=3: inner loop runs 3 times → prints 333.

Context

When This Pattern Shows Up

Reach for this pattern when teaching nested loops, growing inner bounds, and concatenated digit output.

  1. After Program 8

    Natural follow-up in the repeat-digit series — compare growing reverse (Program 7/8) with same-digit rows.

  2. Nested-loop warm-up

    Outer/inner bound practice with an immediate visual check.

  3. Console I/O practice

    Combine loops with Scanner for a flexible row count.

  4. Gateway to variants

    Compare with Program 5 (ascending digits), then continue to Program 10 (descending repeat triangle).

  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

Enter a row count and draw the repeated number triangle in the browser.

Try 5, 7, or 10. Larger values still work up to 20.

Live result
Press "Draw pattern".
Hands-On

Examples Gallery

Three complete Java programs — fixed rows = 5, Scanner input, and a spaced-output variant. Click View Output to reveal sample console results.

📚 Getting Started

Print five rows — inner loop repeats digit i exactly i times.

Example 1 — Fixed rows = 5

Hard-coded row count — outer i selects the digit; inner j controls how many times to print it.

Java
public class RepeatedNumberTrianglePattern {
    public static void main(String[] args) {
        int rows = 5;

        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i);
            }
            System.out.println();
        }
    }
}

How It Works

When i = 3, the inner loop runs three times and prints i each time — output 333. When i = 5, output is 55555.

📈 User Input

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

Example 2 — User Input Version

Read rows with Scanner.nextInt(); same nested loops as Example 1.

Java
import java.util.Scanner;

public class RepeatedNumberTriangleInput {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("Enter the number of rows: ");
        int rows = sc.nextInt();

        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i);
            }
            System.out.println();
        }

        sc.close();
    }
}

How It Works

Same nested-loop core as Example 1; only the source of rows changes.

⚡ Formatting Variant

Add spaces between repeated digits for easier reading.

Example 3 — Spaced Output

Print a space after each repeated digit with print(i + " ").

Java
public class RepeatedNumberTriangleSpaced {
    public static void main(String[] args) {
        int rows = 5;

        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(i + " ");
            }
            System.out.println();
        }
    }
}

How It Works

Same j = 1..i logic with print(i); only the output format adds spaces between digits.

🧠 How the Algorithm Prints Rows

1

Set up

System.out is built in; use Scanner when reading input. Set loop variables i, j with rows = 5.

Setup
2

Outer loop walks rows

for (i = 1; i <= rows; i++) — each row repeats digit i one more time.

Row
3

Inner loop (j)

for (j = 1; j <= i; j++) — repeats digit i exactly i times.

Inner
4

New line

System.out.println() ends the row after the inner loop finishes.

Break
=

repeated number triangle pattern complete

Each row adds one more copy of the row digit — O(n²) time, O(1) extra memory.

Trace

🔎 Worked Walkthrough — row i = 3 (rows = 5)

Trace how increasing i adds one more copy of the row digit.

Row ij rangeOutput
11..11
21..222
31..3333
41..44444
51..555555

After the inner loop, println() moves to the next row.

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: compare inner bounds with Program 5 and Program 8 and watch digit order change.

2. Pattern Series Base

Foundation for inverted, pyramid, diamond, and hollow variants.

Example: continue to Program 10 for the descending repeat triangle.

3. Console Formatting Drills

Practice System.out.print vs System.out.println() without complex math.

Example: put System.out.println() inside the inner loop by mistake.

4. Spaced Output

Add spaces between digits once the two-loop structure works.

Example: use System.out.print(i + " ") between digits on each row.

5. Complexity Intuition

Triangular totals make O(n²) concrete for beginners.

Example: count printed digits for rows = 5 — total is still 15 (1+2+3+4+5)).

6. Input Validation Labs

Pair the pattern with Scanner 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 Java 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: trace i and j on paper for rows = 3 before coding — watch how each row grows by one digit.

Usage Tips

Small habits that keep number-pattern code clean.

  1. 1. Match Inner Bounds

    Outer loop counts down; inner loop must run j = 1..i so each row grows on the right.

  2. 2. Prefer Scanner

    Call sc.hasNextInt() so bad input does not leave rows uninitialized.

  3. 3. Keep System.out.println() Outside

    Only call System.out.println() after the inner loop finishes the row.

  4. 4. Use print(i) for Digits

    for (j = 1; j <= i; j++) System.out.print(i) concatenates digits on one line.

  5. 5. Dry-Run rows = 3

    Trace i = 1, 2, 3 on paper before coding the full rows = 5 demo.

Pro Tip: if the output is a vertical list of single digits per line, you almost certainly put System.out.println() inside the inner loop.

Common Pitfalls

Mistakes that commonly break Repeated Number Triangle Pattern patterns.

  1. 1. Newline Inside the Inner Loop

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

    → Use System.out.print(i) for digits; System.out.println() only after the inner loop.

  2. 2. Ascending outer loop (Program 7)

    for (int i = 1; i <= rows; i++) with j = i..1 prints 1, 21, 321 — not 5, 54, 543.

    → Use for (int i = rows; i >= 1; i--) and for (j = 1; j <= i; j++).

  3. 3. Program 7 inner loop

    for (j = i; j >= 1; j--) builds 1, 21, 321 — not this reverse-growing pattern.

    → Use for (j = 1; j <= i; j++) so each row starts at rows.

  4. 4. Confused with Program 4 shrinking rows

    Program 4 prints the longest row first (54321). Program 8 prints the shortest row first (5) with the same j = 1..i range.

    → Check output order: growing rows need i counting down from rows.

  5. 5. Unchecked Scanner input

    Letters or empty input leave rows uninitialized.

    → Call sc.hasNextInt() and re-prompt on failure.

Edge Cases

Check these inputs before calling the solution done.

rows = 1

Single digit row

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.

rows = 2

Smallest triangle

Two rows: 1 and 21.

Bad input

Non-numeric Scanner input

Unchecked Scanner input leaves rows unset — call hasNextInt() first.

Large rows

Large row count

Each row prints i digits — total work grows as n(n+1)/2.

Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Compare Program 5

  • Program 5: ascending 1, 12, 123 (print j)
  • Review Program 5

2. Descending repeat variant

  • Reverse outer loop: for (i = rows; i >= 1; i--)
  • See Program 10 — 5, 44, 333, 2222, 11111

3. Next in series

  • Continue with Program 10
  • Descending repeat triangle 5, 44, 333, 2222, 11111

4. Spaced output

  • Use System.out.print(i + " ") between digits
  • Same loops, wider visual spacing
Important

Notes

  • Repeat-digit inner loop. Outer loop: i = 1..rows. Inner loop: j = 1..i with print(i).
  • System.out.print stays on the line; System.out.println() advances — mix them carefully.
  • Validate rows > 0 for interactive programs; rows = 1 should print a single 1.
  • Row i prints exactly i copies of digit i — compare with Program 5 where inner loop prints j.

Quick Takeaway: outer loop i = 1..rows, inner loop j = 1..i with System.out.print(i), then System.out.println().

Analysis

⏱️ Time and Space Complexity

ProgramTimeExtra space
Nested loops (Examples 1–3)O(n²)O(1)
Spaced output (Example 3)O(n²)O(1)
Wrap Up

🎉 Conclusion

The Repeated Number Triangle Pattern is a compact nested-loop lesson: outer loop lowers i while the inner loop prints digits rows down to i. Master the fixed-rows version, then try user input and spaced output.

Practice the three examples above, then continue to Program 10 for the descending repeating triangle (5, 44, 333, 2222, 11111).

Each row prints rows..i — keep System.out.print(i) for digits and System.out.println() for the row break.

View Examples Gallery Continue to Program 10
Pro Tips

💡 Best Practices

✅ Do

  • Use for (i = 1; i <= rows; i++) in the outer loop
  • Inner: for (j = 1; j <= i; j++) prints digits i..1
  • Use System.out.print(i) for digits and System.out.println() after each row
  • Validate rows ≥ 1 for interactive programs
  • Call sc.hasNextInt() before using rows

❌ Don’t

  • Call System.out.println() inside the inner digit loop
  • Use Program 7’s ascending outer loop when you meant Program 8 — this pattern needs j-- from i
  • Forget println() inside the inner loop — digits must stay on one 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 repeated number triangle pattern

Print the pattern the beginner-friendly way.

5
Core concepts
△ 01

Rule

Row i prints i repeated i times

Definition
↻ 02

Outer loop

Repeats digit i

Code
↓ 03

Inner loop

j = 1..i, print i

Code
↵ 04

Newline

Ends each row

Shape
O 05

Complexity

O(n²) time

Analysis
🎯 You’re ready to print the Repeated Number Triangle Pattern in Java
Review Quick Reference →

❓ Frequently Asked Questions

The outer loop sets i = 4. The inner loop runs j from 1 to 4 and each iteration prints i, so digit 4 appears four times on that row.
The outer loop runs i from 1 to rows. For each i, the inner loop runs j from 1 to i and prints i with System.out.print, then println ends the row.
Reverse the outer loop: for (int i = rows; i >= 1; i--) and keep the inner loop j = 1..i with print(i). That yields 5, 44, 333, 2222, 11111 for five rows — see Program 10.
Program 5 prints ascending digits 1, 12, 123 (print j). Program 9 repeats the row digit: 1, 22, 333 (print i). Program 10 is the descending repeat triangle (5, 44, 333, 2222, 11111).
Yes. Print System.out.print(i + " ") inside the inner loop — see Example 3.
O(n²) for n rows. Total printed digits are 1+2+...+n = n(n+1)/2.
Use sc.hasNextInt() before sc.nextInt() so bad input does not throw InputMismatchException.
The outer loop never runs, so nothing is printed. Validate and prompt again if you want a clear user message.

Did you Know? 🔊

Outer loop sets row digit i; inner loop prints i exactly i times — 1, 22, 333, … O(n²) for n rows.

Continue to Program 10

Move on to the descending repeating number triangle in the Java number-pattern series.

Program 10 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

Java Number Pattern 8 — Reverse Growing Number Pattern Java Number Pattern 10 — Descending Repeating Number Triangle Pattern