+- Foro no oficial de la UPCT (https://foroupct.es)
+-- Foro: 1º GIT (https://foroupct.es/Forum-1%C2%BA-GIT)
+--- Foro: Fundamentos de Programación (https://foroupct.es/Forum-Fundamentos-de-Programaci%C3%B3n)
+--- Tema: Práctica 4 (/Thread-Pr%C3%A1ctica-4--239)
Práctica 4 - alfonso - 04-01-2016
Código PHP:
package p4;
import p4.Matrices;
import utilidades.Teclado;
public class ProcesarArrays {
// PRÁCTICA 4 EJERCICIO 1 ............................................................
public static void invertir(int a []){
if(a!=null){
int b[] = new int [a.length];
int j=a.length-1;
for(int i=0;i<a.length;i++){
b[j--]=a[i];
}
System.out.print("La matriz inversa de (");
for(int i=0;i<a.length;i++){
System.out.print(a[i]+ " ");
}
System.out.print(") es (");
for(int i=0;i<b.length;i++){
System.out.print(b[i]+ " ");
}
System.out.println(")");
}else System.out.println("El elemento de entrada es NULL");
if(a.length==0) System.out.println("El elemento de entrada es de dimension 0");
}
// PRÁCTICA 4 EJERCICIO 2..........................................................
public static int [] ordenar(int [] a, boolean ascendente){
int b[]= new int [a.length];
int aux;
if(a==null) return null;
for(int g=0;g<a.length;g++){
b[g]=a[g];
}
if(ascendente==true){
for(int i=0;i<b.length-1;i++){
for(int j=0;j<b.length-1-i;j++){
if(b[j]>b[j+1]){
aux=b[j];
b[j]=b[j+1];
b[j+1]=aux;
}
}
}
}else{
for(int i=0;i<b.length-1;i++){
for(int j=0;j<b.length-1-i;j++){
if(b[j]<b[j+1]){
aux=b[j];
b[j]=b[j+1];
b[j+1]=aux;
}
}
}
}
return b;
}
// PRÁCTICA 4 EJERCICIO 3.....................................................
public static boolean hayRepetidos(int a []){
if(a==null || a.length==1) return false;
for(int i=0;i<a.length;i++){
for(int j=i+1;j<a.length;j++){
if(a[i]==a[j]) return true;
}
}
return false;
}
// PRÁCTICA 4 EJERCICIO 4.......................................................
public static int cuentaOcurrencias(int [] a, int k){
if(a.length==0) return 0;
int z=0;
for(int i=0;i<a.length;i++){
if(a[i]==k) z++;
}
return z;
}
public static int [] eliminarK(int [] a, int k){
if(a.length==0){
int b[]= new int [0];
return b;
}
if(a == null) return null;
int b[]= new int [a.length-cuentaOcurrencias(a,k)];
int j=0;
for(int i=0;i<a.length;i++){
if(a[i]!=k) b[j++]=a[i];
}
return b;
}
// PRÁCTICA 4 EJERCICIO 5.................................................
public static int [] ordenarIndices (char [] s){
if(s==null) return null;
if(s.length == 0){
int b[]= new int[0];
return b;
}
char t[] = {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','ñ','o','p','q','r','s','t','u','v','w','x','y','z'};
int b[] = new int [s.length];
for(int i=0;i<s.length;i++){
for(int j=0;j<t.length;j++){
if(s[i] == t[j]) b[i]=j;
}
}
return b;
}
// PRÁCTICA 4 EJERCICIO 6....................................................
public static int [] busquedaBinaria (int [] a, int clave){
if(a==null) return null;
for(int i=0;i<a.length-1;i++){
if(a[i]>a[i+1]) return null;
}
int z = cuentaOcurrencias(a,clave);
if(z==0) return null;
int b[]= new int [2];
//int contador=0;
//boolean prim=true;
int bajo = 0;
int alto = a.length -1;
int medio;
while (bajo <= alto) {
medio = (bajo + alto) / 2;
if (clave == a[medio]) { // se encontró
b[0]=medio;
b[1]=medio;
if(a[medio-1]== clave){
b[0] = medio -1;
b[1] = medio;
}
if(a[medio+1]==clave){
b[0]=medio;
b[1]=medio+1;
}
//System.out.println ("Está en " + medio);
//break;
return b;
}
else if (clave < a[medio]){
alto = medio - 1;
}
else {
bajo = medio + 1;
}
}
return b;
}
// PRÁCTICA 4 EJERCICIO 7....................................................
public static int busquedaBinariaRecursiva(int [] a, int clave){
if(a==null) return -1;
for(int i=0;i<a.length-1;i++){
if(a[i]>a[i+1]) return -1;//devuelve -1 si no está ordenada de menor a mayor
}
int z = cuentaOcurrencias(a,clave);
if(z>1) return -1;//devuelve -1 si hay elementos repetidos
int bajo = 0;
int alto = a.length -1;
int medio,tmp;
if(bajo <= alto){
}
while (bajo <= alto) {
medio = (bajo + alto) / 2;
if (clave == a[medio]) { // se encontró
//System.out.println ("Está en " + medio);
//break;
return tmp;
}
else if (clave < a[medio]){
alto = medio - 1;
}
else {
bajo = medio + 1;
}
}
}
// PRÁCTICA 4 EJERCICIO 8.....................................................
/**
* Devuelve un matriz resultado de haber eliminado la fila
* n-ésima de la matriz m pasada como argumento.
* @param m matriz
* @param n número de fila
* @return matriz resultado de haber eliminado la fila
* n-ésima de la matriz m pasada como argumento.
* null si m no es matriz o no existe la fila.
*/
public static double [][] quitarFila(double [][] m, int n){
if(Matrices.esMatriz(m)==false) return null;
if(n>=m.length || n<0) return null;
double b [][] = new double [m.length-1][m[0].length];
if(n==m.length-1){
for(int i=0;i<m.length-1;i++){
for(int j=0;j<m[i].length;j++){
//System.out.println(i);
//System.out.println(j);
b[i][j] = m[i][j];
}
}
}else{
int h=0;
for(int i=0;i<m.length;i++){
if(i != n){
for(int j=0;j<m[i].length;j++){
b[h][j] = m[i][j];
}
h++;
}
}
}
return b;
}
// PRÁCTICA 4 EJERCICIO 9.....................................................
/**
* Devuelve un matriz resultado de haber eliminado la
* n-ésima columna de la matriz m pasada como argumento.
* @param m matriz
* @param n columna
* @return matriz resultado de haber eliminado la
* n-ésima columna de la matriz m pasada como argumento..
* null si m no e matriz o no existe la columna.
*/
public static double [][] quitarCol(double [][] m, int n){
if(Matrices.esMatriz(m)==false) return null;
if(n>=m.length || n<0) return null;
double b [][] = new double [m.length][m[0].length-1];
int h=0;
if(n==0){
//System.out.println("if 1º");
for(int i=0;i<m.length;i++){
h=0;
for(int j=1;j<m[i].length;j++){
b[i][h++]=m[i][j];
}
}
}else if(n==m[0].length-1){
//System.out.println("if 2");
for(int i=0;i<m.length;i++){
for(int j=0;j<m[i].length-1;j++){
b[i][j] = m[i][j];
}
}
}else{
//h=0;
//System.out.println("el else");
for(int i=0;i<m.length;i++){
h=0;
for(int j=0;j<m[i].length;j++){
if(j != n){
b[i][h++] = m[i][j];
}
}
}
}
return b;
}
// PRÁCTICA 4 EJERCICIO 10......................................................
/**
* Dado un determinante de orden n, se llama menor complementario del
* elemento aij, al determinante de orden n-1 que resulta de suprimir
* en el determinante dado la fila i-ésima y la columna j-ésima.
* @param m determinante de orden n
* @param i índice de fila (aij)
* @param j índice de columna (aij)
* @return array de dos dimensiones con los elementos del menor complementario de m.
* null si m no es matriz o i y j no representan una fila y columna válidas.
*/
public static double [][] getMenorComplementario (double [][] m, int i, int j){
if(Matrices.esMatriz(m)==false) return null;
return quitarFila(quitarCol(m,j),i);
}
public static void resultado(int a[], int b[]){
for(int v=0;v<a.length;v++){
System.out.print(a[v]+ " ");
}
System.out.print("--a--> ");
for (int n=0;n<b.length;n++){
System.out.print(b[n]+ " ");
}
System.out.println("");
}
public static void resultado(char a[], int b[]){
for(int v=0;v<a.length;v++){
System.out.print(a[v]+ " ");
}
System.out.print("--a--> ");
for (int n=0;n<b.length;n++){
System.out.print(b[n]+ " ");
}
System.out.println("");
}
public static void main(String[] args) {
int h[]={4,23,45,13,45,3,1};
int h2[] = {0,1,1,3,4,5,13,13,20,22,40,42,42,42,44};
char x[]= {'a','l','f','o','n','s','o'};
int op,s;
do{
System.out.println("1. Invertir matriz");
System.out.println("2. Orden ascentende");
System.out.println("3. Orden descendente");
System.out.println("4. Elementos repetidos?");
System.out.println("5. Eliminar elemento");
System.out.println("6. Ordenar índices");
System.out.println("7. Búsqueda binaria");
System.out.println("8. salir");
op = Teclado.readInt();
switch (op){
case 1:
System.out.println("Invertir matriz");
invertir(h);
break;
case 2:
System.out.println("Orden ascendente:");
int j[]=ordenar(h,true);
for(int v=0;v<j.length;v++){
System.out.print(h[v]+ " ");
}
System.out.print("--a--> ");
for (int n=0;n<j.length;n++){
System.out.print(j[n]+ " ");
}
System.out.println("");
break;
case 3:
System.out.println("Orden descendente");
int k[]=ordenar(h,false);
resultado(h,k);
break;
case 4:
System.out.println("Elementos repetidos: "+ hayRepetidos(h));
break;
case 5:
System.out.print("Elemento a eliminar: ");
s = Teclado.readInt();
resultado(h,eliminarK(h,s));
case 6:
System.out.println("Ordenar índices");
resultado(x,ordenarIndices(x));
case 7:
System.out.print("Introduce clave a buscar: ");
s = Teclado.readInt();
resultado(h2,busquedaBinaria(h2,s));
}
}while(op<8);
}
}
Código PHP:
package p4;
import java.text.DecimalFormat;
public class Matrices {
/**
* Comprueba si un array de dos dimensiones es matriz.
* m != null && m[i] != null para i= 0..m.length-1 && m[i].length = m.length, i = 0..length-1
* @param m array bidimensional a comprobar
* @return true si m es matriz, false si no lo es.
*/
public static boolean esMatriz(double [][] m){
if (m == null){
return false;
}
if (m.length == 0){
return true;
}
for (int i = 0; i < m.length; i++){
if (m[i] == null){
return false;
}
if (m[i].length != m[0].length){
return false;
}
}
return true;
}
/**
* Comprueba si un array de dos dimensiones es matriz cuadrada.
* m es matriz && m.length == m[0].length
* @param m array bidimensional a comprobar
* @return true si m es matriz cuadrada, false si no lo es.
*/
public static boolean esMatrizCuadrada(double [][] m){
if (!esMatriz(m)){
return false;
}
if (m.length == 0){
return true;
}
if (m.length == m[0].length){
return true;
}
return false;
}
/**
* Devuelve la traspuesta de una matriz dada
* @param m matriz
* @return traspuesta de m
* null si m no es matriz.
*/
public static double [][] traspuesta(double [][] m){
if (!esMatriz(m)){
System.out.println("traspuesta: no es matriz: retorna null");
return null;
}
double [][] tr = new double[m[0].length][m.length];
for (int i = 0; i < tr.length; i++){
for (int j = 0; j < tr[i].length; j++){
tr[i][j] = m[j][i];
}
}
return tr;
}
/**
*
* Para depuración.
*
* Imprime en consola la matriz representada por m.
* @param p polinomio.
*/
public static void printMatriz(double [][] m){
if (!esMatriz(m)){
System.out.println("no es matriz");
return;
}
// Representación de los números con dos decimales.
DecimalFormat form = new DecimalFormat();
form.setMaximumFractionDigits(2);
String [][] ms = new String[m.length][m[0].length];
// Por cada columna apuntamos el elemento que más ocupa para
// ajustar la anchura de la columna en todas las filas.
int [] anchoCol = new int[m[0].length];
for (int i = 0; i < anchoCol.length; i++){
anchoCol[i] = 0;
}
// Obtenemos las representaciones de los números con dos decimales
// y apuntamos los anchos de columna.
for (int i = 0; i < ms.length; i++){
for(int j = 0; j < ms[i].length; j++){
ms[i][j] = form.format(m[i][j]);
if (anchoCol[j] < ms[i][j].length()){
anchoCol[j] = ms[i][j].length();
}
}
}
// Reconstruimos los elementos de ms ajustando las columnas y añadiendo
// blancos de separación entre columnas.
for (int i = 0; i < ms.length; i++){
for(int j = 0; j < ms[i].length; j++){
// Ajustar
while (ms[i][j].length() < anchoCol[j]){
ms[i][j] = " " + ms[i][j];
}
// Añadir separación.
ms[i][j] = ms[i][j] + " ";
}
}
// Imprimimos
for (int i = 0; i < ms.length; i++){
for (int j = 0; j < ms[i].length; j++){
System.out.print(ms[i][j]);
}
System.out.println();
}
}
/**
* Compara dos arrays de double
* @param m1 array 1
* @param m2 array 2
* @return true si son iguales elemento a elemento o si ambas referencias son null
* false en caso contrario.
*/
public static boolean compararMatrices(double [][] m1, double [][] m2){
if (m1 == null && m2 == null){
return true;
}
if (!esMatriz(m1) || !esMatriz(m2) ){
return false;
}
if (m1 == m2){
return true;
}
if (m1.length != m2.length){
return false;
}
if (m1[0].length != m2[0].length){
return false;
}
for (int i = 0; i < m1.length; i++){
for(int j = 0; j < m1[i].length; j++){
if (m1[i][j] != m2[i][j]){
return false;
}
}
}
return true;
}
/**
*
* Para depuración.
*
* Imprime en consola los elementos de un array de doubles.
* @param a array.
*/
public static void printArray(double [] a){
if (a == null){
System.out.print("null");
return;
}
System.out.print("{");
if (a.length == 0){
System.out.print("}");
return;
}
DecimalFormat form = new DecimalFormat();
form.setMaximumFractionDigits(3);
for (int i = 0; i < a.length-1; i++){
System.out.print(form.format(a[i]) + ", ");
}
System.out.print(form.format(a[a.length-1]) + "}");
}
/**
*
* Para depuración.
*
* Coloca en un array de Strings las filas de m.
* @param m matriz.
* @return array de Strings las filas de m.
* null si m no representa a una matriz.
*/
public static String [] matrizToStringArray(double [][] m){
if (!Matrices.esMatriz(m)){
return null;
}
String [] filas = new String[m.length];
// Representación de los números con dos decimales.
DecimalFormat form = new DecimalFormat();
form.setMaximumFractionDigits(3);
String [][] ms = new String[m.length][m[0].length];
// Por cada columna apuntamos el elemento que más ocupa para
// ajustar la anchura de la columna en todas las filas.
int [] anchoCol = new int[m[0].length];
for (int i = 0; i < anchoCol.length; i++){
anchoCol[i] = 0;
}
// Obtenemos las representaciones de los números con dos decimales
// y apuntamos los anchos de columna.
for (int i = 0; i < ms.length; i++){
for(int j = 0; j < ms[i].length; j++){
ms[i][j] = form.format(m[i][j]);
if (anchoCol[j] < ms[i][j].length()){
anchoCol[j] = ms[i][j].length();
}
}
}
// Reconstruimos los elementos de ms ajustando las columnas y añadiendo
// blancos de separación entre columnas.
for (int i = 0; i < ms.length; i++){
for(int j = 0; j < ms[i].length; j++){
// Ajustar
while (ms[i][j].length() < anchoCol[j]){
ms[i][j] = " " + ms[i][j];
}
// Añadir separación.
ms[i][j] = ms[i][j] + " ";
}
}
// Copiamos;
for (int i = 0; i < ms.length; i++){
StringBuffer sb = new StringBuffer();
for (int j = 0; j < ms[i].length; j++){
sb.append(ms[i][j]);
}
filas[i] = sb.toString();
}
return filas;
}
public static void printTabla(String [][] ms){
// Por cada columna apuntamos el elemento que más ocupa para
// ajustar la anchura de la columna en todas las filas.
int [] anchoCol = new int[ms[0].length];
for (int i = 0; i < anchoCol.length; i++){
anchoCol[i] = 0;
}
// Obtenemos las representaciones de los números con dos decimales
// y apuntamos los anchos de columna.
for (int i = 0; i < ms.length; i++){
for(int j = 0; j < ms[i].length; j++){
if (ms[i][j] == null){
ms[i][j] = "null";
}
if (anchoCol[j] < ms[i][j].length()){
anchoCol[j] = ms[i][j].length();
}
}
}
// Reconstruimos los elementos de ms ajustando las columnas y añadiendo
// blancos de separación entre columnas.
for (int i = 0; i < ms.length; i++){
for(int j = 0; j < ms[i].length; j++){
// Ajustar
while (ms[i][j].length() < anchoCol[j]){
ms[i][j] = ms[i][j] + " ";
}
// Añadir separación.
ms[i][j] = ms[i][j] + " ";
}
}
// Imprimimos
for (int i = 0; i < ms.length; i++){
for (int j = 0; j < ms[i].length; j++){
System.out.print(ms[i][j]);
}
System.out.println();
}
}
}
RE: Práctica 4 - alfonso - 04-01-2016
Aquí el test que proporciona el profesor para comprobar que funcionan correctamente las clases implementadas.
Código PHP:
package p4;
import p4.ProcesarArrays;
import p4.Matrices;
public class Test4 {
public static int test_quitarFila(){
System.out.println("***************************************************");
System.out.println("test_quitarFila ");
System.out.println();
int calificacion = 10;
double [][] m = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
double [][][] mf = {
{{4, 5, 6}, {7, 8, 9}},
{{1, 2, 3}, {7, 8, 9}},
{{1, 2, 3}, {4, 5, 6}},
};
double [][] nm = {{1, 2, 3}, {4, 6}, {7, 8, 9}};
System.out.print("Probando con argumento null: ");
try{
double r [][] = ProcesarArrays.quitarFila(null, 1);
if (r != null){
System.out.println(" ---> Error, debería devolver null: (-2) ");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
}catch(Exception exc){
System.out.println(" ---> Error: Se produce error en tiempo de ejecución: (-2)");
calificacion -= 2;
exc.printStackTrace();
}
System.out.println("Probando con argumento que no es matriz válida: ");
try{
double [][] r = null;
for (int i = 0; i < nm[0].length; i++){
//System.out.println("-----------------------");
//System.out.println("Quitando fila " + i);
r = ProcesarArrays.quitarFila(nm, i);
//Algebra.printMatriz(r);
if (r != null){
System.out.println(" ---> Error, debería devolver null. (-2)");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
//System.out.println();
}
}catch(Exception exc){
System.out.println("Se produce error en tiempo de ejecución. (-2) ");
calificacion -= 2;
exc.printStackTrace();
}
System.out.print("Probando con filas que no existen: (-1 y m.length) ");
try{
if (ProcesarArrays.quitarFila(m, -1) != null || ProcesarArrays.quitarFila(m, m.length) != null){
System.out.println("Se produce error en tiempo de ejecución. (-2) ");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
}catch(Exception exc){
System.out.println("Se produce error en tiempo de ejecución. (-2) ");
calificacion -= 2;
exc.printStackTrace();
}
System.out.println("Probando con matrices válidas e índices en rango: ");
Matrices.printMatriz(m);
for (int i = 0; i < m.length; i++){
System.out.println("-----------------------");
System.out.println("Quitando fila " + i);
double r [][] = ProcesarArrays.quitarFila(m, i);
Matrices.printMatriz(r);
if (!Matrices.compararMatrices(r, mf[i])){
System.out.println(" ---> Error, la matriz solicitada no es la obtenida. (-2) ");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
}
calificacion = calificacion>=0?calificacion:0;
System.out.println();
System.out.println("---------------------------------------------------------");
System.out.println("test quitarFila, calificación = " + calificacion);
System.out.println("---------------------------------------------------------");
System.out.println();
System.out.println();
return calificacion;
}
public static int test_quitarColumna(){
System.out.println("******************************************************");
System.out.println("test_quitarColumna ");
System.out.println();
int calificacion = 10;
double [][] m = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
double [][][] mf = {
{{2, 3}, {5, 6}, {8, 9}},
{{1, 3}, {4, 6}, {7, 9}},
{{1, 2}, {4, 5}, {7, 8}},
};
double [][] nm = {{1, 2, 3}, {4, 6}, {7, 8, 9}};
System.out.print("Probando con argumento null: ");
try{
double r [][] = ProcesarArrays.quitarCol(null, 1);
if (r != null){
System.out.println(" ---> Error, debería devolver null: (-2) ");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
}catch(Exception exc){
System.out.println(" ---> Error: Se produce error en tiempo de ejecución: (-2)");
calificacion -= 2;
exc.printStackTrace();
}
System.out.println("Probando con argumento que no es matriz válida: ");
try{
double [][] r = null;
for (int i = 0; i < nm[0].length; i++){
//System.out.println("-----------------------");
//System.out.println("Quitando columna " + i);
r = ProcesarArrays.quitarCol(nm, i);
//Algebra.printMatriz(r);
if (r != null){
System.out.println(" ---> Error, debería devolver null. (-2)");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
//System.out.println();
}
}catch(Exception exc){
System.out.println("Se produce error en tiempo de ejecución. (-2) ");
calificacion -= 2;
exc.printStackTrace();
}
System.out.print("Probando con columnas que no existen: (-1 y m.length) ");
try{
if (ProcesarArrays.quitarCol(m, -1) != null || ProcesarArrays.quitarCol(m, m.length) != null){
System.out.println("Se produce error en tiempo de ejecución. (-2) ");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
}catch(Exception exc){
System.out.println("Se produce error en tiempo de ejecución. (-2) ");
calificacion -= 2;
exc.printStackTrace();
}
System.out.println("Probando con matrices válidas e índices en rango: ");
Matrices.printMatriz(m);
for (int i = 0; i < m.length; i++){
System.out.println("-----------------------");
System.out.println("Quitando columna " + i);
double r [][] = ProcesarArrays.quitarCol(m, i);
Matrices.printMatriz(r);
if (!Matrices.compararMatrices(r, mf[i])){
System.out.println(" ---> Error, la matriz solicitada no es la obtenida. (-2) ");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
}
calificacion = calificacion>=0?calificacion:0;
System.out.println();
System.out.println("---------------------------------------------------------");
System.out.println("test quitarColumna, calificación = " + calificacion);
System.out.println("---------------------------------------------------------");
System.out.println();
System.out.println();
return calificacion;
}
public static int test_getMenorComplementario(){
System.out.println("*****************************************************");
System.out.println("test_getMenorComplementario ");
System.out.println();
int calificacion = 10;
double [][] m = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
double [][][][] adjuntos = {
{
{{5, 6}, {8, 9}},
{{4, 6}, {7, 9}},
{{4, 5}, {7, 8}}
},
{
{{2, 3}, {8, 9}},
{{1, 3}, {7, 9}},
{{1, 2}, {7, 8}}
},
{
{{2, 3}, {5, 6}},
{{1, 3}, {4, 6}},
{{1, 2}, {4, 5}}
}
};
double [][] nm = {{1, 2, 3}, null, {7, 8, 9}};
System.out.print("Probando con argumento null: ");
try{
double r [][] = ProcesarArrays.getMenorComplementario(null, 1, 1);
if (r != null){
System.out.println(" ---> Error, debería devolver null: (-2) ");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
}catch(Exception exc){
System.out.println(" ---> Error: Se produce error en tiempo de ejecución: (-2)");
calificacion -= 2;
exc.printStackTrace();
}
System.out.println("Probando con argumento que no es matriz válida: ");
try{
double [][] r = null;
for (int i = 0; i < nm[0].length; i++){
//System.out.println("-----------------------");
//System.out.println("probando con índices: " + i);
r = ProcesarArrays.getMenorComplementario(nm, i, 0);
//Algebra.printMatriz(r);
if (r != null){
System.out.println(" ---> Error, debería devolver null. (-2)");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
//System.out.println();
}
}catch(Exception exc){
System.out.println("Se produce error en tiempo de ejecución. (-2) ");
calificacion -= 2;
exc.printStackTrace();
}
System.out.println("---------------------------------------------------------");
System.out.println("Probando con elementos que no existen: (-1 y m.length) ");
try{
if (ProcesarArrays.getMenorComplementario(m, -1, 0) != null || ProcesarArrays.getMenorComplementario(m, m.length, 1) != null){
System.out.println("Se produce error en tiempo de ejecución. (-2) ");
calificacion -= 2;
}
else{
System.out.println(" ---> OK");
}
}catch(Exception exc){
System.out.println("Se produce error en tiempo de ejecución. (-2) ");
calificacion -= 2;
exc.printStackTrace();
}
System.out.println("---------------------------------------------------------");
System.out.println("Probando con matrices válidas e índices en rango ");
Matrices.printMatriz(m);
int errores = 0;
String tabla [][] = new String[m.length-1][m[0].length];
for (int i = 0; i < m.length; i++){
System.out.println("menores complementario de elementos de fila: " + i);
for (int j = 0; j < m[i].length; j++){
double r [][] = ProcesarArrays.getMenorComplementario(m, i, j);
String tr[] = Matrices.matrizToStringArray(r);
/*
for(int k = 0; k < tr.length; k++){
System.out.println(tr[k]);
}
*/
for(int k = 0; k < tr.length; k++){
tabla[k][j] = tr[k];
}
if (!Matrices.compararMatrices(r, adjuntos[i][j])){
errores++;
}
}
Matrices.printTabla(tabla);
}
if (errores == 0){
System.out.println(" ---> OK");
}
else{
calificacion -= errores;
System.out.println(" ---> Error. " + errores + " menores complementarios han sido mal construidos");
}
calificacion = calificacion>=0?calificacion:0;
System.out.println();
System.out.println("---------------------------------------------------------");
System.out.println("test getMenorComplementario, calificación = " + calificacion);
System.out.println("---------------------------------------------------------");
System.out.println();
System.out.println();
return calificacion;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
test_quitarFila();
test_quitarColumna();
test_getMenorComplementario();
}
}