Open In App

# Create a matrix with alternating rectangles of O and X

Write a code which inputs two numbers m and n and creates a matrix of size m x n (m rows and n columns) in which every elements is either X or 0. The Xs and 0s must be filled alternatively, the matrix should have outermost rectangle of Xs, then a rectangle of 0s, then a rectangle of Xs, and so on.

Examples:

```Input: m = 3, n = 3
Output: Following matrix
X X X
X 0 X
X X X

Input: m = 4, n = 5
Output: Following matrix
X X X X X
X 0 0 0 X
X 0 0 0 X
X X X X X

Input:  m = 5, n = 5
Output: Following matrix
X X X X X
X 0 0 0 X
X 0 X 0 X
X 0 0 0 X
X X X X X

Input:  m = 6, n = 7
Output: Following matrix
X X X X X X X
X 0 0 0 0 0 X
X 0 X X X 0 X
X 0 X X X 0 X
X 0 0 0 0 0 X
X X X X X X X ```

We strongly recommend to minimize the browser and try this yourself first.

This question was asked in campus recruitment of Shreepartners Gurgaon. I followed the following approach.

1. Use the code for Printing Matrix in Spiral form
2. Instead of printing the array, inserted the element ‘X’ or ‘0’ alternatively in the array.

Algorithm:

1. Start with initializing variables i, k, and l to 0 and x to ‘X’.
2. Create a 2D character array a with m rows and n columns.
3. Store the values of m and n in variables r and c respectively for later use.
4. Use a while loop to fill the array a with alternating rectangles of ‘0’ and ‘X’ characters in a spiral pattern.
5. In the while loop, fill the first row of the remaining rows with ‘X’ character, starting from column l to n-1, and then increment k by 1.
6. Fill the last column of the remaining columns with ‘X’ character, starting from row k to m-1, and then decrement n by 1.
7. Fill the last row of the remaining rows with ‘X’ character, starting from column n-1 to l, and then decrement m by 1.
8. Fill the first column of the remaining columns with ‘X’ character, starting from row m-1 to k, and then increment l by 1.
9. After each iteration of the while loop, toggle the character x between ‘0’ and ‘X’.
10. After the while loop is completed, print the filled matrix a row by row.

Following is implementation of the above approach.

## C++

 `#include ``using` `namespace` `std;` `// Function to print alternating rectangles of 0 and X``void` `fill0X(``int` `m, ``int` `n)``{``    ``/*  k - starting row index``        ``m - ending row index``        ``l - starting column index``        ``n - ending column index``        ``i - iterator    */``    ``int` `i, k = 0, l = 0;` `    ``// Store given number of rows and columns for later use``    ``int` `r = m, c = n;` `    ``// A 2D array to store the output to be printed``    ``char` `a[m][n];``    ``char` `x = ``'X'``; ``// Initialize the character to be stored in a[][]` `    ``// Fill characters in a[][] in spiral form. Every iteration fills``    ``// one rectangle of either Xs or Os``    ``while` `(k < m && l < n)``    ``{``        ``/* Fill the first row from the remaining rows */``        ``for` `(i = l; i < n; ++i)``            ``a[k][i] = x;``        ``k++;` `        ``/* Fill the last column from the remaining columns */``        ``for` `(i = k; i < m; ++i)``            ``a[i][n-1] = x;``        ``n--;` `        ``/* Fill the last row from the remaining rows */``        ``if` `(k < m)``        ``{``            ``for` `(i = n-1; i >= l; --i)``                ``a[m-1][i] = x;``            ``m--;``        ``}` `        ``/* Print the first column from the remaining columns */``        ``if` `(l < n)``        ``{``            ``for` `(i = m-1; i >= k; --i)``                ``a[i][l] = x;``            ``l++;``        ``}` `        ``// Flip character for next iteration``        ``x = (x == ``'0'``)? ``'X'``: ``'0'``;``    ``}` `    ``// Print the filled matrix``    ``for` `(i = 0; i < r; i++)``    ``{``        ``for` `(``int` `j = 0; j < c; j++)``            ``cout <<``" "``<< a[i][j];``        ``cout <<``"\n"``;``    ``}``}` `/* Driver program to test above functions */``int` `main()``{``    ``puts``(``"Output for m = 5, n = 6"``);``    ``fill0X(5, 6);` `    ``puts``(``"\nOutput for m = 4, n = 4"``);``    ``fill0X(4, 4);` `    ``puts``(``"\nOutput for m = 3, n = 4"``);``    ``fill0X(3, 4);` `    ``return` `0;``}` `// This code is contributed by shivanisinghss2110`

## C

 `#include ` `// Function to print alternating rectangles of 0 and X``void` `fill0X(``int` `m, ``int` `n)``{``    ``/*  k - starting row index``        ``m - ending row index``        ``l - starting column index``        ``n - ending column index``        ``i - iterator    */``    ``int` `i, k = 0, l = 0;` `    ``// Store given number of rows and columns for later use``    ``int` `r = m, c = n;` `    ``// A 2D array to store the output to be printed``    ``char` `a[m][n];``    ``char` `x = ``'X'``; ``// Initialize the character to be stored in a[][]` `    ``// Fill characters in a[][] in spiral form. Every iteration fills``    ``// one rectangle of either Xs or Os``    ``while` `(k < m && l < n)``    ``{``        ``/* Fill the first row from the remaining rows */``        ``for` `(i = l; i < n; ++i)``            ``a[k][i] = x;``        ``k++;` `        ``/* Fill the last column from the remaining columns */``        ``for` `(i = k; i < m; ++i)``            ``a[i][n-1] = x;``        ``n--;` `        ``/* Fill the last row from the remaining rows */``        ``if` `(k < m)``        ``{``            ``for` `(i = n-1; i >= l; --i)``                ``a[m-1][i] = x;``            ``m--;``        ``}` `        ``/* Print the first column from the remaining columns */``        ``if` `(l < n)``        ``{``            ``for` `(i = m-1; i >= k; --i)``                ``a[i][l] = x;``            ``l++;``        ``}` `        ``// Flip character for next iteration``        ``x = (x == ``'0'``)? ``'X'``: ``'0'``;``    ``}` `    ``// Print the filled matrix``    ``for` `(i = 0; i < r; i++)``    ``{``        ``for` `(``int` `j = 0; j < c; j++)``            ``printf``(``"%c "``, a[i][j]);``        ``printf``(``"\n"``);``    ``}``}` `/* Driver program to test above functions */``int` `main()``{``    ``puts``(``"Output for m = 5, n = 6"``);``    ``fill0X(5, 6);` `    ``puts``(``"\nOutput for m = 4, n = 4"``);``    ``fill0X(4, 4);` `    ``puts``(``"\nOutput for m = 3, n = 4"``);``    ``fill0X(3, 4);` `    ``return` `0;``}`

## Java

 `// Java code to demonstrate the working.` `import` `java.io.*;` `class` `GFG {` `// Function to print alternating``// rectangles of 0 and X`` ``static` `void` `fill0X(``int` `m, ``int` `n)``{``    ``/* k - starting row index``        ``m - ending row index``        ``l - starting column index``        ``n - ending column index``        ``i - iterator */``    ``int` `i, k = ``0``, l = ``0``;` `    ``// Store given number of rows``        ``// and columns for later use``    ``int` `r = m, c = n;` `    ``// A 2D array to store``        ``// the output to be printed``    ``char` `a[][] = ``new` `char``[m][n];` `        ``// Initialize the character``        ``// to be stored in a[][]``    ``char` `x = ``'X'``;` `    ``// Fill characters in a[][] in spiral``        ``// form. Every iteration fills``    ``// one rectangle of either Xs or Os``    ``while` `(k < m && l < n)``    ``{``        ``/* Fill the first row from the remaining rows */``        ``for` `(i = l; i < n; ++i)``            ``a[k][i] = x;``        ``k++;` `        ``/* Fill the last column from the remaining columns */``        ``for` `(i = k; i < m; ++i)``            ``a[i][n-``1``] = x;``        ``n--;` `        ``/* Fill the last row from the remaining rows */``        ``if` `(k < m)``        ``{``            ``for` `(i = n-``1``; i >= l; --i)``                ``a[m-``1``][i] = x;``            ``m--;``        ``}` `        ``/* Print the first column``                ``// from the remaining columns */``        ``if` `(l < n)``        ``{``            ``for` `(i = m-``1``; i >= k; --i)``                ``a[i][l] = x;``            ``l++;``        ``}` `        ``// Flip character for next iteration``        ``x = (x == ``'0'``)? ``'X'``: ``'0'``;``    ``}` `    ``// Print the filled matrix``    ``for` `(i = ``0``; i < r; i++)``    ``{``        ``for` `(``int` `j = ``0``; j < c; j++)``            ``System.out.print(a[i][j] + ``" "``);``        ``System.out.println();``    ``}``}` `/* Driver program to test above functions */``public` `static` `void` `main (String[] args) {` `    ``System.out.println(``"Output for m = 5, n = 6"``);``    ``fill0X(``5``, ``6``);` `    ``System.out.println(``"Output for m = 4, n = 4"``);``    ``fill0X(``4``, ``4``);` `    ``System.out.println(``"Output for m = 3, n = 4"``);``    ``fill0X(``3``, ``4``);``        ` `    ``}``}` `// This code  is contributed by vt_m`

## Python3

 `# Python3 program to Create a matrix with``# alternating rectangles of O and X` `# Function to print alternating rectangles``# of 0 and X``def` `fill0X(m, n):``    ` `    ``# k - starting row index``    ``# m - ending row index``    ``# l - starting column index``    ``# n - ending column index``    ``# i - iterator``    ``i, k, l ``=` `0``, ``0``, ``0` `    ``# Store given number of rows and``    ``# columns for later use``    ``r ``=` `m``    ``c ``=` `n` `    ``# A 2D array to store the output``    ``# to be printed``    ``a ``=` `[[``None``] ``*` `n ``for` `i ``in` `range``(m)]``    ``x ``=` `'X'` `# Initialize the character to``            ``# be stored in a[][]` `    ``# Fill characters in a[][] in spiral form.``    ``# Every iteration fills one rectangle of``    ``# either Xs or Os``    ``while` `k < m ``and` `l < n:``        ` `        ``# Fill the first row from the``        ``# remaining rows``        ``for` `i ``in` `range``(l, n):``            ``a[k][i] ``=` `x``        ``k ``+``=` `1` `        ``# Fill the last column from``        ``# the remaining columns``        ``for` `i ``in` `range``(k, m):``            ``a[i][n ``-` `1``] ``=` `x``        ``n ``-``=` `1` `        ``# Fill the last row from the``        ``# remaining rows``        ``if` `k < m:``            ``for` `i ``in` `range``(n ``-` `1``, l ``-` `1``, ``-``1``):``                ``a[m ``-` `1``][i] ``=` `x``            ``m ``-``=` `1` `        ``# Print the first column from``        ``# the remaining columns``        ``if` `l < n:``            ``for` `i ``in` `range``(m ``-` `1``, k ``-` `1``, ``-``1``):``                ``a[i][l] ``=` `x``            ``l ``+``=` `1` `        ``# Flip character for next iteration``        ``x ``=` `'X'` `if` `x ``=``=` `'0'` `else` `'0'` `    ``# Print the filled matrix``    ``for` `i ``in` `range``(r):``        ``for` `j ``in` `range``(c):``            ``print``(a[i][j], end ``=` `" "``)``        ``print``()` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``print``(``"Output for m = 5, n = 6"``)``    ``fill0X(``5``, ``6``)` `    ``print``(``"Output for m = 4, n = 4"``)``    ``fill0X(``4``, ``4``)` `    ``print``(``"Output for m = 3, n = 4"``)``    ``fill0X(``3``, ``4``)``    ` `# This code is contributed by pranchalK`

## C#

 `// C# code to demonstrate the working.``using` `System;` `class` `GFG {` `    ``// Function to print alternating``    ``// rectangles of 0 and X``    ``static` `void` `fill0X(``int` `m, ``int` `n)``    ``{``        ` `        ``/* k - starting row index``        ``m - ending row index``        ``l - starting column index``        ``n - ending column index``        ``i - iterator */``        ``int` `i, k = 0, l = 0;``    ` `        ``// Store given number of rows``        ``// and columns for later use``        ``int` `r = m, c = n;``    ` `        ``// A 2D array to store``        ``// the output to be printed``        ``char` `[,]a = ``new` `char``[m,n];``    ` `        ``// Initialize the character``        ``// to be stored in a[][]``        ``char` `x = ``'X'``;``    ` `        ``// Fill characters in a[][] in spiral``        ``// form. Every iteration fills``        ``// one rectangle of either Xs or Os``        ``while` `(k < m && l < n)``        ``{``            ` `            ``/* Fill the first row from the``            ``remaining rows */``            ``for` `(i = l; i < n; ++i)``                ``a[k,i] = x;``            ``k++;``    ` `            ``/* Fill the last column from the``            ``remaining columns */``            ``for` `(i = k; i < m; ++i)``                ``a[i,n-1] = x;``            ``n--;``    ` `            ``/* Fill the last row from the``            ``remaining rows */``            ``if` `(k < m)``            ``{``                ``for` `(i = n-1; i >= l; --i)``                    ``a[m-1,i] = x;``                ``m--;``            ``}``    ` `            ``/* Print the first column``            ``from the remaining columns */``            ``if` `(l < n)``            ``{``                ``for` `(i = m-1; i >= k; --i)``                    ``a[i,l] = x;``                ``l++;``            ``}``    ` `            ``// Flip character for next``            ``// iteration``            ``x = (x == ``'0'``)? ``'X'``: ``'0'``;``        ``}``    ` `        ``// Print the filled matrix``        ``for` `(i = 0; i < r; i++)``        ``{``            ``for` `(``int` `j = 0; j < c; j++)``                ``Console.Write(a[i,j] + ``" "``);``            ``Console.WriteLine();``        ``}``    ``}``    ` `    ``/* Driver program to test``    ``above functions */``    ``public` `static` `void` `Main ()``    ``{``        ``Console.WriteLine(``"Output for"``                    ``+ ``" m = 5, n = 6"``);``        ``fill0X(5, 6);``    ` `        ``Console.WriteLine(``"Output for"``                    ``+ ``" m = 4, n = 4"``);``        ``fill0X(4, 4);``    ` `        ``Console.WriteLine(``"Output for"``                    ``+ ``" m = 3, n = 4"``);``        ``fill0X(3, 4);``    ``}``}` `// This code is contributed by Sam007.`

## PHP

 `= ``\$l``; --``\$i``)``                ``\$a``[``\$m` `- 1][``\$i``] = ``\$x``;``            ``\$m``--;``        ``}` `        ``/* Print the first column from``           ``the remaining columns */``        ``if` `(``\$l` `< ``\$n``)``        ``{``            ``for` `(``\$i` `= ``\$m` `- 1; ``\$i` `>= ``\$k``; --``\$i``)``                ``\$a``[``\$i``][``\$l``] = ``\$x``;``            ``\$l``++;``        ``}` `        ``// Flip character for``        ``// next iteration``        ``\$x` `= (``\$x` `== ``'0'``)? ``'X'``: ``'0'``;``    ``}` `    ``// Print the filled matrix``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$r``; ``\$i``++)``    ``{``        ``for` `(``\$j` `= 0; ``\$j` `< ``\$c``; ``\$j``++)``            ``echo``(``\$a``[``\$i``][``\$j``].``" "``);``        ``echo` `"\n"``;``    ``}``}` `// Driver Code``echo` `"Output for m = 5, n = 6\n"``;``fill0X(5, 6);` `echo` `"\nOutput for m = 4, n = 4\n"``;``fill0X(4, 4);` `echo` `"\nOutput for m = 3, n = 4\n"``;``fill0X(3, 4);` `// This code is contributed by ChitraNayal.``?>`

## Javascript

 ``

Output

```Output for m = 5, n = 6
X X X X X X
X 0 0 0 0 X
X 0 X X 0 X
X 0 0 0 0 X
X X X X X X

Output for m = 4, n = 4
X X X X
X 0 0 X
X 0 0 X
X X X X

Output for m = 3, n = 4
X X X X
X 0 0 X
X X X X```

Time Complexity: O(mn)
Auxiliary Space: O(mn)