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

juan jose Borrero

student•

export class MyArray {

constructor() {

this.length = 0;

this.data = {};

}

unshift(item) {

// Paso 1: si no hay item

if (!item) {

return this.length;

}

// Paso 2: mover elementos a la derecha

for (let i = this.length; i > 0; i--) {

this.data[i] = this.data[i - 1];

}

// Paso 3: agregar el nuevo elemento al inicio

this.data[0] = item;

// Paso 4: aumentar length

this.length++;

// Paso 5: retornar nueva longitud

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

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

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

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
    }

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

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

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

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

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

}

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

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

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

Playground: crea tu propia implementación de unshift

Introducción a las estructuras de datos

Estructuras de Datos en JavaScript para Desarrolladores

Estructuras de Datos: Conceptos Básicos y Aplicaciones Prácticas

Almacenamiento de Datos en Memoria con JavaScript

Arrays y strings

Cómo funcionan arrays en memoria de JavaScript

Construcción de Arrays con Clases en JavaScript

Métodos pop y delete en arrays

Playground: crea tu propia implementación de unshift

Playground: crea tu propia implementación de shift

Inmutabilidad de Strings y Almacenamiento en Memoria

Hash Table

Conceptos y Construcción de Hash Tables en JavaScript

Implementación de Hash Table en JavaScript: Método Set

Implementación del método get en hash table JavaScript

Playground: implementa el metodo Delete

Playground: implementa el método getAllKeys

Linked List

Estructuras de Datos: Listas Enlazadas en JavaScript

Estructura y Creación de una Lista Enlazada Simple en JavaScript

Métodos para Manipular Nodos en Listas Enlazadas

Inserta nodos intermedios sin romper enlaces en JavaScript

Doubly Linked List con punteros bidireccionales

Stacks

Stacks: Concepto y Operaciones Básicas en JavaScript

Implementación de Stacks en JavaScript: Métodos Push y Peek

Queues

Qué es queue y cómo funciona FIFO

Implementación del método enqueue en JavaScript

Trees

Estructuras de Datos: Árboles Binarios y Búsqueda en JavaScript

Construcción y validación de un Árbol de Búsqueda Binaria en JavaScript

Graphs

Conceptos básicos de grafos: tipos y aplicaciones prácticas

Representación visual de grafos en JavaScript

Construcción de Grafos: Método Lista de Adyacencia en JavaScript

Cierre

Estructuras de Datos con JavaScript: Práctica y Aplicación