Answers 1 and 2 are both correct. But nevertheless, your last comment shows that there is still some kind of surprise in your code. If ptr points to int[3] arrays, why does the second printf show the consecutive values of 0, 1, 2 then?
The answer is partly contained in your comment:
"Then ((ptr+0)+0) is ptr[0][0], ((ptr+0)+1) is ptr[0][1] and ((ptr+0)+2) is ptr[0][2] right?"
No, that is not correct. "((ptr+0)+1)" is the same as "ptr+1" and that again is the same as &ptr[1] and that again is the same as &ptr[1][0]. The parentheses work just as always in arithmetic expressions. That is the reason you see an increment of 12 in the first printf.
In your second printf, you wrote expressions like *(*(ptr+0)+1). Notice that the dereference operator (*) binds stronger than the addition, so that means:
*( (*(ptr+0)) + 1 )
which again is
*( (*ptr) + 1 )
The *ptr delivers a int[3]. You can't add 1 to an integer array, so the compiler converts it to an int*. Adding 1 gets you the next consecutive int cell. And that is why you are seeing 0, 1, 2.
Or, in other words, (*(ptr+0)+1) does correspond to &ptr[0][1], while ((ptr+0)+1) does not.
Got it now?