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