This article explains the LeetCode 1297 problem of finding the substring that appears most often while respecting limits on distinct characters and length, and provides a detailed sliding‑window analysis together with complete Java and C++ reference implementations.
This article explains the problem of finding the longest substring without repeating characters, demonstrates a brute‑force O(n³) solution with code, then introduces an optimized sliding‑window approach that runs in linear time O(n), including detailed implementation, complexity analysis, and key insights.
This article explains the principles and implementation details of common rate‑limiting algorithms—token bucket and sliding‑window counting—including their core concepts, key processes, Java code examples, and how to extend them to distributed scenarios with Redis Lua scripts.
This article walks through the complete system‑design process for a Douyin‑style video leaderboard, covering requirement analysis, functional and non‑functional specs, scale estimation, single‑machine baseline, fault‑tolerance, sharding, time‑window handling with a double‑pointer method, and caching strategies to achieve low latency, high throughput, and precise results at massive scale.
This article presents a complete, step‑by‑step analysis of a high‑concurrency Redis counter component that supports up to 100 000 QPS, covering business pain points, architectural design, two core counting strategies, sharding, local batch optimization, code walkthroughs, and performance benchmark results.
This article explains TCP’s flow control and congestion control mechanisms, detailing sliding window operation, zero‑window probing, SWS, window scaling, and the core congestion algorithms (slow start, congestion avoidance, fast retransmit/recovery), and clearly contrasts their purposes, scopes, and key variables.
This article walks through the end‑to‑end system design of a TikTok‑style video leaderboard, covering functional and non‑functional requirements, traffic estimation, single‑node prototypes, fault‑tolerant replication, sharding, elastic partitioning, sliding‑window counters, and caching strategies to achieve low‑latency, high‑throughput ranking at massive scale.
This article systematically compares the architectures of recent large language models—including DeepSeek V3/R1, OLMo 2, Gemma 3, Mistral Small 3.1, Llama 4, Qwen 3, SmolLM 3 and Kimi 2—highlighting innovations such as MLA, MoE, post‑norm, sliding‑window attention, NoPE and optimizer choices, with diagrams and code examples to illustrate their impact on efficiency and performance.
This article explains how to implement a precise sliding‑window rate‑limiting algorithm using Redis Sorted Sets, detailing the problem scenario, the algorithm steps, Lua script implementation, Java integration, and practical extensions for high‑performance backend services.
This article explains why per‑minute API call counting is essential for performance bottleneck detection, capacity planning, security alerts and billing, and presents five concrete Java‑based implementations—including a fixed‑window counter, a sliding‑window counter, AOP‑based transparent monitoring, a Redis time‑series solution, and Micrometer‑Prometheus integration—along with a hybrid architecture, performance benchmarks, and practical capacity‑planning advice.
This article introduces the sliding window technique, demonstrates efficient PHP implementations for computing averages and handling real-time streams, provides optimization strategies, and outlines practical applications such as financial analysis, network monitoring, and recommendation systems, highlighting performance considerations for backend development.
This article explains why rate limiting is essential for microservice reliability, outlines the key factors to consider before applying limits, compares major algorithms such as fixed‑window, sliding‑window, leaky‑bucket and token‑bucket, describes post‑limit actions, and details how Tencent Service Framework (TSF) implements configurable, tag‑based rate limiting in cloud‑native environments.
To prevent audit pipelines from choking during traffic surges, the article proposes augmenting the classic Chain of Responsibility with a sliding‑window anomaly detector, a statistically‑driven dynamic detector, a rule‑based backflow mechanism, and AI‑powered traffic forecasting, enabling adaptive routing and proactive scaling.
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 comprehensive guide delves into TCP’s core mechanisms—including header fields, segmentation and reassembly, the three‑way handshake and four‑step termination, sliding‑window flow and congestion control, retransmission strategies, and connection design patterns—providing a solid foundation for network engineers and developers.
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 explains the fundamental concepts of rate limiting, compares popular algorithms such as token bucket, leaky bucket, and sliding window, and reviews practical implementation methods including Nginx, middleware, Redis, Guava, and Tomcat configurations for both single‑machine and distributed environments.
This article explains the basic concepts, dimensions, and typical algorithms of rate limiting, discusses various implementation strategies such as token bucket, leaky bucket, and sliding window, and reviews practical solutions using Nginx, Guava, Redis, Sentinel, and Tomcat for both single‑node and distributed environments.
This article explains three Redis‑based rate‑limiting techniques—using SETNX, sorted sets, and a token‑bucket with lists—providing code examples, discussing their advantages and drawbacks, and showing how to integrate them into Java Spring applications to protect high‑concurrency services.
This article explains two sliding‑window rate‑limiting methods for SMS sending—one based on IP address and another on phone number—and provides a complete PHP implementation using Redis sorted sets to enforce per‑minute, per‑10‑minute, and per‑hour limits.
This guide explains the fundamental dimensions of rate limiting, compares token‑bucket, leaky‑bucket, and sliding‑window algorithms, and details practical implementations using Guava, Nginx, Redis, and Sentinel for both single‑node and distributed systems.
This article explains the fundamentals of rate limiting, describes widely used algorithms such as token bucket, leaky bucket, and sliding window, and details practical implementation methods ranging from single‑machine tools like Guava and Tomcat to distributed solutions using Nginx, Redis, and Sentinel.
This article explains TCP's retransmission mechanisms—including timeout retransmission, fast retransmit, SACK and D‑SACK—along with sliding window operation, window sizing, and congestion control algorithms such as slow start, congestion avoidance, and fast recovery, providing a comprehensive network fundamentals guide.
This article explains the sliding window rate‑limiting algorithm, its advantages over fixed windows, and provides a detailed step‑by‑step implementation using Sentinel’s data structures, including window partitioning, bucket management, concurrency handling, and calculation of request counts within a moving time interval.
This article explores the importance of rate limiting in distributed micro‑service architectures, explains four core algorithms—fixed window, sliding window, leaky bucket, and token bucket—and details a practical, Redis‑backed multi‑layer throttling solution for a voice‑bot platform, including trade‑offs and implementation tips.
This article explores three core rate‑limiting algorithms—Leaky Bucket, Token Bucket, and Sliding Window—detailing their principles, suitable scenarios, and provides complete Go implementations, enabling developers to choose and integrate the appropriate strategy for controlling request traffic without external dependencies.
This article explains how Alibaba Cloud Container Service for Kubernetes (ACK) uses container‑level resource profiling with half‑life sliding windows and quantile algorithms to automatically recommend accurate CPU and memory requests, improving cluster utilization while maintaining application stability.
This article introduces Alibaba's open‑source Sentinel framework, explains its ecosystem and key features, details the design of its high‑performance sliding‑window data structure (LeapArray) with Java code examples, and compares its flow‑control mechanism to Hystrix’s implementation.
This article continues the previous discussion on TCP handshakes and termination, then thoroughly explains nine essential TCP mechanisms—including sliding window, flow control, congestion control, delayed and piggyback ACKs, sticky packet handling, and keep‑alive—illustrated with diagrams and practical examples.
The article explains the concepts, problem scenarios, resource granularity, rule definition, sliding‑window calculation, and implementation flow of rate limiting and circuit breaking in microservice architectures and API gateways, providing practical guidance for building robust backend services.
This article explains the motivations, concepts, resource granularity, rule definitions, and two‑stage sliding‑window computation needed to design and implement effective rate limiting and circuit breaking mechanisms for microservice APIs and API gateways, ensuring isolated failures do not cascade across services.
This article explores why engineering skills outrank pure algorithm knowledge, explains the challenges of implementing flow‑control algorithms such as token bucket and sliding‑window rate limiting, and walks through Sentinel‑Go's concrete LeapArray implementation with detailed Go code examples.
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 three practical Redis-based rate‑limiting techniques—using SETNX for simple counters, ZSET for a sliding‑window algorithm, and a token‑bucket implementation with List—complete with Java code examples and discussion of their advantages and drawbacks.
This article explains three Redis‑based rate‑limiting methods—using SETNX, a ZSET sliding window, and a token‑bucket with List—provides Java code examples, and discusses their advantages, drawbacks, and how to integrate them into backend services.
This article explains four common rate‑limiting algorithms—fixed‑window counter, sliding window, leaky bucket, and token bucket—detailing their mechanisms, advantages, drawbacks such as the critical‑window problem, and how they can be implemented simply using Redis in backend systems.
This article explains the sliding‑window rate‑limiting technique used by Sentinel, presents a classic sliding‑window coding interview problem with a full Java solution, and then dives into Sentinel's internal classes such as WindowWrap, LeapArray, and MetricBucket to show how windows are created, updated, and slid over time.
This article explains the purpose, scenarios, and detailed implementations of common rate‑limiting algorithms—including counter (fixed window), sliding window, token bucket, and leaky bucket—highlighting their advantages, drawbacks, and sample Python code for each.
The article introduces the concept of rate limiting, explains why it is needed both offline (e.g., crowded theme parks) and online (e.g., flash sales), and details four common algorithms—counter, sliding window, leaky bucket, and token bucket—along with their implementation considerations and trade‑offs.
This article introduces a straightforward Java implementation of a sliding‑window rate‑limiting algorithm for single‑machine use, explains its core logic, demonstrates its behavior with sample output, and visualizes the step‑by‑step process of how timestamps are managed within the window.
Sentinel implements rate‑limiting through a chain‑of‑responsibility where annotated methods trigger SphU.entry, creating a Context, Node, and Entry; slots such as NodeSelectorSlot, ClusterBuilderSlot, StatisticSlot, and FlowSlot update sliding‑window metrics via LeapArray and enforce QPS thresholds, throwing BlockException on violations.
The article presents three scatter algorithms—column scatter, weight distribution, and sliding‑window—that reorder recommendation lists to disperse similar items, describing their mechanics, computational complexities, experimental trade‑offs, and a hybrid case study for efficient, multi‑dimensional list diversification.
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 Flink's sliding window mechanism, shows how the WindowAssigner and WindowOperator work with code examples, analyzes the performance impact of fine‑grained sliding windows, and proposes a practical workaround using tumbling windows combined with external storage such as Redis for efficient PV/UV aggregation.
This article explains how to design a distributed backend that ingests millions of clicks per second, stores data with Kafka and HDFS, computes top‑N articles using sliding windows and periodic aggregation, handles node failures, and mitigates click fraud, all while balancing accuracy and resource usage.
This article describes a flexible web crawler identification approach that combines sliding‑window data collection with Support Vector Machine classification, detailing the underlying concepts, feature extraction, system architecture, client‑server interaction, and deployment steps for practical use.
The author shares hands‑on experiences from a data‑mining contest, covering categorical feature handling, sliding‑window statistics, feature combination strategies, pandas performance tricks, file organization, and using nohup for remote Linux execution to improve model training efficiency.
This article explains how a rate‑limiting system can identify hot‑spot resources by using time‑window statistics, a concurrent LRU hash map, and cluster‑wide aggregation to efficiently track and evict low‑frequency keys while maintaining high throughput.
This article explains TCP fundamentals—including three‑way handshakes, sliding windows, and four‑way termination—then details how the RST flag works and how attackers can forge packets using source ports and sequence numbers to execute powerful RST denial‑of‑service attacks.
