Print Triangle of Stars in JavaScript (Time Complexity: O(n))

Given a positive integer n print a triangle of stars as in the example below

Example:

Input: n = 5
Output:
*
**
***
****
*****
Explanation: Print 5 lines, on ith line print i stars.

Understanding the Problem

The core challenge of this problem is to generate a pattern of stars in the shape of a right-angled triangle. This is a common problem in programming that helps in understanding loops and string manipulation.

Common applications of such problems include generating patterns for console-based applications, understanding nested loops, and practicing basic algorithmic thinking.

Potential pitfalls include off-by-one errors and misunderstanding the loop boundaries.

Approach

To solve this problem, we need to print a series of lines where each line contains an increasing number of stars. The simplest way to achieve this is by using a loop that iterates from 1 to n, printing i stars on the ith iteration.

Let's discuss a naive approach and then an optimized approach:

Naive Approach

The naive approach involves using a single loop to iterate from 1 to n and printing the stars directly within the loop. This approach is straightforward but not very flexible for more complex patterns.

Optimized Approach

The optimized approach is similar to the naive approach but can be extended for more complex patterns. It involves constructing the string of stars for each line and then printing it. This makes the code more modular and easier to extend.

Algorithm

Here is a step-by-step breakdown of the algorithm:

Initialize a loop that runs from 1 to n.
In each iteration, construct a string of i stars.
Print the constructed string.

Code Implementation

// Function to print a triangle of stars
function printTriangleOfStars(n) {
    // Loop from 1 to n
    for (let i = 1; i <= n; i++) {
        // Construct the string of stars
        let stars = '*'.repeat(i);
        // Print the string of stars
        console.log(stars);
    }
}

// Example usage
printTriangleOfStars(5); // Output: 
// *
// **
// ***
// ****
// *****

Complexity Analysis

The time complexity of this approach is O(n) because we have a single loop that runs n times. The space complexity is O(1) as we are using a constant amount of extra space.

Edge Cases

Potential edge cases include:

n = 1: The function should print a single star.
n = 0: The function should not print anything.
Negative values of n: The function should handle this gracefully, possibly by not printing anything.

Example edge case:

Input: n = 0
Output: (no output)

Testing

To test the solution comprehensively, consider the following test cases:

n = 1
n = 5
n = 0
n = -1

Use console.log to verify the output for each test case.

Thinking and Problem-Solving Tips

When approaching such problems, start by understanding the pattern and breaking down the problem into smaller parts. Practice similar problems to improve your problem-solving skills. Use online coding platforms to find and solve related problems.

Conclusion

In this blog post, we discussed how to print a triangle of stars given a positive integer n. We covered the problem definition, approach, algorithm, code implementation, complexity analysis, edge cases, and testing. Understanding and solving such problems is crucial for developing strong programming skills.

Additional Resources

For further reading and practice, consider the following resources: