Area chart with plt.fill_between in Matplotlib - Time & Space Complexity

Time Complexity: Area chart with plt.fill_between

O(n)

Understanding Time Complexity

We want to understand how the time to draw an area chart changes as we add more data points.

How does the drawing time grow when the data size grows?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 1000)
y1 = np.sin(x)
y2 = np.sin(x) + 1

plt.fill_between(x, y1, y2)
plt.show()

This code draws an area chart by filling the space between two curves defined by y1 and y2 over x.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Iterating over the data points in arrays x, y1, and y2 to fill the area.
• How many times: Once for each data point, so as many times as the length of x (here 1000).

How Execution Grows With Input

As the number of data points increases, the number of operations to fill the area grows roughly the same.

Input Size (n)	Approx. Operations
10	About 10 fill steps
100	About 100 fill steps
1000	About 1000 fill steps

Pattern observation: The work grows linearly as the number of points increases.

Final Time Complexity

Time Complexity: O(n)

This means the time to draw the area grows directly in proportion to the number of data points.

Common Mistake

[X] Wrong: "Adding more points won't affect drawing time much because it's just one fill call."

[OK] Correct: The fill_between function processes each data point to create the filled area, so more points mean more work.

Interview Connect

Understanding how plotting functions scale with data size helps you write efficient code and explain performance clearly.

Self-Check

"What if we used fewer points but more complex shapes? How would the time complexity change?"

Practice

1. What does the plt.fill_between function do in matplotlib?

easy

A. It fills the area between two curves or a curve and a baseline.

B. It creates a scatter plot with filled markers.

C. It draws a bar chart with filled bars.

D. It adds grid lines to the plot.

Solution

1. Step 1: Understand the purpose of plt.fill_between

   The function plt.fill_between is designed to fill the area between two lines or between a line and a baseline, creating an area chart effect.

2. Step 2: Compare with other plot types

   Scatter plots, bar charts, and grid lines are created by different functions like plt.scatter, plt.bar, and plt.grid, not plt.fill_between.

3. Final Answer:

   It fills the area between two curves or a curve and a baseline. -> Option A

4. Quick Check:

   plt.fill_between fills area under curve [OK]

Hint: Remember: fill_between fills area under or between lines [OK]

Common Mistakes:

• Confusing fill_between with scatter or bar plot functions
• Thinking it adds grid lines
• Assuming it only fills under a single line without baseline

2. Which of the following is the correct syntax to fill the area between x and y values using matplotlib?

easy

A. plt.fill_between(y, x)

B. plt.fill_between(x, y, color='blue')

C. plt.fill(x, y)

D. plt.fill_between(x)

Solution

1. Step 1: Check the required parameters of plt.fill_between

   The function requires at least two arrays: x (horizontal axis) and y (vertical values). plt.fill_between(x, y, color='blue') correctly uses plt.fill_between(x, y, color='blue') which is valid syntax with an optional color argument.

2. Step 2: Identify incorrect options

   plt.fill(x, y) uses the incorrect function plt.fill instead of plt.fill_between. plt.fill_between(y, x) reverses the x and y parameters, which is incorrect. plt.fill_between(x) misses the y values, causing an error.

3. Final Answer:

   plt.fill_between(x, y, color='blue') -> Option B

4. Quick Check:

   Correct syntax includes x, y, and optional color [OK]

Hint: Syntax: plt.fill_between(x, y, color='color') [OK]

Common Mistakes:

• Using plt.fill instead of plt.fill_between
• Swapping x and y parameters
• Omitting y values

3. What will the following code produce?

import matplotlib.pyplot as plt
x = [1, 2, 3, 4]
y1 = [1, 3, 2, 4]
y2 = [0, 1, 1, 2]
plt.fill_between(x, y1, y2, color='green', alpha=0.5)
plt.show()

medium

A. A scatter plot of points from y1 and y2.

B. A green line plot of y1 with alpha transparency.

C. An error because plt.fill_between cannot take two y arrays.

D. A green shaded area between y1 and y2 curves with 50% transparency.

Solution

1. Step 1: Understand plt.fill_between with two y arrays

   When two y arrays are given, plt.fill_between fills the area between these two curves along the x-axis.

2. Step 2: Analyze color and alpha parameters

   The color is set to green and alpha=0.5 means 50% transparency, so the filled area will appear as a translucent green band between y1 and y2.

3. Final Answer:

   A green shaded area between y1 and y2 curves with 50% transparency. -> Option D

4. Quick Check:

   Two y arrays fill area between curves [OK]

Hint: Two y arrays fill area between curves with color and alpha [OK]

Common Mistakes:

• Thinking it plots lines instead of filled area
• Assuming alpha controls line thickness
• Believing plt.fill_between cannot take two y arrays

4. Identify the error in this code snippet:

import matplotlib.pyplot as plt
x = [1, 2, 3]
y = [2, 3]
plt.fill_between(x, y)
plt.show()

medium

A. plt.fill_between cannot be used without plt.plot first.

B. plt.fill_between requires a color argument.

C. x and y arrays have different lengths causing a ValueError.

D. No error; the code runs fine.

Solution

1. Step 1: Check array lengths for plt.fill_between

   The x array has 3 elements, but y has only 2. This mismatch causes a ValueError because the function expects arrays of equal length.

2. Step 2: Verify other requirements

   Color argument is optional, and plt.plot is not required before fill_between. So options B and C are incorrect.

3. Final Answer:

   x and y arrays have different lengths causing a ValueError. -> Option C

4. Quick Check:

   Array length mismatch causes error [OK]

Hint: Ensure x and y arrays have same length [OK]

Common Mistakes:

• Ignoring array length mismatch
• Thinking color is mandatory
• Assuming plt.plot must be called first

5. You want to create an area chart showing the difference between two datasets y1 and y2 over x, but only fill where y1 is greater than y2. Which code snippet correctly achieves this?

hard

A. plt.fill_between(x, y1, y2, where=(y1 > y2), color='blue', alpha=0.3)

B. plt.fill_between(x, y1, y2, color='blue', alpha=0.3)

C. plt.fill_between(x, y1, y2, where=(y2 > y1), color='blue', alpha=0.3)

D. plt.fill_between(x, y1, y2, where=(y1 == y2), color='blue', alpha=0.3)

Solution

1. Step 1: Use the 'where' parameter to conditionally fill

   The where argument in plt.fill_between allows filling only where a condition is true. To fill where y1 is greater than y2, use where=(y1 > y2).

2. Step 2: Check other options for correctness

   plt.fill_between(x, y1, y2, color='blue', alpha=0.3) fills everywhere between y1 and y2. plt.fill_between(x, y1, y2, where=(y2 > y1), color='blue', alpha=0.3) fills where y2 is greater, which is opposite. plt.fill_between(x, y1, y2, where=(y1 == y2), color='blue', alpha=0.3) fills only where y1 equals y2, which is usually no area.

3. Final Answer:

   plt.fill_between(x, y1, y2, where=(y1 > y2), color='blue', alpha=0.3) -> Option A

4. Quick Check:

   Use where=(y1 > y2) to fill selectively [OK]

Hint: Use where=(condition) to fill selectively [OK]

Common Mistakes:

• Omitting the where parameter for conditional fill
• Reversing the condition in where
• Using equality instead of greater than