Add split-second-stopwatch exercise #2968

Add split-second-stopwatch exercise

Implement the split-second-stopwatch practice exercise with:
- State management (ready/running/stopped)
- Time tracking for current lap and total elapsed time
- Lap functionality with previous laps history
- Start, stop, reset operations with proper state validation
- Error handling for invalid state transitions
- Time formatting in HH:MM:SS format
- Mock time advancement for testing

Includes reference solution, starter implementation, and comprehensive test suite covering all canonical data test cases.

Author: EmmanuelBerkowicz

exercises/practice/split-second-stopwatch/.docs/instructions.md

@@ -0,0 +1,22 @@
+# Instructions
+
+Your task is to build a stopwatch to keep precise track of lap times.
+
+The stopwatch uses four commands (start, stop, lap, and reset) to keep track of:
+
+1. The current lap's tracked time
+2. Previously recorded lap times
+
+What commands can be used depends on which state the stopwatch is in:
+
+1. Ready: initial state
+2. Running: tracking time
+3. Stopped: not tracking time
+
+| Command | Begin state | End state | Effect                                                   |
+| ------- | ----------- | --------- | -------------------------------------------------------- |
+| Start   | Ready       | Running   | Start tracking time                                      |
+| Start   | Stopped     | Running   | Resume tracking time                                     |
+| Stop    | Running     | Stopped   | Stop tracking time                                       |
+| Lap     | Running     | Running   | Add current lap to previous laps, then reset current lap |
+| Reset   | Stopped     | Ready     | Reset current lap and clear previous laps                |

exercises/practice/split-second-stopwatch/.docs/introduction.md

@@ -0,0 +1,6 @@
+# Introduction
+
+You've always run for the thrill of it — no schedules, no timers, just the sound of your feet on the pavement.
+But now that you've joined a competitive running crew, things are getting serious.
+Training sessions are timed to the second, and every split second counts.
+To keep pace, you've picked up the _Split-Second Stopwatch_ — a sleek, high-tech gadget that's about to become your new best friend.

exercises/practice/split-second-stopwatch/.meta/config.json

@@ -0,0 +1,22 @@
+{
+  "authors": [
+    "Jagdish Prajapati, Kah Goh & Emmanuel Berkowicz"
+  ],
+  "files": {
+    "solution": [
+      "src/main/java/SplitSecondStopwatch.java"
+    ],
+    "test": [
+      "src/test/java/SplitSecondStopwatch.java"
+    ],
+    "example": [
+      ".meta/src/reference/java/SplitSecondStopwatch.java"
+    ],
+    "invalidator": [
+      "build.gradle"
+    ]
+  },
+  "blurb": "Time to create a new and improved split second stopwatch using your friendly neighbourhood OOP language!.",
+  "source": "Emmanuel Berkowicz",
+  "source_url": "https://github.com/exercism/problem-specifications/tree/main/exercises/split-second-stopwatch"
+}

exercises/practice/split-second-stopwatch/.meta/src/reference/java/SplitSecondStopwatch.java

@@ -0,0 +1,123 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class SplitSecondStopwatch {
+
+    /**
+     * A split-second stopwatch that tracks elapsed time with lap functionality.
+     * Supports start, stop, reset, and lap operations with precise time tracking.
+     * Times are formatted in HH:MM:SS format with two-digit precision.
+     *
+     * @see <a href="https://github.com/exercism/problem-specifications/tree/main/exercises/split-second-stopwatch">
+     * Problem Specifications
+     * </a>
+     */
+
+    private enum State { READY, RUNNING, STOPPED }
+
+    private State state;
+    private long totalElapsed;
+    private long currentLapStart;
+    private long lastStopTime;
+    private List<String> previousLaps;
+    private long mockTime;
+
+    public SplitSecondStopwatch() {
+        this.state = State.READY;
+        this.totalElapsed = 0;
+        this.currentLapStart = 0;
+        this.lastStopTime = 0;
+        this.previousLaps = new ArrayList<>();
+        this.mockTime = 0;
+    }
+
+    public void start() {
+        if (state == State.RUNNING) {
+            throw new IllegalStateException("cannot start an already running stopwatch");
+        }
+
+        if (state == State.READY) {
+            currentLapStart = mockTime;
+        } else if (state == State.STOPPED) {
+            long pausedDuration = mockTime - lastStopTime;
+            currentLapStart += pausedDuration;
+        }
+
+        state = State.RUNNING;
+    }
+
+    public void stop() {
+        if (state != State.RUNNING) {
+            throw new IllegalStateException("cannot stop a stopwatch that is not running");
+        }
+
+        lastStopTime = mockTime;
+        totalElapsed += mockTime - currentLapStart;
+        state = State.STOPPED;
+    }
+
+    public void reset() {
+        if (state != State.STOPPED) {
+            throw new IllegalStateException("cannot reset a stopwatch that is not stopped");
+        }
+
+        state = State.READY;
+        totalElapsed = 0;
+        currentLapStart = 0;
+        lastStopTime = 0;
+        previousLaps.clear();
+    }
+
+    public void lap() {
+        if (state != State.RUNNING) {
+            throw new IllegalStateException("cannot lap a stopwatch that is not running");
+        }
+
+        long currentLapTime = mockTime - currentLapStart;
+        previousLaps.add(formatTime(currentLapTime));
+        currentLapStart = mockTime;
+    }
+
+    public String state() {
+        return state.name().toLowerCase();
+    }
+
+    public String currentLap() {
+        if (state == State.RUNNING) {
+            return formatTime(mockTime - currentLapStart);
+        } else {
+            return formatTime(lastStopTime - currentLapStart);
+        }
+    }
+
+    public String total() {
+        if (state == State.RUNNING) {
+            return formatTime(totalElapsed + (mockTime - currentLapStart));
+        } else {
+            return formatTime(totalElapsed);
+        }
+    }
+
+    public List<String> previousLaps() {
+        return new ArrayList<>(previousLaps);
+    }
+
+    public void advanceTime(String timeString) {
+        String[] parts = timeString.split(":");
+        long hours = Long.parseLong(parts[0]);
+        long minutes = Long.parseLong(parts[1]);
+        long seconds = Long.parseLong(parts[2]);
+
+        long milliseconds = (hours * 3600 + minutes * 60 + seconds) * 1000;
+        mockTime += milliseconds;
+    }
+
+    private String formatTime(long milliseconds) {
+        long totalSeconds = milliseconds / 1000;
+        long hours = totalSeconds / 3600;
+        long minutes = (totalSeconds % 3600) / 60;
+        long seconds = totalSeconds % 60;
+
+        return String.format("%02d:%02d:%02d", hours, minutes, seconds);
+    }
+}

exercises/practice/split-second-stopwatch/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/split-second-stopwatch/gradle/wrapper/gradle-wrapper.jar

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