This article explains the principles of short URL generation, compares incremental ID, hash, and random algorithms, analyzes their security and collision characteristics, and presents a complete backend design including database schema, caching strategy, sharding, and Java implementation details.
This article examines how short‑video platforms can expand into new user circles by leveraging external trend data, competitive analysis, KOL resources, precise content matching, and data‑driven product strategies to acquire, retain, and reactivate users while balancing growth and platform health.
This article explains the purpose of flow control, compares various rate‑limiting algorithms—including simple window, sliding window, leaky bucket, token bucket, and sliding log—provides Java interface definitions and code examples, discusses their complexity, precision, smoothness, and suitability for single‑machine and distributed scenarios, and offers practical deployment tips using Sentinel, Nginx, Guava, Tair, and Redis.
This article explains what load balancing is, why it is essential for scaling web services, outlines the four OSI‑layer classifications, compares popular software balancers such as LVS, Nginx and HAProxy, and reviews common static and dynamic load‑balancing algorithms with their advantages and use cases.
This article explains the Delaunay triangulation concept, its geometric properties such as empty circumcircles and maximal minimum angles, and presents a detailed divide‑and‑conquer algorithm with step‑by‑step merging logic and a complete TypeScript code implementation.
This article explains the classic Dutch National Flag problem, describes the three‑way partition algorithm with pointer analysis, and provides concise Python and Go implementations that sort an array of red, white, and blue elements in linear time and constant space.
This article presents a data‑driven approach for allocating limited video exposure resources by building a PV‑click‑CTR (P2C) sensitivity model and a multi‑objective optimization framework that balances overall view volume and fairness across scenes, validated through offline metrics and online bucket tests.
The article recounts three technical interview problems—a list‑index extraction using a hash map, a tree‑path reconstruction from parent identifiers, and a minimum‑path‑sum dynamic‑programming challenge—providing Python code solutions and brief explanations for each.
This article introduces Didi's adaptive grouping algorithm, which enhances the uniformity of user allocation in AB experiments by replacing traditional complete randomization with a single-pass method that balances observed metrics across groups, and demonstrates its effectiveness through large‑scale experimental results.
Didi’s AI Lab introduces an Adaptive grouping algorithm for its Apollo AB‑testing platform that allocates users in a single pass using direct and indirect scores, achieving over 95 % balance probability and reducing group imbalance from 14 % (CR) and 2.7 % (RR) to under 0.8 %.
This article explains how to determine whether any four playing cards can be combined using addition, subtraction, multiplication, and division (with parentheses) to reach 24, presenting two Python implementations—an exhaustive enumeration method and a more efficient recursive combination technique—along with performance comparisons.
The article demonstrates how to solve a sixth‑grade geometry problem by programmatically drawing the figure with Python, randomly sampling points inside a rectangle, and estimating the shaded region's area through Monte‑Carlo simulation, achieving results close to the exact answer.
This article presents a combinatorial fish‑division puzzle solved by exhaustive search with Python code, followed by clear explanations and Python implementations of three fundamental sorting algorithms—merge sort, selection sort, and bubble sort—illustrating their core ideas and step‑by‑step processes.
This article examines Python execution speed by benchmarking simple arithmetic, logical checks, built‑in functions like max, and three class‑based point‑in‑rectangle implementations, revealing that straightforward if‑statements are often fastest while highlighting practical tips for writing performant Python code.
This article demonstrates a PHP class that implements the WeChat red packet splitting algorithm, explaining the constraints, providing a complete source code example, and showing how to instantiate the class to distribute a total amount into a specified number of packets with a minimum value.
This article explores various distributed ID generation methods, focusing on Twitter's Snowflake algorithm, detailing its structure, advantages, drawbacks, and comparisons with UUID, database auto-increment, and Redis, while providing implementation insights and references to related open-source solutions.
This article explains the two key properties of recursive functions, demonstrates Python's default recursion depth limit and how to adjust it, discusses the drawbacks of recursion, and presents a programming task to implement a recursive Fibonacci‑triangle generator with sample code.
The article explains how limited hash spaces cause collisions, then compares open hashing (separate chaining) and closed hashing techniques—linear probing, double hashing, and random hashing—detailing their insertion, search, and deletion algorithms along with the performance trade‑offs and load‑factor analysis for each method.
This article explains how to implement a priority queue in Python using the built‑in heapq module, demonstrates extracting smallest and largest elements from price lists, and provides a full PriorityQueue class with push, pop, and is_empty methods, illustrated with stock portfolio examples.
This article provides a thorough introduction to heap data structures, covering their definition, core operations such as insertion and deletion, heap sort implementation, and practical production use cases like priority queues, Top‑K queries, and TP99 calculation, all illustrated with Java code examples.
This article explains the Boyer‑Moore string‑matching algorithm, detailing how the bad‑character and good‑suffix heuristics dramatically reduce comparisons, and provides a complete Java implementation with step‑by‑step illustrations of each matching round and the underlying shift calculations.
This article introduces the open‑source “Fucking Algorithm” project, a popular GitHub collection of over 60 LeetCode‑based articles that explain algorithm problems with detailed reasoning, aiming to improve developers' problem‑solving mindset and algorithmic thinking.
This article explains the brute‑force (BF) substring search algorithm, demonstrates its step‑by‑step operation with examples, then introduces a simple hash‑based sliding‑window method (a basic Rabin‑Karp approach), provides Java code, and shows how to compute and update hashes efficiently to locate a pattern in a main string.
This article explores how large wealth‑management platforms can model product recommendation as a mapping between customers and financial products, defines various evaluation goals such as transaction volume, revenue and user satisfaction, and outlines a systematic A/B‑testing workflow for comparing and optimizing recommendation algorithms.
This article explains how Youku combined user‑growth objectives with real‑time bidding (RTB) advertising, designing and optimizing DSP algorithms to maximize high‑value daily active users under cost constraints, covering business background, RTB mechanics, ranking models, pricing strategies, engineering pipelines, and future directions.
This article introduces the basics of bitwise operations, common operators, practical tricks such as checking parity, setting or clearing bits, and demonstrates their use in solving classic algorithmic challenges like the poison bottle puzzle, power‑of‑two detection, counting set bits, and the 8‑Queens problem.
This article explains the concept of user profiling, outlines an eight‑dimensional tag architecture, describes step‑by‑step methods for constructing a robust profile system from scratch and expanding it, and shows how these profiles support statistical analysis, targeted marketing, and recommendation algorithms.
This article explains the Brute‑Force (BF), Boyer‑Moore (BM), and Knuth‑Morris‑Pratt (KMP) string‑matching algorithms, illustrates their operation with step‑by‑step visual examples, discusses the inefficiencies of BF, the shift rules of BM, and the prefix‑suffix logic of KMP, and provides a complete Java implementation including the construction of the next array.
This article explains how to transform a number like 1234 into a reversed list of its digits using both a straightforward string method and two recursive implementations—standard and tail recursion—while noting Python's general preference for iterative solutions.
Kunpeng, a three‑level advertising framework for Xianyu, unifies activity‑scene‑material abstraction, extensible DataFetcher and modular filter libraries, and a global traffic‑mixing algorithm, enabling business groups to self‑service material delivery, achieve 60‑100% conversion gains, cut UV cost by ~40% and halve time‑to‑market.
This article walks through a common Java interview problem of checking if an integer is odd, presenting multiple candidate solutions, explaining their shortcomings, and culminating in an optimal bitwise implementation while also discussing performance misconceptions.
This article explains the sliding‑window technique for solving the classic “Longest Substring Without Repeating Characters” problem, presents step‑by‑step analysis, demonstrates three Java implementations—from a basic set‑based method to hashmap and array optimizations—and discusses their time‑complexity improvements.
This article explains the binary search algorithm for locating a target element in a sorted array, describing its midpoint‑starting process, halving of the search range, termination conditions, and includes a simple example with its output.
This tutorial explains how to use Python's turtle graphics and the random module to draw a 3×3 magic square, covering functions for drawing squares, filling colors, displaying numbers, and a brute‑force algorithm that shuffles numbers until the magic‑square condition is met.
The article presents an AI‑driven follow‑subtitle system for video streaming that uses server‑side face detection and tracking to attach speech‑bubble bullets to characters, synchronizing trajectories with playback via a client SDK, while addressing cut‑scene handling, latency, and power constraints.
This article explains the principle of jump consistent hashing, compares it with traditional ring‑based methods, shows a step‑by‑step implementation with Go code, and discusses its performance advantages and potential optimizations for distributed key‑value storage systems.
This article introduces the concept of trees and binary search trees, defines a C struct for tree nodes, and provides complete implementations for creating nodes, inserting, deleting, searching, finding min/max, computing size and height, as well as recursive and non‑recursive traversals including pre‑order, in‑order, post‑order and level‑order.
This article explores how to sort a massive 4.6 GB file containing 500 million random integers by applying internal quicksort with median‑of‑three, merge sort, a bitmap‑based approach, and an external‑merge strategy, comparing their performance, memory usage, and implementation details in Java.
This article demonstrates two Python programming exercises: generating all unique three‑digit numbers from digits 1‑4 using nested loops, and calculating a tiered profit‑based bonus by segmenting profit ranges, complete with source code, analysis, and sample outputs.
This article explains how to enumerate every permutation of an array using a depth‑first search backtracking algorithm, illustrates the process with a tree diagram, compares DFS with BFS, and provides a complete C implementation along with a generic Python template.
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.
