Hashing in Competitive Programming

Hashing is a fundamental technique in competitive programming that is used to efficiently manipulate and process large amounts of data. Data Structures like Hash Maps and Hash Sets use hashing techniques to provide faster insertion, deletion and retrieval of values.

What is Hashing?

Hashing is a fundamental data structure and technique used in competitive programming to efficiently store and retrieve elements based on their “keys.”

Imagine a filing cabinet with labels for each document. The labels are like hash functions, and the documents themselves are the elements. By using a good hash function, you can quickly find the document you need without having to look through every single one.

In computer science, hashing involves:

• Hash function: This function takes an element as input and generates a fixed-size, unique value (hash code) for it. Ideally, different elements should have different hash codes (no collisions).
• Hash table: This data structure stores the elements along with their hash codes. It allows for fast lookup and insertion based on the hash code.

Why use Hashing in Competitive Programming?

Competitive programming often involves dealing with large amounts of data and solving problems under tight time constraints. Hashing comes in handy in several situations:

• Efficient searching: Finding specific elements in a large dataset becomes much faster with hashing compared to linear search (O(1) vs. O(n)).
• Duplicate detection: Identifying duplicate elements becomes trivial with a good hash function.
• Set operations: Operations like union, intersection, and difference on sets can be implemented efficiently using hashing.
• Memory optimization: Hash tables can be more memory-efficient than other data structures like sorted arrays.
• Solving specific problems: Certain problems in competitive programming, like string matching or finding collisions in data streams, have elegant solutions using hashing techniques.

Advantages of Hashing

• Fast lookup and insertion: O(1) time complexity in the average case.
• Memory efficiency: Can be more efficient than other data structures for certain types of data.
• Simple to implement: Most languages provide built-in hash table libraries.

Disadvantages of Hashing

• Collisions: Different elements can have the same hash code, requiring collision handling techniques (e.g., chaining, double hashing) which can impact performance.
• Not a good fit for all problems: Not suitable for problems requiring frequent updates or deletions.
• Choosing the right hash function: Important to select a good hash function to minimize collisions.

Common Hash Functions and Collision Handling Techniques

Several hash functions exist, each with its own strengths and weaknesses. Some popular choices include:

• Modulo function: Hash code is the remainder of dividing the element’s value by a prime number. Simple but can lead to collisions for certain data types.
• Polynomial rolling hash: Used for string hashing. Efficiently calculates the hash for any substring based on the previous substring’s hash.
• MurmurHash family: High-performance hash functions with good collision resistance.

Collision handling techniques are crucial when different elements have the same hash code:

• Open addressing: Re-inserts the element in another location in the hash table (e.g., linear probing, quadratic probing). Can lead to performance degradation if collisions are frequent.
• Chaining: Stores elements with the same hash code in a linked list attached to the corresponding slot in the hash table. More efficient than open addressing for high collision rates.

Use Cases of Hashing in Competitive Programming

In competitive programming, hashing is a versatile technique for organizing and retrieving data. Because it performs lightning-quick lookups and data manipulation efficiently, it is a great tool for tackling algorithms. Here are some of its use cases/applications of hashing:

1. Finding Duplicate Elements:

Imagine a dataset where you need to identify duplicate elements. Brute-force pairwise comparisons are inefficient for large datasets. Hashing comes to the rescue. By mapping each element to a unique hash value in a hash table, finding duplicates becomes a simple lookup operation. Time complexity drops from O(n²) to O(1) on average, a significant improvement.

2. Implementing Disjoint-Set Union (DSU):

Disjoint-set union (DSU) algorithms manage groups of elements and perform operations like finding the representative of a group and merging groups. Hashing can be used to efficiently implement DSU by storing sets as hash tables. Finding the representative becomes a constant-time lookup, and merging sets involves updating the hash table pointers, keeping the operation efficient.

3. Counting Frequencies of Elements:

Counting the occurrences of each element in a dataset is another common task. Hashing offers a fast and memory-efficient solution. By storing element counts as values in a hash table, you can retrieve the frequency of any element with a single lookup. This approach is significantly faster than iterating through the entire dataset for each query.

4. Efficient String Matching:

String matching algorithms find occurrences of a pattern string within a larger text string. Hashing can significantly speed up this process. Algorithms like Rabin-Karp use rolling hashes to efficiently compute and compare hash values of substrings, potentially avoiding unnecessary character-by-character comparisons.

5. Solving Collision Problems:

Hash collisions occur when different elements map to the same hash value. While hash functions strive to minimize collisions, they are inevitable. Several techniques address this issue, including open addressing (probing for empty slots) and chaining (grouping colliding elements). Choosing the right approach depends on the specific scenario and desired trade-offs between speed and memory usage.

Hashing in Competitive Programming for C++ Programmers:

Initially, C++ had set and map, which are tree data structures which offers the worst-case time complexity of O(logN) to find any item. With C++11, hash set and hash map as unordered_set and unordered_map was introduced which offer an average case of O(1) but worst case of O(N) to insert, delete or retrieve any item. The average case is O(1) because it is assumed that each item only runs into O(1) collisions on average. For random input, they offer O(1) but it is possible to design inputs to make large number of collisions causing the time complexity of every operation to be O(N). This is quite common on various Competitive Programming platforms where people hack solutions of others who have used unordered maps with standard hash function assuming that it takes O(1) to perform every operation.

How to handle collision attacks?

It is clear that if we use unordered map with standard hash function, it is possible to break the solution from O(N) to O(N^2). The unordered_map class in C++ uses a combination of hashing and modulo arithmetic to store its elements. The hashing function is used to generate a hash value for each element, and the modulo arithmetic is used to map the hash value to a bucket in the hash table.

The __detail::_Mod_range_hashing class is responsible for implementing the modulo arithmetic part of the hashing process. This class takes a hash value as input and returns a bucket index. The __detail::_Prime_rehash_policy class is responsible for implementing the resizing policy of the hash table. This class determines when the hash table needs to be resized and how to resize it. The __prime_list array is an array of prime numbers that is used by the __detail::_Prime_rehash_policy class to determine the size of the hash table. When the hash table needs to be resized, the __detail::_Prime_rehash_policy class will choose the next prime number in the __prime_list array and resize the hash table to that size.

So, instead of using the standard hash function (identity function for integers), we can use a custom non-deterministic hash function that depends on time so even for the same inputs it produces different output.

Below is safe custom hash function that uses a high-precision clock to generate a random number that is used as input to the hash function. This makes it much more difficult for an attacker to predict the output of the hash function therefore making the time complexity of insert, delete and retrieve operations as O(1).

C++

#include <bits/stdc++.h>
using namespace std;

struct gfg_custom_hash {
    static uint64_t splitmix64(uint64_t key)
    {
        key += 0x9e3779b97f4a7c15;
        key = (key ^ (key >> 30)) * 0xbf58476d1ce4e5b9;
        key = (key ^ (key >> 27)) * 0x94d049bb133111eb;
        return key ^ (key >> 31);
    }

    // function to make the hash function non-deterministic
    size_t operator()(uint64_t x) const
    {
        static const uint64_t RANDOM
            = chrono::steady_clock::now()
                  .time_since_epoch()
                  .count();
        return splitmix64(x + RANDOM);
    }
};

int main()
{
    // Passing the custom hash function for the
    // unordered map
    unordered_map<long long, int, gfg_custom_hash> mp;
    mp[1] = 10;
    mp[2] = 20;
    for (auto ele : mp) {
        cout << ele.first << " " << ele.second << "\n";
    }

    // Passing the custom hash function for the
    // unordered set
    unordered_set<long long, gfg_custom_hash> st;
    st.insert(1);
    st.insert(2);
    for (auto ele : st)
        cout << ele << " ";
    cout << "\n";

    return 0;
}

Java

import java.util.*;
import java.util.concurrent.TimeUnit;

class GFGCustomHash {
    static class GFGCustomHashFunction {
        static long splitmix64(long key) {
            key += 0x9e3779b97f4a7c15L;
            key = (key ^ (key >> 30)) * 0xbf58476d1ce4e5b9L;
            key = (key ^ (key >> 27)) * 0x94d049bb133111ebL;
            return key ^ (key >> 31);
        }

        // Function to make the hash function non-deterministic
        public long apply(long x) {
            final long RANDOM = System.nanoTime();
            return splitmix64(x + RANDOM);
        }
    }

    public static void main(String[] args) {
        // Passing the custom hash function for the unordered map
        HashMap<Long, Integer> map = new HashMap<>(16, 0.75f);
        GFGCustomHashFunction customHashFunction = new GFGCustomHashFunction();
        for (long i = 1; i <= 2; i++) {
            map.put(i, (int) (i * 10));
        }

        for (Map.Entry<Long, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " " + entry.getValue());
        }

        // Passing the custom hash function for the unordered set
        HashSet<Long> set = new HashSet<>(16, 0.75f);
        for (long i = 1; i <= 2; i++) {
            set.add(i);
        }

        for (Long element : set) {
            System.out.print(element + " ");
        }
        System.out.println();
    }
}

C#

using System;
using System.Collections.Generic;

public class GFGCustomHash
{
    // Define a struct to implement custom hash function
    public struct GFGCustomHashFunction : IEqualityComparer<long>
    {
        public bool Equals(long x, long y)
        {
            return x == y;
        }

        public int GetHashCode(long obj)
        {
            // Call the static Apply method to generate the hash code
            return (int)Apply((ulong)obj);
        }

        public static ulong SplitMix64(ulong key)
        {
            key += 0x9e3779b97f4a7c15UL;
            key = (key ^ (key >> 30)) * 0xbf58476d1ce4e5b9UL;
            key = (key ^ (key >> 27)) * 0x94d049bb133111ebUL;
            return key ^ (key >> 31);
        }

        // Function to make the hash function non-deterministic
        public static ulong Apply(ulong x)
        {
            // Use a different approach for generating random value in C#,
            // as there's no direct equivalent to chrono::steady_clock::now().time_since_epoch().count() in C#.
            ulong RANDOM = (ulong)DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
            return SplitMix64(x + RANDOM);
        }
    }

    public static void Main(string[] args)
    {
        // Passing the custom hash function for the unordered map
        Dictionary<long, int> map = new Dictionary<long, int>(new GFGCustomHashFunction());
        map.Add(1, 10);
        map.Add(2, 20);
        foreach (var pair in map)
        {
            Console.WriteLine(pair.Key + " " + pair.Value);
        }

        // Passing the custom hash function for the unordered set
        HashSet<long> set = new HashSet<long>(new GFGCustomHashFunction());
        set.Add(1);
        set.Add(2);
        foreach (var element in set)
        {
            Console.Write(element + " ");
        }
        Console.WriteLine();
    }
}

Javascript

class GFGCustomHashFunction {
    static splitmix64(key) {
        key += 0x9e3779b97f4a7c15n;
        key = (key ^ (key >> 30n)) * 0xbf58476d1ce4e5b9n;
        key = (key ^ (key >> 27n)) * 0x94d049bb133111ebn;
        return key ^ (key >> 31n);
    }

    // Function to make the hash function non-deterministic
    static apply(x) {
        const RANDOM = process.hrtime.bigint();
        return GFGCustomHashFunction.splitmix64(x + RANDOM);
    }
}

class GFGCustomHash {
    static main() {
        // Passing the custom hash function for the unordered map
        const map = new Map();
        for (let i = 1n; i <= 2n; i++) {
            map.set(i, Number(i * 10n));
        }

        for (const [key, value] of map) {
            console.log(key + " " + value);
        }

        // Passing the custom hash function for the unordered set
        const set = new Set();
        for (let i = 1n; i <= 2n; i++) {
            set.add(i);
        }

        for (const element of set) {
            process.stdout.write(element + " ");
        }
        console.log();
    }
}

GFGCustomHash.main();

Python3

# Python Implementation
import random

class CustomHash:
    @staticmethod
    def splitmix64(key):
        key += 0x9e3779b97f4a7c15
        key = (key ^ (key >> 30)) * 0xbf58476d1ce4e5b9
        key = (key ^ (key >> 27)) * 0x94d049bb133111eb
        return key ^ (key >> 31)

    @staticmethod
    def random_hash(x):
        RANDOM = random.randint(0, 2**64 - 1)
        return CustomHash.splitmix64(x + RANDOM)

    def __hash__(self, x):
        return self.random_hash(x)

if __name__ == "__main__":
    # Using Python dictionary
    mp = {}
    mp[1] = 10
    mp[2] = 20
    for key, value in mp.items():
        print(key, value)

    # Using Python set
    st = set()
    st.add(1)
    st.add(2)
    for ele in st:
        print(ele)

# This code is contributed by Tapesh(tapeshdua420)

Output

2 20
1 10
2 1 

Hashing in Competitive Programming for Java Programmers:

Java has HashMaps with a hashing function which is applied to the key to calculate the index of the bucket in order to store and retrieve any key-value pair. The Capacity of HashMap is the number of buckets in it. Initially, the capacity of HashMap is 16. As the number of elements in the HashMap increases, the capacity gets increased. This is handled with the help of Load Factor. The load factor is the measure that decides when to increase the capacity of the Map. The default load factor is 75% of the capacity.

HashMap stores and retrieves entries in constant time O(1). However, the problem arises when the number of items is increased, and the number of buckets is fixed, which can increase the time complexity from O(1) to O(N). This can be solved by increasing the number of buckets and redistributing the items across all the buckets. In this way, we’ll be able to keep a constant number of items in each bucket and maintain the time complexity of O(1). With a lower load factor, there will be more free buckets and, hence, fewer chances of a collision. This will help us to achieve better performance for our Map. Hence, we need to keep the load factor low to achieve low time complexity.

Note: A higher value of load factor decreases the space overhead but increases the lookup cost.

Prior to Java 8, HashMap in Java used a LinkedList to store map entries when collisions occurred. This could lead to worst-case performance of O(n), which is not ideal. Java 8 and later versions addressed this issue by using a balanced tree, also known as a red-black tree, to store collided entries. This improves the worst-case performance of HashMap to O(log n), which is a significant improvement.

The TREEIFY_THRESHOLD constant determines when HashMap switches from using a LinkedList to a balanced tree. The current value of this constant is 8, meaning that if there are more than 8 elements in the same bucket, HashMap will use a tree to store them. This ensures that the LinkedList is not used for excessively large buckets, preventing performance degradation.

Java also offers a data structure as TreeMap which is used to store unique elements in a sorted order. Java.util.TreeMap uses a red-black tree in the background which makes sure that there are no duplicates. Additionally, it also maintains the elements in a sorted order. It takes the time complexity of log(N) to insert, delete or retrieve elements from TreeMap.

How to handle collision attacks?

Java handles collisions in its HashMap implementation without requiring users to create custom hash functions. The HashMap class in Java uses a combination of techniques to handle collisions and ensure efficient key-value storage. The key approach is employing separate chaining, which means that each bucket in the hash table is implemented as a linked list. When a collision occurs (i.e., multiple keys hash to the same bucket), the corresponding entries are stored in the linked list associated with that bucket.

Below is an example of Hashing in Competitive Programming for Java:

C++

#include <iostream>
#include <unordered_map>

int main() {
    // Create a new unordered_map object
    std::unordered_map<std::string, int> myMap;

    // Add some key-value pairs to the unordered_map
    myMap["apple"] = 1;
    myMap["banana"] = 2;
    myMap["cherry"] = 3;

    // Print the unordered_map
    std::cout << "Original unordered_map: ";
    for (const auto& pair : myMap) {
        std::cout << "{" << pair.first << ": " << pair.second << "} ";
    }
    std::cout << std::endl;

    // Get the value associated with the key "banana"
    int value = myMap["banana"];

    // Print the value
    std::cout << "Value of key 'banana': " << value << std::endl;

    // Remove the key-value pair associated with the key "cherry"
    myMap.erase("cherry");

    // Print the unordered_map again
    std::cout << "Updated unordered_map: ";
    for (const auto& pair : myMap) {
        std::cout << "{" << pair.first << ": " << pair.second << "} ";
    }
    std::cout << std::endl;

    return 0;
}
// code is contributed by utkarsh

Java

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // Create a new HashMap object
        HashMap<String, Integer> myMap = new HashMap<String, Integer>();

        // Add some key-value pairs to the HashMap
        myMap.put("apple", 1);
        myMap.put("banana", 2);
        myMap.put("cherry", 3);

        // Print the HashMap
        System.out.println("Original HashMap: " + myMap);

        // Get the value associated with the key "banana"
        int value = myMap.get("banana");

        // Print the value
        System.out.println("Value of key 'banana': " + value);

        // Remove the key-value pair associated with the key "cherry"
        myMap.remove("cherry");

        // Print the HashMap again
        System.out.println("Updated HashMap: " + myMap);
    }
}

C#

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        // Create a new Dictionary object
        Dictionary<string, int> myMap = new Dictionary<string, int>();

        // Add some key-value pairs to the Dictionary
        myMap["apple"] = 1;
        myMap["banana"] = 2;
        myMap["cherry"] = 3;

        // Print the Dictionary
        Console.Write("Original Dictionary: ");
        foreach (var pair in myMap)
        {
            Console.Write("{" + pair.Key + ": " + pair.Value + "} ");
        }
        Console.WriteLine();

        // Get the value associated with the key "banana"
        int value = myMap["banana"];

        // Print the value
        Console.WriteLine("Value of key 'banana': " + value);

        // Remove the key-value pair associated with the key "cherry"
        myMap.Remove("cherry");

        // Print the Dictionary again
        Console.Write("Updated Dictionary: ");
        foreach (var pair in myMap)
        {
            Console.Write("{" + pair.Key + ": " + pair.Value + "} ");
        }
        Console.WriteLine();
    }
}

Javascript

// Create a new Map object
let myMap = new Map();

// Add some key-value pairs to the Map
myMap.set("apple", 1);
myMap.set("banana", 2);
myMap.set("cherry", 3);

// Print the Map
console.log("Original Map:");
for (let [key, value] of myMap) {
    console.log(`{${key}: ${value}}`);
}

// Get the value associated with the key "banana"
let value = myMap.get("banana");

// Print the value
console.log("Value of key 'banana':", value);

// Remove the key-value pair associated with the key "cherry"
myMap.delete("cherry");

// Print the Map again
console.log("Updated Map:");
for (let [key, value] of myMap) {
    console.log(`{${key}: ${value}}`);
}

Python3

# Create a new dictionary
my_dict = {}

# Add some key-value pairs to the dictionary
my_dict["apple"] = 1
my_dict["banana"] = 2
my_dict["cherry"] = 3

# Print the dictionary
print("Original dictionary:", my_dict)

# Get the value associated with the key "banana"
value = my_dict["banana"]

# Print the value
print("Value of key 'banana':", value)

# Remove the key-value pair associated with the key "cherry"
my_dict.pop("cherry", None)

# Print the dictionary again
print("Updated dictionary:", my_dict)
#this code is contributed by Kishan 

Output

Original unordered_map: {cherry: 3} {banana: 2} {apple: 1} 
Value of key 'banana': 2
Updated unordered_map: {banana: 2} {apple: 1} 

Hashing in Competitive Programming for Python Programmers:

Python offers dictionaries to store (key, value) pairs. A hash table is a data structure that stores a set of elements in an array of large size, defining the position of the element as its hash taken modulo the size of the array. If hashes of several elements give the same cell in the hash table, the hash table tries to take another cell according to some rule, which depends on the particular implementation of the table. Usually, if the hash f(x) leads to a collision, then it checks the next hash f(f(x)), then f(f(f(x))) and so on, until an empty cell is found. The function f(x) is often a linear transformation (a*x+b)%size, where size is the size of the array, and a and b are relatively prime with it.

Python uses a hash table with an array size equal to a power of two to implement dict, and the transformation is slightly more complex than a simple linear one f(x) = (5x+1+perturb) % size, where perturb is initially equal to hash, but is shifted right by 5 bits in each step. Also in Python, up to very large numbers (around 10^18), hash of a number is the number itself, which is easily predictable.

How to handle collision attacks?

We can prevent the collision attacks by creating a custom type (Wrapper) with a unique hash function that incorporates a random number, the code introduces an additional layer of unpredictability into the hash values. This makes it more challenging for attackers to manipulate or predict the hash values and helps prevent collision attacks in scenarios where the default hash function might be vulnerable.

Below is an example of a custom hash function which one can use to avoid collision attacks.

C++

#include <iostream>
#include <unordered_map>
#include <ctime>
#include <cstdlib>

// Custom hash to avoid collisions
struct Wrapper {
    int x;
    Wrapper(int x) : x(x) {}
    bool operator==(const Wrapper &other) const { return x == other.x; }
};

// Custom hash function
struct WrapperHash {
    int RANDOM = rand() % 1000000000 + 1; // Random number from 1 to 10^9
    std::size_t operator()(const Wrapper& k) const {
        return std::hash<int>()(k.x) ^ RANDOM;
    }
};

int main() {
    srand(time(0)); // Seed for random number generation

    std::unordered_map<Wrapper, int, WrapperHash> freqDict;
    int a[] = {1, 1, 2, 3, 1, 4, 5, 6, 7};

    for (int i = 0; i < sizeof(a)/sizeof(a[0]); i++) {
        // Using Custom hash values
        Wrapper wx(a[i]);
        freqDict[wx]++;
    }

    // Print frequency dictionary in the desired format
    std::cout << "{";
    for (auto it = freqDict.begin(); it != freqDict.end(); ++it) {
        std::cout << it->first.x << ": " << it->second;
        if (std::next(it) != freqDict.end()) {
            std::cout << ", ";
        }
    }
    std::cout << "}" << std::endl;

    return 0;
}

Java

import java.util.*;

public class Main {
    static class Wrapper {
        int value;

        public Wrapper(int value) {
            this.value = value;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Wrapper wrapper = (Wrapper) o;
            return value == wrapper.value;
        }

        @Override
        public int hashCode() {
            return Objects.hash(value);
        }

        @Override
        public String toString() {
            return "{" + value + "}";
        }
    }

    public static void main(String[] args) {
        int[] a = {1, 1, 2, 3, 1, 4, 5, 6, 7};
        Map<Integer, Integer> freqDict = new LinkedHashMap<>();

        for (int x : a) {
            freqDict.put(x, freqDict.getOrDefault(x, 0) + 1);
        }

        System.out.print("{");
        boolean first = true;
        for (Map.Entry<Integer, Integer> entry : freqDict.entrySet()) {
            if (!first) {
                System.out.print(", ");
            } else {
                first = false;
            }
            System.out.print(entry.getKey() + ": " + entry.getValue());
        }
        System.out.println("}");
    }
}

JavaScript

// Custom hash to avoid collisions
class Wrapper {
    constructor(x) {
        this.x = x;
    }

    equals(other) {
        return this.x === other.x;
    }

    // Custom string representation
    toString() {
        return String(this.x); // Convert the value of x to a string
    }
}

// Initialize frequency dictionary
let freqDict = new Map();

let a = [1, 1, 2, 3, 1, 4, 5, 6, 7];

for (let i = 0; i < a.length; i++) {
    // Using Custom hash values
    let wx = new Wrapper(a[i]);
    let key = wx.toString(); // Convert the Wrapper object to a string for use as a key
    let count = freqDict.get(key) || 0;
    freqDict.set(key, count + 1);
}

// Print frequency dictionary
let output = "{ ";
for (let [key, value] of freqDict) {
    output += key + ": " + value + ", ";
}
output = output.slice(0, -2); // Remove the trailing comma and space
output += " }";
console.log(output);

Python3

from random import randint

# Random number from 1 to 10^9
RANDOM = randint(1, 10 ** 9)

# Custom hash to avoid collisions

class Wrapper(int):
    def __init__(self, x):
        int.__init__(x)

    def __hash__(self):
        return super(Wrapper, self).__hash__() ^ RANDOM


a = [1, 1, 2, 3, 1, 4, 5, 6, 7]
freqDict = dict()
mx = 0
for x in a:
        # Using Custom hash values
    wx = Wrapper(x)
    freqDict[wx] = freqDict.get(wx, 0) + 1
print(freqDict)

Output

{7: 1, 6: 1, 5: 1, 1: 3, 4: 1, 2: 1, 3: 1}

Practice Problems on Hashing for Competitive Programming:

Easy Level Problems on Hashing:

Problem	Problem Link
Count Pairs with given Sum	Practice Now
Subarray with 0 Sum	Practice Now
Key Pair	Practice Now
First Repeating Element	Practice Now
Non Repeating Character	Practice Now

Medium Level Problems on Hashing:

Problem	Problem Link
Find triplets with 0 sum	Practice Now
Longest Consecutive Subsequence	Practice Now
Largest Subarray with 0 Sum	Practice Now
Longest Subarray with Sum K	Practice Now
Top K Frequent Elements in the array	Practice Now

Hard Level Problems on Hashing:

Problem	Problem Link
Smallest Window in a string containing all the characters of another string	Practice Now
LRU Cache	Practice Now
Minimum operations to convert array A to B	Practice Now
Largest rectangular sub-matrix whose sum is 0	Practice Now
Account Merge	Practice Now