Why does this give value n^n if I'm just doing n^2?

I am doing a problem in Hackerrank and I got the testcases wrong. After inserting System.out.println commands here and there I finally found out whats wrong with the code:

It was in the while loop. I removed complexities from the while loop and executed a basic loop in my local eclipse environment and the result was same:

This is the code:

	int n=3;
		
		while(n<100)
		{
			System.out.println(n+" n WHILE");
				n=n*n;
			System.out.println(n*n+" n n WHILE");
		}

My understanding was that that n would initialize to n*n, instead it's being initialized to n^n.
The output is as follows:

3 n WHILE
81 n n WHILE
9 n WHILE
6561 n n WHILE
81 n WHILE
43046721 n n WHILE

Ok, I thought maybe some initialization problem or something and I modified the code as follows and its still the printing the same output.

	while(n<100)
		{
			System.out.println(n+" n WHILE");
			n=(int) Math.pow(n, 2);
			System.out.println(n*n+" n n WHILE");
		}

The above code has same output too. Now, I know I can add a duplicate variable to initialize properly but my question is why do the above implementations fail? Also, is keeping a duplicate variable my only workaround? What's the proper way to do that?

PS: Incase you're wondering the hackerrank problem link and my solution, I'll just give a pastebin link instead to lengthening this already large question.
Link = Link

The question code does not calculate n ^ n anywhere, but the way you print makes the output very confusing, because you're print n*n after already updating n, so you're actually printing n ^ 4.

Here is a better version of the print statements:

int n = 3;
while (n < 100) {
	System.out.println("n = " + n + "  ->  " + n + " * " + n + " = " + n * n);
	n = n * n;
}
System.out.println("n = " + n);

Output

n = 3  ->  3 * 3 = 9
n = 9  ->  9 * 9 = 81
n = 81  ->  81 * 81 = 6561
n = 6561

What you are calculating is n ^ (2 ^ i) where i is the number of iterations of the loop, i.e.

• After 1 iteration: n = n * n = n²   (3² = 9)
• After 2 iterations: n = (n * n) * (n * n) = n⁴   (3⁴ = 81)
• After 3 iterations: n = ((n * n) * (n * n)) * ((n * n) * (n * n)) = n⁸   (3⁸ = 6561)
• After 4 iterations: n = n¹⁶   (3¹⁶ = 43,046,721)
• After 5 iterations: n = n³²   (3³² = 1,853,020,188,851,841)
• After 6 iterations: n = n⁶⁴   (3⁶⁴ = 3,433,683,820,292,512,484,657,849,089,281)
• ...

That is a far cry from n ^ (i + 1), which might have been what you expected?

• After 1 iteration: n = n * n = n²   (3² = 9)
• After 2 iterations: n = n * n * n = n³   (3³ = 27)
• After 3 iterations: n = n * n * n * n = n⁴   (3⁴ = 81)
• After 4 iterations: n = n * n * n * n * n = n⁵   (3⁵ = 243)
• After 5 iterations: n = n * n * n * n * n * n = n⁶   (3⁶ = 729)
• After 6 iterations: n = n * n * n * n * n * n * n = n⁷   (3⁷ = 2187)
• ...

To do that, you need a separate result variable:

int n = 3;
int r = n;
while (r < 100) {
	System.out.println("r = " + r + "  ->  " + r + " * " + n + " = " + r * n);
	r = r * n;
}
System.out.println("r = " + r);

Output

r = 3  ->  3 * 3 = 9
r = 9  ->  9 * 3 = 27
r = 27  ->  27 * 3 = 81
r = 81  ->  81 * 3 = 243
r = 243

The line System.out.println(n*n+" n n WHILE"); prints the square of the current value of n.

If you remove this line, the output will make an awful lot more sense.

You are currently printing n, squaring n, and then printing the square of the new n (without squaring n a second time).

The lines ending in "n WHILE" start at 3 and keep squaring. They show the value of n.

The lines ending in "n n WHILE" start at 9 (3 squared) and keep squaring. They show the square of the value of n.

1. You are setting n (n1) to 3. Then print it.
2. Next, you are setting n (n2) to n*n (n1*n1) and then print n*n (n2*n2) in the second print statement. Using the notion n1,n2 you print n2*n2 = (n1*n1)*(n1*n1) = n1^4 which is 81.

Next loop prints 9^2 and 9^4.

The way you were printing the new value made no sense. You initialized n to n^2 and than did another n^2 on that in your print either of these would work.

 while(n<100)
 {
       System.out.println(n+" n WHILE");
       n=n*n;
       System.out.println(n+" n n WHILE");
 }

 while(n<100)
 {
      System.out.println(n+" n WHILE");
      System.out.println(n*n+" n n WHILE");
      n=n*n;         
 }