Method 1: Using Nested Loops
def print_pattern(rows):
for i in range(rows):
num = 1
for j in range(1, i + 2):
print(num, end='')
num = num * (i + 1 - j) // j
print()
print_pattern(5)
# Change the argument to adjust the number of rows
let's break down the code step by step:
def print_pattern(rows):: This line defines a function named print_pattern that takes one argument rows, which represents the number of rows in the pattern.
for i in range(rows):: This loop iterates over each row of the pattern. It goes from 0 to rows - 1.
num = 1: Initializes the variable num to 1 for each row. This variable will hold the numbers to be printed on each row.
for j in range(1, i + 2):: This loop iterates over each column in the current row. It goes from 1 to i + 1.
print(num, end=''): Prints the value of num without a newline character. This ensures that all numbers in the same row are printed on the same line.
num = num * (i + 1 - j) // j: This line updates the value of num for the next column. It calculates the next number in the row based on the previous number using the formula (i + 1 - j) / j. This formula generates Pascal's triangle pattern.
print(): Prints a newline character after printing all numbers in the current row, moving to the next row.
print_pattern(5): Calls the print_pattern function with an argument of 5, which means it will print a pattern with 5 rows. You can change this argument to adjust the number of rows in the pattern.
The pattern generated by this code resembles Pascal's triangle, where each number in a row is the sum of the two numbers directly above it in the previous row.
Method 2: Using Recursion
def print_pattern_recursive(rows):
if rows == 0:
return
print_pattern_recursive(rows - 1)
row = [1]
for i in range(1, rows):
row.append(row[-1] * (rows - i) // i)
print("".join(map(str, row)))
print_pattern_recursive(5)
# Change the argument to adjust the number of rows
let's break down the code step by step:
def print_pattern_recursive(rows):: This line defines a function named print_pattern_recursive that takes one argument rows, which represents the number of rows in the pattern.
if rows == 0:: This is the base case for the recursion. If rows is equal to 0, the function returns immediately, as there's no pattern to print.
return: This statement exits the function immediately if the base case is met.
print_pattern_recursive(rows - 1): This is the recursive call. It calls the print_pattern_recursive function with rows - 1, effectively reducing the number of rows to be printed in each recursive call.
row = [1]: Initializes a list row with a single element, 1. This represents the first row of the pattern.
for i in range(1, rows):: This loop iterates over each row index starting from 1 up to rows - 1.
row.append(row[-1] * (rows - i) // i): This line calculates and appends the next number to the row list. It uses the formula to generate Pascal's triangle pattern: (previous_number * (rows - i)) / i. This formula generates each number in the current row based on the numbers in the previous row.
print("".join(map(str, row))): This line prints the current row as a string by joining all elements in the row list and separating them with an empty string. This effectively prints the numbers of the current row without spaces between them.
print_pattern_recursive(5): Calls the print_pattern_recursive function with an argument of 5, which means it will print a pattern with 5 rows. You can change this argument to adjust the number of rows in the pattern.
The pattern generated by this code is similar to Pascal's triangle, where each number in a row is the sum of the two numbers directly above it in the previous row. However, this code generates each row recursively.
Method 3: Using List Comprehension
def print_pattern_list_comprehension(rows):
pattern = [[1]]
[pattern.append([1] + [pattern[-1][j] + pattern[-1][j + 1] for j in range(len(pattern[-1]) - 1)] + [1]) for _ in range(1, rows)]
[print("".join(map(str, p))) for p in pattern]
print_pattern_list_comprehension(5)
# Change the argument to adjust the number of rows
Let's break down the code step by step:
def print_pattern_list_comprehension(rows):: This line defines a function named print_pattern_list_comprehension that takes one argument rows, representing the number of rows in the pattern.
pattern = [[1]]: Initializes a list pattern with a nested list containing a single element, which is [1]. This represents the first row of the pattern.
[pattern.append([1] + [pattern[-1][j] + pattern[-1][j + 1] for j in range(len(pattern[-1]) - 1)] + [1]) for _ in range(1, rows)]: This is a list comprehension that generates the pattern rows. It iterates over a range starting from 1 up to rows - 1.
pattern[-1] accesses the last row in the pattern list.
[pattern[-1][j] + pattern[-1][j + 1] for j in range(len(pattern[-1]) - 1)] generates the elements of the new row based on the previous row. It iterates over indices j of the previous row and calculates each element by summing adjacent elements.
[1] is appended at the beginning and end of the row to maintain the pattern structure.
pattern.append(...) adds the newly generated row to the pattern list.
[print("".join(map(str, p))) for p in pattern]: This is another list comprehension that prints each row of the pattern. It iterates over each row p in the pattern list, converts each element to a string, joins them without any separator using "".join(), and then prints the resulting string.
print_pattern_list_comprehension(5): Calls the print_pattern_list_comprehension function with an argument of 5, which means it will print a pattern with 5 rows. You can change this argument to adjust the number of rows in the pattern.
The pattern generated by this code is similar to Pascal's triangle, where each number in a row is the sum of the two numbers directly above it in the previous row. However, this code utilizes list comprehensions to generate and print the pattern efficiently.
Posts
0 Comments:
Post a Comment