Pattern programs are one of the best ways to understand loops in Python.

In pattern programs, we normally use:

• for loops
• Nested for loops
• range()
• print()
• end parameter
• Row and column logic

In this part, we will learn the first three patterns:

Pattern-1 → Square Star Pattern

Pattern-2 → Same Row Number Pattern

Pattern-3 → Increasing Column Number Pattern

Understanding these basic patterns is important because many advanced patterns are created using the same row and column concepts.

In Pattern-1, we print a square made of * symbols.

If the user enters:

10

then the program prints:

• 10 rows
• 10 stars in every row

Rows    = n
Columns = n

Therefore, for n = 10, we get a 10 × 10 star pattern.

* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *
* * * * * * * * * *

Let's understand the program line by line.

Line 1

n=int(input("Enter the number of rows: "))

input() accepts the number of rows from the user.

By default, input() returns a string. Therefore, int() converts that value into an integer.

For example:

Enter the number of rows: 10

n = 10

Line 2

for i in range(1,n+1):

This loop controls the number of rows.

If:

n = 10

then:

range(1,n+1)

becomes

range(1,11)

The values of i are:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Therefore, the loop executes 10 times.

Line 3

print("* "*n)

The string:

"* "

contains one star followed by one space.

Multiplying this string by n repeats it n times.

For example:

"* " * 5

produces:

* * * * *

For n = 10:

"* " * 10

produces 10 stars.

Because the print() statement executes once for every iteration of the outer loop, the same row is printed 10 times.

Python allows us to multiply a string by an integer.

Example:

print("* " * 3)

Output:

* * *

Similarly:

print("* " * 5)

Output:

* * * * *

Therefore:

"* " * n

means:

Print "* " n times

The loop controls how many rows are printed.

for i in range(1,n+1):

For n = 10:

Iteration	i	Output
1	1	10 Stars
2	2	10 Stars
3	3	10 Stars
4	4	10 Stars
5	5	10 Stars
6	6	10 Stars
7	7	10 Stars
8	8	10 Stars
9	9	10 Stars
10	10	10 Stars

Notice that i is not used inside print().

Its purpose is only to repeat the statement n times.

Suppose:

n = 3

The loop becomes:

for i in range(1,4):

Execution:

i	Expression	Printed Row
1	"* " * 3	* * *
2	"* " * 3	* * *
3	"* " * 3	* * *

Final output:

* * *
* * *
* * *

START
  │
  ▼
Read n
  │
  ▼
i = 1
  │
  ▼
Is i <= n?
  │
  ├── No ─────────────► END
  │
 Yes
  │
  ▼
Print "* " n times
  │
  ▼
Move to next i
  │
  └──────────────► Check i <= n again

• n represents the number of rows.
• The for loop executes n times.
• "* " * n creates n stars.
• Every row contains the same number of stars.
• The result is a square star pattern.
• This pattern does not require a nested loop because Python string multiplication is used.

Pattern-2 prints numbers in a square format.

The important rule is:

Row 1 → print 1
Row 2 → print 2
Row 3 → print 3
...
Row n → print n

Every row contains n values.

Therefore:

Row Number = Printed Number

This pattern introduces the concept of nested loops.

1 1 1 1 1 1 1 1 1 1
2 2 2 2 2 2 2 2 2 2
3 3 3 3 3 3 3 3 3 3
4 4 4 4 4 4 4 4 4 4
5 5 5 5 5 5 5 5 5 5
6 6 6 6 6 6 6 6 6 6
7 7 7 7 7 7 7 7 7 7
8 8 8 8 8 8 8 8 8 8
9 9 9 9 9 9 9 9 9 9
10 10 10 10 10 10 10 10 10 10

This program contains two loops:

Outer Loop → Controls Rows

Inner Loop → Controls Columns

The structure is:

for i in range(1,n+1):       ← Rows

    for j in range(1,n+1):   ← Columns

        print(i,end=" ")

Therefore:

i → Row Number
j → Column Number

The outer loop is:

for i in range(1,n+1):

It controls the rows.

For n = 10, i takes the values:

1
2
3
4
5
6
7
8
9
10

Each value represents one row.

i = 1 → First row
i = 2 → Second row
i = 3 → Third row
...
i = 10 → Tenth row

The inner loop is:

for j in range(1,n+1):

It controls the number of columns.

For every row, the inner loop executes n times.

If n = 10:

j = 1,2,3,4,5,6,7,8,9,10

Therefore, each row contains 10 values.

The important statement is:

print(i,end=" ")

We print i, not j.

Since i represents the current row number, the same number is printed throughout that row.

For example:

i = 1

The inner loop executes 10 times:

print(1)
print(1)
print(1)
...

Therefore:

1 1 1 1 1 1 1 1 1 1

When:

i = 2

we get:

2 2 2 2 2 2 2 2 2 2

Normally:

print(i)

moves the cursor to the next line after printing.

But this pattern needs multiple values on the same line.

Therefore, we use:

print(i,end=" ")

The end=" " tells Python:

After printing the value,
do not move to the next line.
Add one space instead.

This allows all column values to remain on the same row.

After the inner loop finishes, we use:

print()

This moves the cursor to the next line.

The flow is:

Print all columns of Row 1
          │
          ▼
       print()
          │
          ▼
Move to Row 2

Without this final print(), all numbers would continue on the same line.

Suppose:

n = 3

The program becomes logically:

i = 1
    j = 1 → print 1
    j = 2 → print 1
    j = 3 → print 1

i = 2
    j = 1 → print 2
    j = 2 → print 2
    j = 3 → print 2

i = 3
    j = 1 → print 3
    j = 2 → print 3
    j = 3 → print 3

Output:

1 1 1
2 2 2
3 3 3

i	j Values	Printed Value	Row Output
1	1, 2, 3	i = 1	1 1 1
2	1, 2, 3	i = 2	2 2 2
3	1, 2, 3	i = 3	3 3 3

START
  │
  ▼
Read n
  │
  ▼
Start Outer Loop
i = 1 to n
  │
  ▼
Start Inner Loop
j = 1 to n
  │
  ▼
Print i
  │
  ▼
More columns?
  │
  ├── Yes ──► Next j ──► Print i
  │
  No
  │
  ▼
print()
  │
  ▼
Move to Next Row
  │
  ▼
More rows?
  │
  ├── Yes ──► Next i
  │
  No
  │
  ▼
 END

• The outer loop controls rows.
• The inner loop controls columns.
• Both loops execute n times.
• i represents the row number.
• j represents the column iteration.
• The program prints i, so the same number appears throughout each row.
• end=" " keeps numbers on the same line.
• print() moves execution to the next output line after one row is completed.

Pattern-3 also creates a square number pattern.

However, instead of repeating the row number, every row prints:

1 2 3 4 ... n

For n = 10, every row contains:

1 2 3 4 5 6 7 8 9 10

The important rule is:

Printed Number = Column Number

1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10

This program is very similar to Pattern-2.

The main difference is:

Pattern-2:

print(i,end=" ")


Pattern-3:

print(j,end=" ")

This small change produces a completely different pattern.

In Pattern-3:

i → controls rows

j → controls columns and is also printed

The outer loop is:

for i in range(1,n+1):

Its job is to control the number of rows.

For n = 10:

i = 1 to 10

Therefore, 10 rows are generated.

Notice that i is not printed in this pattern.

The inner loop is:

for j in range(1,n+1):

For every row, j takes values from 1 to n.

For n = 10:

j = 1
j = 2
j = 3
j = 4
j = 5
j = 6
j = 7
j = 8
j = 9
j = 10

Because the program prints j:

print(j,end=" ")

each row becomes:

1 2 3 4 5 6 7 8 9 10

The inner loop always starts again from:

j = 1

whenever a new outer-loop iteration starts.

Consider:

i = 1

j → 1 2 3 4 5

After the first row finishes, the outer loop moves to:

i = 2

The inner loop starts again:

j → 1 2 3 4 5

Therefore, every row contains the same increasing number sequence.

Suppose:

n = 3

Outer Loop — i = 1

j = 1 → print 1
j = 2 → print 2
j = 3 → print 3

First row:

1 2 3

Outer Loop — i = 2

The inner loop starts again:

j = 1 → print 1
j = 2 → print 2
j = 3 → print 3

Second row:

1 2 3

Outer Loop — i = 3

j = 1 → print 1
j = 2 → print 2
j = 3 → print 3

Third row:

1 2 3

Final output:

1 2 3
1 2 3
1 2 3

Row (i)	j Values	Values Printed
1	1, 2, 3	1 2 3
2	1, 2, 3	1 2 3
3	1, 2, 3	1 2 3

START
  │
  ▼
Read n
  │
  ▼
Start Outer Loop
i = 1 to n
  │
  ▼
Start Inner Loop
j = 1 to n
  │
  ▼
Print j
  │
  ▼
Next j
  │
  ▼
Is inner loop complete?
  │
  ├── No ─────► Print next j
  │
 Yes
  │
  ▼
print()
  │
  ▼
Move to next row
  │
  ▼
Is outer loop complete?
  │
  ├── No ─────► Start j from 1 again
  │
 Yes
  │
  ▼
 END

Pattern-2 and Pattern-3 use almost the same nested-loop structure.

The important difference is the variable being printed.

Feature	Pattern-2	Pattern-3
Outer Loop	i	i
Inner Loop	j	j
Printed Variable	i	j
Row 1	1 1 1	1 2 3
Row 2	2 2 2	1 2 3
Row 3	3 3 3	1 2 3

Main Rule

print(i) → Pattern depends on ROW

print(j) → Pattern depends on COLUMN

This is one of the most important concepts to understand before moving to more advanced pattern programs.

• The outer loop controls rows.
• The inner loop controls columns.
• j starts from 1 for every new row.
• The program prints j, so values increase from left to right.
• Every row contains the same number sequence.
• end=" " keeps the values on the same row.
• The empty print() starts the next row.

Pattern	Type	Main Logic
Pattern-1	Square Star Pattern	"* " * n
Pattern-2	Same Row Number	print(i,end=" ")
Pattern-3	Increasing Column Numbers	print(j,end=" ")

The first three patterns introduce an important idea:

                  PATTERN PROGRAM
                        │
              ┌─────────┴─────────┐
              │                   │
              ▼                   ▼
            Rows                Columns
              │                   │
              ▼                   ▼
         Outer Loop           Inner Loop
              │                   │
              ▼                   ▼
              i                   j

In most pattern programs:

i = Row

j = Column

Then we decide what should be printed by creating an expression using:

i
j
n

For example:

print(i) → Row-based pattern

print(j) → Column-based pattern

Understanding this concept will make the upcoming number, alphabet, triangle, pyramid and reverse patterns much easier.

In Part 1A, we completed Pattern-1, Pattern-2 and Pattern-3.

Pattern-1

* * *
* * *
* * *

Uses string multiplication:

"* " * n

Pattern-2

1 1 1
2 2 2
3 3 3

Prints the outer-loop variable:

print(i,end=" ")

Pattern-3

1 2 3
1 2 3
1 2 3

Prints the inner-loop variable:

print(j,end=" ")

Golden Rule

Outer Loop → Rows
Inner Loop → Columns

i → Row
j → Column

In Part 1B, we continue with square patterns.

We will learn:

Pattern-4 → Reverse Number Square
Pattern-5 → Same Row Alphabet Square
Pattern-6 → Increasing Alphabet Square

The main concepts are:

• Reverse range()
• Nested loops
• chr()
• ASCII values
• Row-based alphabet patterns
• Column-based alphabet patterns

This pattern prints numbers from n to 1 in every row.

For n = 10:

10 9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1
10 9 8 7 6 5 4 3 2 1

The important logic is:

Rows    → 1 to n
Columns → n to 1

Outer Loop

for i in range(1,n+1):

The outer loop controls the rows.

Inner Loop

for j in range(n,0,-1):

This is a reverse loop.

For n = 10:

j = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

The third argument:

-1

means decrease the value by one after every iteration.

Printing

print(j,end=" ")

Since j is printed, numbers appear in reverse order.

The syntax of range() is:

range(start, stop, step)

Here:

range(n, 0, -1)

start = n
stop  = 0
step  = -1

The stop value is excluded.

Therefore, for n = 5:

range(5,0,-1)

5, 4, 3, 2, 1

i = 1
j = 3 → print 3
j = 2 → print 2
j = 1 → print 1

i = 2
j = 3 → print 3
j = 2 → print 2
j = 1 → print 1

i = 3
j = 3 → print 3
j = 2 → print 2
j = 1 → print 1

Output:

3 2 1
3 2 1
3 2 1

Read n
  │
  ▼
Outer Loop: i = 1 to n
  │
  ▼
Inner Loop: j = n to 1
  │
  ▼
Print j
  │
  ▼
j = j - 1
  │
  ▼
Inner Loop Complete?
  │
  ├── No → Continue
  │
 Yes
  ▼
print()
  │
  ▼
Next Row

Pattern-5 prints one alphabet repeatedly in every row.

A A A A A A A A A A
B B B B B B B B B B
C C C C C C C C C C
D D D D D D D D D D
E E E E E E E E E E
F F F F F F F F F F
G G G G G G G G G G
H H H H H H H H H H
I I I I I I I I I I
J J J J J J J J J J

The rule is:

Row 1 → A
Row 2 → B
Row 3 → C
...
Row 10 → J

Python's chr() converts an integer Unicode code point into its corresponding character.

For uppercase English letters:

Expression	Value	Character
chr(65)	65	A
chr(66)	66	B
chr(67)	67	C
chr(68)	68	D

The program uses:

chr(64+i)

Therefore:

i = 1 → chr(65) → A
i = 2 → chr(66) → B
i = 3 → chr(67) → C

i = 1
chr(64+1) = chr(65) = A
→ A A A

i = 2
chr(64+2) = chr(66) = B
→ B B B

i = 3
chr(64+3) = chr(67) = C
→ C C C

Output:

A A A
B B B
C C C

Character = chr(64 + i)

Since the formula uses i, the alphabet depends on the row number.

i → Row
     │
     ▼
64 + i
     │
     ▼
chr()
     │
     ▼
Alphabet

Pattern-6 prints increasing alphabets from left to right.

Every row follows:

A B C D E F G H I J

The same sequence is repeated for every row.

The main expression is:

chr(64+j)

Here the alphabet depends on j.

j = 1 → A
j = 2 → B
j = 3 → C
...
j = 10 → J

Since the inner loop restarts for every row, each row again starts from A.

i = 1:
j = 1 → A
j = 2 → B
j = 3 → C

i = 2:
j = 1 → A
j = 2 → B
j = 3 → C

i = 3:
j = 1 → A
j = 2 → B
j = 3 → C

Output:

A B C
A B C
A B C

Pattern	Expression	Depends On
Pattern-5	chr(64+i)	Row
Pattern-6	chr(64+j)	Column

chr(64+i) → Row-based alphabet

chr(64+j) → Column-based alphabet

Pattern	Main Logic
4	range(n,0,-1)
5	chr(64+i)
6	chr(64+j)

Part 1B introduces two especially important concepts: reverse ranges and converting numbers into alphabet characters using chr().

Part 3 introduces right-aligned and right-shifted pattern programs.

We will learn:

Pattern-21 → Decreasing Repeated Reverse Alphabets
Pattern-22 → Decreasing Reverse Alphabet Sequence

Pattern-23 → Right-Aligned Star Triangle without Spaces
Pattern-24 → Right-Aligned Star Triangle with Spaces
Pattern-25 → Right-Aligned Repeated Number Triangle
Pattern-26 → Right-Aligned Increasing Number Triangle
Pattern-27 → Right-Aligned Repeated Alphabet Triangle
Pattern-28 → Right-Aligned Increasing Alphabet Triangle

Pattern-29 → Right-Shifted Decreasing Star Triangle
Pattern-30 → Right-Shifted Decreasing Repeated Number Triangle

The most important new concept is leading spaces.

Increasing right-aligned pattern:

Spaces = n - i
Values = i

As the row number increases:

Spaces ↓
Values ↑

Pattern-21 prints alphabets from J to A.

The number of characters also decreases in every row.

J J J J J J J J J J
I I I I I I I I I
H H H H H H H H
G G G G G G G
F F F F F F
E E E E E
D D D D
C C C
B B
A

For every row:

Character Count = n + 1 - i
Character       = chr(64 + n + 1 - i)

Outer Loop

for i in range(1,n+1):

The outer loop controls the rows.

Inner Loop

for j in range(1,n+2-i):

The actual number of iterations is:

n + 1 - i

Therefore, the number of characters decreases row by row.

Character Formula

chr(64+n+1-i)

For n = 10:

i = 1 → chr(64+10+1-1)
      → chr(74)
      → J

i = 2 → chr(73)
      → I

i = 3 → chr(72)
      → H

...

i = 10 → chr(65)
       → A

i	Character	Times Printed	Output
1	E	5	E E E E E
2	D	4	D D D D
3	C	3	C C C
4	B	2	B B
5	A	1	A

Pattern-22 prints reverse alphabets in each row.

J I H G F E D C B A
J I H G F E D C B
J I H G F E D C
J I H G F E D
J I H G F E
J I H G F
J I H G
J I H
J I
J

The first alphabet always starts from J when n = 10.

The number of alphabets decreases after every row.

The character formula is:

chr(65+n-j)

For n = 10:

j = 1 → chr(65+10-1)
      → chr(74)
      → J

j = 2 → chr(73)
      → I

j = 3 → chr(72)
      → H

Because the expression depends on j, the character changes inside the row.

Pattern	Formula	Depends On	Result
21	chr(64+n+1-i)	Row	Same alphabet repeated
22	chr(65+n-j)	Column	Reverse alphabet sequence

Pattern-21:

E E E E E
D D D D
C C C
B B
A


Pattern-22:

E D C B A
E D C B
E D C
E D
E

Starting from Pattern-23, spaces are printed before the actual pattern.

The basic formula is:

" " * (n-i)

For n = 5:

Row i	Leading Spaces	Pattern Size
1	4	1
2	3	2
3	2	3
4	1	4
5	0	5

So:

Leading Spaces = n - i
Pattern Size   = i

Pattern-23 creates a right-aligned increasing star triangle.

         *
        **
       ***
      ****
     *****
    ******
   *******
  ********
 *********
**********

The stars do not contain spaces between them.

The statement:

" " * (n-i)

generates the leading spaces.

The statement:

"*" * i

generates the stars.

Therefore:

Spaces = n - i
Stars  = i

For n = 5:

i = 1 → 4 spaces + 1 star
i = 2 → 3 spaces + 2 stars
i = 3 → 2 spaces + 3 stars
i = 4 → 1 space  + 4 stars
i = 5 → 0 spaces + 5 stars

i = 1
" " * 4 + "*" * 1
    *

i = 2
" " * 3 + "*" * 2
   **

i = 3
" " * 2 + "*" * 3
  ***

i = 4
" " * 1 + "*" * 4
 ****

i = 5
" " * 0 + "*" * 5
*****

Pattern-24 is similar to Pattern-23, but every star is followed by a space.

         *
        * *
       * * *
      * * * *
     * * * * *
    * * * * * *
   * * * * * * *
  * * * * * * * *
 * * * * * * * * *
* * * * * * * * * *

First, spaces are printed:

print(" "*(n-i),end="")

Then the inner loop prints stars:

for j in range(1,i+1):
    print("*",end=" ")

The number of stars equals i.

Spaces = n - i
Stars  = i

Pattern	Star Logic	Appearance
23	"*"*i	Stars joined together
24	print("*",end=" ")	Space after every star

Pattern-23 → *****

Pattern-24 → * * * * *

         1
        2 2
       3 3 3
      4 4 4 4
     5 5 5 5 5
    6 6 6 6 6 6
   7 7 7 7 7 7 7
  8 8 8 8 8 8 8 8
 9 9 9 9 9 9 9 9 9
10 10 10 10 10 10 10 10 10 10

The row number is repeated according to the current row.

Row 1  → 1 once
Row 2  → 2 twice
Row 3  → 3 three times
...

Leading spaces:

" " * (n-i)

The number string is:

str(i) + " "

It is repeated i times:

(str(i)+" ") * i

For example:

i = 3

str(i) + " "
→ "3 "

"3 " * 3
→ "3 3 3 "

The document contains an additional print() after this statement, so the source program has been preserved exactly.

         1
        1 2
       1 2 3
      1 2 3 4
     1 2 3 4 5
    1 2 3 4 5 6
   1 2 3 4 5 6 7
  1 2 3 4 5 6 7 8
 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 10

The leading-space formula remains:

n - i

The inner loop is:

range(1,i+1)

and prints:

j

Therefore:

i = 1 → 1
i = 2 → 1 2
i = 3 → 1 2 3
i = 4 → 1 2 3 4

The pattern is the right-aligned version of Pattern-11.

         A
        B B
       C C C
      D D D D
     E E E E E
    F F F F F F
   G G G G G G G
  H H H H H H H H
 I I I I I I I I I
J J J J J J J J J J

The alphabet depends on the row:

chr(64+i)

Therefore:

i = 1 → A
i = 2 → B
i = 3 → C
...

The expression:

(chr(64+i)+" ")*i

repeats the current row alphabet i times.

i = 3

chr(67) = C

("C" + " ") * 3

C C C

The document also places an additional print() after the row statement, so it is retained here as provided.

         A
        A B
       A B C
      A B C D
     A B C D E
    A B C D E F
   A B C D E F G
  A B C D E F G H
 A B C D E F G H I
A B C D E F G H I J

Leading spaces:

" " * (n-i)

Number of characters:

i

The alphabet depends on j:

chr(64+j)

Therefore:

j = 1 → A
j = 2 → B
j = 3 → C
j = 4 → D

For i = 4:

A B C D

Pattern-28 is the right-aligned version of Pattern-13.

Pattern-29 reverses the direction used in the previous right-aligned patterns.

* * * * *
 * * * *
  * * *
   * *
    *

Now:

Spaces increase
Stars decrease

The leading-space formula is:

i - 1

The star-count formula is:

n + 1 - i

For n = 5:

i	Spaces	Stars
1	0	5
2	1	4
3	2	3
4	3	2
5	4	1

Therefore:

Spaces = i - 1
Stars  = n + 1 - i

i = 1
spaces = 0
stars  = 5
→ * * * * *

i = 2
spaces = 1
stars  = 4
→  * * * *

i = 3
spaces = 2
stars  = 3
→   * * *

i = 4
spaces = 3
stars  = 2
→    * *

i = 5
spaces = 4
stars  = 1
→     *

5 5 5 5 5
 4 4 4 4
  3 3 3
   2 2
    1

The number decreases from n to 1.

The number of repetitions also decreases.

The leading spaces are:

i - 1

The current number is:

n + 1 - i

The same formula determines how many times the number is repeated:

(str(n+1-i)+" ")*(n+1-i)

For n = 5:

i = 1

Number = 5 + 1 - 1
       = 5

Repetitions = 5

5 5 5 5 5

i = 2

Number = 5 + 1 - 2
       = 4

Repetitions = 4

 4 4 4 4

i = 5

Number = 5 + 1 - 5
       = 1

Repetitions = 1

    1

Patterns 23–28 follow the same basic right-aligned structure.

for i in range(1,n+1):

    print(" "*(n-i),end="")

    # Print i values

The formulas are:

Spaces = n - i
Values = i

Only the value being printed changes.

Pattern	Printed Value
23	Star without spacing
24	Star with spacing
25	Current row number i
26	Column number j
27	chr(64+i)
28	chr(64+j)

Patterns 29–30 use the opposite movement.

Spaces = i - 1
Values = n + 1 - i

Therefore:

Row increases
     │
     ├── Spaces increase
     │
     └── Values decrease

Row	Spaces	Values
1	0	n
2	1	n-1
3	2	n-2
...	...	...
n	n-1	1

Type	Spaces	Values
Increasing	n-i	i
Decreasing	i-1	n+1-i

Increasing

Spaces: 4 3 2 1 0
Values: 1 2 3 4 5

Decreasing

Spaces: 0 1 2 3 4
Values: 5 4 3 2 1

These two formulas are very important for solving many upcoming pattern programs.

Pattern	Space Logic	Value / Loop Logic
21	None	chr(64+n+1-i)
22	None	chr(65+n-j)
23	n-i	"*"*i
24	n-i	range(1,i+1) stars
25	n-i	(str(i)+" ")*i
26	n-i	j
27	n-i	(chr(64+i)+" ")*i
28	n-i	chr(64+j)
29	i-1	"* "*(n+1-i)
30	i-1	(str(n+1-i)+" ")*(n+1-i)

                         START
                           │
                           ▼
                        Read n
                           │
                           ▼
                    Outer Loop (i)
                           │
                           ▼
                 Decide Pattern Type
                           │
              ┌────────────┴────────────┐
              │                         │
              ▼                         ▼
           Increasing                Decreasing
        Right-Aligned              Right-Shifted
              │                         │
              ▼                         ▼
       Spaces = n-i              Spaces = i-1
       Values = i                Values = n+1-i
              │                         │
              └────────────┬────────────┘
                           │
                           ▼
                    Print Spaces
                           │
                           ▼
                    Print Pattern
                           │
             ┌─────────────┼─────────────┐
             ▼             ▼             ▼
           Stars        Numbers       Alphabets
             │             │             │
             └─────────────┴─────────────┘
                           │
                           ▼
                      Next Line
                           │
                           ▼
                       Next Row
                           │
                           ▼
                          END

• " "*(n-i) creates decreasing leading spaces.
• " "*(i-1) creates increasing leading spaces.
• For an increasing right-aligned triangle, use n-i spaces and i values.
• For a decreasing right-shifted triangle, use i-1 spaces and n+1-i values.
• chr(64+n+1-i) creates a decreasing row-based alphabet.
• chr(65+n-j) creates reverse alphabets inside a row.
• chr(64+i) creates an alphabet based on the row.
• chr(64+j) creates alphabets based on columns.
• String multiplication can be used instead of an inner loop when the same value must be repeated.
• end="" prevents Python from moving to the next line while constructing the current row.

Pattern	Pattern Type	Main Concept
21	Decreasing alphabet	Repeated reverse row alphabet
22	Decreasing alphabet	Reverse alphabet sequence
23	Increasing right-aligned	Joined stars
24	Increasing right-aligned	Spaced stars
25	Increasing right-aligned	Repeated row number
26	Increasing right-aligned	Increasing numbers
27	Increasing right-aligned	Repeated row alphabet
28	Increasing right-aligned	Increasing alphabets
29	Decreasing right-shifted	Stars
30	Decreasing right-shifted	Repeated numbers

                RIGHT-ALIGNED PATTERNS
                         │
          ┌──────────────┴──────────────┐
          │                             │
          ▼                             ▼
       Increasing                    Decreasing
          │                             │
          ▼                             ▼
   Spaces = n-i                  Spaces = i-1
   Values = i                    Values = n+1-i
          │                             │
          ▼                             ▼
 Spaces decrease                 Spaces increase
 Values increase                 Values decrease
          │                             │
          └──────────────┬──────────────┘
                         │
                         ▼
                 Choose What to Print
                         │
             ┌───────────┼───────────┐
             ▼           ▼           ▼
           Stars       Numbers    Alphabets
                         │
                         ▼
                 Pattern Completed

Part 4 covers Pattern-31 to Pattern-40.

We will learn:

Pattern-31 → Right-Shifted Decreasing Number Sequence
Pattern-32 → Right-Shifted Decreasing Repeated Alphabet
Pattern-33 → Right-Shifted Decreasing Alphabet Sequence

Pattern-34 → Star Pyramid
Pattern-35 → Repeated Number Pyramid
Pattern-36 → Repeated Alphabet Pyramid
Pattern-37 → Odd Alphabet Pyramid
Pattern-38 → Palindrome Alphabet Pyramid
Pattern-39 → Reverse Odd Number Pyramid
Pattern-40 → Increasing Alphabet Pyramid

This part introduces one very important pyramid formula:

Number of Values = 2 * i - 1

For five rows:

i = 1 → 1 value
i = 2 → 3 values
i = 3 → 5 values
i = 4 → 7 values
i = 5 → 9 values

Pattern-31 prints numbers starting from 1, but the number of values decreases in every row.

Output

1 2 3 4 5
 1 2 3 4
  1 2 3
   1 2
    1

Two things happen row by row:

Leading Spaces → Increase
Numbers        → Decrease

Step 1 — Read Number of Rows

n=int(input("Enter the number of rows: "))

The value of n controls the total number of rows.

Step 2 — Outer Loop

for i in range(1,n+1):

The variable i represents the current row.

Step 3 — Print Leading Spaces

print(" "*(i-1),end="")

The number of leading spaces is:

i - 1

Step 4 — Print Numbers

for j in range(1,n+2-i):
    print(j,end=" ")

The inner loop prints:

1 to n + 1 - i

For n = 5:

i = 1 → 1 2 3 4 5
i = 2 → 1 2 3 4
i = 3 → 1 2 3
i = 4 → 1 2
i = 5 → 1

i	Spaces	j Range	Output
1	0	1 to 5	1 2 3 4 5
2	1	1 to 4	1 2 3 4
3	2	1 to 3	1 2 3
4	3	1 to 2	1 2
5	4	1 to 1	1

Output

E E E E E
 D D D D
  C C C
   B B
    A

The alphabet and its repetition count both decrease in every row.

The leading spaces are generated using:

" " * (i-1)

The current alphabet is calculated using:

chr(65+n-i)

For n = 5:

i = 1 → chr(69) → E
i = 2 → chr(68) → D
i = 3 → chr(67) → C
i = 4 → chr(66) → B
i = 5 → chr(65) → A

The repetition count is:

n + 1 - i

Therefore:

E → 5 times
D → 4 times
C → 3 times
B → 2 times
A → 1 time

Leading Spaces = i - 1

Alphabet =
chr(65 + n - i)

Repetitions =
n + 1 - i

Output

A B C D E
 A B C D
  A B C
   A B
    A

Every row starts from A.

The ending alphabet decreases in every next row.

First, leading spaces are printed:

" " * (i-1)

The inner loop starts from:

65

ASCII value 65 represents:

A

The loop is:

range(65,66+n-i)

For n = 5:

Row 1 → ASCII 65 to 69
      → A B C D E

Row 2 → ASCII 65 to 68
      → A B C D

Row 3 → ASCII 65 to 67
      → A B C

Row 4 → A B

Row 5 → A

Patterns 31–33 follow the same basic shape.

Values decrease
Spaces increase

The common formulas are:

Spaces = i - 1

Values = n + 1 - i

Pattern	Printed Value
31	Increasing numbers from 1
32	Repeated decreasing alphabet
33	Increasing alphabet sequence from A

Pattern-34 starts a new category: Pyramid Patterns.

A normal pyramid follows two important formulas:

Leading Spaces = n - i

Values = 2 * i - 1

For n = 5:

i	Spaces	2*i-1
1	4	1
2	3	3
3	2	5
4	1	7
5	0	9

Therefore the number of values follows the odd-number sequence:

1, 3, 5, 7, 9, ...

Pattern-34 creates a pyramid using stars.

Output

    *
   * * *
  * * * * *
 * * * * * * *
* * * * * * * * *

The source program uses:

"* " * (2*i-1)

So every row contains an odd number of stars.

The expression:

" " * (n-i)

controls the leading spaces.

The expression:

"* " * (2*i-1)

controls the number of stars.

For each row:

i = 1 → 2(1)-1 = 1
i = 2 → 2(2)-1 = 3
i = 3 → 2(3)-1 = 5
i = 4 → 2(4)-1 = 7
i = 5 → 2(5)-1 = 9

Row	Spaces	Stars
1	4	1
2	3	3
3	2	5
4	1	7
5	0	9

Output

    1
   2 2 2
  3 3 3 3 3
 4 4 4 4 4 4 4
5 5 5 5 5 5 5 5 5

The row number is repeated an odd number of times.

The current number is:

i

It is converted into a string:

str(i)

A space is added:

str(i) + " "

Then it is repeated:

2*i - 1

Example for i = 4:

2*4 - 1
= 7

"4 " * 7

4 4 4 4 4 4 4

Output

    A
   B B B
  C C C C C
 D D D D D D D
E E E E E E E E E

The alphabet changes according to the row.

The repetition count follows:

1, 3, 5, 7, 9

The alphabet formula is:

chr(64+i)

Therefore:

i = 1 → A
i = 2 → B
i = 3 → C
i = 4 → D
i = 5 → E

The repetition count is:

2*i - 1

For row 3:

Character = C

Repetitions =
2*3 - 1
= 5

C C C C C

Output

    A
   C C C
  E E E E E
 G G G G G G G
I I I I I I I I I

This pattern skips one alphabet after every row.

A → C → E → G → I

The important formula is:

chr(63 + 2*i)

For each row:

i = 1

63 + 2
= 65

chr(65)
= A

i = 2

63 + 4
= 67

chr(67)
= C

i = 3

63 + 6
= 69

chr(69)
= E

Therefore:

A, C, E, G, I

Again, the repetition count is:

2*i - 1

Pattern-38 is more advanced because every row contains an increasing and decreasing alphabet sequence.

Output

    A
   A B A
  A B C B A
 A B C D C B A
A B C D E D C B A

This is an alphabet palindrome pattern.

Each row reads the same from left to right and right to left.

The first inner loop is:

for j in range(65,65+i):
    print(chr(j),end=" ")

It prints alphabets in increasing order.

For i = 5:

65 → A
66 → B
67 → C
68 → D
69 → E

A B C D E

The second inner loop is:

for k in range(63+i,64,-1):
    print(chr(k),end=" ")

It prints the remaining alphabets in reverse order.

For i = 5:

k starts at:

63 + 5
= 68

chr(68) = D

Then:

68 → D
67 → C
66 → B
65 → A

So the complete row becomes:

A B C D E + D C B A

A B C D E D C B A

i	Increasing Part	Decreasing Part	Complete Row
1	A	-	A
2	A B	A	A B A
3	A B C	B A	A B C B A
4	A B C D	C B A	A B C D C B A
5	A B C D E	D C B A	A B C D E D C B A

Output

    1
   3 2 1
  5 4 3 2 1
 7 6 5 4 3 2 1
9 8 7 6 5 4 3 2 1

Each row starts with an odd number and decreases until 1.

The starting number is:

2*i - 1

Therefore:

i = 1 → 1
i = 2 → 3
i = 3 → 5
i = 4 → 7
i = 5 → 9

The loop:

range(2*i-1,0,-1)

counts backward until 1.

For i = 4:

2*4 - 1
= 7

range(7,0,-1)

7 6 5 4 3 2 1

i	Starting Value	Output
1	1	1
2	3	3 2 1
3	5	5 4 3 2 1
4	7	7 6 5 4 3 2 1
5	9	9 8 7 6 5 4 3 2 1

Output

    A
   A B C
  A B C D E
 A B C D E F G
A B C D E F G H I

Every row starts from A.

The number of alphabets follows:

1, 3, 5, 7, 9

The alphabet loop is:

for j in range(65,65+2*i-1):

The loop always starts at ASCII:

65 → A

The number of iterations is:

2*i - 1

For row 3:

2*3 - 1
= 5

Therefore five alphabets are printed:

A B C D E

For row 5:

2*5 - 1
= 9

A B C D E F G H I

Pattern	Pyramid Content	Main Formula
34	Stars	2*i-1 stars
35	Repeated row number	i repeated 2*i-1 times
36	Repeated row alphabet	chr(64+i)
37	Odd-position alphabet	chr(63+2*i)
38	Alphabet palindrome	Increasing + decreasing alphabets
39	Reverse numbers	2*i-1 down to 1
40	Increasing alphabets	2*i-1 alphabets

The expression:

2*i - 1

generates consecutive odd numbers.

i	Calculation	Result
1	2 × 1 - 1	1
2	2 × 2 - 1	3
3	2 × 3 - 1	5
4	2 × 4 - 1	7
5	2 × 5 - 1	9

This formula is useful because a pyramid normally grows symmetrically:

        1
      3 values
    5 values
  7 values
9 values

Pattern	Leading Spaces	Main Logic
31	i-1	j = 1 to n+1-i
32	i-1	chr(65+n-i) repeated n+1-i
33	i-1	A to decreasing endpoint
34	n-i	2*i-1 stars
35	n-i	i repeated 2*i-1
36	n-i	chr(64+i) repeated 2*i-1
37	n-i	chr(63+2*i) repeated 2*i-1
38	n-i	Increasing + decreasing alphabet
39	n-i	2*i-1 down to 1
40	n-i	Print 2*i-1 alphabets from A

                         START
                           │
                           ▼
                        Read n
                           │
                           ▼
                    Outer Loop (i)
                           │
                           ▼
                  Identify Pattern
                           │
              ┌────────────┴────────────┐
              │                         │
              ▼                         ▼
        Pattern 31-33              Pattern 34-40
              │                         │
              ▼                         ▼
       Decreasing Shape               Pyramid
              │                         │
              ▼                         ▼
     Spaces = i - 1             Spaces = n - i
              │                         │
              ▼                         ▼
 Values = n + 1 - i          Values usually = 2*i-1
              │                         │
              └────────────┬────────────┘
                           │
                           ▼
                    Print Spaces
                           │
                           ▼
                   Generate Values
                           │
              ┌────────────┼────────────┐
              ▼            ▼            ▼
           Stars        Numbers      Alphabets
              │            │            │
              └────────────┴────────────┘
                           │
                           ▼
                      Print Row
                           │
                           ▼
                       Next Row
                           │
                           ▼
                          END

• Patterns 31–33 use increasing leading spaces and decreasing values.
• The common space formula for Patterns 31–33 is i-1.
• Pattern-31 always starts its number sequence from 1.
• Pattern-32 uses chr(65+n-i) to generate decreasing alphabets.
• Pattern-33 always starts its alphabet sequence from A.
• Pattern-34 begins the pyramid-pattern section.
• The most important pyramid formula is 2*i-1.
• 2*i-1 generates the sequence 1, 3, 5, 7, 9, ....
• The common leading-space formula for these increasing pyramids is n-i.
• Pattern-37 uses chr(63+2*i) to generate A, C, E, G, I....
• Pattern-38 requires two inner loops because it first increases alphabets and then decreases them.
• Pattern-39 uses a negative step -1 to print numbers in reverse order.
• Pattern-40 combines ASCII values with the 2*i-1 pyramid formula.

Pattern	Output Type	Key Concept
31	Decreasing numbers	Increasing spaces
32	Repeated decreasing alphabet	ASCII + repetition
33	Decreasing alphabet sequence	ASCII range
34	Star pyramid	2*i-1 stars
35	Number pyramid	Repeated row number
36	Alphabet pyramid	Repeated row alphabet
37	Odd alphabet pyramid	A, C, E, G, I
38	Palindrome alphabet pyramid	Forward + backward loops
39	Reverse number pyramid	Odd number to 1
40	Alphabet pyramid	2*i-1 alphabets

                    PATTERN 31-40
                          │
          ┌───────────────┴───────────────┐
          │                               │
          ▼                               ▼
     Pattern 31-33                   Pattern 34-40
          │                               │
          ▼                               ▼
 Decreasing Right-Shifted               Pyramid
          │                               │
          ▼                               ▼
 Spaces = i - 1                   Spaces = n - i
          │                               │
          ▼                               ▼
Values = n + 1 - i              Values ≈ 2*i - 1
          │                               │
     ┌────┴────┐             ┌────────────┼────────────┐
     ▼         ▼             ▼            ▼            ▼
  Numbers   Alphabets      Stars       Numbers      Alphabets
                                                    │
                                      ┌─────────────┼─────────────┐
                                      ▼             ▼             ▼
                                   Repeated     Palindrome     Sequence

Part 5 covers Pattern-41 to Pattern-50.

In this part, we will learn:

Pattern-41 → Reverse Alphabet Pyramid
Pattern-42 → Reverse-to-Forward Number Pyramid
Pattern-43 → Reverse-to-Forward Alphabet Pyramid
Pattern-44 → Palindrome Number Pyramid
Pattern-45 → Repeated Increasing Alphabet Pyramid
Pattern-46 → Descending Number Triangle
Pattern-47 → Inverted Star Pyramid
Pattern-48 → Inverted Repeated Number Pyramid
Pattern-49 → Inverted Odd Number Pyramid
Pattern-50 → Inverted Number Sequence Pattern

Important concepts used in this part are:

• Nested loops
• Increasing and decreasing ranges
• Negative step in range()
• ASCII values with chr()
• Leading spaces
• Odd-number formulas
• Two inner loops in the same row
• Increasing and inverted pyramids

Pattern-41 prints alphabets in reverse order.

The starting alphabet increases by two positions in every row.

Output

    A
   C B A
  E D C B A
 G F E D C B A
I H G F E D C B A

Observe the first alphabet of every row:

A
C
E
G
I

These are alternate alphabets.

After selecting the starting alphabet, the program prints backward until A.

Step 1 — Read Number of Rows

n=int(input("Enter the number of rows: "))

The variable n stores the number of rows.

Step 2 — Outer Loop

for i in range(1,n+1):

The outer loop controls the rows.

Step 3 — Print Leading Spaces

print(" "*(n-i),end="")

The number of spaces decreases in every row.

n = 5

i = 1 → 4 spaces
i = 2 → 3 spaces
i = 3 → 2 spaces
i = 4 → 1 space
i = 5 → 0 spaces

Step 4 — Calculate Starting Alphabet

65 + 2*i - 2

For different rows:

i = 1 → 65 → A
i = 2 → 67 → C
i = 3 → 69 → E
i = 4 → 71 → G
i = 5 → 73 → I

Step 5 — Print in Reverse Order

range(65+2*i-2,64,-1)

The value decreases by 1 until ASCII value 65.

For row 4:

Starting ASCII = 71

71 → G
70 → F
69 → E
68 → D
67 → C
66 → B
65 → A

Therefore:

G F E D C B A

i	Start ASCII	Start Character	Output
1	65	A	A
2	67	C	C B A
3	69	E	E D C B A
4	71	G	G F E D C B A
5	73	I	I H G F E D C B A

Pattern-42 creates a number pyramid using two parts.

The first part prints numbers in decreasing order and the second part prints numbers in increasing order.

Output

    0
   1 0 1
  2 1 0 1 2
 3 2 1 0 1 2 3
4 3 2 1 0 1 2 3 4

The center value of every row is:

0

The values are symmetrical around 0.

The first inner loop is:

for j in range(1,i):
    print(i-j,end=" ")

It prints decreasing values before 0.

For i = 5:

j = 1 → 5-1 = 4
j = 2 → 5-2 = 3
j = 3 → 5-3 = 2
j = 4 → 5-4 = 1

Output:

4 3 2 1

The second inner loop is:

for k in range(0,i):
    print(k,end=" ")

It prints:

0 1 2 ... i-1

For i = 5:

0 1 2 3 4

Combining both loops:

4 3 2 1 + 0 1 2 3 4

4 3 2 1 0 1 2 3 4

Row	Left Part	Right Part	Complete Output
1	-	0	0
2	1	0 1	1 0 1
3	2 1	0 1 2	2 1 0 1 2
4	3 2 1	0 1 2 3	3 2 1 0 1 2 3
5	4 3 2 1	0 1 2 3 4	4 3 2 1 0 1 2 3 4

Pattern-43 is the alphabet version of Pattern-42.

Output

    A
   B A B
  C B A B C
 D C B A B C D
E D C B A B C D E

The pattern decreases toward A and then increases again.

First Part

for j in range(1,i):
    print(chr(i-j+65),end=" ")

This prints alphabets in decreasing order.

For i = 5:

j = 1 → chr(69) → E
j = 2 → chr(68) → D
j = 3 → chr(67) → C
j = 4 → chr(66) → B

First part:

E D C B

Second Part

for k in range(0,i):
    print(chr(k+65),end=" ")

For i = 5:

k = 0 → A
k = 1 → B
k = 2 → C
k = 3 → D
k = 4 → E

Second part:

A B C D E

Complete row:

E D C B A B C D E

Feature	Pattern-42	Pattern-43
Data Type	Numbers	Alphabets
Center	0	A
Left Side	Decreasing numbers	Decreasing alphabets
Right Side	Increasing numbers	Increasing alphabets
Character Conversion	Not required	chr()

Output

    1
   1 2 1
  1 2 3 2 1
 1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1

Every row first increases from 1 to the row number and then decreases back to 1.

Therefore every row forms a numeric palindrome.

The first loop is:

for j in range(1,i+1):
    print(j,end=" ")

For row 5:

1 2 3 4 5

The second loop is:

for k in range(i-1,0,-1):
    print(k,end=" ")

The loop starts from:

i - 1

This prevents the highest value from being printed twice.

For row 5:

4 3 2 1

Complete row:

1 2 3 4 5 4 3 2 1

i	Increasing Part	Decreasing Part	Output
1	1	-	1
2	1 2	1	1 2 1
3	1 2 3	2 1	1 2 3 2 1
4	1 2 3 4	3 2 1	1 2 3 4 3 2 1
5	1 2 3 4 5	4 3 2 1	1 2 3 4 5 4 3 2 1

Output

    A
   A B A
  A B C A B
 A B C D A B C
A B C D E A B C D

Each row contains two alphabet sequences.

The first sequence prints from A to the current row alphabet.

The second sequence again starts from A, but stops one alphabet earlier.

for j in range(1,i+1):
    print(chr(64+j),end=" ")

For row 5:

j = 1 → A
j = 2 → B
j = 3 → C
j = 4 → D
j = 5 → E

Result:

A B C D E

for k in range(1,i):
    print(chr(64+k),end=" ")

For row 5:

A B C D

Therefore the complete row is:

A B C D E A B C D

The second loop uses:

range(1,i)

instead of:

range(1,i+1)

Therefore it prints one fewer alphabet.

Pattern-46 prints numbers starting from n and decreases toward smaller values.

The number of values increases row by row.

Program Logic Output for n = 5

    5
   5 4
  5 4 3
 5 4 3 2
5 4 3 2 1

The value printed is calculated using:

n + 1 - j

If n = 5:

j = 1 → 5+1-1 = 5
j = 2 → 5+1-2 = 4
j = 3 → 5+1-3 = 3
j = 4 → 5+1-4 = 2
j = 5 → 5+1-5 = 1

But the inner loop executes only i times:

range(1,i+1)

Therefore:

Row 1 → 5
Row 2 → 5 4
Row 3 → 5 4 3
Row 4 → 5 4 3 2
Row 5 → 5 4 3 2 1

Leading Spaces = n - i

Number of Values = i

Printed Value = n + 1 - j

Pattern-47 begins the inverted/decreasing pyramid section.

Output

* * * * * * * * *
 * * * * * * *
  * * * * *
   * * *
    *

The number of stars follows:

9
7
5
3
1

At the same time, leading spaces increase.

for j in range(1,num+2-i):
    print("*",end=" ")

The first loop prints:

num + 1 - i

stars.

For num = 5:

i = 1 → 5 stars
i = 2 → 4 stars
i = 3 → 3 stars
i = 4 → 2 stars
i = 5 → 1 star

for k in range(1,num+1-i):
    print("*",end=" ")

The second loop prints:

num - i

additional stars.

Therefore the total is:

(num + 1 - i) + (num - i)

= 2*num + 1 - 2*i

For num = 5:

i = 1 → 9 stars
i = 2 → 7 stars
i = 3 → 5 stars
i = 4 → 3 stars
i = 5 → 1 star

i	Spaces	First Loop	Second Loop	Total Stars
1	0	5	4	9
2	1	4	3	7
3	2	3	2	5
4	3	2	1	3
5	4	1	0	1

Output

5 5 5 5 5 5 5 5 5
 4 4 4 4 4 4 4
  3 3 3 3 3
   2 2 2
    1

The row value decreases:

5 → 4 → 3 → 2 → 1

The number of repetitions also decreases:

9 → 7 → 5 → 3 → 1

The number printed in each row is:

num + 1 - i

For num = 5:

i = 1 → 5
i = 2 → 4
i = 3 → 3
i = 4 → 2
i = 5 → 1

Two loops print the same number.

First Loop

for j in range(0,num+1-i):

Second Loop

for k in range(1,num+1-i):

Together they generate:

2*num + 1 - 2*i

values.

Therefore:

Row 1 → 9 copies of 5
Row 2 → 7 copies of 4
Row 3 → 5 copies of 3
Row 4 → 3 copies of 2
Row 5 → 1 copy of 1

Output

9 9 9 9 9 9 9 9 9
 7 7 7 7 7 7 7
  5 5 5 5 5
   3 3 3
    1

This pattern prints decreasing odd numbers.

9
7
5
3
1

The number itself is also repeated the same number of times.

The most important expression is:

2*num + 1 - 2*i

For num = 5:

i = 1

2*5 + 1 - 2*1
= 10 + 1 - 2
= 9

i = 2

11 - 4
= 7

i = 3

11 - 6
= 5

i = 4

11 - 8
= 3

i = 5

11 - 10
= 1

Therefore the values are:

9, 7, 5, 3, 1

i	Spaces	Value	Repetitions
1	0	9	9
2	1	7	7
3	2	5	5
4	3	3	3
5	4	1	1

Pattern-50 prints an inverted sequence of numbers.

Output

1 2 3 4 5 6 7
 1 2 3 4 5
  1 2 3
   1

The number of printed values decreases by two after every row.

7 → 5 → 3 → 1

This pattern uses two inner loops to construct every row.

The first inner loop is:

for j in range(1,num+2-i):
    print(j,end=" ")

It prints an increasing sequence starting from 1.

For example, when num = 4:

i = 1 → 1 2 3 4
i = 2 → 1 2 3
i = 3 → 1 2
i = 4 → 1

The second inner loop is:

for k in range(2,num+2-i):
    print(num+k-i,end=" ")

It prints the remaining increasing numbers required to complete the row.

For num = 4 and i = 1:

First loop:
1 2 3 4

Second loop:

k = 2 → 4 + 2 - 1 = 5
k = 3 → 4 + 3 - 1 = 6
k = 4 → 4 + 4 - 1 = 7

Therefore:

1 2 3 4 5 6 7

For row 2:

First loop:
1 2 3

Second loop:
4 5

Complete:
1 2 3 4 5

For row 3:

1 2 3

For row 4:

1

For num = 4:

i	Spaces	First Loop	Second Loop	Complete Row
1	0	1 2 3 4	5 6 7	1 2 3 4 5 6 7
2	1	1 2 3	4 5	1 2 3 4 5
3	2	1 2	3	1 2 3
4	3	1	-	1

Pattern	Type	Main Logic
41	Reverse Alphabet	Odd-position alphabet down to A
42	Number Symmetry	Decrease to 0, then increase
43	Alphabet Symmetry	Decrease to A, then increase
44	Number Palindrome	Increase and then decrease
45	Repeated Alphabet Sequence	Two increasing alphabet loops
46	Descending Numbers	Start from n and decrease

Pattern	Type	Row Size
47	Stars	9, 7, 5, 3, 1
48	Repeated Numbers	9, 7, 5, 3, 1
49	Repeated Odd Numbers	9, 7, 5, 3, 1
50	Increasing Number Sequence	7, 5, 3, 1 for num = 4

Increasing Pyramid Spaces

n - i

Used in Patterns 41–46.

Inverted Pyramid Spaces

i - 1

Used in Patterns 47–50.

Pattern-41 Starting Alphabet

65 + 2*i - 2

Pattern-46 Printed Number

n + 1 - j

Inverted Odd Row Size

2*num + 1 - 2*i

For num = 5, this generates:

9, 7, 5, 3, 1

Pattern-49 Printed Value

2*num + 1 - 2*i

Increasing Pyramid

Leading spaces decrease while values increase.

    *
   * * *
  * * * * *
 * * * * * * *
* * * * * * * * *

Typical space formula:

n - i

Inverted Pyramid

Leading spaces increase while values decrease.

* * * * * * * * *
 * * * * * * *
  * * * * *
   * * *
    *

Typical space formula:

i - 1

This relationship is very important when solving pattern-programming questions.

                         START
                           │
                           ▼
                      Read n / num
                           │
                           ▼
                       Outer Loop
                           │
                           ▼
                 Calculate Row Number
                           │
                           ▼
                    Print Spaces
                           │
             ┌─────────────┴─────────────┐
             │                           │
             ▼                           ▼
      Increasing Pyramid          Inverted Pyramid
       Pattern 41-46              Pattern 47-50
             │                           │
             ▼                           ▼
      Spaces Decrease              Spaces Increase
         n - i                       i - 1
             │                           │
             ▼                           ▼
      Values Increase              Values Decrease
             │                           │
             └─────────────┬─────────────┘
                           │
                           ▼
                  Execute Inner Loop
                           │
                    ┌──────┴──────┐
                    ▼             ▼
               First Part     Second Part
                    │             │
                    └──────┬──────┘
                           ▼
                       Print Row
                           │
                           ▼
                       Next Row
                           │
                           ▼
                          END

• Pattern-41 uses ASCII values to generate alternate starting alphabets A, C, E, G, I.
• A negative step such as -1 is used when values must move backward.
• Pattern-42 combines decreasing and increasing number sequences.
• Pattern-43 applies the same idea using alphabets.
• Pattern-44 is a proper number palindrome because the second half is the reverse of the first half without repeating the center value.
• Pattern-45 uses two increasing alphabet loops.
• Pattern-46 always begins its sequence from n.
• Pattern-47 starts the inverted pyramid patterns in this section.
• In an inverted pyramid, spaces generally increase while the number of values decreases.
• Patterns 47–49 use two loops to create odd-sized rows.
• The sequence 9, 7, 5, 3, 1 can be generated using 2*num+1-2*i when num = 5.
• Pattern-48 repeats the value num+1-i.
• Pattern-49 uses the same odd-number formula both for the printed value and the effective row width.
• Pattern-50 creates decreasing odd-sized rows of consecutive numbers.
• end="" is important when spaces and pattern values must continue on the same line.
• print() after the inner loops moves the cursor to the next row.

Pattern	Pattern Type	Key Concept
41	Reverse Alphabet Pyramid	ASCII + reverse range
42	Number Symmetry Pyramid	Decrease → 0 → Increase
43	Alphabet Symmetry Pyramid	Decrease → A → Increase
44	Number Palindrome	Forward + backward loops
45	Repeated Alphabet Sequence	Two forward loops
46	Descending Number Triangle	n+1-j
47	Inverted Star Pyramid	Odd decreasing width
48	Inverted Number Pyramid	Repeated decreasing value
49	Inverted Odd Number Pyramid	2*num+1-2*i
50	Inverted Number Sequence	Two increasing number loops

                     PATTERN 41-50
                           │
          ┌────────────────┴────────────────┐
          │                                 │
          ▼                                 ▼
     Pattern 41-46                    Pattern 47-50
   Advanced Pyramids                Inverted Patterns
          │                                 │
     Spaces = n-i                      Spaces = i-1
          │                                 │
     ┌────┼────────────┐              ┌─────┼───────────┐
     ▼    ▼            ▼              ▼     ▼           ▼
 Alphabet Number   Palindrome        Star  Number   Sequence
     │    │            │              │     │           │
     │    │            │              │     │           │
    41   42,46         44             47    48,49        50
     │
     ├── Pattern 43 → Alphabet Symmetry
     │
     └── Pattern 45 → Repeated Alphabet Sequence

Part 6 covers Pattern-51 to Pattern-60.

In this part, we will learn:

Pattern-51 → Inverted Repeated Alphabet Pyramid
Pattern-52 → Inverted Odd-Position Alphabet Pyramid
Pattern-53 → Inverted Alphabet Sequence
Pattern-54 → Palindrome Number Pyramid
Pattern-55 → Palindrome Alphabet Pyramid
Pattern-56 → Zero-Centered Symmetrical Number Pyramid
Pattern-57 → Combined Number Diamond Pattern
Pattern-58 → Combined Alphabet Diamond Pattern
Pattern-59 → Increasing and Decreasing Star Pattern
Pattern-60 → Increasing and Decreasing Reverse Number Pattern

Important concepts used in this part are:

• Nested for loops
• Increasing and decreasing row sizes
• Leading spaces
• ASCII values and chr()
• Odd-width inverted pyramids
• Palindrome patterns
• Two-part symmetrical rows
• Combining increasing and decreasing patterns
• Multiple outer loops

Pattern-51 is an inverted pyramid containing repeated alphabets.

Output

E E E E E E E E E
 D D D D D D D
  C C C C C
   B B B
    A

The alphabet decreases row by row:

E → D → C → B → A

The number of repetitions also decreases:

9 → 7 → 5 → 3 → 1

Step 1 — Outer Loop

for i in range(1,num+1):

The outer loop controls the rows.

Step 2 — Leading Spaces

print(" "*(i-1),end="")

The spaces increase row by row.

i = 1 → 0 spaces
i = 2 → 1 space
i = 3 → 2 spaces
i = 4 → 3 spaces
i = 5 → 4 spaces

Step 3 — Find the Alphabet

chr(65+num-i)

For num = 5:

i = 1 → chr(69) → E
i = 2 → chr(68) → D
i = 3 → chr(67) → C
i = 4 → chr(66) → B
i = 5 → chr(65) → A

Step 4 — Repeat the Alphabet

The two inner loops together generate odd row sizes:

9, 7, 5, 3, 1

i	Alphabet	Spaces	Repetitions
1	E	0	9
2	D	1	7
3	C	2	5
4	B	3	3
5	A	4	1

Pattern-52 is similar to Pattern-51, but it uses alternate alphabets.

Output

I I I I I I I I I
 G G G G G G G
  E E E E E
   C C C
    A

The alphabets are:

I → G → E → C → A

These correspond to odd alphabet positions:

9 → 7 → 5 → 3 → 1

The main formula is:

65 + 2*num - 2*i

For num = 5:

i = 1 → 65 + 10 - 2  = 73 → I
i = 2 → 65 + 10 - 4  = 71 → G
i = 3 → 65 + 10 - 6  = 69 → E
i = 4 → 65 + 10 - 8  = 67 → C
i = 5 → 65 + 10 - 10 = 65 → A

Therefore:

I
G
E
C
A

Feature	Pattern-51	Pattern-52
Alphabet Sequence	E, D, C, B, A	I, G, E, C, A
Alphabet Step	Decrease by 1	Decrease by 2
Row Width	9, 7, 5, 3, 1	9, 7, 5, 3, 1
Spaces	Increase	Increase

Pattern-53 prints increasing alphabet sequences inside an inverted pattern.

Output

A B C D E F G
 A B C D E
  A B C
   A

The row lengths decrease by two:

7 → 5 → 3 → 1

Every row begins with A.

for j in range(1,num+2-i):
    print(chr(64+j),end=" ")

The first loop always starts from:

chr(65) → A

For num = 4:

Row 1 → A B C D
Row 2 → A B C
Row 3 → A B
Row 4 → A

for k in range(2,num+2-i):
    print(chr(68+k-i),end=" ")

The second loop continues the alphabet sequence required to complete each row.

For the first row:

First Loop  → A B C D
Second Loop → E F G

Complete Row:
A B C D E F G

The final row contains only:

A

Pattern-54 prints a centered number palindrome.

Output

    1
   1 2 1
  1 2 3 2 1
 1 2 3 4 3 2 1
1 2 3 4 5 4 3 2 1

Each row contains two parts:

Increasing Part + Decreasing Part

For example:

1 2 3 4 5 + 4 3 2 1

becomes:

1 2 3 4 5 4 3 2 1

for j in range(1,i+1):
    print(j,end=" ")

The first loop prints from 1 to i.

For row 4:

1 2 3 4

for k in range(i-1,0,-1):
    print(k,end=" ")

The second loop begins from i-1.

For row 4:

3 2 1

It starts from i-1 so that the center number is not repeated.

Complete row:

1 2 3 4 3 2 1

i	Spaces	Increasing	Decreasing	Complete Row
1	4	1	-	1
2	3	1 2	1	1 2 1
3	2	1 2 3	2 1	1 2 3 2 1
4	1	1 2 3 4	3 2 1	1 2 3 4 3 2 1
5	0	1 2 3 4 5	4 3 2 1	1 2 3 4 5 4 3 2 1

Pattern-55 is the alphabet version of the palindrome pyramid.

Output

    A
   A B A
  A B C B A
 A B C D C B A
A B C D E D C B A

Every row first moves forward through the alphabet and then moves backward.

For example:

A B C D E D C B A

for j in range(65,65+i):
    print(chr(j),end=" ")

ASCII value 65 represents A.

For i = 5:

65 → A
66 → B
67 → C
68 → D
69 → E

Output:

A B C D E

for k in range(63+i,64,-1):
    print(chr(k),end=" ")

For i = 5:

68 → D
67 → C
66 → B
65 → A

Output:

D C B A

Combining both:

A B C D E D C B A

Feature	Pattern-54	Pattern-55
Data	Numbers	Alphabets
Direction	Increase then decrease	Forward then reverse
Palindrome	Yes	Yes
Uses chr()	No	Yes
Leading Spaces	num-i	num-i

Pattern-56 creates a symmetrical number pyramid around 0.

Output

    0
   1 0 1
  2 1 0 1 2
 3 2 1 0 1 2 3
4 3 2 1 0 1 2 3 4

The left side decreases toward 0.

The right side increases away from 0.

for j in range(1,i):
    print(i-j,end=" ")

For i = 5:

j = 1 → 4
j = 2 → 3
j = 3 → 2
j = 4 → 1

Left side:

4 3 2 1

for k in range(0,i):
    print(k,end=" ")

For i = 5:

0 1 2 3 4

Complete row:

4 3 2 1 0 1 2 3 4

The value 0 becomes the center of every row.

i	Left Side	Right Side	Complete Row
1	-	0	0
2	1	0 1	1 0 1
3	2 1	0 1 2	2 1 0 1 2
4	3 2 1	0 1 2 3	3 2 1 0 1 2 3
5	4 3 2 1	0 1 2 3 4	4 3 2 1 0 1 2 3 4

Pattern-57 introduces a new concept: combining two pattern sections.

Output

   3
  2 3
 1 2 3
0 1 2 3
 1 2 3
  2 3
   3

The pattern contains:

Upper Part
    +
Lower Part

The upper part grows, while the lower part shrinks.

for i in range(1,num+1):
    print(" "*(num-i),end="")
    for j in range(0,i):
        print(num+j-i,end=" ")
    print()

For num = 4:

i = 1 → 3
i = 2 → 2 3
i = 3 → 1 2 3
i = 4 → 0 1 2 3

The number of values increases in every row.

for k in range(1,num):
    print(" "*k,end="")
    for l in range(1,num+1-k):
        print(l+k-1,end=" ")
    print()

The second outer loop creates the decreasing half.

For num = 4:

k = 1 → 1 2 3
k = 2 → 2 3
k = 3 → 3

Notice that the middle row:

0 1 2 3

is printed only once.

Upper Part:

   3
  2 3
 1 2 3
0 1 2 3

Lower Part:

 1 2 3
  2 3
   3

Combined:

   3
  2 3
 1 2 3
0 1 2 3
 1 2 3
  2 3
   3

Pattern-58 applies the same combined-pattern logic using alphabets.

Output

    E
   D E
  C D E
 B C D E
A B C D E
 B C D E
  C D E
   D E
    E

The pattern expands until:

A B C D E

and then contracts again.

The main alphabet formula is:

chr(65 + num + j - i)

For num = 5:

Row 1 → E
Row 2 → D E
Row 3 → C D E
Row 4 → B C D E
Row 5 → A B C D E

The starting alphabet moves backward:

E → D → C → B → A

but each row moves forward toward E.

The lower half uses:

chr(65+k+l)

For num = 5:

k = 1 → B C D E
k = 2 → C D E
k = 3 → D E
k = 4 → E

Therefore the complete pattern becomes symmetrical vertically.

Feature	Pattern-57	Pattern-58
Data	Numbers	Alphabets
Structure	Upper + Lower	Upper + Lower
Leading Spaces	Used	Used
Middle Row	0 1 2 3	A B C D E
Uses chr()	No	Yes

Pattern-59 combines an increasing star triangle and a decreasing star triangle.

Output for num = 5

*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*

The number of stars follows:

1
2
3
4
5
4
3
2
1

for i in range(1,num+1):
    for j in range(1,i+1):
        print("*",end=" ")
    print()

The number of stars equals i.

For num = 5:

i = 1 → *
i = 2 → * *
i = 3 → * * *
i = 4 → * * * *
i = 5 → * * * * *

for a in range(1,num+1):
    for k in range(1,num+1-a):
        print("*",end=" ")
    print()

The number of stars decreases after the maximum row.

4
3
2
1

Therefore the visible pattern grows and then shrinks.

Ignoring the final empty iteration produced by the second outer loop, the visible number of rows is:

num + (num - 1)

= 2*num - 1

For num = 5:

2*5 - 1
= 9 visible rows

Pattern-60 uses the same upper-and-lower structure as Pattern-59, but prints descending numbers.

Output for num = 5

4
4 3
4 3 2
4 3 2 1
4 3 2 1 0
4 3 2 1
4 3 2
4 3
4

Every row begins with:

num - 1

For num = 5, every row starts with 4.

The upper part uses:

num - j

For num = 5:

j = 1 → 4
j = 2 → 3
j = 3 → 2
j = 4 → 1
j = 5 → 0

Because the inner loop runs only i times, the rows become:

4
4 3
4 3 2
4 3 2 1
4 3 2 1 0

The lower part uses:

for a in range(1,num+1):
    for k in range(1,num+1-a):
        print(num-k,end=" ")

The number of printed values decreases in every row.

4 3 2 1
4 3 2
4 3
4

Therefore the complete structure expands and then contracts.

Feature	Pattern-59	Pattern-60
Printed Data	*	Numbers
Upper Half	Increasing	Increasing row length
Lower Half	Decreasing	Decreasing row length
Maximum Width	num stars	num numbers
Main Formula	Loop count	num-j

Pattern	Output Type	Main Idea
51	Repeated Alphabets	E → D → C → B → A
52	Odd-Position Alphabets	I → G → E → C → A
53	Alphabet Sequence	A B C ... with decreasing width

Pattern	Type	Center
54	Number Palindrome	Current row number
55	Alphabet Palindrome	Current row alphabet
56	Number Symmetry	0

The common idea is:

Left Part + Center + Right Part

Pattern	Data	Structure
57	Numbers	Spaced upper + lower
58	Alphabets	Spaced upper + lower
59	Stars	Increasing + decreasing
60	Reverse Numbers	Increasing + decreasing

1. Horizontal Symmetry Inside a Row

Patterns 54, 55 and 56 create symmetry inside individual rows.

Pattern-54:
1 2 3 4 3 2 1

Pattern-55:
A B C D C B A

Pattern-56:
3 2 1 0 1 2 3

2. Vertical Symmetry Between Rows

Patterns 57–60 create a top part and a bottom part.

Increase
   │
   ▼
Maximum Row
   │
   ▼
Decrease

This produces vertical symmetry in the complete pattern.

Inverted Pyramid Leading Spaces

i - 1

Used in Patterns 51–53.

Increasing Pyramid Leading Spaces

num - i

Used in Patterns 54–58 upper sections.

Pattern-51 Alphabet

chr(65 + num - i)

Pattern-52 Alternate Alphabet

chr(65 + 2*num - 2*i)

Pattern-54 Reverse Side

range(i-1, 0, -1)

Pattern-55 Forward Alphabet Range

range(65, 65+i)

Pattern-55 Reverse Alphabet Range

range(63+i, 64, -1)

Pattern-56 Left-Side Value

i - j

Pattern-57 Upper Value

num + j - i

Pattern-58 Upper Alphabet

chr(65 + num + j - i)

Pattern-60 Printed Number

num - j

When a pattern first grows and then shrinks, divide the problem into two sections.

Section 1 — Upper Part

for i in range(...):
    # print increasing rows

Section 2 — Lower Part

for i in range(...):
    # print decreasing rows

General structure:

          Small Row
             │
             ▼
          Bigger Row
             │
             ▼
          Biggest Row
             │
             ▼
          Smaller Row
             │
             ▼
          Small Row

This technique is used heavily from Pattern-57 onward.

                         START
                           │
                           ▼
                       Read num
                           │
                           ▼
                Identify Pattern Type
                           │
          ┌────────────────┼────────────────┐
          │                │                │
          ▼                ▼                ▼
      Inverted         Palindrome         Combined
      Alphabet         / Symmetry         Pattern
      51 - 53           54 - 56           57 - 60
          │                │                │
          ▼                ▼                ▼
    Spaces Grow       Print Left       Print Upper
          │                │                │
          ▼                ▼                ▼
   Width Shrinks      Print Center     Maximum Row
          │                │                │
          ▼                ▼                ▼
 Print Alphabet       Print Right      Print Lower
          │                │                │
          └────────────────┼────────────────┘
                           │
                           ▼
                        New Line
                           │
                           ▼
                        Next Row
                           │
                           ▼
                          END

• Pattern-51 prints decreasing alphabets while its row width decreases by two.
• Pattern-52 uses alternate alphabets such as I, G, E, C, A.
• The expression 2*num-2*i helps move backward through alternate alphabet positions.
• Pattern-53 prints consecutive alphabets but decreases the number of alphabets by two in each row.
• Pattern-54 is a number palindrome.
• Pattern-55 is the alphabet equivalent of the palindrome pattern.
• A palindrome pattern normally requires a forward loop and a reverse loop.
• The center value should normally not be repeated when constructing a palindrome.
• Pattern-56 always uses 0 as the center value.
• Patterns 57 and 58 introduce two separate outer-loop sections.
• The first outer loop generates the upper part.
• The second outer loop generates the lower part.
• Pattern-57 works with numbers while Pattern-58 applies similar logic to alphabets.
• Pattern-59 combines increasing and decreasing star triangles.
• Pattern-60 uses the same combined structure with reverse number sequences.
• When solving complex patterns, first identify the number of rows, spaces, values per row, starting value, and direction of movement.

Pattern	Pattern Type	Key Concept
51	Inverted Repeated Alphabet	Decreasing alphabet + odd width
52	Inverted Alternate Alphabet	Alphabet decreases by 2
53	Inverted Alphabet Sequence	Consecutive alphabets
54	Number Palindrome	Forward + reverse
55	Alphabet Palindrome	ASCII forward + reverse
56	Zero-Centered Number Pyramid	Decrease → 0 → increase
57	Combined Number Pattern	Upper + lower sections
58	Combined Alphabet Pattern	Upper + lower alphabet sections
59	Combined Star Pattern	Increase + decrease
60	Combined Reverse Number Pattern	Reverse sequence + row symmetry

                     PATTERN 51-60
                           │
          ┌────────────────┼────────────────┐
          │                │                │
          ▼                ▼                ▼
      Pattern 51-53    Pattern 54-56    Pattern 57-60
       INVERTED          SYMMETRIC        COMBINED
       ALPHABET           PYRAMID          PATTERNS
          │                │                │
     ┌────┼────┐      ┌────┼────┐      ┌────┼──────┐
     ▼    ▼    ▼      ▼    ▼    ▼      ▼    ▼      ▼
    51   52   53     54   55   56     57   58    59-60
     │    │    │      │    │    │      │    │      │
 Repeated Odd Sequence Num Alpha Zero  Num Alpha  Star/Num
 Alphabet Pos.         Pal. Pal. Center

Part 7 covers Pattern-61 to Pattern-70.

In this part, we will learn:

Pattern-61 → Combined Increasing Number Sequence
Pattern-62 → Vertically Symmetrical Repeated Alphabets
Pattern-63 → Vertically Symmetrical Reverse Alphabet Sequence
Pattern-64 → Vertically Symmetrical Forward Alphabet Sequence
Pattern-65 → Right-Aligned Increasing Star Triangle
Pattern-66 → Right-Aligned Repeated Number Triangle
Pattern-67 → Right-Aligned Number Sequence Triangle
Pattern-68 → Right-Aligned Repeated Alphabet Triangle
Pattern-69 → Right-Aligned Alphabet Sequence Triangle
Pattern-70 → Right-Aligned Decreasing Star Triangle

Important concepts used in this part are:

• Nested for loops
• Two-part vertically symmetrical patterns
• Increasing and decreasing row sizes
• Right alignment using leading spaces
• Repeated row values
• Number sequences
• ASCII values and chr()
• Increasing triangles
• Decreasing triangles

Pattern-61 creates a vertically symmetrical number pattern.

Output for num = 5

4
3 4
2 3 4
1 2 3 4
0 1 2 3 4
1 2 3 4
2 3 4
3 4
4

The pattern contains two sections:

Upper Part → Rows increase
Lower Part → Rows decrease

The last value of every visible row is:

4

The upper section is:

for i in range(1,num+1):
    for j in range(1,i+1):
        print(num-i+j-1,end=" ")
    print()

The main formula is:

num - i + j - 1

For num = 5:

i = 1 → 4
i = 2 → 3 4
i = 3 → 2 3 4
i = 4 → 1 2 3 4
i = 5 → 0 1 2 3 4

Each new row begins with a smaller number, but every row ends at 4.

The lower section is:

for a in range(1,num+1):
    for k in range(0,num-a):
        print(k+a,end=" ")
    print()

Its visible rows are:

1 2 3 4
2 3 4
3 4
4

The starting number increases while the number of values decreases.

Upper Part:

4
3 4
2 3 4
1 2 3 4
0 1 2 3 4

Lower Part:

1 2 3 4
2 3 4
3 4
4

Combined:

4
3 4
2 3 4
1 2 3 4
0 1 2 3 4
1 2 3 4
2 3 4
3 4
4

Pattern-62 creates vertical symmetry using repeated alphabets.

Output for num = 5

E
D D
C C C
B B B B
A A A A A
B B B B
C C C
D D
E

The alphabet changes like this:

E
D
C
B
A
B
C
D
E

The middle row contains the maximum number of values.

The alphabet is calculated using:

chr(65 + num - i)

For num = 5:

i = 1 → chr(69) → E
i = 2 → chr(68) → D
i = 3 → chr(67) → C
i = 4 → chr(66) → B
i = 5 → chr(65) → A

The number of repetitions equals the current row number.

E
D D
C C C
B B B B
A A A A A

The lower section uses:

chr(65 + a)

The alphabet now moves forward:

B → C → D → E

At the same time, the number of repetitions decreases:

4 → 3 → 2 → 1

Therefore:

B B B B
C C C
D D
E

Pattern-63 uses decreasing alphabet sequences in a vertically symmetrical structure.

Output for num = 5

E
E D
E D C
E D C B
E D C B A
E D C B
E D C
E D
E

Every row starts with:

E

The sequence moves backward through the alphabet.

The upper section uses:

chr(65 + num - j)

For num = 5:

j = 1 → E
j = 2 → D
j = 3 → C
j = 4 → B
j = 5 → A

Since the inner loop executes only i times:

E
E D
E D C
E D C B
E D C B A

The lower half reduces the sequence one value at a time.

E D C B
E D C
E D
E

The maximum row:

E D C B A

is printed only once.

Pattern-64 is another vertically symmetrical alphabet pattern.

Output for num = 5

E
D E
C D E
B C D E
A B C D E
B C D E
C D E
D E
E

Unlike Pattern-63, the alphabets inside every row move in forward order.

The main expression is:

chr(64 + num - i + j)

For num = 5:

i = 1 → E
i = 2 → D E
i = 3 → C D E
i = 4 → B C D E
i = 5 → A B C D E

The starting alphabet moves backward:

E → D → C → B → A

but each individual row moves forward.

The second half produces:

B C D E
C D E
D E
E

Its starting alphabet moves forward while its row size decreases.

Therefore, the complete pattern is vertically symmetrical.

Pattern	Row Content	Example Middle Row
62	Repeated alphabet	A A A A A
63	Reverse alphabet sequence	E D C B A
64	Forward alphabet sequence	A B C D E

Pattern-65 begins a new family of right-aligned triangle patterns.

Output for num = 5

    *
   * *
  * * *
 * * * *
* * * * *

Two things happen in every row:

Leading Spaces → Decrease
Stars          → Increase

Leading Spaces

" " * (num-i)

For num = 5:

i = 1 → 4 spaces
i = 2 → 3 spaces
i = 3 → 2 spaces
i = 4 → 1 space
i = 5 → 0 spaces

Stars

for j in range(1,i+1):

The star count is equal to i.

1 → *
2 → * *
3 → * * *
4 → * * * *
5 → * * * * *

i	Leading Spaces	Stars
1	4	1
2	3	2
3	2	3
4	1	4
5	0	5

Pattern-66 replaces the stars of Pattern-65 with the current row number.

Output for num = 5

    1
   2 2
  3 3 3
 4 4 4 4
5 5 5 5 5

The row number determines both:

Value       → i
Repetitions → i

The spaces are exactly the same as Pattern-65:

num - i

The inner loop executes i times:

for j in range(1,i+1):

But instead of printing *, it prints:

i

For example, when i = 4:

4 4 4 4

Pattern-67 prints increasing number sequences in a right-aligned triangle.

Output for num = 5

    1
   1 2
  1 2 3
 1 2 3 4
1 2 3 4 5

Every row starts from 1.

for j in range(1,i+1):
    print(j,end=" ")

The value of j is printed directly.

Therefore:

i = 1 → 1
i = 2 → 1 2
i = 3 → 1 2 3
i = 4 → 1 2 3 4
i = 5 → 1 2 3 4 5

Pattern	Printed Value	Example Row 4
65	*	* * * *
66	i	4 4 4 4
67	j	1 2 3 4

The triangle structure is identical. Only the printed value changes.

Pattern-68 is the alphabet version of Pattern-66.

Output for num = 5

    A
   B B
  C C C
 D D D D
E E E E E

Each row prints one alphabet repeatedly.

The expression is:

chr(64 + i)

Therefore:

i = 1 → chr(65) → A
i = 2 → chr(66) → B
i = 3 → chr(67) → C
i = 4 → chr(68) → D
i = 5 → chr(69) → E

The inner loop repeats the selected alphabet i times.

A
B B
C C C
D D D D
E E E E E

Pattern-69 is the alphabet version of Pattern-67.

Output for num = 5

    A
   A B
  A B C
 A B C D
A B C D E

Every row starts from A and moves forward through the alphabet.

The alphabet depends on the column variable:

chr(64 + j)

Therefore:

j = 1 → A
j = 2 → B
j = 3 → C
j = 4 → D
j = 5 → E

Because the inner loop ends at i:

Row 1 → A
Row 2 → A B
Row 3 → A B C
Row 4 → A B C D
Row 5 → A B C D E

Feature	Pattern-66	Pattern-68
Type	Numbers	Alphabets
Value	i	chr(64+i)
Repeated Value	Yes	Yes
Alignment	Right	Right

Feature	Pattern-67	Pattern-69
Sequence	1, 2, 3...	A, B, C...
Printed Expression	j	chr(64+j)
Starts Each Row From	1	A
Row Size	Increasing	Increasing

Pattern-70 begins the right-aligned decreasing triangle family.

Output for num = 5

* * * * *
 * * * *
  * * *
   * *
    *

Unlike Pattern-65:

Spaces → Increase
Stars  → Decrease

The expression:

" " * (i-1)

controls the indentation.

For num = 5:

i = 1 → 0 spaces
i = 2 → 1 space
i = 3 → 2 spaces
i = 4 → 3 spaces
i = 5 → 4 spaces

The spaces increase from top to bottom.

The inner loop is:

for j in range(1,num+2-i):

The number of iterations is:

num + 1 - i

For num = 5:

i = 1 → 5 stars
i = 2 → 4 stars
i = 3 → 3 stars
i = 4 → 2 stars
i = 5 → 1 star

i	Spaces	Stars
1	0	5
2	1	4
3	2	3
4	3	2
5	4	1

Feature	Pattern-65	Pattern-70
Triangle	Increasing	Decreasing
Spaces	Decrease	Increase
Stars	Increase	Decrease
Space Formula	num-i	i-1
Star Count	i	num+1-i

Pattern	Data	Middle Row	Main Idea
61	Numbers	0 1 2 3 4	Increasing sequence
62	Alphabets	A A A A A	Repeated alphabet
63	Alphabets	E D C B A	Reverse sequence
64	Alphabets	A B C D E	Forward sequence

Patterns 65–69 use almost the same triangle structure.

for i in range(1,num+1):

    print(" "*(num-i),end="")

    for j in range(1,i+1):

        # Print required value

    print()

Only the value printed inside the inner loop changes.

Pattern	Printed Expression
65	"*"
66	i
67	j
68	chr(64+i)
69	chr(64+j)

Patterns 65–69 clearly demonstrate the difference between printing i and printing j.

Printing i

for i in range(1,num+1):
    for j in range(1,i+1):
        print(i,end=" ")

The same value repeats across the row:

1
2 2
3 3 3

Printing j

for i in range(1,num+1):
    for j in range(1,i+1):
        print(j,end=" ")

The value changes across the row:

1
1 2
1 2 3

The same idea applies to alphabets:

chr(64+i) → Repeated alphabet
chr(64+j) → Alphabet sequence

For an increasing right-aligned triangle:

Spaces = num - i
Values = i

Therefore:

Row 1 → Maximum spaces + Minimum values
Row 2 → Fewer spaces   + More values
...
Last  → Zero spaces    + Maximum values

For a decreasing right-aligned triangle:

Spaces = i - 1
Values = num + 1 - i

Therefore:

Row 1 → Zero spaces    + Maximum values
Row 2 → More spaces    + Fewer values
...
Last  → Maximum spaces + One value

Pattern-61

num - i + j - 1

Pattern-62 Upper Alphabet

chr(65 + num - i)

Pattern-62 Lower Alphabet

chr(65 + a)

Pattern-63 Reverse Alphabet

chr(65 + num - j)

Pattern-64 Forward Alphabet

chr(64 + num - i + j)

Increasing Right Alignment

" " * (num-i)

Repeated Row Number

i

Increasing Number Sequence

j

Repeated Row Alphabet

chr(64+i)

Increasing Alphabet Sequence

chr(64+j)

Decreasing Right Alignment

" " * (i-1)

Decreasing Row Size

num + 1 - i

Before writing the inner print(), ask what changes in the pattern.

Case 1 — Same value throughout the row

1
2 2
3 3 3

Use the row variable:

print(i,end=" ")

Case 2 — Values change across the row

1
1 2
1 2 3

Use the column variable:

print(j,end=" ")

Case 3 — Same alphabet throughout the row

A
B B
C C C

Use:

chr(64+i)

Case 4 — Alphabet changes across the row

A
A B
A B C

Use:

chr(64+j)

                         START
                           │
                           ▼
                       Read num
                           │
                           ▼
                 Identify Pattern Type
                           │
          ┌────────────────┼──────────────────┐
          │                │                  │
          ▼                ▼                  ▼
      Combined         Right-Aligned      Right-Aligned
      Symmetry          Increasing         Decreasing
       61-64             65-69                70
          │                │                  │
          ▼                ▼                  ▼
    Print Upper       Spaces Decrease     Spaces Increase
          │                │                  │
          ▼                ▼                  ▼
    Middle Row        Values Increase     Values Decrease
          │                │                  │
          ▼                ▼                  ▼
    Print Lower       Print *, Number     Print *
          │           or Alphabet             │
          │                │                  │
          └────────────────┼──────────────────┘
                           │
                           ▼
                         Next Row
                           │
                           ▼
                          END

• Pattern-61 is the number-sequence counterpart of the combined symmetrical patterns from the previous part.
• Patterns 62–64 are vertically symmetrical alphabet patterns.
• Pattern-62 repeats the same alphabet in each row.
• Pattern-63 prints alphabets in reverse order inside each row.
• Pattern-64 prints alphabets in forward order inside each row.
• Patterns 61–64 use separate loops for the upper and lower sections.
• Patterns 65–69 share almost exactly the same triangle structure.
• For right-aligned increasing triangles, leading spaces are calculated using num-i.
• Pattern-65 prints stars.
• Pattern-66 prints the row variable i.
• Pattern-67 prints the column variable j.
• Pattern-68 converts i into an alphabet using chr(64+i).
• Pattern-69 converts j into an alphabet using chr(64+j).
• Pattern-70 reverses the right-aligned triangle logic.
• In Pattern-70, spaces increase while stars decrease.
• Understanding whether the output depends on the row or column is one of the most important concepts in pattern programming.

Pattern	Pattern Type	Key Concept
61	Combined Number Sequence	Vertical number symmetry
62	Repeated Alphabet Symmetry	Repeated letters + vertical symmetry
63	Reverse Alphabet Symmetry	Reverse alphabet sequence
64	Forward Alphabet Symmetry	Forward alphabet sequence
65	Increasing Star Triangle	Right alignment
66	Repeated Number Triangle	Print i
67	Number Sequence Triangle	Print j
68	Repeated Alphabet Triangle	chr(64+i)
69	Alphabet Sequence Triangle	chr(64+j)
70	Decreasing Star Triangle	Increasing spaces + decreasing stars

                       PATTERN 61-70
                             │
          ┌──────────────────┼──────────────────┐
          │                  │                  │
          ▼                  ▼                  ▼
       61 - 64            65 - 69              70
       VERTICAL          RIGHT-ALIGNED      RIGHT-ALIGNED
       SYMMETRY           INCREASING         DECREASING
          │                  │                  │
     ┌────┼────┐       ┌─────┼─────┐            │
     ▼    ▼    ▼       ▼     ▼     ▼            ▼
   Number Rep. Sequence Star Number Alphabet    Star
          │              │     │      │
          │              │   i / j  i / j
          │              │
          ▼              ▼
     Upper + Lower   Spaces = num-i

                       Pattern-70
                           │
                           ▼
                    Spaces = i-1
                           │
                           ▼
                 Values = num+1-i

Part 8 covers Pattern-71 to Pattern-80.

In this part, we will learn:

Pattern-71 → Right-Aligned Decreasing Repeated Numbers
Pattern-72 → Right-Aligned Decreasing Number Sequence
Pattern-73 → Right-Aligned Decreasing Repeated Alphabets
Pattern-74 → Right-Aligned Decreasing Reverse Alphabet Sequence
Pattern-75 → Right-Aligned Decreasing Forward Alphabet Sequence
Pattern-76 → Combined Star Diamond Pattern
Pattern-77 → Combined Repeated Number Diamond
Pattern-78 → Combined Number Sequence Pattern
Pattern-79 → Symmetrical Number Sequence Diamond
Pattern-80 → Combined Repeated Alphabet Diamond

The important concepts used are:

• Nested for loops
• Increasing leading spaces
• Decreasing row sizes
• Repeated numbers
• Descending number sequences
• ASCII values and chr()
• Forward and reverse alphabet sequences
• Upper and lower pattern sections
• Diamond-like patterns
• Vertical symmetry

Pattern-71 is the number version of the decreasing star triangle from Pattern-70.

Output for num = 5

5 5 5 5 5
 4 4 4 4
  3 3 3
   2 2
    1

Two changes happen from one row to the next:

Leading Spaces → Increase
Numbers        → Decrease

The same number is repeated throughout each row.

Step 1 — Read Number

num=int(input("Enter a number:"))

The value of num decides the number of rows.

Step 2 — Outer Loop

for i in range(1,num+1):

For num = 5, i takes:

1, 2, 3, 4, 5

Step 3 — Print Leading Spaces

print(" "*(i-1),end="")

Therefore:

i = 1 → 0 spaces
i = 2 → 1 space
i = 3 → 2 spaces
i = 4 → 3 spaces
i = 5 → 4 spaces

Step 4 — Print Numbers

print(num-i+1,end=" ")

The printed value decreases:

5 → 4 → 3 → 2 → 1

The number of repetitions also decreases.

i	Spaces	Printed Value	Repetitions
1	0	5	5
2	1	4	4
3	2	3	3
4	3	2	2
5	4	1	1

Pattern-72 prints descending number sequences.

Output for num = 5

5 4 3 2 1
 4 3 2 1
  3 2 1
   2 1
    1

The first value decreases on every row:

5 → 4 → 3 → 2 → 1

Every row ends with 1.

The important expression is:

num + 2 - i - j

For num = 5 and i = 1:

j = 1 → 5 + 2 - 1 - 1 = 5
j = 2 → 5 + 2 - 1 - 2 = 4
j = 3 → 3
j = 4 → 2
j = 5 → 1

Therefore, the first row becomes:

5 4 3 2 1

For i = 3:

3 2 1

Feature	Pattern-71	Pattern-72
Values in Row	Repeated	Changing
First Row	5 5 5 5 5	5 4 3 2 1
Printed Expression	num-i+1	num+2-i-j
Alignment	Right	Right

Pattern-73 is the alphabet version of Pattern-71.

Output for num = 5

E E E E E
 D D D D
  C C C
   B B
    A

The alphabet changes from:

E → D → C → B → A

The selected alphabet is repeated throughout its row.

The alphabet is calculated using:

chr(65 + num - i)

For num = 5:

i = 1 → chr(69) → E
i = 2 → chr(68) → D
i = 3 → chr(67) → C
i = 4 → chr(66) → B
i = 5 → chr(65) → A

The number of repetitions is:

num + 1 - i

Therefore:

E → 5 times
D → 4 times
C → 3 times
B → 2 times
A → 1 time

Pattern-74 prints alphabets in reverse order inside each row.

Output for num = 5

E D C B A
 D C B A
  C B A
   B A
    A

The starting alphabet changes:

E → D → C → B → A

Every row finally reaches A.

The inner loop is:

for j in range(num+1-i,0,-1):

For num = 5:

i = 1 → j = 5,4,3,2,1
i = 2 → j = 4,3,2,1
i = 3 → j = 3,2,1
i = 4 → j = 2,1
i = 5 → j = 1

The expression:

chr(64+j)

converts these numbers into:

1 → A
2 → B
3 → C
4 → D
5 → E

Since j decreases, the alphabet sequence is also reversed.

Pattern-75 prints a forward alphabet sequence while the row size decreases.

Output for num = 5

A B C D E
 A B C D
  A B C
   A B
    A

Every row begins with:

A

The ending alphabet changes:

E → D → C → B → A

The leading spaces are:

i - 1

The inner loop executes:

num + 1 - i

times.

The alphabet is generated using:

chr(64+j)

Therefore:

Row 1 → A B C D E
Row 2 → A B C D
Row 3 → A B C
Row 4 → A B
Row 5 → A

Pattern	Type	First Row
73	Repeated Alphabet	E E E E E
74	Reverse Alphabet Sequence	E D C B A
75	Forward Alphabet Sequence	A B C D E