Peterson Algorithm for process synchronisation
Firstly, since the program at the start the question starts with "flag[$i$] = true", it should be run by Process $i$. Here is the full program again formatted slightly better. Note that the I replace "Enter critical section" and "exit critical section" with comment "// inside the critical section", since there is no code that actually corresponds to them. Once the process breaks out of the "while (P)  do no-op" loop, it is in the critical section (CS). The process is exiting the critical section at the exact point of time when it is executing "flag[$i$] = false".


  repeat
  
  
  flag[$i$] = true;
  turn = $j$;
  while ($P$) do no-op;
  Perform some actions  // inside the critical section
  flag[$i$] = false;
  Perform other non-critical section actions.
  
  
  Until false;


The following is the full program run by Process $j$. You should be able to figure out the code represented by $Q$ once you have accepted my answer. :)


  repeat
  
  
  flag[$j$] = true;
  turn = $i$;
  while ($Q$) do no-op;
  Perform some actions   // inside the critical section
  flag[$j$] = false;
  Perform other non-critical section actions.
  
  
  Until false;


These two different programs together that are run by two different processes respectively at the same time competing for (some resources inside) the critical section (CS) is Peterson's algorithm.

Secondly, there is a fatal typo in the "important lines from the algorithm" with line numbers in the question. The second line


  2) turn = process ;


should be 


  2) turn = other ;


Indeed, this line is the key to understand how Peterson's algorithm ensures mutual exclusion. Please note "the important lines from the algorithm" are executed sequentially at the same time by two processes, each considering itself as the "process" and the other process as "other" in those "important lines".  By executing this line, each process tries letting the other process to have a higher priority over itself to enter CS..

A minor typo in OP's question is "while (interested [other] == True" should be "while flag [other] == True".

Thirdly, OP asks which process is exactly currently executing. The answer is not just Process $i$. The answer is not just Process $j$. The answer is both processes. In fact, we can assume both process are executing at all times, each executing a different program. That is what we mean by concurrent processes or concurrent programming. Is it surprising? Please note, however, if the question is which process is exactly executing the program written at the start of OP's question, then, as I have said at first, the answer is Process $i$.

Fourthly, OP asks "which process are we blocking in while loop i.e stopping to enter CS?". Of course, the answer is the current process, that is, the process that is currently executing that line of code. It is the other process if you write the loop uniformly as "while (flag [other] == True &amp;&amp; turn == process)", which can be either Process $i$ or $i$. It can only be Process $i$ if the loop is "while (flag[$j$] = true and turn = $j$)". It can only be Process $j$ if the while loop is "flag[$i$] = true and turn = $i$)". 

Lastly, the "option b) flag[$j$] = true and turn = $j$" should be what $P$ stands for. Here "flag[$j$] = true" means process $j$, the other process, is interested in entering or staying in the critical section(CS) while "turn = $j$" say that the other process is either holding CS or, if other process is interested in entering CS, it has the priority over the current process to enter CS. Both conditions together imply the current process cannot enter CS. Once Process $j$ is not interested in CS by setting flag[$j$] to false, or once the value of variable "turn" is $i$, meaning Process $i$ has a higher priority over Process $j$ to enter CS, the "while (P)" loop is broken and Process $i$ is in CS. (I am avoiding to say "enter CS" here, just to emphasize the fact that there is no other code that enables or represents the act of entering CS. Process $i$ enters CS by breaking out of that while loop.) 

All other options, (a), (c) and (d), are apparently wrong. For more detailed analysis, please check Peterson algorithm at Wikipedia.