# 5 Innovative Ways to Print Natural Numbers Summation Pattern in Python

π‘ 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.