“hash table” Code Answer’s

hash table hashing method

javascript by Mohammad alshraideh

on Aug 19 2022 Donate Comment

 makeHash(key) {
      const asciicodeSum = key.split("").reduce((acc, cur) => {
          return acc + cur.charCodeAt(0);
      }, 0);
      const multiPrime = asciicodeSum * 599;
      const theIndex = multiPrime % this.size;
      console.log(theIndex)
      return theIndex;
  }

Hash Table

python by Keen Kingfisher

on Sep 06 2022 Comment

"""Hash Table
THIS HASH TABLE ASSUMES THAT YOU ARE PUTTING UNIQUE KEYS WHEN YOU...
...CALL put FUNCTION, 
MAKE AN UPDATE FUNCTION IF YOU ARE PUTTING REPEATED KEYS

Included:
	- hash / rehash (using linear probe)
	- load factor
    - put
	- get

Not included:
	- Get prime/ Check prime
    - Resize
    - Update
    and more...
"""
import fractions
class HashTable:
    def __init__(self, size):
        self._size = size
        self._used = 0
        self._keys = [None]*size
        self._values = [None]*size
        
    def hash_function(self, key):
        return (key % self._size)
    
    def rehash(self, old_key):
        return self.hash_function(old_key + 1) # Linear Probe
    
    def load_factor(self):
        return fractions.Fraction(self._used, self._size)
    
    def full(self):
        return self.load_factor() == 1
    
    def put(self, key, value):
        if self.full():
            return "Full"
        
        # There is empty space
        # Get digest
        digest = self.hash_function(key)
        
        # Resolve collisions
        # Rehash if not empty or key does not exist
        while self._keys[digest] is not None and self._keys[digest] != key:
            digest = self.rehash(digest)
            
        # Don't put if key already exists
        if self._keys[digest] == key:
            return "Exists"
        
        # Finally can put in empty space
        else:
            self._keys[digest] = key
            self._values[digest] = value
            self._used += 1 # update used space counter
            return "Entered"
            
    def get(self, key):
        # Get digest
        digest = self.hash_function(key)
        
        # Within the range of the total space
        for _ in range(self._size):
            if self._keys[digest] != key:
                digest = self.rehash(digest)
            else:
                return self._values[digest]
        
        # Not found
        return "Not found"
        
# Test
from randstr import randstr
from random import randint
def HT_Test(HT):
    print(f">>> HashTable:")
    # Make keys and values
    r = randint(8, 15)
    keys = [randint(10, 100) for _ in range(r)]
    vals = list(randstr(len(keys)))
    print(f"Keys to enter: {keys}",
          f"Vals to enter: {vals}",
          f"Key-value pair: {list(zip(keys, vals))}",   # display one list with key-value pair
          sep = "\n", end = "\n\n")
    
    # Initiate Hash Table
    H = HT(len(keys) - 2)
    
    # Put the key-value pair into Hash Table
    print("Put:")
    for i in range(len(keys)):
        key, val = keys[i], vals[i]
        print(f"Key: {key}",
              f"Status: {H.put(key, val)}",
              f"Load factor: {H.load_factor()}", 
              sep = " | ")
    print()
    print(f"Keys entered: {H._keys}",
          f"Values entered: {H._vals}", 
          sep = "\n", end = "\n\n")
    
    # Get the values in Hash Table for each corresponding key
    print("Get:")
    for key in keys:
        print(f"Key: {key}",
              f"({H.get(key)})",
              sep = " | ")

Source: www.programiz.com

hash table

go by gocrazygh

on May 06 2022 Comment

//The hash table is famous for it's constant time complexity

package main

import (
	"fmt"
)

const aSize = 5

//The structure of the hash table is an array
type HashTable struct {
	array [aSize]*Bucket
}

//The bucket is the linked list appeded to the hash table
type Bucket struct {
	head *BucketNode
}

//The keys will be stored in the bucket and will be a bucket node
type BucketNode struct {
	key string
	next *BucketNode
}

//The insert function for the hash table (array)
func (h *HashTable) Insert(key string) {
	index := hash(key)
	h.array[index].InsertBucket(key)
}
//The search function for the hash table (array)
func (h *HashTable) Search(key string) bool{
	index := hash(key)
	return h.array[index].SearchBucket(key)
}
//The delete function for the hash table (array)
func (h *HashTable) Delete(key string) {
	index := hash(key)
	h.array[index].DeleteBucket(key)
	
}

//These three functions edit the bucket
//The insert function for the bucket(linked keys)
func (b *Bucket)InsertBucket(k string)  {
	if !b.SearchBucket(k){
	newNode := &BucketNode{key:k}
	newNode.next = b.head
	b.head = newNode
	}else {
		fmt.Println(k, "already exist")
	}
}

//The search function for the bucket (linked keys)
func (b *Bucket)SearchBucket(k string) bool {
	cNode := b.head
	for cNode != nil {
		if cNode.key == k {
			return true
		}
		cNode = cNode.next
	}
	return false
}

//The delete function for the bucket (linked keys)
func (b *Bucket)DeleteBucket(k string)  {

    if b.head.key == k{
		b.head = b.head.next
		return
	}

	pNode := b.head
	for pNode != nil{
		if pNode.next.key == k{
			pNode.next =pNode.next.next
		}
		pNode = pNode.next
	}
}

//This function turns the string to ascii int and divided by the size
//of the array to get it's index
func hash(key string) int {
	r := 0
	for _, v := range key {
		r+=int(v)
	}
	return r % aSize
}

//This function creates a hash table
func Create() *HashTable {
	r := &HashTable{}
	for i := range r.array {
		r.array[i] = &Bucket{}
	}
	return r
}

func main() {
	myHashTable := Create()//Creating a hash table

	keys := []string{
		"mike",
		"sam",
		"ben",
		"ham",
		"jake",
	}

	for _, v := range keys {//Inserting keys to the hash table
		myHashTable.Insert(v)
	}
    
	fmt.Println(myHashTable.Search("mike"))//Searching for mike
	myHashTable.Delete("mike")//Deleting mike
	fmt.Println(myHashTable.Search("mike"))//Searching again for mike
}

Source: github.com

hash table

java by Wild Wolverine

on Jul 26 2022 Comment

//Java Hashtable
//--------------
  
import java.io.*;
import java.util.*;
  
class AddElementsToHashtable {
    public static void main(String args[])
    {
       
        Hashtable<Integer, String> h1 = new Hashtable<>();
  
        // Initialization of a Hashtable using Generics
        Hashtable<Integer, String> h2 = new Hashtable<Integer, String>();
  
        // Inserting the Elements using put() method
        //                              ------------
        ht1.put(1, "Chris");
        ht1.put(2, "Tony");
        ht1.put(3, "Peter");
        ht2.put(4, "Steven");
  
        // Print mappings to the console (Output)
        System.out.println("Mappings of Hash Table 1 : " + h1);
        System.out.println("Mappings of Hash Table 2 : " + h2);
    }
}

Add a Grepper Answer

“hash table” Code Answer’s

hash table hashing method

Hash Table

hash table

hash table

Answers related to “hash table”

Queries related to “hash table”

Grepper

Documentation

Social

Legal

Contact

Oops, You will need to install Grepper and log-in to perform this action.