UNIDAD 3. Ejercicios de U03 Soluciones.

EJERCICIOS DEL TEMA

EJERCICIO 0. Imagina que quieres usar Java JDK SE 17 (que nace

con vocación de LTS (Long-Time-Support)) y tu versión de Eclipse no
le da soporte, visita markeplacet y busca "Java 17" para instalar el
soporte de este JDK en el IDE Eclipse.

En primer lugar hay que instalar el JDK 17, luego hay que tener
instalado Eclipse. Por último vamos a Help -> MarketPlace y en buscar
escribimos java 17. En el plugin Java 17 Support for Eclipse 2021-09
pulsamos install y aceptamos las licencias.

EJERCICIO 1: Repite el ejemplo 8 usando un bucle while.

1/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

int i = 0;
while (i <= 1000) { // Observa que cambia el < por <=
System.out.println(i); // Y el orden de hacer las operaciones
i++;
};

EJERCICIO 2. En este ejemplo, ¿El bucle es controlado por centinela

o contador? Por contador. La variable i va cambiando (contando) con
los valores que usa el bucle.

EJERCICIO 3: escribe un trozo de código que cree y rellene el array

d a partir de los datos que haya en el array a del ejemplo anterior.
public class GraficoBarras {
public static void main(String[] args) {
int[] a = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 };
// Serías capaz de escribir el código que genera d?
// int[] d = { 0, 0, 0, 0, 0, 0, 1, 2, 4, 2, 1 };
int[] d = new int[11]; // todos a 0 al instanciarlo
for(int i = 0; i < a.length; i++) {
int posicion = a[i] / 10; // Las notas van de 0 a 100
if(posicion >= 0 && posicion < d.length) //por seguridad
d[posicion]++;
}
EJERCICIO 4: Haz el fragmento de código que calcule el beneficio de
la tienda 3 durante el año 2019.
double total = 0.0;
int mes;
for( mes = 0; mes < 12; mes++ ) {
total += beneficios[3][mes];
}

EJERCICIO 5: Repite el ejemplo 44 pero ahora recorre la cadena a

invertir desde el final hasta el principio.
String s = "La casa de papel ha tenido mucho éxito";
String invertida = "";
for(int i = s.length() - 1; i >= 0; i--)
invertida += s.charAt(i);

2/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

System.out.println( invertida );

EJERCICIOS AUTO EVALUABLES

E1. TEST
1. ¿Qué es un bloque de sentencias? ¿Cómo se hacen en Java?

Es un grupo de sentencias. El cuerpo de una clase, de un método, o de una

sentencia de control son un bloque de sentencias. En Java se crean encerradas
entre dos llaves { s1; s2; ... }

2. ¿Cuál es la principal diferencia entre un bucle while y un do-

while?

En un while primero se evalúa la condición y es posible que al ser falsa no se

ejecute el bloque de sentencias. En un do-while, primero se ejecuta el bucle y
luego se evalúa la condición, así que la primera ejecución del bloque siempre se
produce.

3. ¿Qué precauciones hay que tener al acceder a un elemento de

un array unidimensional que almacena tipos primitivos? ¿Y si
almacena objetos o es multidimensional asimétrico?

Antes de acceder a un array que almacena tipos primitivos deberíamos tener la

seguridad de que el objeto está creado (array != null) y si accedemos al elemento
de la posición p, que p está entre 0 y array.length - 1.
Si el array almacena otros objetos y vamos a utilizar un dato o método suyo,
además de las precauciones del punto anterior, debemos tener la seguridad de
que el objeto existe (array[p] != null).

4. Escribe un bucle que muestre todos los múltiplos del número 3

desde el 3 hasta el 36.

3/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

Dos posibles soluciones con un bucle for:

for(int n = 3; n <= 36; n += 3) { for(int n = 3; n <= 36; n++ ) {

System.out.println( n ); if ( n % 3 == 0 )
} System.out.println( n );
}

5. Rellena la subrutina main() para que pregunte al usuario por un

entero, lo lea e indique si es par o impar (recuerda que un número
es par si al dividirlo por 2 su resto es 0, es decir, se puede dividir
por 2).
public static void main (String[] args) {
int n; // El nº leído por el usuario
Scanner teclado= new Scanner( System.in );
System.out.print("Teclee un entero: "); // Pedir el nº
n = teclado.nextInt(); // Leer el nº n
if (n % 2 == 0) // Comprobar si es par o impar
System.out.println("Es un número par.");
else
System.out.println("Es un número impar.");
}

6. Escribe un fragmento de código que genere dos números

aleatorios entre 1 y 10 (todos los valores con la misma
probabilidad, pero diferentes).

Se muestran 3 posibles soluciones

(1)
int x, y; // Los dos números enteros
do {
x = (int)(10 * Math.random() + 1);
y = (int)(10 * Math.random() + 1);
} while (x == y); // continuar hasta que sean distintos
System.out.println(x + " " + y);

(2)
int x, y; // Los dos números enteros

4/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

x = y = 0; // asegurar que el bucle se ejecuta

while ( x == y ) {
x = (int)(10 * Math.random() + 1);
y = (int)(10 * Math.random() + 1);
}
System.out.println(x + " " + y);

(3)
int x, y; // Los dos números enteros
x = (int)(10 * Math.random() + 1); // Elijo uno
do {
y = (int)(10 * Math.random() + 1);
} while (x == y);
System.out.println(x + " " + y);

7. Imagina que s1 y s2 son variables de tipo String, cuyos valores

se espera que contengan representación de números enteros de
tipo int. Escribe un fragmento de código que calcule e imprima su
suma o un mensaje de error si los valores no pueden convertirse de
forma correcta a enteros (Usa la sentencia try-catch).
try {
int n1, n2; // Los valores de s1 y s2 en enteros
int suma; // la suma de n1 y n2
n1 = Integer.parseInt(s1);
n2 = Integer.parseInt(s2);
suma = n1 + n2;
System.out.println("La suma es " + suma);
}
catch ( NumberFormatException e ) {
System.out.println("Error! No puedo convertir a enteros.");
}

8. Muestra la salida que genera esta subrutina main():

public static void main(String[] args) {
int N;
N = 1;
while (N <= 32) {
N = 2 * N;
System.out.println(N);

5/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

}
}

2
4
8
16
32
64

9. Muestra la salida producida por esta subrutina main():

public static void main(String[] args) {
int x, y;
x = 5;
y = 1;
while (x > 0) {
x = x - 1;
y = y * x;
System.out.println(y);
}
}

La mejor forma de averiguarlo es ejecutarlo, pero la idea es comprender la

lógica, así que vamos a hacer una traza:
valor de x | valor de y SALIDA
--------------|------------------------------------
5 | 1 [ Antes del bucle]
4 | 4 [ = 1*4 ] 4
3 | 12 [ = 4*3 ] 12
2 | 24 [ = 12*2 ] 24
1 | 24 [ = 24*1 ] 24
0 | 0 [ = 24*0 ] 0

10. ¿Qué salida genera el siguiente fragmento de código?

String nombre;
int i;
boolean comienza;
nombre = "Richard M. Nixon";
comienza = true;
for (i = 0; i < nombre.length(); i++) {

6/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

if (comienza)
System.out.println( nombre.charAt(i) );
if ( nombre.charAt(i) == ' ' )
comienza = true;
else
comienza = false;
}

Imprime las iniciales de las palabras de la frase.

R
M
N

11. Imagina que tienes un array llamado a cuyo tipo base es int
( int[] a; ). Escribe un trozo de código que cuente y muestre el
número de veces que aparece el número 42 en el array.

int c42;
c42 = 0;
int i;
for ( i = 0; i < array.length; i++ ) {
if ( array[i] == 42 ) {
c42++;
}
}
System.out.println("Hay " + c42 + " valores 42 en el array.")

12. Se define el rango de un array de números como el máximo

valor menos el mínimo valor. Escribe un trozo de código que le
calcule el rango del array de doubles llamado raceTimes (double[]
raceTimes).
Necesitamos tanto el máximo como el mínimo valor:
double max; // maximo valor
double min; // minimo valor
double rango; // el rango: max -min
int i; // for-loop variable
max = min = raceTimes[0]; // Ambos son el primer elemento

7/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

for ( i = 1; i < raceTimes.length; i++ ) {

if ( raceTimes[i] > max )
max = raceTimes[i];
if ( raceTimes[i] < min )
min = raceTimes[i];
}
rango = max – min;
System.out.println("El rango es " + rango);

E2. ¿Cuántas veces debes lanzar dos dados hasta que te salga
Snake eyes (ojos de serpiente, que son dos unos)? Haz un
programa que simule lanzamientos de dos dados y cuente el número
de tiradas hasta que te salgan dos unos.

Nota: en teoría, cada lanzamiento genera resultados de tipo

(1,1), (1,2), (1,3) .... (6,5), (6,6). Por tanto tienes 36 resultados
posibles, todos igual de probables, así que la probabilidad de
sacar (1,1) es 1/36. Por tanto, en teoría necesitas 36
lanzamientos. Pero la realidad, al ser aleatoria, no siempre
coincidirá.
public class U3EA02 {
public static void main(String[] args) {
int d1, d2; // Guarda el resultado de lanzar cada dado
int c = 0; // Cuenta el número de lanzamientos realizados
// No sabemos cuantas veces se repite el lanzamiento -> por condición
// Al menos una vez lanzamos los dados -> do-while
do {
d1 = (int)(Math.random() * 6) + 1;
d2 = (int)(Math.random() * 6) + 1;
c++;
System.out.println("Tirada " + c + " dado1=" + d1 + " dado2=" + d2);
while( d1 != 1 || d2 != 1 );
System.out.println("Snake Eyes en " + c + " tiradas.\n" );
} // fin main
}

E3. ¿Qué número entero entre 1 y 10000 tiene el mayor número

de divisores y cuántos tiene? Escribe un programa que encuentre la

8/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

solución y muestre los resultados.

Nota: es posible que haya varios con el mismo número de

divisores, así que tu programa solamente imprimirá uno de ellos.
La idea básica es ir probando cada entero de 1 hasta 10000 y
para cada uno, contar sus divisores. Recuerda el primer número
que encuentres que más tenga y cuántos tiene.
public class U3EA03 {
public static void main(String[] args) {
int mayorN; // Nº con mayor cantidad de divisores
int mayorD = 0; // Cuantos divisores tiene el que más tiene
// Sabemos cuantos nºs hay que probar? Si de 1 a 10000 -> un for: i= 1..n
for( int i = 1; i <= 10000; i++) {
// Para cada nº, contar cuantos menores o igual lo dividen: j= 1..i
int c = 0; // cuenta los divisores de cada i
for(int j = 1; j <= i; j++) {
if( i % j == 0 ) c++; // si j divide a i sube la cuenta
}
// Si es la mayor cuenta, actualizamos mayorN y mayorD
if( c > mayorD ) {
mayorD = c;
mayorN = i;
}
}
System.out.println( "El número entre 1 y 10000 con más divisores es " +
mayorN + " con " + mayorD + " divisores.\n" );
} // fin main
}

E4. Escribe un programa que lea y calcule expresiones simples

como por ejemplo 17 + 3 y 3,14159 * 4,7, es decir, del tipo "numero
<operación> número". El programa lee una expresión, calcula y
muestra el resultado y lee la siguiente expresión. El programa
acaba cuando el primer número leído sea cero.

Nota: Las expresiones son tecleadas por el usuario y siempre

deben seguir el formato <nº> <operación> <nº>. Las
operaciones pueden ser +, -, * y /.

9/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

import java.util.Scanner;

public class U3EA04 {

public static void main(String[] args) {
Scanner teclado = new Scanner( System.in );
String palabra;
double numIzq, numDer; // Números izquierda y derecha
char operador; // Operación a realizar
String resul; // Resultado de la operación
do {
numIzq = teclado.nextDouble();
operador = teclado.next().charAt(0); // No hay nextChar()
numDer = teclado.nextDouble();
switch( operador ) {
case '+': resul = Double.toString( numIzq + numDer );
break;
case '-': resul = Double.toString( numIzq - numDer );
break;
case '*': resul = Double.toString( numIzq * numDer );
break;
case '/': if( numDer == 0 ) // Evitamos el error
resul = "División por 0";
else
resul = Double.toString( numIzq / numDer );
break;
default: resul = "Operación desconocida \"" + operador + "\"";
}
System.out.println(" = " + resul);
} while( numIzq != 0 && numDer != 0 );
} // fin main
}

E5. Escribe un programa que lea una frase y la rompa en palabras.

Por ejemplo si lee la frase "Esto no es una buena idea", su salida
será:
Esto
no
es
una
buena
idea

a) Usando el método split() de la clase String.

10/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

b) Sin usar el método split().

import java.util.Scanner;

public class U3EA05 {

public static void main(String[] args) {
Scanner teclado = new Scanner( System.in );
System.out.print("Teclee una frase: ");
String frase = teclado.nextLine();
// Apartado a) usando split()
String[] a = frase.split( " " );
for(int i = 0; i < a.length; i++ ) {
System.out.println( a[i] );
}
// Apartado b) sin usar split()
// Localizar posición espacios en blanco/final y extraer palaba 1 a 1
int desde = -2, hasta = -1;
int longitud = frase.length();
while( longitud > 0 && hasta < longitud && desde < hasta ) {
desde = hasta + 1;
hasta = frase.indexOf( " ", desde + 1 );
if( hasta < 0 ) hasta = longitud;
System.out.println( frase.substring(desde, hasta) );
} // while
} // fin main
}

E6. Imagina que un fichero contiene información sobre las ventas

de una empresa en varias ciudades. Cada línea del fichero tiene
diferentes campos separados por el carácter dos puntos (:). Un
fichero de prueba tiene este formato: <ciudad>:<ventas>.
Imagina que tenemos este fichero llamado ventas.dat:
Valencia:1000,11
Alicante:dato no recibido
Castellón de la Plana: 2000,22

Escribe un programa que calcule el total de líneas en el fichero, el

número de ciudades de las que hay datos de ventas correctos (2
campos y un valor numérico en el seguundo campo) y el total de

11/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

ventas.

Nota: tendrás que llamar al programa redirigiendo desde la

línea de comandos la entrada estándar (C:\programa < fichero)
y leer una línea, romper los dos campos e intentar convertir el
valor numérico en un try-catch por si da error de conversión,
ignorando el dato en ese caso o totalizarlo en el caso contrario.
import java.util.Scanner;
import java.io.File;
public class U3EA06 {
public static void main(String[] args) throws Exception {
double totalVentas = 0; // Acumulado de ventas
int totalCiudades = 0; // Lineas correctas
int lineas = 0; // Total de lineas
File dir = new File("."); // Directorio actual
File venta = new File(dir, "ventas.dat");
//File venta = new File("C:\Users\1daw\java\u3\U03E6\\ventas.dat");
Scanner obj = new Scanner(venta);

while (obj.hasNextLine()){
String lineaTexto = obj.nextLine();
System.out.println(lineaTexto);
lineas++;
// separamos en campos: campos[0] es ciudad y campos[1] ventas
String[] campos = lineaTexto.split(":");

campos[1] = campos[1].replace(",", ".");

System.out.println(campos[0]);
System.out.println(campos[1]);
try {
double ventasCiudad = Double.parseDouble(campos[1] );
totalVentas += ventasCiudad;
totalCiudades++;
} catch(NumberFormatException e) {
// No hago nada, simplemente evito error
}
} // while
// Una vez procesado el fichero se muestran los datos
System.out.printf("Lineas: %d Datos: %d Total ventas: %.2f\n",
lineas, totalCiudades, totalVentas);
} // fin main
}

12/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

E7. Volver a realizar el programa que encuentra el número que tenga

mayor número de divisores (ejercicio E3), pero ahora vas a usar un
array de enteros auxiliar de tamaño 10000 y cada vez que cuentes los
divisores de un número, guardas la cantidad en el array. Después de
rellenar el array buscas el mayor valor que almacena, imagina que es
64. Cuando tengas el mayor, imprime todos los números que tengan 64
divisores.

Nota: Las posiciones del array se corresponden con cada

número entre 1 y 10000. El valor almacenado en cada posición
es el número de divisores que tiene cada número. Deberías
obtener esta salida:
Los números que tienen 64 divisores son: 7560, 9240

public class U3EA07 {

public static void main(String[] args) {
int mayorD = 0; // Cuantos divisores tiene el que más tiene
int[] divisores = new int[10000];
// Calculamos y almacenamos divisores de cada entero entre 1 y 10000
for( int i = 1; i < 10000; i++) {
// Para cada nº, contar cuantos menores o igual lo dividen: j= 1..i
int c = 0; // cuenta los divisores de cada i
for(int j= 1; j <= i; j++) {
if( i % j == 0 ) c++;
}
divisores[i-1] = c; // la posición i-1 tiene los divisores de i
}
// Buscar el mayor número
mayorD = divisores[0];
for(int i = 1; i < divisores.length; i++)
if( mayorD < divisores[i] ) mayorD = divisores[i];
// Mostrar los que más divisores tienen buscándolos en el array
System.out.print( "Los números que tienen " + mayorD +
" divisores son: " );
boolean primero = true; // controla poner bien las comas en la lista
for(int i = 0; i < divisores.length; i++)
if( mayorD == divisores[i] ) {
if( !primero ) System.out.print( " ," ); else primero= false;
System.out.print( i + 1 );
}

13/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

} // fin main
}

E8. En matemáticas, la letra griega sigma mayúscula (nuestra letra S),

se utiliza para indicar la operación suma de muchos elementos. Cada
elemento se representa mediante una expresión que puede incluir un
índice (normalmente se utiliza la letra i,j,k). El sigma tiene debajo
donde comienza el índice y arriba donde acaba. Por ejemplo:
10

∑i = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10
i=1

Es una forma de representar un bucle que hace una suma de

expresiones que contienen el índice (i en el ejemplo) y que se puede
interpretar como: para i comenzando a valer 1 y acabando en 10, se
hace la suma de i.

En matemáticas, para representar un bucle que calcule no la suma, si no

el producto de muchas expresiones, se utiliza la letra griega pi
mayúsculas (nuestra P) de la misma forma que sigma es suma. Ejemplo:
10

∏i = 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 * 10
i=1

Haz un programa que pregunte por un número double llamado x, que

representa un ángulo expresado en radianes y calcule su seno
utilizando los primeros 17 términos de la siguiente serie
(descomposición de Taylor):

Nota: debes buscar patrones cuyo comportamiento puedas

14/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

reproducir en un bucle. Observa por ejemplo, que las fracciones

tienen exponentes y denominadores impares, que a veces suman
y a veces restan...

import java.util.Scanner;

public class U3EA08 {

public static void main(String[] args) {
Scanner teclado = new Scanner( System.in );
double x; // En radianes

System.out.print( "Teclee radianes: " );

x = teclado.nextDouble();
double seno = x; // El primer término fuera del bucle
double signo = -1; // Comienza restando
double potencia = x; // Actualizo potencias no calculo desde 0
double factorial = 1; // Actualizo factorial no calculo desde 0
for(int i = 3; i < 34; i += 2) {
potencia *= x * x; // x^3 -> x^5 -> x^7 ...
factorial *= i * (i-1); // 1! * 3*2 -> 3! * 5*4 -> ...
seno += signo * potencia / factorial;
signo = -signo; // Para la próxima: + -> - -> + ...
}
System.out.printf("seno(%.2f)= %.6f\n", x, seno);
} // fin main
}

E9. Escribe un programa que pregunte por un número entero n y cree

tres matrices llamadas a, b y c (arrays bidimensionales de doubles) de
nxn, pida los datos de a y b al usuario, y en c guarde su suma. Cada
elemento i,j de C es:

Cij = Aij + Bij

import java.util.Scanner;

public class U3EA09 {

public static void main(String[] args) {
Scanner teclado = new Scanner( System.in );
int n; // filas y columnas de las matrices

15/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

double[][] ma, mb, mc; // matrices

do {
System.out.print( "Dimensiones (entero n > 0): " );
n = teclado.nextInt();
} while(n <= 0);
// Definir A
ma = new double[n][n];
System.out.println( "Defina A: " );
for(int f= 0; f < n; f++)
for(int c= 0; c < n; c++) {
System.out.print( "A[" + (f+1) + ", " + (c+1) + "]= " );
ma[f][c] = teclado.nextDouble();
}
// Definir B
mb = new double[n][n];
System.out.println( "Defina B: " );
for(int f= 0; f < n; f++)
for(int c= 0; c < n; c++) {
System.out.print( "B[" + (f+1) + ", " + (c+1) + "]= " );
mb[f][c] = teclado.nextDouble();
}
// Calcular C
mc = new double[n][n];
for(int f= 0; f < n; f++) {
System.out.print("|");
for(int c = 0; c < n; c++) {
mc[f][c] = ma[f][c] + mb[f][c];
System.out.printf( " %6.2f ", mc[f][c] );
}
System.out.println("|");
}
} // fin main
}

E10. Escribe un programa que pregunte por las dimensiones de una

matriz A (afilas, acolumnas) la creas y por las de una matriz B (bFilas,
bColumnas). Si se pueden multiplicar, crea la matriz C que almacene la
matriz producto de A x B, lee los datos de las matrices A y B y realiza
la multiplicación. Si no se pueden multiplicar, lo indicas. Ten en cuenta
que:
• El número de filas de B tiene que ser igual al número de

16/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

columnas de A para poder multiplicarse.

• La matriz producto (C = A x B) tendrá el número de filas de A y
el número de columnas de B.
• Cada elemento de C, llamado Cij = multiplicar la fila i de A por la
columna j de B.

Ejemplo: elemento 0,0 es multiplicar la fila (1, 2) por la columna (3, 4).
Debajo, el elemento (1,1)

import java.util.Scanner;

public class U3EA10 {

public static void main(String[] args) {
Scanner teclado = new Scanner( System.in );
int aF, aC, bF, bC; // filas y columnas de A y B
double[][] ma, mb, mc; // Las matrices A, B y C

// Definir A
do {
System.out.print( "Filas de matriz A (> 0): " );
aF = teclado.nextInt();
System.out.print( "Columnas de matriz A (> 0): " );
aC = teclado.nextInt();
} while(aF <= 0 || aC <= 0);
ma = new double[aF][aC];
// Definir B
do {
System.out.print( "Filas de matriz B (>0): " );
bF = teclado.nextInt();
System.out.print( "Columnas de matriz B (> 0): " );
bC = teclado.nextInt();
} while(bF <= 0 || bC <= 0);
mb = new double[bF][bC];

17/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

// Comprobar que se pueden multiplicar

if( aC == aF ) {
// Leer datos de las matrices A y B
System.out.println( "Defina A: " );
for(int f= 0; f < aF; f++)
for(int c = 0; c < aC; c++) {
System.out.print("A[" + (f+1) + ", " + (c+1) + "]= " );
ma[f][c] = teclado.nextDouble();
}
System.out.println( "Defina B: " );
for(int f= 0; f < bF; f++)
for(int c= 0; c < bC; c++) {
System.out.print( "B[" + (f+1) + ", " + (c+1) + "]= " );
mb[f][c] = teclado.nextDouble();
}
// Crear C, recorrer sus elementos para calcularlos
mc = new double[aF][bC];
for(int f= 0; f < aF; f++)
for(int c= 0; c < bC; c++)
for(int k = 0; k < aC; /* tb bF */ k++)
mc[f][c] += ma[f][k] * mb[k][c];
// Mostrar la solución
System.out.println("La matriz C= A x B:");
for(int f= 0; f < aF; f++) {
System.out.print(" |");
for(int c = 0; c < bC; c++)
System.out.printf( " %6.2f ", mc[f][c] );
System.out.println("|");
}
}
else {
System.out.println("A y B no se pueden multiplicar.");
}
} // fin main
}

E11: Pregunta por un número entero n (que es el número de alumnos de

una clase) y crea dos arrays de ese tamaño, uno llamado nombres que
almacene Strings y otro llamado notas que almacene números con
decimales. A continuación rellena los arrays con datos:
Número de alumnos: 10
Nombre del alumno 0: Manolo
Nota: 6,1

18/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

:
Nombre del alumno 4: Santi
Nota: 9,3
Ahora, ordena de mayor a menor nota los datos (nombres y notas):

Recorre todas las posiciones desde la primera a la última-1 y recuerda

en una variable i en qué posición estás. Suponiendo que la mayor nota
es la de la posición i, busca si hay otra mayor en las posiciones i+1, i+2 ..
hasta el final y si la encuentras recuerda donde está (digamos pmayor).
Si la posición del mayor es distinta de i, intercambia los datos de los
dos arrays (nombres[i] <-> nombres[pmayor]; y notas[i] <->
notas[pmayor]). Incrementas i y vuelves a repetir el proceso con la
siguiente.

(3) Si el mayor es otro, intercambio i y el mayor

6.1 9.3

(2) supongo mayor ← 6.1 y busco otro desde j =i+1 hasta n

(1) i =0
En un paso ya tengo ordenado el primer elemento, voy a por el segundo,
i <- i+1
(3) Si el mayor es otro, intercambio i y el mayor

9.3 5.2 8.7

(2) supongo mayor ← 5.2 y busco otro desde j =i+1 hasta n

(1) i =1
Si repites el proceso n-1 veces, para las posiciones de la 0 (el principio)

19/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

hasta la n-2 (la anterior al final) acabarás ordenando la lista de mayor

a menor. Cuando tengas los arrays ordenados los imprimes:

Santi (9,3) ... Manolo (6,1) ...

import java.util.Scanner;

public class U3EA11 {

public static void main(String[] args) {
Scanner teclado = new Scanner( System.in );
int n; // Nº alumnos
double[] notas; // Notas de los n alumnos
String[] nombres; // Nombres de los n alumnos

do {
System.out.print( "Número de alumnos (> 0): " );
n = teclado.nextInt();
} while( n <= 0 );
notas = new double[n];
nombres = new String[n];
// Leer datos
for(int i = 0; i < n; i++) {
teclado.nextLine(); // Quita retornos de nextInt/nextDouble
System.out.print( "Nombre de alumno " + (i+1) + ": " );
nombres[i] = teclado.nextLine();
System.out.print( "Nota de alumno " + (i+1) + ": " );
notas[i] = teclado.nextDouble();
}
// Ordenar arrays de nombres y notas por notas de mayor a menor
for(int i = 0; i < n-1; i++) {
double mayor = notas[i];
int pmayor= i;
for(int j= i+1; j < n; j++)
if( mayor < notas[j] ) {
pmayor = j;
mayor = notas[j];
}
// comprobar si hay otro mayor
if( pmayor != i ) { // hay otro más mayor
// Intercambiar notas
double temp = notas[i];
notas[i] = mayor; // mayor es igual a notas[pmayor]
notas[pmayor]= temp;
// Intercambiar nombres
String tempS = nombres[i];
nombres[i]= nombres[pmayor];
nombres[pmayor]= tempS;

20/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

}
}
// Mostrar arrays ordenados
for(int i= 0; i < n; i++) {
if ( i != 0 ) System.out.print(", "); // Pone ',' salvo 1a vez
System.out.print(nombres[i] + "(" + notas[i] + ")");
}
} // fin main
}

E12: Crea una tabla de 10x10 enteros y la rellenas con valores

aleatorios de 0 hasta 10. Encuentra el valor que más se repite e indica
el porcentaje de celdas de la tabla donde está almacenado con
respecto del total de la tabla. Da prioridad a la rapidez sobre el
consumo de memoria.
public class U3EA12 {
public static void main(String[] args) {
int[][] n = new int[10][10]; // tabla de enteros

// Rellenarla con nºs aleatorios enteros entre 0-10

for(int i = 0; i < n.length; i++)
for(int j = 0; j < n[0].length; j++)
n[i][j] = (int)(Math.random() * 11);
// Mostrarla
for(int i = 0; i < n.length; i++) {
System.out.print("\n |");
for(int j = 0; j < n[0].length; j++)
System.out.printf( " %2d ", n[i][j] );
System.out.println(" |");
}
// Buscar el valor que más se repite (la moda)
// ******* Primer enfoque *******
// Como son 11 posibles valores (0-10) creo array de 11 posiciones
// Cuento en cada posición las veces que aparece y luego busco el
// mayor acumulado
int[] apariciones = new int[11];
for(int i = 0; i < n.length; i++)
for(int j = 0; j < n[0].length; j++)
apariciones[ n[i][j] ]++;
//Busco el mayor
int mayor= 0;
for(int i = 1; i < apariciones.length; i++)
if( apariciones[mayor] < apariciones[i] ) mayor = i;

21/24
UNIDAD 3. Ejercicios de U03 Soluciones.

System.out.println( "El valor de moda es " + mayor + " con " +

apariciones[mayor] + " ocurrencias.");
// ******* Segundo enfoque *******
// Si hay muchos valores/desconocidos, copio datos si no puedo
// cambiarlos. Supongo que el primero es el mayor, lo cuento
// y uso el valor para marcar los ya estudiados
// Repito hasta que todos los valores queden a ese
int i, j;
int[][] copia = new int[n.length][];
for(i= 0; i < n.length; i++ )
copia[i] = n[i].clone(); // System.arrayClone(), Arrays.copyOf()
// Supongo que la moda es el primero y lo cuento
int primeraModa = copia[0][0], posibleModa; // me sirve de marca
int primeraOcu = 0, posibleOcu = 0;
for(i = 0; i < copia.length; i++)
for(j = 0; j < copia[0].length; j++)
if( copia[i][j] == primeraModa) primeraOcu++;
posibleModa = primeraModa;
posibleOcu = primeraOcu;
// Cuento el resto mientras haya diferentes a primeraModa
boolean continuar;
do {
continuar = false; // Cuando haya contado todos sera false
// Localizar un nuevo valor distinto de primeraModa
i = j = 0;
int fn = -1, cn = -1; // fila y columna de un nuevo valor
while ( i < copia.length && fn < 0 && cn < 0 ) {
j = 0;
while( j < copia[0].length && fn < 0 && cn < 0 ) {
if ( copia[i][j] != primeraModa) {
fn = i;
cn = j;
}
else j++;
}
if( fn < 0 && cn < 0 ) i++;
}
if ( fn >= 0 && cn >= 0 ) { // Nuevo valor Localizado en fn,cn
continuar= true;
// Un nuevo valor encontrado. Contarlo y anularlo.
int nuevaModa = copia[i][j];
int nuevaOcu = 0;
while ( i < copia.length ) {
while( j < copia[0].length ) {
if(copia[i][j] == nuevaModa) {
copia[i][j] = primeraModa; // anular
nuevaOcu++; // contar
}

22/24
 UNIDAD 3. Ejercicios de U03 Soluciones.

j++;
}
i++;
j = 0;
}
// Si hay más ocurrencias que la posible, se cambia
if( nuevaOcu > posibleOcu ) {
posibleOcu = nuevaOcu;
posibleModa = nuevaModa;
}
}
} while( continuar );
System.out.println( "El valor de moda es " + posibleModa + " con " +
posibleOcu + " ocurrencias.");
} // fin main
}

E13: Crea un array de 10 enteros y lo rellenas con valores aleatorios

entre 0 y 10. Busca el número 5 indicando la posición donde se
encuentre o una posición imposible si no lo encuentra y para ello debes
adaptar el método de búsqueda dicotómico expresado en el siguiente
algoritmo en pseudocódigo.
ALGORITMO DE BÚSQUEDA DICOTÓMICA
PREREQUISITOS: a debe estar ordenado de menor a mayor
ENTRADAS:
• ARRAY a
• elemento a buscar e
INICIO
Definir primero, ultimo, mitad como enteros;
definir buscando como logico;
buscando <- verdadero;
primero <- primera posición donde buscar en el array;
ultimo <- última posición donde buscar en el array;
mientras primero < ultimo Y buscando hacer
mitad <- (primero + ultimo) / 2;
si e = a[mitad] entonces
buscando <- FALSO:
sino
si e < a[mitad] entonces
ulltimo <- mitad – 1;
sino

23/24
UNIDAD 3. Ejercicios de U03 Soluciones.

si e > a[mitad] entonces

primero <- mitad + 1;
finsi
finsi
finsi
finmientras
si buscando entonces
escribir e encontrado;
sino
escribir e no encontrado;
finsi
FIN

package p1;

import java.util.Arrays;

public class U03EA13 {

public static void main(String[] args) {
int[] a = new int[10];
for(int i = 0; i < 10; i++) {
a[i] = (int)(Math.random() * 11);
}
Arrays.sort(a);
int e = 5, primero = 0, ultimo= a.length - 1, mitad;
// Cambio buscando por posición donde se encuentra
int posicion = -1; // -1 equivale a no encontrado
while( primero <= ultimo && posicion < 0) {
mitad = (primero + ultimo) / 2;
if( e == a[mitad] )
posicion = mitad;
else if( e < a[mitad] )
ultimo = mitad - 1;
else if( e > a[mitad] )
primero = mitad + 1;
}
System.out.println("El array a=" + Arrays.toString(a) );
if(posicion < 0)
System.out.println("5 no encontrado");
else
System.out.println("5 encontrado en pos " + posicion);
}
}

24/24