Discrete Fourier Transform (DFT) in Signal Processing - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple DFT calculation

What is the output of the following Python code that computes the DFT of a simple signal?

Signal Processing

import numpy as np
x = np.array([1, 0, -1, 0])
X = np.fft.fft(x)
print(np.round(X, 2))

A [0.+0.j 2.+0.j 0.+0.j 2.+0.j]

B [0.+0.j 1.+0.j 0.+0.j 1.+0.j]

C [0.+0.j 0.+2.j 0.+0.j 0.-2.j]

D [0.+0.j 0.-2.j 0.+0.j 0.+2.j]

💡 Hint

Recall that the DFT of a real-valued signal can have complex values representing frequency components.

The input signal is a simple 4-point sequence alternating between 1 and -1. Its DFT has zero DC component and imaginary parts at frequencies 1 and 3, with values 0+2j and 0-2j respectively.

❓ data_output

intermediate

Number of frequency bins in DFT output

If you apply a Discrete Fourier Transform (DFT) to a signal with 16 samples, how many frequency bins will the output contain?

A 8

B 32

C 15

D 16

💡 Hint

The DFT output length matches the input length.

The DFT output has the same number of frequency bins as the number of input samples, so 16 bins for 16 samples.

❓ visualization

advanced

Visualizing magnitude spectrum of a signal

Which plot correctly shows the magnitude spectrum of a 1 kHz sine wave sampled at 8 kHz for 8 ms?

Signal Processing

import numpy as np
import matplotlib.pyplot as plt
fs = 8000
f = 1000
t = np.arange(0, 0.008, 1/fs)
x = np.sin(2 * np.pi * f * t)
X = np.fft.fft(x)
freqs = np.fft.fftfreq(len(X), 1/fs)
magnitude = np.abs(X)
plt.stem(freqs[:len(freqs)//2], magnitude[:len(magnitude)//2])
plt.xlabel('Frequency (Hz)')
plt.ylabel('Magnitude')
plt.title('Magnitude Spectrum')
plt.show()

A A plot with peaks at 1000 Hz and 7000 Hz

B A plot with multiple peaks evenly spaced every 1000 Hz

C A plot with a single peak at 1000 Hz and zero elsewhere

D A flat plot with no peaks

💡 Hint

Remember the DFT output is symmetric for real signals, so peaks appear at the frequency and its mirror.

The magnitude spectrum of a real sine wave sampled at 8 kHz shows a peak at 1 kHz and a symmetric peak at 7 kHz (which is fs - f).

🧠 Conceptual

advanced

Effect of zero-padding on DFT resolution

What is the main effect of zero-padding a time-domain signal before computing its DFT?

A It interpolates the DFT output to give a smoother frequency spectrum without increasing true resolution

B It increases the actual frequency resolution by adding new frequency components

C It decreases the frequency resolution by shortening the signal length

D It removes noise from the signal before DFT

💡 Hint

Think about what zero-padding does to the length of the input and the spacing of frequency bins.

Zero-padding increases the number of DFT points, which interpolates the frequency spectrum and makes it smoother, but does not increase the true frequency resolution determined by the original signal length.

🔧 Debug

expert

Identify the error in manual DFT implementation

Consider this Python code attempting to compute the DFT manually. What error will it raise or what is the output?

Signal Processing

import numpy as np
x = [1, 2, 3]
N = len(x)
X = []
for k in range(N):
    s = 0
    for n in range(N):
        s += x[n] * np.exp(-2j * np.pi * k * n / N)
    X.append(s)
print(X[3])

A [6.+0.j, -1.5+0.866j, -1.5-0.866j]

B IndexError: list index out of range

C TypeError: unsupported operand type(s) for +: 'int' and 'complex'

D Prints the full DFT list without error

💡 Hint

Check the index used to access the list X after the loop.

The list X has length 3 with indices 0,1,2. Accessing X[3] causes an IndexError because index 3 is out of range.

Practice

1. What does the Discrete Fourier Transform (DFT) primarily do to a signal?

easy

A. Converts the signal from time domain to frequency domain

B. Amplifies the signal amplitude

C. Filters out noise from the signal

D. Compresses the signal data size

Solution

1. Step 1: Understand signal domains

   The time domain shows how a signal changes over time, while the frequency domain shows the signal's frequency components.

2. Step 2: Role of DFT

   DFT transforms a signal from the time domain into the frequency domain, revealing hidden frequencies.

3. Final Answer:

   Converts the signal from time domain to frequency domain -> Option A

4. Quick Check:

   DFT = Time to Frequency [OK]

Hint: DFT = time to frequency conversion [OK]

Common Mistakes:

• Thinking DFT amplifies signals
• Confusing DFT with noise filtering
• Assuming DFT compresses data

2. Which of the following is the correct Python syntax to compute the DFT of a 1D array signal using numpy?

easy

A. numpy.dft(signal)

B. numpy.fft.fft(signal)

C. numpy.fft.dft(signal)

D. numpy.fft.transform(signal)

Solution

1. Step 1: Identify numpy FFT function

   In numpy, the function to compute the Discrete Fourier Transform is fft inside the fft module.

2. Step 2: Check correct syntax

   The correct call is numpy.fft.fft(signal). Other options are either non-existent or incorrect function names.

3. Final Answer:

   numpy.fft.fft(signal) -> Option B

4. Quick Check:

   Use numpy.fft.fft() for DFT [OK]

Hint: Use numpy.fft.fft() to compute DFT [OK]

Common Mistakes:

• Using nonexistent numpy.dft() function
• Confusing module and function names
• Typing transform instead of fft

3. Given the Python code:

import numpy as np
signal = np.array([1, 0, -1, 0])
dft_result = np.fft.fft(signal)
print(np.round(dft_result, 2))

What is the output?

medium

A. [0.+0.j 0.+2.j 0.+0.j 0.-2.j]

B. [0.+0.j 0.+0.j 0.+0.j 0.+0.j]

C. [0.+0.j 2.+0.j 0.+0.j 2.+0.j]

D. [0.+0.j 1.+0.j 0.+0.j 1.+0.j]

Solution

1. Step 1: Understand input signal

   The signal is [1, 0, -1, 0], a simple 4-point sequence alternating positive and negative values.

2. Step 2: Compute DFT manually or recall pattern

   DFT of this sequence results in complex values showing frequency components. The output is [0.+0.j, 0.+2.j, 0.+0.j, 0.-2.j] after rounding.

3. Final Answer:

   [0.+0.j 0.+2.j 0.+0.j 0.-2.j] -> Option A

4. Quick Check:

   DFT of alternating signal = complex freq components [OK]

Hint: Look for imaginary parts in DFT of alternating signals [OK]

Common Mistakes:

• Ignoring imaginary parts in output
• Confusing zero arrays with actual DFT
• Misreading numpy rounding output

4. Identify the error in this Python code snippet for computing DFT:

import numpy as np
signal = [1, 2, 3, 4]
dft = np.fft.fft(signal, n=2)
print(dft)

medium

A. np.fft.fft does not accept the parameter n

B. The signal must be a numpy array, not a list

C. The parameter n=2 truncates the DFT length incorrectly

D. The print statement syntax is incorrect

Solution

1. Step 1: Understand parameter n in np.fft.fft

   The parameter n sets the length of the DFT. If shorter than signal length, signal is truncated.

2. Step 2: Effect of n=2 on signal length 4

   Setting n=2 truncates the signal from length 4 to 2, losing data and changing the DFT result unexpectedly.

3. Final Answer:

   The parameter n=2 truncates the DFT length incorrectly -> Option C

4. Quick Check:

   n parameter truncates or pads signal [OK]

Hint: Check if n parameter matches signal length [OK]

Common Mistakes:

• Assuming n pads signal always
• Thinking signal must be numpy array
• Believing np.fft.fft disallows n parameter

5. You have a noisy signal sampled at 8 points: [1, 0, 1, 0, 1, 0, 1, 0]. You want to remove high-frequency noise by zeroing out the last 4 DFT coefficients and then reconstruct the signal using inverse DFT. Which Python code snippet correctly performs this?

hard

A. dft = np.fft.fft(signal)
dft[0:4] = 0
clean_signal = np.fft.ifft(dft).real

B. dft = np.fft.fft(signal)
dft[:4] = 0
clean_signal = np.fft.ifft(dft).real

C. dft = np.fft.fft(signal)
dft[2:] = 0
clean_signal = np.fft.ifft(dft).real

D. dft = np.fft.fft(signal)
dft[4:] = 0
clean_signal = np.fft.ifft(dft).real

Solution

1. Step 1: Compute DFT of signal

   Use np.fft.fft(signal) to get frequency components.

2. Step 2: Zero out last 4 coefficients to remove high frequencies

   Since signal length is 8, last 4 coefficients are dft[4:]. Setting them to zero removes high-frequency noise.

3. Step 3: Reconstruct signal with inverse DFT

   Use np.fft.ifft(dft).real to get cleaned time-domain signal.

4. Final Answer:

   dft = np.fft.fft(signal) dft[4:] = 0 clean_signal = np.fft.ifft(dft).real -> Option D

5. Quick Check:

   Zero last half DFT coefficients to filter high freq [OK]

Hint: Zero last half DFT coefficients to remove high frequencies [OK]

Common Mistakes:

• Zeroing first half instead of last half
• Zeroing wrong slice indices
• Forgetting to take real part after inverse DFT