Repeat Digit
echo $i
Row $i prints the digit $i exactly $i times — e.g. row 3 → 333.

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 PHP examples, edge cases, and O(n²) complexity.
echo $i
Row $i prints the digit $i exactly $i times — e.g. row 3 → 333.
$i = 1..$rows
Outer loop picks the digit for each row — grows from 1 to $rows.
$j = 1..$i
Inner loop controls repeat count — row length equals outer index $i.
echo $j vs $i
Program 5 prints ascending digits; this repeats the row digit instead.
1–20 rows
Pick a row count and draw the repeated triangle instantly in the browser.
Complexity
Total digits ≈ n(n+1)/2 — quadratic time; extra memory stays O(1).
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 PHP: outer loop for ($i = 1; $i <= $rows; $i++), inner loop for ($j = 1; $j <= $i; $j++) echo $i, then echo PHP_EOL.
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.
Inner loop prints the row digit, not $j.
Inner loop runs $i times on row $i.
Program 5: 1, 12, 123. Program 9: 1, 22, 333.
Total prints grow as n(n+1)/2.
In short: for each $i from 1 to $rows, print $i exactly $i times, then echo PHP_EOL.
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).
// $rows = 5 (conceptual shape)
for ($i = 1; $i <= $rows; $i++) {
for ($j = 1; $j <= $i; $j++) {
echo $i; // digit i, repeated i times
}
echo PHP_EOL; // next row
} | Item | Type | Description |
|---|---|---|
$rows | int | Number of triangle lines — outer loop runs from 1 up to $rows. |
$i | int | Outer loop — current row digit; grows from 1 to rows. |
$j | int | Inner loop — runs $j from 1 to $i; prints $i each time. |
for i from 1 to rows:
for j from 1 up to i:
print i
print newline | Approach | Idea | Best for |
|---|---|---|
| Nested loops | 1, 22, 333, … | Learning and interviews |
| User-input rows | fgets(STDIN); | Flexible console programs |
| Spaced output | echo $i . " " | Easier reading per row |
| Goal | Pattern |
|---|---|
| Walk rows | for ($i = 1; $i <= $rows; $i++) |
| Repeat digit i | for ($j = 1; $j <= $i; $j++) echo $i; |
| End the row | echo PHP_EOL; |
| Spaced digits | echo $i . " "; |
| User input | fgets(STDIN); |
| Program 5 contrast | Program 5 prints ascending digits (echo $j); Program 9 repeats row digit (echo $i) |
How outer $i and inner repeat count $j = 1..$i with echo $i work together.
for ($i = 1; $i <= $rows; $i++)Selects row digit — grows from 1 to rows.
for ($j = 1; $j <= $i; $j++)Repeats digit $i exactly $i times.
echo $iPrint row digit $i each iteration — 333 not 123.
trace i=3Dry-run when i=3: inner loop runs 3 times → prints 333.
Reach for this pattern when teaching nested loops, growing inner bounds, and concatenated digit output.
Natural follow-up in the repeat-digit series — compare growing reverse (Program 7/8) with same-digit rows.
Outer/inner bound practice with an immediate visual check.
Combine loops with fgets(STDIN) for a flexible row count.
Compare with Program 5 (ascending digits), then continue to Program 10 (descending repeat triangle).
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.
Enter a row count and draw the repeated number triangle in the browser.
Three complete PHP programs — fixed $rows = 5, fgets(STDIN) input, and a spaced-output variant. Click View Output to reveal sample console results.
Print five rows — inner loop repeats digit $i exactly $i times.
$rows = 5Hard-coded row count — outer $i selects the digit; inner $j controls how many times to print it.
<?php
$rows = 5;
for ($i = 1; $i <= $rows; $i++) {
for ($j = 1; $j <= $i; $j++) {
echo $i;
}
echo PHP_EOL;
} When $i = 3, the inner loop runs three times and prints $i each time — output 333. When $i = 5, output is 55555.
Read the row count with fgets(STDIN) instead of hard-coding 5.
Read $rows with fgets(STDIN); same nested loops as Example 1.
<?php
echo "Enter the number of rows: ";
$input = trim(fgets(STDIN));
if (!is_numeric($input)) {
echo "Invalid input." . PHP_EOL;
exit(1);
}
$rows = (int) $input;
for ($i = 1; $i <= $rows; $i++) {
for ($j = 1; $j <= $i; $j++) {
echo $i;
}
echo PHP_EOL;
} Same nested-loop core as Example 1; only the source of $rows changes.
Add spaces between repeated digits for easier reading.
Print a space after each repeated digit with echo $i . " ".
<?php
$rows = 5;
for ($i = 1; $i <= $rows; $i++) {
for ($j = 1; $j <= $i; $j++) {
echo $i . " ";
}
echo PHP_EOL;
} Same $j = 1..$i logic with echo $i; only the output format adds spaces between digits.
echo is built in; use fgets(STDIN) when reading input. Set loop variables $i, $j with $rows = 5.
for ($i = 1; $i <= $rows; $i++) — each row repeats digit $i one more time.
for ($j = 1; $j <= $i; $j++) — repeats digit $i exactly $i times.
echo PHP_EOL ends the row after the inner loop finishes.
Each row adds one more copy of the row digit — O(n²) time, O(1) extra memory.
$i = 3 (when $rows = 5)Trace how increasing $i adds one more copy of the row digit.
Row $i | $j range | Output |
|---|---|---|
| 1 | 1..1 | 1 |
| 2 | 1..2 | 22 |
| 3 | 1..3 | 333 |
| 4 | 1..4 | 4444 |
| 5 | 1..5 | 55555 |
After the inner loop, echo PHP_EOL moves to the next row.
Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.
Clearest visual proof that outer and inner bounds interact.
Example: compare inner bounds with Program 5 and Program 8 and watch digit order change.
Foundation for inverted, pyramid, diamond, and hollow variants.
Example: continue to Program 10 for the descending repeat triangle.
Practice echo vs echo PHP_EOL without complex math.
Example: put echo PHP_EOL inside the inner loop by mistake.
Add spaces between digits once the two-loop structure works.
Example: use echo $i . " " between digits on each row.
Triangular totals make O(n²) concrete for beginners.
Example: count printed digits for $rows = 5 — total is still 15 (1+2+3+4+5)).
Pair the pattern with fgets(STDIN) 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.
Why this pattern earns a permanent spot in beginner PHP courses.
Wrong bounds show up immediately as a broken staircase.
Only loops and console output — no arrays or math libraries.
Invert, center, hollow, or change the fill character with small edits.
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.
Small habits that keep number-pattern code clean.
Outer loop counts down; inner loop must run $j = 1..$i so each row grows on the right.
fgets(STDIN)Call is_numeric($input) so bad input does not leave $rows unset.
echo PHP_EOL OutsideOnly call echo PHP_EOL after the inner loop finishes the row.
for ($j = 1; $j <= $i; $j++) echo $i concatenates digits on one line.
$rows = 3Trace $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 echo PHP_EOL inside the inner loop.
Mistakes that commonly break Repeated Number Triangle Pattern patterns.
Each digit lands on its own line — you get a column, not a triangle.
→ Use echo $i for digits; echo PHP_EOL only after the inner loop.
$j instead of $iecho $j builds Program 5’s ascending digits (1, 12, 123) instead of repeated digits (1, 22, 333).
→ Always echo $i inside the inner loop for this pattern.
Using $j <= $rows on every row prints the same length each time — a rectangle, not a triangle.
→ Keep for ($j = 1; $j <= $i; $j++) so row length equals $i.
Program 10 repeats digits while counting the outer loop down (5, 44, 333). Program 9 counts up (1, 22, 333).
→ Keep for ($i = 1; $i <= $rows; $i++) for this ascending repeat triangle.
Letters or empty input leave $rows unset.
→ Call is_numeric($input) and re-prompt on failure.
Check these inputs before calling the solution done.
Output is just 1 on one line.
Outer loop never runs — print nothing or show a message.
$rows < 0Treat as invalid; re-prompt instead of silent empty output.
Two rows: 1 and 22.
Unchecked fgets(STDIN) input leaves $rows unset — call is_numeric($input) first.
Each row prints $i digits — total work grows as n(n+1)/2.
Try these variations to lock in the pattern.
1, 12, 123 (echo $j)for (i = rows; i >= 1; i--)5, 44, 333, 2222, 111115, 44, 333, 2222, 11111echo $i . " " between digits$i = 1..$rows. Inner loop: $j = 1..$i with echo $i.echo stays on the line; echo PHP_EOL advances — mix them carefully.$rows > 0 for interactive programs; $rows = 1 should print a single 1.$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 echo $i, then echo PHP_EOL.
| Program | Time | Extra space |
|---|---|---|
| Nested loops (Examples 1–3) | O(n²) | O(1) |
| Spaced output (Example 3) | O(n²) | O(1) |
The Repeated Number Triangle Pattern is a compact nested-loop lesson: outer loop raises $i while the inner loop echoes digit $i exactly $i times. 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 digit $i exactly $i times — keep echo $i for digits and echo PHP_EOL for the row break.
for ($i = 1; $i <= $rows; $i++) in the outer loopfor ($j = 1; $j <= $i; $j++) repeats digit $iecho $i for digits and echo PHP_EOL after each row$rows ≥ 1 for interactive programsis_numeric($input) before using $rowsecho PHP_EOL inside the inner digit loop$j (Program 5) or reverse the outer loop (Program 10) when you meant repeated ascending digitsecho PHP_EOL after each row — the next row continues on the same line$rows = 1 edge casePrint the pattern the beginner-friendly way.
Row $i prints $i × $i
Repeats digit $i
$j = 1..$i, echo $i
Ends each row
ShapeO(n²) time
AnalysisOuter loop sets row digit $i; inner loop prints $i exactly $i times — 1, 22, 333, … O(n²) for $n rows.
Move on to the descending repeating number triangle in the PHP number-pattern series.
12 people found this page helpful