Zomato platform: A Comprehensive APS Portfolio

Course Name
Algorithmic Problem Solving

Course Code
23ECSE309

Name
Shashank Kulkarni

University
KLE Technological University, Hubballi-31

Course Instructor
Prakash Hegade

Portfolio Domain selected
Zomato

A Step Towards Enhanced Service Management on Zomato

This page hosts:

Introduction
Need of Portfolio
Objectives
Data Structures and Algorithms applicable
Key Learnings and Take Aways
References

Introduction

Zomato is a leading online food delivery service, providing a platform for ordering food conveniently and efficiently. In today’s day and age, the efficiency and effectiveness of food delivery services can be significantly enhanced through the strategic application of data structures and algorithms. This portfolio project delves into the core functionalities of Zomato’s diverse services, applying the theoretical knowledge and practical skills acquired from the course Algorithmic Problem Solving (APS). By using advanced algorithmic techniques and data structures, this project aims to propose solutions to real-world business applications. From optimizing order allocation algorithms for improved efficiency and speed to enhancing route planning for better accuracy and reduced delivery time, the potential for enhancement is vast.

This portfolio showcases how algorithms can be applied within Zomato’s ecosystem. Each use case illustrates how specific DSA principles can solve practical challenges faced by a food delivery service like Zomato, bridging the gap between theory and application. Explore the use cases to see how DSA and Algorithmic Problem Solving techniques are used to enhance performance, reliability, and efficiency in a real-world context.

Need of Portfolio

The ever-evolving landscape of food delivery services necessitates continual improvements in service management and user experience. Zomato, as a leading player in this industry, faces various operational challenges that can be addressed through the strategic application of data structures and algorithms. This portfolio is essential for several reasons. Firstly, optimizing service efficiency is crucial; efficient order allocation and route planning can minimize delivery times and maximize resource utilization. By exploring advanced algorithmic solutions, this portfolio aims to enhance these processes, resulting in a more streamlined and efficient service. Additionally, the transition from theoretical knowledge to practical application is a critical step in the learning process. This portfolio provides an opportunity to apply concepts learned in Data Structures and Algorithms (DSA) and Algorithmic Problem Solving (APS) courses to real-world problems, thereby solidifying understanding and skills.

Objectives

1. Apply theoretical concepts from Data Structures and Algorithms (DSA) and Algorithmic Problem Solving (APS) courses to practical, real-world problems within the Zomato platform.

2. Optimize order allocation algorithms to improve the efficiency and speed of food delivery services.

3. Enhance route planning algorithms to achieve better accuracy and reduced delivery times.

4. Implement data structures to improve the reliability and performance of Zomato’s services.

5. Bridge the gap between theoretical knowledge and practical application by addressing real-world challenges faced by Zomato.

Data Structures and Algorithms applicable

1. Route Planning

The Bellman-Ford algorithm is a shortest path algorithm that can be used to find the fastest way to get from one location to another. Zomato could utilize this algorithm to determine the quickest route for delivering food to customers, especially in scenarios where route costs may include negative weights, such as discounts or varying traffic conditions that affect travel time. The primary advantage of Bellman-Ford is its ability to find the shortest path even in graphs with negative edge weights, providing flexibility in route optimization under diverse conditions. However, a significant disadvantage is that it is slower than Dijkstra’s algorithm for graphs without negative edge weights, making it less efficient in those cases. The worst-case time complexity of Bellman-Ford is O(VE), where V is the number of restaurants and E is the number of connections between them, indicating that it can be computationally intensive for large graphs. Despite this, its versatility in handling negative weights makes it a valuable tool for comprehensive route planning in varied delivery environments.

Here’s my code for implementing Bellman Ford algorithm

2. Restaurant Recommendations

Breadth-First Search (BFS) is a graph traversal algorithm that can be used to find all the restaurants within a certain distance from a customer’s location. Zomato could utilize BFS to recommend nearby restaurants to customers based on their location, enhancing user experience by providing relevant and convenient dining options. The primary advantage of BFS is its simplicity, making it easier to implement compared to Depth-First Search (DFS). Additionally, BFS ensures that the closest restaurants are found first, providing users with the nearest options. However, BFS can consume more memory than DFS for certain graphs, especially those with high branching factors. Despite this, its efficiency in finding nearby locations quickly makes it an ideal choice for generating location-based restaurant recommendations. The time complexity of BFS is O(V + E), where V is the number of restaurants and E is the number of connections between them, making it efficient for large networks.

Depth-First Search (DFS) is a graph traversal algorithm that Zomato could employ to discover restaurants connected to a particular establishment, aiding in recommending similar dining options to customers. Unlike Breadth-First Search (BFS), DFS explores deeply into each restaurant network before backtracking, which can be more memory-efficient for certain types of connections. However, implementing DFS requires handling recursion or managing a stack, making it more complex than BFS. In terms of efficiency, DFS operates in O(V + E) time complexity, where V is the number of restaurants and E is the number of connections between them, making it a viable choice for exploring restaurant networks effectively.

Here’s my code for implementing BFS algorithm

Here’s my code for implementing DFS algorithm

3. Food delivery Routes Optimisation

The Ford-Fulkerson algorithm is a pivotal tool for calculating maximum flow within a network, a capability Zomato could leverage to streamline food delivery operations by optimizing driver routes. This algorithm systematically determines the maximum volume of flow that can traverse from a source to a sink in a network, ensuring efficient distribution of resources like delivery routes among restaurants and customers.While beneficial for its ability to handle complex networks with varying capacities, it’s important to note that the Ford-Fulkerson algorithm can be computationally demanding, especially for larger networks. Its time complexity, O(E * F), where E represents the number of edges and F is the maximum flow value, underscores the need for efficient implementation to maintain performance across our expanding delivery operations.

Here’s my code for implementing Ford Fulkerson algorithm

4. Restaurant Search and Autocomplete

Zomato’s exploding restaurant database demands a swift and memory-efficient search mechanism. Linear search, with its sluggish O(n) time complexity in the worst case, becomes impractical for such a vast dataset. Trie data structures emerge as a hero, excelling at prefix searches (O(k) time complexity) where k represents the length of the user’s query, for real-time suggestions as users type, significantly accelerating the search experience. Moreover, tries conquer memory limitations by leveraging shared prefixes among restaurant names, allowing Zomato to scale effectively. While insertion and deletion operations might be slightly slower in tries (O(k)), the gains in search speed and scalability make them a perfect fit for optimizing Zomato’s search functionality.

Here’s my code for implementing Trie

5. Optimizing Delivery Routes with Topological Sort

Zomato’s delivery heroes navigate a complex web of restaurants, ensuring food arrives fresh and fast. But managing intricate delivery chains with dependencies can be a logistical nightmare. Imagine a chef preparing a multi-course meal – appetizers must be ready before the main course. Here’s where topological sort comes in, a powerful algorithm that tackles these dependencies with elegance.Topological sort boasts a time complexity of O(V + E), where V represents the number of restaurants and E signifies the number of dependencies between them. It also excels in space complexity, requiring only O(V) additional space. In simpler terms, the algorithm efficiently analyzes these dependencies and sequences deliveries in a permissible order. This ensures the delivery person isn’t left waiting at a restaurant with unfinished preparations.The benefits are undeniable – optimized routes, potentially faster deliveries, and a smoother experience for both customers and restaurant partners. Imagine the delight of a customer receiving their piping hot appetizer before the main course arrives! However, it’s crucial to acknowledge that topological sort thrives on well-defined dependencies. In scenarios with more intricate relationships between restaurants and tasks, alternative methods might be necessary.Despite this limitation, topological sort stands out as a compelling strategy for Zomato’s delivery management. By ensuring a logical flow of deliveries, it empowers Zomato’s delivery heroes to navigate the restaurant network efficiently, ultimately delighting customers with fresh and timely deliveries.

Here’s my code for implementing Topological Sort

6. Fast and Efficient Data Analysis with Segment Trees

Zomato’s data scientists wear many hats, constantly seeking innovative ways to analyze the vast amount of information flowing through the platform. One such challenge lies in efficiently querying and understanding trends across Zomato’s expansive restaurant database. Traditional methods, while functional, can become sluggish for large datasets. Here’s where segment trees enter the scene, offering a powerful tool for tackling this challenge.Imagine a vast library with millions of books. A segment tree acts like a meticulously organized index, allowing researchers to pinpoint specific sections or genres with remarkable speed. Similarly, Zomato’s segment tree can store information about restaurants (ratings, cuisines, locations) and efficiently answer queries about subsets of that data.The beauty lies in its time complexity. Segment trees excel at range queries, finding information within a specific range of restaurants (e.g., top-rated Italian restaurants in a particular area) with a logarithmic complexity of O(log n), where n represents the total number of restaurants. This translates to lightning-fast retrieval, empowering Zomato to gain valuable insights into user preferences and restaurant performance across various categories.While updates to the restaurant database might require additional operations in the segment tree, the significant gains in query speed make it an invaluable asset for Zomato’s data analysis tasks. By wielding the power of segment trees, Zomato can unlock a deeper understanding of its customer base and optimize its services to deliver even more delightful dining experiences.

Here’s my code for implementing Segement Tree

7. Understanding Hidden Preferences using LCS

Zomato strives to connect users with the perfect meal, but understanding individual preferences can be a challenge. Traditional recommendation systems often focus on explicit user ratings or purchase history. Here’s where Longest Common Subsequence (LCS) comes in, offering a novel approach to uncovering implicit user preferences with a time complexity of O(mn), where m and n represent the lengths of the two sequences being compared (e.g., user order history and restaurant description).Imagine two friends discussing their favorite movies. LCS identifies the longest sequence of movies they both enjoyed, revealing a shared preference for comedies perhaps. Similarly, Zomato’s LCS can analyze a user’s past order history, identifying commonalities across seemingly disparate choices. Did a user order a vegetarian pizza followed by a paneer tikka masala? LCS recognizes a pattern – a potential preference for vegetarian Indian cuisine.The power lies in its ability to unearth hidden connections. By efficiently identifying the LCS between a user’s past orders and restaurant descriptions (cuisine, ingredients), Zomato can infer implicit preferences. This allows for more nuanced recommendations, suggesting dishes or restaurants that align with a user’s underlying culinary desires.While LCS might not be a perfect solution for all recommendation scenarios, it offers a valuable tool for Zomato to understand user preferences beyond explicit ratings. By incorporating LCS analysis, Zomato can create more personalized recommendations, ultimately guiding users towards a delightful and unexpected culinary discovery.

Here’s my code for implementing Longest Common Subsequence algorithm

8. Faster Restaurant Search and Optimised Management of Restaurant Data using B+ trees

Zomato’s ever-expanding restaurant database requires a structure that prioritizes both efficient searches and seamless updates. While Binary Search Trees (BSTs) offer organized retrieval, they can become sluggish for massive datasets when dealing with frequent insertions and deletions of restaurants. Here’s where B+ Trees emerge as a powerful alternative.Imagine a well-organized library with a meticulously maintained card catalog (BST). While efficient for finding specific books, inserting new titles can disrupt the flow. B+ Trees function like a multi-level index system in this library. They group multiple entries on each page, enabling faster navigation through vast collections.For Zomato, this translates to significant advantages. B+ Trees excel at searches, allowing users to find restaurants based on specific criteria (cuisine, location, rating) with remarkable speed. Their logarithmic search time (O(log n)) makes them significantly faster than linear searches in unsorted data. Additionally, B+ Trees efficiently handle insertions and deletions, crucial for Zomato’s dynamic database. They also support efficient range queries, ideal for finding top-rated restaurants within a specific area.While B+ Trees require slightly more storage space compared to BSTs, the gains in search speed, update efficiency, and range query capabilities make them a perfect fit for optimizing Zomato’s restaurant data management and ultimately, enhancing the user experience.

Here’s my code for implementing B+ tree algorithm

9. Utilizing Huffman Encoding for Efficient Data Compression in Zomato

Huffman encoding can be utilized in Zomato to efficiently compress data, particularly for storing and transmitting large amounts of text data such as restaurant descriptions, menu details, and customer reviews. By implementing Huffman encoding, Zomato can reduce the size of these text data, leading to faster data retrieval and reduced storage costs. The time complexity of building the Huffman Tree is O(n log n), where n is the number of unique characters, which includes constructing the frequency table, building a priority queue of characters based on their frequencies, and iteratively merging nodes. Generating Huffman codes has a time complexity of O(n), as each character is visited once during the tree traversal. The advantages of using Huffman encoding include efficient compression, which significantly reduces data size, leading to faster retrieval and lower storage costs; lossless compression, ensuring that the original data can be perfectly reconstructed without any loss of information; and adaptive encoding, allowing the algorithm to dynamically adjust based on character frequencies. However, there are disadvantages as well, such as the initial overhead of building the Huffman tree and generating codes, the complexity of managing variable-length codes, and the fact that it may not be optimal for small data sets with minimal variation in character frequency. By leveraging Huffman encoding, Zomato can enhance its data management efficiency, leading to a better user experience with faster load times and reduced storage requirements.

Here’s my code for implementing Huffman Encoding

10. Optimizing Delivery Logistics with Dijkstra’s Algorithm

Dijkstra’s algorithm can be effectively utilized in Zomato to optimize route planning and delivery logistics. By treating restaurants and delivery points as nodes in a graph and the routes between them as edges with weights representing travel distances or times, Dijkstra’s algorithm can efficiently determine the shortest path from a central hub or distribution center to each restaurant or customer location. This capability is crucial for Zomato’s delivery operations, ensuring that delivery personnel can reach destinations swiftly and efficiently, thereby minimizing delivery times and improving overall service reliability. Moreover, Dijkstra’s algorithm’s time complexity of O((V + E) log V) with a priority queue makes it suitable for real-time route planning in dynamic environments where traffic conditions and delivery demands constantly change. Integrating Dijkstra’s algorithm into Zomato’s operations can lead to enhanced customer satisfaction through faster deliveries and optimized resource allocation.

Here’s my code for implementing Dijkstra’s algorithm

11. A Search Algorithm for Efficient Route Planning

The A* search algorithm, an extension of Dijkstra’s algorithm, incorporates heuristics to prioritize paths that appear to lead more directly to the goal. In Zomato’s delivery logistics, the algorithm can optimize routes by considering both the shortest path and estimated travel time based on current traffic conditions. Using a heuristic function to estimate the remaining distance to the destination, A* can significantly reduce computation time compared to Dijkstra’s algorithm, making it ideal for real-time navigation in densely populated urban areas. This leads to more accurate and timely deliveries, enhancing the customer experience.A* is generally faster than Dijkstra’s algorithm due to its use of heuristics, reducing the number of nodes explored. When the heuristic is admissible (never overestimates the cost to reach the goal), A* is guaranteed to find the shortest path. The algorithm can be adapted with different heuristic functions to suit various environments and constraints, such as avoiding traffic congestion or preferring certain types of roads. Additionally, A* can be dynamically adjusted based on real-time traffic data, making it suitable for urban delivery systems where conditions change frequently.However, A* can require significant memory, especially in large graphs, as it needs to store all explored nodes in memory. The performance of A* heavily depends on the quality of the heuristic function; a poorly chosen heuristic can lead to inefficient searches and longer computation times. Implementing A* effectively can be more complex compared to simpler algorithms like Dijkstra’s, particularly when incorporating dynamic factors like real-time traffic updates. While generally faster, A* can still be computationally expensive for very large graphs or when the heuristic is computationally intensive.The time complexity of A* is O(E), where E is the number of edges in the graph, but more specifically O(b^d), where b is the branching factor and d is the depth of the optimal solution. In the worst case, its complexity is similar to Dijkstra’s algorithm, O((V + E) log V), when using a priority queue. By integrating the A* search algorithm, Zomato can enhance its delivery logistics, ensuring faster and more reliable service, ultimately improving customer satisfaction and operational efficiency.

Here’s my code for implementing A* search algorithm

12. Hash Maps for Fast Data Retrieval and Other Operations

Hash Maps are crucial for fast data retrieval in various parts of Zomato’s operations. They can be used to store and access user profiles, restaurant information, and menu details quickly. By using hash functions to map keys (like user IDs or restaurant IDs) to specific data, Zomato can ensure constant time complexity, O(1), for search, insert, and delete operations, significantly enhancing overall application performance. The primary advantage of Hash Maps is their efficiency in data retrieval, providing rapid access to large volumes of data essential for a seamless user experience. For instance, the system can quickly fetch user profile information and order history using a Hash Map. However, Hash Maps require more memory than other data structures due to the need to handle collisions and maintain efficient hash functions. Poorly designed hash functions can lead to collisions, degrading performance to O(n) in the worst case. They are also not inherently ordered, which can be a drawback for ordered data retrieval. Despite these limitations, Hash Maps enable rapid data access, improving application responsiveness and user experience. By effectively handling key-value pairs and ensuring efficient hashing, Zomato can optimize backend processes and provide a robust platform for users. Integrating Hash Maps ensures Zomato can manage and access large volumes of data efficiently, resulting in improved performance and user satisfaction.

Here’s my code for implementing Hash Map

13. Priority Queues for Task Scheduling

Priority Queues are essential for task scheduling in Zomato’s delivery operations. They can prioritize delivery orders based on factors like urgency, distance, or preparation time, ensuring that high-priority orders are handled first. Implemented using binary heaps, priority queues offer O(log n) time complexity for insertion and deletion, making them efficient for dynamic environments. This efficiency is crucial for Zomato, where rapid decision-making is necessary to manage a high volume of orders. By using priority queues, Zomato can ensure that the most urgent orders are dispatched promptly, minimizing wait times for customers and enhancing overall service reliability.Priority queues also help in balancing workloads among delivery personnel by dynamically adjusting to changing conditions, such as traffic or restaurant preparation times. However, they do require careful management of priorities to avoid bottlenecks and ensure that lower-priority tasks are not unduly delayed. This necessitates a well-designed priority system that accurately reflects the business’s operational needs and customer expectations.Despite these challenges, the benefits of using priority queues in task scheduling are significant. They allow Zomato to streamline its delivery operations, making real-time adjustments based on current demand and conditions. For example, during peak hours, priority queues can help ensure that time-sensitive orders, like those from premium customers, are given precedence. This capability leads to more efficient use of resources, reducing the likelihood of delays and improving overall customer satisfaction.Moreover, priority queues can be integrated with other systems, such as inventory management and order tracking, to provide a comprehensive solution for order processing. By leveraging the power of priority queues, Zomato can maintain a high level of service quality, even as the volume and complexity of orders increase. This integration supports scalability, allowing Zomato to grow its operations without sacrificing performance or reliability.

Here’s my code for implementing priority Queue

14. Bloom Filters for Fast Membership Queries

Bloom Filters offer versatile applications within Zomato’s operations, enhancing efficiency and user experience in several key areas. They can streamline user activity tracking by quickly determining if a user has previously interacted with a restaurant or menu item, thereby optimizing personalized recommendations and user engagement strategies. For real-time service updates, Bloom Filters can swiftly check menu item availability, ensuring that customers receive accurate information without delays. Additionally, they aid in preventing duplicate orders by efficiently identifying ongoing transactions, thereby enhancing order accuracy and operational efficiency. In Zomato’s caching mechanisms, Bloom Filters optimize data retrieval by quickly determining if requested information is cached, reducing the need for frequent database queries and enhancing system responsiveness. Bloom Filters are particularly advantageous due to their O(k) time complexity for insertion and membership queries, where k is the number of hash functions used, making them highly efficient for large datasets. However, they do not support element deletion and have a trade-off between accuracy and memory usage, as increasing accuracy often requires more memory. Despite these limitations, integrating Bloom Filters across these functionalities empowers Zomato to maintain a responsive platform, streamline operations, and deliver a seamless user experience while effectively managing large-scale data operations.

Here’s my code for implementing Bloom Filter algorithm

15. K-D Trees for Spatial Searches

K-D Trees (K-dimensional trees) offer Zomato a robust solution for spatial searches, crucial for optimizing delivery logistics and enhancing user experience. These trees efficiently locate points in multi-dimensional spaces, enabling Zomato to quickly determine the nearest restaurant or delivery location based on user preferences or current demand. With a time complexity of O(log n) for search operations, K-D Trees ensure rapid retrieval of spatial data, supporting real-time decision-making in dynamic environments. While K-D Trees can become unbalanced with frequent data updates, techniques like rotation and reordering can maintain tree balance and preserve performance. Despite potential challenges, K-D Trees are indispensable for managing geographical data effectively. They empower Zomato to deliver precise location-based services, improve operational efficiency, and elevate customer satisfaction by ensuring timely and accurate deliveries. Integrating K-D Trees enhances Zomato’s ability to navigate complex spatial data scenarios, providing a competitive edge in the competitive food delivery market.

Here’s my code for implementing K-D tree

16. Disjoint-set (Union-Find) Data Structure for Connectivity

Disjoint-set data structures, known as Union-Find, are essential for managing connectivity and equivalence relationships within Zomato’s operations. They facilitate efficient tracking of interconnected data, such as restaurant chains or delivery network components, using nearly constant time complexity (amortized O(α(n))), where α(n) is the inverse Ackermann function. This efficiency is maintained through strategies like path compression and union by rank, which optimize union and find operations to prevent performance degradation and ensure rapid updates across large datasets. While Union-Find excels in connectivity management, particularly in scenarios requiring dynamic connectivity checks and component tracking, its implementation benefits from careful consideration of data structure design and algorithmic choices. By integrating Union-Find into its backend systems, Zomato enhances scalability and operational efficiency, supporting seamless service delivery and robust management of interconnected data across its platform. This integration not only streamlines operations but also contributes to improved data integrity and reliability, reinforcing Zomato’s ability to meet the dynamic demands of food delivery services effectively.

Here’s my code for implementing Union Find algorithm

17. Levenshtein Distance for Spell Checking and Correction

Levenshtein distance, a fundamental algorithm in string processing, computes the minimum number of single-character edits needed to transform one string into another. In Zomato’s operational framework, this algorithm plays a crucial role in enhancing search functionalities by correcting user input errors and ensuring precise retrieval of menu items or restaurant names. By leveraging a dynamic programming approach with a time complexity of O(m * n), where m and n are the lengths of the strings, Levenshtein distance facilitates efficient spell checking and data normalization. This capability not only improves search accuracy but also enhances user interaction quality by accommodating variations in user input and ensuring robust data retrieval mechanisms. Integrating Levenshtein distance into Zomato’s search algorithms empowers the platform to deliver reliable and intuitive search results, optimizing user experience and satisfaction in dynamic food service environments.

Here’s my code for implementing Levenshtein Distance algorithm

Key Learnings and Take Aways

Through this portfolio on Zomato, I have gained invaluable insights into the practical application of Data Structures and Algorithms (DSA) in optimizing food delivery services. The key learnings include the ability to implement and utilize advanced algorithms such as Dijkstra’s algorithm for efficient route planning, A* search algorithm for real-time navigation, and priority queues for task scheduling. Additionally, understanding the significance of data structures like hash maps for fast data retrieval and Union-Find (Disjoint-set) for managing connectivity has been crucial. These implementations have not only enhanced my problem-solving skills but also underscored the importance of algorithmic efficiency in improving service reliability, performance, and user satisfaction within a dynamic and competitive industry like online food delivery.

References

[1] Vedant Thakur, “Ola Electric Partners With BYPL And BRPL To Expand Its Network Of Charging Stations In New Delhi”, Motoroids, https://www.motoroids.com/news/ola-electric-partners-with-bypl-and-brpl-to-expand-its-network-of-charging-stations-in-new-delhi/

[2] Thaddeus Abiy, Hannah Pang, Christopher Williams, “Dijkstra’s Shortest Path Algorithm”, Brilliant, https://brilliant.org/wiki/dijkstras-short-path-finder/

[3] Saurabh Kumar, “Bellman-Ford Algorithm”, Ideserve, https://brilliant.org/wiki/dijkstras-short-path-finder/

[4] François Aubry, “Graphs - Topological sort”,INGInious, https://inginious.org/course/competitive-programming/graphs-toposort

[5] Artyom Kalinin, “File:Skip list add element.gif”,Wikimedia Commons, https://commons.wikimedia.org/wiki/File:Skip_list_add_element.gif

[6] Eeppeliteloop, “File:Huffman huff demo.gif”,Wikimedia Commons, https://commons.wikimedia.org/wiki/File:Huffman_huff_demo.gif

[7] Sebastian De Lima, “A quick explanation of DFS & BFS (Depth First Search & Breadth-First Search)”, Medium, https://medium.com/analytics-vidhya/a-quick-explanation-of-dfs-bfs-depth-first-search-breadth-first-search-b9ef4caf952c

[8] flyguy67, “Traveling Salesman Problem Visualization”, Make A GIF, https://makeagif.com/gif/traveling-salesman-problem-visualization-UZrVqj

[9] Xav65, “File:FordFulkerson.gif”, Wikimedia Commons, https://commons.wikimedia.org/wiki/File:FordFulkerson.gif

[10] Lucky Sharma, “BloomFilter in SearchEngine (Solr)”, Medium, https://mightguy.medium.com/bloomfilter-in-searchengine-part-i-2f34814894b9