Playground: implementa el método getAllKeys

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

Brian Alfonso Bocanegra Hernández

student•

Mi aporte

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

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

Alan Saldívar

student•

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

Ulqernesh Karvenae

student•

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

Daniel Cruz

student•

Mi Solucion

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

Jose Castillo

student•

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

student•

  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

student•

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

Octavio Alvarez Olan

student•

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

student•

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

Creative Artisan

student•

En que parte del ejercicio dice que no debemos?

Pedro Roberto Capriles Morales

student•

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

student•

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

Andrés Camilo Vélez Mejía

student•

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

Antonio Guzman

student••

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

student•

la verdad no he entendido nada del tema

Andres giovanny lopez cortes

student•

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

student•

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

student•

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

student•

Mi solucion

getAllKeys() {

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

}

Daniel Andres Rojas Paredes

student•

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

student•

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

student•

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

student•

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

student•

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

student•

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

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