Girar la array 45 grados

Dada una array mat[][] de tamaño N*N, la tarea es rotar la array 45 grados e imprimir la array.

Ejemplos:

Entrada: N = 6, 
mat[][] =

Salida:
        3
      6 4
    1 9 5
   4 5 8 1
  4 7 9 7 5
4 5 8 7 2 9
  5 2 9 5 5
   7 9 3 3
    2 5 5
     9 6
      8

Entrada: N = 4, 
mat[][] = 

Salida:
    2
  9 5
 5 1 7
6 8 4 2
 4 2 3
  6 3
   3 

Enfoque 1: 

Siga los pasos que se indican a continuación para resolver el problema:

1. Almacene los elementos diagonales en una lista usando una variable de contador.
2. Imprima la cantidad de espacios necesarios para que la salida se vea como el patrón deseado.
3. Imprime los elementos de la lista después de invertir la lista .
4. Atraviese únicamente elementos diagonales para optimizar el tiempo de la operación.

A continuación se muestra la implementación del enfoque anterior:

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to rotate matrix by 45 degree
void matrix(int n, int m, vector<vector<int>> li)
{
     
    // Counter Variable
    int ctr = 0;
     
    while (ctr < 2 * n - 1)
    {
        for(int i = 0;
                i < abs(n - ctr - 1);
                i++)
        {
            cout << " ";
        }
         
        vector<int> lst;
 
        // Iterate [0, m]
        for(int i = 0; i < m; i++)
        {
             
            // Iterate [0, n]
            for(int j = 0; j < n; j++)
            {
                 
                // Diagonal Elements
                // Condition
                if (i + j == ctr)
                {
                     
                    // Appending the
                    // Diagonal Elements
                    lst.push_back(li[i][j]);
                }
            }
        }
             
        // Printing reversed Diagonal
        // Elements
        for(int i = lst.size() - 1; i >= 0; i--)
        {
            cout << lst[i] << " ";
        }
        cout << endl;
        ctr += 1;
    }
}
 
// Driver code   
int main()
{
     
    // Dimensions of Matrix
    int n = 8;
    int m = n;
     
    // Given matrix
    vector<vector<int>> li{
        { 4, 5, 6, 9, 8, 7, 1, 4 },
        { 1, 5, 9, 7, 5, 3, 1, 6 },
        { 7, 5, 3, 1, 5, 9, 8, 0 },
        { 6, 5, 4, 7, 8, 9, 3, 7 },
        { 3, 5, 6, 4, 8, 9, 2, 1 },
        { 3, 1, 6, 4, 7, 9, 5, 0 },
        { 8, 0, 7, 2, 3, 1, 0, 8 },
        { 7, 5, 3, 1, 5, 9, 8, 5 } };
     
    // Function call
    matrix(n, m, li);
 
    return 0;
}
 
// This code is contributed by divyeshrabadiya07

// Java program for
// the above approach
import java.util.*;
class GFG{
 
// Function to rotate
// matrix by 45 degree
static void matrix(int n, int m,
                   int [][]li)
{
  // Counter Variable
  int ctr = 0;
 
  while (ctr < 2 * n - 1)
  {
    for(int i = 0; i < Math.abs(n - ctr - 1);
            i++)
    {
      System.out.print(" ");
    }
 
    Vector<Integer> lst = new Vector<Integer>();
 
    // Iterate [0, m]
    for(int i = 0; i < m; i++)
    {
      // Iterate [0, n]
      for(int j = 0; j < n; j++)
      {
        // Diagonal Elements
        // Condition
        if (i + j == ctr)
        {
          // Appending the
          // Diagonal Elements
          lst.add(li[i][j]);
        }
      }
    }
 
    // Printing reversed Diagonal
    // Elements
    for(int i = lst.size() - 1; i >= 0; i--)
    {
      System.out.print(lst.get(i) + " ");
    }
     
    System.out.println();
    ctr += 1;
  }
}
 
// Driver code   
public static void main(String[] args)
{   
  // Dimensions of Matrix
  int n = 8;
  int m = n;
 
  // Given matrix
  int[][] li = {{4, 5, 6, 9, 8, 7, 1, 4},
                {1, 5, 9, 7, 5, 3, 1, 6},
                {7, 5, 3, 1, 5, 9, 8, 0},
                {6, 5, 4, 7, 8, 9, 3, 7},
                {3, 5, 6, 4, 8, 9, 2, 1},
                {3, 1, 6, 4, 7, 9, 5, 0},
                {8, 0, 7, 2, 3, 1, 0, 8},
                {7, 5, 3, 1, 5, 9, 8, 5}};
 
  // Function call
  matrix(n, m, li);
}
}
 
// This code is contributed by Princi Singh

# Python3 program for the above approach
 
# Function to rotate matrix by 45 degree
 
 
def matrix(n, m, li):
 
    # Counter Variable
    ctr = 0
    while(ctr < 2 * n-1):
        print(" "*abs(n-ctr-1), end ="")
        lst = []
 
        # Iterate [0, m]
        for i in range(m):
 
                # Iterate [0, n]
            for j in range(n):
 
                # Diagonal Elements
                # Condition
                if i + j == ctr:
 
                    # Appending the
                    # Diagonal Elements
                    lst.append(li[i][j])
 
        # Printing reversed Diagonal
        # Elements
        lst.reverse()
        print(*lst)
        ctr += 1
 
 
# Driver Code
 
# Dimensions of Matrix
n = 8
m = n
 
# Given matrix
li = [[4, 5, 6, 9, 8, 7, 1, 4],
      [1, 5, 9, 7, 5, 3, 1, 6],
      [7, 5, 3, 1, 5, 9, 8, 0],
      [6, 5, 4, 7, 8, 9, 3, 7],
      [3, 5, 6, 4, 8, 9, 2, 1],
      [3, 1, 6, 4, 7, 9, 5, 0],
      [8, 0, 7, 2, 3, 1, 0, 8],
      [7, 5, 3, 1, 5, 9, 8, 5]]
 
# Function Call
matrix(n, m, li)

// C# program for
// the above approach
using System;
using System.Collections;
class GFG{
  
// Function to rotate
// matrix by 45 degree
static void matrix(int n, int m,
                   int [,]li)
{
  // Counter Variable
  int ctr = 0;
 
  while (ctr < 2 * n - 1)
  {
    for(int i = 0;
            i < Math.Abs(n - ctr - 1);
            i++)
    {
      Console.Write(" ");
    }
 
    ArrayList lst = new ArrayList();
 
    // Iterate [0, m]
    for(int i = 0; i < m; i++)
    {
      // Iterate [0, n]
      for(int j = 0; j < n; j++)
      {
        // Diagonal Elements
        // Condition
        if (i + j == ctr)
        {
          // Appending the
          // Diagonal Elements
          lst.Add(li[i, j]);
        }
      }
    }
 
    // Printing reversed Diagonal
    // Elements
    for(int i = lst.Count - 1;
            i >= 0; i--)
    {
      Console.Write((int)lst[i] + " ");
    }
 
    Console.Write("\n");
    ctr += 1;
  }
}
  
// Driver code   
public static void Main(string[] args)
{   
  // Dimensions of Matrix
  int n = 8;
  int m = n;
  
  // Given matrix
  int[,] li = {{4, 5, 6, 9, 8, 7, 1, 4},
               {1, 5, 9, 7, 5, 3, 1, 6},
               {7, 5, 3, 1, 5, 9, 8, 0},
               {6, 5, 4, 7, 8, 9, 3, 7},
               {3, 5, 6, 4, 8, 9, 2, 1},
               {3, 1, 6, 4, 7, 9, 5, 0},
               {8, 0, 7, 2, 3, 1, 0, 8},
               {7, 5, 3, 1, 5, 9, 8, 5}};
  
  // Function call
  matrix(n, m, li);
}
}
 
// This code is contributed by Rutvik_56

<script>
 
// Javascript program to rotate a matrix by 45 degrees
 
// A function to rotate a matrix
// mat[][] of size R x C.
// Initially, m = R and n = C
function matrix(m, n, mat)
{
    let ctr = 0;
     
    while(ctr < 2*n-1)
    {
        for(let i = 0; i < Math.abs(n-ctr-1); i++)
        {
            document.write(" ");
        }
     
    var list = [];
    // Iterate [0, m]
    for(let i = 0; i < m; i++)
    {
          
        // Iterate [0, n]
        for(let j = 0; j < n; j++)
        {
              
            // Diagonal Elements
            // Condition
            if (i + j == ctr)
            {
                  
                // Appending the
                // Diagonal Elements
                list.push(mat[i][j]);
            }
        }
    }
 
    // Print rotated matrix
    for(let i = list.length-1; i >= 0; i--)
    {
            document.write(list[i] + " ");
    }       
        document.write("<br>");
        ctr+=1;
    }
 
}
 
// Driver code
 
// Test Case 1
let R = 8;
let C = 8;
let a = [ [ 4, 5, 6, 9, 8, 7, 1, 4 ],
        [ 1, 5, 9, 7, 5, 3, 1, 6 ],
        [ 7, 5, 3, 1, 5, 9, 8, 0 ],
        [ 6, 5, 4, 7, 8, 9, 3, 7 ],
        [ 3, 5, 6, 4, 8, 9, 2, 1 ],
        [ 3, 1, 6, 4, 7, 9, 5, 0 ],
        [ 8, 0, 7, 2, 3, 1, 0, 8 ],
        [ 7, 5, 3, 1, 5, 9, 8, 5 ]  ];
         
matrix(R, C, a);
 
// This code is contributed by Aarti_Rathi
 
</script>

       4 
      1 5 
     7 5 6 
    6 5 9 9 
   3 5 3 7 8 
  3 5 4 1 5 7 
 8 1 6 7 5 3 1 
7 0 6 4 8 9 1 4 
 5 7 4 8 9 8 6 
  3 2 7 9 3 0 
   1 3 9 2 7 
    5 1 5 1 
     9 0 0 
      8 8 
       5 

Complejidad temporal: O(N ³ )
Espacio auxiliar: O(N)

Enfoque 2: 

 (por rythmrana2)

Siga los pasos dados para imprimir la array girada 45 grados:

1. imprima los espacios requeridos.
2. imprime el elemento de esta manera –

          recorrer la array de la forma en que desea imprimirla – 

• Imprimiremos la array dividiéndola en dos partes usando dos bucles for, el primer bucle imprimirá el primer triángulo de la array y el segundo bucle imprimirá el segundo triángulo de la array
• para la primera mitad de la array, tome un bucle que vaya desde la primera fila hasta la última fila de la array.
• en cada fila, tome un bucle while que imprima el primer elemento de la fila y el segundo elemento de la fila sobre la fila actual y el tercer elemento de la fila que está dos veces por encima de la fila actual, de esta manera imprimiremos el primero semitriángulo de la array.
• tome dos contadores, c para contar cuántos elementos más tiene la diagonal actual y el contador inc para acceder a esos elementos.
• haga esto de manera similar para la segunda mitad de la array.

A continuación se muestra la implementación del enfoque anterior:

#include <bits/stdc++.h>
using namespace std;
 
// function to print the matrix rotated at 45 degree.
void rotate(int m, int n, int* a)
{
    // for printing the first half of matrix
    for (int i = 0; i < m; i++) {
 
        // print spaces
        for (int k = 0; k < m - i; k++) {
            cout << " ";
        }
        // counter to keep a track of the number of elements
        // left for the current diagonal
        int c = min(m - 1, min(i, n - 1));
 
        // to access the diagonal elements
        int inc = 0;
 
        // while loop prints the diagonal elements of the
        // current loop.
        while (i <= m - 1 && c != -1) {
            cout << *(a + (i - inc) * n + inc) << " ";
 
            // increasing this variable to reach the
            // remaining elements of the diagonal
            inc++;
 
            // decreasing the counter to as an element is
            // printed
            c--;
        }
 
        cout << endl;
    }
 
    // for printing second half of the matrix
    for (int j = 1; j < n; j++) {
 
        // print spaces
        if (m < n) {
            for (int k = 0; k <= j - 1; k++) {
                cout << " ";
            }
        }
        else{
            for (int k = 0; k <= j; k++) {
                cout << " ";
            }
        }
         
 
        // counter to keep a track of the number of elements
        // left for the current diagonal
        int c2 = min(m - 1, n - j - 1);
 
        // to access the diagonal elements
        int inc2 = 0;
 
        // while loop prints the diagonal elements of the
        // current loop.
        while (j <= n - 1 && c2 != -1) {
            cout << *((a + (m - 1 - inc2) * n) + j + inc2)
                 << " ";
            inc2++;
            c2--;
        }
 
        cout << endl;
    }
}
// Driver code
int main()
{
    int m, n;
    cin >> m >> n;
    int a[m][n];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cin >> a[i][j];
        }
    }
    rotate(m, n, (int*)a);
    return 0;
} // contributed by rythmrana2

      3 
     6 4 
    1 9 5 
   4 5 8 1 
  4 7 9 7 5 
 4 5 8 7 2 9 
  5 2 9 5 5 
   7 9 3 3 
    2 5 5 
     9 6 
      8 

Complejidad del tiempo: O(N ² )

Espacio Auxiliar: O(1)