Binomial Distribution Exercises in R: 17 Practice Problems

Explanation: dbinom(x, size, prob) returns the probability mass at exactly x successes. The first argument is the count you want a probability for, not a vector of trial outcomes. For a fair coin the answer is $\binom{10}{5} \cdot 0.5^{10} = 252 / 1024 \approx 0.2461$. A common mistake is using pbinom() here, which would return the cumulative probability $P(X \le 5)$ instead of the exact-equality mass.

Explanation: Every trial is one widget, success means defective, and the trials are assumed independent with constant probability 0.03, which is the textbook binomial setup. Around 25.5 percent is the single most likely count near the mean $np = 1.5$. If the defect rate were estimated from a small pilot rather than known, you would want a Beta-binomial or a credible interval on $p$ before treating the answer as exact.

Explanation: Passing a vector 0:20 to dbinom() vectorizes the call and returns 21 probabilities in one shot, which is the cleanest way to build a PMF table for plotting. The peak at $k = 6$ matches $np$, the mean of the distribution. For larger size the bars start to look bell-shaped, foreshadowing the normal approximation you will see in Section 4.

Explanation: pbinom(q, size, prob) returns the lower-tail probability $P(X \le q)$ by default, so passing q = 2 includes the masses at 0, 1, and 2. You could verify by hand with sum(dbinom(0:2, 10, 0.5)), which returns the same value. Many beginners reach for dbinom(2, ...) here and get the at-exactly-2 mass instead of the at-most-2 cumulative.

Explanation: The trick is the offset: pbinom(q, ..., lower.tail = FALSE) returns $P(X > q)$, strictly greater than, so to capture $P(X \ge 8)$ you pass q = 7. Equivalently you can write 1 - pbinom(7, 20, 0.3), but the lower.tail = FALSE path is numerically more stable for probabilities near 1 because it avoids 1 - x cancellation when x is tiny.

Explanation: Inclusive interval probabilities use a discrete-aware offset: $P(a \le X \le b) = P(X \le b) - P(X \le a - 1)$. Passing 39 instead of 40 is the most common mistake here. The answer roughly 96.5 percent is close to but not exactly the 95 percent you would read off a continuous normal approximation, which is a reminder that the normal CDF is a smoothing of this step function.

Explanation: The CDF is defined as the cumulative sum of the PMF, so the two values must agree to floating-point precision. This identity is the reason pbinom() and sum(dbinom(...)) are interchangeable for small size, but pbinom() is preferred for large size because R uses a stable algorithm rather than summing many tiny floats. Exercises like this one are also useful when sanity-checking custom probability code against the built-in family.

Explanation: qbinom(p, ...) returns the smallest integer $k$ with cumulative probability at least p, so it is the discrete inverse of pbinom(). The answer 58 says that in 100 fair flips you would expect to see 58 or fewer heads at least 95 percent of the time. A common confusion is to expect the normal approximation $\mu + 1.645\sigma = 58.2$ to round to 58 exactly, which it does here but does not always.

Explanation: This is a prediction interval, not a confidence interval. It says where future daily conversion counts should fall under the assumed model, holding prob = 0.05 fixed. A confidence interval would instead quantify uncertainty about prob itself. Reviewers sometimes flag prediction intervals that are too narrow because the analyst forgot to account for parameter uncertainty, especially when prob was estimated from a small sample.

Explanation: Empirical and theoretical quantiles should match for large n, and 50000 is well past the regime where Monte Carlo noise matters here. Passing type = 1 to quantile() is important because it uses the inverse of the empirical CDF, which matches the discrete-aware definition qbinom() uses. Other type values interpolate between adjacent order statistics and can drift off by 1 for skewed discrete distributions.

Explanation: Setting size = 1 makes rbinom() generate Bernoulli outcomes (0 or 1), and the sample mean of those is the maximum likelihood estimate of prob. With 10000 draws the standard error is $\sqrt{0.5 \cdot 0.5 / 10000} = 0.005$, so values near 0.495 to 0.505 are routine. Cranking n higher tightens that band, while shrinking n widens it and makes Monte Carlo estimation noticeably noisier.

Explanation: $\hat p$ is the sample success proportion and is the MLE of the binomial probability parameter. Its Wald standard error uses $\hat p$ in place of the unknown true $p$, which is why the formula plugs in 0.28 rather than a hypothesized 0.5. For small samples or proportions near 0 or 1, Wald standard errors overstate precision; in those regimes prefer Wilson or Agresti-Coull intervals returned by binom.test() and prop.test().

Explanation: The theoretical mean of $\text{Binomial}(n, p)$ is $np$ and the variance is $np(1 - p)$, both classic results derived from summing $n$ independent Bernoulli variables. Empirical estimates from 5000 draws should be within a few percent of these targets. If you saw the empirical variance systematically above the theoretical value, that would signal overdispersion and you might switch to a Beta-binomial or quasi-binomial fit.

Explanation: rle() returns run-length encoding of a vector: the lengths and the values of consecutive equal stretches, which is exactly the streak structure you want here. Filtering runs$values == 1 keeps the make-streaks and drops the miss-streaks. The expected longest run for $p = 0.85$ and $n = 1000$ grows like $\log_{1/p}(n) \approx 28$, but tail values in the 30s and 40s are routine because the maximum of geometric-like streak lengths has a heavy right tail.

Explanation: binom.test() returns a list (an htest object) and the p-value lives in $p.value. For two-sided tests R uses the rule of summing probabilities of all outcomes at least as unlikely as the observed one, which is exact and discrete-aware, not the lazy 2 * pbinom(...) shortcut. The 5.7 percent value is famously just over the 5 percent threshold, a good talking point about the arbitrariness of alpha cutoffs.

Explanation: The 95 percent interval binom.test() returns is Clopper-Pearson, the exact interval inverted from the binomial CDF. It is wider than the Wald or Wilson alternatives but guarantees coverage at least 95 percent. The interval here excludes the null value 0.10, consistent with the small p-value, but you should still report the effect size (12.5 percent observed versus 10 percent baseline) since statistical and practical significance are not the same.

Explanation: prop.test() uses a chi-squared statistic that is a normal approximation to the binomial, and correct = FALSE turns off Yates continuity correction so the comparison is apples-to-apples. The two p-values agree to about two significant figures here because $n = 100$ and the success count is comfortably away from 0 and $n$. For very small $n$ or extreme proportions the gap widens and the exact test is the safer default.