Tutorialspoint.dev

Print a given matrix in counter-clock wise spiral form

Given a 2D array, print it in counter-clock wise spiral form. See the following examples.

Examples :

Input:
        1    2   3   4
        5    6   7   8
        9   10  11  12
        13  14  15  16
Output: 
1 5 9 13 14 15 16 12 8 4 3 2 6 10 11 7 

Input:
        1   2   3   4  5   6
        7   8   9  10  11  12
        13  14  15 16  17  18
Output: 
1 7 13 14 15 16 17 18 12 6 5 4 3 2 8 9 10 11 

Explanation :

Below is the implementation :

C++

// C++ implementation to print
// the counter clock wise
// spiral traversal of matrix
#include <bits/stdc++.h>
using namespace std;
  
#define R 4
#define C 4
  
// function to print the
// required traversal
void counterClockspiralPrint(int m, 
                             int n, 
                             int arr[R][C])
{
    int i, k = 0, l = 0;
  
    //  k - starting row index
    //    m - ending row index
    //    l - starting column index
    //    n - ending column index
    //    i - iterator 
  
    // initialize the count
    int cnt = 0;
  
    // total number of 
    // elements in matrix
    int total = m * n;
  
    while (k < m && l < n) 
    {
        if (cnt == total)
            break;
  
        // Print the first column 
        // from the remaining columns
        for (i = k; i < m; ++i)
        {
            cout << arr[i][l] << " ";
            cnt++;
        }
        l++;
  
        if (cnt == total)
            break;
  
        // Print the last row from
        // the remaining rows 
        for (i = l; i < n; ++i) 
        {
            cout << arr[m - 1][i] << " ";
            cnt++;
        }
        m--;
  
        if (cnt == total)
            break;
  
        // Print the last column 
        // from the remaining columns 
        if (k < m) 
        {
            for (i = m - 1; i >= k; --i) 
            {
                cout << arr[i][n - 1] << " ";
                cnt++;
            }
            n--;
        }
  
        if (cnt == total)
            break;
  
        // Print the first row 
        // from the remaining rows 
        if (l < n) 
        {
            for (i = n - 1; i >= l; --i) 
            {
                cout << arr[k][i] << " ";
                cnt++;
            }
            k++;
        }
    }
}
  
// Driver Code
int main()
{
    int arr[R][C] = {{ 1, 2, 3, 4 },
                     { 5, 6, 7, 8 },
                     { 9, 10, 11, 12 },
                     { 13, 14, 15, 16 }};
    counterClockspiralPrint(R, C, arr);
    return 0;
}

Java

// Java implementation to print
// the counter clock wise
// spiral traversal of matrix
import java.io.*;
  
class GFG 
{
    static int R = 4;
    static int C = 4;
  
    // function to print the
    // required traversal
    static void counterClockspiralPrint(int m, 
                                        int n, 
                                        int arr[][])
    {
        int i, k = 0, l = 0;
  
    /* k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator */
  
        // initialize the count
        int cnt = 0;
  
        // total number of
        // elements in matrix
        int total = m * n;
  
        while (k < m && l < n) 
        {
            if (cnt == total)
                break;
  
            // Print the first column 
            // from the remaining columns
            for (i = k; i < m; ++i)
            {
                System.out.print(arr[i][l] + " ");
                cnt++;
            }
            l++;
  
            if (cnt == total)
                break;
  
            // Print the last row from
            // the remaining rows 
            for (i = l; i < n; ++i) 
            {
                System.out.print(arr[m - 1][i] + " ");
                cnt++;
            }
            m--;
  
            if (cnt == total)
                break;
  
            // Print the last column 
            // from the remaining columns 
            if (k < m) 
            {
                for (i = m - 1; i >= k; --i) 
                {
                    System.out.print(arr[i][n - 1] + " ");
                    cnt++;
                }
                n--;
            }
  
            if (cnt == total)
                break;
  
            // Print the first row 
            // from the remaining rows
            if (l < n) 
            {
                for (i = n - 1; i >= l; --i) 
                {
                    System.out.print(arr[k][i] + " ");
                    cnt++;
                }
                k++;
            }
        }
    }
  
// Driver Code
public static void main(String[] args)
{
    int arr[][] = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
      
    // Function calling             
    counterClockspiralPrint(R, C, arr);
}
}
  
// This code is contributed by vt_m

/div>

Python3

# Python3 implementation to print
# the counter clock wise
# spiral traversal of matrix
R = 4
C = 4
  
# Function to print 
# the required traversal
def counterClockspiralPrint(m, n, arr) :
    k = 0; l = 0
      
    # k - starting row index
    # m - ending row index
    # l - starting column index
    # n - ending column index
    # i - iterator 
  
    # initialize the count
    cnt = 0
  
    # total number of 
    # elements in matrix
    total = m * n
  
    while (k < m and l < n) :
        if (cnt == total) :
            break
  
        # Print the first column 
        # from the remaining columns 
        for i in range(k, m) :
            print(arr[i][l], end = " ")
            cnt += 1
          
        l += 1
  
        if (cnt == total) :
            break
  
        # Print the last row from
        # the remaining rows 
        for i in range (l, n) :
            print( arr[m - 1][i], end = " ")
            cnt += 1
          
        m -= 1
          
        if (cnt == total) :
            break
  
        # Print the last column  
        # from the remaining columns 
        if (k < m) :
            for i in range(m - 1, k - 1, -1) :
                print(arr[i][n - 1], end = " ")
                cnt += 1
            n -= 1
  
        if (cnt == total) :
            break
  
        # Print the first row 
        # from the remaining rows 
        if (l < n) :
            for i in range(n - 1, l - 1, -1) :
                print( arr[k][i], end = " ")
                cnt += 1
                  
            k += 1
              
  
# Driver Code
arr = [ [ 1, 2, 3, 4 ],
        [ 5, 6, 7, 8 ],
        [ 9, 10, 11, 12 ],
        [ 13, 14, 15, 16 ] ]
          
counterClockspiralPrint(R, C, arr)
  
# This code is contributed by Nikita Tiwari

C#

// C# implementation to print
// the counter clock wise
// spiral traversal of matrix;
using System;
  
class GFG 
{
    static int R = 4;
    static int C = 4;
  
    // function to print the required traversal
    static void counterClockspiralPrint(int m, 
                                        int n, 
                                        int[,] arr)
    {
        int i, k = 0, l = 0;
  
        // k - starting row index
        // m - ending row index
        // l - starting column index
        // n - ending column index
        // i - iterator
  
        // initialize the count
        int cnt = 0;
  
        // total number of elements in matrix
        int total = m * n;
  
        while (k < m && l < n) 
        {
            if (cnt == total)
                break;
  
            // Print the first column from 
            // the remaining columns
            for (i = k; i < m; ++i) 
            {
                Console.Write(arr[i,l] + " ");
                cnt++;
            }
            l++;
  
            if (cnt == total)
                break;
  
            // Print the last row from
            // the remaining rows 
            for (i = l; i < n; ++i)
            {
                Console.Write(arr[m - 1, i] + " ");
                cnt++;
            }
            m--;
  
            if (cnt == total)
                break;
  
            // Print the last column from 
            // the remaining columns
            if (k < m) {
                for (i = m - 1; i >= k; --i)
                {
                    Console.Write(arr[i, n - 1] + " ");
                    cnt++;
                }
                n--;
            }
  
            if (cnt == total)
                break;
  
            // Print the first row from
            // the remaining rows 
            if (l < n) 
            {
                for (i = n - 1; i >= l; --i)
                {
                    Console.Write(arr[k, i] + " ");
                    cnt++;
                }
                k++;
            }
        }
    }
  
// Driver code
public static void Main()
{
    int[,] arr =new int[,] {{1, 2, 3, 4},
                            {5, 6, 7, 8},
                            {9, 10, 11, 12},
                            {13, 14, 15, 16}};
      
    // Function calling     
    counterClockspiralPrint(R, C, arr);
}
}
  
// This code is contributed by KRV.

PHP

<?php
// PHP implementation to print
// the counter clock wise
// spiral traversal of matrix
  
$R = 4;
$C = 4;
  
// function to print 
// the required traversal
function counterClockspiralPrint($m, $n
                                 $arr)
{
    $i; $k = 0; $l = 0;
  
    /* k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator */
  
    // initialize the count
    $cnt = 0;
  
    // total number of 
    // elements in matrix
    $total = $m * $n;
  
    while ($k < $m and $l < $n
    {
        if ($cnt == $total)
            break;
  
        // Print the first column 
        // from the remaining columns 
        for ($i = $k; $i < $m; ++$i)
        {
            echo $arr[$i][$l] ," ";
            $cnt++;
        }
        $l++;
  
        if ($cnt == $total)
            break;
  
        // Print the last row from 
        // the remaining rows 
        for ($i = $l; $i < $n; ++$i
        {
            echo $arr[$m - 1][$i] , " ";
            $cnt++;
        }
        $m--;
  
        if ($cnt == $total)
            break;
  
        // Print the last column 
        // from the remaining columns
        if ($k < $m
        {
            for ($i = $m - 1; $i >= $k; --$i
            {
                echo $arr[$i][$n - 1] , " ";
                $cnt++;
            }
            $n--;
        }
  
        if ($cnt == $total)
            break;
  
        // Print the first row 
        // from the remaining rows 
        if ($l < $n) {
            for ($i = $n - 1; $i >= $l; --$i
            {
                echo $arr[$k][$i] , " ";
                $cnt++;
            }
            $k++;
        }
    }
}
  
// Driver Code
global $R,$C;
    $arr = array(array( 1, 2, 3, 4 ),
                 array( 5, 6, 7, 8 ),
                 array( 9, 10, 11, 12 ),
                 array( 13, 14, 15, 16 ));
echo counterClockspiralPrint($R, $C, $arr);
  
// This code is contributed by anuj_67.
?>


Output :

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

Time Complexity : O(mn).



This article is attributed to GeeksforGeeks.org

You Might Also Like

leave a comment

code

0 Comments

load comments

Subscribe to Our Newsletter