Add rate limiter exercise

config.json

@@ -810,6 +810,14 @@
         ],
         "difficulty": 4
       },
+      {
+        "slug": "rate-limiter",
+        "name": "rate-limiter",
+        "uuid": "b4b0c60e-4ce1-488e-948f-bcb6821c773c",
+        "practices": [],
+        "prerequisites": ["generic-types"],
+        "difficulty": 4
+      },
       {
         "slug": "rotational-cipher",
         "name": "Rotational Cipher",

exercises/practice/rate-limiter/.docs/instructions.md

@@ -0,0 +1,23 @@
+# Instructions
+
+Your task is to build a fixed‑window rate limiter.
+
+Imagine a single server connected to one or more clients.
+A client sends a request, the server does some work, and returns a response.
+But processing takes time.
+If a client sends too many requests too quickly, the server can become overwhelmed — everything slows down or fails.
+
+A rate limiter is a small component that decides whether to allow or reject a request based on how frequently that client has been making requests.
+Different strategies exist; in this exercise you’ll implement a fixed‑window rate limiter.
+
+Fixed‑window rate limiting groups time into equal‑length windows (for example, every 10 seconds) and allows up to a certain number of requests within each window for each client.
+Once the window resets, the allowance refreshes for the next window.
+Each client is tracked separately, so another client can make requests within that same period.
+
+For example, consider a rate limiter configured to limit 2 requests per 10 seconds per client.
+Lets say a client sends a request: 
+
+- Being its first request, the request is permitted.
+- A second request within 10 seconds after the first one is also permitted.
+- However, further requests after that would be denied _until_ at least 10 seconds has elapsed since the first request.
+- If a second client sends its first request within 10 seconds with of the first client's first request, it would also be permitted, _regardless_ of whether the first client has sent a second request. 

exercises/practice/rate-limiter/.meta/config.json

@@ -0,0 +1,21 @@
+{
+  "authors": [
+    "andreatanky"
+  ],
+  "files": {
+    "solution": [
+      "src/main/java/RateLimiter.java"
+    ],
+    "test": [
+      "src/test/java/RateLimiterTest.java"
+    ],
+    "example": [
+      ".meta/src/reference/java/RateLimiter.java",
+      ".meta/src/reference/java/TimeSource.java"
+    ],
+    "editor": [
+      "src/main/java/TimeSource.java"
+    ]
+  },
+  "blurb": "Practice stateful logic and time handling by implementing a fixed-window rate limiter"
+}

exercises/practice/rate-limiter/.meta/src/reference/java/RateLimiter.java

@@ -0,0 +1,49 @@
+import java.time.Duration;
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+
+public class RateLimiter<K> {
+
+    private static final class WindowState {
+        Instant windowStart;
+        int usedCount;
+
+        WindowState(Instant windowStart, int usedCount) {
+            this.windowStart = windowStart;
+            this.usedCount = usedCount;
+        }
+    }
+
+    private final int limit;
+    private final Duration windowSize;
+    private final TimeSource timeSource;
+    private final Map<K, WindowState> states = new HashMap<>();
+
+    public RateLimiter(int limit, Duration windowSize, TimeSource timeSource) {
+        this.limit = limit;
+        this.windowSize = windowSize;
+        this.timeSource = timeSource;
+    }
+
+    public boolean allow(K clientId) {
+        Instant now = timeSource.now();
+
+        WindowState s = states.get(clientId);
+        if (s == null) {
+            s = new WindowState(now, 0);
+            states.put(clientId, s);
+        }
+
+        if (!now.isBefore(s.windowStart.plus(windowSize))) {
+            s.windowStart = now;
+            s.usedCount = 0;
+        }
+
+        if (s.usedCount < limit) {
+            s.usedCount += 1;
+            return true;
+        }
+        return false;
+    }
+}

exercises/practice/rate-limiter/.meta/src/reference/java/TimeSource.java

@@ -0,0 +1,18 @@
+import java.time.Duration;
+import java.time.Instant;
+
+public class TimeSource {
+    private Instant now;
+
+    public TimeSource(Instant start) {
+        this.now = start;
+    }
+
+    public Instant now() {
+        return now;
+    }
+
+    public void advance(Duration d) {
+        this.now = this.now.plus(d);
+    }
+}

exercises/practice/rate-limiter/build.gradle

@@ -0,0 +1,25 @@
+plugins {
+    id "java"
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testImplementation platform("org.junit:junit-bom:5.10.0")
+    testImplementation "org.junit.jupiter:junit-jupiter"
+    testImplementation "org.assertj:assertj-core:3.25.1"
+
+    testRuntimeOnly "org.junit.platform:junit-platform-launcher"
+}
+
+test {
+    useJUnitPlatform()
+
+    testLogging {
+        exceptionFormat = "full"
+        showStandardStreams = true
+        events = ["passed", "failed", "skipped"]
+    }
+}

exercises/practice/rate-limiter/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists