隆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 & Factory pattern en JavaScript

68

Playground - Implementa singleton en un chat

D铆a 22

69

Builder & Protype pattern en JavaScript

70

Playground - Mejora el c贸digo usando builder pattern

71

Adapter & Decorator pattern en JavaScript

72

Playground - Personaliza productos de una tienda

D铆a 23

73

Facade & proxy pattern en JavaScript

74

Playground - Proxy en servicio de mensajer铆a

75

Chain of responsability & Observer pattern en JavaScript

76

Playground - Implementaci贸n de Observador en Newsletter

D铆a 24

Live Class

77

30 d铆as de JS con Juan DC

78

30 d铆as de JS con Nicobytes

No tienes acceso a esta clase

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

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Aprende todo un fin de semana sin pagar una suscripci贸n 馃敟

Reg铆strate

Comienza en:

2D
5H
32M
11S

Playground - Dibuja un triangulo

15/78

Aportes 128

Preguntas 5

Ordenar por:

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

o inicia sesi贸n.

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

Sab铆as que鈥

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

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


Soluci贸n:

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

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

Tonteria total, usando metodos aun no vistos.

Soluci贸n 馃槈

馃毀
馃毀
馃毀
馃毀
馃毀
馃毀
馃毀
馃毀
馃毀
馃毀
馃毀
馃毀
馃毀
馃毀
馃毀
馃毀

export function printTriangle(size, character) {
  // Tu c贸digo aqu铆 馃憟
  let string = ""
  for (let i = 1; i <= size; i++) {

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

Soluci贸n鈥 馃槃

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

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

Pens茅 que se deb铆a resolver sin usar alguna otra funci贸n como repeat(), yo lo hice as铆:

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

aun asi me voy feliz 馃挍

El codigo sirve para VSCode 鉁 no para el playground 馃敶

Hola, dejo mi solucion
Caminito anti spoilers
馃殫
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Llegamos 馃搷

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

Esto fue lo que pude lograr apenas 馃槮

Mi soluci贸n:

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

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

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

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

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



**
*
*
*
*
*
*

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

Mi soluci贸n:

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

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

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

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

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

馃槩馃う鈥嶁檧锔忦煠 estuvo muy hard.
export function printTriangle(size, character) {
let fila = 鈥樷;
for (let i = 1; i <= size; i++) {
fila += 鈥 '.repeat(size - i) + character.repeat(i) + 鈥榎n鈥;
}
return fila.trimEnd();
}
console.log(printTriangle(5, 鈥*鈥));

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

Mi soluci贸n al reto, similar al resto:

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

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

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

    x++;
  }
  return triangle;
}

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

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

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

return arrChar.join(鈥橽n鈥)
}

MI solucion:

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

Es trabajo humilde pero honesto

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

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

Esta es la soluci贸n que pude realizar, realmente este playground s铆 me cost贸 porque intent茅 hacerlo s贸lo con bucles hasta que le铆 en la documentaci贸n que existe el m茅todo 鈥榬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;
}

Usando padStart y repeat 馃檪

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

Aqu铆 dejo mi c贸digo, con espacios en blanco que no mencionan鈥 馃槂

export function printTriangle(size, character) {
// Tu c贸digo aqu铆 馃憟
let arr = []
for (let i = 1; i <= size; i++) {
let lineTri = " 鈥.repeat(size - i) + character.repeat(i);
arr.push(lineTri);
}
return arr.join(鈥漒n");
}

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

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

Mi soluci贸n despues de muchos intentos

馃弳
馃弳
馃弳
馃弳
馃弳
馃弳
馃弳
馃弳
馃弳
馃弳
馃弳

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

馃洝锔忦煕★笍馃洝锔廍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;
}
export function printTriangle(size, character) {
  let triangulo = ""
  for (let i = 1; i <= size; i++){    
    triangulo += " ".repeat(size - i) + character.repeat(i) + "\n"    
  }
  return triangulo.slice(0, -1)
}

.
.
.
.
.
.
.
.
.
.
.

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

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

printTriangle(6, "$")

Usar repeat para mi no es trampa

Aqui mi solucion,鈥
.
.
.
.









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

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

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

Hola. Comparto mi soluci贸n al ejercicio
.
.
.
.
.
.
Consiste en
.
.
.
.
.
Un doble recorrido de 鈥榝or鈥 para el alto y el ancho. Una condici贸n que eval煤a si el ancho de ese momento 鈥榳鈥 es menor a lo esperado para espacios en blanco en esa l铆nea (size-(h-1)), en dado caso, agrega un espacio en blanco a la cadena, sino, agrega el 鈥榗haracter鈥. Finalmente tomo el slice de la cadena acumulada menos los dos 煤ltimos caracteres del 煤ltimo salto de l铆nea agregado.

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

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

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

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

Mi solucion

Usando ciclos y lo mas escueta que se me ocurrio

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

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

Dur铆simo, mucho m谩s complicado que lo visto pero habr谩 que rebusc谩rsela

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

Aqu铆 esta mi soluci贸n. Me tome un buen tiempo tratando de resolverlo por mi cuenta pero lo logr茅. 馃槢
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

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

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

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

隆Hola, Platzinauta!
Objetivo
En este desaf铆o, debes dibujar un tri谩ngulo is贸sceles usando bucles.
Mi soluci贸n,
Se detalla hasta abajo.猬


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

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

    if (i + 1 < size)
      cTotal = cTotal + "\n";
    cTotal = cSpacios + cTotal;
    rta = rta + cTotal;
    i++;
  }
  return (rta); 
 
}
export function printTriangle(size, character) {
  // Tu c贸digo aqu铆 馃憟
  let triangle = "";

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

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

  return triangle;
}

Mi solucion 馃憞

.
.
.
.
.
.
.
.
.
.

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

Mi solucion

S
P
O
I
L
E
R

S
P
O
I
L
E
R

S
P
O
I
L
E
R

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

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

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

Cuidadito con el spoilers

.
.
.
.

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

Que lo disfruten, jajaja

function printTriangle(size, character) {

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

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

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

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

  return triangle;
}

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

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





AntiSpoler;
Me ayude de la funcion repeat

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

Soluci贸n

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

馃洝锔忦煕★笍馃洝锔 Sin spoilers 馃洝锔忦煕★笍馃洝锔
Mi soluci贸n 馃憞

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

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

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

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

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

  return trinagle; 
}

Mi soluci贸n鈥
A
N
T
I
S
P
O
I
L
E
R

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

Lo logre realizar utilizando solo for鈥
ESCUDO

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

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

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

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

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

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

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

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

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

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

No hace falta decir que, si no ponemos correctamente esta 煤ltima parte tambi茅n tendr铆amos un ciclo infinito.

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

Me cost贸 un poco entenderlo, pero al final lo consegu铆 investigando un poco m谩s:

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

Explicaci贸n:

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

Compartiendo Soluci贸n
馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍馃洝锔忦煕★笍
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

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

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

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

Links documentaci贸n:

undefined