Skip to content

Solving the Two Water Jug Interview Question with Python

Updated: at 03:34 AM

The “two water jug problem” is a common technical interview question asked by companies like Google, Amazon, and Facebook to assess a candidate’s analytical thinking and problem-solving skills. This how-to guide will demonstrate how to thoroughly solve this programming brain teaser in Python step-by-step.

Table of Contents

Open Table of Contents

Overview of the Two Water Jug Problem

The two water jug problem presents the following scenario:

You have two jugs - a 4 gallon jug and a 3 gallon jug. Neither jug has any measuring markers on it. There is a pump that can be used to completely fill up either of the jugs with water. How can you measure exactly 2 gallons of water using just the two jugs and the pump?

This question tests your ability to think algorithmically and come up with an optimal solution given the constraints. The key skills assessed are:

While this may seem like a simple brain teaser, there are actually multiple solutions with varying levels of efficiency. A strong candidate will be able to code the most optimal solution in Python.


To follow this guide, you should have:

Setting up the Problem

Let’s break down the components of the problem:

Goal: Measure 2 gallons of water




We can model this scenario in Python with some simple variables and data structures:

# Jug sizes
jug4 = 4
jug3 = 3

# Amount goals
goal = 2

# Jug states
jug4_filled = 0
jug3_filled = 0

This represents our starting point. Now we need to figure out a sequence of steps using these variables to reach the goal amount.

Approaches to Solving the Problem

There are a few potential approaches one could take:

1. Brute Force

Try every single sequence of steps randomly until you get 2 gallons.

Pros: Simple to implement.

Cons: Extremely inefficient, will take a very long time for more complex problems. Wastes time and computing resources.

2. Backtracking Recursive Algorithm

Use recursion to incrementally try every possible sequence of steps. Backtrack when you hit a dead end.

Pros: Guaranteed to find the solution.

Cons: Can be slow and use a lot of memory for more complex problems.

3. Optimal Mathematical Solution

Analyze the problem and come up with the optimal sequence of steps mathematically.

Pros: Fastest and most efficient solution. Demonstrates strong analytical skills.

Cons: More complex to implement. Requires mathematical insight.

For demonstration purposes, we will walk through examples of both the backtracking recursive algorithm and the optimal mathematical solution.

Backtracking Recursive Solution

Here is one way to implement a backtracking recursive algorithm in Python:

def solve(jug4, jug3, goal, jug4_filled, jug3_filled):

  if jug4_filled == goal or jug3_filled == goal:
    return True

  if jug4_filled == jug4 or jug3_filled == jug3:
    return False

  # Try filling up jug4
  if solve(jug4, jug3, goal, jug4, jug3_filled):
    return True

  # Try filling up jug3
  if solve(jug4, jug3, goal, jug4_filled, jug3):
    return True

  # Try emptying jug4
  if solve(jug4, jug3, goal, 0, jug3_filled):
    return True

  # Try emptying jug3
  if solve(jug4, jug3, goal, jug4_filled, 0):
    return True

  # Try pouring jug4 into jug3
  pour_amount = min(jug4_filled, jug3 - jug3_filled)
  if solve(jug4, jug3, goal, jug4_filled - pour_amount, jug3_filled + pour_amount):
    return True

  # Try pouring jug3 into jug4
  pour_amount = min(jug3_filled, jug4 - jug4_filled)
  if solve(jug4, jug3, goal, jug4_filled + pour_amount, jug3_filled - pour_amount):
    return True

  # No solution found
  return False

This implements a depth-first search with backtracking. At each step, it tries all possible actions (fill, empty, pour) recursively until it either reaches the goal amount or hits a dead end. When it hits a dead end, it backtracks and tries a different path.

To find the solution:

print(solve(4, 3, 2, 0, 0))

This will print True once a solution sequence is found.

While this works, it is inefficient, since we are trying all possibilities without much direction. Let’s analyze the problem mathematically to find a more optimal solution.

Optimal Mathematical Solution

Upon closer analysis, we can make the following observations:

Using these insights, we can derive that:

  1. Fill the 3 gallon jug fully (3 gallons)
  2. Pour all its water into the 4 gallon jug (4 gallons)
  3. Fill the 3 gallon jug fully again (3 gallons)
  4. Pour enough water from it into the 4 gallon jug to total 2 gallons

This sequence of steps is guaranteed to reach the exact 2 gallon goal in the fewest steps.

Here is an implementation in Python:

print("Fill 3 gallon jug")
jug3_filled = 3
print("Pour 3 gallon jug into 4 gallon jug")
jug4_filled = jug3_filled
jug3_filled = 0

print("Fill 3 gallon jug again")
jug3_filled = 3
print("Pour from 3 gallon jug into 4 gallon jug until total reaches 2 gallons")
pour_amount = 2 - jug4_filled
jug4_filled += pour_amount
jug3_filled -= pour_amount

print("Jug 4 gallon amount:", jug4_filled)
print("Jug 3 gallon amount:", jug3_filled)

This prints:

Fill 3 gallon jug
Pour 3 gallon jug into 4 gallon jug
Fill 3 gallon jug again
Pour from 3 gallon jug into 4 gallon jug until total reaches 2 gallons
Jug 4 gallon amount: 2
Jug 3 gallon amount: 1

We reached the exact 2 gallon goal in only 4 steps optimally.

Evaluating and Improving Solutions

When evaluating solutions, some key criteria:

Some ways we could improve these solutions:


In this guide, we walked through a thorough approach to solving the two water jug technical interview question in Python:

Solving programming problems like this demonstrates strong analytical thinking, coding, and problem-solving abilities. With practice, you can master approaches to tackle various technical interview questions in Python. The key is to think step-by-step, optimize solutions, and cleanly implement them in code.