This article explains the LeetCode 1402 problem of maximizing the total satisfaction score by arranging dishes, describes the greedy approach of sorting and using suffix sums, and provides a Java implementation that iteratively adds positive suffix sums to compute the optimal result.
This presentation details how Hallo Mobility tackles the challenges of information‑flow ad modeling by describing the ad ecosystem, the company’s business evolution, and the advertiser‑side algorithmic solutions—including plan‑level quality detection, creative‑level uplift modeling, feature‑cross engineering, and pre‑bid user screening—while outlining future directions for automated, data‑driven ad delivery.
This article presents detailed problem statements, mathematical analysis, and Python implementations for seven algorithmic challenges covering combinatorial counting, geometry, number theory, graph shortest paths, Hamiltonian cycles, time conversion, and Pascal's triangle indexing.
This article explains a Tencent interview question requiring identification of a QQ number appearing more than half the time among 2N entries, discusses naive sorting and hashmap approaches, and presents the optimal O(N) time, O(1) space Moore voting algorithm with a complete C++ implementation and sample output.
This article explains what performance means, why optimization remains essential even on powerful multi‑core CPUs, large memory, and SSDs, and demonstrates through simple code examples how algorithmic complexity can cause noticeable lag, urging developers to prioritize performance tuning.
This article explains how a low‑code platform redesigned its report page using a tile layout powered by React‑Grid‑Layout, detailing vertical and horizontal squeeze modes, nesting, height‑auto adaptation, mixed tile‑flow layouts, and algorithm optimizations for smoother drag‑and‑drop interactions.
This tutorial explains how to implement a one‑stroke gesture recognizer with HTML5 canvas, covering drawing, resampling, translation, rotation, scaling, feature extraction, and similarity measurement using Euclidean and cosine distances, complete with full TypeScript code examples.
This article walks through a Python coding challenge that sums numbers in a list while ignoring sections that start with 6 and end with the next 9, presenting five distinct solutions—including flag‑based, loop‑based, and recursive approaches—complete with explanations and full code examples.
This article presents abstract‑paxos, a unified framework that derives Paxos and Raft from first principles, defines information certainty, quorum, and a total order on states using commit_index, and details a two‑phase protocol, member‑change handling, and how the model maps to classic Paxos and Raft implementations.
This article explains a classic interview question of locating the smallest missing positive integer from an array, analyzes its theoretical bounds, and presents three O(n) time, O(1) space solutions—including a clever marking technique and a swap‑based method—accompanied by complete Go implementations.
This article presents a detailed walkthrough of the LeetCode "Container With Most Water" problem, covering the problem statement, a two‑pointer analysis, and a complete Java implementation, while highlighting key insights for efficiently maximizing water storage.
The article explains consistent hashing—using a circular 2^32 hash ring with virtual nodes to evenly distribute keys across dynamic cache servers—provides a complete Go implementation including host registration, key lookup, and a bounded‑load extension that tracks server load, demonstrates a proxy‑cache setup, and discusses practical testing and production‑grade enhancements.
This article explains how to count the number of isosceles acute‑angled triangles whose vertices lie on the vertices of a regular n‑gon, discusses separate cases for even and odd n, handles duplicate equilateral triangles, and provides a correct Java implementation that avoids integer overflow.
This article outlines seven fundamental Java performance‑optimization directions—ranging from code reuse and parallel execution to JVM tuning—providing a theoretical framework that helps developers understand how to balance resource usage, reduce latency, and improve overall system efficiency.
This article explains how to count the number of isosceles acute triangles whose vertices lie on a regular n‑gon (3 ≤ n ≤ 10⁷), derives separate formulas for even and odd n, handles duplicate equilateral cases, and provides a correct Java implementation that avoids overflow.
This article explains how to implement an automatic missile‑tracking system for a shooting game using Python’s Pygame library, covering the underlying differential‑equation‑based algorithm, step‑by‑step trigonometric calculations, handling of coordinate systems, image rotation challenges, and provides complete source code.
This article explains the concept of skip lists as an ordered random data structure, illustrates how Redis uses skip lists for sorted sets, and provides a complete Java implementation with detailed code examples and analysis of their performance characteristics.
This article presents a Python fan's arithmetic challenge—calculating the alternating sum 1‑2+3‑4+…+99—and walks through five distinct code solutions, from basic loops to concise itertools one‑liners, highlighting their logic and trade‑offs.
This article walks through creating a Python program that simulates the popular Chinese card game ZhaJinHua, covering deck construction, random dealing to five players, hand‑type evaluation, scoring, and ranking, with complete source code and a concise explanation of each step.
ByteDance’s data platform front‑end team surveyed academic, commercial, and open‑source word‑cloud solutions, identified gaps in geo‑ and shape‑based clouds, and engineered a performant front‑end layout algorithm that generates customizable shape word clouds for diverse business scenarios.
This article surveys academic, commercial, and open‑source word‑cloud solutions, explains the underlying algorithms, visual encodings, layout strategies, interaction techniques, and classifications, and discusses the strengths, limitations, and future directions of word‑cloud visualisation.
This article introduces the classic Two Sum problem, explains its brute‑force O(n²) approach, then presents an optimal O(n) hash‑table solution and a more advanced sort‑plus‑binary‑search method, providing complete C++ implementations and performance comparisons for each technique.
Even when individual algorithm modules show higher accuracy or revenue, the overall platform can decline due to factors like competitor encroachment, macro‑economic shifts, concept drift, overlapping marginal returns, attribution errors, and coupled A/B experiments, all of which require careful analysis and mitigation.
The article explains the classic bulb‑switch problem, showing how toggling bulbs in successive rounds leads to only those positioned at perfect‑square indices remaining on, derives the mathematical reasoning behind the pattern, and presents a concise O(1) solution using the integer square‑root of n.
This article explains how to answer range maximum queries on a static array efficiently by preprocessing with a sparse table, achieving O(n log n) build time and O(1) query time, and provides a complete C++ implementation with state compression and interval decomposition.
This article explains the classic water‑jug interview problem using two cups of 9 L and 15 L, derives the reachable volumes via greatest‑common‑divisor logic, and provides complete C++ code to determine feasibility and output the pouring steps for any target volume.
This article explains why service rate limiting is essential for high‑concurrency systems, compares it with service degradation, introduces common limiting algorithms such as counter, leaky‑bucket and token‑bucket, and shows how to implement distributed rate limiting using Redis for real‑world backend services.
This article explains the concept of “lucky numbers” in an integer list—where a number’s value equals its occurrence count—and walks through a Python solution that progressively uses set, count, map, zip, filter, lambda and sorted, culminating in a concise one‑liner implementation.
The article explains how Kafka implements delayed operations using a timing wheel with O(1) insertion and deletion, describes its parameters, multi‑level wheel design for large time spans, and the mechanism of advancing the wheel via DelayQueue and the ExpiredOperationReaper, contrasting it with Netty's approach.
This article walks through the origin, architecture, and tooling of Shopee Candy, a multi‑region match‑3 H5 game, detailing the Algorithm SDK, animation system, map editor, score runner, replayer, and future plans for configurability, performance, anti‑cheat, and AI‑driven level design.
This guide shows how to generate smooth, high‑quality curves from a polyline in pure JavaScript by computing quadratic and cubic Bézier points, deriving control points via angle‑bisector geometry, assembling the segments, and rendering and animating the result on an HTML5 canvas without external libraries.
This tutorial explains how to solve the LeetCode "Lucky Numbers in a List" problem in Python by extracting unique elements, counting their occurrences with map and count, pairing them with zip, filtering with lambda, sorting the result, and finally compressing the whole logic into a single expressive line of code.
This article explains the theoretical and practical range of Tencent QQ numbers, why the lower limit is set to 10001, how unused accounts are reclaimed, and demonstrates how bitmap techniques can efficiently deduplicate billions of QQ IDs using simple C++ code.
This article walks through four approaches—sorting, hashmap, file splitting, and a bitmap technique—to deduplicate 4 billion QQ numbers within a 1 GB memory limit, explains why the first three fail, and shows how a bitmap solves the problem efficiently.
This article demystifies the fast inverse square root algorithm used in games, explaining the origin of the infamous 0x5f3759df magic number, the underlying IEEE‑754 floating‑point representation, the evil bit‑hack, Newton iteration steps, and how these tricks accelerate vector normalization.
The Smart Matching Engine for Haolo’s ride‑sharing service ingests driver and passenger orders via Kafka‑Flink pipelines into Elasticsearch, then applies multi‑stage matching—nearby search, itinerary‑based filtering using ETA, angle, distance, route‑similarity and shared‑mileage calculations—and finally ranks results with evolving pre‑sorting and algorithmic models, including PMML and deep‑learning, to optimize driver‑passenger pairing.
The article introduces the Dual Vector Foil (DVF) algorithm system, which decouples index construction from model training to enable lightweight, high‑precision large‑scale recall using arbitrary complex models, and details its two‑stage and one‑stage solutions, graph‑based retrieval implementation, performance optimizations, and experimental results.
This article explains several algorithmic strategies—including sorting, hash maps, file splitting, and bitmap techniques—to remove duplicates from a file containing 4 billion QQ numbers while staying within a 1 GB memory limit, and it provides extension exercises for sorting, median, top‑K, and duplicate detection.
This article explains how Redis implements its Sorted‑Set using a skiplist, starting with the basics of a singly linked list, analyzing insertion and query complexities, deriving the skiplist structure and its O(log N) performance, and comparing it with hash tables, balanced trees, and B‑trees.
This article explains how to handle the massive‑data problem of intersecting two files containing billions of URLs by using hash‑based divide‑and‑conquer techniques, file partitioning, and in‑memory hash lookups to achieve scalable performance beyond naive O(m·n) approaches.
This article explains why rate limiting is essential for system stability, outlines common throttling patterns such as circuit breaking, degradation, delayed processing, and privilege handling, and dives into popular algorithms like counter, leaky bucket, and token bucket with concrete Java and Nginx examples.
This article explains four practical methods—sorting, hash map, file splitting, and bitmap—to deduplicate 4 billion QQ numbers within a 1 GB memory limit, and provides extended exercises on sorting, finding the median, top‑K, and duplicate detection for massive datasets.
This article explains the classic two‑egg, 100‑floor interview puzzle, analyzes why it became a staple, and walks through four solution approaches—from a naïve linear method to binary search and a balanced partition strategy—culminating in a mathematically derived optimal method that never exceeds fourteen drops.
This article details Youku’s first “Free Viewpoint” technology optimization, explaining its underlying principles, client architecture, performance‑boosting strategies such as smart bitrate, multi‑channel downloading, pre‑caching, and the resulting improvements in playback smoothness and device coverage.
This article walks through four practical techniques—sorting, hashmap, file splitting, and bitmap—to remove duplicate QQ numbers from a 4‑billion‑record file within a 1 GB memory limit, and provides extended exercises for sorting, median, top‑K, and duplicate detection.
This article explains how to compute the maximum of each k‑sized sliding window over an integer array using both a priority‑queue (heap) approach and an optimized monotonic deque technique, complete with detailed walkthroughs, visual illustrations, and full Python code.
This article introduces the sliding window algorithmic technique, explains its relation to TCP flow control, demonstrates its implementation with Java code for maximum subarray sum, longest substring without repeats, and minimum window substring problems, and provides a reusable framework for solving similar LeetCode challenges.
This article explains why iOS memory leaks become critical as apps grow, introduces five representative leak models, details a production‑ready object‑graph scanning solution with custom data structures and a non‑recursive DFS algorithm, and evaluates its performance impact and mitigation strategies.
The article examines how low‑level recommendation‑algorithm improvements in information‑flow feeds can boost user retention, LTV and overall growth by addressing cold‑start challenges, survivor bias, and causal inference through personalized ranking, ecosystem construction, and multi‑task learning.
This article explains the greedy approach to the knapsack problem, demonstrates how to compute item value‑to‑weight ratios, selects items based on those ratios, shows a complete Java example, and discusses why the greedy method may not always yield the optimal solution.
This article presents Car Home's experience building a real‑time materialized view system on Apache Flink, detailing system analysis, problem decomposition, a global‑version‑based CDC algorithm, its implementation as a Flink connector, practical deployment results, and remaining challenges such as clock dependency and state size.
This article explains how to design and implement a points‑based lottery (luck draw) system in Java with Spring Boot, covering database schema for prizes, probability limits, prize pools, the random draw algorithm, prize restrictions, and asynchronous prize distribution using a factory pattern.
This article explains how to implement a lottery feature in a Java backend, covering database schema design for prizes, probability limits and records, constructing a prize pool, the random selection algorithm, handling prize limits, and using a factory pattern to distribute various prize types.
This article explains how to determine whether a singly linked list contains a cycle using three approaches—brute‑force, hash‑marking, and the optimal fast‑and‑slow pointer technique—providing Go and C++ implementations that achieve minimal time and O(1) space complexity suitable for a Tencent interview.
This article explains the classic House Robber interview question, detailing the problem constraints, illustrating why a naive alternating‑house approach fails, and presenting a clear dynamic‑programming solution with recurrence, base cases, and a concise code example.
This article introduces the fundamentals of directed acyclic graphs (DAGs), explains adjacency representations, details the Dagre layout algorithm’s concepts, computation steps, and constraints, and presents the Perfect‑Process front‑end library that implements these techniques for interactive pipeline diagram rendering and editing.
Rate limiting protects services from overload by controlling traffic, using techniques such as circuit breaking, degradation, buffering, privilege handling, and algorithms like counters, leaky bucket, and token bucket, with implementations ranging from Guava in Java to Nginx+Lua for distributed systems.
This article explores how to solve a common interview coding challenge—implementing a square‑root function without using library calls—by discussing problem analysis, linear and binary‑search approaches, optimization techniques, testing strategies, and the broader skills interviewers aim to assess.
This article explains the principles of BitMap, BitSet, and Bloom Filter data structures, illustrating how they use bits to efficiently store, add, delete, and query large sets of integers, and discusses their practical applications such as fast sorting, deduplication, and membership testing.
This article compiles a series of backend interview questions covering HTTP header fields, HTTPS handshake, TCP connection states, virtual and physical memory concepts, TCP connection limits, Eureka architecture and consistency, Hystrix fault‑tolerance mechanisms, Zookeeper's Zab protocol and leader election, and provides a Java solution for finding the longest substring without repeating characters.
This article presents a classic monkey‑and‑peach puzzle, derives the minimal initial peach count using mathematical reasoning, and then demonstrates a brute‑force Python program that searches for the solution, illustrating how loops and modular checks solve the problem.
This tutorial shows how to create a Tetris mini‑game with AI using a straightforward algorithm, Python 3.6, PyQt5, and detailed code that evaluates board states based on cleared lines, holes, heights, and other metrics to select optimal moves.
This article explains why rate limiting is needed in both physical venues and online systems, describes common limiting strategies such as circuit breaking, service degradation, delayed processing, and privileged handling, and details three major algorithms—counter, leaky bucket, and token bucket—along with practical Java and Nginx‑Lua code examples.
This article presents a classic stock‑like profit maximization problem using mooncake prices, explains the input and expected output, and walks through three solution strategies—brute‑force enumeration, a greedy linear scan, and a dynamic‑programming approach—complete with Go code examples and visual illustrations.
This article explains the merge sort algorithm’s divide‑and‑conquer principle, analyzes its O(n log n) time complexity, and provides two complete C# code examples—one for a generic merge sort and another for merging two already sorted arrays—along with visual illustrations of the merging process.
This article presents five programming problems from Hulu's 2022 campus recruitment—including particle simulation, Sophie‑N number counting, optimal activity point on a tree, devil‑maze navigation, and non‑intersecting triangles—complete with problem statements, input/output specifications, sample cases, and detailed solution approaches.
This article explains the concepts, strategies, and algorithms of rate limiting—including circuit breaking, service degradation, leaky‑bucket and token‑bucket methods—and provides practical Java, Guava, and Nginx + Lua implementations for controlling concurrency and protecting backend services.
This article presents a PHP implementation of Redis-based rate limiting, explaining how to limit the number of requests per time interval by using timestamp-modulo keys, atomic increment operations, and key expiration, along with detailed code and step-by-step commentary.
Alibaba Mama’s talk explains how calibrated probability models—evolving from simple Platt scaling to Bayesian isotonic regression and real‑time wave‑adjusted variants—improve click‑through and conversion predictions, enabling more accurate bidding, stable auctions, and fairer ad allocation despite data drift and sparsity.
This article explains how to determine whether a singly linked list contains a cycle using the fast‑slow pointer technique, derives the mathematical reasoning for locating the cycle entry point, and provides a complete Java implementation that returns the node where the cycle begins or null if none.
This article explains the role and data structure of Memtable in LevelDB, introduces the probabilistic SkipList design, analyzes its time and space complexities, and provides a full Java implementation of a SkipListMap with code examples and a brief look at LevelDB's own SkipList implementation.
This article explains the Least Frequently Used (LFU) cache eviction strategy, contrasts it with LRU, and provides a complete Java implementation—including node definition, insertion, sorting, removal, and retrieval logic—along with a test scenario and discussion of LFU's drawbacks.
This article presents a collection of concise Python one‑liners—ranging from creating 2‑D lists and clamping numbers to generating Fibonacci sequences and converting strings to snake_case—each explained with clear code examples and practical use cases for everyday programming tasks.
This article explains why rate limiting is essential for system stability, compares it with caching and degradation, details three core algorithms—counter, leaky bucket, and token bucket—and provides concrete Guava, Java, and Nginx + Lua code examples for implementing both local and distributed throttling.
This article explains how Redis implements the “nearby people” feature using its Geo module, detailing the GEOADD and GEORADIUS commands, their underlying algorithms, source‑code flow, and the resulting time‑complexity for adding and querying location data.
This article explores how to identify a single poisonous bottle among 1,000 using the fewest rabbits and the shortest time by analyzing pure‑time, pure‑space, balanced strategies, and finally applying binary encoding to solve the classic interview puzzle in just one day.
This article explains the classic circular gas‑station challenge, presents its key constraints, walks through a concrete example, and compares three solution strategies—brute‑force, reverse (backtrack) greedy, and a cumulative‑sum graphical method—highlighting their trade‑offs and insights.
This article explains why rate limiting is essential for high‑availability services, describes HTTP 429 standards and response headers, classifies rate‑limiting strategies by granularity, target, and algorithm, and provides detailed Go code examples using the time/rate library for fixed‑window, sliding‑window, leaky‑bucket, and token‑bucket implementations.
This article presents a classic river‑crossing puzzle where three people and three ghosts must use a two‑seat boat without ever letting ghosts outnumber people on either bank, detailing the analysis, each crossing round, and the logical search strategy to solve it.
This article explores the HyperLogLog algorithm for cardinality estimation, tracing its development from Linear and LogLog counting, detailing its Redis implementation with sparse and dense encodings and command workflows, and presenting experiments that demonstrate its memory efficiency and analyze observed error rates versus the theoretical 0.81% standard deviation.
This article explains heap sort's time and space complexities, introduces max‑heap and min‑heap concepts, details the algorithmic steps for building and maintaining the heap, and provides a complete Java implementation with accompanying code examples.
This article explores a classic puzzle where one must locate a single poisonous bottle among 1000 using rabbits as testers, comparing time‑focused, space‑focused, and balanced strategies before revealing an optimal binary‑encoding solution that finds the poison in one day with just ten rabbits.
This article explains the fundamental concept of recursion using a cinema‑seat analogy, demonstrates array‑sum and Fibonacci implementations in JavaScript, shows how to visualize recursive calls, discusses stack‑overflow and redundant computation issues, and presents iterative and memoized alternatives.
This article details a technical approach to automatically generating stroke order animation data for Chinese characters from standard font files, covering SVG rendering, coordinate transformations, deep learning-based stroke decomposition, and CSS animation techniques.
An in‑depth look at how mattsta’s CRCSpeed implementation replaced Redis’s original CRC algorithm, delivering up to four‑fold speed gains, the history of its development from 2014 to its 2020 integration, and the performance impact on RDB generation and cluster slot hashing.
An ecosystem‑wide intelligent promotion system applies a budget‑pacing algorithm with probabilistic throttling and fine‑ranking score adjustments in 5‑minute slots, guaranteeing uniform video exposure while minimizing impact on overall consumption, boosting daily exposure completion from under 5 % to up to 70 % and reducing watch‑time loss.
This article explains how to implement a missile auto‑tracking system in a 2D shooting game using Python and Pygame, covering the underlying differential‑equation‑based algorithm, step‑by‑step calculations, handling of coordinate systems, and code for rotation and rendering.
This article walks through the classic “pick‑from‑both‑ends” apple game, analyzing why greedy choices fail, and presents recursive, memoized, and dynamic‑programming solutions in Go, complete with code examples and step‑by‑step explanations to help you determine the winning strategy.
The Vivo Internet Server Team extended TARS with a dynamic load‑balancing algorithm that recalculates each node’s weight every minute using metrics such as 5‑minute average response time, timeout and exception rates, CPU, memory and network load, automatically adapting traffic distribution beyond the built‑in round‑robin, weighted round‑robin and consistent‑hash methods.
This article details how Qingteng FM’s recommendation system progressed from manual curation to strategy‑based and personalized recommendations, explains the multi‑stage algorithm pipeline, describes the three‑layer deployment architecture, and outlines future challenges and opportunities in audio content recommendation.
This article introduces common rate‑limiting algorithms—counter, sliding‑window, leaky bucket, and token bucket—explains their principles, compares their advantages and drawbacks, and provides Java code examples, including how Sentinel 1.8.0 implements each technique using structures such as LeapArray and WarmUpController.
This article walks through the fundamentals of red‑black trees, explains their equivalence to 2‑3‑4 trees, details insertion and deletion algorithms, and shares practical debugging techniques to help readers implement and understand this complex balanced binary search tree.
This article walks through the fundamentals of red‑black trees, explains their equivalence to 2‑3‑4 trees, details insertion and deletion rules, compares their performance to plain binary search trees, and shares practical debugging tips for implementing a balanced tree in code.
This article explains the concept of full permutations, presents a classic interview problem requiring all permutations of a distinct integer array, and walks through a backtracking solution in Java with detailed step‑by‑step analysis and code examples.
This article explains the stack data structure, its LIFO characteristics, typical applications such as bracket matching, expression evaluation, next‑greater‑element problems, browser navigation, and JavaScript execution contexts, and provides clear JavaScript code examples for each scenario.
This article compiles a detailed set of 66 classic algorithm and data‑structure interview questions, each accompanied by problem statements, analysis of possible solutions, and illustrative code snippets, providing a valuable resource for developers preparing for technical interviews.
This article introduces the core concepts of algorithms, covering their definition, five essential properties, design principles such as correctness and readability, methods for analyzing time and space complexity, common complexity classes, and a variety of algorithmic strategies including recursion, dynamic programming, greedy and divide‑and‑conquer techniques.
This article presents a curated collection of 69 frequently asked algorithm and data‑structure interview questions, each accompanied by concise English explanations, solution ideas, and illustrative diagrams to help readers master core programming concepts and improve their interview performance.
This article introduces the fundamentals of bitwise operations, explains each operator with clear rules and examples, demonstrates practical tricks such as parity checks and value swapping, and walks through classic interview problems—including addition without arithmetic, counting set bits, and finding unique numbers—complete with Java code snippets and visual illustrations.
Given an array where each element indicates the maximum jump length from that position, this article explores multiple strategies—depth‑first search, dynamic programming, greedy, and reverse‑tracking—to determine whether the frog can reach the last board, comparing their efficiency and implementation details.
