Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » NECESITO AYUDA CON ESTE EJERCICIO DE JAVA

Java - NECESITO AYUDA CON ESTE EJERCICIO DE JAVA

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil

NECESITO AYUDA CON ESTE EJERCICIO DE JAVA

Publicado por Akaza (2 intervenciones) el 17/12/2022 20:11:07
Una matriz cuadrada de enteros se define como de “máximos crecientes continuos y uniformemente
distribuidos” (MCCUD) si cumple:
1. En cada fila de la matriz todos los valores de esa fila son distintos entre sí.
2. max_fila_1 < max_fila_2 < max_fila_3 < ...< max_fila_N donde, max_fila_i, representa el mayor
valor entero encontrado en la fila i-ésima de la matriz.
3. ∀i, (max_fila_i+1 – max_fila_i = constante), es decir, la diferencia entre los máximos de dos filas
consecutivas es constante.
Departamento de Informática e Ingeniería de Sistemas pág. 2
Prácticas de Informática. Grado en Ingeniería Eléctrica
4. En cada columna de la matriz hay una única componente cuyo valor es el valor máximo de la fila de
esa componente.
En la figura se muestra una matriz MCCUD.
Se pide codificar un programa en Java que pida la dimensión de la matriz por teclado, pida los valores de sus
elementos también por teclado y determine si es MCCUD. La solución de este problema tiene que
contener al menos 4 funciones (1 por condición) pero puede contener más si las consideráis necesarias.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Richtofen

NECESITO AYUDA CON ESTE EJERCICIO DE JAVA

Publicado por Richtofen (18 intervenciones) el 25/01/2023 13:58:41
Buenas,

Te dejo un código de ejemplo por si te ayuda pero básicmente son ejercicios típicos de array para manejarte con ellos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
public class Main
{
 
  /**
   * Método auxiliar para encontrar números repetidos en un array
   */
  private static boolean isRepeatedNumber(int[] currentRow)
  {
    int currentPos = 0;
    boolean equalsDetected = false;
    for (int index = 0; index < currentRow.length; index++)
    {
      for (int i = 0; i < currentRow.length; i++)
      {
        if( currentPos != i )
        {
          if( currentRow[currentPos] == currentRow[i] )
          {
            equalsDetected = true;
            break;
          }
        }
      }
      // Exit loop is a num is equals
      if(equalsDetected)
      {
        break;
      }
      else{
        currentPos++;
      }
    }
    return equalsDetected;
  }
 
  /**
   * 1. En cada fila de la matriz todos los valores de esa fila son distintos entre sí.
   */
  private static boolean checkRowElements(int[][] A)
  {
    boolean equalsDetected = false;
    for (int i = 0; i < A.length; i++)
    {
      equalsDetected = isRepeatedNumber(A[i]); // Fila de A para analizar
      if(equalsDetected)
        break;
    }
    return equalsDetected;
  }
 
  /**
   * Metodo auxiliar para encontrar el maximo de un array
   */
  private static int maxRowElement(int[] currentRow)
  {
    int tmpMax = currentRow[0];
    for (int i = 1; i < currentRow.length; i++)
    {
      tmpMax = ( currentRow[i] > tmpMax ) ? currentRow[i] : tmpMax;
    }
    return tmpMax;
  }
 
  /**
   * 2. max_fila_1 < max_fila_2 < max_fila_3 < ...< max_fila_N donde, max_fila_i, representa el mayor
   * valor entero encontrado en la fila i-ésima de la matriz.
   */
  public static boolean checkMaxRowElements(int[][] A)
  {
    boolean res = true;
    int maxCurrentRow = maxRowElement(A[0]);
    for (int i = 1; i < A.length; i++)
    {
      if( maxRowElement(A[i]) <= maxCurrentRow )
      {
        System.out.println( "   * El elemento máximo de la fila [" + (i+1) + "] = " + maxRowElement(A[i]) +
                            " es más pequeño que el elemento máximo de la fila [" + i + "] = " + maxCurrentRow);
        res = false;
        break;
      }
      else{
        maxCurrentRow = maxRowElement(A[i]);
      }
    }
    return res;
  }
 
 
  /**
   * ∀i, (max_fila_i+1 – max_fila_i = constante), es decir, la diferencia entre los máximos de dos
   * filas consecutivas es constante.
   */
  private static boolean checkRowDiff(int[][] A)
  {
    boolean res = true;
    int diffValue = maxRowElement(A[1]) - maxRowElement(A[0]);
    for (int i = 1; i < A.length-1; i++)
    {
      if( (maxRowElement(A[i+1]) - maxRowElement(A[i])) != diffValue )
      {
        System.out.println( "   * La diferencia de valores máximos inicial (Fila 1 y 0) es " + diffValue +
                            " y la diferencia entre Filas " + (i+1) + " y " + i + " es " +  (maxRowElement(A[i+1]) - maxRowElement(A[i])));
        res = false;
        break;
      }
    }
    return res;
  }
 
  /**
   * 4. En cada columna de la matriz hay una única componente cuyo valor es el valor máximo
   * de la fila de esa componente.
   */
  private static boolean checkMaxElementColumns(int[][] A)
  {
    boolean res = true;
    boolean maxInSameCols = false;
    boolean[] ocuppiedCols = new boolean[A[0].length]; // Todos elementos false
    for (int i = 0; i < A.length; i++)
    {
      // Se obtiene el máximo de esa fila
      int currentMax = maxRowElement(A[i]);
      // Se busca en que columna se encuentra dicho maximo
      for (int j = 0; j < A[0].length; j++)
      {
        if( currentMax == A[i][j] )
        {
          // Se comprueba que en dicha columna no se haya hallado un máximo previamente
          if( ocuppiedCols[j] == true)
          {
            System.out.println("En la columna " + j + " ya se encontraba un máximo de fila");
            maxInSameCols = true;
          }
          else{
            ocuppiedCols[j] = true;
          }
          break;
        }
      }
      // No se sigue evaluando la matriz ya que hay una columna donde no se cumple la condición
      if(maxInSameCols)
      {
        res = false;
        break;
      }
    }
    return res;
  }
 
  /**
   * Método final donde se evalua is la matriz es MCCUD
   */
  private static boolean isMccud(int[][] A)
  {
    boolean checkCond1 = false, checkCond2 = false, checkCond3 = false, checkCond4 = false;
    System.out.println("Cumple condicion 1? " + ( checkCond1 = !checkRowElements(A) ) ); // Devuelve false si no hay numeros repetidos
    System.out.println("Cumple condicion 2? " + ( checkCond2 = checkMaxRowElements(A) ) );
    System.out.println("Cumple condicion 3? " + ( checkCond3 = checkRowDiff(A) ) );
    System.out.println("Cumple condicion 4? " + ( checkCond4 = checkMaxElementColumns(A) ) );
    return checkCond1 && checkCond2 && checkCond3 && checkCond4;
  }
 
 
  public static void main(String[] args)
  {
    int[][] A = { { 5, 6, 2,-4},
                  { 6, 7, 8, 3},
                  {10, 4,-5, 9},
                  { 4,-7, 1,12} };
 
    System.out.println( "\nLa matriz es MCUUD? "+ isMccud(A) );
  }
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar