Posted on by Kalkicode
Code Matrix

Print Half clockwise and Half anticlockwise spiral view of a matrix

The problem is to print the half-clockwise and half-anticlockwise spiral views of a given matrix. In the half-clockwise spiral view, elements are printed in a spiral manner starting from the top-left corner, moving to the right, then down, left, and so on. In the half-anticlockwise spiral view, elements are printed in a spiral manner starting from the top-right corner, moving down, left, up, and so on. The goal is to print these two spiral views of the matrix.

Example

Consider the following 7x6 matrix:

 1  2  3  4  5  6
22 23 24 25 26  7
21 36 37 38 27  8
20 35 42 39 28  9
19 34 41 40 29 10
18 33 32 31 30 11
17 16 15 14 13 12

The half-clockwise spiral view starts from the top-left corner and goes in the following order: 1 2 3 24 37 42 41 32 15 16 17 18 19 20 21 22 23 36 35 34 33. The half-anticlockwise spiral view starts from the top-right corner and goes in the following order: 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25.

Idea to Solve the Problem

half clockwise and anticlockwise spiral view of a matrix

To print the half-clockwise and half-anticlockwise spiral views of the matrix, we can follow these steps:

  1. Define a class MyMatrix to handle matrix operations.
  2. Implement the clockwise function to print the half-clockwise spiral view: a. Loop through each side of the spiral: i. Print the elements from left to right along the top side. ii. Print the elements from top to bottom along the right side. iii. Print the elements from right to left along the bottom side. iv. Print the elements from bottom to top along the left side. v. Decrease the value of k (number of remaining elements to print). b. If there are still elements to print and the inner spiral is not yet covered, recursively call the clockwise function with the updated boundaries.
  3. Implement the anticlockwise function similarly to the clockwise function to print the half-anticlockwise spiral view.
  4. In the spiral_view function, determine whether the matrix has more than 2 columns: a. If it has more than 2 columns, check if the number of columns is even or odd. b. Call the clockwise function and the anticlockwise function accordingly to print the two spiral views.
  5. Print the half-clockwise and half-anticlockwise spiral views of the matrix.

Pseudocode

clockwise(matrix, s_row, s_col, e_row, e_col, k):
    # Print left to right
    ...
    # Print top to down
    ...
    # Print bottom right to bottom left
    ...
    # Print bottom left to top
    ...
    if s_row + 1 <= e_row - 1 and k > 0:
        clockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k)

anticlockwise(matrix, s_row, s_col, e_row, e_col, k):
    # Print top to down
    ...
    # Print left to right
    ...
    # Print bottom left to top
    ...
    # Print top right to left
    ...
    if s_row + 1 <= e_row - 1 and k > 0:
        anticlockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k)

spiral_view(matrix):
    if this.cols > 2:
        if this.cols % 2 == 0:
            # Print clockwise and anticlockwise views
            ...
        else:
            # Print clockwise and anticlockwise views
            ...
    else if this.cols == 2:
        # Print clockwise and anticlockwise views
        ...

Code Solution

Here given code implementation process.

/*
  C Program 
+ Print Half clockwise and Half anticlockwise spiral view of a matrix
*/
#include<stdio.h>
#define ROW 7
#define COL 6

void clockwise(int data[ROW][COL],
  int s_row,
  int s_col,
  int e_row,
  int e_col,
  int k)
{
  //Left to right
  for (int i = s_col; i <=e_col && k > 0 ; ++i,k--)
  {
    printf("%4d",data[s_row][i] );
  }
  //Top to down
  for (int i = s_row+1; i <=e_row && k > 0  ; ++i,k--)
  {

    printf("%4d",data[i][e_col] );

  }
  //Bottom right to bottom-left
  for (int i = e_col-1; i >=s_col && k > 0 ; --i,k--)
  {
 
    printf("%4d",data[e_row][i] );
  }

  //Bottom left to top
  for (int i =e_row-1 ; i > s_row && k > 0 ; --i,k--)
  {
   
    printf("%4d",data[i][s_row] );

  }

  if(s_row+1 <= e_row-1 && k > 0)
  {
    //Recursive call
    clockwise(data,s_row+1,s_col+1,e_row-1,e_col-1,k);
  }
    
}


void anticlockwise(int data[ROW][COL],
  int s_row,
  int s_col,
  int e_row,
  int e_col,
  int k)
{

  //Top to down
  for (int i = s_row; i <=e_row && k > 0  ; ++i,k--)
  {

    printf("%4d",data[i][s_col] );

  }
  //Left to right
  for (int i = s_col+1; i <=e_col && k > 0 ; ++i,k--)
  {
    printf("%4d",data[e_row][i] );
  }

  //Bottom left to top
  for (int i =e_row-1 ; i >= s_row && k > 0 ; --i,k--)
  {
   
    printf("%4d",data[i][e_col] );

  }

  //top right to left
  for (int i = e_col-1; i > s_col && k > 0 ; --i,k--)
  {
 
    printf("%4d",data[s_row][i] );
  }


  if(s_row+1 <= e_row-1 && k > 0)
  {
    //Recursive call
    anticlockwise(data,s_row+1,s_col+1,e_row-1,e_col-1,k);
  }
    
}
void spiral_view(int arr[ROW][COL])
{

  if(COL>2)
  {
    //When exists more than 2 columns

    if(COL%2==0)
    {
      //When the  size of column are Even
      printf("\n Clockwise \n");
      clockwise(arr,0,0,ROW-1,(COL/2)-1,(ROW*COL)/2);
      printf("\n Anticlockwise \n");
      anticlockwise(arr,0,(COL/2),ROW-1,COL-1,(ROW*COL)/2);
    }
    else
    {
      //When the  size of column are Odd
      printf("\n Clockwise \n");
      clockwise(arr,0,0,ROW-1,(COL/2),ROW*(COL+1)/2);
      printf("\n Anticlockwise \n");
      anticlockwise(arr,0,(COL/2),ROW-1,COL-1,ROW*(COL+1)/2 );
    }

  }
  else if(COL == 2)
  {
    //When exists only 2 columns
    printf("\n Clockwise \n");
    clockwise(arr,0,0,ROW-1,COL-1,(ROW*COL));
    printf("\n Anticlockwise \n");
    anticlockwise(arr,0,0,ROW-1,COL-1,(ROW*COL));
  }


}
int main(){

  int arr[ROW][COL] ={
    {1, 2, 3, 4, 5, 6},
    {22,23,24,25,26,7},
    {21,36,37,38,27,8},
    {20,35,42,39,28,9},
    {19,34,41,40,29,10},
    {18,33,32,31,30,11},
    {17,16,15,14,13,12},
  }; 
  spiral_view(arr);



  return 0;
}

Output

 Clockwise
   1   2   3  24  37  42  41  32  15  16  17  18  19  20  21  22  23  36  35  34  33
 Anticlockwise
   4  25  38  39  40  31  14  13  12  11  10   9   8   7   6   5  26  27  28  29  30
/*
  C++ Program
  Print Half clockwise and Half anticlockwise spiral view of a matrix
*/
#include<iostream>
#define ROW 7
#define COL 6
using namespace std;


class MyMatrix {
	public:
		int rows;
	int cols;
	MyMatrix() {
		//Get matrix size
		this->rows = ROW;
		this->cols = COL;
	}
	void clockwise(int matrix[][COL], int s_row, int s_col, int e_row, int e_col, int k) {
		//Left to right

		for (int i = s_col; i <= e_col && k > 0; ++i, k--) {
			cout << " " << matrix[s_row][i];
		}
		//Top to down

		for (int i = s_row + 1; i <= e_row && k > 0; ++i, k--) {
			cout << " " << matrix[i][e_col];
		}
		//Bottom right to bottom-left

		for (int i = e_col - 1; i >= s_col && k > 0; --i, k--) {
			cout << " " << matrix[e_row][i];
		}
		//Bottom left to top

		for (int i = e_row - 1; i > s_row && k > 0; --i, k--) {
			cout << " " << matrix[i][s_row];
		}
		if (s_row + 1 <= e_row - 1 && k > 0) {
			//Recursive call
			this->clockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k);
		}
	}
	void anticlockwise(int matrix[][COL], int s_row, int s_col, int e_row, int e_col, int k) {
		//Top to down

		for (int i = s_row; i <= e_row && k > 0; ++i, k--) {
			cout << " " << matrix[i][s_col];
		}
		//Left to right

		for (int i = s_col + 1; i <= e_col && k > 0; ++i, k--) {
			cout << " " << matrix[e_row][i];
		}
		//Bottom left to top

		for (int i = e_row - 1; i >= s_row && k > 0; --i, k--) {
			cout << " " << matrix[i][e_col];
		}
		//top right to left

		for (int i = e_col - 1; i > s_col && k > 0; --i, k--) {
			cout << " " << matrix[s_row][i];
		}
		if (s_row + 1 <= e_row - 1 && k > 0) {
			//Recursive call
			this->anticlockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k);
		}
	}
	void spiral_view(int matrix[][COL]) {
		if (this->cols > 2) {
			//When exists more than 2 columns

			if (this->cols % 2 == 0) {
				//When the  size of column are Even

				cout << "\n Clockwise \n";
				this->clockwise(matrix, 0, 0, this->rows - 1, (this->cols / 2) - 1, (this->rows *this->cols) / 2);
				cout << "\n Anticlockwise \n";
				this->anticlockwise(matrix, 0, (this->cols / 2), this->rows - 1, this->cols - 1, (this->rows *this->cols) / 2);
			} else {
				//When the  size of column are Odd

				cout << "\n Clockwise \n";
				this->clockwise(matrix, 0, 0, this->rows - 1, (this->cols / 2), this->rows *(this->cols + 1) / 2);
				cout << "\n Anticlockwise \n";
				this->anticlockwise(matrix, 0, (this->cols / 2), this->rows - 1, this->cols - 1, this->rows *(this->cols + 1) / 2);
			}
		} else
		if (this->cols == 2) {
			//When exists only 2 columns

			cout << "\n Clockwise \n";
			this->clockwise(matrix, 0, 0, this->rows - 1, this->cols - 1, (this->rows *this->cols));
			cout << "\n Anticlockwise \n";
			this->anticlockwise(matrix, 0, 0, this->rows - 1, this->cols - 1, (this->rows *this->cols));
		}
	}
};
int main() {
	int matrix[][COL] = {
		{
			1,
			2,
			3,
			4,
			5,
			6
		},
		{
			22,
			23,
			24,
			25,
			26,
			7
		},
		{
			21,
			36,
			37,
			38,
			27,
			8
		},
		{
			20,
			35,
			42,
			39,
			28,
			9
		},
		{
			19,
			34,
			41,
			40,
			29,
			10
		},
		{
			18,
			33,
			32,
			31,
			30,
			11
		},
		{
			17,
			16,
			15,
			14,
			13,
			12
		}
		
	};
	MyMatrix obj ;
	obj.spiral_view(matrix);
	return 0;
}

Output

 Clockwise
 1 2 3 24 37 42 41 32 15 16 17 18 19 20 21 22 23 36 35 34 33
 Anticlockwise
 4 25 38 39 40 31 14 13 12 11 10 9 8 7 6 5 26 27 28 29 30
/*
  Java Program
  Print Half clockwise and Half anticlockwise spiral view of a matrix
*/
public class MyMatrix {

  public int rows;
  public int cols;
  public MyMatrix(int [][]matrix)
  {
    //Get matrix size
    this.rows = matrix.length;
    this.cols = matrix[0].length;

  }

  public void clockwise(int [][]matrix,
    int s_row,
    int s_col,
    int e_row,
    int e_col,
    int k)
  {
    //Left to right
    for (int i = s_col; i <=e_col && k > 0 ; ++i,k--)
    {
      System.out.print("  "+matrix[s_row][i] );
    }
    //Top to down
    for (int i = s_row+1; i <=e_row && k > 0  ; ++i,k--)
    {

      System.out.print("  "+matrix[i][e_col] );

    }
    //Bottom right to bottom-left
    for (int i = e_col-1; i >=s_col && k > 0 ; --i,k--)
    {
   
      System.out.print("  "+matrix[e_row][i] );
    }

    //Bottom left to top
    for (int i =e_row-1 ; i > s_row && k > 0 ; --i,k--)
    {
     
      System.out.print("  "+matrix[i][s_row] );

    }

    if(s_row+1 <= e_row-1 && k > 0)
    {
      //Recursive call
      clockwise(matrix,s_row+1,s_col+1,e_row-1,e_col-1,k);
    }
      
  }


  public void anticlockwise(int [][]matrix,
    int s_row,
    int s_col,
    int e_row,
    int e_col,
    int k)
  {

    //Top to down
    for (int i = s_row; i <=e_row && k > 0  ; ++i,k--)
    {

      System.out.print("  "+matrix[i][s_col] );

    }
    //Left to right
    for (int i = s_col+1; i <=e_col && k > 0 ; ++i,k--)
    {
      System.out.print("  "+matrix[e_row][i] );
    }

    //Bottom left to top
    for (int i =e_row-1 ; i >= s_row && k > 0 ; --i,k--)
    {
     
      System.out.print("  "+matrix[i][e_col] );

    }

    //top right to left
    for (int i = e_col-1; i > s_col && k > 0 ; --i,k--)
    {
   
      System.out.print("  "+matrix[s_row][i] );
    }


    if(s_row+1 <= e_row-1 && k > 0)
    {
      //Recursive call
      anticlockwise(matrix,s_row+1,s_col+1,e_row-1,e_col-1,k);
    }
      
  }
  public void spiral_view(int [][]matrix)
  {

    if(this.cols>2)
    {
      //When exists more than 2 columns

      if(this.cols%2==0)
      {
        //When the  size of column are Even
        System.out.print("\n Clockwise \n");
        clockwise(matrix,0,0,this.rows-1,(this.cols/2)-1,(this.rows*this.cols)/2);
        System.out.print("\n Anticlockwise \n");
        anticlockwise(matrix,0,(this.cols/2),this.rows-1,this.cols-1,(this.rows*this.cols)/2);
      }
      else
      {
        //When the  size of column are Odd
        System.out.print("\n Clockwise \n");
        clockwise(matrix,0,0,this.rows-1,(this.cols/2),this.rows*(this.cols+1)/2);
        System.out.print("\n Anticlockwise \n");
        anticlockwise(matrix,0,(this.cols/2),this.rows-1,this.cols-1,this.rows*(this.cols+1)/2 );
      }

    }
    else if(this.cols == 2)
    {
      //When exists only 2 columns
      System.out.print("\n Clockwise \n");
      clockwise(matrix,0,0,this.rows-1,this.cols-1,(this.rows*this.cols));
      System.out.print("\n Anticlockwise \n");
      anticlockwise(matrix,0,0,this.rows-1,this.cols-1,(this.rows*this.cols));
    }


  }
  public static void main(String[] args) 
  {
    //Define matrix element
    int [][]matrix =
    {
      {1, 2, 3, 4, 5, 6},
      {22,23,24,25,26,7},
      {21,36,37,38,27,8},
      {20,35,42,39,28,9},
      {19,34,41,40,29,10},
      {18,33,32,31,30,11},
      {17,16,15,14,13,12}
    }; 
    MyMatrix obj = new MyMatrix(matrix);

    obj.spiral_view(matrix);
  }
}

Output

 Clockwise
 1 2 3 24 37 42 41 32 15 16 17 18 19 20 21 22 23 36 35 34 33
 Anticlockwise
 4 25 38 39 40 31 14 13 12 11 10 9 8 7 6 5 26 27 28 29 30
/*
  C# Program
  Print Half clockwise and Half anticlockwise spiral view of a matrix
*/
using System;

public class MyMatrix {
	int rows;
	int cols;
	MyMatrix(int[,] matrix) {
		//Get matrix size
		this.rows = matrix.GetLength(0);
		this.cols = matrix.GetLength(1);
	}
	public void clockwise(int[,] matrix, int s_row, int s_col, int e_row, int e_col, int k) {
		//Left to right

		for (int i = s_col; i <= e_col && k > 0; ++i, k--) {
			Console.Write(" " + matrix[s_row,i]);
		}
		//Top to down

		for (int i = s_row + 1; i <= e_row && k > 0; ++i, k--) {
			Console.Write(" " + matrix[i,e_col]);
		}
		//Bottom right to bottom-left

		for (int i = e_col - 1; i >= s_col && k > 0; --i, k--) {
			Console.Write(" " + matrix[e_row,i]);
		}
		//Bottom left to top

		for (int i = e_row - 1; i > s_row && k > 0; --i, k--) {
			Console.Write(" " + matrix[i,s_row]);
		}
		if (s_row + 1 <= e_row - 1 && k > 0) {
			clockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k);
		}
	}
	public void anticlockwise(int[,] matrix, int s_row, int s_col, int e_row, int e_col, int k) {
		//Top to down

		for (int i = s_row; i <= e_row && k > 0; ++i, k--) {
			Console.Write(" " + matrix[i,s_col]);
		}
		//Left to right

		for (int i = s_col + 1; i <= e_col && k > 0; ++i, k--) {
			Console.Write(" " + matrix[e_row,i]);
		}
		//Bottom left to top

		for (int i = e_row - 1; i >= s_row && k > 0; --i, k--) {
			Console.Write(" " + matrix[i,e_col]);
		}
		//top right to left

		for (int i = e_col - 1; i > s_col && k > 0; --i, k--) {
			Console.Write(" " + matrix[s_row,i]);
		}
		if (s_row + 1 <= e_row - 1 && k > 0) {
			anticlockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k);
		}
	}
	public void spiral_view(int[,] matrix) {
		if (this.cols > 2) {
			//When exists more than 2 columns

			if (this.cols % 2 == 0) {
				Console.Write("\n Clockwise \n");
				clockwise(matrix, 0, 0, this.rows - 1, (this.cols / 2) - 1, (this.rows * this.cols) / 2);
				Console.Write("\n Anticlockwise \n");
				anticlockwise(matrix, 0, (this.cols / 2), this.rows - 1, this.cols - 1, (this.rows * this.cols) / 2);
			} else {
				Console.Write("\n Clockwise \n");
				clockwise(matrix, 0, 0, this.rows - 1, (this.cols / 2), this.rows * (this.cols + 1) / 2);
				Console.Write("\n Anticlockwise \n");
				anticlockwise(matrix, 0, (this.cols / 2), this.rows - 1, this.cols - 1, this.rows * (this.cols + 1) / 2);
			}
		} else
		if (this.cols == 2) {
			Console.Write("\n Clockwise \n");
			clockwise(matrix, 0, 0, this.rows - 1, this.cols - 1, (this.rows * this.cols));
			Console.Write("\n Anticlockwise \n");
			anticlockwise(matrix, 0, 0, this.rows - 1, this.cols - 1, (this.rows * this.cols));
		}
	}
	public static void Main(String[] args) {
		int[,]
		//Define matrix element
		matrix = {
			{
				1,
				2,
				3,
				4,
				5,
				6
			},
			{
				22,
				23,
				24,
				25,
				26,
				7
			},
			{
				21,
				36,
				37,
				38,
				27,
				8
			},
			{
				20,
				35,
				42,
				39,
				28,
				9
			},
			{
				19,
				34,
				41,
				40,
				29,
				10
			},
			{
				18,
				33,
				32,
				31,
				30,
				11
			},
			{
				17,
				16,
				15,
				14,
				13,
				12
			}
		};
		MyMatrix obj = new MyMatrix(matrix);
		obj.spiral_view(matrix);
	}
}

Output

 Clockwise
 1 2 3 24 37 42 41 32 15 16 17 18 19 20 21 22 23 36 35 34 33
 Anticlockwise
 4 25 38 39 40 31 14 13 12 11 10 9 8 7 6 5 26 27 28 29 30
<?php
/*
  Php Program
  Print Half clockwise and Half anticlockwise spiral view of a matrix
*/
class MyMatrix {
	public $rows;
	public $cols;

	function __construct($matrix) {
		//Get matrix size
		$this->rows = count($matrix);
		$this->cols = count($matrix[0]);
	}
	public 	function clockwise($matrix, $s_row, $s_col, $e_row, $e_col, $k) {
		//Left to right

		for ($i = $s_col; $i <= $e_col && $k > 0; ++$i, $k--) {
			echo(" ". $matrix[$s_row][$i]);
		}
		//Top to down

		for ($i = $s_row + 1; $i <= $e_row && $k > 0; ++$i, $k--) {
			echo(" ". $matrix[$i][$e_col]);
		}
		//Bottom right to bottom-left

		for ($i = $e_col - 1; $i >= $s_col && $k > 0; --$i, $k--) {
			echo(" ". $matrix[$e_row][$i]);
		}
		//Bottom left to top

		for ($i = $e_row - 1; $i > $s_row && $k > 0; --$i, $k--) {
			echo(" ". $matrix[$i][$s_row]);
		}
		if ($s_row + 1 <= $e_row - 1 && $k > 0) {
			//Recursive call
			$this->clockwise($matrix, $s_row + 1, $s_col + 1, $e_row - 1, $e_col - 1, $k);
		}
	}
	public 	function anticlockwise($matrix, $s_row, $s_col, $e_row, $e_col, $k) {
		//Top to down

		for ($i = $s_row; $i <= $e_row && $k > 0; ++$i, $k--) {
			echo(" ". $matrix[$i][$s_col]);
		}
		//Left to right

		for ($i = $s_col + 1; $i <= $e_col && $k > 0; ++$i, $k--) {
			echo(" ". $matrix[$e_row][$i]);
		}
		//Bottom left to top

		for ($i = $e_row - 1; $i >= $s_row && $k > 0; --$i, $k--) {
			echo(" ". $matrix[$i][$e_col]);
		}
		//top right to left

		for ($i = $e_col - 1; $i > $s_col && $k > 0; --$i, $k--) {
			echo(" ". $matrix[$s_row][$i]);
		}
		if ($s_row + 1 <= $e_row - 1 && $k > 0) {
			//Recursive call
			$this->anticlockwise($matrix, $s_row + 1, $s_col + 1, $e_row - 1, $e_col - 1, $k);
		}
	}
	public 	function spiral_view($matrix) {
		if ($this->cols > 2) {
			//When exists more than 2 columns

			if ($this->cols % 2 == 0) {
				//When the  size of column are Even

				echo("\n Clockwise \n");
				$this->clockwise($matrix, 0, 0, $this->rows - 1, (intval($this->cols / 2)) - 1, intval(($this->rows *$this->cols) / 2));
				echo("\n Anticlockwise \n");
				$this->anticlockwise($matrix, 0, (intval($this->cols / 2)), $this->rows - 1, $this->cols - 1, intval(($this->rows *$this->cols) / 2));
			} else {
				//When the  size of column are Odd

				echo("\n Clockwise \n");
				$this->clockwise($matrix, 0, 0, $this->rows - 1, (intval($this->cols / 2)), intval($this->rows *($this->cols + 1) / 2));
				echo("\n Anticlockwise \n");
				$this->anticlockwise($matrix, 0, (intval($this->cols / 2)), $this->rows - 1, $this->cols - 1, intval($this->rows *($this->cols + 1) / 2));
			}
		} else
		if ($this->cols == 2) {
			//When exists only 2 columns

			echo("\n Clockwise \n");
			$this->clockwise($matrix, 0, 0, $this->rows - 1, $this->cols - 1, ($this->rows *$this->cols));
			echo("\n Anticlockwise \n");
			$this->anticlockwise($matrix, 0, 0, $this->rows - 1, $this->cols - 1, ($this->rows *$this->cols));
		}
	}
}

function main() {
	//Define matrix element
	$matrix = array(array(1, 2, 3, 4, 5, 6), array(22, 23, 24, 25, 26, 7), array(21, 36, 37, 38, 27, 8), array(20, 35, 42, 39, 28, 9), array(19, 34, 41, 40, 29, 10), array(18, 33, 32, 31, 30, 11), array(17, 16, 15, 14, 13, 12));
	$obj = new MyMatrix($matrix);
	$obj->spiral_view($matrix);

}
main();

Output

 Clockwise
 1 2 3 24 37 42 41 32 15 16 17 18 19 20 21 22 23 36 35 34 33
 Anticlockwise
 4 25 38 39 40 31 14 13 12 11 10 9 8 7 6 5 26 27 28 29 30
/*
  Node Js Program
  Print Half clockwise and Half anticlockwise spiral view of a matrix
*/
class MyMatrix {
	;;
	constructor(matrix) {
		//Get matrix size
		this.rows = matrix.length;
		this.cols = matrix[0].length;
	}
	clockwise(matrix, s_row, s_col, e_row, e_col, k) {
		//Left to right

		for (var i = s_col; i <= e_col && k > 0; ++i, k--) {
			process.stdout.write(" " + matrix[s_row][i]);
		}

		//Top to down

		for (var i = s_row + 1; i <= e_row && k > 0; ++i, k--) {
			process.stdout.write(" " + matrix[i][e_col]);
		}

		//Bottom right to bottom-left

		for (var i = e_col - 1; i >= s_col && k > 0; --i, k--) {
			process.stdout.write(" " + matrix[e_row][i]);
		}

		//Bottom left to top

		for (var i = e_row - 1; i > s_row && k > 0; --i, k--) {
			process.stdout.write(" " + matrix[i][s_row]);
		}

		if (s_row + 1 <= e_row - 1 && k > 0) {
			//Recursive call
			this.clockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k);
		}
	}
	anticlockwise(matrix, s_row, s_col, e_row, e_col, k) {
		//Top to down

		for (var i = s_row; i <= e_row && k > 0; ++i, k--) {
			process.stdout.write(" " + matrix[i][s_col]);
		}

		//Left to right

		for (var i = s_col + 1; i <= e_col && k > 0; ++i, k--) {
			process.stdout.write(" " + matrix[e_row][i]);
		}

		//Bottom left to top

		for (var i = e_row - 1; i >= s_row && k > 0; --i, k--) {
			process.stdout.write(" " + matrix[i][e_col]);
		}

		//top right to left

		for (var i = e_col - 1; i > s_col && k > 0; --i, k--) {
			process.stdout.write(" " + matrix[s_row][i]);
		}

		if (s_row + 1 <= e_row - 1 && k > 0) {
			//Recursive call
			this.anticlockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k);
		}
	}
	spiral_view(matrix) {
		if (this.cols > 2) {
			//When exists more than 2 columns

			if (this.cols % 2 == 0) {
				//When the  size of column are Even

				process.stdout.write("\n Clockwise \n");
				this.clockwise(matrix, 0, 0, this.rows - 1, (parseInt(this.cols / 2)) - 1, parseInt((this.rows *this.cols) / 2));
				process.stdout.write("\n Anticlockwise \n");
				this.anticlockwise(matrix, 0, (parseInt(this.cols / 2)), this.rows - 1, this.cols - 1, parseInt((this.rows *this.cols) / 2));
			} else {
				//When the  size of column are Odd

				process.stdout.write("\n Clockwise \n");
				this.clockwise(matrix, 0, 0, this.rows - 1, (parseInt(this.cols / 2)), parseInt(this.rows *(this.cols + 1) / 2));
				process.stdout.write("\n Anticlockwise \n");
				this.anticlockwise(matrix, 0, (parseInt(this.cols / 2)), this.rows - 1, this.cols - 1, parseInt(this.rows *(this.cols + 1) / 2));
			}
		} else
		if (this.cols == 2) {
			//When exists only 2 columns

			process.stdout.write("\n Clockwise \n");
			this.clockwise(matrix, 0, 0, this.rows - 1, this.cols - 1, (this.rows *this.cols));
			process.stdout.write("\n Anticlockwise \n");
			this.anticlockwise(matrix, 0, 0, this.rows - 1, this.cols - 1, (this.rows *this.cols));
		}
	}
}

function main(args) {
	//Define matrix element
	var matrix = [
		[1, 2, 3, 4, 5, 6],
		[22, 23, 24, 25, 26, 7],
		[21, 36, 37, 38, 27, 8],
		[20, 35, 42, 39, 28, 9],
		[19, 34, 41, 40, 29, 10],
		[18, 33, 32, 31, 30, 11],
		[17, 16, 15, 14, 13, 12]
	];
	var obj = new MyMatrix(matrix);
	obj.spiral_view(matrix);
}

main();

Output

 Clockwise
 1 2 3 24 37 42 41 32 15 16 17 18 19 20 21 22 23 36 35 34 33
 Anticlockwise
 4 25 38 39 40 31 14 13 12 11 10 9 8 7 6 5 26 27 28 29 30
#   Python 3 Program
#   Print Half clockwise and Half anticlockwise spiral view of a matrix
class MyMatrix :
	
	def __init__(self, matrix) :
		# Get matrix size
		self.rows = len(matrix)
		self.cols = len(matrix[0])
	
	def clockwise(self, matrix, s_row, s_col, e_row, e_col, k) :
		# Left to right
		i = s_col
		while (i <= e_col and k > 0) :
			print(" ", matrix[s_row][i], end = "")
			i += 1
			k -= 1
		
		# Top to down
		i = s_row + 1
		while (i <= e_row and k > 0) :
			print(" ", matrix[i][e_col], end = "")
			i += 1
			k -= 1
		
		# Bottom right to bottom-left
		i = e_col - 1
		while (i >= s_col and k > 0) :
			print(" ", matrix[e_row][i], end = "")
			i -= 1
			k -= 1
		
		# Bottom left to top
		i = e_row - 1
		while (i > s_row and k > 0) :
			print(" ", matrix[i][s_row], end = "")
			i -= 1
			k -= 1
		
		if (s_row + 1 <= e_row - 1 and k > 0) :
			self.clockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k)
		
	
	def anticlockwise(self, matrix, s_row, s_col, e_row, e_col, k) :
		# Top to down
		i = s_row
		while (i <= e_row and k > 0) :
			print(" ", matrix[i][s_col], end = "")
			i += 1
			k -= 1
		
		# Left to right
		i = s_col + 1
		while (i <= e_col and k > 0) :
			print(" ", matrix[e_row][i], end = "")
			i += 1
			k -= 1
		
		# Bottom left to top
		i = e_row - 1
		while (i >= s_row and k > 0) :
			print(" ", matrix[i][e_col], end = "")
			i -= 1
			k -= 1
		
		# top right to left
		i = e_col - 1
		while (i > s_col and k > 0) :
			print(" ", matrix[s_row][i], end = "")
			i -= 1
			k -= 1
		
		if (s_row + 1 <= e_row - 1 and k > 0) :
			self.anticlockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k)
		
	
	def spiral_view(self, matrix) :
		if (self.cols > 2) :
			# When exists more than 2 columns

			if (self.cols % 2 == 0) :
				print("\n Clockwise \n", end = "")
				self.clockwise(matrix, 0, 0, self.rows - 1, (int(self.cols / 2)) - 1, int((self.rows * self.cols) / 2))
				print("\n Anticlockwise \n", end = "")
				self.anticlockwise(matrix, 0, (int(self.cols / 2)), self.rows - 1, self.cols - 1, int((self.rows * self.cols) / 2))
			else :
				print("\n Clockwise \n", end = "")
				self.clockwise(matrix, 0, 0, self.rows - 1, (int(self.cols / 2)), int(self.rows * (self.cols + 1) / 2))
				print("\n Anticlockwise \n", end = "")
				self.anticlockwise(matrix, 0, (int(self.cols / 2)), self.rows - 1, self.cols - 1, int(self.rows * (self.cols + 1) / 2))
			
		elif (self.cols == 2) :
			print("\n Clockwise \n", end = "")
			self.clockwise(matrix, 0, 0, self.rows - 1, self.cols - 1, (self.rows * self.cols))
			print("\n Anticlockwise \n", end = "")
			self.anticlockwise(matrix, 0, 0, self.rows - 1, self.cols - 1, (self.rows * self.cols))
		
	

def main() :
	matrix = [
		[1, 2, 3, 4, 5, 6],
		[22, 23, 24, 25, 26, 7],
		[21, 36, 37, 38, 27, 8],
		[20, 35, 42, 39, 28, 9],
		[19, 34, 41, 40, 29, 10],
		[18, 33, 32, 31, 30, 11],
		[17, 16, 15, 14, 13, 12]
	]
	obj = MyMatrix(matrix)
	obj.spiral_view(matrix)


if __name__ == "__main__":
	main()

Output

 Clockwise
  1  2  3  24  37  42  41  32  15  16  17  18  19  20  21  22  23  36  35  34  33
 Anticlockwise
  4  25  38  39  40  31  14  13  12  11  10  9  8  7  6  5  26  27  28  29  30
# Ruby Program
# Print Half clockwise and Half anticlockwise spiral view of a matrix
class MyMatrix 
	# Define the accessor and reader of class MyMatrix
	attr_reader :rows, :cols
	attr_accessor :rows, :cols
	def initialize(matrix) 
		# Get matrix size
		self.rows = matrix.length
		self.cols = matrix[0].length
	end
	def clockwise(matrix, s_row, s_col, e_row, e_col, k) 
		# Left to right
		i = s_col
		while (i <= e_col && k > 0) 
			print(" ", matrix[s_row][i])
			i += 1
			k -= 1
		end
		# Top to down
		i = s_row + 1
		while (i <= e_row && k > 0) 
			print(" ", matrix[i][e_col])
			i += 1
			k -= 1
		end
		# Bottom right to bottom-left
		i = e_col - 1
		while (i >= s_col && k > 0) 
			print(" ", matrix[e_row][i])
			i -= 1
			k -= 1
		end
		# Bottom left to top
		i = e_row - 1
		while (i > s_row && k > 0) 
			print(" ", matrix[i][s_row])
			i -= 1
			k -= 1
		end
		if (s_row + 1 <= e_row - 1 && k > 0) 
			self.clockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k)
		end
	end
	def anticlockwise(matrix, s_row, s_col, e_row, e_col, k) 
		# Top to down
		i = s_row
		while (i <= e_row && k > 0) 
			print(" ", matrix[i][s_col])
			i += 1
			k -= 1
		end
		# Left to right
		i = s_col + 1
		while (i <= e_col && k > 0) 
			print(" ", matrix[e_row][i])
			i += 1
			k -= 1
		end
		# Bottom left to top
		i = e_row - 1
		while (i >= s_row && k > 0) 
			print(" ", matrix[i][e_col])
			i -= 1
			k -= 1
		end
		# top right to left
		i = e_col - 1
		while (i > s_col && k > 0) 
			print(" ", matrix[s_row][i])
			i -= 1
			k -= 1
		end
		if (s_row + 1 <= e_row - 1 && k > 0) 
			self.anticlockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k)
		end
	end
	def spiral_view(matrix) 
		if (self.cols > 2) 
			# When exists more than 2 columns

			if (self.cols % 2 == 0) 
				print("\n Clockwise \n")
				self.clockwise(matrix, 0, 0, self.rows - 1, (self.cols / 2) - 1, (self.rows * self.cols) / 2)
				print("\n Anticlockwise \n")
				self.anticlockwise(matrix, 0, (self.cols / 2), self.rows - 1, self.cols - 1, (self.rows * self.cols) / 2)
			else 
				print("\n Clockwise \n")
				self.clockwise(matrix, 0, 0, self.rows - 1, (self.cols / 2), self.rows * (self.cols + 1) / 2)
				print("\n Anticlockwise \n")
				self.anticlockwise(matrix, 0, (self.cols / 2), self.rows - 1, self.cols - 1, self.rows * (self.cols + 1) / 2)
			end
			elsif (self.cols == 2) 
			print("\n Clockwise \n")
			self.clockwise(matrix, 0, 0, self.rows - 1, self.cols - 1, (self.rows * self.cols))
			print("\n Anticlockwise \n")
			self.anticlockwise(matrix, 0, 0, self.rows - 1, self.cols - 1, (self.rows * self.cols))
		end
	end
end
def main() 
	matrix = [
		[1, 2, 3, 4, 5, 6],
		[22, 23, 24, 25, 26, 7],
		[21, 36, 37, 38, 27, 8],
		[20, 35, 42, 39, 28, 9],
		[19, 34, 41, 40, 29, 10],
		[18, 33, 32, 31, 30, 11],
		[17, 16, 15, 14, 13, 12]
	]
	obj = MyMatrix.new(matrix)
	obj.spiral_view(matrix)
end


main()

Output

 Clockwise 
 1 2 3 24 37 42 41 32 15 16 17 18 19 20 21 22 23 36 35 34 33
 Anticlockwise 
 4 25 38 39 40 31 14 13 12 11 10 9 8 7 6 5 26 27 28 29 30
/*
  Scala Program
  Print Half clockwise and Half anticlockwise spiral view of a matrix
*/
class MyMatrix(var rows: Int,var cols: Int) {


	def this(matrix: Array[Array[Int]]) {
		//Get matrix size
		this( matrix.length,matrix(0).length);
	}
	def clockwise(matrix: Array[Array[Int]], s_row: Int, s_col: Int, e_row: Int, e_col: Int, k_size: Int): Unit = {
		//Left to right
		var i: Int = s_col;
      	var k: Int = k_size;
		while (i <= e_col && k > 0) {
			print(" " + matrix(s_row)(i));
			i += 1;
			k -= 1;
		}
		//Top to down
		i = s_row + 1;
		while (i <= e_row && k > 0) {
			print(" " + matrix(i)(e_col));
			i += 1;
			k -= 1;
		}
		//Bottom right to bottom-left
		i = e_col - 1;
		while (i >= s_col && k > 0) {
			print(" " + matrix(e_row)(i));
			i -= 1;
			k -= 1;
		}
		//Bottom left to top
		i = e_row - 1;
		while (i > s_row && k > 0) {
			print(" " + matrix(i)(s_row));
			i -= 1;
			k -= 1;
		}
		if (s_row + 1 <= e_row - 1 && k > 0) {
			this.clockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k);
		}
	}
	def anticlockwise(matrix: Array[Array[Int]], s_row: Int, s_col: Int, e_row: Int, e_col: Int, k_size: Int): Unit = {
		//Top to down
		var i: Int = s_row;
      	var k: Int = k_size;
		while (i <= e_row && k > 0) {
			print(" " + matrix(i)(s_col));
			i += 1;
			k -= 1;
		}
		//Left to right
		i = s_col + 1;
		while (i <= e_col && k > 0) {
			print(" " + matrix(e_row)(i));
			i += 1;
			k -= 1;
		}
		//Bottom left to top
		i = e_row - 1;
		while (i >= s_row && k > 0) {
			print(" " + matrix(i)(e_col));
			i -= 1;
			k -= 1;
		}
		//top right to left
		i = e_col - 1;
		while (i > s_col && k > 0) {
			print(" " + matrix(s_row)(i));
			i -= 1;
			k -= 1;
		}
		if (s_row + 1 <= e_row - 1 && k > 0) {
			this.anticlockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k);
		}
	}
	def spiral_view(matrix: Array[Array[Int]]): Unit = {
		if (this.cols > 2) {
			//When exists more than 2 columns

			if (this.cols % 2 == 0) {
				print("\n Clockwise \n");
				this.clockwise(matrix, 0, 0, this.rows - 1, ((this.cols / 2).toInt) - 1, ((this.rows * this.cols) / 2).toInt);
				print("\n Anticlockwise \n");
				this.anticlockwise(matrix, 0, ((this.cols / 2).toInt), this.rows - 1, this.cols - 1, ((this.rows * this.cols) / 2).toInt);
			} else {
				print("\n Clockwise \n");
				this.clockwise(matrix, 0, 0, this.rows - 1, ((this.cols / 2).toInt), (this.rows * (this.cols + 1) / 2).toInt);
				print("\n Anticlockwise \n");
				this.anticlockwise(matrix, 0, ((this.cols / 2).toInt), this.rows - 1, this.cols - 1, (this.rows * (this.cols + 1) / 2).toInt);
			}
		} else
		if (this.cols == 2) {
			print("\n Clockwise \n");
			this.clockwise(matrix, 0, 0, this.rows - 1, this.cols - 1, (this.rows * this.cols));
			print("\n Anticlockwise \n");
			this.anticlockwise(matrix, 0, 0, this.rows - 1, this.cols - 1, (this.rows * this.cols));
		}
	}
}
object Main {
	def main(args: Array[String]): Unit = {
		val matrix: Array[Array[Int]] = Array(
			Array(1, 2, 3, 4, 5, 6),
			Array(22, 23, 24, 25, 26, 7),
			Array(21, 36, 37, 38, 27, 8),
			Array(20, 35, 42, 39, 28, 9),
			Array(19, 34, 41, 40, 29, 10),
			Array(18, 33, 32, 31, 30, 11),
			Array(17, 16, 15, 14, 13, 12));
		val obj: MyMatrix = new MyMatrix(matrix);
		obj.spiral_view(matrix);
	}
}

Output

 Clockwise
 1 2 3 24 37 42 41 32 15 16 17 18 19 20 21 22 23 36 35 34 33
 Anticlockwise
 4 25 38 39 40 31 14 13 12 11 10 9 8 7 6 5 26 27 28 29 30
/*
  Swift Program
  Print Half clockwise and Half anticlockwise spiral view of a matrix
*/
class MyMatrix {
	var rows: Int;
	var cols: Int;
	init(_ matrix: [
		[Int]
	]) {
		//Get matrix size
		self.rows = matrix.count;
		self.cols = matrix[0].count;
	}
	func clockwise(_ matrix: [
		[Int]
	], _ s_row: Int, _ s_col: Int, _ e_row: Int, _ e_col: Int, _ k_size: Int) {
		//Left to right
		var i: Int = s_col;
     	var k : Int = k_size;
      
		while (i <= e_col && k > 0) {
			print(" ", matrix[s_row][i], terminator: "");
			i += 1;
			k -= 1;
		}
		//Top to down
		i = s_row + 1;
		while (i <= e_row && k > 0) {
			print(" ", matrix[i][e_col], terminator: "");
			i += 1;
			k -= 1;
		}
		//Bottom right to bottom-left
		i = e_col - 1;
		while (i >= s_col && k > 0) {
			print(" ", matrix[e_row][i], terminator: "");
			i -= 1;
			k -= 1;
		}
		//Bottom left to top
		i = e_row - 1;
		while (i > s_row && k > 0) {
			print(" ", matrix[i][s_row], terminator: "");
			i -= 1;
			k -= 1;
		}
		if (s_row + 1 <= e_row - 1 && k > 0) {
			self.clockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k);
		}
	}
	func anticlockwise(_ matrix: [
		[Int]
	], _ s_row: Int, _ s_col: Int, _ e_row: Int, _ e_col: Int, _ k_size: Int) {
		//Top to down
		var i: Int = s_row;
     	var k : Int = k_size;
		while (i <= e_row && k > 0) {
			print(" ", matrix[i][s_col], terminator: "");
			i += 1;
			k -= 1;
		}
		//Left to right
		i = s_col + 1;
		while (i <= e_col && k > 0) {
			print(" ", matrix[e_row][i], terminator: "");
			i += 1;
			k -= 1;
		}
		//Bottom left to top
		i = e_row - 1;
		while (i >= s_row && k > 0) {
			print(" ", matrix[i][e_col], terminator: "");
			i -= 1;
			k -= 1;
		}
		//top right to left
		i = e_col - 1;
		while (i > s_col && k > 0) {
			print(" ", matrix[s_row][i], terminator: "");
			i -= 1;
			k -= 1;
		}
		if (s_row + 1 <= e_row - 1 && k > 0) {
			self.anticlockwise(matrix, s_row + 1, s_col + 1, e_row - 1, e_col - 1, k);
		}
	}
	func spiral_view(_ matrix: [
		[Int]
	]) {
		if (self.cols > 2) {
			//When exists more than 2 columns

			if (self.cols % 2 == 0) {
				print("\n Clockwise \n", terminator: "");
				self.clockwise(matrix, 0, 0, self.rows - 1, (self.cols / 2) - 1, (self.rows * self.cols) / 2);
				print("\n Anticlockwise \n", terminator: "");
				self.anticlockwise(matrix, 0, (self.cols / 2), self.rows - 1, self.cols - 1, (self.rows * self.cols) / 2);
			} else {
				print("\n Clockwise \n", terminator: "");
				self.clockwise(matrix, 0, 0, self.rows - 1, (self.cols / 2), self.rows * (self.cols + 1) / 2);
				print("\n Anticlockwise \n", terminator: "");
				self.anticlockwise(matrix, 0, (self.cols / 2), self.rows - 1, self.cols - 1, self.rows * (self.cols + 1) / 2);
			}
		} else
		if (self.cols == 2) {
			print("\n Clockwise \n", terminator: "");
			self.clockwise(matrix, 0, 0, self.rows - 1, self.cols - 1, (self.rows * self.cols));
			print("\n Anticlockwise \n", terminator: "");
			self.anticlockwise(matrix, 0, 0, self.rows - 1, self.cols - 1, (self.rows * self.cols));
		}
	}
}
func main() {
	let matrix: [
		[Int]
	] = [
		[1, 2, 3, 4, 5, 6],
		[22, 23, 24, 25, 26, 7],
		[21, 36, 37, 38, 27, 8],
		[20, 35, 42, 39, 28, 9],
		[19, 34, 41, 40, 29, 10],
		[18, 33, 32, 31, 30, 11],
		[17, 16, 15, 14, 13, 12]
	];
	let obj: MyMatrix = MyMatrix(matrix);
	obj.spiral_view(matrix);
}
main();

Output

 Clockwise
  1  2  3  24  37  42  41  32  15  16  17  18  19  20  21  22  23  36  35  34  33
 Anticlockwise
  4  25  38  39  40  31  14  13  12  11  10  9  8  7  6  5  26  27  28  29  30

Output Explanation

The mentioned Java code correctly implements the above algorithm to print the half-clockwise and half-anticlockwise spiral views of the matrix. It identifies the boundaries of the matrix and divides it into half-clockwise and half-anticlockwise regions. It then recursively prints the spiral views of these regions. The output matches the expected half-clockwise and half-anticlockwise spiral views of the given matrix.

Time Complexity

The time complexity of the mentioned solution is O(N), where N is the number of elements in the matrix. The clockwise and anticlockwise functions iterate through each element of the matrix exactly once, printing the elements in the desired order. The spiral_view function performs constant time operations based on the number of columns in the matrix. Therefore, the overall time complexity is O(N).

Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment