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;
}

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

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.

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
}

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);
}

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;
}

Usando padStart y repeat 🙂

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

Aqui les dejo mi solucion:

export function printTriangle(size, character) {
  // Tu código aquí 👈
  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
}

😢🤦‍♀️🤢 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, “*”));

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.

Spoiler
.
.
.
.
.
.
.
.
.

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

esta fue la solución que puedo brindar con los conocimientos actuales del curso, aunque al testearlo da que esta mal, si lo imprimimos en consola, nos da lo que nos piden

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

Que estupidez esto ponen un reto, con temas que todavia no conoces -_-

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

No entendí lo de mi código pero esta fue mi solución…no entiendo lo de padStart 😦

function printTriangle(size, character) {
    let triangle;
    let righttriangle = "";
    for (let i = 1; i <= size; i++) {
        if (i < size) {
            triangle = character.repeat(i) + "\n";
            righttriangle += triangle.padStart(size + 1);
        }
        else {
            triangle = character.repeat(i);
            righttriangle += triangle.padStart(size);
        }
    }
    return righttriangle;
}
console.log(printTriangle(5, "*"));

  let text = "";

  for (let i = 1; i <= size; i++) {
    for (let j = (size - i); j >= 1; j--) {
      text += " ";
    }
    for (let k = 1; k <= i; k++) {
      text += character;
    }
    if (size !== i) { text += "\n"; }
  }
  return text;

Aquí también funciona.

🛡️🛡️🛡️Escudo anti spoilers🛡️🛡️🛡️

Dibuja un triángulo

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");
}

console.log(printTriangle(5, "*"));
console.log(printTriangle(6, "$"));

Listo

export function printTriangle(size, character) {
  let oneCharacter = character;
  let stringFinal = "";
  for (let i = 1; i <= size; i++) {
    let space = '';
    for (let x = size; x > i; x--) {
      space += ' ';
    }
    if (i != 1) {
      character += oneCharacter;
    }
    stringFinal += space + character
    if (i != size) {
      stringFinal += "\n";
    }
  }
  return stringFinal;
}

Esta solución me dio error, voy analizar nuevamente!

function printTriangle(size, character) {
  for (let i = 1; i <= size; i++) {
    let row = "";
    for (let j = 1; j <= size - i; j++) {
      row += " ";
    }
    for (let k = 1; k <= i; k++) {
      row += character;
    }
    console.log(row);
  }
}

Mi solución usando métodos de arrays:
🗿
🗿
🗿
🗿
🗿
🗿
🗿

export function printTriangle(size, character) {
  return [...Array(size+1).keys()] // creamos un arreglo desde el 0 hasta el size+1 (+1 porque removeremos el 0)
    .splice(1) // removemos el 0
    .sort((x,y)=>y-x) // ordenamos de mayor a menor
    .map((char, spaces)=>{ 
      // char => veces que se repite character [6, 5, 4, 3, 2, 1]
      // spaces => veces que se repiten los caracteres [0, 1, 2, 3, 4, 5]
      return " ".repeat(spaces) + character.repeat(char)
    } )
    .reverse() // invertimos las posiciones en la lista
    .join("\n") // los juntamos añadiendo un salto de línea
}

Costo, pero salió 😁

🐢_🐢_🐢
🐢_🐢_🐢
🐢_🐢_🐢
🐢_🐢_🐢
🐢_🐢_🐢
🐢_🐢_🐢
🐢_🐢_🐢

const printTriangle = (size, character) => {
    
for (c = 0; c < size; c++) {
        console.log(' '.repeat(size-(c+1)) + character.repeat(c+1)) 
    }
}

export function printTriangle(size, character) {
  // Tu código aquí 👈
  var row = "";  
  for (var i = 1; i <= size; i++) {
    for (var j = 0; j < size - i; j++) {
      row += " ";
    }

    for (var k = 0; k < i; k++) {
      row += character;
    }

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

  return row;
}

este si no pude tuve que ver los aportes, me siento bruto jajaja

Yo lo hice asi y no me funciona en el playground pero en cualquier otro editor si:

function printTriangle(size, character) {
    // Tu código aquí 👈
    for (let i = size; i >= 0 ; i--) {
        console.log(' '.repeat(i).concat(character.repeat(size-i)))
    }
}
  
printTriangle(8, '+');

Aqui mi solucion usando solo for y variables:

export function printTriangle(size, character) {
  // counter : variable que identifica cuantas veces debo dibujar el caracter, a medida que vaya iterando se va sumando +1
  let counter = 1;
  let final_message = ''
  let message; 
  for (let x = 1; x <= size; x++){
    // 1er for para crear las n lineas ingresadas como parametro
    // por cada iteracion limpio la variable message ya que me sirve para armar la nueva linea
    message = ''
    for (let y = size; y >= 1; y--){
      
      if (y > counter) {
        message += ' ';
      }
      else {
        message += character;
      }
    }
    counter++;
    // mientras la iteracion sea mayor a size adjunto el salto de linea \n
    if (x < size) {
      message += '\n';
    }
    final_message = final_message + message;
  }  
  return final_message;
}

.
.
.
.
.
.

Alternativa 1: con lo que hemos visto hasta ahora.

function printTriangle (size, character) {
    let spaces = "";
    let characters = character;
    let countSpaces = size - 1; 
    let countCharacters = 1; 
    
    for (let i = 0; i < countSpaces; i++) {
        spaces+= " ";  
    }
    console.log(spaces + character);
  
    let line = 1;
    while (line < size) {
        for (let i = 0; i < countCharacters; i++) {
            characters+= character;
            spaces = "";
            countSpaces--;
            for (let i = 0; i < countSpaces; i++) {
                spaces+= " ";  
            }
        }     
        line++;
        console.log(spaces + characters);
    }
}

Alternativa 2: con métodos de strings.

function printTriangle(size, character) {
    let space = " ";
    let triangle = "";

    for (let i = 1; i <= (size - 1); i++) {
        triangle+= (space.repeat(size - i) + character.repeat(i) + `\n`);
    }
    triangle+= character.repeat(size);
    return triangle;
}

Mi solución, anteriormente había trabajado con esto de imprimir patrones en consola, y la verdad siempre los he buscado en internet, solo le ajusto los detalles

function printTriangle(size, character) {
    let result = "";
    for (let i = 1; i <= size; i++) {
        for (let j = 0; j < size - i; j++) {
            result += " ";
        }
        for (let k = 0; k < i; k++) {
            result += character;
        }
        if (i!== size)result += "\n";
    }
    return result
}

Gracias a la asesoria de Orlando en el grupo de Discord se logro, utilizando las clases anteriores

export function printTriangle(size, character) {

  let formato_espacio = " "
  var tamano = size - 1
  var res3 = ""

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

    //Esta variable se vuelve a asignar cada vez que hay una interración nueva
    let character_espacio = ""
    let formato = ""

    for (var j = tamano; j > 0; j--) {
      formato += formato_espacio
    }

    for (var s = 1; s <= i; s++) {
      character_espacio += character
    }

    if (tamano > 0) {
      res3 = res3 + formato + character_espacio + "\n"
    }
    else {
      res3 = res3 + formato + character_espacio
    }

    tamano--
  }

  return res3;

}

Hice esto con todo lo visto previamente en este curso:

export function printTriangle(size, character) {
  let triangulo = "";

  for (let i = 1; i <= size; i++) {
    if (i !== 1) triangulo =  triangulo + '\n';

    //Agregando espacios
    for (let e = size - i; e != 0; e--) {
      triangulo = triangulo + ' ';
    }
    //Agregando caracter
    for (let j = 0; j < i; j++) {
      triangulo = triangulo + character;
    }
  }
  return triangulo;
}

Mi solución en una línea 😁

export function printTriangle(size, character) {
  return Array(parseInt(size)).fill().map((v, i) => ' '.repeat(size - (i + 1)) + character.repeat(i + 1)).join('\n');
}```

🛡️🛡️🛡️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;
}

Mi aporte utilizando for anidado:

export function printTriangle(size, character) {
let triangulo = “”;
let aux = size;
for (let i = 1; i <= size; i++){
for (let j = 1; j <= size; j++){
if (j >= aux) {
triangulo = triangulo + ${character};
} else {
triangulo += " ";
}
}
aux–;
triangulo += “\n”;
}

return triangulo;
}

Aqui dejo mi humilde respuesta usando “repeat()” para crear un string repetido y join al final para devolver un solo bloque de texto (que hubiera deseado que lo dijeran explicitamente, me tocó ver la respuesta porque yo los estaba imprimiendo linea por linea y me salia que mi respuesta era incorrecta).

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

Veo que hay varias personas que preguntan la explicación de las soluciones. No se si sea muy tarde (he empezado hoy el reto), aquí les dejo el código con la explicación línea por línea.
Espero les sirva:
.
.
.
.
.
.
.
.
.
.
.
.
.

export function printTriangle(size, character) {
  //todas las lineas que se impriman deben tener el mismo numero de caracteres
  //para que el triangulo esté alineado a la derecha
  //la estructura de las lineas sería básicamente:
  //Num espacios en blanco + Num caracteres
  //Donde num espacios en blanco = size - Num caracteres
  //Y Num caracteres se va incrementando desde 1 hasta size en cada linea
  //    * - 1 caracter, 4 espacios en blanco
  //   ** - 2 caracter, 3 espacios en blanco
  //  *** - 3 caracter, 2 espacios en blanco
  // **** - 4 caracter, 1 espacios en blanco
  //***** - 5 caracter, 0 espacios en blanco
  let triangle = "";

  //numCharacters se incrementa desde el 1, como dijimos arriba
  //Repetimos desde 1 hasta size - 1 (todas las lineas menos la última)  
  for (let numCharacters = 1; numCharacters < size; numCharacters++){
    //Los espacios en blanco seran size - numcharacter,
    //tal como explicamos antes.
    //Por esta razón hacemos un for desde 1 hasta ese valor
    for (let j = 1; j <= size - numCharacters; j++){
      triangle += " ";
    }

    //Luego hay que añadir la cantidad de caracteres a la linea
    for (let j = 1; j <= numCharacters; j++) {
      triangle += character ;
    }

    //Finalmente para terminar la linea hay que agregar el salto de linea
    triangle += "\n";
  }

  //Finalmente para la última línea simplemente repetimos size veces los caracteres (sin el salto de linea)
  for (let i = 0; i < size; i++){
    triangle += character;
  }
  return triangle;
}

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");
}

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;
}