Playground: implementa el método getAllKeys

Curso de Estructuras de Datos con JavaScript

Contenido del curso

Introducción a las estructuras de datos

Arrays y strings

Hash Table

Linked List

Stacks

Queues

Trees

24
Estructuras de Datos: Árboles Binarios y Búsqueda en JavaScript
06:15 min
25
Construcción y validación de un Árbol de Búsqueda Binaria en JavaScript
19:36 min

Graphs

Cierre

29
Estructuras de Datos con JavaScript: Práctica y Aplicación
03:14 min

Tomar examen

Playground: implementa el método getAllKeys

Comentarios73

Brian Alfonso Bocanegra Hernández

Estudiante

Mi aporte

 getAllKeys(){
    const array = this.data
    let key = []

    array.forEach((e) => {
      e.forEach((k) => {
        key.push(k[0]);
      })
    });
    return key;
  }

Alan Saldívar

Estudiante

  getAllKeys(){
    return this.data
      .flat()
      .map(([name]) => name)
  }

Ulqernesh Karvenae

Estudiante

XD no conocía que existia desestructuración con arrays, gracias

Daniel Cruz

Estudiante

Mi Solucion

getAllKeys(){
    // Tu código aquí 👈
    let items = this.data
      .filter(item => item != undefined)
      .flat()
      .map(item => item[0])
    
    return items;
  }

Jose Castillo

Estudiante

Creo que esta solución no seria tan optima si se presenta una coalición. si tu data se presenta así:

let data = [ ["Diego", 1990], ["Alejandra", 2000], [ ["Daniel", 1990], ["Alex", 2005] ] ]

Cuando le apliques un flat()… este solo hará plano el array un solo nivel, generándote algo como esto:

["Diego", 1990, "Alejandra", 2000, ["Daniel", 1990], ["Alex", 2005]]

Así que tendrías que indicarle al método flat para que vaya un nivel mas profundo, esto se logra enviándole un argumento, podría ser algo así:

data.filter(item => item != undefined).flat(2);
// OUTPUT:
// ["Diego", 1990, "Alejandra", 2000, "Daniel", 1990, "Alex", 2005]

Ahora que ya tenemos un resultado mas limpio para trabajar, y necesitamos solo las keys. podríamos evaluarlo de la siguiente manera, si nuestras keys siempre serán del tipo “string”, y nuestro value del tipo “number”, podriamos filtrar para que solo muestre los datos de tipo “string” :

data.filter(items => items != undefined).flat(2)
	.filter(item =>typeof item == "string");

// OUTPUT:
// ["Diego", "Alejandra", "Daniel", "Alex"]

Ahora en caso de que nuestras keys y values no tengan un tipo definido, podemos hacerlo del siguiente modo:

data.filter(items => items != undefined).flat(2)
	.filter((item, index)=> index % 2 == 0);

// OUTPUT:
// ["Diego", "Alejandra", "Daniel", "Alex"]

Obteniendo así el mismo resultado, pero en este caso no basara su respuesta en el tipo de dato, sino en el index de los elementos, que corresponderá siempre al de las Keys.

Genoveva Flores

Estudiante

  getAllKeys(){
    let keys = [];
    for (let i = 0; i < this.data.length; i++) {
      if (this.data[i]) {
        for (let j = 0; j < this.data[i].length; j++) {

          if (this.data[i][j]) {
            keys.push(this.data[i][j][0])
          }

        }

      }
    }
    return keys;
  }

Diego Reyes Cabrera

Estudiante

Yo hice algo muy similar! Solo cambia un poco: !foto

Octavio Alvarez Olan

Estudiante

Se supone que el metodo no debe usar metodos:)

<code> 
  getAllKeys(){
    // Tu código aquí 👈
    const table = this.data;
    const allKeys = []
    for (let i = 0; i < table.length; i++) {
      if (table[i]) {
        for (let j = 0; j < table[i].length; j++) {
          allKeys.push(table[i][j][0]);
        }
      }
    }
    return allKeys;
  }

Kevin Daniel Hincapie Lumbaque

Estudiante

Pero estas usando push... entonces fallaste? heheh, bromita nomas. Yo use reduce para mi solucion :3.

Creative Artisan

Estudiante

En que parte del ejercicio dice que no debemos?

Pedro Roberto Capriles Morales

Estudiante

Solución

  getAllKeys() {
    const keys = [];
    for (let bucket of this.data) {
      if (bucket) {
        for (let item of bucket) {
          keys.push(item[0]);
        }
      }
    }

    return keys;
  }

Caso de prueba

test("Should return an array with all keys", () => {
    const myHashTable = new MyHashTable(50);
    const dataExpected = ["Diego", "Mariana", "Miranda", "Cat"];

    myHashTable.set("Diego", 1990);
    myHashTable.set("Mariana", 1998)
    myHashTable.set("Miranda", 2000)
    myHashTable.set("Cat", 2010)
    const data = myHashTable.getAllKeys();

    console.log(data);

    expect(typeof myHashTable.data === "object").toBeTruthy();
    expect(data).toHaveLength(4);
    expect(data).toEqual(expect.arrayContaining(dataExpected));
  });

Repositorio:

José Eduardo Meza Gallardo

Estudiante

  getAllKeys() {
    return this.data.flatMap(el => {
      return el.map((key) => key[0]);
    });
  }

Andrés Camilo Vélez Mejía

Estudiante

import { HashTable } from "./hashTable.js"

export class Solution extends HashTable {
  constructor(size){
    super()
    this.data = new Array(size)
  }


  getAllKeys(){
    // Tu código aquí 👈
    let allValues = [];
    for (const arr of this.data) {
      if (arr) {
        for (const element of arr) {
          allValues.push(element[0]);
        }
      }
    }
    return allValues;
  }
}

Josué Antonio Contreras Guzmán

Estudiante

•

Mi solución y aporte :

getAllKeys() {

let newArrayKeys = [];

let data = this.data.filter(item => item != undefined).flat();

data.forEach(key => newArrayKeys.push(key[0]));

return newArrayKeys;

}

Cristián Santiago Rivera Guzmán

Estudiante

la verdad no he entendido nada del tema

Andres giovanny lopez cortes

Estudiante

comparto mi solucion

getAllKeys(key) { const address = this.hashMethod(key); return this.data[address] } AllKeysMethod() { for (let i = 0; i < this.data.length; i++) { const bucket = this.data[i]; if (bucket) { for (let j = 0; j < bucket.length; j++) { console.log(bucket[j][0]); } }

} return this.data; }}

Erick Martinez

Estudiante

Mi solución:

getAllKeys() {
    let keys = [];

    for (let i = 0; i < this.data.length; i++) {
      if (!Array.isArray(this.data[i])) continue;

      for (let j = 0; j < this.data[i].length; j++) {
        keys.push(this.data[i][j][0])
      }
    }
    return keys;
  }
```getAllKeys() {    let keys = \[];
&#x20;   for (let i = 0; i < this.data.length; i++) {      if (!Array.isArray(this.data\[i])) continue;
&#x20;     for (let j = 0; j < this.data\[i].length; j++) {        keys.push(this.data\[i]\[j]\[0])      }    }    return keys;  }

Ana Rotela Cabrera

Estudiante

Comparto mi solución

  getAllKeys(){
    const keyArrays = [];
    for (let i = 0; i < this.data.length; i++){
      const currentBucket = this.data[i];
      if (currentBucket) {
        for (let j = 0; j < currentBucket.length; j++){
          keyArrays.push(currentBucket[j][0]);
        }
      }
    }
    return keyArrays;
  }
``` &#x20;

Alex Santacruz

Estudiante

Mi solucion

getAllKeys() {

return this.data.flatMap((item) => item.map((el) => el[0]));

}

Daniel Andres Rojas Paredes

Estudiante

no entiendo por que este codigo no parece funcionar, debe tener algo que ver con la logica pero no entiendo en que parte esta el fallo ```js getAllKeys(){ const keys = this.data.map(bucket=>{ // let keys=new array[this.size] if(bucket){ bucket.forEach(element => {return element[0]

  });

}

}) return keys }

Fernando Balandrano

Estudiante

import { HashTable } from "./hashTable.js"

export class Solution extends HashTable {
  constructor(size){
    super()
    this.data = new Array(size)
  }
```import { HashTable } from "./hashTable.js"
export class Solution extends HashTable {  constructor(size){    super()    this.data = new Array(size)  }

Daniel Andres Rojas Paredes

Estudiante

como no hacerlo:

se me ocurrio aplanar el arreglo, y retornar los elementos pares del arreglo. estos deberian corresponder a las keys. pero no tube en cuenta que para que esta logica funcionara, todas las posiciones de la hash table deberian pocer un tupla almenos (key,value). pero esto nunca es asi, la hash se inicializa con un size definido, lo que hace que hallan elementos undefince cuando no halla tuplas, por lo que es imposible determinar que el arreglo aplanado tendra un numero par de elementos donde todos los pares seran keys (= ja ja ja a intentar otra vez ... y me sentia tan orgulloso de mi solucion

getAllKeys(){ const flatten=this.data.flat(2) const keys=new Array(flatten.length/2) for(let i=0;i<flatten.length;i+2){ keys[i/2]=flatten[i]; } return keys}

DEIVY ALEJANDRO BAUTISTA PARDO

Estudiante

getAllKeys() {
    const bucketList = this.data
    const keyList = []
    for (const key in bucketList) {
        if (Object.hasOwnProperty.call(bucketList, key)) {
            const element = bucketList[key];
            for (const keys in element) {
                const value = element[keys];
                keyList.push(value[0])
            }
        }
    }
    return keyList
}
```    getAllKeys() {        const bucketList = this.data        const keyList = \[]        for (const key in bucketList) {            if (Object.hasOwnProperty.call(bucketList, key)) {                const element = bucketList\[key];                for (const keys in element) {                    const value = element\[keys];                    keyList.push(value\[0])                }            }        }        return keyList    }

DEIVY ALEJANDRO BAUTISTA PARDO

Estudiante

const bucketList = this.data
        const keyList = []
        for (const key in bucketList) {
            if (Object.hasOwnProperty.call(bucketList, key)) {
                const element = bucketList[key];
                for (const keys in element) {
                    const value = element[keys];
                    keyList.push(value[0])
                }
            }
        }
        return keyList
```const bucketList = this.data        const keyList = \[]        for (const key in bucketList) {            if (Object.hasOwnProperty.call(bucketList, key)) {                const element = bucketList\[key];                for (const keys in element) {                    const value = element\[keys];                    keyList.push(value\[0])                }            }        }        return keyList&#x20;

Alan Dell Oso

Estudiante

Mi solución

getAllKeys() {
    let keys = [];
    this.data.flat(1).forEach(bucket => {
      if (bucket[0]) {
        keys.push(bucket[0]);
      }
    });
    return keys;
  }
}

  getAllKeys(){
    let keys = [];
    for (let i = 0; i < this.data.length; i++) {
      if (this.data[i]) {
        for (let j = 0; j < this.data[i].length; j++) {

          if (this.data[i][j]) {
            keys.push(this.data[i][j][0])
          }

        }

      }
    }
    return keys;
  }

<code> 
  getAllKeys(){
    // Tu código aquí 👈
    const table = this.data;
    const allKeys = []
    for (let i = 0; i < table.length; i++) {
      if (table[i]) {
        for (let j = 0; j < table[i].length; j++) {
          allKeys.push(table[i][j][0]);
        }
      }
    }
    return allKeys;
  }

  getAllKeys() {
    const keys = [];
    for (let bucket of this.data) {
      if (bucket) {
        for (let item of bucket) {
          keys.push(item[0]);
        }
      }
    }

    return keys;
  }

test("Should return an array with all keys", () => {
    const myHashTable = new MyHashTable(50);
    const dataExpected = ["Diego", "Mariana", "Miranda", "Cat"];

    myHashTable.set("Diego", 1990);
    myHashTable.set("Mariana", 1998)
    myHashTable.set("Miranda", 2000)
    myHashTable.set("Cat", 2010)
    const data = myHashTable.getAllKeys();

    console.log(data);

    expect(typeof myHashTable.data === "object").toBeTruthy();
    expect(data).toHaveLength(4);
    expect(data).toEqual(expect.arrayContaining(dataExpected));
  });

import { HashTable } from "./hashTable.js"

export class Solution extends HashTable {
  constructor(size){
    super()
    this.data = new Array(size)
  }


  getAllKeys(){
    // Tu código aquí 👈
    let allValues = [];
    for (const arr of this.data) {
      if (arr) {
        for (const element of arr) {
          allValues.push(element[0]);
        }
      }
    }
    return allValues;
  }
}

getAllKeys() {
    let keys = [];

    for (let i = 0; i < this.data.length; i++) {
      if (!Array.isArray(this.data[i])) continue;

      for (let j = 0; j < this.data[i].length; j++) {
        keys.push(this.data[i][j][0])
      }
    }
    return keys;
  }
```getAllKeys() {    let keys = \[];
&#x20;   for (let i = 0; i < this.data.length; i++) {      if (!Array.isArray(this.data\[i])) continue;
&#x20;     for (let j = 0; j < this.data\[i].length; j++) {        keys.push(this.data\[i]\[j]\[0])      }    }    return keys;  }

  getAllKeys(){
    const keyArrays = [];
    for (let i = 0; i < this.data.length; i++){
      const currentBucket = this.data[i];
      if (currentBucket) {
        for (let j = 0; j < currentBucket.length; j++){
          keyArrays.push(currentBucket[j][0]);
        }
      }
    }
    return keyArrays;
  }
``` &#x20;

import { HashTable } from "./hashTable.js"

export class Solution extends HashTable {
  constructor(size){
    super()
    this.data = new Array(size)
  }
```import { HashTable } from "./hashTable.js"
export class Solution extends HashTable {  constructor(size){    super()    this.data = new Array(size)  }

getAllKeys() {
    const bucketList = this.data
    const keyList = []
    for (const key in bucketList) {
        if (Object.hasOwnProperty.call(bucketList, key)) {
            const element = bucketList[key];
            for (const keys in element) {
                const value = element[keys];
                keyList.push(value[0])
            }
        }
    }
    return keyList
}
```    getAllKeys() {        const bucketList = this.data        const keyList = \[]        for (const key in bucketList) {            if (Object.hasOwnProperty.call(bucketList, key)) {                const element = bucketList\[key];                for (const keys in element) {                    const value = element\[keys];                    keyList.push(value\[0])                }            }        }        return keyList    }

const bucketList = this.data
        const keyList = []
        for (const key in bucketList) {
            if (Object.hasOwnProperty.call(bucketList, key)) {
                const element = bucketList[key];
                for (const keys in element) {
                    const value = element[keys];
                    keyList.push(value[0])
                }
            }
        }
        return keyList
```const bucketList = this.data        const keyList = \[]        for (const key in bucketList) {            if (Object.hasOwnProperty.call(bucketList, key)) {                const element = bucketList\[key];                for (const keys in element) {                    const value = element\[keys];                    keyList.push(value\[0])                }            }        }        return keyList&#x20;

Playground: implementa el método getAllKeys

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