Pattern consisting of numbers moving in clockwise direction around a rectangular shape (length and breadth decreasing each time) [closed]

Answer 1

I just had to come up with this myself, code is for counter clockwise but you can change that simply by changing the directions array.

int x = 0;
int y = 0;
int c = width * height;
int directions[4] = { 0, 1, 0, -1};
int distances[2] = { height, width-1};
int di = 0;
int dx = directions[ di];
int dy = directions[ di+1];
int dis = distances[ di];

for( int i=0; i<c; i++)
{
    value = data[ y * width + x] = i;

    dis--;
    if( dis == 0)
    {
        distances[ di % 2]--;
        di++;
        dx = directions[ di % 4];
        dy = directions[ (di+1) %4];
        dis = distances[ di % 2];
    }
    x += dx;
    y += dy;
}

Answer 2

I would create 4 separate loops.

Loop 1 would create 1 2 3 4 5
Loop 2 would create 6 7 8 9
Loop 3 would create 10 11 12 13
Loop 4 would create 14 15 16

When this is done, you've filled out the outside of the square, and are left with a smaller, 3x3 square inside, which can be filled in exactly the same way, with exactly the same 4 loops.

Answer 3

package arrays;

public class SpiralPrinting {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[][] a = new int[][] { { 1, 2, 3 }, { 5, 6, 7 }, { 9, 10, 11 },
                { 13, 14, 15 } };

        int cols = a[0].length;
        int rows = a.length;
        Business1 b = new Business1();
        b.print(a, rows, cols);
    }
}

class Business1 {

    int i = 0;
    int j = 0;
    int count = 0;

    public void print(int[][] a, int row, int col) {
        int max = row * col;
        while (count < max) {
            for (int k = 0; k < col; k++) {
                System.out.println(a[i][j]);
                j++;
                count++;
            }
            row--;
            j--;
            i++;
            for (int k = 0; k < row; k++) {
                System.out.println(a[i][j]);
                i++;
                count++;
            }
            i--;
            j--;
            col--;

            for (int k = 0; k < col; k++) {
                System.out.println(a[i][j]);
                j--;
                count++;
            }
            row--;
            j++;
            i--;
            for (int k = 0; k < row; k++) {
                System.out.println(a[i][j]);
                i--;
                count++;
            }
            i++;
            j++;
            col--;

        }
    }
}

Answer 4

public ArrayList<Integer> spiralOrder(final List<ArrayList<Integer>> a) {
     ArrayList<Integer> result = new ArrayList<Integer>();
      int m = a.get(0).size();
      int n = a.size();
      if(m>1 && n>1){
         int loopCounter = (n > m)  ? m*2 : n *2 -1 ;
         int opr=1;
         int i=0,j=0;
         int opA=m,opB=n,opC=0,opD=1;
         for(int k=0;k < loopCounter ;k++){
              if(opr == 1){
                 int counter =0;
                 while(counter < opA){
                    System.out.print(a.get(i).get(j)+ ";");
                    result.add(a.get(i).get(j));
                    counter++;

                    if(j != opA-1){
                        j++;
                    }
                    else{
                        break;
                    }
                 }
                 opr =2;
                 continue;
             }
             if(opr == 2){
                 i++;
                 int counter =1;
                 while(counter < opB){
                     System.out.print(a.get(i).get(j)+ ";");
                    result.add(a.get(i).get(j));
                    counter++;

                   if( i != opB-1){
                     i++;
                   }
                   else{
                       break;
                   }
                 }
                 opr =3;
                 continue;
             }
             if(opr == 3){
                 j--;
                 int counter =j;
                 while(counter >= opC){
                     System.out.print(a.get(i).get(j)+ ";");
                    result.add(a.get(i).get(j));
                    counter --;
                     if(j != opC){
                     j--;
                    }
                    else{
                        break;
                    }
                  }
                 opr =4;
                 continue;
             }
             if(opr == 4){
                 i--;
                 int counter = i;
                 while(counter >= opD){
                     System.out.print(a.get(i).get(j)+ ";");
                    result.add(a.get(i).get(j));
                    counter --;
                    if(i != opD){
                     i--;
                    }else{
                        break;
                    }
                 }
                 opr =1;
                 j++;
                 opA = opA -1;
                 opB = opB -1;
                 opC= opC +1;
                 opD = opD+1;
                 continue;
             }
         }

     }

    else if(n ==1){
        for(int k=0;k < a.get(0).size();k++){
            result.add(a.get(0).get(k));
        }
    }

    // Populate result;
    return result;

}

Answer 5

I would do it this way:

Initialize a 5x5 two-dimensional array of integers to 0. Have a direction variable, and define constants or an enum for the four directions. Start moving 'right' from (0, 0), filling in the array with increasing values until you hit the edge or a number that is not 0. Then, increment the direction (and wrap) and continue. Then print the array in rows.

An alternative using loops is to iterate over all the (x, y) coordinates, and pass x and y into a function that gives you the value at that position. The function I wrote does exactly the same thing as would the function that fills the array, except it doesn't write to an array, and when it reaches the given (x, y) it returns the current value. Not very efficient, but it achieves the result.

Answer 6

Since this is a homework question, I'm just going to give you a hint -- start by writing this function:

void predecessor(int in_x, int in_y, int& out_x, int& out_y);

I won't say any more -- up to you to figure out what that function is for :)