**π‘ Problem Formulation:** Imagine you need a Python program that can read a number `n`

and construct a pattern of natural numbers up to that number, which when summed row-wise will give you the sequence of triangular numbers. For instance, if your input `n`

is `4`

, the desired output will be a pattern where the first row is `1`

, second row `2 3`

, third row `4 5 6`

, and so forth.

## Method 1: Using Loops

This method uses nested loops to construct the summation pattern. The outer loop runs from 1 to `n`

, while the inner loop prints the sequence of numbers which continually increments. Each new line represents the sum of an increasing sequence of natural numbers.

Here’s an example:

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

Output:

1 2 3 4 5 6 7 8 9 10

The `print_summation_pattern`

function takes an integer `n`

, then iterates through an increasing range of numbers to print each row of the summation pattern. The `num`

variable keeps track of the current number to print, and `end=" "`

ensures that numbers are printed on the same line with a space.

## Method 2: Using List Comprehension

List comprehensions provide a concise way to create lists, and in this case, the list comprehension is used within a function to print the natural number summation pattern.

Here’s an example:

def print_summation_pattern_lc(n): num = 1 [print(*(range(num, num + i))) or (lambda x: exec('global num\nnum += x'))(i) for i in range(1, n+1)] print_summation_pattern_lc(4)

Output:

1 2 3 4 5 6 7 8 9 10

This method declares a lambda function inside the list comprehension to increment the `num`

variable. The `print`

function is used with argument unpacking (* operator) to print each sub-range of natural numbers forming the summation pattern.

## Method 3: Using itertools

This method utilizes the `itertools`

module to create an iterator that accumulates the sum of natural numbers and prints them in a pattern.

Here’s an example:

from itertools import count def print_summation_pattern_itertools(n): nums = count(1) for i in range(1, n+1): print(" ".join(str(next(nums)) for _ in range(i))) print_summation_pattern_itertools(4)

Output:

1 2 3 4 5 6 7 8 9 10

The `print_summation_pattern_itertools`

function takes advantage of the `count`

function from `itertools`

, which returns an iterator that produces consecutive integers starting from the number 1, and prints the required summation pattern.

## Method 4: Using Recursion

This method uses recursion to construct the pattern. It prints each row and then calls itself with the updated starting number and the decremented `n`

until `n`

is zero.

Here’s an example:

def print_summation_pattern_recursive(n, start=1): if n > 0: print(" ".join(str(start + i) for i in range(n))) print_summation_pattern_recursive(n-1, start + n) print_summation_pattern_recursive(4)

Output:

1 2 3 4 5 6 7 8 9 10

This recursive function `print_summation_pattern_recursive`

prints the first row and then invokes itself with a new starting number which is the sum of `n`

and `start`

. It stops when `n`

reaches zero, thus completing the pattern.

## Bonus One-Liner Method 5: Using Range and Join

This one-liner approach utilizes the `join`

method and range within a generator expression to print the pattern efficiently.

Here’s an example:

def print_pattern_oneliner(n): print("\n".join(" ".join(str(x) for x in range(i, i+j)) for j in range(1, n+1) for i in range(j*(j-1)//2, j*(j-1)//2+j))) print_pattern_oneliner(4)

Output:

1 2 3 4 5 6 7 8 9 10

This one-liner function `print_pattern_oneliner`

uses nested generator expressions to create strings for each row and joins each row with a newline character. The range for each row starts with the sum of integers up to `j-1`

and ends with the sum of integers up to `j`

.

## Summary/Discussion

**Method 1:**Using Loops. Straightforward and easy to understand. Can be slightly verbose for large patterns.**Method 2:**Using List Comprehension. Compact and elegant, but may be less readable for those unfamiliar with list comprehensions and lambdas.**Method 3:**Using`itertools`

. Offers good readability and utilizes powerful standard library tools. Might be less intuitive for beginners.**Method 4:**Using Recursion. Offers a neat recursive solution. However, recursion can lead to stack overflow for large values of`n`

.**Bonus Method 5:**Using Range and Join. Extremely concise. Can be a single, hard-to-read line of code which may reduce maintainability.