该循环执行多少次

Question

I was just wondering how many times a nested loop like this would run

int sum = 0;
for(int i = 0; i < total; i++) {
    for(int j = i + 1; j < total; j++) {
        for(int k = j; k < total; k++) {
            sum++;    
        }
    }
}
System.out.println(sum);

I can easily see the output of sum, but I would like to be able to mathematically calculate the total of sum with any number for total .

Answer 1

It needs only a little bit knowledge of programming.Actually logic that is running behind is only computational kind of thing. let's say:

total=10,sum=0

- when i is 0:

That time j is initialised with 1(i+1) and k as well. So k will lead us to execute the loop 9 times and and as j is incremented ,it will lead us to execute sum statement 8 times and 7 times and further 6 times till 1 time. (9+8+7+6+5+4+3+2+1=45 times.)

- when i is 1:

That time j is initialised with 2 and k as well.So sum statement is going to execute 8 times and then 7 times and then 6 times till 1. (8+7+6+5+4+3+2+1=36 times).

- when i is 2:

Same thing happens repeatedly but starting with difference number ,so this time (7+6+5+4+3+2+1=28)

• So this sequence continues until there is significance of occuring the condition with trueness. This happens till i is 9.

So the final answer is 1+3+6+10+15+21+28+36+45=165.

Answer 2

The first iteration of the middle loop adds

total-1 + total-2 + ... + 1 

to the sum.

The second iteration of the middle loop adds

total-2 + total - 3 + ... + 1 

to the sum

The last iteration of the middle loop adds

1

to the sum.

If you sum all of these terms, you get

(total - 1) * 1 + (total - 2) * 2 + (total - 3) * 3 + ... + 2 * (total - 2) + 1 * (total - 1)

It's been a while since I studied math, so I don't remember if there's a simpler formula for this expression.

For example, if total is 10, you get:

9 * 1 + 8 * 2 + 7 * 3 + 6 * 4 + 5 * 5 + 4 * 6 + 3 * 7 + 2 * 8 + 1 * 9 =
9 + 16 + 21 + 24 + 25 + 24 + 21 + 16 + 9 = 
165

Answer 3

TL;DR

The loop will be executed for ((total ^ 3) - total) / 6 times and hence that will be the value of sum at the end of the loop.

---

int sum = 0;
for(int i = 0; i < total; i++) { 
    for(int j = i + 1; j < total; j++) {
        for(int k = j; k < total; k++) {
            sum++;    
        }
    }
}

It is easy to see that the outer loop runs for a total times. The second loop is the trickier one

Let's try to work this out

i = 0 , j runs from 1..total - 1

i = 1 , j runs from 2..total - 1

i = 2 , j runs from 3..total - 1

... i = total - 2 , j runs from total - 1 ..total - 1 (will only run once)

i = total - 1 , inner loop does not execute as the loop termination condition is true.

The third loop is dependent on the second inner loop - k runs from j..total - 1

Let us take total as 6

j runs from 1..5 -> k runs for 5 times ( j = 1 ) + 4 times( j = 2 ) + 3 times( j = 3 )+ 2 times( j = 4 ) + 1 time( j = 4 )

(Showing a minified version for others)

2..5 -> 4+3+2+1
3..5 3+2+1
4..5 2+1
5..5 1

Which is

1 + 2 + 3 + 4 + 5+
1 + 2 + 3 + 4 + 
1 + 2 + 3 +
1 + 2 +
1

Generally,

1 + 2 + 3 + .. n +
1 + 2 + 3 +..n - 1+
1 + 2 + 3 +..n - 2+
1 + 2 + 3 +
1 + 2 +
1

This boils down to the sum n * (n - 1)) / 2

For all values of n ranging from 1 to total

This can be verified with the below

int res = 0;
for (int i = 1; i <= total; i++) {
    res += (i * (i - 1))/2;
}

res will be equal to your sum .

Mathematically, the above is

((total ^ 3) - total) / 6

Derivation:

References:

Sums of the First n Natural Numbers

Sum of the Squares of the First n Natural Numbers

Answer 4

outermost loop runs 'total' number of times.

for each outer loop , middle loop runs 'total-i' times.

ie total * total+total * (total-1)+total * (total-2)....total * 1

= total*(total+total-1+total-2...1)

= total*(1+2+3....total)

= total*(sum of first 'total' natural numbers)

= total*(total*(total+1)/2)

now the innermost loop also runs 'total-j' times for each middle loop

ie total*(total*(total+1)/2)*(total+(total-1)+(total-2)....+1)

= total*(total*(total+1)/2)*(1+2+3....+total)

= total*(total*(total+1)/2)* (sum of first 'total' natural numbers)

= total*(total*(total+1)/2) * (total*(total+1)/2).. So finally you will get something close to

total * (total*(total+1)/2) * (total*(total+1)/2).

Sorry there's a correction as @andreas mentioned innermost and middle loops run only till total-i-1 times in which case it will be the sum of first (total-1) no.s which should be (total-1)*total/2 so the final output should be

total * (total*(total-1)/2) * (total*(total-1)/2) .

Answer 5

The equation is like below and the k is equal to total :

Answer 6

As we know, the sum of an arithmetic progression is:

The inner-most loop will loop for

times, which is a function to j .

You sum it up and get a function to i , aka:

You sum it up again and get a function to total , aka:

---

For Mathematica users, the result is:

f[x_]:=Sum[Sum[x-j,{j,i+1,x-1}],{i,0,x-1}]

From here , we can see it more clearly, and the FINAL result is:

where x is total .

Answer 7

If we run this loop 100 times and generate a data set, then graph it, we get this:

Now, this graph is clearly a cubic. So we can do a solve using the cubic equation of ax^3+bx^2+cx+d.

Using 4 points, the values of them all are:

So the full equation is

y=x^3/6-x/6
y=x(x^2/6-1/6)
y=(x/6)(x^2-1)

Interactive Graph:

 <iframe src="https://www.desmos.com/calculator/61whd83djd?embed" width="500px" height="500px" style="border: 1px solid #ccc" frameborder=0></iframe> 

Answer 8

That function will loop (total/6)*(total*total - 1) times The snippet bellow just verifies that

 var total = 100 var sum = 0; for(var i = 0; i < total; i++) { for(var j = i + 1; j < total; j++) { for(var k = j; k < total; k++) { sum++; } } } function calc(n) { return n*(n-1)*(n+1)/6 } console.log("sum: "+sum) console.log("calc: "+calc(total)) 

Answer 9

A simple loop like this:

for (i = a; i < b; i ++) {
    ....
}

runs ba iterations ( i takes the values: a , a+1 , a+2 ... b-2 , b-1 ) if a < b and 0 iterations otherwise. We will assume below that a < b always.

Its number of iterations can be compute using the simple maths formula:

Applying the formula to your code

We start with the innermost loop:

for(int k = j; k < t; k++) {
    sum++;    
}

Its number of iterations is:

Using the formula above, the value of U is (t-1)-j+1 which means:

U = t - j

Adding the middle loop

Adding the middle loop, the number of iterations becomes:

The terms of the second sum are t-(i+1) , t-(i+2) , ... t-(t-2) , t-(t-1) .
By solving the parentheses and putting them in the reverse order they can be written as:
1 , 2 , ... ti-2 , ti-1 .

Let p = t - j . The second sum now becomes:

It is the sum of the first ti-1 natural numbers and its value is:

Adding the outer loop

Adding the outer loop the sum becomes:

On the last sum, the expression (t - i) starts with t (when i = 0 ), continues with t-1 (when i = 1 ) and it keeps decreasing until it reaches 1 (when i = t - 1 ). By replacing q = t - i , the last sum becomes:

The last expression subtracts the sum of the first n natural numbers from the sum of the first n square numbers . Its value is:

Now it's easy to simplify the expression:

The final answer

The number of iterations of the posted code is: