This article provides a step‑by‑step tutorial on building a match‑3 (candy‑crush style) game, covering basic rules, core matching and removal algorithms in JavaScript, and a complete implementation in Cocos Creator with grid layout, touch handling, swap animation, piece falling, and refill logic.
This article explains how to locate the kth largest element in an array by leveraging quicksort partitioning, showing that the target index equals len(nums)‑k and iteratively narrowing the search range until the element is found, with a complete Go implementation.
This article explains LeetCode problem 124, describing the definition of a path in a binary tree, analyzing the constraints, and providing a detailed Java implementation that uses depth‑first search to compute the maximum path sum while handling negative sub‑paths.
This article explains how to decode nested strings formatted as k[encoded_string] by using a stack to record repetition counts and substrings, detailing the push/pop logic with examples like 2[a3[b]] and 3[a]2[bc] and providing a complete Go implementation.
This article explains how to reverse a singly‑linked list in groups of K nodes by locating each segment's head and tail, reversing the segment, and recursively processing the remainder, with a complete Go implementation and step‑by‑step reasoning.
This article explains how to solve LeetCode problem 162 (Find Peak Element) in O(log n) time using a binary‑search approach, detailing the three possible cases, providing pseudocode, and presenting a complete Go implementation that handles boundary conditions as negative infinity.
The article explains how to detect a cycle in a singly‑linked list using fast and slow pointers, then locate the cycle’s entry node by resetting the slow pointer to the head and moving both pointers one step at a time, with full Go implementation provided.
Given a circular road with n stations and the distances between each consecutive pair, this article explains how to determine the minimal travel distance between any two stations by evaluating both clockwise and counter‑clockwise routes, providing problem details, examples, solution logic, reference implementations in Python, Java, and C++, and complexity analysis.
This article explains how to solve the classic “longest substring without repeating characters” problem using a sliding‑window technique, detailing pointer management, duplicate detection, and a complete Go implementation.
The article explains a dynamic‑programming approach to the classic “Maximum Subarray Sum” problem, defining dp[i] as the best sum ending at index i, deriving the recurrence dp[i]=max(dp[i‑1]+nums[i], nums[i]), initializing base cases, and providing complete Go code.
Given two positive integers n and k, construct an array of n distinct numbers whose greatest common divisor is k and whose total sum is as small as possible, then output that minimal sum.
The article explains how to determine whether a given push sequence and pop sequence form a valid stack operation by using a temporary Go slice as a stack, iterating through the push list, and repeatedly popping while the top matches the next pop element, finally returning a boolean result.
Given a circular road with n stations and the clockwise distances between consecutive stations, this article explains how to calculate the minimum travel distance between any two stations by comparing clockwise and counter‑clockwise routes, with full Python, Java, and C++ implementations.
This article explains how Redis implements geospatial indexing with GEOADD and GEORADIUS commands, walks through their source‑code implementations, describes the underlying geohash calculations and nine‑cell grid search strategy, and derives the O(N + log M) time complexity for nearby‑people queries.
This article presents a DP‑based algorithm to plan charging stops at highway rest stations for an electric vehicle with 1000 km range, minimizing total travel time including driving, queueing, and charging, and provides a Python implementation with O(N) time and space complexity.
Given an initial array of size n and q update operations that replace a single element each time, this article explains how to output the array's total sum after every modification using a simple O(N+q) simulation with constant extra space, and provides Python, Java, and C++ implementations.
This article explains the maximum‑sum submatrix problem, presents a brute‑force enumeration, introduces a 2‑dimensional prefix‑sum technique to compute submatrix sums in O(1), and provides a complete Python implementation with complexity analysis.
This article explains how to merge multiple sorted linked lists (or arrays) into a single ascending list using a min‑heap priority queue, presents two Python solutions—one converting arrays to linked lists and another operating directly on arrays—along with detailed code, example, and complexity analysis.
Rate limiting controls request flow to protect system stability, covering its definition, motivations, common algorithms such as token bucket, leaky bucket, fixed and sliding windows, their pros and cons, single‑machine vs distributed implementations, and practical component choices for backend services.
This article investigates how diff tools work by presenting three algorithmic approaches—shortest edit distance, longest common subsequence, and the Myers algorithm—each explained with dynamic‑programming concepts, back‑tracing techniques, and complete TypeScript code examples.
Given a binary string, you may color some '1's red and some '0's blue but adjacent opposite bits cannot both be colored; this article presents O(N) dynamic‑programming and greedy algorithms that compute the maximum number of characters that can be colored, with full code examples in Python, Java, and C++.
This article describes how Qunar implemented an automated root‑cause analysis system for flight‑ticket transaction interception, detailing the problem background, system research, a custom algorithm focusing on explanatory power, performance optimizations that reduced analysis time from five minutes to under ten seconds, and the resulting operational improvements.
Binary search is an efficient O(log n) algorithm for locating a target value in a sorted array, and this article explains its step-by-step process, provides iterative and recursive PHP code examples, and discusses their usage and performance considerations.
This article explains a coding problem where a merchant trades multiple goods over several days, describes the input and output formats, demonstrates how each product can be handled independently using a greedy approach identical to LeetCode 122, provides a full Python implementation, and analyzes its time and space complexity.
This article introduces front‑end graph visualization using AntV G6 and Graphin, explains graph models and JSON data structures, covers traversal, shortest‑path and clustering algorithms, compares G6 and Graphin, and provides detailed TypeScript and React code for custom extensions, event handling, and full‑screen support.
This tutorial explains how to build a Python script that captures the 4399 mini‑game window, splits the screenshot into icons, uses image hashing to identify matches, applies a path‑finding algorithm to locate connectable pairs, and simulates mouse clicks to automatically clear the game board.
This article explains the dynamic‑programming solution to count the number of distinct ways a monkey can climb a staircase of n steps when each jump can be either 1 or 3 steps, including problem definition, recurrence relation, Python implementation, and time‑space analysis.
Given a list of children’s IDs and flags indicating whether each child shares a class with the previous one, this article explains how to determine the two class groups using a dynamic‑programming approach, presents full Python code, and analyzes its O(N + x log x + y log y) time and O(N) space complexity.
This article explains common rate‑limiting algorithms—including fixed‑window counters, sliding windows, leaky buckets, and token buckets—detailing their principles, advantages, and pitfalls, and provides complete Java code examples to illustrate implementation and testing of each method.
This article explains Redis's LFU eviction algorithm, its implementation details, code-level mechanics, configuration steps, and how it improves upon LRU by using frequency-based counters and decay to make smarter cache eviction decisions.
The article proposes a six‑layer methodology for mobile compatibility testing that starts with hardware specs, adds market and roadmap insights, prioritizes high‑share and bug‑prone models, classifies performance tiers, accounts for special devices, aligns scenarios with key parameters, and uses an algorithm to group, rank, and flag representative devices for efficient testing.
This article explains how to determine the maximum number of Linux distributions in a connected group by modeling the relationships as an adjacency matrix and applying BFS or DFS to count the largest connected component, with full Python implementations and complexity analysis.
This article examines why encrypted data hinders fuzzy queries and presents three categories of solutions—naïve, conventional, and advanced—detailing their implementations, performance trade‑offs, and security implications to help developers choose an appropriate approach.
This article explains the ten Celestial Stems and twelve Terrestrial Branches, their symbolic meanings, the 60‑year cycle, and provides step‑by‑step formulas to compute the stem‑branch pair for a given year, month, and day, illustrated with a 2010 example.
This document describes the background, design, capability classification, implementation details, case studies, practical experience, and future outlook of a recommendation‑algorithm Platform‑as‑a‑Service (PaaS) that enables reusable, extensible, and configurable recommendation capabilities across dozens of business lines.
This article explains the 2023B problem of locating the maximum‑value mine cluster on a grid of '0', '1', and '2' cells, provides BFS and DFS solutions in Python, and details input format, examples, and time‑space complexity.
This article explains how to determine the shortest waiting time required to perform integration testing on a specific microservice when services have startup dependencies and individual load times, using a BFS‑based topological sort algorithm with a detailed Python implementation and complexity analysis.
The article presents a grid‑based Mars terraforming problem where cells are marked YES, NO, or NA, and asks to determine the minimum number of solar days needed to convert all convertible (NO) cells to habitable (YES) using a multi‑source BFS approach, returning –1 if impossible, with full Python implementation and complexity analysis.
This article examines the mobile game black‑market ecosystem, outlines common fraud patterns such as script cheats, account trading, and illegal recharge, and presents a comprehensive anti‑fraud architecture that combines real‑time risk assessment, offline analysis, and adaptive mitigation strategies for game developers and operators.
This article explains a graph‑based interview problem where, given an undirected network of N nodes and their connections, you must determine the minimum time for a broadcast node to receive all responses, and provides a full Python BFS solution with complexity analysis.
This article presents three interview‑style algorithm problems—a golden treasure‑box search, an inequality‑set validator with maximum‑difference calculation, and a smallest‑number‑after‑removing‑digits task—each with clear problem statements, constraints, step‑by‑step simulation logic, and full Python code implementations.
Given a SATA disk capacity M and a sequence of blockchain file sizes, the task is to find the largest sum of a contiguous subsequence whose total does not exceed M, using an O(N) sliding‑window algorithm with O(1) extra space.
This article examines several Java deduplication techniques—including List.contains, HashSet, double-loop removal, and Stream.distinct—by providing sample code, measuring execution time on a 20,000‑element list, and analyzing their time complexities to guide developers toward efficient duplicate‑removal strategies.
This article explains the definition and operations of sequential and circular queues, illustrates the false overflow issue in array‑based queues, and provides a complete Java implementation of a circular queue with enqueue, dequeue, and utility methods.
Redis implements approximate LRU and LFU eviction policies by sampling keys and using a compact 24‑bit field to store timestamps and counters, where LRU evicts the least recently accessed items and LFU evicts those with low, decay‑adjusted access frequency, each with trade‑offs for different workloads.
This article recounts how a MIT information‑theory class assignment sparked David Huffman's invention of a bottom‑up binary‑tree coding method that revolutionized lossless data compression and became a cornerstone of modern computer science.
Qianchuan is a unified recommendation platform that consolidates numerous low‑traffic, diverse scenarios into a five‑layer architecture—service, access, DPP, algorithm, and infrastructure—addressing challenges of varying products, goals, strategies, recommendation types, and limited resources through flexible product selection, multi‑goal support, advanced recall and ranking models, and extensible, low‑cost algorithms, while planning broader scene coverage, bias reduction, and componentized, reproducible solutions.
This article demonstrates several straightforward Python techniques for retrieving the longest string from a list, including a manual loop, the built‑in max function, sorted usage, and an additional variant, each accompanied by clear code examples and explanations.
The article surveys Didi’s driver‑passenger matching challenges and presents a suite of solutions—from greedy nearest‑driver and Kuhn‑Munkres bipartite matching to stable marriage, dynamic and one‑to‑many assignments, reinforcement‑learning, routing and queueing models—while validating assumptions statistically, integrating preference‑aware machine learning, and outlining multi‑objective and digital‑twin future research.
The article details how a mobile app’s scanner was re‑engineered from single‑code to multi‑code detection by overhauling the logic pipeline, adding UI overlays, implementing a rotation‑and‑scale transformation algorithm, integrating iOS Vision alongside the existing SDK, applying confidence filtering, deduplication, edge‑intelligence prediction, and memory‑optimized caching, ultimately boosting recognition rates by over 30 percentage points and reducing miss‑detections.
This article analyzes the challenges of stitching multi‑modal transport routes in Ctrip's backend, identifies performance bottlenecks through monitoring, profiling and benchmarking, and presents a series of optimizations—including code refactoring, indexing, multi‑way merge, multi‑level caching, preprocessing, multithreading, lazy computation, and JVM tuning—that collectively reduce latency and resource consumption.
This article explains three core rate‑limiting algorithms—Leaky Bucket, Token Bucket, and Sliding Window—detailing their principles, suitable scenarios, and provides complete Go implementations to help developers choose and integrate the right strategy for handling traffic spikes and protecting backend resources.
This article provides a comprehensive overview of rate limiting, covering basic concepts, common algorithms such as token bucket, leaky bucket, and sliding window, and practical implementation methods across Nginx, Tomcat, Guava, Redis, and Sentinel for distributed backend systems.
The article explores how AIOps, a human‑machine collaborative approach powered by data, algorithms, and contextual knowledge, transforms modern operations by enabling real‑time insight, predictive decision‑making, automated execution, and continuous feedback, especially in complex, security‑sensitive environments like finance.
Elon Musk repeatedly pledged to open‑source Twitter’s recommendation algorithm, yet after massive layoffs and the loss of key engineers, the promised code remains hidden, illustrating how managerial decisions can cripple open‑source initiatives and impact platform trust and performance.
This article explores the “push‑step aggregation” technique featured in the drama “Microscope under the Ming,” revealing that it is essentially the Shoelace Theorem for quickly computing polygon areas, complete with mathematical derivation, visual illustrations, and a Python implementation.
This article introduces the core concepts of dynamic programming, explains its principles of breaking problems into subproblems with optimal substructure, and provides step‑by‑step Python implementations for the classic knapsack optimization and a shortest‑path graph algorithm, complete with illustrative code and visualizations.
This article explains the SnowFlake distributed ID algorithm, detailing its 64‑bit structure, bit allocation for timestamps, datacenter and worker IDs, sequence numbers, and provides a complete Java implementation along with its advantages and limitations.
This article introduces linked lists as a fundamental data structure, compares them with arrays, explains single, doubly, and circular variants, demonstrates insertion, deletion, and boundary handling with dummy nodes, and details two‑pointer techniques for cycle detection and finding the list’s midpoint.
Elon Musk announced that Twitter’s recommendation algorithm will be open‑sourced as early as next week, citing transparency and bias reduction, while experts debate the feasibility and potential impact on AI standards, and the tech community shares humorous code snippets mocking the move.
This article examines the challenges of fuzzy searching encrypted data and presents three categories of solutions—silly, conventional, and advanced—detailing their implementation ideas, performance trade‑offs, storage costs, and practical recommendations for secure yet searchable data.
This article explores Java’s built‑in sorting mechanisms, detailing the underlying TimSort and Dual‑Pivot Quicksort algorithms, their implementation in the JDK, performance characteristics, and comparative benchmarks, while providing code examples and insights into when each method is most effective.
This article compares advertising and recommendation algorithms, highlighting distinct optimization goals, model design focuses, training methods, implementation principles, auxiliary strategies, and model characteristics, emphasizing how ads aim to increase revenue while recommendations prioritize user engagement and diversity.
This article combines a light‑hearted Valentine’s Day introduction for programmers with a detailed presentation of the classic Two Sum problem, including problem description, constraints, example inputs and outputs, multiple language implementations, and a complexity analysis.
This article provides a comprehensive, formal introduction to skip lists, covering their probabilistic foundations, structural design, detailed C implementations for creation, search, insertion, deletion, random level generation, space and time complexity analyses, and extensions such as fast random access and span maintenance.
This article examines how high‑performance sorting functions such as C's qsort() and Java's Collections.sort() are implemented, compares suitable algorithms, analyzes merge sort versus quicksort, and presents practical optimizations like median‑of‑three pivots, random pivots, recursion depth limits, and hybrid insertion sort.
This article explores strategies for batch scaling Kafka replicas with minimal data migration, presenting two design ideas, detailed calculations of broker lists, partition counts, start indexes, and replica shifts, and provides step‑by‑step algorithms and code snippets to compute optimal replica assignments for both expansion and contraction scenarios.
On January 9 from 19:00 to 20:00, algorithm engineer Zhang Yuanliang will present Taobao’s scenario-adaptive, self-supervised multi-scenario recommendation model, detailing its architecture, experimental results, and practical deployment for improving personalized item recall across diverse user contexts.
This article introduces the fundamentals of the Base64 encoding algorithm, explains its role in reverse‑engineering and security scenarios, details the encoding and decoding processes, and provides complete Java and native C++ implementations with code examples for Android development.
stl4go provides a generic Go 1.18 container library that implements an optimized skip‑list‑based ordered map, using adaptive levels, efficient random‑level generation, type‑specific paths, and cache‑friendly node structures to achieve near‑C++ performance, surpassing existing Go generic collections.
This article introduces the concept of rate limiting, explains three core algorithms—fixed window, sliding window, and leaky bucket—along with the token bucket approach, provides Java code examples for each, discusses their principles, advantages, and pitfalls, and outlines practical implementation considerations.
This article introduces four classic sorting algorithms—bubble sort, selection sort, insertion sort, and quick sort—explaining their principles and providing complete PHP implementations for each to help readers understand and apply these fundamental techniques.
This article reviews why reversible encryption is needed for certain sensitive fields, classifies three categories of fuzzy‑search‑on‑encrypted‑data techniques—naïve, conventional, and advanced—and evaluates their implementation steps, performance trade‑offs, and practical recommendations.
This article explains how to determine the smallest positive integer absent from an unsorted array using an in‑place linear‑time algorithm, covering problem analysis, core insight, step‑by‑step implementation details, Python code, and complexity evaluation.
The article explains why companies use algorithm, fundamental, component, and scenario interviews, outlines the three main purposes of algorithm tests, and shows how interview focus shifts across campus hiring, early‑career social recruitment, and senior positions.
This article explains the concepts of binary trees, complete binary trees, and binary heaps, shows how React implements a min‑heap for its task scheduler, and provides detailed JavaScript code examples for push, pop, siftUp, siftDown, and peek operations.
This article explains the fundamental concepts of rate limiting, compares common algorithms such as token bucket, leaky bucket and sliding window, and details practical implementations using Nginx, Tomcat, Redis, Guava, and Sentinel for both single‑node and distributed backend systems.
This article explains a classic interview puzzle where ten mice and a two‑hour observation window are used to identify a single toxic bottle out of a thousand by encoding the bottles in binary and interpreting the mice's survival as binary bits.
This article demonstrates how to move all zeros to the end of a Python list using two concise code snippets, explains the reasoning behind each approach, and provides a clear example for readers to apply the technique in their own projects.
This article presents a scientific color adaptation solution that uses a quantization algorithm to extract dominant image colors, refines them via HSB adjustments, validates against WCAG contrast standards, and demonstrates practical deployment in app store and game center interfaces.
This article explains the fundamentals of the K-means clustering algorithm, describing its distance‑based similarity principle, the objective of minimizing squared error, and a step‑by‑step iterative procedure—including random centroid initialization, assignment, centroid recomputation, and convergence criteria.
This article explains why Vue SSR performance suffers, introduces cache concepts and eviction policies, and walks through a complete, O(1) LRU cache built with JavaScript using a hash map, doubly‑linked list and arrays, complete with code and visual examples.
This article explains a Markov‑based scoring method for ranking sports teams, treating each match as a vote where weaker teams award points to stronger ones, and shows how to construct a stochastic matrix, handle dangling nodes, compute the steady‑state vector, and derive final rankings, analogous to Google’s PageRank.
This article provides a comprehensive overview of various load balancing strategies—including round‑robin, random, weighted, smooth weighted round‑robin, consistent hashing, least‑active, and optimal‑response algorithms—explaining their principles, advantages, disadvantages, use‑cases, and offering complete Java code examples for each.
This article explains how to build a tree‑based sensitive‑word detection algorithm in PHP, discusses the challenges of correctly iterating over multibyte strings, and provides a complete implementation with code examples that handle Unicode characters efficiently.
This article provides an overview of search, recommendation, and advertising as core internet services, comparing their problem definitions, business goals, algorithmic models, and system architectures across web, e‑commerce, and O2O scenarios, while outlining historical development and key industry examples.
This article examines the challenges of fuzzy searching encrypted data and compares three categories of solutions—naïve (sand‑wich), conventional, and advanced (super)—detailing their implementation ideas, performance implications, and suitability for real‑world applications.
Tencent Ads hosted two KDD2022‑focused live sessions showcasing the CONFLUX and MVKE algorithms, explaining their technical foundations, real‑world impact on billions of ad impressions, and answering audience questions about brand versus performance ads, validation methods, and future research directions.
This article analyzes Haro’s two‑wheeler dispatch problem, compares it with food‑delivery and ride‑hailing scheduling, outlines eight technical challenges, presents a multi‑fast‑good‑cheap algorithm framework, and details a simulation system that validates and improves the scheduling solution.
This tutorial explains what a dragon curve fractal is, how it can be constructed by iterative paper folding, and provides step‑by‑step Python code—including sequence generation and Turtle graphics—to draw both straight‑line and circular versions of the curve.
The author explains how the viral “Sheep Sheep” puzzle’s random mechanics make it nearly impossible to clear, then details the creation of a clone called “Fish Fish” with customizable difficulty, open‑source code, and the core implementation techniques used.
This article explains how Redis uses its Geo module, combining ordered sets and Geohash encoding, to efficiently implement the “nearby people” feature, covering command usage, detailed source‑code analysis of GEOADD and GEORADIUS, algorithmic steps, and complexity evaluation.
This article examines why encrypted data hinders fuzzy queries, categorizes three implementation approaches—from naive in‑memory decryption to conventional database tricks and advanced algorithmic solutions—evaluates their security, performance, and storage impacts, and provides practical references for real‑world systems.
Rate limiting safeguards distributed systems by controlling request rates through algorithms such as leaky bucket, token bucket, fixed and sliding windows, and back pressure, while client‑side tactics like exponential backoff, jitter, and careful retries, and requires atomic distributed storage solutions (e.g., Redis+Lua) to avoid race conditions.
Alibaba’s DaTaobao team unveiled a high‑definition live‑streaming guide that combines video processing algorithms, equipment recommendations, and standardized low‑cost solutions to dramatically improve picture quality for both top‑tier and novice streamers, while also offering free access and ongoing support.
This article presents three algorithmic challenges: counting pattern occurrences on an M×N canvas, determining the number of leaf nodes in a binary tree represented by an array, and maximizing stock trade profit under constraints on negative returns and total gain, each with input specifications, sample cases, and solution outlines.
After struggling with a seemingly easy scoring problem in a regional programming contest, the author details multiple Go implementations—including a map, a 27‑base array, and a trie—examines their time and memory issues, discovers input handling pitfalls, and ultimately achieves an accepted solution.
This article explains the core PSO velocity and position formulas, provides a complete Python implementation with detailed comments, runs the algorithm on a 2‑dimensional test function, and presents the optimal solution and convergence plot.
This article examines why encrypted data hinders fuzzy queries, categorizes three implementation strategies—from naïve to conventional to advanced—explains their mechanisms, evaluates performance and security trade‑offs, and provides practical references for building searchable encrypted fields.
This article explains the fundamentals of consistent hashing, its application in load‑balancing distributed caches, analyzes common issues such as data skew and cache avalanche, introduces virtual nodes for uniform distribution, provides Java code examples, and compares it with Redis's HashSlot approach.
