Imprimir una array dada en forma de espiral – Part 1

Posted on by Rudeus Greyrat

Dada una array 2D, imprímala en forma de espiral. Vea los siguientes ejemplos.

Ejemplos: 

C++

#include <bits/stdc++.h>
using namespace std;
  
vector<int> spiralOrder(vector<vector<int> >& matrix)
{
    int m = matrix.size(), n = matrix[0].size();
    vector<int> ans;
  
    if (m == 0)
        return ans;
  
    vector<vector<bool> > seen(m, vector<bool>(n, false));
    int dr[] = { 0, 1, 0, -1 };
    int dc[] = { 1, 0, -1, 0 };
  
    int x = 0, y = 0, di = 0;
  
    // Iterate from 0 to m * n - 1
    for (int i = 0; i < m * n; i++) {
        ans.push_back(matrix[x][y]);
        // on normal geeksforgeeks ui page it is showing
        // 'ans.push_back(matrix[x])' which gets copied as
        // this only and gives error on compilation,
        seen[x][y] = true;
        int newX = x + dr[di];
        int newY = y + dc[di];
  
        if (0 <= newX && newX < m && 0 <= newY && newY < n
            && !seen[newX][newY]) {
            x = newX;
            y = newY;
        }
        else {
            di = (di + 1) % 4;
            x += dr[di];
            y += dc[di];
        }
    }
    return ans;
}
  
// Driver code
int main()
{
    vector<vector<int> > a{ { 1, 2, 3, 4 },
                            { 5, 6, 7, 8 },
                            { 9, 10, 11, 12 },
                            { 13, 14, 15, 16 } };
  
    for (int x : spiralOrder(a)) {
        cout << x << " ";
    }
    return 0;
}
  
// This code is contributed by Yashvendra Singh

Java

// Java program for the above approach
import java.util.*;
  
class Solution {
  
    // Function to print in spiral order
    public static List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> ans = new ArrayList<Integer>();
  
        if (matrix.length == 0)
            return ans;
  
        int m = matrix.length, n = matrix[0].length;
        boolean[][] seen = new boolean[m][n];
        int[] dr = { 0, 1, 0, -1 };
        int[] dc = { 1, 0, -1, 0 };
        int x = 0, y = 0, di = 0;
  
        // Iterate from 0 to R * C - 1
        for (int i = 0; i < m * n; i++) {
            ans.add(matrix[x][y]);
            seen[x][y] = true;
            int cr = x + dr[di];
            int cc = y + dc[di];
  
            if (0 <= cr && cr < m && 0 <= cc && cc < n
                    && !seen[cr][cc]) {
                x = cr;
                y = cc;
            } else {
                di = (di + 1) % 4;
                x += dr[di];
                y += dc[di];
            }
        }
        return ans;
    }
  
    // Driver Code
    public static void main(String[] args) {
        int a[][] = { { 1, 2, 3, 4 },
                { 5, 6, 7, 8 },
                { 9, 10, 11, 12 },
                { 13, 14, 15, 16 } };
  
        System.out.println(spiralOrder(a));
    }
}

Python3

def spiralOrder(matrix):
    ans = []
  
    if (len(matrix) == 0):
        return ans
  
    m = len(matrix)
    n = len(matrix[0])
    seen = [[0 for i in range(n)] for j in range(m)]
    dr = [0, 1, 0, -1]
    dc = [1, 0, -1, 0]
    x = 0
    y = 0
    di = 0
  
    # Iterate from 0 to R * C - 1
    for i in range(m * n):
        ans.append(matrix[x][y])
        seen[x][y] = True
        cr = x + dr[di]
        cc = y + dc[di]
  
        if (0 <= cr and cr < m and 0 <= cc and cc < n and not(seen[cr][cc])):
            x = cr
            y = cc
        else:
            di = (di + 1) % 4
            x += dr[di]
            y += dc[di]
    return ans
  
  
# Driver code
a = [[1, 2, 3, 4],
     [5, 6, 7, 8],
     [9, 10, 11, 12],
     [13, 14, 15, 16]]
  
for x in spiralOrder(a):
    print(x, end=" ")
print()

C#

// C# program for the above approach
using System;
using System.Collections.Generic;
  
public class GFG {
  
    // Function to print in spiral order
    public static List<int> spiralOrder(int[,] matrix)
    {
        List<int> ans = new List<int>();
  
        if (matrix.Length == 0)
            return ans;
  
        int R = matrix.GetLength(0), C = matrix.GetLength(1);
        bool[,] seen = new bool[R,C];
        int[] dr = { 0, 1, 0, -1 };
        int[] dc = { 1, 0, -1, 0 };
        int r = 0, c = 0, di = 0;
  
        // Iterate from 0 to R * C - 1
        for (int i = 0; i < R * C; i++) {
            ans.Add(matrix[r,c]);
            seen[r,c] = true;
            int cr = r + dr[di];
            int cc = c + dc[di];
  
            if (0 <= cr && cr < R && 0 <= cc && cc < C
                && !seen[cr,cc]) {
                r = cr;
                c = cc;
            }
            else {
                di = (di + 1) % 4;
                r += dr[di];
                c += dc[di];
            }
        }
        return ans;
    }
  
    // Driver Code
    public static void Main(String[] args)
    {
        int[,]a = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
  
        spiralOrder(a).ForEach(i=>Console.Write(i+" "));
    }
}
  
// This code is contributed by 29AjayKumar

Javascript

<script>
  
// JavaScript program for the above approach
  
// Function to print in spiral order
function spiralOrder(matrix)
{
    let ans = [];
   
        if (matrix.length == 0)
            return ans;
   
        let R = matrix.length, C = matrix[0].length;
        let seen = new Array(R);
        for(let i=0;i<R;i++)
        {
            seen[i]=new Array(C);
            for(let j=0;j<C;j++)
            {
                seen[i][j]=false;
            }
        }
          
        let dr = [ 0, 1, 0, -1 ];
        let dc = [ 1, 0, -1, 0 ];
        let r = 0, c = 0, di = 0;
   
        // Iterate from 0 to R * C - 1
        for (let i = 0; i < R * C; i++) {
            ans.push(matrix[r]);
            seen[r] = true;
            let cr = r + dr[di];
            let cc = c + dc[di];
   
            if (0 <= cr && cr < R && 0 <= cc && cc < C
                && !seen[cr][cc]) {
                r = cr;
                c = cc;
            }
            else {
                di = (di + 1) % 4;
                r += dr[di];
                c += dc[di];
            }
        }
        return ans;
}
  
// Driver Code
let a=[[ 1, 2, 3, 4 ],[ 5, 6, 7, 8 ],
[ 9, 10, 11, 12 ],[ 13, 14, 15, 16 ]];
document.write(spiralOrder(a));
                        
  
  
// This code is contributed by unknown2108
  
</script>

C++

// C++ Program to print a matrix spirally
  
#include <bits/stdc++.h>
using namespace std;
#define R 4
#define C 4
  
void spiralPrint(int m, int n, int a[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
    */
  
    while (k < m && l < n) {
        /* Print the first row from
               the remaining rows */
        for (i = l; i < n; ++i) {
            cout << a[k][i] << " ";
        }
        k++;
  
        /* Print the last column
         from the remaining columns */
        for (i = k; i < m; ++i) {
            cout << a[i][n - 1] << " ";
        }
        n--;
  
        /* Print the last row from
                the remaining rows */
        if (k < m) {
            for (i = n - 1; i >= l; --i) {
                cout << a[m - 1][i] << " ";
            }
            m--;
        }
  
        /* Print the first column from
                   the remaining columns */
        if (l < n) {
            for (i = m - 1; i >= k; --i) {
                cout << a[i][l] << " ";
            }
            l++;
        }
    }
}
  
/* Driver Code */
int main()
{
    int a[R][C] = {{1, 2, 3, 4},
                   {5, 6, 7, 8},
                   {9, 10, 11, 12},
                   {13, 14, 15, 16}};
  
    // Function Call
    spiralPrint(R, C, a);
    return 0;
}
  
// This is code is contributed by rathbhupendra

C

// C program to print the array in a
// spiral form
  
#include <stdio.h>
#define R 4
#define C 4
  
void spiralPrint(int m, int n, int a[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
    */
  
    while (k < m && l < n) {
        /* Print the first row from the remaining rows */
        for (i = l; i < n; ++i) {
            printf("%d ", a[k][i]);
        }
        k++;
  
        /* Print the last column from the remaining columns
         */
        for (i = k; i < m; ++i) {
            printf("%d ", a[i][n - 1]);
        }
        n--;
  
        /* Print the last row from the remaining rows */
        if (k < m) {
            for (i = n - 1; i >= l; --i) {
                printf("%d ", a[m - 1][i]);
            }
            m--;
        }
  
        /* Print the first column from the remaining columns
         */
        if (l < n) {
            for (i = m - 1; i >= k; --i) {
                printf("%d ", a[i][l]);
            }
            l++;
        }
    }
}
  
/* Driver Code */
int main()
{
    int a[R][C] =  {{1, 2, 3, 4},
                   {5, 6, 7, 8},
                   {9, 10, 11, 12},
                   {13, 14, 15, 16}};
  
    // Function Call
    spiralPrint(R, C, a);
    return 0;
}

Java

// Java program to print a given matrix in spiral form
import java.io.*;
  
class GFG {
  
    // Function print matrix in spiral form
    static void spiralPrint(int m, int n, int a[][])
    {
        int i, k = 0, l = 0;
  
        /*  k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator
        */
  
        while (k < m && l < n) {
            // Print the first row from the remaining rows
            for (i = l; i < n; ++i) {
                System.out.print(a[k][i] + " ");
            }
            k++;
  
            // Print the last column from the remaining
            // columns
            for (i = k; i < m; ++i) {
                System.out.print(a[i][n - 1] + " ");
            }
            n--;
  
            // Print the last row from the remaining rows */
            if (k < m) {
                for (i = n - 1; i >= l; --i) {
                    System.out.print(a[m - 1][i] + " ");
                }
                m--;
            }
  
            // Print the first column from the remaining
            // columns */
            if (l < n) {
                for (i = m - 1; i >= k; --i) {
                    System.out.print(a[i][l] + " ");
                }
                l++;
            }
        }
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int R = 4;
        int C = 4;
        int a[][] =  {{1, 2, 3, 4},
                   {5, 6, 7, 8},
                   {9, 10, 11, 12},
                   {13, 14, 15, 16}};
  
        // Function Call
        spiralPrint(R, C, a);
    }
}
  
// Contributed by Pramod Kumar

Python3

# Python3 program to print
# given matrix in spiral form
  
  
def spiralPrint(m, n, a):
    k = 0
    l = 0
  
    ''' k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator '''
  
    while (k < m and l < n):
  
        # Print the first row from
        # the remaining rows
        for i in range(l, n):
            print(a[k][i], end=" ")
  
        k += 1
  
        # Print the last column from
        # the remaining columns
        for i in range(k, m):
            print(a[i][n - 1], end=" ")
  
        n -= 1
  
        # Print the last row from
        # the remaining rows
        if (k < m):
  
            for i in range(n - 1, (l - 1), -1):
                print(a[m - 1][i], end=" ")
  
            m -= 1
  
        # Print the first column from
        # the remaining columns
        if (l < n):
            for i in range(m - 1, k - 1, -1):
                print(a[i][l], end=" ")
  
            l += 1
  
  
# Driver Code
a = [[ 1, 2, 3, 4 ],
     [ 5, 6, 7, 8 ],
     [ 9, 10, 11, 12 ],
     [ 13, 14, 15, 16 ]]
  
R = 4
C = 4
  
# Function Call
spiralPrint(R, C, a)
  
# This code is contributed by Nikita Tiwari.

C#

// C# program to print a given
// matrix in spiral form
using System;
  
class GFG {
    // Function print matrix in spiral form
    static void spiralPrint(int m, int n, int[, ] a)
    {
        int i, k = 0, l = 0;
        /* k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator
        */
  
        while (k < m && l < n) {
            // Print the first row
            // from the remaining rows
            for (i = l; i < n; ++i) {
                Console.Write(a[k, i] + " ");
            }
            k++;
  
            // Print the last column from the
            // remaining columns
            for (i = k; i < m; ++i) {
                Console.Write(a[i, n - 1] + " ");
            }
            n--;
  
            // Print the last row from
            // the remaining rows
            if (k < m) {
                for (i = n - 1; i >= l; --i) {
                    Console.Write(a[m - 1, i] + " ");
                }
                m--;
            }
  
            // Print the first column from
            // the remaining columns
            if (l < n) {
                for (i = m - 1; i >= k; --i) {
                    Console.Write(a[i, l] + " ");
                }
                l++;
            }
        }
    }
  
    // Driver Code
    public static void Main()
    {
        int R = 4;
        int C = 4;
        int[, ] a =  {{1, 2, 3, 4},
                   {5, 6, 7, 8},
                   {9, 10, 11, 12},
                   {13, 14, 15, 16}};
  
        // Function Call
        spiralPrint(R, C, a);
    }
}
  
// This code is contributed by Sam007

PHP

<?php 
// PHP program to print a given
// matrix in spiral form
$R = 4;
$C = 4;
  
function spiralPrint($m, $n, &$a)
{
    $k = 0;
    $l = 0;
  
    /* $k - starting row index
        $m - ending row index
        $l - starting column index
        $n - ending column index
        $i - iterator
    */
  
    while ($k < $m && $l < $n)
    {
        /* Print the first row from
           the remaining rows */
        for ($i = $l; $i < $n; ++$i)
        {
            echo $a[$k][$i] . " ";
        }
        $k++;
  
        /* Print the last column 
        from the remaining columns */
        for ($i = $k; $i < $m; ++$i)
        {
            echo $a[$i][$n - 1] . " ";
        }
        $n--;
  
        /* Print the last row from
           the remaining rows */
        if ($k < $m)
        {
            for ($i = $n - 1; $i >= $l; --$i)
            {
                echo $a[$m - 1][$i] . " ";
            }
            $m--;
        }
  
        /* Print the first column from
           the remaining columns */
        if ($l < $n)
        {
            for ($i = $m - 1; $i >= $k; --$i)
            {
                echo $a[$i][$l] . " ";
            }
            $l++; 
        }     
    }
}
  
// Driver code
$a = array(array(1, 2, 3, 4),
           array(5, 6, 7, 8),
           array(9, 10, 11, 12),
           array(13, 14, 15, 16));
// Function Call
spiralPrint($R, $C, $a);
  
// This code is contributed
// by ChitraNayal
?>

Javascript

<script>
  
// JavaScript Program to print a matrix spirally
  
function spiralPrint(m, n, arr) {
    let i, k = 0, l = 0;
    /*
        k - starting row index
        m - ending row index
        l - starting column index
        n - ending column index
        i - iterator  
    */
  
    while (k < m && l < n) {
        // print the first row from the remaining rows
        for (i = l; i < n; ++i) {
            document.write(arr[k][i] + ' ');
        }
        k++;
  
        // print the last column from the remaining columns
        for (i = k; i < m; ++i) {
            document.write(arr[i][n - 1] + ' ');
        }
        n--;
  
        // print the last row from the remaining rows
        if (k < m) {
            for (i = n - 1; i >= l; --i) {
                document.write(arr[m - 1][i] + ' ');
            }
            m--;
        }
  
        // print the first column from the remaining columns
        if (l < n) {
            for (i = m - 1; i >= k; --i) {
                document.write(arr[i][l] + ' ');
            }
            l++;
        }
    }
}
  
// function call
let arr = [[ 1, 2, 3, 4 ],
     [ 5, 6, 7, 8 ],
     [ 9, 10, 11, 12 ],
     [ 13, 14, 15, 16 ]];
let r = arr.length;
let c = arr[0].length;
  
spiralPrint(r, c, arr);
  
// This code is contributed by karthiksrinivasprasad
  
</script>

C++

// C++. program for the above approach
#include <iostream>
using namespace std;
  
#define R 4
#define C 4
  
// Function for printing matrix in spiral
// form i, j: Start index of matrix, row
// and column respectively m, n: End index
// of matrix row and column respectively
void print(int arr[R][C], int i, int j, int m, int n)
{
    // If i or j lies outside the matrix
    if (i >= m or j >= n)
        return;
  
    // Print First Row
    for (int p = j; p < n; p++)
        cout << arr[i][p] << " ";
  
    // Print Last Column
    for (int p = i + 1; p < m; p++)
        cout << arr[p][n - 1] << " ";
  
    // Print Last Row, if Last and
    // First Row are not same
    if ((m - 1) != i)
        for (int p = n - 2; p >= j; p--)
            cout << arr[m - 1][p] << " ";
  
    // Print First Column,  if Last and
    // First Column are not same
    if ((n - 1) != j)
        for (int p = m - 2; p > i; p--)
            cout << arr[p][j] << " ";
  
    print(arr, i + 1, j + 1, m - 1, n - 1);
}
  
// Driver Code
int main()
{
  
    int a[R][C] = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
  
    // Function Call
    print(a, 0, 0, R, C);
    return 0;
}
// This Code is contributed by Ankur Goel

Java

// Java program for the above approach
import java.util.*;
  
class GFG {
    static int R = 4;
    static int C = 4;
  
    // Function for printing matrix in spiral
    // form i, j: Start index of matrix, row
    // and column respectively m, n: End index
    // of matrix row and column respectively
    static void print(int arr[][], int i, int j, int m,
                      int n)
    {
        // If i or j lies outside the matrix
        if (i >= m || j >= n) {
            return;
        }
  
        // Print First Row
        for (int p = i; p < n; p++) {
            System.out.print(arr[i][p] + " ");
        }
  
        // Print Last Column
        for (int p = i + 1; p < m; p++) {
            System.out.print(arr[p][n - 1] + " ");
        }
  
        // Print Last Row, if Last and
        // First Row are not same
        if ((m - 1) != i) {
            for (int p = n - 2; p >= j; p--) {
                System.out.print(arr[m - 1][p] + " ");
            }
        }
  
        // Print First Column, if Last and
        // First Column are not same
        if ((n - 1) != j) {
            for (int p = m - 2; p > i; p--) {
                System.out.print(arr[p][j] + " ");
            }
        }
        print(arr, i + 1, j + 1, m - 1, n - 1);
    }
  
    // Driver Code
    public static void main(String[] args)
    {
        int a[][] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
  
        // Function Call
        print(a, 0, 0, R, C);
    }
}
  
// This code is contributed by 29AjayKumar

Python3

# Python3 program for the above approach
  
# Function for printing matrix in spiral
# form i, j: Start index of matrix, row
# and column respectively m, n: End index
# of matrix row and column respectively
  
  
def printdata(arr, i, j, m, n):
  
    # If i or j lies outside the matrix
    if (i >= m or j >= n):
        return
  
    # Print First Row
    for p in range(i, n):
        print(arr[i][p], end=" ")
  
    # Print Last Column
    for p in range(i + 1, m):
        print(arr[p][n - 1], end=" ")
  
    # Print Last Row, if Last and
    # First Row are not same
    if ((m - 1) != i):
        for p in range(n - 2, j - 1, -1):
            print(arr[m - 1][p], end=" ")
  
    # Print First Column, if Last and
    # First Column are not same
    if ((n - 1) != j):
        for p in range(m - 2, i, -1):
            print(arr[p][j], end=" ")
  
    printdata(arr, i + 1, j + 1, m - 1, n - 1)
  
  
# Driver code
R = 4
C = 4
arr = [[1, 2, 3, 4],
       [5, 6, 7, 8],
       [9, 10, 11, 12],
       [13, 14, 15, 16]]
  
# Function Call
printdata(arr, 0, 0, R, C)
  
# This code is contributed by avsadityavardhan

C#

// C# program for the above approach
using System;
  
class GFG {
    static int R = 4;
    static int C = 4;
  
    // Function for printing matrix in spiral
    // form i, j: Start index of matrix, row
    // and column respectively m, n: End index
    // of matrix row and column respectively
    static void print(int[, ] arr, int i, int j, int m,
                      int n)
    {
        // If i or j lies outside the matrix
        if (i >= m || j >= n) {
            return;
        }
  
        // Print First Row
        for (int p = i; p < n; p++) {
            Console.Write(arr[i, p] + " ");
        }
  
        // Print Last Column
        for (int p = i + 1; p < m; p++) {
            Console.Write(arr[p, n - 1] + " ");
        }
  
        // Print Last Row, if Last and
        // First Row are not same
        if ((m - 1) != i) {
            for (int p = n - 2; p >= j; p--) {
                Console.Write(arr[m - 1, p] + " ");
            }
        }
  
        // Print First Column, if Last and
        // First Column are not same
        if ((n - 1) != j) {
            for (int p = m - 2; p > i; p--) {
                Console.Write(arr[p, j] + " ");
            }
        }
        print(arr, i + 1, j + 1, m - 1, n - 1);
    }
  
    // Driver Code
    public static void Main(String[] args)
    {
        int[, ] a = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
        // Function Call
        print(a, 0, 0, R, C);
    }
}
  
// This code is contributed by Princi Singh

Javascript

<script>
// JavaScript program for the above approach
  
// Function for printing matrix in spiral
// form i, j: Start index of matrix, row
// and column respectively m, n: End index
// of matrix row and column respectively
  
function print(arr, i, j, m, n) {
  
    // If i or j lies outside the matrix
    if (i >= m || j >= n) return;
  
    // Print First Row
    for (let p = j; p < n; p++) {
        document.write(arr[i][p] + ' ')
    }
  
    // Print Last Column
    for (let p = i + 1; p < m; p++) {
        document.write(arr[p][n - 1] + ' ')
    }
  
    // Print Last Row, if Last and
    // First Row are not same
    if ((m - 1) != i) {
        for (let p = n - 2; p >= j; p--) {
            document.write(arr[m - 1][p] + ' ');
        }
    }
  
    // Print First Column, if Last and
    // First Column are not same    
    if ((n - 1) != j) {
        for (let p = m - 2; p > i; p--) {
            document.write(arr[p][j] + ' ');
        }
    }
    print(arr, i + 1, j + 1, m - 1, n - 1)
}
  
// function call
let arr = [ [1, 2, 3, 4],
            [5, 6, 7, 8],
            [9, 10, 11, 12],
            [13, 14, 15, 16]
           ];
let r = arr.length;
let c = arr[0].length;
  
print(arr, 0, 0, r, c);
  
// This code is contributed by karthiksrinivasprasad
  
</script>

C++

#include <iostream>
#include <vector>
using namespace std;
#define R 4
#define C 4
  
bool isInBounds(int i, int j)
{
    if (i < 0 || i >= R || j < 0 || j >= C)
        return false;
    return true;
}
  
// check if the position is blocked
bool isBlocked(int matrix[R][C], int i, int j)
{
    if (!isInBounds(i, j))
        return true;
    if (matrix[i][j] == -1)
        return true;
    return false;
}
  
// DFS code to traverse spirally
void spirallyDFSTravserse(int matrix[R][C], int i, int j,
                          int dir, vector<int>& res)
{
    if (isBlocked(matrix, i, j))
        return;
    bool allBlocked = true;
    for (int k = -1; k <= 1; k += 2) {
        allBlocked = allBlocked
                     && isBlocked(matrix, k + i, j)
                     && isBlocked(matrix, i, j + k);
    }
    res.push_back(matrix[i][j]);
    matrix[i][j] = -1;
    if (allBlocked) {
        return;
    }
  
    // dir: 0 - right, 1 - down, 2 - left, 3 - up
    int nxt_i = i;
    int nxt_j = j;
    int nxt_dir = dir;
    if (dir == 0) {
        if (!isBlocked(matrix, i, j + 1)) {
            nxt_j++;
        }
        else {
            nxt_dir = 1;
            nxt_i++;
        }
    }
    else if (dir == 1) {
        if (!isBlocked(matrix, i + 1, j)) {
            nxt_i++;
        }
        else {
            nxt_dir = 2;
            nxt_j--;
        }
    }
    else if (dir == 2) {
        if (!isBlocked(matrix, i, j - 1)) {
            nxt_j--;
        }
        else {
            nxt_dir = 3;
            nxt_i--;
        }
    }
    else if (dir == 3) {
        if (!isBlocked(matrix, i - 1, j)) {
            nxt_i--;
        }
        else {
            nxt_dir = 0;
            nxt_j++;
        }
    }
    spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir,
                         res);
}
  
// to traverse spirally
vector<int> spirallyTraverse(int matrix[R][C])
{
    vector<int> res;
    spirallyDFSTravserse(matrix, 0, 0, 0, res);
    return res;
}
  
// Driver Code
int main()
{
    int a[R][C] = { { 1, 2, 3, 4 },
                    { 5, 6, 7, 8 },
                    { 9, 10, 11, 12 },
                    { 13, 14, 15, 16 } };
  
    // Function Call
    vector<int> res = spirallyTraverse(a);
    int size = res.size();
    for (int i = 0; i < size; ++i)
        cout << res[i] << " ";
    cout << endl;
    return 0;
} // code contributed by Ephi F

Java

import java.io.*;
import java.util.*;
  
class GFG {
    public static int R = 4, C = 4;
    public static boolean isInBounds(int i, int j)
    {
        if (i < 0 || i >= R || j < 0 || j >= C)
            return false;
        return true;
    }
  
    // check if the position is blocked
    public static boolean isBlocked(int[][] matrix, int i,
                                    int j)
    {
        if (!isInBounds(i, j))
            return true;
        if (matrix[i][j] == -1)
            return true;
        return false;
    }
  
    // DFS code to traverse spirally
    public static void
    spirallyDFSTravserse(int[][] matrix, int i, int j,
                         int dir, ArrayList<Integer> res)
    {
        if (isBlocked(matrix, i, j))
            return;
        boolean allBlocked = true;
        for (int k = -1; k <= 1; k += 2) {
            allBlocked = allBlocked
                         && isBlocked(matrix, k + i, j)
                         && isBlocked(matrix, i, j + k);
        }
        res.add(matrix[i][j]);
        matrix[i][j] = -1;
        if (allBlocked) {
            return;
        }
  
        // dir: 0 - right, 1 - down, 2 - left, 3 - up
        int nxt_i = i;
        int nxt_j = j;
        int nxt_dir = dir;
        if (dir == 0) {
            if (!isBlocked(matrix, i, j + 1)) {
                nxt_j++;
            }
            else {
                nxt_dir = 1;
                nxt_i++;
            }
        }
        else if (dir == 1) {
            if (!isBlocked(matrix, i + 1, j)) {
                nxt_i++;
            }
            else {
                nxt_dir = 2;
                nxt_j--;
            }
        }
        else if (dir == 2) {
            if (!isBlocked(matrix, i, j - 1)) {
                nxt_j--;
            }
            else {
                nxt_dir = 3;
                nxt_i--;
            }
        }
        else if (dir == 3) {
            if (!isBlocked(matrix, i - 1, j)) {
                nxt_i--;
            }
            else {
                nxt_dir = 0;
                nxt_j++;
            }
        }
        spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir,
                             res);
    }
  
    // to traverse spirally
    public static ArrayList<Integer>
    spirallyTraverse(int[][] matrix)
    {
        ArrayList<Integer> res = new ArrayList<Integer>();
        spirallyDFSTravserse(matrix, 0, 0, 0, res);
        return res;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int a[][] = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
  
        // Function Call
        ArrayList<Integer> res = spirallyTraverse(a);
        int size = res.size();
        for (int i = 0; i < size; ++i)
            System.out.print(res.get(i) + " ");
        System.out.println();
    }
}
  
// This code is contributed by Manu Pathria

Python3

R = 4
C = 4
  
  
def isInBounds(i, j):
    global R
    global C
    if (i < 0 or i >= R or j < 0 or j >= C):
        return False
    return True
  
# Check if the position is blocked
  
  
def isBlocked(matrix, i, j):
    if (not isInBounds(i, j)):
        return True
    if (matrix[i][j] == -1):
        return True
  
    return False
  
# DFS code to traverse spirally
  
  
def spirallyDFSTravserse(matrix, i, j, Dir, res):
    if (isBlocked(matrix, i, j)):
        return
  
    allBlocked = True
    for k in range(-1, 2, 2):
        allBlocked = allBlocked and isBlocked(
            matrix, k + i, j) and isBlocked(matrix, i, j + k)
  
    res.append(matrix[i][j])
    matrix[i][j] = -1
    if (allBlocked):
        return
  
    # dir: 0 - right, 1 - down, 2 - left, 3 - up
    nxt_i = i
    nxt_j = j
    nxt_dir = Dir
    if (Dir == 0):
        if (not isBlocked(matrix, i, j + 1)):
            nxt_j += 1
        else:
            nxt_dir = 1
            nxt_i += 1
  
    elif(Dir == 1):
        if (not isBlocked(matrix, i + 1, j)):
            nxt_i += 1
        else:
            nxt_dir = 2
            nxt_j -= 1
  
    elif(Dir == 2):
        if (not isBlocked(matrix, i, j - 1)):
            nxt_j -= 1
        else:
            nxt_dir = 3
            nxt_i -= 1
  
    elif(Dir == 3):
        if (not isBlocked(matrix, i - 1, j)):
            nxt_i -= 1
        else:
            nxt_dir = 0
            nxt_j += 1
  
    spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir, res)
  
# To traverse spirally
  
  
def spirallyTraverse(matrix):
    res = []
    spirallyDFSTravserse(matrix, 0, 0, 0, res)
    return res
  
  
# Driver code
a = [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
  
# Function Call
res = spirallyTraverse(a)
print(*res)
  
# This code is contributed by rag2127

C#

using System;
using System.Collections.Generic;
  
class GFG {
  
    public static int R = 4, C = 4;
    public static bool isInBounds(int i, int j)
    {
        if (i < 0 || i >= R || j < 0 || j >= C)
            return false;
  
        return true;
    }
  
    // Check if the position is blocked
    public static bool isBlocked(int[, ] matrix, int i,
                                 int j)
    {
        if (!isInBounds(i, j))
            return true;
        if (matrix[i, j] == -1)
            return true;
        return false;
    }
  
    // DFS code to traverse spirally
    public static void spirallyDFSTravserse(int[, ] matrix,
                                            int i, int j,
                                            int dir,
                                            List<int> res)
    {
        if (isBlocked(matrix, i, j))
            return;
  
        bool allBlocked = true;
  
        for (int k = -1; k <= 1; k += 2) {
            allBlocked = allBlocked
                         && isBlocked(matrix, k + i, j)
                         && isBlocked(matrix, i, j + k);
        }
        res.Add(matrix[i, j]);
        matrix[i, j] = -1;
  
        if (allBlocked) {
            return;
        }
  
        // dir: 0 - right, 1 - down, 2 - left, 3 - up
        int nxt_i = i;
        int nxt_j = j;
        int nxt_dir = dir;
        if (dir == 0) {
            if (!isBlocked(matrix, i, j + 1)) {
                nxt_j++;
            }
            else {
                nxt_dir = 1;
                nxt_i++;
            }
        }
        else if (dir == 1) {
            if (!isBlocked(matrix, i + 1, j)) {
                nxt_i++;
            }
            else {
                nxt_dir = 2;
                nxt_j--;
            }
        }
        else if (dir == 2) {
            if (!isBlocked(matrix, i, j - 1)) {
                nxt_j--;
            }
            else {
                nxt_dir = 3;
                nxt_i--;
            }
        }
        else if (dir == 3) {
            if (!isBlocked(matrix, i - 1, j)) {
                nxt_i--;
            }
            else {
                nxt_dir = 0;
                nxt_j++;
            }
        }
        spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir,
                             res);
    }
  
    // To traverse spirally
    public static List<int> spirallyTraverse(int[, ] matrix)
    {
        List<int> res = new List<int>();
        spirallyDFSTravserse(matrix, 0, 0, 0, res);
        return res;
    }
  
    // Driver code
    static public void Main()
    {
        int[, ] a = { { 1, 2, 3, 4 },
                      { 5, 6, 7, 8 },
                      { 9, 10, 11, 12 },
                      { 13, 14, 15, 16 } };
  
        // Function Call
        List<int> res = spirallyTraverse(a);
        int size = res.Count;
  
        for (int i = 0; i < size; ++i)
            Console.Write(res[i] + " ");
  
        Console.WriteLine();
    }
}
  
// This code is contributed by avanitrachhadiya2155

Javascript

<script>
  
var R = 4, C = 4;
function isInBounds(i, j)
{
    if (i < 0 || i >= R || j < 0 || j >= C)
        return false;
    return true;
}
// Check if the position is blocked
function isBlocked(matrix, i, j)
{
    if (!isInBounds(i, j))
        return true;
    if (matrix[i][j] == -1)
        return true;
    return false;
}
// DFS code to traverse spirally
function spirallyDFSTravserse(matrix, i, j, dir, res)
{
    if (isBlocked(matrix, i, j))
        return;
    var allBlocked = true;
    for (var k = -1; k <= 1; k += 2) {
        allBlocked = allBlocked
                     && isBlocked(matrix, k + i, j)
                     && isBlocked(matrix, i, j + k);
    }
    res.push(matrix[i][j]);
    matrix[i][j] = -1;
    if (allBlocked) {
        return;
    }
    // dir: 0 - right, 1 - down, 2 - left, 3 - up
    var nxt_i = i;
    var nxt_j = j;
    var nxt_dir = dir;
    if (dir == 0) {
        if (!isBlocked(matrix, i, j + 1)) {
            nxt_j++;
        }
        else {
            nxt_dir = 1;
            nxt_i++;
        }
    }
    else if (dir == 1) {
        if (!isBlocked(matrix, i + 1, j)) {
            nxt_i++;
        }
        else {
            nxt_dir = 2;
            nxt_j--;
        }
    }
    else if (dir == 2) {
        if (!isBlocked(matrix, i, j - 1)) {
            nxt_j--;
        }
        else {
            nxt_dir = 3;
            nxt_i--;
        }
    }
    else if (dir == 3) {
        if (!isBlocked(matrix, i - 1, j)) {
            nxt_i--;
        }
        else {
            nxt_dir = 0;
            nxt_j++;
        }
    }
    spirallyDFSTravserse(matrix, nxt_i, nxt_j, nxt_dir,
                         res);
}
// To traverse spirally
function spirallyTraverse(matrix)
{
    var res = [];
    spirallyDFSTravserse(matrix, 0, 0, 0, res);
    return res;
}
// Driver code
var a = [ [ 1, 2, 3, 4 ],
              [ 5, 6, 7, 8 ],
              [ 9, 10, 11, 12 ],
              [ 13, 14, 15, 16 ]];
// Function Call
var res = spirallyTraverse(a);
var size = res.length;
for (var i = 0; i < size; ++i)
    document.write(res[i] + " ");
  
</script>

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *