Nested loops, how many times does it run? - java

How many times does this nested loop run. How do I determine it by looking at the code.
int i = 5, j =0;
while (i>0)
{
j = 1;
while (j<i )
{
System.out.println(“Inner loop!”);
j++;
}
System.out.println(“Outer loop!”);
i

Since you left out the -- from the i-- on the last row, this will never terminate.

well, first off, the code isn't complete, and depending on how it completes changes the answer completely. It should be something like:
int i = 5, j =0;
while (i>0)
{
j = 1;
while (j<i )
{
System.out.println(“Inner loop!”);
j++;
}
System.out.println(“Outer loop!”);
i++; // OR i--;
}
If the case is the final part is"i++" at the end it runs for an infinite number of times, because when "While(i>0) " evaluates, "i" never becomes less then 0. And "infinite" only in logic, as numbers (integers in this case) have a definite upper bound in code/compilers.
If its "i--" then its a simple matter of counting. The larger loop, [while (i>0)] will count down from 5 to 0, and quit when i is zero, that means it will will run with i=5, i=4, i=3, i=2, and i=1. This means effectively the outer loop runs 5 times, and each time it runs a little less.
J starts at 1 and counts up to just under i [while(j [lessthen] i)], meaning it will run the first time counting 1 to 4, because J starts at one, and goes to one-less-then i (5 the first time). So 4 the first time, 3 the second time, 2 the third time, 1 the forth time, and none the fifth time, because in that last case the evaluation is 1(j)[lessthen]1(i), which is false and exits the loop.
To get your final number, you count the number of times the inner loop happens successfully, in this case 4 + 3 + 2 +1 or....10 times. Assuming its "i--"

Related

In this code, error showing "division by zero", for the condition inside the while loop. Why is this happening?

Here when I add System.out.println(j) inside the loop, the initial number is random, and the next outputs are huge values from 400000
Value of j is Initialized to 1, does while loop counts all int values unless mentioned?
public static void main(String[] args) {
int num = 31;
int j = 1, c = 0;
while (num != 0) {
//System.out.println(j);
if (num % j == 0) {
c += j;
}
j++;
}
System.out.println(c);
}
The only way that the loop could be exited in normal circumstances, is if num became 0. But you never reassign num to any other number, so it is always 31, so the loop won't end (in a regular manner).
What happens though is in your loop you're incrementing j on every pass. j is declared an int. ints have maximum values defined, after which they go to minimum value, so from maximum (positive) number, after another increase you get a minimum (negative) number. Then you count up till you reach 0. And then the exception is thrown as the application tries to divide by 0.
(see here: What happens when you increment an integer beyond its max value?)
The reason you see 400000 as the first displayed value is because the loops go so fast, that the console is not able to handle it gracefully, and you see just some of the outputs displayed.
Not sure what you're trying to achieve, but in order for this program to work differently, either change the loop condition or add a break statement inside - as mentioned in the comments.

Iterator variable in Java for loops

Say I have this code
for (int i = 0; i < 6; i++) {
// do something in here
}
Will the variable i increment 5 times or 6 times? I had this question on an exam and wrote 6 because I thought that since i started at 0, it would need to be incremented 6 times in order to break the loop conditional.
The variable i will be incremented 6 times and the loop will run 6 times. After the last increment i will be equal to 6, the loop will see that the condition i < 6 is not met, and therefore will break out of the loop.
You should see the difference between an increment and an iteration.
i=0 at the beginning, the loop runs for the 1st time and i increments to 1
i=1 now, the loop runs for the 2nd time and i increments to 2
i=2 now, the loop runs for the 3rd time and i increments to 3
i=3 now the loop runs for the 4th time and i increments to 4
i=4 now, the loop runs for the 5th time and i increments to 5
i=5 now, the loop runs for the 6th time and i increments to 6
i=6 now, the loop does not run because i < 6 is not true and no increment happens
As you can see above, there were 6 iterations and 6 increments. Note that this may not always be the case where the number of iterations is equal to the number of increments/decrements.
If you define the variable i outside of the for loop and then print its value out after the loop is finished, you will see that i will be equal to 6.
Check this out:
int i;
for (i = 0; i < 6; i++) {
// do something in here
}
System.out.println(i);
as long as i = 0,1,2,3,4,5 the condition is true, so it should be 5 iterations.
(6 cycles)
You can also add System.out.print(i); to see the output.

the number of iterations of >>>> "for(int i=start;i<num;i++)" i

i'm talking about for loops in that form for(int i=0;i<5;i++)
i was expecting that the increment statement is done after the check and i think i wrote programs depending on that concept .
the problem is that when i tried to run that code
`for( int i = 0; i<5; i++) {
System.out.println(i);
}
i was surprised to find the doesn't include 5
the output was
0
1
2
3
4
i'm confused with this i think the statments must be executed at its order
Write it like this i<=5:
for( int i = 0; i<=5; i++) {
System.out.println(i);
}
Output:
0
1
2
3
4
5
The sequence of a for loop is something like this:
Perform the initial expression (e.g. assign initial values)
BEGINNING OF 1ST LOOP ITERATION:
Check if the condition is true, and end the loop if it isn't
Do the body of the loop
Increment
BEGINNING OF 2ND LOOP ITERATION:
Check if the condition is true, and end the loop if it isn't
Do the body of the loop
Increment
BEGINNING OF 3RD LOOP ITERATION:
Check if the condition is true, and end the loop if it isn't
Do the body of the loop
Increment
...
And so on. As you see the increment is done just before each check, not after the check as you thought.
The statement within the loop runs first and then increments the value of 'i'. This is how i++ functions, it will have i=0 for first loop and so on. So, on the 5th iteration i will be equal to 4.
As soon as i becomes 5 after executing the statements for 5th time, it no longer satisfies the condition i<5 and exits the loop.
In Java, typically the indexing starts from 0.
But still, if you want 1,2,3,4 and 5 as indexes. Use for(int i=1;i<=5;i++).
The reason why you do not get a 5 is because of the logic operator <.
i = 0;
is i < 5? Yes.
[..] i = 5; is i < 5? No. 5 < 5 is false.
for (int i = 0; i <= 5; i++)
{ System.out.println(i); }
This will give you 5 since you check if it is equal to it.

Java Nested For loops run time analysis

Say I have the following for loops:
for (int i = 1; i < n; i*=2) {
for (int j = 1; j < i; j*=2) {
//constant functions here
}
}
The outer loop will run log(n) times, my question is about how many times the inner loop will run. We can approximate j to be 2s, for some s, and it will stop when 2s < i, which can again be approximated to 2r, for some r. If we take the log of both sides, we get that s < r, which is when the second for loop will stop. Based on this, can we say that the inner loop runs constant times? And that the total number of times this function will run is just log(n)?
First neglect the outer loop, suppose the value of i =4, the inner loop will run for log(4) times, generalizing the inner loop will run log(i) times,for different values of i. Now consider the outer loop, value of i changes log(n) times. Hence the complexity is log(n)*log(i) or just simply (log(n))^2
in one word the answer is : Log2(n)2
Proof
consider Log2(n) = k so we have in first iteration of outer loop, inner loop runs 1 time because i = 2, in second iteration inner loops runs 2 times because i = 4, and ... in k'th iteration of outer loop, inner loop runs k times because i = 2k so number of your iterations:
1 + 2 + ... + k = k(k+1)/2
so the answer is O(Log2(n)2)

cannot understand for statement result

Our teacher in my AP Computer Science course gave us this code
final int LIMIT = 5;
int i, count;
for (count=1; count<=LIMIT; count++)
{
for (i=0; i<count; i++)
{
System.out.print(count);
}
}
System.out.println();
When this code executes, the output is as follows
1
22
333
4444
55555
I do not have a good understanding of the for statement and I cannot understand why the code would print 1 once, 2 twice, 3 three times, ect. Can someone please try to explain this to me?
This is a great question and covers the basics of for loops.
Thinking About For Loops: The Basics
Think about the code you have written above in this way:
A for loop does ("executes") what is enclosed in its body once for each time you specify - or, to think about it another way, until a condition that you specify is false. As the coder, you need to tell the program: [1] at what point to begin; [2] how many times to do it (better thought about as "until when to do it"); [3] and by how many the code should "count" (what we call "increment").
To demonstrate with pseudo-code:
for ([1]; [2]; [3])
or
for (where to begin; how many times; how to count) {
// DO SOMETHING
}
Remember, as you "count", you are increasing - in the case of the first for loop - the count variable by the how to count piece (count + how to count). What you have in your above code is a nested for loop - a loop inside another loop (described, below). Referencing the pseudo-code I have written, above, your first for loop does the following:
for (start counting at 1; iterate once until count is greater than 5; increment count by 1)
Your Question
Now, comes the piece that is throwing you. You have two variables to pay attention to because you have two for loops: count, in the first for loop (used by the second); i in the second. Each time your first for loop iterates, the first for loop must execute the second for loop (look at your code). Again, pay attention to the two variables - but, more importantly, the relationship between the variables in both for loops' conditions. The second for loop depends upon the first. Think about it this way:
As count is incremented (here, increased by one), the second for loop must execute its own operation that many times:
for (i starting at 0; i not equal to count; increment by 1)
So, at the first iteration you would see something like this:
for (count = 1; count will always iterate once until condition false; increment){ }
for (i = 0; i < count (1); increment i){ }
Result will be:
1
Then the first loop is incremented (count becomes 2) and you get:
for (i = 0; i < (2); increment i)
Because the second loop will iterate until i is no longer less than 2 (not including 2), your result will be:
22
This relationship will continue until you get your final result:
55555
A Final Comment
Your teacher is looking to teach you a few different things with the code you provided, above, namely two: nested for loops; and how initializing your iterator (i and count) and the condition statement <, >, <=, >=, etc.) affects the behavior of a loop.
The first for loop indicates that it will loop the contents LIMIT times(which is 5), incrementing count by 1 at the end of each loop. The second inner for loop indicates that number of times to print the number count.
Might be easier to understand with indentation of your code:
final int LIMIT = 5;
int i, count;
for (count=1; count<=LIMIT; count++) {
for (i=0; i<count; i++) {
System.out.print(count);
}
System.out.println();
}
The first for loop starts at 1 and ends at limit 5. The inner loop starts at 0 and goes to the current count. So for the first iteration the inner loop will go from 0 to 1. This will print count 1 time which count is 1. The second time through the outer loop the counter will be 2 so the inner loop will loop from 0 to 2. It will print 2 twice. The 3rd time through count will be 3. The inner loop will loop from 0 to 3 and print 3 3 times. Etc... This is nested looping.
The first loop will write 5 lines as LIMIT = 5
The second loop will write n times the current index of the first loop, for each line.
n equals the current index of the first loop. So line #1, one time 1, line #2, two times 2, ....
You have two for loops, the outer loop starts count with a value of 1 and will iterate until count has a value greater than 5. The inner for loop will start with a value of 0 and will iterate until i has a value greater than or equal to count. So,
count <- 1
i <- 0
while (i < count) { print(count); i++; } // <-- 0 to 1 is a range of 1
newline();
Then
count <- 2
i <- 0
while (i < count) { print(count); i++; } // <-- 0 to 2 is a range of 2
newline();
And so on.
It is probably best to explain this by walking through the steps on by one...
final int LIMIT = 5;
int i, count;
for (count=1; count<=LIMIT; count++)
{
for (i=0; i<count; i++)
{
System.out.print(count);
}
System.out.println(); //from the results you are getting, this statement should be here
}
To put this in human readable terms:
A. we have a number LIMIT that is 5
B. we have a number i and count
C. set the number count to 1
D. if the number count is less than LIMIT, do the following:
1. set the number i to 0
2. if the number i is less than the number count, do the following:
a. print out the number count
b. add 1 to the number i
c. go back to step 2
3. print out an empty line
4. add 1 to the number count
5. go back to step D
So, if we go through the loops, here's what our variables become:
count is set to 1
count is less than 5
i is set to 0
i is less than count? yes, i is 0 and count is 1
print out the value of count (which is 1)
add 1 to i
i is 1
is i less than count? no, i is 1 and count is 1
print out a new line
add 1 to count
count is 2
count is less than 5
i is set to 0
i is less than count? yes, i is 0 and count is 2
print out the value of count (which is 2)
add 1 to i
is i less than count? yes, i is 1 and count is 2
print out the value of count (which is 2)
add 1 to i
is i less than count? no, i is 2 and count is 2
print out a new line
add 1 to count
count is 3
etc.
This continues until count is greater than 5, at which point it exists. As you can see from the pattern, the variable count determines which number gets printed, and the variable i determines how many times it is printed.

Categories