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.
Related
I am trying to do in Java:
int i=5;
while(i-- >0) {
System.out.println(i);
}
When running this program the output is:
4
3
2
1
0
I am very surprised to see 0 in output. I am new in development. Can anyone justify this?
In your while condition i-- > 0, the variable i is evaluated first and then decremented.
When i reaches the value 1, it will pass the loop test and then get decremented to 0. This is why the print statement shows 0 in the output.
Here is a mnemonic you can use to keep track of how the decrement and increment operators work:
int i = 5;
System.out.println("When i = 5 then:");
System.out.println("i-- is " + i--);
i = 5;
System.out.println("--i is " + --i);
Output:
When i = 5 then:
i-- is 5
--i is 4
Simply, because you compare i>0 and decrement i afterwards.
// If I is 1, you compare 1>0 and decrement i afterwards.
// This is how the postdecrement operator works
while(i-- >0) {
System.out.println(i);
}
the loop will behave like the following.
is i=5 > 0?
decrement i to 4
output i = 4.
is i=4 > 0?
decrement i to 3
output i = 3.
...
and so on
As you can see the value you compare to 0 is allways higher then the one you are outputing. This happens due to how the -- operator works. If it´s preceding to the i as --i it will decrement the variable i first and return it´s value afterwards. If it´s not preceding as in your case i-- you will have the value of i returned first and i beeing decremented afterwards.
Postdecrement/Increment operator works on the principle "Use first and then Change"
Initially value of i=5, when it enters while loop it will compare value of i first and then it prints the decremented value. Here i will show you each iteration along with checks performed in each iteration,
Now value of i=5(in memory), inside while(5>0), it prints 4.
Now value of i=4(in memory), inside while(4>0), it prints 3.
Now value of i=3(in memory), inside while(3>0), it prints 2.
Now value of i=2(in memory), inside while(2>0), it prints 1.
Now value of i=1(in memory), inside while(1>0), it prints 0.
Hope now you are clear to go ahead. Gud Luck.
The post-decrement operator -- is like a post-paid service. Like a credit card, first you use, then you pay.
I thought I can give you a real-life idea of what really is occurring in this statement, when i == 1
while(i-- >0)
So, first you check if i(1)>0. 1>0 So, yes it is. Right after this statement is done, i becomes 0. Then, you print that value.
Alternatively, you might also get this intuition by noticing that although your loop started with i=5, the value 5 never got printed.
Since you are using the post-decrement operator in the while loop, when i is 1, i-- returns 1, and then inside the loop you get 0 when you print i for the last time.
Only because of post decrement operator (i--) will check the condition first then decrease the value of i. Output is giving such. Thank you
int i=5; //initialize with 5
while(i-- >0) { //post decrements operator so, check condition first then decrease the value.
System.out.println(i);
}
In first iteration of while loop will check 5 > 0 will be checked after that decrease the value of i and i will become 4 So, Print it 4 not 5.
When i = 5 conditional statement will be (5>0) (true) and print 4.
i = 4 conditional statement will be (4>0) (true) and print 3.
i = 3 conditional statement will be (3>0) (true) and print 2.
i = 2 conditional statement will be (2>0) (true) and print 1.
i = 1 conditional statement will be (1>0) (true) and print 0.
Now, i became 0 so conditional statement will be (0>0) (False).
So, loop exits.
To get desired output try this
while(--i >0) {
System.out.println(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.
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--"
I am trying to find a way to count down from the int that is input by a user and then add each second value as i count down to 0
for example.
{user inputs 10
program counts down 8,6,4,2,0
then add 10 + 8 + 6 + 4 +2 +0= 30
}
how can I do this using a nested for loop
so far I have only been able to take user input, and count down by 2 each time. I get to 0 but have no way of adding every second value.
My code:
so far, it just counts to 0
public class Week5b {
static Scanner userVal = new Scanner (System.in);
public static void main(String[] args) {
//printTable();
reverseAddSkip();
public static void reverseAddSkip(){
System.out.println("Please enter an integer");
for (int i = userVal.nextInt(); i >=0; i-=2){
System.out.println(i) ;
}/* this creates a loop where the variable i is equal to user input;
the condition for the loop to continue is whether the input is larger or equal to 0; the update part of the loop takes 2 away each time, as if it were -- (which takes away one each time) */
}
}
How would I write that out mathematically?
Adding the sum of i-=2 to the original value of i.
You type 11 , it counts 9 7 5 3 1 , then adds 11 9 7 5 3 1. and give you the sum.
don't know how to sum every 2 numbers decrementing by 2, from a user value.
You input put 50, it counts down by 2 to 0
you put 51 it counts down by 2 to 0
but I haven't found away to sum all then numbers that were generated before getting to 0
:/
NoGlitching,
You need to look at the control flow of your program - which is to say, the path it takes upon execution.
You should also look at using more variables.
I'll give you the pseudocode I would use, because I think it's important for you to be able to write the code yourself:
Make a new integer called OriginalInput.
Make a new integer called RunningTotal.
Set RunningTotal to 0.
Store the user's input in OriginalInput.
Loop through OriginalInput.
Print the current OriginalInput.
Add the current OriginalInput to RunningTotal.
When the loop is finished:
Print RunningTotal.
I hope this helps.
EDIT:
// First you equalize j with i
input = userVal.nextInt();
j = i; // Put the user input in j first. for instance 11.
for (int i = input; i >=0; i-=2)
{
if (i >= 0) // If i is not below 0
{
j += i; // Add to j what i has now (everytime -2)
// put a system out print here to show what was added
// J starts as 11 and adds 9,7,5,3,1 then nothing. So it ends as 36.
}
}
// outside the For loop after it ends but INSIDE your method, you get the sum from the variable j!
public class Main {
public static void main(String args []){
long numberOfPrimes = 0; //Initialises variable numberOfPrimes to 0 (same for all other variables)
int number = 1;
int maxLimit = 10000000;
boolean[] sieve = new boolean[maxLimit]; //creates new boolean array called sieve and allocates space on the
//stack for this array which has maxLimit spaces in it
for ( int i = 2; i < maxLimit; i++ ) { //for statement cycling from 2 to 10000000, does not execute the rest
//of the block if the boolean value in the array is true
if ( sieve[i] == true ) continue;
numberOfPrimes++; //otherwise it increments the number of prime numbers found
if ( numberOfPrimes == 10001 ) { //if 10001st prime number is found, break from loop
number = i;
break;
}
for ( int j = i+i; j < maxLimit; j += i ) //do not understand the point of this loop logically
sieve[j] = true; //testing if the value in the array is true again?
}
System.out.println("10001st prime: "+ number);
}
}
I don't really understand what is going on in this program and was hoping somebody could explain it to me? I have commented the specific lines causing me trouble/what I understand lines to be doing. Thank you very much for all the help! :)
Make yourself familiar with Eratosthenes' Sieve algorithm. Wikipedia even has animated gif demonstrating the process. And your code is just a straightforward implementation of it.
Yes, this is your basic implementation of Eratosthenes' Sieve. There are quite a few ways in which you can improve it, but let's go over the basic principle first.
What you are doing is creating an array of boolean values. The INDEX in the array represents the number which we are testing to see if it is a prime or not.
Now you are going to start checking each number to see if it is a prime. First off, the definition of a prime is "all numbers divisible ONLY by itself and 1 without fractioning".
for ( int i = 2; i < maxLimit; i++ )
You start with the INDEX 2 (the number 3) because depending on your definition, 1 and 2 are always prime. (Some definitions say 1 is not a prime).
if ( sieve[i] == true ) continue;
If a number has been marked as a non-prime previously, we don't bother with the current iteration.
numberOfPrimes++;
if ( numberOfPrimes == 10001 ) {
number = i;
break;
}
If the INDEX we are at currently has not been marked as being a prime, it has to be one, so we increment the number of primes we have found. The next piece of code I'm assuming is part of the requirements of the program which states that if 10001 primes have been found, the program must exit. That part can be left out if you actually want to check for primes up to the maximum number defined in stead of for a specific number of primes.
for ( int j = i+i; j < maxLimit; j += i )
sieve[j] = true;
This is where the actual magic of the sieve starts. From the definition of a prime, a number cannot be a prime if it is divisible by anything other than itself and 1. Therefore, for any new number we find that is a prime, we can mark all it's factors as NOT being prime. For example, the first iteration of the for loop, we start with 3. Because sieve[2] is false (have not visited before), it is a prime (AND 3 IS A PRIME!). Then, all other factors of 3 CANNOT be primes. The above mentioned for loop goes through the entire sieve and marks all factors of 3 as false. So that loop will do: sieve[5] = true; sieve[8] = true ... up until the end of the sieve.
Now, when you reach the first number greater than the maximum defined initially, you can be certain that any number that has a factor has been marked as not being a prime. What you end up with is a boolean array, where each index marked as false, represents a prime number.
You can probably get a much better description on wikipedia, but this is the jist of it. Hope it helps!
for ( int j = i+i; j < maxLimit; j += i ) //dont understand the point of this loop logically
sieve[j] = true; //testing if the value in the array is true again ?
This is not a testing, but rather a setting. This loop is setting all the items in the array with indexes multiple of i to true. When i is 2, then the items 4, 6, 8 ... will be set to true. When i is 3, the items 6, 9, 12 ... will be set to true and so on.
And as you can deduce by the first if,
if ( sieve[i] == true ) continue;
... all the items that are true correspond to non-prime numbers.
I find the easiest way to understand something is to deconstruct it. Therefore, lets go through the loop a few times, shall we?
Dawn of the First Iteration
− 9999998 Values Remain −
i = 2
sieve[2] is false, so we keep going in the current iteration.
numberOfPrimes = 1 and thus we continue processing
Set every multiple of 2 to true in sieve[].
Dawn of the Second Iteration
− 9999997 Values Remain −
i = 3
sieve[3] is false, so we keep going in the current iteration.
numberOfPrimes = 2 and thus we continue processing
Set every multiple of 3 to true in sieve[].
Dawn of the Third Iteration
− 9999996 Values Remain −
i = 4
sieve[4] is true (from first iteration). Skip to next iteration.
etc... but in this case, the moon doesn't crash into Termina.
The loop in question isn't checking for true values, it's setting true values.
It's going through each multiple of the prime and marking it as non-prime up to maxLimit. You'll notice there's no other math in the code to determine what's prime and what's not.
This is the algorithm to find the prime numbers between 1 and the maximum limit given.
And the loop added 2nd is to make true for the number which is divisible by any other number. so for the first outer loop all the number divisible by two ll be set to true then divisible by 3 then by 4 and so on.. and the numbers for which the boolean array contains false are the prime numbers.