This article explains how to determine whether a binary tree contains a root‑to‑leaf path whose node values sum to a given target, outlines the recursive subtraction method, and provides a complete C implementation of the algorithm.
This article explains the binary‑tree maximum path sum problem, provides example inputs and outputs, analyzes three possible path configurations, and presents both a brute‑force and an optimized depth‑first search implementation in C.
This article explains the divide‑and‑conquer principle behind quick sort, walks through a concise Python version and a more classic C‑style implementation, analyzes their inefficiencies, and offers practical optimization tips such as better pivot selection, space reduction, and hybrid sorting strategies.
The article outlines a multi‑pass bucket‑sorting strategy to locate the median of a 10 GB unordered integer file using only 2 GB of RAM, detailing how to partition data into byte‑wise buckets, compute the median’s bucket, and finalize the result with in‑memory sorting.
This article explains the differences between true and pseudo‑random numbers, why JavaScript's Math.random is unsuitable for secure lottery draws, and how to use the Web Crypto API's Crypto.getRandomValues with a provided code example to achieve cryptographically strong randomness.
This tutorial explains the structure of Chinese citizen ID numbers, details the ISO 7064 checksum calculation, and provides Python code to generate random valid IDs and verify existing ones, covering area codes, birth dates, sequence and gender digits.
This article explains how Redis implements location‑based services using GEOADD and GEORADIUS commands, analyzes their source code, describes the underlying geohash algorithm, and evaluates the time‑complexity of nearby‑people queries, providing practical insights for building efficient proximity features.
The talk presented at the Shanghai Computer Society Annual Meeting details how big data and algorithms are leveraged in the real‑estate internet sector to enhance user personalization, improve agent matching, and assess video quality, illustrating practical implementations and performance gains across data collection, modeling, and recommendation pipelines.
This article explains the A* search algorithm, its evaluation function, heuristic choices, grid‑based distance metrics, relaxation techniques for faster sub‑optimal paths, and provides a complete JavaScript implementation with code examples and reference links.
The article treats functions as pure data‑to‑data mappings and demonstrates how common mathematical operations such as factorial, exponentiation, and Fibonacci can be expressed in TypeScript/JavaScript using recursive, tail‑recursive, iterative, and logarithmic‑time algorithms that illustrate functional transformation techniques and efficient algorithm design.
This article presents a robust binary‑search template, explains why traditional implementations often fail, shows how to avoid overflow and infinite loops, and provides clear Java code and step‑by‑step guidance using real LeetCode problems as examples.
This article explains why a single server eventually hits a performance ceiling, introduces high‑performance clustering and the role of load balancers, compares DNS, hardware, and software load‑balancing solutions, outlines typical multi‑layer architectures, and reviews common load‑balancing algorithms with their pros and cons.
This article explains why Java's String.hashCode() uses the multiplier 31, covering its implementation, mathematical justification, JVM optimization, comparative analysis with other multipliers, and experimental results on hash collision rates and distribution using a large English word dataset.
A candid recount of a ByteDance backend interview reveals how superficial preparation, gaps in Nginx, uWSGI, Redis, and data‑structure knowledge, and nervousness can derail even experienced developers, while offering concrete advice on early preparation, resume framing, and tackling tough technical questions.
This article explains the challenges of deadlock detection in Linux kernel lockdep, especially with read‑write locks, and presents a formally proven general deadlock prediction algorithm that models lock dependencies using a two‑thread abstraction, lemmas, and lock‑type promotion to reliably predict potential deadlocks.
The article explains how to generate prime numbers with a recursive filtering method, identify twin primes below 10,000, and includes Java implementations of bubble sort and insertion sort, along with a brief commentary on Groovy's advantages and a curated list of related technical articles.
This article reviews several practical algorithm tricks—including using n&(n‑1) to clear the lowest set bit, counting bits, converting numbers, applying double‑pointer methods to linked lists and sorted arrays, and leveraging XOR properties—to simplify typical interview coding problems.
This article explains the insertion sort algorithm using a playing‑card example, walks through each sorting round with clear illustrations, and provides an optimized Java implementation that reduces unnecessary swaps while maintaining the core logic of shifting elements.
This article presents the ten most frequently asked hand‑coding interview problems—quick sort, binary search, climbing stairs, two‑sum, max drawdown, merging sorted arrays, maximum subarray, longest non‑repeating substring, permutations, and three‑sum—each with clear Python implementations, difficulty ratings, occurrence probabilities, and sample outputs to boost your interview success.
This article explains the symmetric‑tree problem, outlines a depth‑first recursive strategy with base‑case checks, demonstrates short‑circuit evaluation, analyzes time complexity, and provides a complete Java implementation that determines tree symmetry in linear time.
This article explains the KMP string‑matching algorithm, how it builds the prefix (next) table to avoid the O(M·N) worst‑case of naive search, provides JavaScript implementations, compares it with Boyer‑Moore and V8's indexOf strategy, and includes detailed code examples.
The article explains how to solve a variant of the linked‑list reversal problem where every K nodes are reversed as a group starting from the tail, using recursion and double reversal techniques, and provides complete Java implementations for the algorithm.
This article offers a clear, visual introduction to red‑black trees, covering binary search tree fundamentals, the four balancing rules, insertion cases with recolor and rotation steps, and step‑by‑step animated examples, helping readers grasp and remember the concepts through images and analogies.
This article explains Nginx's five load‑balancing methods, focusing on the weighted round‑robin algorithm, its basic and smooth variants, provides code examples, step‑by‑step execution, and a mathematical proof of why the smooth version distributes traffic fairly according to server weights.
This comprehensive guide explains dynamic programming fundamentals, contrasts it with greedy recursion, and walks through Java implementations for Fibonacci, rod‑cutting, simplified and traditional knapsack, Levenshtein edit distance, and longest common subsequence, highlighting performance gains and reconstruction techniques.
This article analyzes the shortcomings of Nginx's native Smooth Weighted Round‑Robin (SWRR) algorithm in large‑scale application gateway scenarios, presents a real‑world case where weight adjustments cause traffic spikes, and introduces the VNSWRR algorithm that achieves O(1) selection time, smoother weight handling, and up to 60% higher QPS performance.
The author revisits prime‑number filtering using Python's lambda syntax, rewrites the algorithm with a recursive approach, and then demonstrates a heart‑shaped ASCII art program, highlighting new insights into Python's expressive capabilities and code clarity.
This article explains the Paxos consensus algorithm, its purpose in solving data consistency across distributed nodes, its basic two‑phase workflow with proposer, acceptor, and learner roles, and illustrates three typical scenarios with step‑by‑step examples and code snippets.
The article discusses an interview scenario where a candidate must determine the most frequent integer among billions of values using only a few gigabytes of memory, exploring hash tables, file partitioning, and hashing strategies to handle massive data sets efficiently.
This article reviews the seven sharding algorithms supported by DBLE, introduces the unique JumpStringHash algorithm with its configuration and usage details, summarizes the complete XML rule examples for all algorithms, and links to the previous series articles for further reference.
This article explores the multifaceted criteria for evaluating a good recommendation system, covering macro and micro perspectives, product domain considerations, information retrieval, algorithmic accuracy, user experience, and business impact, and outlines a systematic iteration process for continuous improvement.
This article reviews why rate limiting is crucial in microservice architectures, outlines common limiting techniques such as semaphore counting, thread‑pool isolation, fixed and sliding windows, token‑bucket and leaky‑bucket algorithms, and discusses practical considerations like clock sync, SDK vs. server enforcement, and accuracy‑latency trade‑offs.
This article explains the Paxos consensus algorithm in plain terms, using a relatable travel‑planning analogy to illustrate how proposers, acceptors, and majority voting achieve fault‑tolerant agreement in distributed systems, and connects the concept to real‑world implementations like Google’s Chubby and ZooKeeper.
This article introduces five classic bitwise operation examples in Java—including checking odd/even, swapping variables without a temporary, finding a unique number, fast exponentiation, and determining the greatest power of two not exceeding N—explaining the underlying binary logic, code implementations, and their efficiency advantages.
Rate limiting is essential for microservice resilience, preventing overloads and protecting business continuity, and can be implemented through various methods such as semaphores, thread‑pool isolation, fixed or sliding windows (using Redis ZSets or local memory), token‑bucket/leaky‑bucket algorithms, each with trade‑offs in accuracy, performance, clock synchronization, and deployment location.
This article shares practical, step‑by‑step techniques for improving algorithm problem‑solving skills, emphasizing gradual difficulty progression, categorizing problems by data structure, a three‑stage solving process, and the importance of abstraction and sustained motivation for effective LeetCode practice.
This article explains the classic binary search algorithm, presents a Java implementation, and details multiple binary‑search variants—including finding first/last equal elements, elements less than or greater than a key—while providing clear code examples and guidance on boundary handling.
This article introduces recursion by outlining its three essential elements—function purpose, base case, and recurrence relation—and demonstrates each step with clear Java/C examples such as factorial, Fibonacci, frog‑jump, and linked‑list reversal, while also covering common pitfalls and optimization techniques.
This article explains the fundamentals of load balancing, covering its definition, benefits, various types such as server, firewall, and link load balancing, hardware vs software solutions, local and global strategies, and common algorithms like round robin, weighted, least connections, and DNS‑based methods.
This article reviews major in‑memory inverted index compression techniques such as PForDelta, PEF, and MILC, explains their principles and trade‑offs, and details practical optimizations applied at 58.com to achieve query performance comparable to uncompressed indexes while reducing memory usage by about 35 percent.
This article explains what arrays are, how they enable O(1) random access through address calculation, the time‑complexities of insertion and deletion operations, techniques for improving array efficiency, and why zero‑based indexing is used, comparing arrays with dynamic containers like ArrayList.
This article presents a comprehensive overview of 58.com’s search efficiency optimization, detailing the business background, ranking framework, data, algorithm, and engineering components, describing the three-stage ranking process, strategy and platform optimizations, feature engineering, model upgrades, and the resulting performance improvements.
This article presents a JavaScript solution for locating the maximum element in a bitonic (first increasing then decreasing) array, explaining that the problem is a variant of binary search and providing a complete implementation using a binary‑search‑based algorithm.
This article explains the concept of a priority queue, presents a interview‑style problem requiring O(log n) enqueue and dequeue operations, and shows how to implement the solution efficiently using a binary heap with detailed step‑by‑step illustrations and a complete JavaScript code example.
This article introduces several practical algorithmic tricks—using array indices as counters, applying modulo for circular traversal, employing two‑pointer methods for linked‑list problems, leveraging bit‑shift and bitwise operations, adding sentinel nodes, and optimizing recursive solutions with memoization and bottom‑up DP—each illustrated with Java code examples.
Learn multiple techniques to calculate the square root of 2—including binary search, Newton’s iteration, and a clever C library implementation—through clear explanations, step‑by‑step illustrations, and full JavaScript and C code examples that reveal the underlying mathematics and performance considerations.
Netflix’s data‑driven strategy, which uses massive subscriber analytics to shape original content and marketing, has sparked a clash with Hollywood’s traditional, relationship‑focused approach, leading to internal power struggles, leadership changes, and a broader debate over algorithmic versus human intuition in entertainment.
Ada Lovelace, the daughter of poet Byron, pioneered computer programming by introducing algorithms and the concept of loops, influencing modern software engineering and inspiring the Ada programming language named in her honor, recognized by the U.S. Department of Defense and industry leaders.
This article introduces the depth‑first search algorithm for web crawling, explains how URLs are structured, shows the traversal order using a binary‑tree analogy, provides a recursive implementation example, warns about stack overflow, and hints at an upcoming breadth‑first search tutorial.
This article uses a vivid allegorical story to introduce the Paxos algorithm, then explains its roles, two-phase protocol, fault assumptions, and why majority and multiple acceptors are essential for achieving reliable consensus in distributed systems.
This article explains what load balancing is, compares it to navigation routing, and details five common strategies—round‑robin, weighted round‑robin, least connections, fastest response, and hash‑based—along with their pros, use‑cases, and health‑check mechanisms for achieving high availability.
In this interview case study, a candidate solves the challenge of extracting the largest 1,000 numbers from a billion‑element dataset using a quick‑select style partition algorithm, achieving O(n) time, and implements the solution in Java with concise code.
This article introduces the "wave fluctuation equal distribution" algorithm that splits a value into N parts within a bounded range with random variation, explains its characteristics, and provides two JavaScript implementations—an exhaustive enumeration method and a fast random allocation method—along with performance analysis and validation techniques.
An interviewee faces the challenge of determining whether a newly given integer exists within a set of 4 billion numbers, and the article explores efficient solutions—from naive disk‑I/O approaches to distributed processing and the memory‑saving bitmap technique—highlighting their performance trade‑offs and implementation details.
This article explains how to prevent isolated empty seats when users select cinema seats by modeling seat layouts, defining forbidden patterns, converting them into regular expressions, and implementing concise JavaScript validation code that reduces complex nested if‑statements to a few clear lines.
This article details the design, algorithmic challenges, and implementation of an automated JSON diff tool used in Qunar's Hackathon to compare complex API responses, handle unordered arrays, ignore configurable nodes, and provide fast, accurate regression testing for large JSON payloads.
This comprehensive guide explores essential strategies for handling massive datasets, covering hash-based structures, bucket partitioning, heap and quicksort techniques, trie trees, Bloom filters, external sorting, and MapReduce, and demonstrates how to efficiently solve common interview problems such as top‑K queries and duplicate removal.
This article explains the technical challenges Google Photos faced—such as handling millions of images, preserving aspect ratios, enabling instant navigation, and maintaining 60fps scrolling—and details the algorithms, data chunking, justified layout, and performance optimizations that make the web UI fast and fluid.
This article demonstrates a compact 21‑line Python spell checker that uses a Bayesian model and edit‑distance concepts to suggest correct spellings, explaining the underlying probability theory and providing a full code walkthrough.
Meituan’s new book, 'Machine Learning Practice,' authored by over twenty frontline engineers, offers a comprehensive guide to internet‑company ML techniques, is now sold in major bookstores, invites reader feedback, and provides QR‑code access to the team’s official account and an electronic bibliography, plus a companion summary of 27 essential AI articles.
This article explains four common rate‑limiting algorithms—fixed‑window counter, sliding window, leaky bucket, and token bucket—detailing how each works, their pseudo‑code implementations, and when to use them to protect high‑traffic systems such as flash‑sale platforms.
This article explains the origin, alphabet, step‑by‑step conversion process, padding rules, and provides a Java example to illustrate how Base64 encodes binary data into printable characters, highlighting why the output is about one‑third larger than the input.
This article presents twelve Python programming exercises covering string manipulation, list handling, regular expressions, binary conversion, and algorithmic sorting, each accompanied by clear explanations and complete code snippets that illustrate how to solve the problems step by step.
By encoding billions of GPS points and ten thousand district polygons into GeoHash cells, using exact matches, approximate filtering, neighbor‑cell lookup tables, and a final precise geometry test, the authors cut the required operations from 2×10^20 to about 1.8×10^12, enabling full processing in under a day.
This article introduces the most commonly used algorithms in engineering—recommendation, optimization, estimation, and classification—explains their typical application scenarios, and discusses various testing methods and evaluation metrics such as offline experiments, user surveys, A/B testing, and performance indicators like accuracy, coverage, diversity, and robustness.
The article reflects on a senior engineer’s interview experience, arguing that hiring should focus on the probability of "working well" rather than superficial metrics like education, algorithms, or basic knowledge, and it outlines how factors such as experience, fundamentals, algorithms, and especially personality influence hiring decisions.
This article explores the concept of short URLs, their practical applications such as social media and QR codes, discusses various generation methods, presents algorithmic designs like incremental ID encoding and caching strategies, and provides a reference implementation for building a reliable URL shortening service.
Decision trees are tree-structured classifiers that split data using attributes chosen for maximal purity measured by Gini impurity or entropy, with algorithms like ID3 selecting splits by information gain, while overfitting is mitigated through constraints and pruning techniques such as REP, PEP, and CCP.
This article explains the theory and JavaScript implementations of various knapsack problem variants—including 0/1, complete, unbounded, and multi‑knapsack—detailing state transition equations, space‑optimisation techniques such as rolling arrays and binary decomposition, and provides full code examples for each solution.
This article provides a step‑by‑step walkthrough of the 0‑1 knapsack problem, explains the dynamic‑programming formulation, demonstrates how to build the DP table, and presents a complete JavaScript solution with optimizations and boundary‑handling techniques.
This article explains the rules, scoring system, and level design of the classic "Popstar" match‑3 game, then details a full MVC implementation in JavaScript—including tile representation, wave‑average distribution, shuffle, wall solidification, view updates, control bindings, and a discussion of the knapsack‑style max‑score problem—while providing complete code snippets and a GitHub repository link.
This article examines the evolution of Ant Design's color‑palette generation algorithms from the simple tint/shade approach in 1.x, through the HSL‑based Bézier‑easing method in 2.x, to the HSV‑driven implementation in 3.x, highlighting their principles, code implementations, strengths, and shortcomings.
This article explains the concept of load balancing in distributed systems, outlines its benefits for throughput and reliability, compares common architectural layers, evaluates key algorithmic considerations, and provides Python implementations of round‑robin, weighted, random, hash‑based, and least‑connection strategies along with deployment options.
The Metric Logic Tree automates business metric anomaly analysis by integrating heterogeneous data sources (Kylin, MySQL, Elasticsearch, Druid) with a three‑layer architecture—metric calculation, algorithmic analysis (waterfall and Gini‑coefficient methods), and a master‑worker computation service—that parallelizes queries, delivers immediate conclusions, and shortens decision cycles, as demonstrated in Meituan‑Dianping’s hotel‑travel operations.
This article explains what user profiling is, why it’s crucial for recommendation systems, outlines key dimensions such as personal attributes, status, and interests, describes algorithms like classification and autoregressive models, and details offline and real‑time computation methods, evaluation techniques, and practical examples.
This article explains how to extend a red‑black tree with a subtree‑size counter to support O(log n) rank and selection operations, detailing the required count updates during insertion, deletion, and tree rotations, and provides complete pseudocode for left/right rotations, rank queries, and element‑by‑rank retrieval.
This article explains the core challenges of search engines, the origins and mechanics of the PageRank algorithm, its handling of dead ends and spider traps, extensions like Topic‑Sensitive PageRank, and the various link‑spam attacks and countermeasures such as Spam Farms and TrustRank.
This article introduces decision trees in data analysis and machine learning, explains core concepts, compares popular algorithms such as ID3, C4.5, and CART, details their mathematical foundations, and provides a complete Python implementation with code examples for building and visualizing trees.
A third‑grader’s bulb‑toggling puzzle is solved by showing that a bulb stays on only when its number is a perfect square, leading to 14 lit bulbs out of 200, and a simple Ruby program is used to demonstrate the result.
This article explains how to implement the classic Snake game using the MVC pattern, detailing the model's grid representation, chain‑list versus array for the snake body, random food placement algorithms, view rendering optimizations with PIXI, and control APIs for game interaction.
This article explores how to implement recursive and non‑recursive DOM tree searches, hash‑based lookups, and several classic sorting algorithms—including quick sort and merge sort—in JavaScript, discussing their time and space complexities, stability considerations, and practical performance tips for front‑end development.
The article explains the background of flash‑memory wear‑leveling, reviews common garbage‑collection strategies, compares classic algorithms such as Greedy, Cost‑Benefit, CAT and CICL, and introduces the Non‑Balance method that evaluates real block endurance to extend SSD life up to three times.
This article explains how to protect API servers from abuse by implementing rate limiting using the Token Bucket algorithm, discusses its drawbacks, and provides practical Java and Redis-based solutions with code examples and performance considerations.
This article compiles ten common algorithmic challenges frequently asked in front‑end interviews, explains why mastering data structures matters for developers, and provides concise solutions and key insights for each problem, from palindrome checks to binary search tree implementation in JavaScript.
This article explains the meaning of Big O notation—O(n), O(1) and O(log n)—using intuitive box-and‑card analogies, shows how Redis command complexities are expressed, and highlights why constant‑time operations are the most efficient for large data sets.
This article explains how to use a Python implementation of the minimax algorithm to analyze a Doudizhu end‑game scenario, detailing the core logic, recursive hand simulation, caching optimizations, and the final result that the farmer side has no guaranteed winning strategy.
This article explains the definition and 4V characteristics of big data and presents practical algorithms—including hash partitioning, min‑heap top‑K selection, bitmap extensions, and Bloom filter techniques—to efficiently handle ultra‑large log files, integer sets, and keyword searches within strict memory limits.
The seventh issue of Baidu Waimai's technical monthly presents a collection of practical engineering articles covering operations monitoring, big‑data platform incubation, BFT crawling algorithm, zombie‑process avoidance, Nginx+Lua overload protection, OLTP/OLAP integration, new‑user repurchase prediction, a generic frontend tracking solution, and the use of favicons to personalize websites.
This article explores Nginx’s built‑in and extended load‑balancing algorithms—including weighted round‑robin, IP‑hash, fair, generic‑hash and consistent‑hash—by dissecting source code, explaining implementation details, and presenting comprehensive performance tests that compare their balance, consistency, and fault‑tolerance across varied scenarios.
This article explains the concept of a stack as a LIFO data structure, shows how to implement a Stack class in JavaScript with essential methods like push, pop, size, empty, peek, and clear, and demonstrates practical usage through recursive and iterative factorial calculations.
This article explains how Hulu’s advertising platform leverages big‑data pipelines, time‑series forecasting, bipartite‑graph optimization, linear‑model targeting, and real‑time allocation to improve sales, delivery, reporting, and planning of guaranteed‑delivery brand ads.
By adapting the classic Two Generals problem into a Three-Armies scenario, this article demystifies the Basic Paxos algorithm, illustrating its prepare/commit phases, proposal handling, and consensus challenges with detailed step-by-step examples and insights into its practical implications for distributed systems.
The article explains that Paxos relies on a fixed set of voters (the majority) for consistency, shows why configuration‑driven member changes break the protocol, and introduces a simple dynamic membership algorithm that uses delayed activation windows to achieve atomic member updates without violating Paxos guarantees.
This article provides a vivid explanation of the Paxos algorithm, illustrating how it achieves reliable consensus among unreliable processors through a two‑phase prepare/promise and propose/accept process, using distributed auction analogies, message sequencing, and read/write operations to ensure consistency in distributed systems.
This article explains the Multi-Paxos algorithm, showing how independent Paxos instances can be combined into a globally ordered sequence, how the Prepare phase can be omitted in certain cases, and why a leader emerges naturally to maximize efficiency.
The article explores the author's experiments combining artificial intelligence with typography, detailing the development of algorithms that measure font attributes, compute similarity scores, and generate rule‑based design systems, while reflecting on the challenges, inspirations, and future possibilities of AI‑driven font selection and design.
This article explains load balancing fundamentals, differentiates layer‑4 and layer‑7 balancing, describes hardware and software solutions, local and global deployment, various algorithms and health‑check methods, and discusses performance, scalability, security, and management considerations for modern network operations.
The article outlines how to boost system performance through algorithmic refinements, hardware and software resource upgrades, interaction optimizations between algorithms and resources, and effective caching techniques, while acknowledging trade‑offs and the need for balanced decisions.
This presentation details how Ctrip's hotel R&D team leverages machine learning and big data to address OTA-specific challenges, improve key service KPIs, evaluate project benefits, and deploy models through a robust pipeline and architecture, offering practical case studies and operational insights.
This article uses the classic stable matching (Gale‑Shapley) algorithm to model romantic courtship, illustrating how men‑proposing and women‑proposing versions lead to different stable pairings and highlighting the advantage of the proactive side in achieving preferred matches.
