¿Cómo ordenaría una matriz 2D de manera que las filas y columnas se clasifiquen en orden creciente? Los elementos de las filas deben ser únicos.

Answer 1

A2A

“Primero tengo que comparar los elementos de la primera fila y luego comparar los elementos de la columna “.

He usado el lenguaje java, puede usar cualquier otro idioma en el que se sienta cómodo.

Programa:

import java.util. *;

matriz de clase

{

público estático vacío principal (String abc [])

{

int i, j, z = 0, p = 0;

int A [] [] = nuevo int [2] [3];

Scanner sc = nuevo escáner (Recursos e información del sistema);

para (i = 0; i <2; i ++)

{

para (j = 0; j <3; j ++)

{

System.out.println (“Ingrese los elementos de la matriz”);

A [i] [j] = sc.nextInt ();

}

}

System.out.println (“\ n la primera matriz es”);

para (i = 0; i <2; i ++)

{

para (j = 0; j <3; j ++)

{

System.out.print (“” + A [i] [j]);

}

System.out.println (“”);

}

para (int b = 0; b <2; b ++)

{

si (A [b] [p] <A [b] [p + 1])

{

si (A [b] [p] <A [b] [p + 2])

{}

más

{

z = A [b] [p];

A [b] [p] = A [b] [p + 2];

A [b] [p + 2] = z;

}

}

más

{

z = A [b] [p];

A [b] [p] = A [b] [p + 1];

A [b] [p + 1] = z;

si (A [b] [p] <A [b] [p + 2])

{}

más

{

z = A [b] [p];

A [b] [p] = A [b] [p + 2];

A [b] [p + 2] = z;

}

}

si (A [b] [p + 1] <A [b] [p + 2])

{}

más

{

z = A [b] [p + 1];

A [b] [p + 1] = A [b] [p + 2];

A [b] [p + 2] = z;

}

}

para (int b = 0; b <2; b ++)

{

si (A [p] [b] <A [p + 1] [b])

{

}

más

{

z = A [p] [b];

A [p] [b] = A [p + 1] [b];

A [p + 1] [b] = z;

}

}

System.out.println (“\ nRequired Marix es:”);

para (i = 0; i <2; i ++)

{

para (j = 0; j <3; j ++)

{

System.out.print (“” + A [i] [j]);

}

System.out.println (“”);

}

}

}

salida:

Espero que esto ayude …

Saludos 😉

Answer 2

Esta es una buena solución al problema.

#include
usando el espacio de nombres estándar;

// Este mapa se usa para mantener el recuento de las ocurrencias de cada número.
map map1;

int main () {
//freopen(“in.txt “,” r “, stdin);
//freopen(“out.txt “,” w “, stdout);
int n, m, u;
cin >> n >> m; // dimensiones de la matriz.

// Si no está familiarizado con los vectores, es solo una matriz dinámica.
// En este caso, una matriz dinámica de 2d.
vector > a (n, vector (m));
map map1;

para (int i = 0; i para (int j = 0; j cin >> u;
if (map1.find (u) == map1.end ()) map1 [u] = 1;
de lo contrario map1 [u] ++;
}
}

iter automático = map1.begin ();
para (int i = 0; i iter = map1.begin (); // comienza desde el elemento min para cada fila.
para (int j = 0; j // si se han utilizado todas las ocurrencias, continúe eliminando hasta que un elemento con
// se encuentra una ocurrencia distinta de cero.
while (iter-> second == 0) iter = map1.erase (iter);
a [i] [j] = iter-> primero; // Asigna el valor del elemento encontrado.
iter-> segundo–; // disminuye su cuenta.
iter ++; // siguiente valor por favor.
}
}
bandera int = 1; // para verificar si la matriz es buena.
vector b (m);
para (int i = 0; i // si no está ordenado significa que no existe un sol.
if (! is_sorted (a [i] .begin (), a [i] .end ())) flag = 0;
}
// si existe sol.
if (bandera) {
para (int i = 0; i para (int j = 0; j cout << a [i] [j] << "";
}
cout << endl;
}
}
más {
cout << "-1 \ n";
}
devuelve 0;
}

Answer 3

Espero que esto satisfaga todos los casos. Este es el que se me ocurrió después de todo este tiempo.

#include
int main (int argc, char * argv []) {
// cambia a cualquier no de entradas
int a [] = {2,2,1,3,5,4}, temp;
resultado int [100] [100];
int n, filas, columnas;
int i, j, k;
n = sizeof (a) / sizeof (a [0]);
// ingrese filas y columnas para la matriz de salida
scanf (“% d”, & filas);
scanf (“% d”, & columnas);
// ordenamiento normal
para (i = 0; i para (j = 0; j si (a [j]> a [j + 1])
{
temp = a [j];
a [j] = a [j + 1];
a [j + 1] = temp;
}
}
// organiza los elementos ordenados verticalmente en una matriz 2D, esto garantiza que los elementos de las filas sean distintos, ya que los elementos similares se colocan en filas diferentes, por lo tanto, dado que los elementos verticales se ordenan, los elementos horizontales también se ordenan 🙂
para (i = 0, k = 0; i para (j = 0; j {
resultado [j] [i] = a [k];
}
// simplemente imprime la matriz 2D
para (i = 0; i {
para (j = 0; j printf (“% d”, resultado [i] [j]);
printf (“\ n”);
}
devuelve 0;
}