FFT with np.fft module in NumPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of FFT on a simple signal

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

NumPy

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

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

B [0.+0.j 0.+2.j 0.+0.j 0.-2.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]

💡 Hint

Recall that FFT output is complex and symmetric for real inputs.

The FFT of the signal [1, 0, -1, 0] results in complex values with imaginary parts at certain frequencies. The output shows non-zero imaginary parts at indices 1 and 3.

❓ data_output

intermediate

Length of FFT output array

Given a real input array of length 8, what is the length of the output array from np.fft.fft?

NumPy

import numpy as np
x = np.arange(8)
fft_x = np.fft.fft(x)
print(len(fft_x))

A 4

B 16

C 7

D 8

💡 Hint

FFT output length equals input length for np.fft.fft.

The FFT output array length is the same as the input array length when using np.fft.fft.

🔧 Debug

advanced

Identify the error in FFT frequency calculation

What error does the following code raise when trying to compute FFT frequencies for a signal of length 5? import numpy as np freqs = np.fft.fftfreq(5, d=0) print(freqs)

NumPy

import numpy as np
freqs = np.fft.fftfreq(5, d=0)
print(freqs)

A ZeroDivisionError

B TypeError

C ValueError

D No error, prints frequencies

💡 Hint

Check the meaning of the parameter d in fftfreq.

The parameter d is the sample spacing. Setting d=0 causes division by zero inside fftfreq, raising ZeroDivisionError.

🚀 Application

advanced

Using FFT to find dominant frequency

Given a noisy signal composed of two sine waves at 5 Hz and 20 Hz sampled at 100 Hz, which code snippet correctly identifies the dominant frequency using FFT?

NumPy

import numpy as np
fs = 100
T = 1/fs
t = np.linspace(0, 1, fs, endpoint=False)
signal = np.sin(2*np.pi*5*t) + 0.5*np.sin(2*np.pi*20*t) + 0.1*np.random.randn(fs)

A

fft_vals = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(signal), T)
dominant_freq = freqs[np.argmax(np.abs(fft_vals))]
print(round(dominant_freq, 1))

B

fft_vals = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(signal), 1)
dominant_freq = freqs[np.argmax(np.abs(fft_vals))]
print(round(dominant_freq, 1))

C

fft_vals = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(signal))
dominant_freq = freqs[np.argmax(np.abs(fft_vals))]
print(round(dominant_freq, 1))

D

fft_vals = np.fft.fft(signal)
freqs = np.fft.fftfreq(len(signal), 0)
dominant_freq = freqs[np.argmax(np.abs(fft_vals))]
print(round(dominant_freq, 1))

💡 Hint

Sample spacing d should be the inverse of sampling frequency fs.

The sample spacing d must be 1/fs to get correct frequency values. Option A uses d=T=1/fs correctly.

🧠 Conceptual

expert

Interpretation of FFT output symmetry

For a real-valued input signal of length N, which statement about the FFT output from np.fft.fft is true?

A The FFT output is always purely real.

B The FFT output contains only positive frequencies.

C The FFT output is symmetric: the second half is the complex conjugate of the first half reversed.

D The FFT output length is half the input length.

💡 Hint

Think about properties of FFT for real inputs.

For real inputs, FFT output is symmetric: the second half is the complex conjugate of the first half reversed. This is called Hermitian symmetry.

Practice

1. What does the np.fft.fft() function do in numpy?

easy

A. It calculates the mean of an array.

B. It sorts an array in ascending order.

C. It generates random numbers.

D. It computes the Fast Fourier Transform of a signal.

Solution

1. Step 1: Understand the purpose of FFT

   FFT converts time-domain data into frequency-domain data quickly.

2. Step 2: Identify the function role

   np.fft.fft() computes this Fast Fourier Transform on input data.

3. Final Answer:

   It computes the Fast Fourier Transform of a signal. -> Option D

4. Quick Check:

   FFT = Fast Fourier Transform [OK]

Hint: FFT = Fast Fourier Transform, converts time to frequency [OK]

Common Mistakes:

• Confusing FFT with sorting or averaging functions
• Thinking FFT generates random data
• Mixing FFT with statistical calculations

2. Which of the following is the correct syntax to compute the FFT of a numpy array data?

easy

A. np.fft(data).fft()

B. np.fft.fft(data)

C. fft(np.data)

D. np.fft_fft(data)

Solution

1. Step 1: Recall numpy FFT syntax

   The correct function call is np.fft.fft() with the data array as argument.

2. Step 2: Check each option

   Only np.fft.fft(data) matches the correct syntax; others are invalid or incorrect.

3. Final Answer:

   np.fft.fft(data) -> Option B

4. Quick Check:

   Correct function call = np.fft.fft(data) [OK]

Hint: Use np.fft.fft(array) to compute FFT [OK]

Common Mistakes:

• Swapping function and module order
• Using wrong function names
• Passing wrong argument types

3. What is the output of the following code?

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

medium

A. [1.+0.j 0.+0.j 0.+0.j 0.+0.j]

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

C. [4.+0.j 0.+0.j 0.+0.j 0.+0.j]

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

Solution

1. Step 1: Understand input signal

   The input array has one '1' followed by zeros, representing a unit impulse (delta function).

2. Step 2: Compute FFT of impulse

   The FFT of a unit impulse of length 4 is [4.+0.j 0.+0.j 0.+0.j 0.+0.j], because the sum of the input is 1 at position 0, but the FFT sums all elements, so the DC component is 4.

3. Final Answer:

   [4.+0.j 0.+0.j 0.+0.j 0.+0.j] -> Option C

4. Quick Check:

   Impulse FFT = DC component equals sum of input [OK]

Hint: FFT of unit impulse = all ones [Incorrect], actually FFT of [1,0,0,0] = [4,0,0,0] [OK]

Common Mistakes:

• Thinking FFT shows sum only at DC ([4.+0.j 0.+0.j 0.+0.j 0.+0.j])
• Ignoring complex number format
• Misreading array rounding

4. Identify the error in this code snippet:

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

medium

A. The FFT length n cannot be smaller than the input length.

B. The print statement syntax is incorrect.

C. The function np.fft.fft does not accept the parameter n.

D. The input signal must be a numpy array, not a list.

Solution

1. Step 1: Check FFT length parameter

   The input signal length is 4, but n=-1 is smaller than input length.

2. Step 2: Understand FFT behavior with n parameter

   FFT length n must be at least the input length or zero-padded; smaller n truncates data causing error or unexpected results.

3. Final Answer:

   The FFT length n cannot be smaller than the input length. -> Option A

4. Quick Check:

   FFT length n ≥ input length [OK]

Hint: FFT length n ≥ input length [OK]

Common Mistakes:

• Thinking lists are invalid input
• Believing n can be any number
• Assuming print syntax error

5. You have a noisy signal stored in a numpy array noisy_signal. You want to remove high-frequency noise by zeroing FFT components above index 5. Which code correctly applies this filter and returns the cleaned signal?

hard

A. fft_vals = np.fft.fft(noisy_signal)
fft_vals[5:] = 0
clean_signal = np.fft.ifft(fft_vals).real

B. fft_vals = np.fft.fft(noisy_signal)
fft_vals[:5] = 0
clean_signal = np.fft.ifft(fft_vals).real

C. fft_vals = np.fft.ifft(noisy_signal)
fft_vals[5:] = 0
clean_signal = np.fft.fft(fft_vals).real

D. clean_signal = np.fft.fft(noisy_signal)
clean_signal[5:] = 0

Solution

1. Step 1: Compute FFT of noisy signal

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

2. Step 2: Zero out high-frequency components

   Set FFT values from index 5 onward to zero to remove high frequencies.

3. Step 3: Compute inverse FFT to get cleaned signal

   Apply np.fft.ifft() and take real part to get filtered time-domain signal.

4. Final Answer:

   fft_vals = np.fft.fft(noisy_signal) fft_vals[5:] = 0 clean_signal = np.fft.ifft(fft_vals).real -> Option A

5. Quick Check:

   Zero high freq FFT, then inverse FFT [OK]

Hint: Zero high freq FFT components, then inverse FFT [OK]

Common Mistakes:

• Zeroing low-frequency components instead
• Using ifft before fft
• Not taking real part after inverse FFT