Add rate limiter exercise

config.json

@@ -1900,6 +1900,14 @@
           "lists"
         ],
         "difficulty": 10
+      },
+      {
+        "slug": "rate-limiter",
+        "name": "rate-limiter",
+        "uuid": "b4b0c60e-4ce1-488e-948f-bcb6821c773c",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 1
       }
     ],
     "foregone": [

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

@@ -0,0 +1,12 @@
+What this exercise is about
+
+You will build a fixed‑window rate limiter: a small component that restricts how many
+operations each key may perform within a fixed period of time (a “window”).
+
+What you should implement
+
+- Implement a single method in `src/main/java/FixedWindowRateLimiter.java`:
+  - `public boolean allow(K key)` — decide whether to allow the operation for the key
+    and update the limiter’s internal state accordingly.
+
+Everything else (interfaces and constructor) is provided for you.

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

@@ -0,0 +1,19 @@
+{
+  "authors": [],
+  "files": {
+    "solution": [
+      "src/main/java/RateLimiter.java",
+      "src/main/java/TimeSource.java",
+      "src/main/java/FixedWindowRateLimiter.java"
+    ],
+    "test": [
+      "src/test/java/RateLimiterTest.java"
+    ],
+    "example": [
+      ".meta/src/reference/java/RateLimiter.java",
+      ".meta/src/reference/java/TimeSource.java",
+      ".meta/src/reference/java/FixedWindowRateLimiter.java"
+    ]
+  },
+  "blurb": ""
+}

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

@@ -0,0 +1,49 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class FixedWindowRateLimiter<K> implements RateLimiter<K> {
+
+    private static final class WindowState {
+        long windowStartNanos;
+        int usedCount;
+
+        WindowState(long windowStartNanos, int usedCount) {
+            this.windowStartNanos = windowStartNanos;
+            this.usedCount = usedCount;
+        }
+    }
+
+    private final int limit;
+    private final long windowSizeNanos;
+    private final TimeSource timeSource;
+    private final Map<K, WindowState> states = new HashMap<>();
+
+    public FixedWindowRateLimiter(int limit, long windowSizeNanos, TimeSource timeSource) {
+        this.limit = limit;
+        this.windowSizeNanos = windowSizeNanos;
+        this.timeSource = timeSource;
+    }
+
+    @Override
+    public boolean allow(K key) {
+        long now = timeSource.nowNanos();
+        WindowState s = states.get(key);
+        if (s == null) {
+            s = new WindowState(now, 0);
+            states.put(key, s);
+        }
+
+        long elapsed = now - s.windowStartNanos;
+        if (elapsed >= windowSizeNanos) {
+            s.windowStartNanos = now;
+            s.usedCount = 0;
+        }
+
+        if (s.usedCount < limit) {
+            s.usedCount += 1;
+            return true;
+        }
+        return false;
+    }
+}
+

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

@@ -0,0 +1,3 @@
+public interface RateLimiter<K> {
+    boolean allow(K key);
+}

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

@@ -0,0 +1,21 @@
+public interface TimeSource {
+    long nowNanos();
+
+    final class Fake implements TimeSource {
+        private long now;
+
+        public Fake(long startNanos) {
+            this.now = startNanos;
+        }
+
+        @Override
+        public long nowNanos() {
+            return now;
+        }
+
+        public void advance(long nanos) {
+            this.now += nanos;
+        }
+    }
+}
+

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/src/main/java/FixedWindowRateLimiter.java

@@ -0,0 +1,32 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class FixedWindowRateLimiter<K> implements RateLimiter<K> {
+
+    private static final class WindowState {
+        long windowStartNanos;
+        int usedCount;
+
+        WindowState(long windowStartNanos, int usedCount) {
+            this.windowStartNanos = windowStartNanos;
+            this.usedCount = usedCount;
+        }
+    }
+
+    private final int limit;
+    private final long windowSizeNanos;
+    private final TimeSource timeSource;
+    private final Map<K, WindowState> states = new HashMap<>();
+
+    public FixedWindowRateLimiter(int limit, long windowSizeNanos, TimeSource timeSource) {
+        this.limit = limit;
+        this.windowSizeNanos = windowSizeNanos;
+        this.timeSource = timeSource;
+    }
+
+    @Override
+    public boolean allow(K key) {
+        throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
+    }
+}
+

exercises/practice/rate-limiter/src/main/java/RateLimiter.java

@@ -0,0 +1,3 @@
+public interface RateLimiter<K> {
+    boolean allow(K key);
+}

exercises/practice/rate-limiter/src/main/java/TimeSource.java

@@ -0,0 +1,24 @@
+public interface TimeSource {
+    long nowNanos();
+
+    /**
+     * Deterministic fake clock for tests.
+     */
+    final class Fake implements TimeSource {
+        private long now;
+
+        public Fake(long startNanos) {
+            this.now = startNanos;
+        }
+
+        @Override
+        public long nowNanos() {
+            return now;
+        }
+
+        public void advance(long nanos) {
+            this.now += nanos;
+        }
+    }
+}
+

exercises/practice/rate-limiter/src/test/java/RateLimiterTest.java

@@ -0,0 +1,88 @@
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class RateLimiterTest {
+
+    @Test
+    void allowsUpToLimitThenDeniesUntilBoundary() {
+        TimeSource.Fake clock = new TimeSource.Fake(0L);
+        RateLimiter<String> limiter = new FixedWindowRateLimiter<>(3, 10_000L, clock);
+
+        assertThat(limiter.allow("A")).isTrue();
+        assertThat(limiter.allow("A")).isTrue();
+        assertThat(limiter.allow("A")).isTrue();
+        assertThat(limiter.allow("A")).isFalse();
+
+        // Just before boundary: still same window
+        clock.advance(9_999L);
+        assertThat(limiter.allow("A")).isFalse();
+
+        // At exact boundary: new window
+        clock.advance(1L);
+        assertThat(limiter.allow("A")).isTrue();
+    }
+
+    @Test
+    void continuesCountingWithinWindowAfterBoundaryReset() {
+        TimeSource.Fake clock = new TimeSource.Fake(0L);
+        RateLimiter<String> limiter = new FixedWindowRateLimiter<>(2, 5_000L, clock);
+
+        assertThat(limiter.allow("key")).isTrue();
+        assertThat(limiter.allow("key")).isTrue();
+        assertThat(limiter.allow("key")).isFalse();
+
+        // Jump to next window
+        clock.advance(5_000L);
+        assertThat(limiter.allow("key")).isTrue();
+        assertThat(limiter.allow("key")).isTrue();
+        assertThat(limiter.allow("key")).isFalse();
+    }
+
+    @Test
+    void separateKeysHaveIndependentCountersAndWindows() {
+        TimeSource.Fake clock = new TimeSource.Fake(42L);
+        RateLimiter<String> limiter = new FixedWindowRateLimiter<>(1, 100L, clock);
+
+        assertThat(limiter.allow("A")).isTrue();
+        assertThat(limiter.allow("B")).isTrue(); // independent key
+        assertThat(limiter.allow("A")).isFalse();
+        assertThat(limiter.allow("B")).isFalse();
+
+        clock.advance(100L); // new window for both at boundary
+        assertThat(limiter.allow("A")).isTrue();
+        assertThat(limiter.allow("B")).isTrue();
+    }
+
+    @Test
+    void longGapsResetWindowDeterministically() {
+        TimeSource.Fake clock = new TimeSource.Fake(1_000L);
+        RateLimiter<String> limiter = new FixedWindowRateLimiter<>(2, 50L, clock);
+
+        assertThat(limiter.allow("X")).isTrue();
+        assertThat(limiter.allow("X")).isTrue();
+        assertThat(limiter.allow("X")).isFalse();
+
+        // Advance several windows worth
+        clock.advance(1_000L);
+        assertThat(limiter.allow("X")).isTrue();
+        assertThat(limiter.allow("X")).isTrue();
+        assertThat(limiter.allow("X")).isFalse();
+    }
+
+    @Test
+    void exactBoundaryIsNewWindowEveryTime() {
+        TimeSource.Fake clock = new TimeSource.Fake(0L);
+        RateLimiter<String> limiter = new FixedWindowRateLimiter<>(1, 10L, clock);
+
+        assertThat(limiter.allow("k")).isTrue();
+        assertThat(limiter.allow("k")).isFalse();
+
+        // Move exactly to boundary repeatedly; each time should allow once
+        for (int i = 0; i < 5; i++) {
+            clock.advance(10L);
+            assertThat(limiter.allow("k")).isTrue();
+            assertThat(limiter.allow("k")).isFalse();
+        }
+    }
+}

exercises/settings.gradle

@@ -117,6 +117,7 @@ include 'practice:proverb'
 include 'practice:pythagorean-triplet'
 include 'practice:queen-attack'
 include 'practice:rail-fence-cipher'
+include 'practice:rate-limiter'
 include 'practice:raindrops'
 include 'practice:rational-numbers'
 include 'practice:react'