How is runtime affected when for() loop is inside an if() statement? - runtime

Question

Say we have this code:
doSomething(int n) {
for(int i = 0; i < n; i++) {
if (i % 7 == 0) {
for(int j = 0; j < n; j++) {
print("*");
}
}
}
}
What are the big-O and big-omega runtimes (with proofs/work shown)?
My mind is being blown by the if() statement and how to prove the big-omega (since for big-O we can just ignore the condition because it's an upper bound).
Any help is much appreciated. Thanks!

Answer 1

Let's begin by trying to rewrite things in a way that more clearly exposes the runtime. For example, that inner loop has a runtime of Θ(n), so let's rewrite the code like this:
for(int i = 0; i < n; i++) {
if (i % 7 == 0) {
do Θ(n) work
}
}
Now, think about what happens when this loop runs. One out of every seven iterations will trigger that inner loop and do Θ(n) work, and the remaining six-sevenths won't and will do Θ(1) work per iteration. This means that the total work done is
n ((1 / 7) × Θ(n) + (6 / 7) × Θ(1))
= n(Θ(n) + Θ(1))
= n(Θ(n))
= Θ(n2).
In other words, the total work done here is Θ(n2). And that makes sense, too, since essentially that if statement just reduces the work done by a factor of 1/7, and big-O notation ignores constant factors.
You had originally written the question for this code:
for(int i = 0; i < n; i++) {
if (n % 7 == 0) {
for(int j = 0; j < n; j++) {
print("*");
}
}
}
Here's my original answer:
Let's begin by trying to rewrite things in a way that more clearly exposes the runtime. For example, that inner loop has a runtime of Θ(n), so let's rewrite the code like this:
for(int i = 0; i < n; i++) {
if (n % 7 == 0) {
do Θ(n) work
}
}
So now let's think about what's happening here. There are two possibilities for what could happen. First, it might be the case that n is a multiple of seven. In that case, the if statement triggers every time, and on each of the n outer loop iterations we do Θ(n) work. Therefore, we can say that the total work done in the worst case will be Θ(n2). We can't tighten that bound because as n gets larger and larger, we keep running into more and more multiples of seven. Second, it might be the case that n isn't a multiple of seven. When that happens, we do Θ(n) loop iterations that all do Θ(1) work each, so in the best case we'll do Θ(n) total work.
Overall, this means that in the worst case we do Θ(n2) work, and in the best case we do Θ(n) work. We can therefore say that the runtime of the function is O(n2) and Ω(n), though I think that the more precise descriptions of the best and worst-case runtimes are a little more informative.
The key to the analysis here is realizing that that if statement is either going to always to fire or never going to fire. That makes it easier for us to split the reasoning into two separate cases.
Remember that a big-O analysis isn't just about multiplying a bunch of things together. It's about thinking about what the program will actually do if we were to run it, then thinking through how the logic will play out. You'll rarely be wasting your time if you try approaching big-O analysis this way.