Printing staircase revisited

Question

What can be more elegant ways to solve the given problem.

    #
   ##
  ###
 ####

Code:

function StairCase(n) {
    for (var i = 1; i <= n; i++) {
        var col = i;
        for(var j = 1; j <= n - col; j++) {
            process.stdout.write(' ');
        }
        for(var j = 1; j <= col; j++) {
            process.stdout.write('#');
        }
        process.stdout.write('\n');
    }

}

Answer 1

JavaScript function names should start with a lowercase character, and "staircase" is one compound word in English.

Since every line is nearly the same, and only one character changes at a time, you should take advantage of that and use an array as a buffer.

function staircase(n) {
    var line = Array(n + 1).fill(' ');
    line[n] = '\n';
    for (var i = n - 1; i >= 0; i--) {
        line[i] = '#';
        process.stdout.write(line.join(''));
    }
}

Answer 2

No need for the additional for loops:

function StairCase(n) {
    var s = '';
    for (var i = 1; i <= n; i++) {
            s += ' '.repeat(n - i) + '#'.repeat(i)  + '\n';
    }
    return s;
}

If you don't have repeat for some reason, another implementation could be:

String.prototype.Repeat = function(count) {
    var ret = '';
    for(var i = 0; i < count; i++){
        ret += this.valueOf();
    }
    return ret;
}

function StairCase(n) {
    var s = '';
    for (var i = 1; i <= n; i++) {
            s += ' '.Repeat(n - i) + '#'.Repeat(i)  + '\n';
    }
    return s;
}

Answer 3

This traditional Javascript code works fine:

function staircase(n) {
  var line = Array(n + 1).fill(' ');
  //line[n] = '';
  for (var i = n - 1; i >= 0; i--) {
    line[i] = '#';
    console.log(line.join(''));
  }
}

and ES6 we can write:

const staircase = n => {
  const line = Array(n + 1).fill(' ');
  //line[n] = ''; 
  for (let i = n - 1; i >= 0; i--) {
    line[i] = '#';
    console.log(line.join(''));
  }
}

If our given input is 6 the output should be:

     #
    ##
   ###
  ####
 #####
######

Answer 4

No need to use two for loops, you can use repeat function inside for loop.

See the below example.

var staircase = "",
    n = 6,
    space = " ",
    hash = "#";
for(var i = n ; i > 0 ;i--){
    staircase+=space.repeat(i-1).concat(hash.repeat(n-(i-1))) + "\n";
}
console.log(staircase);

Output Will be :

     #
    ##
   ###
  ####
 #####
######

Answer 5

The last loop must not be the same as the previous one, because the problem ask for not leave any space characters. So You need to skip from creating it as '\n'.

let i = 0;
let stair = '';

for (i = 1; i <= n; i++){
    if (i < n) {
    stair += ' '.repeat(n - i) + '#'.repeat(i) + '\n';   
    } else {
        stair += '#'.repeat(i);   


    } 
}

console.log(stair)

}

Answer 6

I prefer use functional and prototypical inheritance over native loops because it's cleaner. And I use MAP because ES6 feature is far more short and useful, though MAP has no side effects.

const reversedArr = (n) => Array.from(Array(n).keys()).reverse()

const staircase = (n) => reversedArr(n).map((value, index) => {
        return console.log(' '.repeat(value)+'#'.repeat(index+1)+'\n')
    })

staircase(50)

func is a output of a logic: Array.from(Array(n).keys()).reverse() that receives n:integer parameter.

Array.from is a new syntax from ES6, it means that you can fill an array from "here" to "there" ie: Array.from(0, 6) returns [0,1,2,3,4,5,6]

so all the staircase(n) return is a output of map of this array. Such array that receive Array(n).keys() and reverses it with prototype reverse()

so that the array could be: [6,5,4,3,2,1,0] instead.

the map repeat iterate over the array created from Array.from(Array(n).keys()).reverse() and return a log for each item such as every item repeats ' ' (blank space) + "#" at the end of this string.

Answer 7

Here is the solution using ES6 array.map() with no for-loop used, which to me is the most clear and intuitive solution:

function staircase(n) {
    // intiate an empty n*n matrix
    let matrix = Array(n).fill().map(() => Array(n).fill());

    matrix.map((curArr, idY) => { // for each array row in matrix
        curArr.map((curVal, idX) => { // for each element in the current array row
            // evaluate each element's to-be-assigned value
            matrix[idY][idX] = (idX + idY + 1 >= n) ? '#' : ' ';
        }, [])
    }, [])

    // convert each row into string
    matrix.forEach((row) => {
        console.log(row.join(''));
    })
    // now we have the staircase
}

If you're interested, go researching about functional programming, pure functions and immutability.

Answer 8

No need to declare loads of variables.

function staircase(n) {
    let a = "#";
    for(let i =1;i<=n;i++){
        console.log(" ".repeat(n-i)+a.repeat(i))
    }
}