Understanding Wave Motion at 0.75 Hz

[SUMMARY]

This blog page intuitively uses imagined particle motion, wave animation, periodic shifts, and phase tracking to solve a Korean high-school wave exam, with a Python program provided to animate wave motion.

Link to Original Exam Problem(Korean)

 

<Problem>

The figure shows the displacement of a wave with frequency 0.75 Hz propagating in the +x direction, as a function of position x. The solid line and the dotted line represent the wave at time t = 0 and t = t₀, respectively. At t = 0, the displacement of the wave first becomes 2 m at time t = t₀ after t = 0. Which of the <Statements> are correct?

<Statements>

   a. The propagation speed of the wave is 3 m/s.

   b. t₀ = 1 second.
   c. At t = 2 seconds, the displacement of the wave at x = 3 m is 2 m.

<Choices>

① a  ② c  ③ a,b  ④ b,c  ⑤ a,b,c

 

[Think Along]
This problem can be solved more easily than expected if you can imagine the motion of the wave. However, imagining the motion of a wave is harder than it seems. It takes practice, and for practice, it can help to think of a rubber duck in the bathtub.

A rubber duck

A rubber duck is floating in the bathtub, and waves are passing through. This is a magical rubber duck—it moves up and down with the waves but never slips sideways. Using the up-and-down motion of the duck, we can define the period of the wave. In the problem, the frequency is given as 0.75 Hz, so the duck will move up and down 0.75 times per second. That means 1/4 of a cycle in 0.333 seconds, 2/4 in 0.666 seconds, 3/4 in 1 second, and 1 full cycle in 1.333 seconds. In other words, it takes 1.333 seconds for the duck’s vibration to complete one full cycle.

Now, let’s try to imagine the motion of the wave.

Animated illustration of the wave motion

Main Drawing of the Problem

Looking at the black-and-white figure above, it may seem as if the wave is moving to the left, but if you carefully observe the motion of the green graph and the changes at each moment t, it is clear that the wave is moving to the right. Now that you are familiar with the motion of the wave, let’s solve the problem.

 

Condition (a)

a. The propagation speed of the wave is 3 m/s.

In the animation below, you can see that it travels 1 meter in 0.333 seconds. Therefore, in 1 second it will travel 3 meters, so the propagation speed is indeed 3 m/s.

Animated illustration of the wave motion

Next, condition (b)

b. t₀ = 1 second.

This is also correct. During 1 second, the wave slides to the right by 3/4 of a wavelength. Since the wavelength is 4 m, sliding 3 m to the right matches the orange dotted graph.

 

Finally, condition (c)

c. At t = 2 seconds, the displacement of the wave at x = 3 m is 2 m.

To think of it simply, from t = 0 to t = 1 the graph shifted 1 m to the left, so from t = 0 to t = 2, the graph would shift 2 m to the left. In reality, it goes 3 steps to the right and then 3 steps further to the right, but because of the wave’s periodicity, that ends up being the same as going 1 step to the left and then another step to the left.

Animated illustration of the wave motion

So, if you look closely at the graph in the animation at t = 0.666, the displacement at x = 3 is 2. Therefore, (c) is correct.

Hence, the answer is 5.

[Epilogue]

Wave problems require the ability to animate the motion of the wave in your head using the given conditions. You could try to memorize formulas for each type, but since there are so many cases, even a slight change in the conditions can lead to a wrong answer and cause you to lose interest. It seems there is no other way but practice.

 

[Python Program for the Wave Animation]

# Wave shift animation with pause segments and optional GIF saving or live display.
# Smooth loop across one full period (T = 1/f). No duplicated first/last frame to prevent flicker.
# Pauses at t = 1/3 T and 2/3 T, then continuous to T, and loops back to 0 seamlessly.

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation, PillowWriter

# ===== User options =====
OUTPUT_MODE = "gif"                 # "gif" or "show"
GIF_PATH = "wave_slide_to_right.gif"     # path to save GIF when OUTPUT_MODE == "gif"
FPS = 30                            # frames per second
PAUSE_FRAMES = 15                   # pause duration at t=1/3 T and t=2/3 T (frames)
END_REPEAT_DELAY_MS = 0             # used only for live display (show mode)

# ===== Wave parameters =====
A = 2.0               # amplitude [m]
f = 0.75              # frequency [Hz]
lam = 4.0             # wavelength [m]  (so in 1 s, shift = 0.75*λ to +x)
omega = 2*np.pi*f     # angular frequency
k = 2*np.pi/lam       # wave number
phi = 0.0             # initial phase at t=0
T = 1.0 / f           # period = 4/3 s

# Spatial axis (0~8 m like the figure)
x = np.linspace(0, 8, 1000)

# Reference curves for t=0 (solid light) and t=T (same shape as t=0)
y_t0 = A * np.sin(k*x - omega*0 + phi)
y_tT = A * np.sin(k*x - omega*1 + phi)

# ===== Build timeline with pauses at t=1/3 T and t=2/3 T =====
# Important for smooth loop: DO NOT include the final frame at t=T, and do not pause there.
segments = [(0.0, T/4.0), (T/4.0, 2.0*T/4.0), (2.0*T/4.0, 3.0*T/4.0), (3.0*T/4.0, 4.0*T/4.0)]
frames_per_segment = int(FPS * (T/3.0))  # equal frames per segment across one period

t_values = []
for (t_start, t_end) in segments:
    # frames inside the segment, excluding endpoint to avoid duplicate at boundaries
    seg_ts = np.linspace(t_start, t_end, frames_per_segment, endpoint=False)
    t_values.extend(seg_ts.tolist())
    # add a pause at internal breakpoints only (not at the very end t=T)
    if t_end <= T:  # internal boundary
        t_values.extend([t_end] * PAUSE_FRAMES)

# ===== Set up the figure =====
fig, ax = plt.subplots(figsize=(7, 3.2), dpi=150)
ax.set_xlim(0, 8)
ax.set_ylim(-2.4, 2.4)
ax.set_xlabel("x (m)")
ax.set_ylabel("Amplitude (m)")

# Static references
ax.plot(x, y_t0, linewidth=1.0, alpha=0.4, label="t=0")
ax.plot(x, y_tT, linestyle="--", linewidth=1.0, alpha=0.8, label="t=1")

# Animated line
line, = ax.plot(x, y_t0, linewidth=2.0, label="Sliding Wave")
# show time modulo T to make the loop feel natural
title = ax.set_title("Sliding Wave: t = 0.000 s")
ax.legend(loc="upper right")


def update(frame_index):
    t = t_values[frame_index]
    y = A * np.sin(k*x - omega*t + phi)
    line.set_data(x, y)
    t_mod = (t % T)
    title.set_text(f"Sliding Wave: t = {t_mod:0.3f} s")
    return line, title

ani = FuncAnimation(
    fig,
    update,
    frames=len(t_values),
    interval=1000/FPS,
    blit=False,
    repeat=True,
    repeat_delay=END_REPEAT_DELAY_MS  # used for live display only
)

# ===== Output selection =====
if OUTPUT_MODE.lower() == "gif":
    # Save GIF via PillowWriter (GIF will loop; we avoided duplicate end/start frames)
    writer = PillowWriter(fps=FPS)
    ani.save(GIF_PATH, writer=writer)
    print(f"Saved: {GIF_PATH}")
elif OUTPUT_MODE.lower() == "show":
    plt.show()
else:
    raise ValueError("Unknown OUTPUT_MODE. Use 'gif' or 'show'.")

 

[Source: June 2025 Korean National Physics I Exam, Grade 12, Problem 10]

2026-06-103-0.75hz-wave-propagation-evaluated-by-chatgpt5.pdf

0.04MB