Shape Rule
digit i repeats exactly i times
Row rows prints rows repeated rows times, then each next row repeats its digit fewer times down to a single 1.

The inverted repeating number triangle widens first then shrinks: digit i repeats exactly i times — nested loops, echo vs PHP_EOL, and a clear visual result. This tutorial covers the shape rule, loop structure, a live preview, algorithm steps, worked PHP examples, edge cases, and complexity.
digit i repeats exactly i times
Row rows prints rows repeated rows times, then each next row repeats its digit fewer times down to a single 1.
Rows
for ($i = $rows; $i >= 1; $i--) walks each line from the longest down to one digit.
Digits
for ($j = 1; $j <= $i; $j++) prints digit $i exactly $i times on that row.
Same line / next line
Repeated digits use echo $i; end each row with echo PHP_EOL;.
1–20 rows
Pick a row count and draw the inverted repeating number triangle instantly in the browser.
Complexity
Total digit prints still = n(n+1)/2; extra memory stays O(1).
An inverted repeating number triangle pattern starts with the widest row and loses one repeat each line as the digit decreases. Each row prints the same digit multiple times; the repeat count shrinks while the digit value shrinks.
In PHP you usually solve it with two nested for loops: the outer loop picks the digit, the inner loop repeats it with echo $i, then echo PHP_EOL; moves to the next line.
It pairs naturally with Program 10 in PHP courses. Once nested loops and echo click, pyramids, diamonds, and hollow shapes become much easier.
On row i, print digit i exactly i times.
Outer picks the digit; inner controls how many times it repeats.
echo $i in the inner loop; echo PHP_EOL; after.
Gateway to Program 10 (5, 44, 333, …) and Program 12.
In short: for each row i from rows down to 1, repeat echo $i exactly i times, then call echo PHP_EOL;.
Given a positive integer rows, print an inverted repeating number triangle: row i repeats digit i exactly i times, with the outer loop counting from rows down to 1.
// First 5 rows (conceptual shape)
// 55555
// 4444
// 333
// 22
// 1 | Item | Type | Description |
|---|---|---|
rows | int | Number of triangle lines to print (typically ≥ 1). |
| Printed output | text | Each row repeats one digit; the top row has rows copies of rows, the bottom row has a single 1. |
for i from rows down to 1:
repeat i times:
print i (no newline)
print newline | Approach | Idea | Best for |
|---|---|---|
| Nested loops | Outer digit + inner repeats | Learning and interviews |
str_repeat((string) $i, $i) in inner loop | Print a full repeated row with str_repeat | Leaner C style once loops are understood |
| Goal | Pattern |
|---|---|
| Walk each row | for ($i = $rows; $i >= 1; $i--) |
Repeat digit i | for ($j = 1; $j <= $i; $j++) echo $i; |
| End the row | echo PHP_EOL; |
| One-line row shortcut | str_repeat((string) $i, $i) repeated per row |
| Program 10 variant | for ($j = $rows; $j >= $i; $j--) echo $i; (descending repeats) |
Same triangle — different ways to emit characters.
same linePrints a digit without moving to the next line
new lineEnds the current row after all digits are printed
one digitWrites digit i when i is 1..9 — no format string
loops firstMaster nested loops before the str_repeat shortcut
Reach for this triangle when teaching or testing nested-loop basics.
Most PHP pattern series start here before pyramids and diamonds.
Outer/inner bound practice with an immediate visual check.
Combine loops with fgets(STDIN) for a flexible row count.
Compare Program 10 (5, 44, 333, …) and Program 12 next.
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.
Choose a row count between 1 and 20 and draw the inverted repeating number triangle in the browser.
Three complete PHP programs — fixed row count, CLI input, and a str_repeat shortcut. Click View Output to reveal sample console results.
Print five rows of the inverted repeating number triangle with nested loops.
rows = 5Hard-coded height — outer picks digit, inner repeats it i times.
<?php
$rows = 5;
for ($i = $rows; $i >= 1; $i--) {
for ($j = 1; $j <= $i; $j++) {
echo $i;
}
echo PHP_EOL;
} When i = 5, the inner loop runs five times and prints 55555. When i = 4, it prints 4444, and so on until i = 1 prints 1. echo PHP_EOL; after the inner loop starts the next row.
Let the user choose the height at runtime.
Read the row count with (int) trim(fgets(STDIN)) (check is_numeric() in real apps).
<?php
echo "Enter the number of rows: ";
$rows = (int) trim(fgets(STDIN));
for ($i = $rows; $i >= 1; $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. Non-numeric input casts to 0 without validation — check is_numeric(trim($line)) in safer labs.
Same shape without an explicit inner repeat loop.
str_repeat((string) $i, $i)Build each row with str_repeat((string) $i, $i), then end with echo PHP_EOL;.
<?php
$rows = 5;
for ($i = $rows; $i >= 1; $i--) {
echo str_repeat((string) $i, $i) . PHP_EOL;
} str_repeat((string) $i, $i) creates a string of repeated digit i. Great once you understand the nested-loop idea; keep the two-loop version for exams that ask you to show both bounds.
Set $rows = 5; and use fgets(STDIN) when reading input from the terminal.
for ($i = $rows; $i >= 1; $i--) picks the digit; the inner loop prints it $i times.
for ($j = 1; $j <= $i; $j++) repeats digit $i exactly $i times with echo $i;.
echo PHP_EOL; ends the row so the next outer iteration starts fresh.
Total digit prints: 1+2+…+n = n(n+1)/2 — O(n²) time, O(1) extra memory.
rows = 4Trace each outer-loop value of i and count how many times the inner loop prints digit i.
i | Inner j range | Repeats | Printed row |
|---|---|---|---|
4 | 1..4 | 4 | 4444 |
3 | 1..3 | 3 | 333 |
2 | 1..2 | 2 | 22 |
1 | 1..1 | 1 | 1 |
Total digit prints: 1 + 2 + 3 + 4 = 10 = 4×5/2.
Where this tiny pattern (and its loop structure) shows up beyond the homework prompt.
Clearest visual proof that outer and inner bounds interact.
Example: change j <= i and watch the shape change.
Foundation for inverted, pyramid, diamond, and hollow variants.
Example: Program 10 uses for ($j = $rows; $j >= $i; $j--) so repeats grow as the digit shrinks.
Practice echo vs PHP_EOL without complex math.
Example: put echo PHP_EOL; inside the inner loop by mistake.
Swap digits for letters, stars, or spaced output once the loop works.
Example: print i + " " for spaced repeated digits on each row.
Triangular totals make O(n²) concrete for beginners.
Example: count printed digits for n = 10 still → 55.
Pair the pattern with fgets(STDIN) 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 C 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: learn the nested-loop version first; treat str_repeat((string) $i, $i) as a polish shortcut afterward.
Small habits that keep number-pattern code clean.
Use rows (or n) and keep i/j for row/column — or rename to row/col.
Avoid crashes when the user types letters instead of a number.
Only call echo PHP_EOL; after the inner loop finishes the row.
for ($j = 1; $j <= $i; $j++) with echo $i; repeats digit $i exactly $i times.
Trace rows = 3 on paper before coding larger demos.
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 inverted repeating number patterns.
Each repeated digit lands on its own line — you get a column, not a triangle.
→ Use echo $i for repeats; echo PHP_EOL; only after the inner loop.
j <= rows prints a rectangle; wrong outer bounds flatten or invert the shape.
→ For this shape, keep j <= i.
Omitting echo PHP_EOL; glues every repeat onto one endless line.
→ Always end the row after the inner loop.
Letters or empty input throw undefined rows.
→ Check is_numeric(trim($line)) and re-prompt on failure.
Switching to i = 0 without adjusting the inner bound prints an empty first row or wrong counts.
→ If 0-based, print i with wrong inner bound (e.g. j <= i + 1).
Check these inputs before calling the solution done.
Output is just one copy of rows on one line.
Outer loop never runs — print nothing or show a message.
rows < 0Treat as invalid; re-prompt instead of silent empty output.
Output grows as n²/2 characters — fine for labs, noisy for huge n.
Unchecked CLI leaves rows unset — call is_numeric(trim($line)) first.
Use j <= i so row i repeats exactly i times.
Try these variations to lock in the pattern.
for ($i = $rows; $i >= 1; $i--) as outer loopis_numeric() until $rows >= 1echo $i between repeated digitsn(n+1)/2 — hence O(n²) time.echo $i; stays on the line; echo PHP_EOL; advances — mix them carefully.rows > 0 for interactive programs; rows = 1 should print rows copies of the top digit.Quick Takeaway: outer loop picks the row, inner loop repeats digit i, then break the line — that is the whole pattern.
| Program | Time | Extra space |
|---|---|---|
| Nested loops (Examples 1–2) | O(rows²) | O(1) |
str_repeat((string) $i, $i) (Example 3) | O(rows²) | O(rows) per row string (temporary) |
The inverted repeating number triangle pattern is a small nested-loop exercise with lasting payoff: row/column thinking, echo vs PHP_EOL, and O(n²) intuition. Master the classic two-loop version, then optionally shorten rows with str_repeat((string) $i, $i).
Practice the three examples above, then continue to Program 12 for the next pattern in the series.
Row i repeats digit i — keep echo $i for each copy and echo PHP_EOL; for the break, and validate row counts when reading input.
echo $i for repeats and echo PHP_EOL; after each rowrows ≥ 1 for interactive programsis_numeric() before using $rowsecho PHP_EOL; inside the inner repeat loopj >= i when you meant Program 10 insteadrows = 1 edge casePrint the triangle the beginner-friendly way.
Row i repeats digit i
DefinitionPicks the digit each row
CodeRepeats digit with echo $i
CodeEnds each row
I/OO(n²) time
AnalysisRow digit i repeats exactly i times. The outer loop counts down from rows, so the first row is widest (rows copies of rows) and each line shortens — still O(n²) total prints.
Next up — ascending repeating shrinking pattern in the series.
12 people found this page helpful