Playground: crea tu propia implementación de unshift

Clase 7 de 29 • Curso de Estructuras de Datos con JavaScript

Andres Eduardo Maneiro Antunez

student•

Aqui les suministro mi solucion al reto * * * * * * * * * * * * * * * * * * * * * *

export class MyArray {
  constructor() {
    this.length = 0;
    this.data = {};
  }
  
  unshift(item){
    // Tu código aquí 👈 
    if (!item) {
      return this.length
    }
    if (this.length !== 0) {
      for (let i = this.length - 1; i >= 0; i--) {
        this.data[i + 1] = this.data[i];
      }
    }

    this.data[0] = item;
    this.length++;
    return this.length
  }
}

Ismael Grimaldo Vega

student•

Hey! se agradece que hayas puesto los espacios en blanco para esconder la solución. Lo voy a implementar 🫡

Edgar Oliveros

student•

brutal, justo pensaba en como recorrer el array desde el final y encontre tu respuesta, esto me va a servir muchooo

Laura Muñoz

student•

Mi solución fue: * * * * * * Alerta Spoiler! * * * * * *

unshift(item) {
    if (item) {
      for (let i = this.length; i > 0; i--) {
        this.data[i] = this.data[i - 1];
      }
      this.data[0] = item;
      this.length++;
    }
    return this.length;  
  }

Benjamin Nahuel Quevedo

student•

Meu humilde resolución:

unshift(item){
        for(let i = this.length; i > 0; i--){
            this.data[i] = this.data[i - 1]
        }

        this.length++;
        this.data[0] = item;
        return this.length
    }

Si se te dificulta entender el "For" te dejo un ejemplo de como funciona: Supongamos que mi array "this.data" tiene 4 elementos, por lo que 'i' en el ciclo for empieza en "4", checkea si es mayor a 0 y, como en este caso si lo es, le resta 1 por lo que ahora 'i' vale 3, luego se ejecuta "this.data[i] = this.data[i - 1]" esto hace que 'this.data[3]' sea igual a 'this.data[2]' y se repite el proceso hasta llegar a la posición 0 donde se rompe el ciclo For y se agrega el nuevo elemento al array en la posición 0.

Esta solución nació de la pregunta: Como hago que la posición 2 (Por ejemplo) se mueva a la posición 3? y la clave fue que una vez leí o escuche a alguien decir que "Cortar y pegar es en realidad copiar, pegar y borrar el original" por lo que me di cuenta que no necesitaba mover el elemento sino copiarlo y pegarlo en una posición mas para luego borrarlo (en este caso reemplazarlo).

Daniel Schmidt

student•

Mi solución

  unshift(item) {
    if (item) {
      this.length = 1;
      Object.values(this.data).forEach(el => {
        this.data[this.length++] = el;
      });
      this.data[0] = item;
    }
    return this.length;
  }

Ivan David Martinez Baron

student•

Curiosamente mi algoritmo que es completamente distinto funciona en mi vscode. Agrego los mismos input que en la guía y la respuesta es correcta. Sin embargo cuando corro las pruebas las dos ultimas no corresponden, pero no se que entrada le pusieron, deberían permitirlas ver para también se puedan probar en nuestros algoritmos antes de probar en el simulador

Fernando Orozco Velasquez

student•

A mi también me pasó lo mismo, en mi caso fue porque aunque no se envié ningún valor el método me seguía aumentando el valor del length, asé que solo es de devolver el 'length' actual cuando se manda un String vacéo

David Elias Gatica Morales

student•

unshift(item){
    for (let i = this.length; i >= 0; i--) {
      this.data[i] = this.data[i - 1]
      if (i == 0) {
        this.data[i] = item
      }
    }
    return this.length++
  }

Harold Zurita Simon

student•

Soluciòn 😄..

. . . .

export class MyArray {
  constructor() {
    this.length = 0;
    this.data = {};
  }
  
  unshift(item) {
    if (item) {
      for (let i = this.length; i > 0; i--) {
        this.data[i] = this.data[i - 1];
      }
      this.data[0] = item;
      this.length++;
    }
    
    return this.length;
  }
}

David Sanchez Garcia

student•

Siento que me compliqué mucho con los if, pero pues quedó cx

unshift(item) {
    if (this.length === 0 && item) {
      this.data[0] = item;
      this.length++
      return this.length;
    }
    else if (this.length != 0 && item) {
      for (let i = this.length; i > 0; i--) {
        this.data[i] = this.data[i - 1];
      }
      this.data[0] = item;
      this.length++;
      return this.length;
    }
    else if (!item) {
      return this.length;
    }
  }
}

Johan Sebastian

student•

Ismael Cruz Procel

student•

Hola!

En la solución no me queda del todo claro para que se usa la siguiente sentencia:

    for(let i = this.length; i > 0; i--){
      this.data[i] = this.data[i - 1];
    }

Alguien me podria explicar, gracias de antemano!!!

Israel Blas

student•

Es que si te das cuenta cada elemento dentro de tu array al agregar uno al inicio estos ocuparan el siguiente lugar Si solo hay un elemento y este esta en la posicion 0 pasara a la posición 1 y el nuevo elemento a la posición 0. Y así agregando más elementos.

Por eso el for se inicializa desde el final porque el ultimo elemento ya no estará en la posición this.length - 1 sino en la this.length y asi hasta llegar al primer elemento que ahora estara en la posición 1 y no 0.

Ismael Cruz Procel

student•

Es decir que esa sentencia, recorre los "lugares" de los elementos del array?

Cristián Santiago Rivera Guzmán

student•

la verdad no he entendido nada al respecto

Diego Reyes Cabrera

student•

Todavía nada? Qué dudas tienes?

Jonathan Garcia

student•

Hector Daniel Tapia

student•

Voy a intentar que hice antes de mostrar el codigo :

1-tenemos que validar que cuando no nos envien nada devuelva la longitud del this.data que lo representa this.length.

2-despues realizo un if para guardar por primera vez cuando el this.length es 0 lo agrega y suma el this.length.

3-realizamos un for decreciente que nos va ayudar a que los valores se actualizen correctamente.

le asignamos al iterador this.length para que nos ayude mas adelante en la logica y decimos que iterador tiene que ser mayor a 0 osea siempre se va a detener en 1 porque hacemos que el iterador i-- valla decrementando,por lo tanto evitamos tocar el indice 0 , luego como sabemos que i = a la longitud que es this.length y las longitudes no toman en cuenta el 0 como los indices this.data[i] hace referencia digamos como al proximo indice del ultimo si tenemos 0,1 su longitud es de 2 y ese 2 es el que hacemos referencia a this.data[i] y le asignamos this.data[i - 1] que vendria ser el ultomo valor segun la iteracion .

4- despues como nunca tocamos el indice 0 reasignamos this.data[0] a todos los nuevos valores osea item incrementamos el this.length++ y eso seria todo retornamos y listo.

  unshift(item) {
    if (!item) {
      return this.length
    }
    // Si el array está vacío, simplemente agregamos el elemento en 0
    if (this.length === 0) {
      this.data[0] = item;
      this.length++;
      return this.data;
    }

    // Desplazamos todos los elementos una posición hacia adelante
    console.log("estoy afuera del for" ,this.data)
    for (let i = this.length; i > 0; i--) {
      this.data[i] = this.data[i - 1]; // Movemos el anterior al siguiente
    }
    console.log("estoy afuera del for", this.data);

    // Insertamos el nuevo elemento en la posición 0
    this.data[0] = item;
    this.length++;
    

    return this.data;
  }

Andres giovanny lopez cortes

student•

giovanni.sayago

student•

Comparto mi solución:

export class MyArray {
  constructor() {
    this.length = 0;
    this.data = {};
  }
  push(item) {
    this.data[this.length] = item;
    this.length++;
    return this.data;
  }

  unshift(item) {
    if (item !== undefined) {
      if (this.length === 0) {
        this.push(item);
      } else {
        this.push("");
        for (let index = this.length - 2; index >= 0; index--) {
          const temporal = this.data[index];
          this.data[index + 1] = temporal;
        }
        this.data[0] = item;
      }
    }
    return this.length;
  }

}

Jasubi Lehem Piñeyro Legaspi

student•

export class MyArray {
  constructor() {
    this.length = 0;
    this.data = {};
  }
  
  unshift(item) {
    if (!item) return this.length

    for (let index = this.length; index > 0; index--) {
      this.data[index] = this.data[index - 1]
    }
    
    if (this.length === 0) {
      this.data[this.length] = item;
    } else {
      this.data[0] = item;
    }

    this.length++

    return this.length
  }
}

Jasubi Lehem Piñeyro Legaspi

student•

export class MyArray { constructor() { this.length = 0; this.data = {}; } unshift(item) { if (!item) return this.length for (let index = this.length; index > 0; index--) { this.data[index] = this.data[index - 1] } if (this.length === 0) { this.data[this.length] = item; } else { this.data[0] = item; } this.length++ return this.length }}

Kyb3r Cipher

student•

Aqui mi implementacion:

****************************************************************************************************************************************************************************************************************************

unshift(item) { // Add element to first index.
        if (item) {
            for (let i = this.length; i > 0; i--) {
                this.data[i] = this.data[i - 1];
            }

            this.data[0] = item;
            this.length++;
        }
        return this.length;
    }

Aramis Garcia Guerrero

student•

Buen ejercicio de lógica!

unshift(item){
        for(let i = this.length; i >= 0; i--){
            this.data[i] = this.data[i-1];            
        }
    
        this.data[0] = item;
        this.length++;

        return this.length;
    }
```unshift(item){        for(let i = this.length; i >= 0; i--){            this.data\[i] = this.data\[i-1];                    }            this.data\[0] = item;        this.length++;
        return this.length;    }

Natalia Gallego Heras

student•

Mi solución siempre devuelve la longitud

  unshift(item){
      return this.length
  }

Y tiene una condicional sencilla en caso de que verdaderamente se haya pasado un item por parámetro

  unshift(item){
      if(item){
      }
      return this.length
  }

En caso de que sí, se aumenta la longitud.

  unshift(item){
      if(item){
        this.length++
        }
      }
      return this.length
  }

Entonces un bucle decreciente recorre el objeto desde la última posición hasta una posición mayor que 0. El elemento previo ocupa la posición actual.

  unshift(item){
      if(item){
        this.length++
        for (let i = this.length-1; i > 0; i--){
          this.data[i] = this.data[i-1]
        }
      }
      return this.length
  }

Una vez terminado el bucle, cuando todos los elementos han ocupado una posición posterior, el item pasado por parámetro ocupa la posición 0

    unshift(item){
      if(item){
        this.length++
        for (let i = this.length-1; i > 0; i--){
          this.data[i] = this.data[i-1]
        }
        this.data[0] = item;
      }
      return this.length
  }