隆Te damos la bienvenida a este reto!

1

隆Bienvenido al mundo de JavaScript!

D铆a 1

2

Variables, funciones y sintaxis b谩sica

3

Tipos de datos

4

Playground - Retorna el tipo

5

Tipos de datos - pt 2

D铆a 2

6

Operadores

7

Hoisting y coerci贸n

8

Playground - Calcula la propina

9

Alcance de las variables

D铆a 3

10

Condicionales

11

Playground - Calcula a帽os bisiestos

12

Switch

13

Playground - Obten informaci贸n de mascotas seg煤n su tipo

14

Ciclos

15

Playground - Dibuja un triangulo

D铆a 4

16

Arrays

17

Playground - Encuentra al michi mas famoso

18

Objetos

19

Playground - Obten el promedio de los estudiantes

D铆a 5 - Checkpoint

20

Playground - encuentra el palindromo m谩s grande

D铆a 6

21

Reasignaci贸n y redeclaraci贸n

22

Modo estricto

D铆a 7

23

Debugging y manejo de errores

24

Programaci贸n funcional

Quiz: D铆a 7

D铆a 8

25

Closures

26

Playground - Crea una calculadora con closures

27

Higher order functions

28

Playground - Crea tu propio m茅todo map

D铆a 9

29

ECMAScript

30

TC39

Quiz: D铆a 9

D铆a 10 - Checkpoint

31

ES6

32

ES7

33

Playground - Task planner

D铆a 11

34

Asincronismo

35

Playground - Promesas

36

Manejando el asincronismo

37

Playground - Resuelve el callback hell usando promesas

38

Playground - Resuelve el callback hell usando async/await

D铆a 12

39

Arrays a profundidad

40

M茅todos de arrays: Every, Find y findIndex

41

Playground - V谩lida el formulario

D铆a 13

42

M茅todos de arrays: Includes, Join y concat

43

Playground - agrupa los productos

44

M茅todos de arrays: Flat y FlatMap

45

Playground - Encuentra la ubicaci贸n del valor buscado

D铆a 14

46

Mutable functions

47

Playground - Modifica una lista de compras

48

M茅todos de arrays: sort

49

Playground - Ordena los productos

D铆a 15 - Checkpoint

50

Playground - Sistema de reservaciones de un hotel

D铆a 16

51

Programaci贸n orientada a objetos en JavaScript

52

Objetos literales

53

Playground - Congela el objeto recursivamente

D铆a 17

54

Prototipos en JavaScript

55

Playground - Modifica el prototype de los arrays

56

Playground - Crea un auto usando clases

D铆a 18

57

Abstracci贸n en JavaScript

58

Playground - Sistema de carrito de compras

59

Encapsulamiento en JavaScript

60

Playground - Encapsula datos de los usuarios

D铆a 19

61

Herencia en JavaScript

62

Playground - Jerarqu铆a de animales

63

Polimorfismo en JavaScript

64

Playground - Sistema de pagos

D铆a 20 - Checkpoint

65

Playground - Agenda de vuelos

D铆a 21

66

Patrones de dise帽o

67

Sinlgeton y Factory pattern en JavaScript

68

Playground - Implementa singleton en un chat

D铆a 22

69

Adapter y Decorator pattern en JavaScript

70

Playground - Personaliza productos de una tienda

71

Builder y Protype pattern en JavaScript

72

Playground - Mejora el c贸digo usando builder pattern

D铆a 23

73

Facade y proxy pattern en JavaScript

74

Playground - Proxy en servicio de mensajer铆a

75

Chain of responsability y Observer pattern en JavaScript

76

Playground - Implementaci贸n de Observador en Newsletter

D铆a 24 - Checkpoint

77

Playground - Crea un task manager con patrones de dise帽o

D铆a 25

78

Estructuras de datos en JavaScript

79

Playground - Crea tu propia implementaci贸n de un array

80

Hash tables en JavaScript

81

Playground - Implementaci贸n de una HashTable para Contactos

D铆a 26

82

Set en JavaScript

83

Playground - Remueve duplicados de una lista

84

Maps en JavaScript

85

Playground - Crea un organizador de tareas

D铆a 27

86

Singly Linked List en JavaScript

87

Playground - Agrega m茅todos a la singly linked list

88

Playground - Implementaci贸n de una singly linked list

D铆a 28

89

Stacks en JavaScript

90

Playground - Crea un stack para una playlist

D铆a 29

91

Queues en JavaScript

92

Playground - Crea una cola de emails

D铆a 30

93

隆Lo lograste!

Live Class

94

30 d铆as de JS con Juan DC

95

30 d铆as de JS con Nicobytes

96

30 d铆as de JS con GNDX

97

30 d铆as de JS con LeoCode

98

30 d铆as de JS con Teffcode

99

Sesi贸n: Cierre de los 30 d铆as de JavaScript

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Playground - Dibuja un triangulo

15/99

Aportes 153

Preguntas 9

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

隆Hola Platzinauta!

.

馃洝锔忦煕★笍馃洝锔廍ste 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 鈥淗ola鈥 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鈥o 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.

馃洝锔忦煕★笍馃洝锔廍scudo 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');
}```

馃洝锔忦煕★笍馃洝锔廍STE 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 鈥渞epeat()鈥 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 鈥榬epeat鈥

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 鈥減rintTriangle鈥, toma dos argumentos: 鈥渟ize鈥 y 鈥渃haracter鈥. 鈥渟ize鈥 es un n煤mero entero que indica el tama帽o del tri谩ngulo que se desea imprimir y 鈥渃haracter鈥 es un car谩cter que se utilizar谩 para construir el tri谩ngulo.

La funci贸n utiliza un bucle 鈥渇or鈥 anidado para construir el tri谩ngulo. En el bucle exterior, se crea una variable llamada 鈥渢riangle鈥 que inicialmente est谩 vac铆a. Este ser谩 el resultado final que se devolver谩.

En el bucle exterior, se utiliza una variable llamada 鈥渓ine鈥 para iterar a trav茅s de cada l铆nea del tri谩ngulo. En cada iteraci贸n, se inicia un nuevo bucle 鈥渇or鈥 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 鈥渓ine鈥) y del tama帽o total del tri谩ngulo (determinado por el argumento 鈥渟ize鈥). Estos espacios en blanco se agregan al resultado 鈥渢riangle鈥 utilizando el operador 鈥+=鈥.

Luego, en el segundo bucle 鈥渇or鈥, se construyen los caracteres del tri谩ngulo. En cada iteraci贸n, se agrega el car谩cter especificado por el argumento 鈥渃haracter鈥 al resultado 鈥渢riangle鈥. La cantidad de caracteres agregados depende de la posici贸n actual de la l铆nea (determinada por la variable 鈥渓ine鈥).

Finalmente, despu茅s de los bucles 鈥渇or鈥 anidados, se verifica si la l铆nea actual es la 煤ltima l铆nea del tri谩ngulo (determinado por la variable 鈥渟ize鈥). Si no es as铆, se agrega un salto de l铆nea 鈥淺n鈥 al resultado 鈥渢riangle鈥.

Cuando se completa la construcci贸n del tri谩ngulo, se devuelve el resultado final 鈥渢riangle鈥.

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 鈥淧ARA 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;
}
undefined