如何使用JavaScript显示金字塔？

下面是显示金字塔的代码，但它并不完全生成所需的输出

函数生成锥（）{
var totalNumberofRows=5；
var arr=新数组（）；
对于（var i=1；i您应该在每一行迭代中生成一个数组，并在最后输出它：

function generatePyramid() {
    var totalNumberofRows = 5,
        arr;
    for (var i = 1; i <= totalNumberofRows; i++) {
        arr = [];
        for (var j = 1; j <= i; j++) {
            arr.push(j);            
        }
        console.log(arr.join(" ") + "\n");
    }
}

函数生成锥（）{
var totalNumberofRows=5，
arr；
对于（var i=1；i请尝试以下代码


函数生成锥（）{
var totalNumberofRows=5；
var输出=“”；
对于（var i=1；i这可以使用单个for循环来完成


var num=”“；
var size=提示（“输入棱锥体的大小”）；
对于（var i=1；i为什么不这样

let printPyramid = (n) => {
    if (n===0) {
        return false;
    } else {
        let arr = [];
        for(let i=0; i<n; i++) {
           arr.push(i);
           console.log(arr.toString());
        }
    }
}

let printPyramid=（n）=>{
如果（n==0）{
返回false；
}否则{
设arr=[]；
对于（设i=0；i这将在控制台中创建一个适当的棱锥体：


函数createPyramid（行）
{
for（设i=0；i函数生成锥（num）{
对于（var i=1；i，这里有一个使用ES6语法的简单解决方案

function generatePyramid(num) {
  let number = '';

  for (let i = 1; i <= num; i++) {
    console.log(number += i);
  }
}
generatePyramid(5);

函数生成锥（num）{
让数字=“”；
对于（设i=1；i
const金字塔=（n）=>{
常数mid=数学层（（2*n-1）/2）；
对于（让row=0；row数字金字塔的简单代码

for(var i=1; i<=5; i++){
 var Num='';
 for(var j=0; j<i; j++){
     Num += i;
 }
 print(Num) }

for（var i=1；i其他选项
一行代码：

function generatePyramid(n) {
    return [...Array(n)]
        .forEach((_, i) => console.log([...Array(++i)].map((_, j) => ++j).join(' ')));
}

**您可以为给定的任何图案设置循环条件的框架，可以是三角形、直角三角形、倒三角形等。有关更多信息，请参阅下面的代码和工作簿图像。
PS：在步骤6中的工作簿图像中，它是2+i而不是3+i，因此j>=4-i&&j=n+1-i&&j=4-i&&j=n+1-i&&j<=n-1+i

1,3,5,7,9=>
奇数系列（星星）以金字塔模式出现

1,2,3,4,5=>
计数器（行数）

每个计数器都存在
（2*n）-1
值

函数金字塔（n）{//输入或行数
对于（var i=1；i一个有趣的小解决方案：）


//在此处设置n的值
var n=5；
三角形（n）；
函数生成器三角形（n）{
var width=（2*n）-1；//始终如此。
var midpoint=Math.floor（宽度/2）；//金字塔的中间。
let level=''；//将在每个级别循环中重置
对于（var i=0；imiddpoint+i）{
级别+='；
}否则{
级别+='#'；
}
}
控制台日志（级别）；
}
}
在这种情况下，我会坚持使用递归方法：


函数generatePyramid（n，行=0，行=''，数=1）{
如果（行===n）{
返回；
}
if（line.length==n）{
console.log（行）
返回发电机金字塔（n，第+1行）
} 
if（line.length）使用JavaScript在控制台上绘制金字塔
使每行具有奇数个填充字符
在每行前面加上空格（或“间隔字符”），不包括最后一行。
为此：

使用
repeat（）
确定每行的间隔字符数。可以将行数-1作为参数传递

这是我的解决办法


函数drawPyramid（线条、填充字符、间隔字符）{
让fillChars=''；
设间隔符=SpaceChar | |“”；//默认间隔符为“”
让间隔器计数=行；
for（设i=1；i=2）
fillChars=fillChar+fillChars；
控制台日志（间隔器重复（间隔器计数-1）+填充字符）；
计数--；
}
}
drawPyramid（4，“*”）；
最简单的解决方案是：-


函数金字塔（n）{
对于（设i=1；i假设您希望返回数字，而不是其他答案所示的星号，以下是解决方案：

请注意，此解决方案以线性（O（n））时间复杂度运行，不会通过将每一行记录到控制台而牺牲性能，而是一次记录整个金字塔

function generatePyramid(n) {
  let pyramid = '';
  let prev;

  for (let i = 1; i <= n; i++) {
    if (prev) {
      pyramid += '\n';
      prev =  prev + ' ' + i;
    } else {
      prev = i;
    }
    pyramid += ' '.repeat(n - i) + prev;
  }

  return pyramid;
}

捷径

 function generatePyramid(n) {
        var output="";
        for (var i = 1; i <= n; i++) {
            output += i + " ";
            console.log(output);
        }
    }  

    generatePyramid(5);

函数生成器金字塔（n）{
var输出=”；
对于（var i=1；i如果我们讨论的是“金字塔”问题，那么这将是一个合适的解决方案

function pyramid(n) {
// generate base of pyramid, aka longest possible string
let limit = n+n-1;

let hashesToPrint = 1; // number of hashes to print
for (let i=0; i<n; i++) {
    
    // get length of spaces we need on each side
    let difference = (limit - hashesToPrint) / 2;
    
    // generate spaces string
    let spaces = ' '.repeat(difference);

    // create pounds string
    let pounds = '#'.repeat(hashesToPrint);

    // append spaces on either side of our pound string
    let newString = spaces + pounds + spaces

    console.log(newString)

    // increment our counter by two
    hashesToPrint += 2
}


函数金字塔（n）{//如果（例如）n=3；
常量columnLength=（n*2）-1；//5
让middle=Math.floor（columnLength/2）//中间应该是2
如果要使用符号或单个数字打印直角三角形，请使用（让row=0；row）

let pyramid = '';
for(pyramid.length=0; pyramid.length<=7 ; pyramid+='#'){
  console.log(pyramid);
}

让金字塔=”；
对于（棱锥体长度=0；棱锥体长度函数棱锥体（n）{
常数中点=数学楼层（（2*n-1）/2）

for（设行=0；行
for（让列=0；列<2*n-1；列++）
{
如果（中点行=
（列）{
级别+='#'；
}
否则{
级别+=''；
}
}
控制台日志（级别）；
}

}

金字塔（5）；
这么多鼓舞人心的答案；
我想加上我的：）

设m，o，r，c，pr=（n，x=（n{
m=（x>>1）最简单的解决方案之一是使用.repeat函数


let count=1；
设x=“#””；
对于（a=0；a我的解决方案

function pyramid(n) {
// generate base of pyramid, aka longest possible string
let limit = n+n-1;

let hashesToPrint = 1; // number of hashes to print
for (let i=0; i<n; i++) {
    
    // get length of spaces we need on each side
    let difference = (limit - hashesToPrint) / 2;
    
    // generate spaces string
    let spaces = ' '.repeat(difference);

    // create pounds string
    let pounds = '#'.repeat(hashesToPrint);

    // append spaces on either side of our pound string
    let newString = spaces + pounds + spaces

    console.log(newString)

    // increment our counter by two
    hashesToPrint += 2
}

函数金字塔（n）{
//生成金字塔的底部，也称为最长的字符串
设极限=n+n-1；
让hashesToPrint=1；//要打印的哈希数
对于（设i=0；i
函数金字塔（行）{
对于（var i=0；i那么什么是必需的输出？图像是必需的输出如何以这种格式显示？我不认为它将显示为金字塔，它将几乎只显示与问题中的OP相同的内容，这不是期望的结果。当在控制台中执行时：1 12 123 1234 12345这不是问题所要求的吗不，那是
            *
VM74:11    ***
VM74:11   *****
VM74:11  *******
VM74:11 ********* 

function generatePyramid(n) {
  let pyramid = '';
  let prev;

  for (let i = 1; i <= n; i++) {
    if (prev) {
      pyramid += '\n';
      prev =  prev + ' ' + i;
    } else {
      prev = i;
    }
    pyramid += ' '.repeat(n - i) + prev;
  }

  return pyramid;
}

function drawTriangle(n) {
  let triangle = '';
  let prev;
  for (let i = 1; i <= n; i++) {
    if (prev) {
      triangle += '\n';
      prev = prev + ' ' + i;
    } else {
      prev = i;
    }
    triangle += prev;
  }
  return triangle;
}

 function generatePyramid(n) {
        var output="";
        for (var i = 1; i <= n; i++) {
            output += i + " ";
            console.log(output);
        }
    }  

    generatePyramid(5);

let pyramid = '';
for(pyramid.length=0; pyramid.length<=7 ; pyramid+='#'){
  console.log(pyramid);
}

 for(let column = 0 ; column < 2*n-1 ; column++)
    {
     if(midpoint-row <= column && midpoint + row >= 
        column){
        level += '#';
       }
       else{
           level += ' ';
           }

    }
   console.log(level);
  }

    let m, o, r, c, pr = (n, x = (n << 1) - 1) => {
        m = (x >> 1) << 0;
        o = '';
        for (r = 0; r < n; r++) {
            for (c = 0; c < x; c++)
                o += (m - r <= c && m + r >= c) ? "#" : " ";
            o += '\n';
        }
        console.log(o);
    }

    pr(5);
    pr(20);
    pr(2);

function pyramid(n) {
// generate base of pyramid, aka longest possible string
let limit = n+n-1;

let hashesToPrint = 1; // number of hashes to print
for (let i=0; i<n; i++) {
    
    // get length of spaces we need on each side
    let difference = (limit - hashesToPrint) / 2;
    
    // generate spaces string
    let spaces = ' '.repeat(difference);

    // create pounds string
    let pounds = '#'.repeat(hashesToPrint);

    // append spaces on either side of our pound string
    let newString = spaces + pounds + spaces

    console.log(newString)

    // increment our counter by two
    hashesToPrint += 2
}