Random sampling distributions in NumPy - Time & Space Complexity

Time Complexity: Random sampling distributions

O(n)

Understanding Time Complexity

We want to understand how the time needed to create random samples changes as we ask for more samples.

How does the work grow when we increase the number of random values we generate?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

import numpy as np

# Generate n random samples from a normal distribution
n = 1000
samples = np.random.normal(loc=0, scale=1, size=n)

# Calculate the mean of the samples
mean_value = np.mean(samples)

This code generates n random numbers from a normal distribution and then finds their average.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Generating n random numbers and then calculating their mean.
• How many times: The random number generation and mean calculation each process all n elements once.

How Execution Grows With Input

As we ask for more samples, the work grows roughly in direct proportion to the number of samples.

Input Size (n)	Approx. Operations
10	About 10 random draws and 10 values averaged
100	About 100 random draws and 100 values averaged
1000	About 1000 random draws and 1000 values averaged

Pattern observation: Doubling the number of samples roughly doubles the work done.

Final Time Complexity

Time Complexity: O(n)

This means the time needed grows in a straight line with the number of samples you want.

Common Mistake

[X] Wrong: "Generating random samples is instant and does not depend on how many samples I ask for."

[OK] Correct: Each sample requires some work, so more samples mean more time. The time grows directly with the number of samples.

Interview Connect

Understanding how sampling time grows helps you explain performance when working with data simulations or bootstrapping in real projects.

Self-Check

"What if we generate samples in batches of fixed size instead of all at once? How would the time complexity change?"

Practice

1. What does the numpy.random.choice function do in random sampling?

easy

A. It selects random elements from a given array or list.

B. It generates random numbers from a normal distribution.

C. It creates a sequence of numbers with equal spacing.

D. It calculates the mean of a dataset.

Solution

1. Step 1: Understand the purpose of numpy.random.choice

   This function is used to randomly pick elements from an input array or list, optionally with replacement.

2. Step 2: Compare with other options

   Options A, B, and C describe different numpy functions or operations unrelated to random selection from an array.

3. Final Answer:

   It selects random elements from a given array or list. -> Option A

4. Quick Check:

   numpy.random.choice = random selection [OK]

Hint: Remember: choice picks from arrays, normal generates bell curve numbers [OK]

Common Mistakes:

• Confusing choice with normal distribution generator
• Thinking choice creates sequences
• Assuming choice calculates statistics

2. Which of the following is the correct syntax to generate 5 samples from a binomial distribution with 10 trials and success probability 0.3 using numpy?

easy

A. numpy.binomial(10, 0.3, 5)

B. numpy.random.binomial(10, 0.3, size=5)

C. numpy.random.binomial(size=5, 10, 0.3)

D. numpy.random.binomial(5, 10, 0.3)

Solution

1. Step 1: Recall the numpy binomial function signature

   The correct syntax is numpy.random.binomial(n, p, size) where n is number of trials, p is success probability, and size is number of samples.

2. Step 2: Check each option

   numpy.random.binomial(10, 0.3, size=5) matches the correct order and uses the keyword size. numpy.binomial(10, 0.3, 5) misses .random. numpy.random.binomial(size=5, 10, 0.3) mixes keyword size=5 followed by positionals, causing SyntaxError. numpy.random.binomial(5, 10, 0.3) swaps parameters incorrectly.

3. Final Answer:

   numpy.random.binomial(10, 0.3, size=5) -> Option B

4. Quick Check:

   binomial(n, p, size) = numpy.random.binomial(10, 0.3, size=5) [OK]

Hint: Remember order: trials, probability, then size keyword [OK]

Common Mistakes:

• Mixing argument order
• Omitting size keyword
• Using wrong function name

3. What is the output of the following code?

import numpy as np
np.random.seed(0)
samples = np.random.normal(loc=5, scale=2, size=3)
print(np.round(samples, 2))

medium

A. [7.65 5.12 6.34]

B. [8.53 4.32 6.58]

C. [8.82 4.0 6.89]

D. [8.53 5.8 6.96]

Solution

1. Step 1: Understand the code

   The code sets a random seed for reproducibility, then generates 3 samples from a normal distribution with mean 5 and standard deviation 2.

2. Step 2: Run or recall the output

   Using seed 0, the samples generated are [8.53, 5.8, 6.96] after rounding to 2 decimals.

3. Final Answer:

   [8.53 5.8 6.96] -> Option D

4. Quick Check:

   Seed 0 normal samples = [8.53 5.8 6.96] [OK]

Hint: Use seed for fixed output, then round to compare [OK]

Common Mistakes:

• Ignoring seed causes different outputs
• Rounding incorrectly
• Mixing mean and scale parameters

4. Identify the error in this code snippet that tries to sample 4 values from a uniform distribution between 0 and 1:

import numpy as np
samples = np.random.uniform(low=0, high=1, size=4)
print(samples)

medium

A. There is no error; the code runs correctly.

B. The parameters low and high are reversed.

C. The function name should be random.uniform without numpy prefix.

D. The size parameter must be a tuple, not an integer.

Solution

1. Step 1: Review the numpy uniform function syntax

   np.random.uniform(low, high, size) is the correct way to generate samples from a uniform distribution.

2. Step 2: Check the code correctness

   The code uses correct function name, parameter order, and size as integer for 1D array. It will run without error and print 4 random values between 0 and 1.

3. Final Answer:

   There is no error; the code runs correctly. -> Option A

4. Quick Check:

   Uniform sampling syntax correct = There is no error; the code runs correctly. [OK]

Hint: Check function name and parameter order carefully [OK]

Common Mistakes:

• Confusing numpy.random.uniform with Python's random.uniform
• Swapping low and high values
• Using tuple for size unnecessarily

5. You want to simulate rolling a fair six-sided die 1000 times and count how many times the number 4 appears. Which numpy code correctly performs this simulation?

hard

A. rolls = np.random.choice([1,2,3,4,5,6], size=1000)
count_4 = np.sum(rolls == 4)

B. rolls = np.random.binomial(6, 1/6, size=1000)
count_4 = np.count_nonzero(rolls == 4)

C. rolls = np.random.randint(1, 7, size=1000)
count_4 = np.sum(rolls == 4)

D. rolls = np.random.normal(4, 1, size=1000)
count_4 = np.sum(rolls == 4)

Solution

1. Step 1: Understand the problem

   We want to simulate rolling a die 1000 times, each roll equally likely from 1 to 6, then count how many times 4 appears.

2. Step 2: Evaluate each option

   rolls = np.random.randint(1, 7, size=1000) count_4 = np.sum(rolls == 4): rolls = np.random.randint(1, 7, size=1000) count_4 = np.sum(rolls == 4) uses randint from 1 to 6 (exclusive upper bound 7), perfect for die rolls. rolls = np.random.binomial(6, 1/6, size=1000) count_4 = np.count_nonzero(rolls == 4): rolls = np.random.binomial(6, 1/6, size=1000) count_4 = np.count_nonzero(rolls == 4) uses binomial which models number of successes in trials, not die rolls. rolls = np.random.choice([1,2,3,4,5,6], size=1000) count_4 = np.sum(rolls == 4): rolls = np.random.choice([1,2,3,4,5,6], size=1000) count_4 = np.sum(rolls == 4) omits replace=True (defaults to False), raising ValueError since size=1000 > 6. rolls = np.random.normal(4, 1, size=1000) count_4 = np.sum(rolls == 4): rolls = np.random.normal(4, 1, size=1000) count_4 = np.sum(rolls == 4) uses normal distribution, inappropriate for discrete die rolls.

3. Step 3: Choose the best correct code

   rolls = np.random.randint(1, 7, size=1000) count_4 = np.sum(rolls == 4) is the correct way to simulate die rolls and count 4s.

4. Final Answer:

   rolls = np.random.randint(1, 7, size=1000) count_4 = np.sum(rolls == 4) -> Option C

5. Quick Check:

   Use randint for discrete uniform die rolls = rolls = np.random.randint(1, 7, size=1000) count_4 = np.sum(rolls == 4) [OK]

Hint: Use randint(1,7) for dice rolls, then count matches [OK]

Common Mistakes:

• Using binomial instead of uniform discrete
• Using normal distribution for discrete outcomes
• Forgetting replace=True in choice