Playground: crea tu propia implementación de shift

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

Libian María Hernández Gil

student•

Hasta aquí este curso ha sido súper genial para mi.... El poder construir un Array u objeto y poder manipularlo a partir de mis propios métodos, para modificar sus propiedades ha sido muy enriquecedor para mi. Con esto he logrado ser más detallista de los pasos necesarios para lograr algo... En fin, el poner en práctica la lógica para crear pequeños algoritmos, haciendo uso de los ciclos y condicionales y entender la lógica detrás de los métodos, es lo que hace que este curso tenga un alto valor en aprendizaje significativo.... Excelente como siempre, la explicación de nuestro Prof. Diego, el Grande.

Andrés Julian Caro Restrepo

student•

. . . .

  shift(){
    // Tu código aquí 👈
    if (this.length !== 0) {
      const firstItem = this.data[0];
      this.shiftIndex(0);

      return firstItem;
    } else {
      return undefined;
    }
  }

Diego Boyatjian

student•

dejo mi solucion * * * * * * * * * * * *

 shift() {
        // Tu código aquí 👈
        if (this.length == 0) {
            return undefined;
        }

        //obtengo el primer elemento
        const firstItem = this.data[0];

        // corrijo el numero de indice de cada elemento
        for (let i = 0; i < this.length; i++) {
            this.data[i] = this.data[i + 1];
        }
        // remuevo el ultimo slot que queda con undefined
        delete this.data[this.length - 1];

        // corrijo el largo del array
        this.length--;
        
        return firstItem;
    }

Cristián Santiago Rivera Guzmán

student•

la verdad he quedado inconcluso con este tema, no entendi para nada los procesos que llevo a cabo

diego Marcos

student•

Aqui mi solucion, usando el metodo shiftIndex() del profe :)

Santiago Salamanca

student•

Mi solución al reto. Utilizo el Object.keys(this.data) en lugar del this.length porque es de las cosas que más me costó aprender al recorrer objetos, es más una elección personal para tener presente eso y no olvidar cómo se hace

import { MyArray } from "./MyArray";

export class BetterArray extends MyArray {
  constructor(){
    super()
    this.length = 0
    this.data = {}
  }

  shift() {
    // Tu código aquí 👈
    let keys = Object.keys(this.data);
    let objectSize = keys.length;

    if (objectSize == 0) return undefined;

    let valueToShift = this.data[0];
    
    if (objectSize > 0) {
      for (let actualPosition = 0; actualPosition < objectSize; actualPosition++) {
        this.data[actualPosition] = this.data[actualPosition + 1];
      }
      delete this.data[objectSize - 1];
      this.length--;
    }
    return valueToShift;
  }
}

Jose Carlos Machado

student•

Mi querido "aportazo!" a la comunidad... :)

shift() { // Tu código aquí 👈 let first = this.data[0]; if (this.length === 0) { return undefined; } else {

for (let i = 0; i <= this.length - 1; i++) { this.data[i] = this.data[i + 1] } delete this.data[this.length - 1]; this.length-- return first } }

Miguel León Machado

student•

import { MyArray } from "./MyArray";

export class BetterArray extends MyArray {
  constructor(){
    super()
    this.length = 0
    this.data = {}
  }

  shift() {
    if (this.length == 0) return undefined;

    const itemDeleted = this.data[0];

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

    return itemDeleted;
  }
}

Johan Sebastian

student•

Andres giovanny lopez cortes

student•

este es mi code

dshift()

const newArrayShift = this.data[0]

this.deleteFirstElement()

return newArrayShift;

}

deleteFirstElement() {

for (let i = 0; i < this.length; i++) {

this.data[i] = this.data[i + 1]

}

this.length--; }

}

giovanni.sayago

student•

Hola comparto mi solución

shift() {

    if (this.length === 0) {
      return undefined;
    } else {
      const item = this.data[0];
      for (let i = 1; i < this.length; i++) {
        this.data[i - 1] = this.data[i];
      }
      const lastPosition = this.length - 1;
      delete this.data[lastPosition];
      this.length--;

      return item;
    }
  }

Edwar Sanchez

student•

Mi aporte
shift() {
    if (this.length === 0) return undefined;

    let elmEliminado = this.data[0];

    for (let i = 1; i < this.length; i++){
      this.data[i - 1] = this.data[i];
    }
    
    delete this.data[this.length - 1];
    this.length--;  

    return elmEliminado;
  }
```shift() {    if (this.length === 0) return undefined;
&#x20;   let elmEliminado = this.data\[0];
&#x20;   for (let i = 1; i < this.length; i++){      this.data\[i - 1] = this.data\[i];    }        delete this.data\[this.length - 1];    this.length--; &#x20;
&#x20;   return elmEliminado;  }

Aramis Garcia Guerrero

student•

Por poco se estalla mi cabeza

shift(){
        if(this.length === 0) return undefined;

        const firstItem = this.data[0];

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

        delete this.data[this.length-1];
        this.length--;        

        return firstItem;
    }

```shift(){        if(this.length === 0) return undefined;
        const firstItem = this.data\[0];
        for(let i = 0; i < this.length; i++){            this.data\[i] = this.data\[i+1];        }
        delete this.data\[this.length-1];        this.length--;        
        return firstItem;    }

Natalia Gallego Heras

student•

Mi solución tiene una constante, una condicional y un return.

La constante guarda el primer elemento
Si no hay primer elemento, retorna undefined

  shift() {
    const shifted = this.data[0]
    if(shifted){
    }
    return undefined
  }

Si sí existe, reduce la longitud y retorna la constante

  shift() {
    const shifted = this.data[0]
    if(shifted){
      this.length-- 
      return shifted
    }
    return undefined
  }

Mediante un bucle, desplaza cada elemento a la posición previa

  shift() {
    const shifted = this.data[0]
    if(shifted){
      this.length--     
      for (let i = 0; i < this.length; i++) {
        this.data[i] = this.data[i+1]
      }
      return shifted
    }
    return undefined
  }

Una vez realiza el bucle y cada elemento se ha guardado en una posición previa, elimina el último elemento (ya que de otra forma aparecería repetido, en la nueva posición y en la antigua)

  shift() {
    const shifted = this.data[0]
    if(shifted){
      this.length--     
      for (let i = 0; i < this.length; i++) {
        this.data[i] = this.data[i+1]
      }
      delete this.data[this.length]
      return shifted
    }
    return undefined
  }

Fidel Parabacuto

student•

Les dejo un reverse de la suerte

reverse(){
    let i = 0
    let j = this.length - 1 
    while(i<j){
      let temp = this.data[i]
      this.data[i] = this.data[j]
      this.data[j] = temp
      i++
      j--
    }

Josue David

student•

this is what I did:import { MyArray } from "./MyArray"; export class BetterArray extends MyArray { constructor(){ super() this.length = 0 this.data = {} } shift(){ // Tu código aquí 👈 if (!this.length) return undefined; const value = this.data[0]; delete this.data[0]; for (let i = 0; i < this.length - 1; i++){ this.data[i] = this.data[i + 1]; } delete this.data[this.length - 1] this.length--; return value }}

import { MyArray } from "./MyArray";

export class BetterArray extends MyArray {
  constructor(){
    super()
    this.length = 0
    this.data = {}
  }

  shift(){
    // Tu código aquí 👈
    if (!this.length) return undefined;
    const value = this.data[0];
    delete this.data[0];
    for (let i = 0; i < this.length - 1; i++){
      this.data[i] = this.data[i + 1];
    }
    delete this.data[this.length - 1]
    this.length--;
    return value
    
  }
}

Alan Dell Oso

student•

Mi solución:

shift(){
    if (this.length > 0) {
      const targetItem = this.data[0];
      this.#reorderIndex(0);
      return targetItem;
    }
    return undefined;
  }

  #reorderIndex(initialIndex) {
    for (let i = initialIndex; i < this.length - 1; i++) {
      this.data[i] = this.data[i + 1];
    }
    delete this.data[this.length - 1];
    this.length--;
  }

Andres Montes

student•

reto

import { MyArray } from "./MyArray";

export class BetterArray extends MyArray {
  constructor(){
    super()
    this.length = 0
    this.data = {}
  }

  shift(){
    // Tu código aquí 👈
    if (this.length === 0) {
      return undefined
    } else {
      const element = this.data[0]
      for (let i = 0; i < this.length; i++) {
          this.data[i] = this.data[i + 1]
      }
      delete this.data[this.length - 1]
      this.length -= 1
        return element
      }
    
  }
}

Harold Zurita Simon

student•

Solución 😄..

. . . .

import { MyArray } from "./MyArray";

export class BetterArray extends MyArray {
  constructor(){
    super()
    this.length = 0
    this.data = {}
  }

  shift() {
    const firstItem = this.data[0];

    if (firstItem) { 
      for (let i = 1; i < this.length; i++) {
        this.data[i - 1] = this.data[i];
      }
      delete this.data[this.length - 1];
      this.length--;
    }

    return firstItem;
  }
}

Fernando Orozco Velasquez

student•

Esta es mi solución a este reto 💚

Acá pueden probar el código, (hice un return 'undefined' implicito ya que al estar vacío el Array sus valores son undefined)

import { MyArray } from "./MyArray";

export class BetterArray extends MyArray {
  constructor(){
    super()
    this.length = 0
    this.data = {}
  }

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

    delete this.data[this.length - 1];                          
    this.length--;  
    return item;  
  }
}

Playground: crea tu propia implementación de shift

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

Construcción de Arrays con Clases en JavaScript

Construcción de Arrays con Clases en JavaScript

Eliminar elementos de un array en JavaScript: método POP y DELETE

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

Inserción de nodos en listas enlazadas en JavaScript

Implementación de Listas Doblemente Enlazadas en Programación

Stacks

Stacks: Concepto y Operaciones Básicas en JavaScript

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

Queues

Colas: Estructura de Datos y Operaciones Básicas

Implementación de Colas (Queues) 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 de Grafos en JavaScript: Listas y Matrices

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

Cierre

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