Update tests two bucket

exercises/practice/two-bucket/.meta/config.json

@@ -4,8 +4,10 @@
   ],
   "contributors": [
     "FridaTveit",
+    "jagdish-15",
     "jmrunkle",
     "lemoncurry",
+    "LoadingBG",
     "mirkoperillo",
     "msomji",
     "muzimuzhi",

exercises/practice/two-bucket/.meta/src/reference/java/TwoBucket.java

@@ -1,149 +1,140 @@
 import java.util.ArrayList;
-import java.util.Objects;
+import java.util.List;
+import java.util.Map;
 
 class TwoBucket {
-
-    private class State {
-        int moves;
-        int bucketOne;
-        int bucketTwo;
-
-        State (int moves, int bucketOne, int bucketTwo) {
-            this.moves = moves;
-            this.bucketOne = bucketOne;
-            this.bucketTwo = bucketTwo;
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            State otherState = (State) o;
-            return this.moves == otherState.moves &&
-                    this.bucketOne == otherState.bucketOne &&
-                    this.bucketTwo == otherState.bucketTwo;
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(moves, bucketOne, bucketTwo);
-        }
-    }
-
-    private State finalState;
-
-    private int bucketOneCap;
-    private int bucketTwoCap;
-    private int desiredLiters;
-    private String startBucket;
-
+    private int totalMoves = Integer.MAX_VALUE;
+    private String finalBucket = "";
+    private int otherBucket = Integer.MAX_VALUE;
+
+    private final int bucketOneCap;
+    private final int bucketTwoCap;
+    private final int desiredLiters;
+
     TwoBucket(int bucketOneCap, int bucketTwoCap, int desiredLiters, String startBucket) {
+        fillBuckets(
+            startBucket.equals("one") ? bucketOneCap : 0,
+            bucketOneCap,
+            startBucket.equals("two") ? bucketTwoCap : 0,
+            bucketTwoCap,
+            desiredLiters,
+            1,
+            startBucket
+        );
+
         this.bucketOneCap = bucketOneCap;
         this.bucketTwoCap = bucketTwoCap;
         this.desiredLiters = desiredLiters;
-        this.startBucket = startBucket;
-
-        finalState = computeFinalState();
     }
 
-    private ArrayList<State> getAdjacentStates (State state) {
-        ArrayList<State> adjacentStates = new ArrayList<State>();
-
-        //Empty bucket one
-        adjacentStates.add(new State(state.moves + 1, 0, state.bucketTwo));
-
-        //Empty bucket two
-        adjacentStates.add(new State(state.moves + 1, state.bucketOne, 0));
-
-        //Fill bucket one
-        adjacentStates.add(new State(state.moves + 1, bucketOneCap, state.bucketTwo));
+    private List<Map.Entry<Integer, Integer>> statesReached = new ArrayList<>();
+
+    private void fillBuckets(
+        int bucketOne,
+        int bucketOneCap,
+        int bucketTwo,
+        int bucketTwoCap,
+        int desiredLiters,
+        int actionsTaken,
+        String startingBucket
+    ) {
+        if (startingBucket.equals("one") && bucketOne == 0 && bucketTwo == bucketTwoCap
+            || startingBucket.equals("two") && bucketTwo == 0 && bucketOne == bucketOneCap
+            || statesReached.contains(Map.entry(bucketOne, bucketTwo))
+            || bucketOne > bucketOneCap
+            || bucketTwo > bucketTwoCap) {
+            return;
+        }
+
+        if (bucketOne == desiredLiters) {
+            if (actionsTaken < totalMoves) {
+                this.totalMoves = actionsTaken;
+                this.finalBucket = "one";
+                this.otherBucket = bucketTwo;
+            }
+            return;
+        }
+        if (bucketTwo == desiredLiters) {
+            if (actionsTaken < totalMoves) {
+                this.totalMoves = actionsTaken;
+                this.finalBucket = "two";
+                this.otherBucket = bucketOne;
+            }
+            return;
+        }
 
-        //Fill bucket two
-        adjacentStates.add(new State(state.moves + 1, state.bucketOne, bucketTwoCap));
+        statesReached.add(Map.entry(bucketOne, bucketTwo));
 
-        //pour from bucket one to bucket two
-        if (state.bucketOne + state.bucketTwo > bucketTwoCap) {
-            adjacentStates.add(new State(state.moves + 1,
-                                         state.bucketOne - (bucketTwoCap - state.bucketTwo),
-                                         bucketTwoCap));
-        } else {
-            adjacentStates.add(new State(state.moves + 1, 0, state.bucketOne + state.bucketTwo));
+        if (bucketOne != 0) {
+            fillBuckets(0, bucketOneCap, bucketTwo, bucketTwoCap, desiredLiters, actionsTaken + 1, startingBucket);
         }
-
-        //pour from bucket two to bucket one
-        if (state.bucketTwo + state.bucketOne > bucketOneCap) {
-            adjacentStates.add(new State(state.moves + 1,
-                                         bucketOneCap,
-                                         state.bucketTwo - (bucketOneCap - state.bucketOne)));
-        } else {
-            adjacentStates.add(new State(state.moves + 1, state.bucketTwo + state.bucketOne, 0));
+        if (bucketTwo != 0) {
+            fillBuckets(bucketOne, bucketOneCap, 0, bucketTwoCap, desiredLiters, actionsTaken + 1, startingBucket);
         }
 
-        return adjacentStates;
-    }
-
-    private boolean isValid(State state) {
-        if (state.bucketOne == bucketOneCap && state.bucketTwo == 0 && startBucket.equals("two")) {
-            return false;
-        } else if (state.bucketOne == 0 && state.bucketTwo == bucketTwoCap && startBucket.equals("two")) {
-            return false;
+        fillBuckets(
+            bucketOneCap, bucketOneCap, bucketTwo, bucketTwoCap, desiredLiters, 
+            actionsTaken + 1, startingBucket
+        );
+        fillBuckets(
+            bucketOne, bucketOneCap, bucketTwoCap, bucketTwoCap, desiredLiters, 
+            actionsTaken + 1, startingBucket
+        );
+
+        if (bucketOne + bucketTwo <= bucketTwoCap) {
+            fillBuckets(
+                0, bucketOneCap, bucketTwo + bucketOne, bucketTwoCap, desiredLiters, 
+                actionsTaken + 1, startingBucket
+            );
         } else {
-            return true;
+            fillBuckets(
+                bucketOne + bucketTwo - bucketTwoCap, bucketOneCap, bucketTwoCap, bucketTwoCap, 
+                desiredLiters, actionsTaken + 1, startingBucket
+            );
         }
-    }
-
-    private State computeFinalState() {
-        ArrayList<State> paths = new ArrayList<State>();
-
-        State initialState;
-        if (startBucket.equals("one")) {
-            initialState = new State(1, bucketOneCap, 0);
+        if (bucketOne + bucketTwo <= bucketOneCap) {
+            fillBuckets(
+                bucketOne + bucketTwo, bucketOneCap, 0, bucketTwoCap, desiredLiters, 
+                actionsTaken + 1, startingBucket
+            );
         } else {
-            initialState = new State(1, 0, bucketTwoCap);
+            fillBuckets(
+                bucketOneCap, bucketOneCap, bucketTwo + bucketOne - bucketOneCap, bucketTwoCap, 
+                desiredLiters, actionsTaken + 1, startingBucket
+            );
         }
+    }
 
-        if (initialState.bucketOne == desiredLiters || initialState.bucketTwo == desiredLiters) {
-            return initialState;
+    private void checkIfImpossible() {
+        boolean exceedsCapacity = desiredLiters > bucketOneCap && desiredLiters > bucketTwoCap;
+        boolean invalidDivision = desiredLiters % gcd(bucketOneCap, bucketTwoCap) != 0;
+
+        if (exceedsCapacity || invalidDivision) {
+            throw new IllegalArgumentException("impossible");
         }
+    }
 
-        paths.add(initialState);
-
-        for (int i = 0; i < 10000; i++) {
-            State currentState = paths.remove(0);
-            ArrayList<State> adjacentStates = getAdjacentStates(currentState);
-            for (State state : adjacentStates) {
-                if (state.bucketOne == desiredLiters || state.bucketTwo == desiredLiters) {
-                    return state;
-                }
-
-                if (!paths.contains(state) && isValid(state)) {
-                    paths.add(state);
-                }
-            }
+    private int gcd(int a, int b) {
+        while (b != 0) {
+            int temp = b;
+            b = a % b;
+            a = temp;
         }
-
-        return null;
+        return a;
     }
 
     int getTotalMoves() {
-        return finalState.moves;
+        checkIfImpossible();
+        return totalMoves;
     }
 
     String getFinalBucket() {
-        if (finalState.bucketOne == desiredLiters) {
-            return "one";
-        } else if (finalState.bucketTwo == desiredLiters) {
-            return "two";
-        } else {
-            return "No solution found in " + finalState.moves + " iterations!";
-        }
+        checkIfImpossible();
+        return finalBucket;
     }
 
     int getOtherBucket() {
-        if (getFinalBucket().equals("one")) {
-            return finalState.bucketTwo;
-        } else if (getFinalBucket().equals("two")) {
-            return finalState.bucketOne;
-        } else {
-            return -1;
-        }
+        checkIfImpossible();
+        return otherBucket;
     }
 }

exercises/practice/two-bucket/.meta/tests.toml

@@ -1,6 +1,13 @@
-# This is an auto-generated file. Regular comments will be removed when this
-# file is regenerated. Regenerating will not touch any manually added keys,
-# so comments can be added in a "comment" key.
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
 
 [a6f2b4ba-065f-4dca-b6f0-e3eee51cb661]
 description = "Measure using bucket one of size 3 and bucket two of size 5 - start with bucket one"
@@ -19,3 +26,12 @@ description = "Measure one step using bucket one of size 1 and bucket two of siz
 
 [eb329c63-5540-4735-b30b-97f7f4df0f84]
 description = "Measure using bucket one of size 2 and bucket two of size 3 - start with bucket one and end with bucket two"
+
+[449be72d-b10a-4f4b-a959-ca741e333b72]
+description = "Not possible to reach the goal"
+
+[aac38b7a-77f4-4d62-9b91-8846d533b054]
+description = "With the same buckets but a different goal, then it is possible"
+
+[74633132-0ccf-49de-8450-af4ab2e3b299]
+description = "Goal larger than both buckets is impossible"

exercises/practice/two-bucket/src/test/java/TwoBucketTest.java

@@ -2,6 +2,7 @@
 import org.junit.jupiter.api.Test;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
 public class TwoBucketTest {
 
@@ -75,4 +76,52 @@ public void testBucketOneSizeTwoBucketTwoSizeThreeStartWithOne() {
         assertThat(twoBucket.getOtherBucket()).isEqualTo(2);
 
     }
+
+    @Disabled("Remove to run test")
+    @Test
+    public void testReachingGoalIsImpossible() {
+
+        TwoBucket twoBucket = new TwoBucket(6, 15, 5, "one");
+
+        assertThatExceptionOfType(IllegalArgumentException.class)
+                .isThrownBy(() -> twoBucket.getTotalMoves())
+                .withMessage("impossible");
+        assertThatExceptionOfType(IllegalArgumentException.class)
+                .isThrownBy(() -> twoBucket.getFinalBucket())
+                .withMessage("impossible");
+        assertThatExceptionOfType(IllegalArgumentException.class)
+                .isThrownBy(() -> twoBucket.getOtherBucket())
+                .withMessage("impossible");
+
+    }
+
+    @Disabled("Remove to run test")
+    @Test
+    public void testBucketOneSizeSixBucketTwoSizeFifteenStartWithOne() {
+
+        TwoBucket twoBucket = new TwoBucket(6, 15, 9, "one");
+
+        assertThat(twoBucket.getTotalMoves()).isEqualTo(10);
+        assertThat(twoBucket.getFinalBucket()).isEqualTo("two");
+        assertThat(twoBucket.getOtherBucket()).isEqualTo(0);
+
+    }   
+
+    @Disabled("Remove to run test")
+    @Test
+    public void testGoalLargerThanBothBucketsIsImpossible() {
+
+        TwoBucket twoBucket = new TwoBucket(5, 7, 8, "one");
+
+        assertThatExceptionOfType(IllegalArgumentException.class)
+                .isThrownBy(() -> twoBucket.getTotalMoves())
+                .withMessage("impossible");
+        assertThatExceptionOfType(IllegalArgumentException.class)
+                .isThrownBy(() -> twoBucket.getFinalBucket())
+                .withMessage("impossible");
+        assertThatExceptionOfType(IllegalArgumentException.class)
+                .isThrownBy(() -> twoBucket.getOtherBucket())
+                .withMessage("impossible");
+
+    }
 }