Dada una array, ordene las filas de la array en orden ascendente y luego ordene las columnas en orden descendente.
Ejemplos:
Input : a[3][3] = {{1, 2, 3},
{4, 5, 6},
{7, 8, 9}};
Output : 7 8 9
4 5 6
1 2 3
Input : a[3][3] = {{3, 2, 1},
{9, 8, 7},
{6, 5, 4}};
Output : 7 8 9
4 5 6
1 2 3
Acercarse:
- Recorra todas las filas una por una y ordene las filas en orden ascendente utilizando una clasificación de array simple.
- Convertir array a su transpuesta
- Nuevamente ordene todas las filas, pero esta vez en orden descendente.
- Nuevamente convierta una array a su transpuesta
A continuación se muestra la implementación del enfoque anterior:
C++
// C++ implementation to sort the rows
// of matrix in ascending order followed by
// sorting the columns in descending order
#include <bits/stdc++.h>
using namespace std;
#define MAX_SIZE 10
// function to sort each row of the matrix
// according to the order specified by
// ascending.
void sortByRow(int mat[][MAX_SIZE], int n,
bool ascending)
{
for (int i = 0; i < n; i++)
{
if (ascending)
sort(mat[i], mat[i] + n);
else
sort(mat[i], mat[i] + n, greater<int>());
}
}
// function to find transpose of the matrix
void transpose(int mat[][MAX_SIZE], int n)
{
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
// swapping element at index (i, j)
// by element at index (j, i)
swap(mat[i][j], mat[j][i]);
}
// function to sort the matrix row-wise
// and column-wise
void sortMatRowAndColWise(int mat[][MAX_SIZE],
int n)
{
// sort rows of mat[][]
sortByRow(mat, n, true);
// get transpose of mat[][]
transpose(mat, n);
// again sort rows of mat[][] in descending
// order.
sortByRow(mat, n, false);
// again get transpose of mat[][]
transpose(mat, n);
}
// function to print the matrix
void printMat(int mat[][MAX_SIZE], int n)
{
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
cout << mat[i][j] << " ";
cout << endl;
}
}
// Driver program to test above
int main()
{
int n = 3;
int mat[n][MAX_SIZE] = {{3, 2, 1},
{9, 8, 7},
{6, 5, 4}};
cout << "Original Matrix:\n";
printMat(mat, n);
sortMatRowAndColWise(mat, n);
cout << "\nMatrix After Sorting:\n";
printMat(mat, n);
return 0;
}
Java
// Java implementation to sort the rows
// of matrix in ascending order followed by
// sorting the columns in descending order
import java.util.Arrays;
import java.util.Collections;
class GFG
{
static int MAX_SIZE=10;
// function to sort each row of the matrix
// according to the order specified by
// ascending.
static void sortByRow(Integer mat[][], int n,
boolean ascending)
{
for (int i = 0; i < n; i++)
{
if (ascending)
Arrays.sort(mat[i]);
else
Arrays.sort(mat[i],Collections.reverseOrder());
}
}
// function to find transpose of the matrix
static void transpose(Integer mat[][], int n)
{
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
{
// swapping element at index (i, j)
// by element at index (j, i)
int temp = mat[i][j];
mat[i][j] = mat[j][i];
mat[j][i] = temp;
}
}
// function to sort the matrix row-wise
// and column-wise
static void sortMatRowAndColWise(Integer mat[][],
int n)
{
// sort rows of mat[][]
sortByRow(mat, n, true);
// get transpose of mat[][]
transpose(mat, n);
// again sort rows of mat[][] in descending
// order.
sortByRow(mat, n, false);
// again get transpose of mat[][]
transpose(mat, n);
}
// function to print the matrix
static void printMat(Integer mat[][], int n)
{
for (int i = 0; i < n; i++)
{
for (int j = 0; j < n; j++)
System.out.print(mat[i][j] + " ");
System.out.println();
}
}
// Driver code
public static void main (String[] args)
{
int n = 3;
Integer mat[][] = {{3, 2, 1},
{9, 8, 7},
{6, 5, 4}};
System.out.print("Original Matrix:\n");
printMat(mat, n);
sortMatRowAndColWise(mat, n);
System.out.print("\nMatrix After Sorting:\n");
printMat(mat, n);
}
}
// This code is contributed by Anant Agarwal.
Python3
# Python implementation to sort the rows
# of matrix in ascending order followed by
# sorting the columns in descending order
MAX_SIZE=10
# function to sort each row of the matrix
# according to the order specified by
# ascending.
def sortByRow(mat, n, ascending):
for i in range(n):
if (ascending):
mat[i].sort()
else:
mat[i].sort(reverse=True)
# function to find
# transpose of the matrix
def transpose(mat, n):
for i in range(n):
for j in range(i + 1, n):
# swapping element at index (i, j)
# by element at index (j, i)
temp = mat[i][j]
mat[i][j] = mat[j][i]
mat[j][i] = temp
# function to sort
# the matrix row-wise
# and column-wise
def sortMatRowAndColWise(mat, n):
# sort rows of mat[][]
sortByRow(mat, n, True)
# get transpose of mat[][]
transpose(mat, n)
# again sort rows of
# mat[][] in descending
# order.
sortByRow(mat, n, False)
# again get transpose of mat[][]
transpose(mat, n)
# function to print the matrix
def printMat(mat, n):
for i in range(n):
for j in range(n):
print(mat[i][j] , " ", end="")
print()
#Driver code
n = 3
mat = [[3, 2, 1],
[9, 8, 7],
[6, 5, 4]]
print("Original Matrix:")
printMat(mat, n)
sortMatRowAndColWise(mat, n)
print("Matrix After Sorting:")
printMat(mat, n)
# This code is contributed
# by Anant Agarwal.
C#
// C# implementation to sort the rows
// of matrix in ascending order followed by
// sorting the columns in descending order
using System;
public static class GFG {
// function to sort each row of the matrix
// according to the order specified by
// ascending.
static void sortByRow(int[, ] m)
{
// loop for rows of matrix
for (int i = 0; i < m.GetLength(0); i++) {
// loop for column of matrix
for (int j = 0; j < m.GetLength(1); j++) {
// loop for comparison and swapping
for (int k = 0; k < m.GetLength(1) - j - 1;
k++) {
if (m[i, k] > m[i, k + 1]) {
// swapping of elements
int t = m[i, k];
m[i, k] = m[i, k + 1];
m[i, k + 1] = t;
}
}
}
}
}
static void reverseArray(int[, ] arr)
{
// Traverse each row of [,]arr
for (int i = 0; i < arr.GetLength(1); i++) {
// Initialise start and end index
int start = 0;
int end = arr.GetLength(0) - 1;
// Till start < end, swap the element
// at start and end index
while (start < end) {
// Swap the element
int temp = arr[i, start];
arr[i, start] = arr[i, end];
arr[i, end] = temp;
// Increment start and decrement
// end for next pair of swapping
start++;
end--;
}
}
}
// function to find transpose of the matrix
public static void transpose(int[, ] mat, int n)
{
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
// swapping element at index (i, j)
// by element at index (j, i)
int temp = mat[i, j];
mat[i, j] = mat[j, i];
mat[j, i] = temp;
}
}
}
// function to sort the matrix row-wise
// and column-wise
public static void sortMatRowAndColWise(int[, ] mat,
int n)
{
// sort rows of mat[][]
sortByRow(mat);
// get transpose of mat[][]
transpose(mat, n);
// again sort rows of mat[][] in descending
// order.
sortByRow(mat);
reverseArray(mat);
// again get transpose of mat[][]
transpose(mat, n);
}
// function to print the matrix
public static void printMat(int[, ] mat, int n)
{
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
Console.Write(mat[i, j]);
Console.Write(" ");
}
Console.Write("\n");
}
}
// Driver program to test above
internal static void Main()
{
int n = 3;
int[, ] mat
= { { 3, 2, 1 }, { 9, 8, 7 }, { 6, 5, 4 } };
Console.Write("Original Matrix:\n");
printMat(mat, n);
sortMatRowAndColWise(mat, n);
Console.Write("\nMatrix After Sorting:\n");
printMat(mat, n);
}
}
// This code is contributed by Aarti_Rathi
PHP
<?php
// PHP implementation to sort the rows
// of matrix in ascending order followed by
// sorting the columns in descending order
$MAX_SIZE = 10;
// function to sort each row of the matrix
// according to the order specified by
// ascending.
function sortByRow(&$mat, $n, $ascending)
{
for ($i = 0; $i < $n; $i++)
{
if ($ascending)
sort($mat[$i]);
else
rsort($mat[$i]);
}
}
// function to find transpose
// of the matrix
function transpose(&$mat, $n)
{
for ($i = 0; $i < $n; $i++)
{
for ($j = $i + 1; $j < $n; $j++)
{
// swapping element at index (i, j)
// by element at index (j, i)
$temp = $mat[$i][$j];
$mat[$i][$j] = $mat[$j][$i];
$mat[$j][$i] = $temp;
}
}
}
// function to sort the matrix row-wise
// and column-wise
function sortMatRowAndColWise(&$mat, $n)
{
// sort rows of mat[][]
sortByRow($mat, $n, true);
// get transpose of mat[][]
transpose($mat, $n);
// again sort rows of mat[][] in
// descending order.
sortByRow($mat, $n, false);
// again get transpose of mat[][]
transpose($mat, $n);
}
// function to print the matrix
function printMat(&$mat, $n)
{
for ($i = 0; $i < $n; $i++)
{
for ($j = 0; $j < $n; $j++)
echo $mat[$i][$j] . " ";
echo "\n" ;
}
}
// Driver Code
$n = 3;
$mat = array(array(3, 2, 1),
array(9, 8, 7),
array(6, 5, 4));
echo "Original Matrix:\n";
printMat($mat, $n);
sortMatRowAndColWise($mat, $n);
echo "\nMatrix After Sorting:\n";
printMat($mat, $n);
// This code is contributed by Ita_c
?>
Javascript
<script>
// Javascript implementation to sort the rows
// of matrix in ascending order followed by
// sorting the columns in descending order
let MAX_SIZE=10;
// function to sort each row of the matrix
// according to the order specified by
// ascending.
function sortByRow(mat,n,ascending)
{
for (let i = 0; i < n; i++)
{
if (ascending)
mat[i].sort(function(a,b){return a-b;});
else
mat[i].sort(function(a,b){return b-a;});
}
}
// function to find transpose of the matrix
function transpose(mat,n)
{
for (let i = 0; i < n; i++)
for (let j = i + 1; j < n; j++)
{
// swapping element at index (i, j)
// by element at index (j, i)
let temp = mat[i][j];
mat[i][j] = mat[j][i];
mat[j][i] = temp;
}
}
// function to sort the matrix row-wise
// and column-wise
function sortMatRowAndColWise(mat,n)
{
// sort rows of mat[][]
sortByRow(mat, n, true);
// get transpose of mat[][]
transpose(mat, n);
// again sort rows of mat[][] in descending
// order.
sortByRow(mat, n, false);
// again get transpose of mat[][]
transpose(mat, n);
}
// function to print the matrix
function printMat(mat,n)
{
for (let i = 0; i < n; i++)
{
for (let j = 0; j < n; j++)
document.write(mat[i][j] + " ");
document.write("<br>");
}
}
// Driver code
let n = 3;
let mat = [[3, 2, 1],
[9, 8, 7],
[6, 5, 4]];
document.write("Original Matrix:<br>");
printMat(mat, n);
sortMatRowAndColWise(mat, n);
document.write("\nMatrix After Sorting:<br>");
printMat(mat, n);
// This code is contributed by avanitrachhadiya2155
</script>
Producción
Original Matrix: 3 2 1 9 8 7 6 5 4 Matrix After Sorting: 7 8 9 4 5 6 1 2 3
Complejidad temporal: O(N 2 log N)
Espacio auxiliar: O(1)
Publicación traducida automáticamente
Artículo escrito por MrinalVerma y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA