Playground - Dibuja un triangulo

¡Hola Platzinauta!

.

🛡️🛡️🛡️Este es un escudo anti spoilers🛡️🛡️🛡️

.
Los bucles son una herramienta súper poderosa y súper útil cuando necesitas pasar de nivel con los lenguajes de programación, además, de estos dependen la complejidad algoritmica de tus soluciones a problemas más grandes, un concepto del cual deberás preocuparte en un futuro no muy lejano.
.
Este ejercicio en cuestión, es súper interesante pero tiene un detalle muy interesante el cuál puede que haga que tu solución no pase pero aquí te explico el porque y la solución planteada ¿Lograrás resolverlo?
.
Procedo a poner un gif de un loop

Explicación

Si resolviste el problema pero tu solución no pasa, puede ser por este sutil pero importante detalle que deje en la guía.

Recuerda que para hacer el salto de línea debes usar “\n”, no olvides removerla de la última parte.

Primero te explicaré la solución la cuál incluye métodos avanzados que aprenderás a lo largo de este camino y posibles alternativas al código de solución
.

export function printTriangle(size, character) {
  // Inicializa mi array de elementos
  const triangle = [];
  // Empieza a iterar desde 1 hasta que el iterador sea igual a size
  for (let i = 1; i <= size; i++) {
    // inicializa una variable llamada "characters" que contendrá una cadena de caracteres repetidos. 
    // La cantidad de caracteres repetidos dependerá del valor de "i".
    let spaces = " ".repeat(size - i);
    // Después repetimos el carácter a pintar la cantidad de veces del iterador
    let characters = character.repeat(i);
    // Para después juntar el número de espacios y caracteres en un solo string
    let figure = `${spaces}${characters}`;
    // Y al final mandar esto al array inicial
    triangle.push(figure);
  }

  // La prueba nos pide un string, por lo que usaremos join() para convertir
  // El array en un string donde las comas sean reemplazadas por el salto de linea
  return triangle.join("\n");
}

Es importante mencionar que el método .join() propio de los arrays reemplaza las comas por el carácter dado
Ejemplo:

const names = ["Nico", "Juan", "Oscar"]
console.log(names.join(" Hola "))

Este código nos devolverá lo siguiente

"Nico Hola Juan Hola Oscar"

Excluyendo el “Hola” al inicio y al final del string, si usas otra alternativa deberás pensar en omitir el salto de linea “\n” del inicio y final del string resultante
.
¿Cómo te fue con este reto?

Saludos, les recomiendo que intenten hacer los ejercicios utilizando solamente los conceptos que se han tratado hasta este punto, evitando utilizar métodos que no se hayan tocado como manipulación de strings.

Una de las intenciones de estas practicas es ejercitar el pensamiento lógico y algoritmos.

Aquí les dejo un ejemplo usando solamente lo que se ha tocado hasta este tema.

export function printTriangle(size, character) {
  let triangle = "";
  let characterNumber = 1;
  while(characterNumber <= size){
      for (let j = 0; j < size - characterNumber; j++) {
        triangle += " ";
      }
      for (let j = 0; j < characterNumber; j++) {
        triangle += character;
      }
    if (characterNumber < size) { triangle += `\n` };
    characterNumber++;
    }
  
  return triangle;
}

En esta tengo que admitir que no tenia ni la mas minima idea de como hacerlo.

Solución

export function printTriangle(size, character) {
  let triangle = "";
  for (let i = size; i > 0; i--) {
    for (let j = 1; j <= size; j++) {
      triangle += j < i ? ' ' : character;
    }
    if(i > 1){
      triangle += `\n`;
    }
  }
  return triangle;
}

Sabías que…

Un triángulo rectángulo es un tipo de triángulo que tiene un ángulo recto, es decir, un ángulo de 90 grados. Los otros dos ángulos son agudos, es decir, tienen menos de 90 grados.

La característica principal de un triángulo rectángulo es que uno de sus lados es más largo que los otros dos. Este lado se llama hipotenusa y siempre se encuentra opuesto al ángulo recto. Los otros dos lados se llaman catetos, y se clasifican en cateto opuesto (altura) y cateto adyacente (base).

Solución:

/**
 * Generates a triangle of the specified size and character.
 * @param {number} size - Size of the triangle.
 * @param {string} character - Character to use for the triangle.
 * @returns {string} Right triangle.
 */
function printTriangle(size, character) {
    let triangle = "";
    for (let i = 1; i <= size; i++) {
        const blanks = " ".repeat(size - i)
        const characters = character.repeat(i)
        triangle += blanks + characters
        if (i < size) triangle += "\n"
    }
    return triangle
}

Nadie hizo el ejercicio con los temas que hemos visto. Me siento timado un poco con la solución de LeoCodeo.

Tonteria total, usando metodos aun no vistos.

Solución 😉

🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let string = ""
  for (let i = 1; i <= size; i++) {

    string += `${" ".repeat(size - i)}${character.repeat(i)}\n`
  }
  string = string.slice(0, -1)
  return string
}

Solución… 😄

Para el ejemplo de un tamaño 5. Si la suma de las coordenadas es mayor que el tamaño-1, imprimimos el carácter, sino sumamos un espacio.
.
Al recorrer toda una fila hacemos un salto de línea “\n”.
.
Al final podemos quitar el salto de línea sobrante con el método substring(), tomando la cadena que va desde el inicio hasta el (tamaño de la cadena)-1.
.

export function printTriangle(size, character) {
  let triangle = "";
  for (let i = 0; i < size; i++) { 
    for (let j = 0; j < size; j++) { 
      if ((i + j) >= (size - 1)) {
        triangle += character;
      } else { 
        triangle += " ";
      }
    }
    triangle += "\n";
  }
  return triangle.substring(0,triangle.length-1);
}

Pensé que se debía resolver sin usar alguna otra función como repeat(), yo lo hice así:

Mo solución al reto, desde un inicio sabia que debia usar metodos de array, me dio resultado pero no di con que la fila principal quedara en la parte derecha, use el repeat() propuesto por Leo…

aun asi me voy feliz 💛

El codigo sirve para VSCode ✅ no para el playground 🔴

Hola, dejo mi solucion
Caminito anti spoilers
🚗
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 📍

export function printTriangle(size, character) {
  let triangulo = '';
  for (let i = 1; i <= size; i++) {
    let line = '';
    const blanckcharacter = size - i;
    for (let n = 1; n <= size; n++) {
      line += n <= blanckcharacter ? " " : `${character}`;
    }
    const addLineBrak = i < size ? '\n' : '';
    triangulo += `${line}${addLineBrak}`
  }
  return triangulo;
}

Esto fue lo que pude lograr apenas 😦

Mi solución:

let piramid = ""
  let step = 1;
  while (size >0) {

    for (let j = size-1; j > 0 ; j--) {
      piramid = piramid + " ";
    }
    
    for (let i = 0; i < step; i++) {
      piramid = piramid + character;
    }

    if (size != 1) {
      piramid = piramid + "\n";
    }
    console.log(piramid)
    step++;
    size--;
  }
  return piramid

Este es el playground más complicado hasta el momento, pero logré solucionarlo utilizando lo aprendido hasta este punto aunque existen soluciones más sencillas utilizando algunos métodos:

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let triangle = ""
  for (let i = 1; i <= size; i++) {
    for (let j = 1; j <= size; j++) {
      if (j <= size - i) {
        triangle += " "
      } else {
        triangle += character
      }
    }
    triangle += (i != size) ? "\n" : ""
  }
  return triangle
}

**
*
*
*
*
*
*

function printTriangle(size, character) {
  // Tu código aquí 👈
  let textoFinal = '';
  for (let i = 1; i <= size; i++) {
    let figure = character.repeat(i).padStart(size) + '\n';
    textoFinal += figure;
  }
  return textoFinal.trimEnd(); //trim.end elimina espacios en blanco al final de una cadena de caracteres.
}

Mi solución:

function printTriangle(size, character) {
  const array=[];
  for(let i=1;i<=size;i++){
    const suma= character.repeat(i); 
    array.push(`${" ".repeat(size-suma.length)}${suma}`);
  }
  return array.join("\n");
}

Si se les dificulta y en algo les puedo ayudar, con mucho gusto me pueden preguntar.

Me parece que la solucion que muestrra como la sugerida o esperada, solo utiliza un ciclo for, y para la impresion de los caracteres utiliza funciones que ya estan en la experiencia de tener un conocimiento medio de Java script, aqui ya no llegue a esa solucion, y conozco el funcionamiento y uso de los cicls. Seguire practicando.

/*Despues de un día entero agregando y quitando espacios por fin se me dio (ANTI-ESPOILER)
.
.
.
.
.
.
.
.*/

export function printTriangle(size, character) {
  const figure = [];
  const space = " ";
  for (let i = 1; i <= size; i++) {
    figure.push(`${space.repeat(size - i) + character.repeat(i)}`);
  }
  return figure.join("\n");
}

😢🤦‍♀️🤢 estuvo muy hard.
export function printTriangle(size, character) {
let fila = ‘’;
for (let i = 1; i <= size; i++) {
fila += ’ '.repeat(size - i) + character.repeat(i) + ‘\n’;
}
return fila.trimEnd();
}
console.log(printTriangle(5, “*”));

export function printTriangle(size, character) {
  let array = [];
  for (var i = 1; i <= size; i++) {
    array.push(' '.repeat(size - i) + character.repeat(i))
  }
  return array.join("\n");
}
printTriangle(5, "*");
printTriangle(5, "*")

Mi solución al reto, similar al resto:

export function printTriangle(size, character) {
  let x = 1;
  let triangle = "";
  while (x <= size) {
    for (let j = 0; j < size - x; j++){
      triangle += " ";
    }

    for (let i = 1; i <= x; i++){
      triangle += character;
    }

    if (x < size) {
      triangle += `\n`;
    }

    x++;
  }
  return triangle;
}

export function printTriangle(size, character) {
let triangle = “”;
let space = size;
let temp = 0;
for (let i = 1; i <= size; i++) {
space–;
temp = space;
while (temp > 0) {
triangle = triangle + " ";
temp–;
}
temp = size - space;
while (temp > 0) {
triangle = triangle + character;
temp–;
}
if (i != size) {
triangle = triangle + “\n”;
}
}
return triangle;
}

MI humilde Aporte
export function printTriangle(size, character) {

let arrChar = [];
let espace = " ";
let adjunt = “”;
for (let i = 1; i <= size; i++){
adjunt = espace.repeat(size - i) + character.repeat(i)
arrChar.push(adjunt)
}

return arrChar.join(’\n’)
}

MI solucion:

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let string = "";
  for (let i = 0; i < size; i++){
    for (let j = 0; j < size; j++){
      if (i + j >= size - 1) {
        string += character;
      } else {
        string += " ";
      }
    }
    string += "\n";
  }
  return string.substring(0,string.length-1);
} 

Es trabajo humilde pero honesto

export function printTriangle(size, character) {
  var triangle = '';
  for (let i = 1; i <= size; i++){
    triangle += ' '.repeat(size - i);
    triangle += character.repeat(i);
      triangle += '\n';
  }

  return triangle.slice(0, -1);
}

Esta es la solución que pude realizar, realmente este playground sí me costó porque intenté hacerlo sólo con bucles hasta que leí en la documentación que existe el método ‘repeat’

String.prototype.repeat()

export function printTriangle(size, character) {

  let triangle = [];

  const space = ' ';

  for (let i = 1; i <= size; i++) {

    // number of empty spaces
    const insertSpaces = space.repeat(size - i);

    // number of characters
    const insertCharacters = character.repeat(i);

    const lineToInsert = `${insertSpaces}${insertCharacters}`;

    triangle.push(lineToInsert);
  }

  return triangle.join('\n')
}

Esta función, llamada “printTriangle”, toma dos argumentos: “size” y “character”. “size” es un número entero que indica el tamaño del triángulo que se desea imprimir y “character” es un carácter que se utilizará para construir el triángulo.

La función utiliza un bucle “for” anidado para construir el triángulo. En el bucle exterior, se crea una variable llamada “triangle” que inicialmente está vacía. Este será el resultado final que se devolverá.

En el bucle exterior, se utiliza una variable llamada “line” para iterar a través de cada línea del triángulo. En cada iteración, se inicia un nuevo bucle “for” para construir los espacios en blanco en la línea actual. La cantidad de espacios en blanco depende de la posición actual de la línea (determinada por la variable “line”) y del tamaño total del triángulo (determinado por el argumento “size”). Estos espacios en blanco se agregan al resultado “triangle” utilizando el operador “+=”.

Luego, en el segundo bucle “for”, se construyen los caracteres del triángulo. En cada iteración, se agrega el carácter especificado por el argumento “character” al resultado “triangle”. La cantidad de caracteres agregados depende de la posición actual de la línea (determinada por la variable “line”).

Finalmente, después de los bucles “for” anidados, se verifica si la línea actual es la última línea del triángulo (determinado por la variable “size”). Si no es así, se agrega un salto de línea “\n” al resultado “triangle”.

Cuando se completa la construcción del triángulo, se devuelve el resultado final “triangle”.

export function printTriangle(size, character) {
  let triangle = "";
  for (let line = 1; line <= size; line++) {

    for (let spaces = 0; spaces < size - line; spaces++) {
      triangle += " ";
    }

    for (let symbols = 0; symbols < line; symbols++) {
      triangle += character;
    }

    if (line != size) {
      triangle += "\n";
    }
  }

  return triangle
}

export function printTriangle(size, character) {
let triangle = “”;
for (let i = size; i > 0; i–) {
for (let j = 1; j <= size; j++) {
triangle += j < i ? ’ ’ : character;
}
if(i > 1){
triangle += \n;
}
}
return triangle;
}

Lo más difícil fue usar solamente recursos que se hayan visto en hasta acá y en el curso básico…

Esta fue mi forma de hacerlo:

export function printTriangle(size, character) {
  let salida = "";
  let simb = 1;
  let max = size;
  while (size > 0) {
    let esp = 0;
    for (let i = 1; i < size; i++) {
      salida += " ";
      esp++;
    }
    for (let j = 0; j < (max - esp); j++) {
      salida += character;
    }
    if (size > 1) {
      salida += "\n";
    }

    size--;
  }
  return salida;
}

SOLUCIÓN
SOLUCIÓN
SOLUCIÓN
SOLUCIÓN
SOLUCIÓN
.
.
.
.
.
.
Comparto mi solución

function printTriangle(size, character) {
    let triangle = "";
    let linea = "";
    for (let i = 1; i <= size; i++){
        if(linea.length < size){
            linea += " ".repeat(size -i);
            linea += `${character}`.repeat(i);
            triangle +=`${linea}\n`;
        }
        linea = "";
    }
    return triangle;
}
console.log("el resultado es\n"+printTriangle(6,"*"));

Hola mi opinión es la siguiente: si van a dejar ejercicios y despues una posible solucion no hacer esa misma con metodos y cosas que por el momento no se han visto porque si es asi no le miro sentido a esto. Entiendo y me gusta que el hacer los playgrounds con metodos, temas diferentes etc es bueno para conocer diferentes soluciones para que seamos curiososno y no quedarnos simplemente con los temas vistos pero la idea del reto es aprender y mejorar de una manera que entendamos todo lo visto para ser mejores de aqui en adelante.

// SPOILER ALERT SECTION
















// SPOILER ALERT SECTION

Mi solución hice tratando de usar solo lo que vimos hasta ahora anidando 3 bucles while y un operador ternario para comprobar si ya se llego a la línea final “PARA NO AGREGAR UN SALTO DEMAS” un motivo por el que vi que a muchos les da error.

function printTriangle(size, character) {
  let i = 1;
  let output = "";
  while (i <= size) {
    let line = "";
    let j = 1;
    while (j <= i) {
      line += character;
      j++;
    }
    let spaces = "";
    let k = 1;
    while (k <= size - i) {
      spaces += " ";
      k++;
    }
    output += spaces + line + (i < size ? "\n" : "");
    i++;
  }
  return output;
}

Se que hay formas de simplificar el código por ejemplo usando métodos repeat(), padStart() y algunos más por ahí que ví en otras soluciones, pero como dije, solo trate de usar lo visto hasta ahora.

Mi solución:

function printTriangle(size, character) {
  const triangle = []
  for (let i = 1; i <= size; i++) {
    triangle.push(character.repeat(i).padStart(size));
  }
  return triangle.join('\n');
}

Saludos a todos, esta es mi respuesta:

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let triangulo = "";
  for (let i = 0; i < size; i++) {
    for (let j = 1; j <= size; j++) {
      if (j < (size - i)) {
        triangulo = triangulo + ' ';
      }
      else {
        triangulo = triangulo + character;
      }
    }
    if (i < size - 1) {
      triangulo = triangulo + '\n';
    }
  }
  return triangulo;
}

Solución

Dejo espacios para no spoilearle a los demas.

export function printTriangle(size, character) {
  // Tu código aquí 👈
  for (let i=1; i<= size; i++) {
    console.log(character.repeat(i).padStart(size, " "))
  }
}

Hola, la verdad tuve muchos problemas con los ciclos anidados y la lógica, éste fue mi resultado, espero que puedan darme retroalimentación sin utilizar ningún tema próximo, sólo los vistos.

Muchas gracias

export function printTriangle(size, character) {
  let resultado = "";
  for (let i = 0; i < size; i++) {
    for (let j = 1; j < size - i; j++) {
      resultado = resultado + " ";
    }

    for (let j = 0; j < i + 1; j++) {
      resultado = resultado + character;
    }

    if (i < size - 1) {
      resultado = resultado + "\n";
    }
  }
  return resultado;
}

Me siento como muchos compañeros, creí que era aprender js en 30 días, no 30 días en que los que ya saben iban a reforzar conocimiento, esto su fue muy desmotivante.

Hola 😄, finalmente logre mi solución al ejercicio.

🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧
🚧

export function printTriangle(size, character) {
  let triangulo = '';
  let espacio = ' ';
  let bajarLaLinea = '\n'

  let contadorEspacio = 1;



  for (let i = 0; i < size; i++){

    for (let e = 0; e < size - contadorEspacio; e++){
          triangulo += espacio;
    }
    for (let c = 0; c < contadorEspacio; c++){
      triangulo += character;
    }
    if (contadorEspacio < size) {
      triangulo += bajarLaLinea;
    }
    contadorEspacio++;
  }
  return triangulo;
}

Esta es mi solución y si pasó las pruebas:

export function printTriangle(size, character) {
    let triangulo = "";
    for (let i = size; i > 0; i--) {
      for (let j = 1; j <= size; j++) {
        if (j < i)
          triangulo += " ";
        else
          triangulo += character;
      }
      if ( i > 1)
        triangulo += "\n";
    }
    return triangulo;
}

Escudos anti spoilers
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️

export function printTriangle(size, character) {
  // Cadena que almacenará los espacios en blanco y los caracteres
  let row = ''

  // for para determinar la altura del triangulo
  for (let i = 1; i <= size; i++) {
    // for para agregar espacios en blanco
    for (let j = 1; j <= size - i; j++) row += ' '

    // for para dibujar los caracteres
    for (let k = 1; k <= i; k++) row += character

    // Condicion para eliminar el salto de linea en la ultima linea
    if (i < size) row += '\n'
  }

  return row
}

My solution :

Hay un curso en donde el profe Oscar explica como usar esta funcion :

export function printTriangle(size, character) {
  let count = 1, triangulo = '';
  while (count <= size) {
    triangulo += `${character.padStart(count, character).padStart(size, ' ')}`
    count++;
    if (count <= size)
      triangulo += '\n'
  }
  return triangulo
}

export const printTriangle = (size, character) => {
  let result = [];
  for (let i = 0; i < size; i++) {
    result.push(`${character.padStart(i + 1, character)}`.padStart(size, ' '));
  }
  return result.join('\n');
}

si solo quieres imprimir XD

    for (let a = 1; a <= size ; a++) { 
 
        console.log(' '.repeat(size-a)+character.repeat(a));

    }```

Solución alternativa

export function printTriangle(size, character) {
    let triangle = "";
    for (let i = 1; i <= size; i++) {
        let space = " ".repeat(size - i)
        let asteriscos = character.repeat(i)
        triangle += space + asteriscos + "\n"
    }
    return triangle.trimEnd() //trimEnd elimina espacios al final
}

Veo muchas soluciones que utilizan dos for y aunque soluciona el problema no es lo mas optimo por su complejidad temporal. Siempre es bueno intentar optimizar nuestro codigo y dar soluciones en lo posible con complejidad temporal O(n). Comparto mi solucion propuesta.

export function printTriangle(size, character) {
  var result = "";
  for (let i = 1; i <= size; i++) {
    result += (" ".repeat(size - i)) + (character.repeat(i)) + "\n";
  }
  // delete last character
  return result.slice(0, -1);

Aquí dejo mi solución:
~
~
~
~
~
~
~
~
~
~
~

export 
  function printTriangle(size, character) {
    let space = " ";
    for (let i = 1; i <= size; i++) {
      console.log(space.repeat(size - i) + character.repeat(i));
    }
  }
  printTriangle(6, "*");

Dejo mi solución:
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function printTriangle(size, character) {
  let triangle = '';
  for (let i = size; i > 0; i--) {
    const whitespaces = ' '.repeat(i - 1);
    const repeatCharacters = character.repeat(size - i + 1);
    const breakline = i > 1 ? '\n' : '';
    triangle += whitespaces + repeatCharacters + breakline;
  }
  
  return triangle;
}

Hola Mi Solución.

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let triangle = "";
  for (let i = 1; i <= size; i++) {
    console.log
    let spaces = " ".repeat(size - i);
    let characters = character.repeat(i);
    triangle += spaces + characters;
    if (i < size) { 
      triangle += "\n";
    }
  }

  console.log(triangle);
  return triangle;
}

export function printTriangle(size, character) {
// Tu código aquí 👈
let espace = size
let line = ""
for (let i = 1; i <= size; i++) {
for (let j = espace; j > 1; j–) {
line = line + " "
}

for (let k = 1; k <= i; k++) {
  line = line + character
}
if (i<size) { line = line + "\n" }

espace--

}
return line
}

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function printTriangle(size, character) {
  debugger
  let triangle = ""
  let info = ""
  let spaces = ""

  for (let m = 0; m < size; m++) {
    spaces += " "
  }

  for (let i = 0; i < size; i++) {

    if (i < size - 1) {
      spaces = spaces.slice(0, -1)
      info += character
      triangle += `${spaces}${info}\n`
    } else {
      info += character
      triangle += `${info}`
    }
  }
  return (triangle)
}

Te comparto mi solución, Pensé primero en imprimir línea por línea, pero un console.log siempre agrega un salto de carro, así que llenamos todo en una variable.

-agregué el ultimo if porque agregaba un salto de carro al final.

export function printTriangle(size, character) {
  let espacioPintado = size - 1;
  let caracterPintado = 1;
  let triangulo = ""; 
  while (caracterPintado != size + 1) {
    for (let i = 1; i <= espacioPintado; i++) {
      triangulo += " ";
    }
    for (let i = 1; i <= caracterPintado; i++) {
      triangulo += character;
    }
    if (caracterPintado != size)
      triangulo += "\n";
    caracterPintado++;
    espaciosPintado--;
  }
  return triangulo;
}

en playcode me funciona asi

function printTriangle(size, character) {
  // Tu código aquí 👈
 let space = "&nbsp"
  let str = ""
  for (let x = 1; x <= size; x++) {

    str+=`${space.repeat(size - (x))}${character.repeat(x)}\n`
  }
  console.log(str)
}
printTriangle(6,"&")

al pasarlo aca asi:

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let space = "&nbsp"
  let str = ""
  for (let x = 1; x <= size; x++) {

    str += `${"".repeat(size - (x))}${character.repeat(x)}\n`
  }
  return str
}

no funciona, talves no entiende el caracter de espaciado &nbsp

Me gustó esta solución, sin hacer uso de arrays y sus metodos que aun no hemos visto (en este reto),
Recordé la propiedad .repeat() y .trimEnd() 😅😅

aqui mi código

export function printTriangle(size, character) {
  let string = ""
  for (let i = 1; i <= size; i++) {

    string += `${" ".repeat(size - i)}${character.repeat(i)}\n`
  }
  
  return string.trimEnd();
  
}

Un poco dificil de entender pero bueno

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let response = "";

  for (let i = 1; i <= size; i++) {
    let row = "";
    for (let empty = size - i; empty > 0; empty--) {
      row += " ";
    }
    for (let filled = 1; filled <= i; filled++) {
      row += character;
    }
    if (i == size) {
      response = response + row;
    } else {
      response = response + row + "\n";
    }
  }

  return response;
   
}

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function printTriangle(size, character) {
  let result = ""
  for (let index = 0; index < size; index++) {
    for (let i = 0; i < (size - 1) - index; i++) {
      result += " ";
    }
    for (let i2 = 0; i2 < index + 1; i2++) {
      result += character
    }
    if (index + 1 < size)
      result += '\n'
  }
  return result
}

Sé que se puede mejorar más, mucho más (a simple vista se ve que lo reborujé todo), pero ya corrió y pasó las pruebas. Después lo optimizo:
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

  // Tu código aquí 👈
  let cadena = "";
  for (let x = 0; x < size; x++) {
    for (let y = size; y > 0; y--) {
      if ((y - 1) > x) {
        cadena = cadena + " ";
      }
      else {
        cadena = cadena + character;
      }
    }
    if(x<(size-1)) cadena = cadena + "\n";
  }
  //console.log(cadena);
  return (cadena);

Algo simple, pero funciona jaja 😄

function printTriangle(size, character) {
	let triangle = [];

	for (let i = 1; i <= size; i++) {
		const row = character.repeat(i).padStart(size, ' ');
		triangle.push(row);
	}

	return triangle.join('\n');
}

Lo logré!
Alerta de spoiler…
🚨
🚨
🚨
🚨
🚨
🚨
🚨
🚨
🚨
🚨
🚨
🚨
🚨
🚨
🚨
🚨
🚨

export function printTriangle(size, character) {
  let triangulo = ""
  let numCaracter = 1
  let c = 0
  while (numCaracter <= size) {
    for (let i = 1; i <= size - numCaracter; i++) {
      triangulo += " "
      c ++
    }
    while ( c < size) {
      triangulo += character
      c++
    }
    
    if (numCaracter < size) {
      triangulo += "\n"
      c=0
    }
    numCaracter++
  }
  return triangulo
}

Hola Comparto mi solución.
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
?
function triangulo(size, simbol) {
console.log(tamaño: ${size} simbolo: ${simbol});
let contador = 1;
while (contador <= size) {
for (let index = 0; index < contador; index++) {
console.log(simbol);
}
contador++;
console.log("\n");
}
}
triangulo(3, “*”);

Esta fue mi solucion, me tomo toda la mañana

export function printTriangle(size, character) {
  let repeat = 1
  let count_space = size
  let space = ' '
  let result = ''
  let salto = '\n'
  while (repeat <= size) {
    if (repeat == size) {
      salto = ''
    }
    let space_blank = space.repeat(count_space - 1)
    result = result + space_blank + character.repeat(repeat) + salto
    count_space--
    repeat++
  }
  return result
}
printTriangle(5, "*")
Input: printTriangle(6, "$")

Mi solución usando repeat

El método repeat() construye y devuelve una nueva cadena que contiene el número especificado de copias de la cadena en la cual fue llamada, concatenados.

str.repeat(count)

export function printTriangle(size, character) {
  let texto = ""
  let str = ' ';
  for (let i = 1; i <= size; i++) {
    if (i == size) {
      texto += `${str.repeat(size - i)}` + `${character.repeat(i)}`
    } else {
      texto += `${str.repeat(size - i)}` + `${character.repeat(i)}` + "\n"
    }
  }
  return texto
}

Pues al final se logro
.
.
.
.
.
.
…
.

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let triangulo = '';
  for (let i = 1; i <= size; i++) { 
    for (let j = size; j >= 1; j--) {
      if (i == j || j<i) {
        triangulo += character;
      } else { 
        triangulo += ' ';
      }
    }
    i < size ? triangulo += '\n' : triangulo;
    }
  return triangulo;
}

por fin despues de tanto quebradero de cabeza, dejo mi codigo
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
export function printTriangle(size, character) {
// Tu código aquí 👈
let tri = ""
let cont = 1
for (let j = 1; j <= size; j++) {
for (let i = 1; i <= size - cont; i++) {
tri += " "
//tri += ‘’ + \n + '’
}
for (let i = 1; i <= cont; i++) {
tri += character

}

if (cont < size) {
  tri += `\n`
}
cont++

}
return tri

}

Acá les va mi solución uwu

export function printTriangle(size, character) {
  // Tu código aquí 👈
  // String temporal que contendra los carácteres en "2D" usando \n
  let tmpString = ''
  // for para recorrer las filas
  for (let i = 0; i <= size - 1; i++){
    // for para recorrer las columnas
    for (let j = 0; j <= size - 1; j++){
      // Valida si la suma de los indices es mayor al tamaño ingresado menos uno
      // dado que la posición para dibujar los carácteres es esa misma
      if (i + j >= size - 1) {
        tmpString += character;
      }
      // Sino solo se añade un espacio al String temporal
      else {
        tmpString +=' ';
      }
    }
    // Valida si no es la última fila, para de esta forma no añadir un salto de línea
    if (i != size - 1) {
      tmpString += '\n';
    }
  }
  return tmpString;
}

He aquí mi solución

export function printTriangle(size, character) {
  let i = 0;
  let cadena = "";
  let line = "";
  while (i < size) {
    cadena = cadena + character;
    let lng = i + 1;
    let blankSpace = "";
    for (let j = 0; j < size - lng; j++){
      blankSpace = blankSpace + " ";
    }
    line = line + blankSpace + cadena + '\n';
    i++;
  }
  return line.substring(0, line.length).trimEnd();
}

Dejo mi solución… SPOILER!!!
*
*
*
*
*
*
*
*
*
*
*
*
*

export function printTriangle(size, character) {
  // Tu código aquí 👈
  var output = ""
  for (let i = 0; i < size; i++) {
    var row = ""
    for (let j = 0; j < i + 1; j++) {
      row += character
    }
    output = `${output}${row.padStart(size)}\n`
  }
  return output.slice(0, (size * size) + size - 1)
  
}

export function printTriangle(size, character) {
  let linea = character;
  let triangulo = "";
  for (let i = 1; i <= size; i++) {
    triangulo += linea.padStart(size) + (i < size? '\n':'');
    linea += character;
  }
  return triangulo;
}

A continuacón mi aporte.
Me costo un poco pensarlo solo con las herramientas que hemos visto hasta ahora. Sin embargo, Salio!

↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓
↓

function printTriangle(size, character) {

  var stringSpace = '';
  var string = '';
  var char = '';

  for (let i = 1; i <= size; i++) {

    var n = i < size ? '\n' : '';

    for (let j = 1; j <= size - i; j++) {
      stringSpace = `${stringSpace}` + " ";
    }

    char = `${char}` + `${character}`;
    string = `${string}` + `${stringSpace}` + `${char}` + `${n}`;
    stringSpace = '';
  }

  return string;
}

Solución del reto usando solo los temas vistos :

<code> 
function printTriangle(size, character) {
  // Tu código aquí 👈
  let char = character
  let gap
  let line
  let arraySign = [];
  let triangulo 

  while (size > 0) {
    gap = ""
    for (let z = size - 1; z > 0; z--) {
      gap += " "
    }
    line = gap + char
    char += character
    arraySign.push(line)
    size--
  }
  triangulo = arraySign.join("\n")
  return triangulo
}

Escudo spoiler - Resuelto solo con ciclos y condicionales if
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function printTriangle(size, character) {
  let triangle = "";
  for (let i = 1; i <= size; i++) {
    let spaces = size - i;

    for (let j = 1; j <= size; j++) {
      if (spaces > 0) {
        triangle = triangle + " ";
        spaces--;
      }
      else {
        triangle = triangle + character;
      }
    }

    if (i != size) triangle = triangle + "\n";
  }

  return triangle;
}

Usando padStart y repeat 🙂

 function printTriangle(size, character) {
  return [...Array(size)]
    .map((_, index) => character.repeat(index + 1).padStart(size, ' '))
    .join('\n')
}

Aquí dejo mi código, con espacios en blanco que no mencionan… 😃

export function printTriangle(size, character) {
// Tu código aquí 👈
let arr = []
for (let i = 1; i <= size; i++) {
let lineTri = " “.repeat(size - i) + character.repeat(i);
arr.push(lineTri);
}
return arr.join(”\n");
}

Escudo
Escudo
Escudo
Escudo
Escudo
Escudo
Escudo
Escudo
Escudo
Escudo
Escudo
Escudo
Escudo

function printTriangle(size, character) 
  let triangle = '';
  for (let i = 1; i <= size; i++) {
    let heigh = '';
    let numberOfSpace = size - i;
    for (let j = 1; j <= size; j++) {
      let positionsOfBlankSpace = '';
      positionsOfBlankSpace += j;
      if (positionsOfBlankSpace <= numberOfSpace) {
        heigh += ' ';
      } else {
        heigh += `${character}`
      }
    }
    let lineBreak = '';
    if (i < size) {
      lineBreak = '\n';
    } else {
      lineBreak = '';
    }
    triangle += `${heigh}${lineBreak}`
  }
  return triangle;   
}

Mi solución despues de muchos intentos

🏆
🏆
🏆
🏆
🏆
🏆
🏆
🏆
🏆
🏆
🏆

export function printTriangle(size, character) {
  let triangle = '';
  let line = '';
  let space = ' ';
  for (let index = 1; index <= size; index++) {
    line = space.repeat(size - index) + character.repeat(index);
    triangle += line;
    if (index < size) triangle += "\n";
  }
  return triangle;
}

🛡️🛡️🛡️ESTE ES UN ESCUDO ANTI-SPOILERS🛡️🛡️🛡️
Tengo tiempo programando en JS, así que me propuse a programar este ejercicio evitando hacer uso de built-in string methods y siguiendo con lo que hasta este momento se ha enseñado en las clases. Y no porque sea malo usar estos string methods, de hecho en la mayoría de casos es más rápido y práctico programar haciendo uso de ellos.

Así que aquí les comparto mi solución como una alternativa más sin string methods:
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️
🛡️

export function printTriangle(size, character) {
  let result = '';
  for (let line = 1; line <= size; line++) {
    let row = '';
    for (let space = size - line; space > 0; space--) row = row + ' ';
    for (let char= 1; char<= line; char++) row = row + character
    result = result + row + ((line < size) ? '\n' : '');
  }
  return result;
}

export function printTriangle(size, character) {
  let triangulo = ""
  for (let i = 1; i <= size; i++){    
    triangulo += " ".repeat(size - i) + character.repeat(i) + "\n"    
  }
  return triangulo.slice(0, -1)
}

.
.
.
.
.
.
.
.
.
.
.

export function printTriangle(size, character) {
  let triangle = ''
  for (let i = 1; i <= size; i++) {
    for (let e = size; e > i; e--) {
      //console.log(' ')
      triangle += ' '
    }
    for (let j = 1; j <= i; j++) {
      //console.log(character)
      triangle += character
    }

    console.log(triangle)
    //console.log('\n')
    triangle = ''
  }
}

printTriangle(6, "$")

Usar repeat para mi no es trampa

Aqui mi solucion,…
.
.
.
.
…
…
…
…
…
…
…
…
…
…

function printTriangle(size, character) {
  let triangle = '';
  for (let i = size - 1; i >= 0; i--) {
    triangle = triangle + ' '.repeat(i) + character.repeat(size - i);
    if (i !== 0) triangle = triangle + '\n';
  }
  return triangle;
}

yo llegue a este resultado, llego en la consola al mismo resultado, pero me marca error en esta prueba alguien me indica donde esta fallando mi logica? …por favor, les dejo el codigo.

function printTriangle(size, character) {
    // Tu código aquí 👈
        let char1='';
        let array1=[];
        let espacios = '';
        let array2=[''];
        let rta = '';
    for (let index = 0; index < size; index++) {
       char1 = char1 + character;
       array1.push(char1);
       espacios += ' ';
       array2.unshift(espacios);
     }
    for (let i = 0; i < array1.length; i++) {
    
        rta=rta+array2[i+1]+array1[i]+`\n`;
    }
    console.log(rta);
    
  }

Hola. Comparto mi solución al ejercicio
.
.
.
.
.
.
Consiste en
.
.
.
.
.
Un doble recorrido de ‘for’ para el alto y el ancho. Una condición que evalúa si el ancho de ese momento ‘w’ es menor a lo esperado para espacios en blanco en esa línea (size-(h-1)), en dado caso, agrega un espacio en blanco a la cadena, sino, agrega el ‘character’. Finalmente tomo el slice de la cadena acumulada menos los dos últimos caracteres del último salto de línea agregado.

export function printTriangle(size, character) {
  let line = ""
  for (let h = 0; h < size; h++){
    for (let w = 0; w < size; w++){
      if (w < (size - (h + 1))) line += " ";
      else line += character
    }
    line += "\n"
  }
  return line.slice(0,line.length-1)
}

Pues yo diria que voy de acuerdo al proceso de aprendizaje y esta es mi solucion:

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let triangulo = '';
  for (let i = 1; i <= size; i++) {
    for (let j = 1; j <= size; j++) {
      if (j <= size - i) {
        triangulo += ' ';
      } else {
        triangulo += character;
      }
    }
    if (i < size) {
      triangulo += '\n';
    }
  }
  return triangulo;
}

Mi solucion

Usando ciclos y lo mas escueta que se me ocurrio

.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let triangle = '';
  for (let i = 1; i <= size; i++){
    triangle+=character.repeat(i).padStart(size) + (i<size?'\n':'');
  }
  return triangle;
  }

Durísimo, mucho más complicado que lo visto pero habrá que rebuscársela

Recomendaría cambiar la solución que muestran por defecto, sí se puede hacer con los conceptos vistos hasta el momento

Aquí esta mi solución. Me tome un buen tiempo tratando de resolverlo por mi cuenta pero lo logré. 😛
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function printTriangle(size, character) {
    // Tu código aquí 👈
    let vacio = "";
    let simbolos = "";
    let contador = "";
    for (let i = 0; i < size; i++){
      vacio += " ";
      simbolos += character;
    }
    
    for(let i = size - 1; i > 0; i--){
        contador += vacio.substring(0, i) + simbolos.substring(i) + "\n";
    }

    contador += simbolos;
    console.log(contador);
    return contador;
}

El método substring retorna una fragmento del string al que se lo aplique. Recibe como argumentos primero el índice inicial, desde del cual se va extraer el nuevo string y es incluyente, y segundo el índice final, hasta donde se va extraer y es excluyente. Si no se pasa indices final la función recorre hasta el final del string original.

¡Hola, Platzinauta!
Objetivo
En este desafío, debes dibujar un triángulo isósceles usando bucles.
Mi solución,
Se detalla hasta abajo.⬇
⬇
⬇
⬇

export function printTriangle(size, character) {
  //@autor dmos
  let i = 0, j = 0, k = 0;
  let cTotal = "", cSpacios = "", rta = "";

  while (i < size) {
    cTotal = ""; cSpacios = "";
    for (k = 1; k < size - i; k++) {
      cSpacios = cSpacios + " ";
    }
    for (j = 0; j <= i; j++) {
      cTotal = cTotal + character;
    }

    if (i + 1 < size)
      cTotal = cTotal + "\n";
    cTotal = cSpacios + cTotal;
    rta = rta + cTotal;
    i++;
  }
  return (rta); 
 
}

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let triangle = "";

  for (let i = 1; i <= size; i++) {
    const spacesCount = size - i;
    const charCount = i;
    triangle += " ".repeat(spacesCount) + character.repeat(charCount);

    if (i !== size) { // Se agrega nueva linia si no es la ultima fila
      triangle += "\n";
    }
  }

  return triangle;
}

Mi solucion 👇

.
.
.
.
.
.
.
.
.
.

function printTriangle(size, character) {
    let triangulo = '';
    for (let i = 1; i <= size; i++){
        triangulo += ' '.repeat(size - i) + character.repeat(i) + (size !== i ? '\n' : '');
    }
    return triangulo;
  }

Mi solucion

S
P
O
I
L
E
R

S
P
O
I
L
E
R

S
P
O
I
L
E
R

export function printTriangle(size, character) {
  var triangle = "";

  for (var i = 1; i <= size; i++) {
    for (var j = 1; j <= size - i; j++) {
      triangle += " ";
    }
    for (var k = 1; k <= i; k++) {
      triangle += character;
    }
    if (i < size) {
      triangle += "\n";
    }
  }
  return triangle;
}

Mi solución lo plantie sin metodos de los objetos string

Cuidadito con el spoilers

.
.
.
.
…
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

Que lo disfruten, jajaja

function printTriangle(size, character) {

  let triangle = "";
  
  for (let i=1; i <= size; i++){

    for (var j = 1; j <= (size - i); j++) {
      triangle = triangle + " ";
    }

    for (let y = j; y <= size; y++) {
      triangle = triangle + character;
    }

    if (i < size) {
      triangle = triangle + "\n"
    }
    
  }

  return triangle;
}

Este si me costo un ratito quedo de la siguiente manera:

export function printTriangle(size, character) {
  // Tu código aquí 👈
  let cadena = "";
  for (var i = 1; i < size; i++) {
    for (var j = size; j > 0; j--) {
      if (j > i) {
        cadena += " ";
      }
      else { 
        cadena += "" + character;
      }
    }
    cadena += "\n";
  }
  cadena += character.repeat(size);
  return cadena;
}

•    *
  

•   **
  

•   ***
  

•  ****
  

• *****
  

• ---

• ---

• ---

• ---

• ---

AntiSpoler;
Me ayude de la funcion repeat

export function printTriangle(size, character) {
  let cad = '';
  for (let i = 1; i <= size; i++) {
    let rep = " ".repeat(size - i) + character.repeat(i);
    if (i < size) {
      rep += "\n";
    }
    cad += rep;
  }
  return cad;
}

Solución

export function printTriangle(size, character) {
  let text = "";
  for (let i = 1; i <= size; i++) {
    text += (" ").repeat(size - i) + character.repeat(i) + ((i < size) ? "\n" : "");
  }
  return text;
}

🛡️🛡️🛡️ Sin spoilers 🛡️🛡️🛡️
Mi solución 👇

export function printTriangle(size, character) {
  let trinagle = '';

  for (let i = 0; i < size; i++) {
    // Auxiliar para recorrer cada carácter
    let currentChart = 1;

    // Concatena cada carácter vacío
    while (currentChart < size - i) {
      trinagle += ' ';
      currentChart++;
    }

    // Concatena el resto de los caracteres
    // para formar el triangulo
    while (currentChart <= size) {
      trinagle += character;
      currentChart++;
    }

    // Evita el último salto de línea 
    if (i < size - 1) {
      trinagle += "\n";
    }
  }

  return trinagle; 
}

Mi solución…
A
N
T
I
S
P
O
I
L
E
R

function printTriangle(size, character) {
  // Tu código aquí 👈
  let textoFinal = "";
  for (let i = 1; i <= size; i++) {
    let spaces = " ".repeat(size - i);
    let caracter = character.repeat(i);
    let figure = `${spaces}${caracter}\n`;
    textoFinal += figure;
  }
  return textoFinal.trimEnd();
}

Lo logre realizar utilizando solo for…
ESCUDO

Una iteración en programación es cada uno de las vueltas que da un bucle, es decir, cada de las repeticiones de un trozo de código.

Podemos verlo en los bucles que tiene el lenguaje de programación, como puede ser for, while, repeat o do.

Dentro del bucle for, dentro de los paréntesis, vemos 3 partes diferenciadas y separadas por un ;

Antes de nada, necesitamos una variable que usaremos para detectar cada una de las iteraciones.

Esta variable se puede declarar fuera del bucle, pero hay lenguajes que permiten declararla en el mismo bucle, limitando su alcance y eliminándose una vez salgamos de él.

En la primera parte, en i = 0, es dónde asignamos el primer valor de la variable, habitualmente un cero.

En cada iteración se comprueba si debemos salir del bucle, en este caso se ve en i < TOTAL , que comprueba si la variable ha llegado al final del bucle.

Hay que fijarse muy bien que la condición se cumpla en algún momento, sino nos encontraríamos con un bucle infinito. Un bucle infinito es aquel que nunca acaba, lo que dará un error en el momento de ejecución del programa.

TOTAL suele ser un número (o una constante o una variable, como hemos dicho antes, aunque muchos lenguajes no permiten esta última opción porque su valor puede ser cambiado).

En la última parte, i++ es dónde cambiamos el valor de i para la próxima repetición (o iteración). Lo habitual es incrementar su valor, para acercarnos ciclo a ciclo al TOTAL.

No hace falta decir que, si no ponemos correctamente esta última parte también tendríamos un ciclo infinito.

export function printTriangle(size, character) {
  let triangulo="";
  
  for (let i = 1; i <= size; i++) {
    for (let j = i; j < size; j++) {
      triangulo +=" "; 
    }
   
    for (let h = 1; h <= i; h++) {
     triangulo += character;
    }
    if (size != i) {
      triangulo += '\n'
    }
  }
  
  return triangulo
}

Me costó un poco entenderlo, pero al final lo conseguí investigando un poco más:

export function printTriangle(size, character) {
  // Crear una variable con string en blanco
  let triangle = '';
  // Verificar si el dato 'size' es un número positivo mayor que 0
  if (isNaN(size) || size <= 0) {
    return 'Ingrese un número positivo mayor que 0';
  } else {
    // Iterar incrementalmente dentro del valor de 'size'
    for (let i = 1; i <= size; i++) {
      // Iterar decrementalmente dentro del valor de 'size'
      for (let j = size; j >= 1; j--) {
        // Comprobar según el valor de 'j' e 'i'
        if (j <= i) {
          // si es 'true', agregar un 'character' a 'triangle'
          triangle += character;
        } else {
          // si es 'false', agregar un espacio en blanco a 'triangle'
          triangle += ' ';
        }
      }
      // Eliminar la ultima ejecución ("")
      if (i <= size - 1) {
        // agregar un salto de línea en 'triangle'
        triangle += '\n';
      }
    }
    // retornar la variable 'triangle'
    return triangle;
  }
}

Explicación:

1. Primero crea la variable triangle con un string vacío ('') para guardar el triángulo que vamos a crear.
2. Verificamos, mediante una condicional if, si el tamaño size del triángulo es un entero positivo mayor que 0.
   • Sí, es true, retornamos un mensaje indicando que el dato de size es incorrecto y finalizamos la ejecución.
   • Sí, es flase, ejecutamos el código necesario para generar el triángulo.
3. Para generar el triángulo, ejecutamos un bucle for para iterar de forma incremental desde 1 hasta size.
4. Dentro del primer bucle, creamos otro bucle decremental desde size hasta 1 cuya función es agregar espacios en blanco para alinear el triángulo a la derecha y agregar el carácter especificado en character:
5. Por medio de una condicional if comprobamos los índices j e i de los bucles anteriores:
   • Sí, es true, agregamos un character a triangle.
   • Sí, es false, agregamos un espacio en blanco ' ' a triangle.
6. Cuando el bucle interno termina su ciclo, se ejecuta una última condicional if que agrega un salto de línea '\n' a triangle (eliminando el último salto de línea para evitar un "") para que se siga ejecutando el primer bucle, repitiendo el proceso hasta que se complete el triángulo isósceles.
7. Por último, cuando los dos bucles cumplieron su función, se retorna triangle con nuestro triángulo isósceles.

Compartiendo Solución
🛡️🛡️🛡️🛡️🛡️🛡️🛡️🛡️
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function printTriangle(size, character) {
  let result = ''
  for (let i = 0; i < size; i++) {
    let figure = character.repeat(i + 1)
    let spaces = ' '.repeat(size - figure.length)
    result += spaces + figure + '\n'
  }
  return result.slice(0, -1)
}

Utilizo dos métodos que no hemos visto hasta el momento.

1. repeat() => repite un string cuantas veces le indiquemos.
2. slice() => ‘corta o extraer’ un string dentro de las posiciones que uno indique.

Links documentación:

• Repeat
• Slice