Difference between these algorithm representations? - algorithm

Question

Recently I've been studying algorithm analysis and in my class I've seen code like this to represent a sample algorithm:
z = 0
for x = 1; x <= n; x++ do
for y = 1; y <= n; y++ do
z = z + 1
end for
end for
I understand that these for loops can be read as "as long as x/y is equal or lower than n do the following and at the end of each cycle add 1 to x/y, then test the condition again". However in some books like the algorithm design manual I see stuff like this:
r:= 0
for i:= 1 to n do
for j:= 1 to i do
for k:= j to i + j do
r:= r + 1
return (r)
Is it esencially the same as the first example I gave or does it mean something different? It also conflicts me that in the second example there is no increments like x++ so that the loop stops after a certain number of cycles. Also why stating k:= j instead of simply k:= 1 since j=1 in this algorithm?
Clarification: I didn't mean to ask if they do the same in the sense of producing the same output, but rather refer to if the for loops in both of them work the same as in stopping after the value of n is matched when adding 1 after each cycle to for example the variable i (as it was done for x or y in the first example).

Answer 1

It looks like your first algorithm is using a C-like notation where it specifies the starting state, the condition to proceed, and how the state gets updated after each iteration.
The second one appears to be using loops based on iterating over a specified range: "for each of the values in this range, do the following...". This is fairly common in modern scripting languages such as Python or Ruby, and is arguably closer to how people think about iteration.
Either algorithm can be written using the other one's notation.
Algorithm 1 / style 2
z := 0
for x := 1 to n do
for y:= 1 to n do
z := z + 1
return(z) # I’m assuming you actually wanted a return value
Algorithm 2 / style 1
r = 0
for i = 1; i <= n; i++ do
for j = 1; j <= i; j++ do
for k = j; k <= i + j; k++ do
r = r + 1
end for
end for
end for
return(r)
Stick with one style or the other, and you'll see that the differences in the counts aren't because of the different pseudocode styles. These are different algorithms.

Answer 2

The second one is not really the same as the first one.
I read
for i;= 1 to n do
because of 1 to n as
for i = 1; i <= n; i += 1
In each j-loop k is starting from j. So k is starting from 1 only in the first
j-loop of each i-loop.
While the first algorithm is simply imaginable as rows and columns, the second one is not.
function a1(n) {
console.clear();
console.log('algorithm 1');
console.log('n = ' + n);
console.log('x | y | z');
var x, y, z = 0;
var tr, td;
for (x = 1; x <= n; x += 1) {
tr = document.createElement('tr');
for (y = 1; y <= n; y++) {
td = document.createElement('td');
z = z + 1;
console.log(x + ' | ' + y + ' | ' + z);
tr.appendChild(td);
td.innerHTML = z;
}
tbl1.appendChild(tr);
}
}
function a2(n) {
var i, j, k, r = 0;
console.clear();
console.log('algorithm 2');
console.log('n = ' + n);
console.log('i | j | k |i+j| r')
for (i = 1; i <= n; i += 1) {
for (j = 1; j <= i; j += 1) {
for (k = j; k <= (i + j); k += 1) {
r = r + 1;
console.log(i+ ' | ' + j + ' | ' + k + ' | ' + (i+j) + ' | ' + r);
}
}
}
return (r);
}
// output table 1 handle
var tbl1 = document.getElementById('output1');
// Event handlers for buttons a1 and a2
document.getElementById("a1_start").addEventListener("click", function(){
a1(5);
});
document.getElementById("a2_start").addEventListener("click", function(){
console.log('returns ' + a2(4));
});
td {
text-align: center;
border: solid 1px #000;
}
<button id="a1_start">
start algorithm 1
</button>
<button id="a2_start">
start algorithm 2
</button>
<table id="output1">
</table>