How to find the middle position between two given position in a 2D array

I have a 2D array where I want to find the middle position between two given position:
below eg shows the indexes at each position.

00, 01, 02, 03
10, 11, 12, 13
20, 21, 22, 23
30, 31, 32, 33

Inputs:

• For position 23 and 33 I should get the output position 31.
  Here the inputs are iStart is 2 and jStart is 3, similarly iEnd is 3 and jEnd is 3
  The expected o/p is i_mid = 3 and j_mid = 1

• For position 00 and 22 I should get the output position 11.
  Here the inputs are iStart is 0 and jStart is also 0, similarly iEnd and jEnd are equal to 1
  The expected o/p is i_mid = 1 and j_mid = 1

• For position 02 and 23 I should get the output position 12.
  Here the inputs are iStart is 0 and jStart is 2, similarly iEnd is 2 and jEnd is 3
  The expected o/p is i_mid = 1 and j_mid = 2

• For position 10 and 31 I should get the output position 20.
  Here the inputs are iStart is 3 and jStart is 1, similarly iEnd is 3 and jEnd is 1
  The expected o/p is i_mid = 2 and j_mid = 0

I released that to calculate we should also know the length of the array as it is nxm matrix, ie. max value of i can go is n and max value of j can go is m.
therefor for a nxm array iMax will be n and jMax will be m

Now the function can be represents as:

void getMiddle(int iStart, int jStart, int iEnd, int jEnd, int iMax, int jMax) {


 //We need to find the mid_i and mid_j of the input positions
 System.out.println("midd_i = "+ mid_i +" and midd_j = "+mid_j);
}

I solved this via a brute force approach, however I'm looking for an optimal solution.

In my approach, first I find the number of elements that can come between the given position and then I divided the number of element by 2 and traverse the position till half of the elements that can come as that point will be the mid, my solution is as followed:

void getMiddle(int iStart, int jStart, int iEnd, int jEnd, int jMax) {
   int numberOfRows = (iEnd - iStart) + 1;
   int totalElementsInRows = jMax * numberOfRows;
   int eliminateStartElements = jStart;
   int eliminateEndElements = (jMax - 1) - jEnd;
   int totalElementsPresentBetweenPositions = totalElementsInRows - (eliminateStartElements + eliminateEndElements);
   int halfElement = totalElementsPresentBetweenPositions/2;
   int countElement = 0;
   for(int i = iStart; i<= iEnd; i++) {
      for(int j = 0; j< jMax; j++) {
        countElement++;
        if(halfElement == countElement) {
          System.out.println("midd_i = "+ i +" and midd_j = "+j);
          break;
        }
      }
  }
}

I'm sure there should be an optimal solution, If anyone have the optimal solution, please help.

It's a wrong approach, please see the comment section below.

////////////////////////////

You can find the average between the points. When you have point A and point B. The program has to compute average in two dimensions: x=(Ax + Bx)/2. Similarly in the y-axis.

You don't have to worry about .5 appended to end of the number, because Java will truncate it for you.

There should be a way to do this with a geometric approach...

Find the midpoint between the two you want to get, so if you wanted to find the position between mat[0][0] and mat[2][2], you find the midpoints:

mid = (Math.abs(x1 - x2) / 2, Math.abs(y1 - y2) / 2)

x = (2 - 0) / 2 = 1
y = (2 - 0) / 2 = 1

so the answer there would be mat[1][1]

if it were a less straightforward example, such as mat[0][2] and mat[3][3]:

we first find the midpoint, such as:

x = (3 - 0) / 2 = 1.5
y = (3 - 2) / 2 = 0.5

round the answers to the nearest whole number to get the right indexes

You can simplify the task by imagining concrete numbers in the respective positions instead of the indices, which range from 0 to n x m - 1. Something like :

 0,  1,  2,  3
 4,  5,  6,  7
 8,  9, 10, 11
12, 13, 14, 15

Then for each elemnt at m[i][j] applies

m[i][j] = i * m[i].length + j

and for each k, 0 <= k < n x m

 i = k / m
 j = k % m

which sums up in your method looking like:

static void getMiddle(int iStart, int jStart, int iEnd, int jEnd, int iMax, int jMax) {
    int s = iStart * jMax + jStart;
    int e = iEnd * jMax + jEnd;
    int mid_i = ((e+s)/2)/jMax;
    int mid_j = ((e+s)/2)%jMax;
    System.out.println("midd_i = "+ mid_i +" and midd_j = "+mid_j);
}

Note: I'm not checking for valid inputs, for example if iStart <= iEnd <= iMax

Test out put with your input example:

getMiddle(0, 0, 2, 2, 4, 4);
getMiddle(0, 2, 2, 3, 4, 4);
getMiddle(1, 0, 3, 1, 4, 4);

midd_i = 1 and midd_j = 1
midd_i = 1 and midd_j = 2
midd_i = 2 and midd_j = 0