Water and Jug Problem - Practice Coding Problems

Water and Jug Problem - Problem

You're standing at a river with two empty jugs and need to measure exactly target liters of water. The first jug holds x liters, the second holds y liters, and you have an unlimited water supply from the river.

Your available operations are:

Fill either jug completely with water
Empty either jug completely
Pour water from one jug to another until either the source jug is empty or the target jug is full

The question is: Can you measure exactly target liters using these operations?

For example, with a 3-liter jug and 5-liter jug, you can measure exactly 4 liters by filling the 5L jug, pouring into 3L jug (leaving 2L in the 5L jug), emptying the 3L jug, pouring the 2L into it, then filling the 5L jug again and pouring 1L into the 3L jug, leaving exactly 4L!

Input & Output

example_1.py — Standard Case

$ Input: x = 3, y = 5, target = 4

› Output: true

💡 Note: Fill 5L jug → Pour into 3L jug (2L remains) → Empty 3L jug → Pour 2L into 3L jug → Fill 5L jug → Pour 1L into 3L jug, leaving exactly 4L in the 5L jug

example_2.py — Impossible Case

$ Input: x = 2, y = 6, target = 5

› Output: false

💡 Note: GCD(2,6) = 2, and 5 is not divisible by 2, so it's impossible to measure exactly 5L using 2L and 6L jugs

example_3.py — Edge Case

$ Input: x = 1, y = 2, target = 3

› Output: true

💡 Note: Fill both jugs completely: 1L + 2L = 3L exactly

Visualization

Tap to expand

Understanding the Visualization

Identify Operations

We have 6 possible operations: fill jug A, fill jug B, empty jug A, empty jug B, pour A→B, pour B→A

State Space

Each state is represented as (amount_in_A, amount_in_B). BFS explores all reachable states

Mathematical Insight

The problem reduces to Bézout's identity: can we express target as ax + by for integers a,b?

GCD Connection

The answer is YES iff target is divisible by GCD(x,y) and target ≤ x+y

Key Takeaway

🎯 Key Insight: This classic puzzle is actually a number theory problem! The GCD determines the 'granularity' of measurements possible, and any target that's a multiple of this GCD (within capacity limits) can be achieved through the pouring operations.

Time & Space Complexity

Time Complexity

⏱️

O(log(min(x,y)))

Time complexity of GCD calculation using Euclidean algorithm

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables

✓ Linear Space

Constraints

1 ≤ x, y ≤ 10³
0 ≤ target ≤ x + y
Note: Jugs cannot be partially filled

Asked in

G Google 25 ⊞ Microsoft 18 a Amazon 15 Apple 12

The optimal solution uses number theory and Bézout's identity. The key insight is that we can measure exactly target liters if and only if target is divisible by GCD(x,y) and doesn't exceed the total capacity. This reduces the problem from state exploration to a simple mathematical check in O(log(min(x,y))) time.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Solution (GCD)	O(log(min(x,y)))	O(1)	Use number theory: target is achievable if it's a multiple of GCD(x,y)

Mathematical Solution (GCD) — Algorithm Steps

Handle edge cases: target = 0, or one jug is 0
Calculate GCD(x, y) using Euclidean algorithm
Check if target is divisible by GCD
Ensure target doesn't exceed total capacity x+y

Visualization

Tap to expand

Step-by-Step Walkthrough

Bézout's Identity

Any achievable amount can be written as ax + by

GCD Property

GCD(x,y) is the smallest positive measurable amount

Divisibility Check

Target must be a multiple of GCD to be achievable

Code -

solution.c — C

#include <stdio.h>
#include <stdbool.h>

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

bool canMeasureWater(int x, int y, int target) {
    if (target == 0) return true;
    if (target > x + y) return false;
    if (x == 0) return y == target;
    if (y == 0) return x == target;
    
    return target % gcd(x, y) == 0;
}

int main() {
    int x, y, target;
    scanf("%d %d %d", &x, &y, &target);
    printf("%s\n", canMeasureWater(x, y, target) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log(min(x,y)))

Time complexity of GCD calculation using Euclidean algorithm

⚡ Linearithmic

Space Complexity

O(1)

Only using a few variables

✓ Linear Space

Constraints

1 ≤ x, y ≤ 10³
0 ≤ target ≤ x + y
Note: Jugs cannot be partially filled

21.5K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Mathematical Solution (GCD) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler