Number pattern in JavaScript

Number patterns in JavaScript are essential for developers who want to create visually appealing outputs and understand algorithmic thinking. These patterns involve generating sequences of numbers that follow specific rules or arrangements, helping developers grasp mathematical concepts that underlie complex algorithms.

What are Number Patterns?

Number patterns are sequences of numbers arranged in specific formations, typically displayed in triangular or pyramid structures. Each pattern follows a mathematical rule that determines how numbers are positioned and incremented.

Pattern 1: Zero-Padded Triangle

This pattern creates a triangular structure where each row contains numbers from 1 to the row number, with zero-padding for formatting.

Input: 4

Expected Output:

01 
01 02 
01 02 03 
01 02 03 04

Implementation

function getPattern(n) {
    // Loop through each row 
    for (let i = 1; i <= n; i++) { 
        // Create an empty string for the row 
        let row = ""; 
        
        // Loop through each column in the row 
        for (let j = 1; j <= i; j++) { 
            // Add the column number to the row with zero padding
            row += j.toString().padStart(2, "0") + " "; 
        } 
        // Print the row 
        console.log(row); 
    } 
}

const n = 4;
getPattern(n);

01 
01 02 
01 02 03 
01 02 03 04 

Pattern 2: Simple Number Pyramid

This pattern generates a simple triangular arrangement where each row shows numbers from 1 to the current row number.

function generateNumberPyramid(rows) {
    let pattern = '';
    for (let i = 1; i <= rows; i++) {
        for (let j = 1; j <= i; j++) {
            pattern += j + ' ';
        }
        pattern += '<br>';
    }
    return pattern;
}

// Example usage:
console.log(generateNumberPyramid(5));

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

Pattern 3: Floyd's Triangle

Floyd's Triangle is a right-angled triangle where consecutive natural numbers fill each row. Unlike previous patterns, numbers continue incrementing across rows.

function generateFloydsTriangle(rows) {
    let pattern = '';
    let num = 1;
    for (let i = 1; i <= rows; i++) {
        for (let j = 1; j <= i; j++) {
            pattern += num + ' ';
            num++;
        }
        pattern += '<br>';
    }
    return pattern;
}

// Example usage:
console.log(generateFloydsTriangle(4));

1 
2 3 
4 5 6 
7 8 9 10

Pattern 4: Pascal's Triangle

Pascal's Triangle uses binomial coefficients where each number is the sum of the two numbers above it. The first and last numbers in each row are always 1.

function generatePascalsTriangle(rows) {
    let pattern = '';
    for (let i = 0; i < rows; i++) {
        let row = '';
        for (let j = 0; j <= i; j++) {
            let coef = factorial(i) / (factorial(j) * factorial(i - j));
            row += coef + ' ';
        }
        pattern += row.trim() + '<br>';
    }
    return pattern;
}

function factorial(num) {
    if (num <= 1) {
        return 1;
    }
    return num * factorial(num - 1);
}

// Example usage:
console.log(generatePascalsTriangle(5));

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1

Key Programming Concepts

All these patterns use nested loops where the outer loop controls rows and the inner loop handles columns. String concatenation builds each row, and mathematical functions like factorials enable complex patterns like Pascal's Triangle.

Conclusion

Number patterns in JavaScript demonstrate fundamental programming concepts like loops, string manipulation, and mathematical operations. These patterns are useful for algorithm practice, visual displays, and understanding mathematical relationships in code.