Afianza tus conocimientos de programaci ón mediante la resolución de ejercicios

Ejercicios de Programación en Java
Condicionales, Bucles, Tablas y Funciones
F.M. Pérez Montes

Esta obra está publicada bajo una licencia: Creative Commons Reconocimiento-No Comercial-Sin Obra Derivada 3.0 España, que le permite copiar, distribuir y comunicar públicamente la obra, siempre y cuando reconozca el crédito del autor, lo haga sin fines comerciales y no altere, transforme o genere una obra derivada a partir de ésta. Dispone del texto legal completo en la siguiente dirección: http://creativecommons.org/licenses/by-nc-nd/3.0/es/ ©2011, Francisco Manuel Pérez Montes. Algunos derechos reservados. Edita Asoc. Por la Innovación Educativa Eduinnova. Esta obra se encuentra disponile en: http://www.eduinnova.es/monografias2011/ene2011/java.pdf Depósito legal: SE 1211-2011. ISBN: 978-84-614-7595-7.

A mi hija Claudia,  la solución a todos los problemas.

por sus innumerables correcciones y por la clase Entrada.AGRADECIMIENTOS A todos los que han hecho posible este libro. En especial a mi amigo y compañero: Alfonso Jiménez. .

ÍNDICE

Prólogo ............................................... Página Introducción .......................................... Página Boletín 1 (Variables y condicionales) ................. Página

1 4 6

Boletín 2 (Condicionales y bucles) .................... Página 35 Boletín 3 (Bucles anidados) ........................... Página 62 Boletín 4 (Tablas) .................................... Página 69 Boletín 5 (Tablas n-dimensionales) .................... Página 96 Boletín 6 (Funciones) ................................. Página 115 Apéndice I (Boletines completos) ...................... Página 192 Apéndice II (Clase Entrada) ........................... Página 206

I

PRÓLOGO
El libro Ejercicios de Programación en Java: Condicionales, Bucles, Tablas y Funciones nace como fruto de años de docencia en materias relacionadas: Algorítmica, Programación, Lenguaje C y Java, entre otros. Con el paso del tiempo he constatado que aprender un lenguaje de programación es relativamente sencillo y sobre este tema existen muchos y muy buenos textos. Pero aprender a programar es algo totalmente distinto, que necesita de un mayor esfuerzo y abordar el problema desde otra perspectiva. Siempre utilizo la metáfora del pianista para explicar el tándem programar/lenguaje de programación: saber tocar las notas de un piano es relativamente fácil, tan solo debemos anotar en cada una de las teclas a qué nota musical corresponde. Esto sería similar a conocer un lenguaje de programación. Es muy sencillo utilizar un entender la mecánica de un while. Volviendo al piano: una vez que dominamos la relación tecla/nota, un pianista debe if o

aprender muchas otras cosas para que aquello que está tocando suene bien; esto sería saber tocar el piano. Para saber programar, no basta saber cómo funciona una instrucción sino saber
Ejercicios de Programación en Java

1

utilizarla conjuntamente con otras, en el orden y la forma adecuadas para que la aplicación que estamos creando suene bien. Esta obra no es un libro para aprender java ni sus numerosas bibliotecas, es un libro que por medio de ejercicios resueltos, desde cero, y con la práctica facilita la asimilación de las técnicas de programación. Para aprender a programar la mejor forma es desvincular la lógica de la aplicación (cómo hacerlo) del lenguaje utilizado para implementarlo. Dicho en otras palabras: lo mejor es utilizar seudocódigo (un lenguaje teórico de alto nivel) donde no tengamos que preocuparnos por las particularidades del lenguaje de programación, ni por la rigidez de su sintaxis. El inconveniente de utilizar seudocódigo es que el lector no tiene nada tangible, nada con lo que se pueda comprobar el buen funcionamiento de la aplicación; por este motivo se ha decidido utilizar Java. Esta elección se justifica frente a otras alternativas, como el lenguaje C, que también es muy didáctico, simplemente por el hecho de que con Java podemos abstraernos un poco más, al ser un lenguaje de más alto nivel. También hay que decir que en la medida de lo posible no profundizaremos en las bibliotecas del lenguaje; en otras ocasiones esto será totalmente imposible de llevar a la práctica y hemos de trabajar con los detalles. Para finalizar, desearía comentar que el libro se estructura como un conjunto de boletines de ejercicios que se resuelven de la forma más didáctica posible. Un programador

Ejercicios de Programación en Java

2

experto seguramente encontrará soluciones mucho más elegantes y eficientes. Aquí nuestro principal objetivo es que el lector entienda qué está haciendo y por qué lo hace. La dificultad de los boletines crece gradualmente y en cada boletín se trata un tema distinto. Una vez resueltos los ejercicios de un boletín podremos disponer de ellos para utilizarlos en posteriores boletines. La resolución de los ejercicios no es única, y en ocasiones merece la pena ver otro enfoque distinto. Es por esto por lo que en algunos casos se han incluido varias soluciones. Si el lector se enfrenta a la tarea de aprender a programar, este libro, junto con las clases que pueda recibir en una facultad, escuela técnica o ciclo formativo de grado superior, serán una ayuda eficaz para llevar a cabo su objetivo. Esta tarea debe tomarse sin prisas, entendiendo los detalles sutiles y dedicando mucho tiempo a la práctica.

Sevilla, octubre de 2010 Francisco M. Pérez Montes

Ejercicios de Programación en Java

3

...INTRODUCCIÓN Este libro está compuesto como una colección de boletines de ejercicios (se encuentran disponibles en el Apéndice I)... de la siguiente forma: Boletín 1.. dejando de lado la eficiencia. utilizando distintos enfoques. La resolución de los ejercicios de programación.... Condicionales y bucles Boletín 3. Tablas Boletín 5.. Tablas n-dimensionales Boletín 6.. son el complemento ideal para las clases de programación impartidas en una facultas... Variables y condicionales Boletín 2.... En cada boletín se resuelven ejercicios con una temática común... Ejercicios de Programación en Java 4 ..... se incluye más de una solución por ejercicio. Bucles anidados Boletín 4. Cuando existen distintas soluciones...... escuela técnica o ciclo formativo de grado superior.. aquí se plantea la más didáctica y fácil de entender.. Funciones Los ejercicios no tienen solución única..

Por todo esto. Las funciones que proporciona la clase Entrada son: Entrada.cadena() Entrada. que permite realizar de forma transparente la entrada por teclado.caracter() Lee un número entero por teclado y lo devuelve Lee un número real por teclado y lo devuelve Lee una cadena de caracteres y la devuelve Lee un solo carácter por teclado y lo devuelve Ejercicios de Programación en Java 5 . lo que plantea el problema de empezar a explicar código y funciones que se escapan al programador novel. Aprender a utilizarla es sencillo y proporciona una herramienta cómoda y fiable para dejar de preocuparnos por la entrada de datos. Algo similar ocurre en las asignaturas de programación.Otro aspecto importante es la entrada por teclado. algo primordial para poder introducir datos y probar nuestros programas. En un principio el alumno no debe tener los conocimientos necesarios para escribir el código que le proporcione dicha entrada.real() Entrada. La clase Entrada se encuentra en el Apéndice II. se ha diseñado la clase Entrada.entero() Entrada.

Si no existen.println("No existen soluciones reales").out.d.out. // coeficientes ax^2+bx+c=0 double x1. else{ // queda confirmar que a sea distinto de 0. y muestre sus soluciones reales.out. c=Entrada.out.println("Introduzca primer coeficiente (a):"). public class Main { public static void main(String[] args) { double a.b. // soluciones y determinante System. a=Entrada. // calculamos el determinante d=((b*b)-4*a*c). b=Entrada. if(d<0) System. System.x2.entero(). debe indicarlo. Pedir los coeficientes de una ecuación se 2º grado. System.c. package bol01ej01.println("Introduzca segundo coeficiente: (b):").println("Introduzca tercer coeficiente: (c):").entero().Variables y condicionales 1. Boletín 1 Ejercicios de Programación en Java 6 .entero().

PI*(r*r).println("El área de una circunferencia de radio " + r+ " es: " + a). } } 3.real(). Pedir el radio de una circunferencia y calcular su longitud. x2=(-b-Math.println("Solución: " + x2).out. A=PI*r^2. public class Main { public static void main(String[] args) { double a.r. } } } 2. public class Main { Ejercicios de Programación en Java 7 . package bol01ej02.out.print("Introduce el radio de un circulo: "). // para elevar al cuadrado otra opción es: Math. System. r=Entrada.// si a=0 nos encontramos una división por cero. Pedir el radio de un círculo y calcular su área. 2) System. a=Math.sqrt(d))/(2*a).println("Solución: " + x1).out. x1=(-b+Math. package bol01ej03.out. // área y radio System.pow (r.sqrt(d))/(2*a). System.

l=2*Math. r=Entrada. else System.entero().print("Introduce el radio de una circunferencia: ").out.n2. Pedir dos números y decir si son iguales o no. public class Main { public static void main(String[] args) { int n1.out. } } 4. if(n1==n2) System.out.r.out. System. package bol01ej04. System. n2=Entrada.println("Son iguales"). // longitud y radio System. n1=Entrada.println("No son iguales").println("La longitud de una circunferencia de radio " + r+ " es: " + l).PI*r.public static void main(String[] args) { double l.out.entero(). System.real().print("Introduce un número: ").out. } } Ejercicios de Programación en Java 8 .print("Introduce otro número: ").

System. package bol01ej06.print("Introduce un número: "). n2=Entrada.entero().print("Introduce otro número: ").println("Positivo"). else // suponemos que el 0 es positivo.out.n2.print("Introduce un número: "). System. num=Entrada. Pedir un número e indicar si es positivo o negativo. if( num < 0) System.out.entero(). public class Main { public static void main(String[] args) { int n1. System.out. } } 6.5. public class Main { public static void main(String[] args) { int num. package bol01ej05. Pedir dos números y decir si uno es múltiplo del otro.println("Negativo"). Ejercicios de Programación en Java 9 . n1=Entrada.entero(). System.out.out.

package bol01ej07.println("No son múltiplos").out.} } if(n1%n2==0) System. 7. else System.out.print("Introduce otro número: ").entero(). // si ambos números son iguales diría que n2 es mayor que n1 if(n1>n2) System.println(n1 + " es mayor que " + n2).out. n2=Entrada. else System.entero(). System.print("Introduce un número: "). n1=Entrada. public class Main { public static void main(String[] args) { int n1.out.out. System.println("Son múltiplos").out.n2.println(n2 + " es mayor que " + n1). } } Ejercicios de Programación en Java 10 . Pedir dos números y decir cual es el mayor.

n1=Entrada.entero().out.println("Son iguales").print("Introduce un número: "). else { if(n1>n2) System.println(n2 + " es mayor que " + n1).println(n1 + " es mayor que " + n2). if(n1==n2) System. public class Main { public static void main(String[] args) { int n1.out.out. else System. package bol01ej09. Pedir dos números y decir cual es el mayor o si son iguales. System.print("Introduce otro número: ").out. Ejercicios de Programación en Java 11 .n2. package bol01ej08. System.8. public class Main { public static void main(String[] args) { int n1.out. n2=Entrada.n2.entero(). } } } 9. Pedir dos números y mostrarlos ordenados de mayor a menor.

print("Introduce otro número: ").out. System.println(a+".out. System.entero(). "+c).println(n2 + " y " + n1).print("Introduzca primer número: ").out.System.entero().entero().b.println(n1 + " y " + n2).print("Introduce un número: "). if(n1>n2) System. "+b+". else System. n1=Entrada. package bol01ej10.print("Introduzca tercer número: ").out. System.println( a+". c=Entrada. else{ if(a>c && c>b) System.out. b=Entrada. System.out.c. } } 10. "+c+". "+b). if(a>b && b>c) System. Pedir tres números y mostrarlos ordenados de mayor a menor. Ejercicios de Programación en Java 12 .entero(). public class Main { public static void main(String[] args) { int a.print("Introduzca segundo número: "). a=Entrada.out.entero(). n2=Entrada.out.out.

out. package bol01ej11. public class Main { public static void main(String[] args) { int num. Pedir un número entre 0 y 9. "+a). "+c+".println("tiene 1 cifra"). Ejercicios de Programación en Java 13 .println(c+".println(b+".999: ").out. "+a+". num=Entrada.out. "+b). else{ if(c>b && b>a) System.out. "+a+". "+a).print("Introduzca un número entre 0 y 99. else{ if(b>c && c>a) System. if(num<10) System. } } } } } } } 11.out.else{ if(b>a && a>c) System. else{ if(c>a && a>b) System.println(c+".entero(). "+c). System.999 y decir cuantas cifras tiene.out.println(b+". "+b+".

else{ if(num<100000) System.999 y mostrarlo con las cifras al revés.out.println("tiene 3 cifras"). u.out.println("tiene 2 cifras"). um:(unidades de millar) // c: (centenas). Pedir un número entre 0 y 9.out. } } } } } } 12.println("tiene 5 cifras"). // 9 9 . 9 9 9 a cada guarismo lo llamaremos: //dm um c d u: dm (decenas de millar). u: (unidades) Ejercicios de Programación en Java 14 . d: (decenas). c.out. else{ if(num<1000) System. int dm. else{ if(num<10000) System. d. public class Main { public static void main(String[] args) { int num.else{ if(num<100) System.println("tiene 4 cifras"). um. package bol01ej12.

System.999: ").println (num).print("Introduzca un número entre 0 y 99. // lo imprimimos al revés: System. num = num / 10. // unidad u = num % 10.out.System. Ejercicios de Programación en Java 15 . Pedir un número entre 0 y 9. decir si es capicúa. // centenas c = num % 10. // unidades de millar um = num % 10. // otra forma de hacerlo es num = 10000*u + 1000*d + 100*c + 10*um + dm. } } 13. num=Entrada.out. // decenas d = num % 10.999. num = num / 10.entero(). package bol01ej13.println (u + " " + d + " " + c + " " + um + " " + dm). num = num / 10. num = num / 10. // decenas de millar dm = num.out.

// unidades de millar um = num % 10. int dm.public class Main { public static void main(String[] args) { int num. num = num / 10. // centenas c = num % 10. c.999: "). // unidad u = num % 10. d. num = num / 10. 9 9 9 a cada guarismo lo llamaremos: //dm um c d u: dm (decenas de millar).print("Introduzca un número entre 0 y 99. u. d: (decenas). um:(unidades de millar) // c: (centenas). num=Entrada. // decenas de millar dm = num. // decenas d = num % 10.out. // 9 9 . num = num / 10. num = num / 10. u: (unidades) System. um. // el número será capicúa si las cifras son iguales dos a dos por los extremos // las centenas no las tenemos en cuenta Ejercicios de Programación en Java 16 .entero().

pero nuestro código lo identifica como NO capicúa. num=Entrada.if (dm == u && um == d) System.entero(). } } package bol01ej13. c. // hay que tener en cuenta que en este ejercicio el número 121 es similar al 00121 y // resulta que 121 es capicúa. d: (decenas). Ejercicios de Programación en Java 17 . // 9 9 . num = num / 10.println ("el número NO es capicúa"). // La idea es no tener en cuenta los ceros por la derecha. boolean capicua = false. // unidad u = num % 10. u. // suponemos que el número no es capicúa. d. u: (unidades) // En esta versión haremos que el número 121 ó el 33 sea visto como capicúa.println ("el número es capicúa"). No tendremos en cuenta este pequeño error.999: ").print("Introduzca un número entre 0 y 99. Ya // que trabajamos con el 00121. else System.out. public class Main { public static void main(String[] args) { int num.out.out. int dm. um. System. um:(unidades de millar) // c: (centenas). 9 9 9 a cada guarismo lo llamaremos: //dm um c d u: dm (decenas de millar).

// decenas d = num % 10. um. // centenas c = num % 10. d. 0. c. u) if (dm == 0 && um == u && c == d) capicua = true. c. u) if (dm == 0 && um == 0 && c == 0 && d == u) capicua = true. num = num / 10.println ("el número es capicúa"). u) if (dm == u && um == d) capicua = true. d. //si el número tiene 5 cifras (dm. num = num / 10. Ejercicios de Programación en Java 18 .out. c. d. 0. um. //si el número tiene 3 cifras (0. // se entiende que un número de una cifra no es capicúa if (capicua) System. //si el número tiene 4 cifras (0. // unidades de millar um = num % 10. 0. //si el número tiene 2 cifras (0. num = num / 10. u) if (dm == 0 && um==0 && c == u) capicua = true. // decenas de millar dm = num. d.

public class Main { public static void main(String[] args) { int nota.. else if(nota==5) System.out. System. Suficiente.out. else Ejercicios de Programación en Java 19 . // tanto los if's como los else's encierran a una sola instrucción // y no es necesario utilizar llaves { } if(nota>=0 && nota<5) System.println("INSUFICIENTE"). else if(nota==7 || nota==8) System. Pedir una nota de 0 a 10 y mostrarla de la forma: Insuficiente..println("BIEN").println("SUFICIENTE"). Bien.out.entero(). package bol01ej14.print("Introduzca una nota: ").println ("el número NO es capicúa"). nota=Entrada.else } } System.out. else if(nota==6) System.out.out.println("NOTABLE"). 14.

println("INSUFICIENTE").out.println("BIEN"). } } package bol01ej14b. break.println("SUFICIENTE").println("NOTABLE"). System. nota=Entrada. break.out. case 7: case 8: System. case 5: System. switch(nota){ case 0: case 1: case 2: case 3: case 4: System. break.entero().if(nota==9 || nota==10 ) System.out. case 9: Ejercicios de Programación en Java 20 .out.println("SOBRESALIENTE"). case 6: System.out.print("Introduzca una nota: "). public class Main { public static void main(String[] args) { int nota.out. break.

año.entero().entero(). } } } 15.print("Introduzca mes: "). // // // // para que una fecha sea correcta se tiene que cumplir día en el rango 1.out..print("Introduzca día: ").12 año cualquiera distinto del 0 System. public class Main { public static void main(String[] args) { int dia.out.println("ERROR").out.case 10: System. break. System.out.mes.entero(). mes y año de una fecha e indicar si la fecha es correcta. dia=Entrada.out. if (dia >= 1 && dia <=30) if (mes >= 1 && mes <= 12) Ejercicios de Programación en Java 21 . package bol01ej15. default: System.println("SOBRESALIENTE"). System. Suponiendo todos los meses de 30 días. año=Entrada.print("Introduzca año: "). break.30 mes en el rango 1.. Pedir el día. mes=Entrada.

out.out. Con meses de 28.out.println("Fecha incorrecta").out. else System. mes=Entrada.out.println ("Fecha correcta"). Sin años bisiestos. else else } } System.print("Introduzca mes: "). // el único año que no existe es el 0 if(año==0) System. dia=Entrada. 30 y 31 días.entero().println("Día incorrecto"). mes y año de una fecha e indicar si la fecha es correcta. System.out.entero(). Pedir el día. package bol01ej16. else{ if(mes==2 && (dia>=1 && dia<=28)) Ejercicios de Programación en Java 22 . año=Entrada. 16.out.año.mes.print("Introduzca año: "). System.print("Introduzca día: ").out.entero(). System. public class Main { public static void main(String[] args) { int dia.println ("Año incorrecto"). System.println("Mes incorrecto").if (año != 0) System.

dia=Entrada. año=Entrada.entero().out.out.out. } } } } } package bol01ej16.println("Fecha incorrecta").out.entero().print("Introduzca año: ").año.mes.print("Introduzca día: ").print("Introduzca mes: ").entero(). public class Main { public static void main(String[] args) { int dia. boolean fecha_correcta=true. else System. else{ if( (mes==1 || mes==3 || mes==5 || mes==7 || mes==8 || mes==10 || mes==12) && (dia>=1 && dia<=31)) System. else{ if((mes==4 || mes==6 || mes==9 || mes==11) && (dia>=1 && dia<=30)) System.println(dia + "/" + mes + "/" + año+": Fecha correcta"). System.out.println(dia + "/" + mes + "/" + año+": Fecha correcta"). mes=Entrada.System. System. System.out.out.println(dia + "/" + mes + "/" + año+": Fecha correcta"). int dias_del_mes. Ejercicios de Programación en Java 23 .

out. if(mes==1 || mes==3 || mes==5 || mes==7 || mes==8 || mes==10 || mes==12) dias_del_mes = 31.31 no tiene sentido fecha_correcta = false. public class Main { Ejercicios de Programación en Java 24 . package bol01ej17. else System. if (fecha_correcta) System.println("Fecha incorrecta"). if (dia<1 || dia >31) // un día fuera del rango 1. if (mes<1 || mes >12) // un mes fuera del rango 1. if(mes==4 || mes==6 || mes==9 || mes==11) dias_del_mes = 30. Pedir el día. if(mes==2 ) dias_del_mes = 28. } } 17. mes y año de una fecha correcta y mostrar la fecha del día siguiente.12 no tiene sentido fecha_correcta = false..println(dia + "/" + mes + "/" + año+": Fecha correcta").out. // si se utiliza un mes fuera del rango 1. if(año==0) // el único año que no existe es el 0 fecha_correcta = false...12 // supondremos que los días del mes son 0. if (dia > dias_del_mes) fecha_correcta = false.dias_del_mes = 0. suponer que todos los meses tienen 30 días.

// suponemos que la fecha introducida es correcta // incrementamos el día dia ++. mes ++.año. lo reiniciamos a 1 e incrementamos el mes if (dia >= 30) { dia = 1. } } // habría que tener en cuenta que el año pasa del -1 al +1 // en este código pasaríamos del año -1 al 0 (que nunca existió) // para corregirlo: if (año == 0) año = 1. año ++. System.print("Introduzca día: ").mes. año=Entrada. System.entero().out. // si el día supera 30. dia=Entrada.out.out.public static void main(String[] args) { int dia.entero(). lo reiniciamos a 1 e incrementamos el año if (mes >= 12) { mes = 1. mes=Entrada.print("Introduzca mes: ").entero().print("Introduzca año: "). Ejercicios de Programación en Java 25 . System. // si el mes supera 12.

print("Introduzca día: "). if(mes==4 || mes==6 || mes==9 || mes==11) dias_del_mes = 30. if(mes==1 || mes==3 || mes==5 || mes==7 || mes==8 || mes==10 || mes==12) dias_del_mes = 31.print("Introduzca mes: ").out. public class Main { public static void main(String[] args) { int dia. System. dia=Entrada.out. System.} } System.println (dia + "/"+ mes + "/" + año). // incrementamos el día dia ++.out. int dias_del_mes=0.print("Introduzca año: "). // suponemos que la fecha introducida es correcta if(mes==2 ) dias_del_mes = 28.año. 18. Ejercicios de Programación en Java 26 . package bol01ej18. Ídem que el ej.out. mes=Entrada.mes. 17. suponiendo que cada mes tiene un número distinto de días (suponer que febrero tiene siempre 28 días). año=Entrada.entero(). // guardaremos el número de días que tiene el mes System.entero().entero().

out. } } // habría que tener en cuenta que el año pasa del -1 al +1 // en este código pasaríamos del año -1 al 0 (que nunca existió) // para corregirlo: if (año == 0) año = 1. package bol01ej19. System. Pedir dos fechas y mostrar el número de días que hay de diferencia.println (dia + "/"+ mes + "/" + año). // si el mes supera 12. Suponiendo todos los meses de 30 días. // lo reiniciamos a 1 e incrementamos el mes if (dia >= dias_del_mes) { dia = 1. año ++. } } 19. lo reiniciamos a 1 e incrementamos el año if (mes >= 12) { mes = 1. mes ++. public class Main { Ejercicios de Programación en Java 27 .// si el día supera el número de días del mes.

package bol01ej20. y mostrar la hora en el segundo siguiente.out. mes2=Entrada. dia1=Entrada.out.print("Introduzca mes: ").entero(). System.println ("Días de diferencia: " + total_dias). System.out.entero().print("Introduzca año: ").año1.public static void main(String[] args) { int dia1. System.println ("Fecha 1:").print("Introduzca año: ").entero(). año1=Entrada. System.entero(). System. Pedir una hora de la forma hora.mes1.entero(). System.print("Introduzca día: ").out. int dia2. 20.out.print("Introduzca mes: ").mes2. año2=Entrada.out.out. } } System.año2.print("Introduzca día: "). System. int total_dias.out.out. // suponemos que las fecha introducidas son correctas // convertimos las dos fechas a días y calculamos la diferencia total_dias = dia2-dia1 + 30*(mes2-mes1)+365*(año2-año1).entero(). minutos y segundos. Ejercicios de Programación en Java 28 . mes1=Entrada. dia2=Entrada.println ("Fecha 2:"). System.

out. la reiniciamos a 0 if (h>=24) h=0. s=Entrada. System.public class Main { public static void main(String[] args) { int h.out. h=Entrada. m=Entrada. los reiniciamos a 0 e incrementamos los minutos if (s >= 60) { s = 0. h ++. // si los segundos superan 59. minutos y segundos System. // si los minutos superan 59.println ("Fecha: "+ h + ":"+ m + ":" + s).entero().print("Introduzca minutos: ").out.entero(). System.print("Introduzca segundos: ").out. } } System. // hora. m ++. // si la hora supera 23.m. } } Ejercicios de Programación en Java 29 . los reiniciamos a 0 e incrementamos la hora if (m >= 60) { m = 0.s.print("Introduzca hora: ").entero(). // suponemos que la hora introducida es correcta // incrementamos los segundos s ++.

out. Ejercicios de Programación en Java 30 .println("CERO").21. case 5: System. case 2: System. case 1: System.out. break.println("CINCO").println("DOS"). tres. y mostrar dicha nota de la forma: cero.println("TRES"). Pedir una nota numérica entera entre 0 y 10.out. break. switch(num){ case 0: System. System.print("Introduzca una nota numérica entre 0 y 10: "). break. public class Main { public static void main(String[] args) { int num.out. case 3: System.. uno.entero(). num=Entrada.println("UNO"). break.println("CUATRO")..out. break.out. package bol01ej21. break. case 4: System. dos.out.

Ejercicios de Programación en Java 31 . break. case 7: System. } } } 22. para 56 mostrar: cincuenta y seis. case 8: System.println("DIEZ"). // es una forma de hacerlo bastante burda. Por ejemplo. break.println("OCHO"). public class Main { public static void main(String[] args) { int num. int unidades. break. break.out.out. break.println("NUEVE"). decenas.out. Pedir un número de 0 a 99 y mostrarlo escrito. // esta versión muesrta 11 como diez y uno.out. package bol01ej22.out.case 6: System. case 10: System.println("SIETE").println("SEIS"). case 9: System.

.out. num=Entrada.entero().out. break. case 4: System. case 3: System. unidades = num % 10. // y otro condicional para mostrar "y" System. decenas = num / 10.. break. case 2: System.out. switch(decenas){ case 0: System.print("cuarenta"). break.out. case 1: System.print("cincuenta").out.out. break..// se puede poner algunos condicionales para los números especiales: 11. break. Ejercicios de Programación en Java 32 .print("sesenta"). case 5: System. case 6: System.out.print("veinte").print("Introduzca un número (0 a 99): ").print("diez").print("").out.12. break.print("treinta").

out. switch(unidades){ case 0: System.out. break. break.print("ochenta").out. case 8: System. case 9: System.println("uno"). break. break. case 7: System.out.print("noventa"). break.break.out.println("cuatro").println("tres"). case 4: System.out.out.print("setenta"). } System.print (" y ").println(""). break. break. case 2: System. case 1: System.out.out. Ejercicios de Programación en Java 33 . case 3: System.println("dos").

case 5: System.out. case 9: System. } } } Ejercicios de Programación en Java 34 .out. break.println("nueva"). case 8: System. break. break. break.out.println("ocho").println("siete"). case 7: System. case 6: System.println("cinco"). break.break.out.out.println("seis").

System. package bol02ej01.Condicionales y bucles 1.print("Introduzca otro número: ").cuadrado. num=Entrada. // num guardará el número que leamos // y cuadrado guardará el cuadrado de num System.entero(). public class Main { public static void main(String[] args) { int num. System. // volvemos a leer num } } } Boletín 2 Ejercicios de Programación en Java 35 . num=Entrada.print("Introduzca número: "). repetir el proceso hasta que se introduzca un número negativo. while(num>=0){ // repetimos el proceso mientras el número leído no sea negativo cuadrado=num*num.println(num+ "² es igual a "+ cuadrado). Leer un número y mostrar su cuadrado.out.entero().out.out.

public class Main { public static void main(String[] args) { int num. while(num!=0) // mientras num sea distinto de 0 { if(num>0) // mayor que cero: positivo System.entero(). num=Entrada.entero().println("Positivo"). } // al salir del mientras tenemos la certeza que num es 0 } } 3.print("Introduzca un número: "). package bol02ej03.println("Negativo"). package bol02ej02. // repetimos el proceso y volvemos a leer num System. num=Entrada. El proceso se repetirá hasta que se introduzca un 0. Leer un número e indicar si es positivo o negativo.2.out. Leer números hasta que se introduzca un 0. Para cada uno indicar si es par o impar.print("Introduzca otro número: ").out. Ejercicios de Programación en Java 36 .out. System.out. else // si no es positivo: es negativo System.

Ejercicios de Programación en Java 37 .print("Introduzca un número: "). package bol02ej04. contador. public class Main { public static void main(String[] args) { int num.println("Impar").println("Par").out.print("Introduzca otro número: "). // repetimos el proceso y volvemos a leer num System. while(num!=0) // mientras num sea distinto de 0 { if(num%2 == 0) // si el resto de dividir entre dos es cero: esto indica que es par System.entero().out.out.out. System. Pedir números hasta que se teclee uno negativo. else // en caso contrario: impar System. } } } // al salir del mientras tenemos la certeza que num es 0 4. y mostrar cuántos números se han introducido.entero().public class Main { public static void main(String[] args) { int num. num=Entrada. num=Entrada.

// contador toma el valor que tuviera en este momento más uno // en definitiva: contador se incrementa en uno System.print("Introduzca un número: ").entero(). Ejercicios de Programación en Java 38 . num=Entrada. // sin tener en cuenta el último número negativo. 5. Realizar un juego para adivinar un número.out. num=Entrada.// num guardará los números introducidos // y contador se incrementará para llevar la cuenta de los números introducidos System. num. Para ello pedir un número N.out. y luego ir pidiendo números indicando “mayor” o “menor” según sea mayor o menor con respecto a N.out. // al comienzo el número de números introducidos es 0 while(num>0) // mientras num sea positiva { contador =contador+1. El proceso termina cuando el usuario acierta. public class Main { public static void main(String[] args) { int n.print("Introduzca otro número: ").println("Se han introducido: " +contador + " números"). } } } System. package bol02ej05. contador=0.entero().

entero(). System.out.out.print("Introduce número: ").entero(). public class Main { public static void main(String[] args) { int n.entero().. num=Entrada.out. Ejercicios de Programación en Java 39 .println("mayor"). while(num!=n) // mientras no coincidan ambos números { if(num>n) System.").out.print("Introduce N: "). } // al salir del mientras tenemos la certeza que num es igual a n } } package bol02ej05. num.out. // n es el número que hay que acertar // num guarda los números introducidos System.println("menor"). else System. n =Entrada..out. num=Entrada.print("Introduce número: "). System.println("acertaste.// n es el número que hay que acertar // num guarda los números introducidos System.

System.").. mostrar la suma de todos los números introducidos. podemos hacer que se n tome un valor // aleatorio entre 1 y 100.out.out.print("Introduce número: "). num=Entrada. Pedir números hasta que se teclee un 0.n=(int)(Math.random()*100)+1.entero().print("Introduce número: ")..out..out.println("menor").println("mayor").out. // Así el juego es algo más entretenido. // en lugar de pedir n. package bol02ej06. else System.println("acertaste.entero(). num=Entrada. while(num!=n) // mientras no coincidan ambos números { if(num>n) System. } } 6. public class Main { public static void main(String[] args) { Ejercicios de Programación en Java 40 .. System. } // al salir del mientras tenemos la certeza que num es igual a n System.

elementos. suma. do { System. } } 7. y calcular la media.entero().println("La suma de todos los números es: "+suma). } while(num!=0). suma=0. suma=suma+num. package bol02ej07. System. float media.print("Introduzca un número: ").out. public class Main { public static void main(String[] args) { int num. Pedir números hasta que se introduzca uno negativo.int num.out. // la media puede tener decimales // num: guardará los números introducidos por el usuario // suma: almacenará la suma de todos los números introducidos // elementos: será un contador que indicará el números de números 8o elementos) introducidos Ejercicios de Programación en Java 41 .suma. num=Entrada.

System.out.print("Introduzca un número: "); num=Entrada.entero(); suma= 0; elementos= 0; while(num>=0) // nos interesan los positivos y el cero { suma+=num; elementos++; System.out.print("Introduzca otro número: "); num=Entrada.entero(); } if (elementos == 0) // daría un error de división por cero System.out.println("Imposible hacer la media"); else { media= (float)suma/elementos; System.out.println("La media es de: " + media); } } }

8. Pedir un número N, y mostrar todos los números del 1 al N.
package bol02ej08; public class Main { public static void main(String[] args) {

Ejercicios de Programación en Java

42

int i,num; System.out.print("Introduce un número: "); num=Entrada.entero(); i=1; // i es el contador que tomará los valores de 1 a n while(i<=num){ System.out.println(i); i++; } } }

9. Escribir todos los números del 100 al 0 de 7 en 7.
package bol02ej09; public class Main { public static void main(String[] args) { // inicializamos la i a 100 // mientras la i sea mayor o igual a 0 // y en cada vuelta del for la i se decrementa en 7 for (int i=100;i>=0;i-=7) System.out.println(i); // el for al llevar una sola instrucción en su cuerpo de ejecución // no precisa de llaves { }

} }

Ejercicios de Programación en Java

43

10. Pedir 15 números y escribir la suma total.
package bol02ej10; public class Main { public static void main(String[] args) { int num,suma_total; suma_total=0; for (int i=1;i<=15;i++) { System.out.print("Introduzca número: "); num=Entrada.entero(); suma_total=suma_total+num; } System.out.println("La suma total es de: "+suma_total);

} }

11. Diseñar un programa que muestre el producto de los 10 primeros números impares.
package bol02ej11; public class Main { public static void main(String[] args) { long producto=1; // producto guardará la multiplicación de los 10 primeros números impares. // es muy importante acordarse de inicializarlo a 1. Ya que si lo hacemos a 0,

Ejercicios de Programación en Java

44

el producto siempre valdrá 0. // // // // // para calcular los 10 primeros números impares utilizamos un for que: comience en 1 y en cada vuelta se incremente en 2, así obtenemos 1, 3, 5, 7, 9, 11, 13, 15, 17, 19.

for (int i=1; i<20; i+=2) { producto=producto*i; } System.out.println("La multiplicación de los 10 primeros impares: " + producto); } }

12. Pedir un número y calcular su factorial.
package bol02ej12; public class Main { public static void main(String[] args) { // long factorial; con long se puede calcular hasta el factorial de 25 double factorial; int num; System.out.print("Introduce un número: "); num=Entrada.entero();

Ejercicios de Programación en Java

45

i>0. // es importante inicializarlo a 1.i--) { factorial=factorial*i. // suma de los números positivos y negativos float media_pos.println("El factorial de " + num + " es: " + factorial). // contador de positivos int cont_neg.suma_neg.out. Pedir 10 números. la media de los números negativos y la cantidad de ceros. 13. int cont_ceros. } } } System.media_neg. Mostrar la media de los números positivos. // contador de negativos int suma_pos.factorial=1. ya que multiplicará// por ejemplo: el factorial de 10 es: // 10*9*8*7*6*5*4*3*2*1 for (int i=num. public class Main { public static void main(String[] args) { int num. // el contador de ceros int cont_pos. package bol02ej13. // las medias 8positivas y negativa9 pueden tener decimales Ejercicios de Programación en Java 46 .

i<=10. if(num==0) cont_ceros++. suma_neg+=num.println("El número de ceros introducidos es de: "+cont_ceros). } } } // tratamos los ceros System. suma_pos+=num. for (int i=1. suma_neg=0. num=Entrada.cont_ceros=0.i++) { System.out. cont_neg=0.println("No se puede hacer la media de los positivos").print("Introduce número: "). else { if(num>0) { cont_pos++.out.out. suma_pos=0. //Tratamos los positivos if (cont_pos ==0) System. cont_pos=0. Ejercicios de Programación en Java 47 .entero(). } else { cont_neg++.

out. if(sueldo>1000) mayor_1000++.i++) { System.out.mayor_1000. Ejercicios de Programación en Java 48 . } // tratamos los negativos if (cont_pos ==0) System.i<10. public class Main { public static void main(String[] args) { int sueldo.print("Escribe un sueldo: ").out. Pedir 10 sueldos. System.println("Media de los negativos: "+ media_neg).else { media_pos= (float)suma_pos/cont_pos. for (int i=1.suma.println("No se puede hacer la media de los negativos"). } } } 14. else { media_neg= (float)suma_neg/cont_neg. package bol02ej14.println("Media de los positivos: "+ media_pos). sueldo =Entrada.out. mayor_1000=0. System. Mostrar su suma y cuantos hay mayores de 1000€. suma=0.entero().

suma=suma+sueldo. Dadas las edades y alturas de 5 alumnos. media_altura=0. } } 15. package bol02ej15.mayor_edad. if(edad>18) mayor_edad++. mayor_edad=0. la cantidad de alumnos mayores de 18 años. suma_alt=0. mostrar la edad y la estatura media. Ejercicios de Programación en Java 49 . //mayor_edad: mayores de 18 años double altura. System.i<5.mayor_175. mayor_175=0.out. altura=Entrada. } System.println("Mayores de 1000 hay: "+mayor_1000). edad=Entrada. y la cantidad de alumnos que miden más de 1.print("Introduzca edad: ").entero().out. System.media_altura. suma_edad=0. public class Main { public static void main(String[] args) { int edad.75.suma_edad.real().suma_alt. for (int i=1.i++){ System.out.out.media_edad.out.println("Alumno " +i).print("Introduzca altura: ").println("la suma es de: "+suma). System.

println("\n\nLa edad media es de: " +media_edad). do { System.if(altura>1.out.75: " +mayor_175).print("Introduce número (de 0 a 10): "). Pide un número (que debe estar entre 0 y 10) y mostrar la tabla de multiplicar de dicho número. System.out. num=Entrada.out.entero().75) mayor_175++.println("Mayor de 1. } Ejercicios de Programación en Java 50 .out. suma_alt=suma_alt+altura. System.println("Mayor de 18 años: " +mayor_edad). public class Main { public static void main(String[] args) { int num. } media_edad=suma_edad/5.println("La altura media es de: " +media_altura). System. media_altura=suma_alt/5.out. package bol02ej16. System. suma_edad=suma_edad+edad. } } 16.

float facturacion_total. public class Main { public static void main(String[] args) { int codigo.i<=10.while ( ! (0<=num && num<=10)). // el código del artículo en cada factura int litros. cantidad en litros vendidos del artículo 1 y cuantas facturas se emitieron de más de 600 €. la cantidad vendida en litros y el precio por litro. // guardará el importe de la factura con la que estemos trabajando // el importe de todas las facturas // el total de litros vendidos del producto 1 en todas las facturas Ejercicios de Programación en Java 51 . Se pide de 5 facturas introducidas: Facturación total. // la cantidad de litros en cada factura float precio. } } } 17. En cada factura figura: el código del artículo.println("\n\nTabla del " + num).i++) { System.out. Una empresa que se dedica a la venta de desinfectantes necesita un programa para gestionar las facturas. System. package bol02ej17. int litros_cod1. // el precio por litro en cada factura float importe_factura.println(num + " x " + i + " = " + num*i).out. for (int i=1.

out.println("\n\n\nResumen de ventas\n").print("precio (litro): "). System.out. facturacion_total += importe_factura.entero().print("código de producto: ").print("cantidad (litros): ").println("Factura nº " + i). importe_factura = litros*precio.real().out.println("La facturación total es de: " +facturacion_total + "€"). if (codigo == 1) litros_cod1 += litros. } System. // contador que sirve para llevar la cuenta de cuantas facturas hay de for (int i=1.i++) { System. System. System. litros_cod1 = 0.entero(). litros=Entrada. if(importe_factura >= 600) mas_600 ++. codigo=Entrada.int mas_600.out.out. mas_600 = 0.out. precio= (float)Entrada. Ejercicios de Programación en Java 52 . más de 600 € facturacion_total = 0. // facturación total System.i<=5.

} } 18. // el código del artículo en cada factura int litros. más de 600 € facturacion_total = 0.1.println("Ventas del producto 1: " + litros_cod1 + " litros"). // la cantidad de litros en cada factura float precio. int mas_600.// litros del articulo 1 System. package bol02ej18. float facturacion_total.0. Solo existen tres productos con precios: 1. Igual que el anterior pero suponiendo que no se introduce el precio por litro. // guardará el importe de la factura con la que estemos trabajando // el importe de todas las facturas // el total de litros vendidos del producto 1 en todas las facturas // contador que sirve para llevar la cuenta de cuantas facturas hay de Ejercicios de Programación en Java 53 .25 €/litro.out.3 €/litro y 3. public class Main { public static void main(String[] args) { int codigo. // factura de mas de 600 euros System. // ahora el precio no se pide por teclado float importe_factura. int litros_cod1.println("Factura superior a 600€: " + mas_600).out.6 €/litro. 2.

case 3: precio = 1. codigo=Entrada.print("código de producto: "). break. facturacion_total += importe_factura. switch (codigo) { case 1: precio = 0. // este caso no debe darse } importe_factura = litros*precio. litros=Entrada.out.print("cantidad (litros): "). mas_600 = 0. break.6f. System. case 2: precio = 3f. System. for (int i=1.i++) { System.litros_cod1 = 0.out.out.25f.entero(). break.i<=5.entero(). default: precio = 0.println("Factura nº " + i). if (codigo == 1) Ejercicios de Programación en Java 54 .

println("Ventas del producto 1: " + litros_cod1 + " litros"). suspensos=0.aprobados.println ("\n\n\nResumen de ventas\n").out.condicionados.suspensos. // facturación total System. Ejercicios de Programación en Java 55 .litros_cod1 += litros. Dadas 6 notas. aprobados=0.out. } } 19.out. public class Main { public static void main(String[] args) { int nota. if(importe_factura >= 600) mas_600 ++. condicionados (=4) y suspensos. escribir la cantidad de alumnos aprobados. // factura de mas de 600 euros System.println("Factura superior a 600€: " + mas_600).println("La facturación total es de: " +facturacion_total + "€"). // litros del articulo 1 System.out. } System. package bol02ej19.

println("Condicionados: "+condicionados).i<=6. public class Main { public static void main(String[] args) { Ejercicios de Programación en Java 56 .println("Suspensos: " +suspensos). nota=Entrada. if(nota == 4) condicionados++. } System. for (int i=1.out.i++) { System.out.print("Introduzca nota entre 0 y 10: "). } } 20. System. ya que es el único caso posible suspensos++.condicionados=0.println("Aprobados: " +aprobados). introducir N sueldos. Pedir un número N. else if(nota < 4) // este if sobra. y mostrar el sueldo máximo.entero(). package bol02ej20.out. else if(nota >= 5) aprobados++.out. System.

public class Main { public static void main(String[] args) { int sueldo. int n. sueldo_max. // si leemos un sueldo mayor que el máximo. } } } package bol02ej20. int n.print("Número de sueldos: "). System. este sueldo será el nuevo máximo. sueldo_max=0. if (sueldo > sueldo_max) sueldo_max = sueldo.i++) { System. System.out.println("\nEl sueldo máximo es: " +sueldo_max). sueldo=Entrada. for (int i=1. System.int sueldo. n = Entrada. inicializamos el sueldo // máximo a cero.entero().i<=n.out. // como los sueldos son positivos.println("--------").out. Ejercicios de Programación en Java 57 .out.print("Introduce sueldo: ").entero(). sueldo_max = 0.

out.print("Número de sueldos: "). // esta bandera indica si hemos asignado el primer sueldo como sueldo máximo // con esto podremos tener sueldos negativos primer_sueldo_asignado = false.out. } } System.out. primer_sueldo_asignado = true.println("--------"). este sueldo será el nuevo máximo. n = Entrada. sueldo=Entrada. System. } Ejercicios de Programación en Java 58 .boolean primer_sueldo_asignado.entero().out.i++) { System.print("Introduce sueldo: "). } if (sueldo > sueldo_max) sueldo_max = sueldo.entero().i<=n.println("\nEl sueldo máximo es: " +sueldo_max). System. // si leemos un sueldo mayor que el máximo. if (primer_sueldo_asignado == false) { // asignamos como máximo el primer sueldo leído sueldo_max = sueldo. for (int i=1.

package bol02ej21. Pedir 10 números. // la variable hay_negativo según los dos posibles valores indica: // false: no se ha introducido ningún número negativo // true: al menos hay un número negativo hay_negativo =false. if(num<0) hay_negativo =true. y mostrar al final si se ha introducido alguno negativo.21.i<=10. boolean hay_negativo.out.entero().println("No hay ningún número negativo"). // si num es menor que cero. else System. } } Ejercicios de Programación en Java 59 .out. cambiamos el valor de hay_negativo a true } if(hay_negativo == true) System.out. public class Main { public static void main(String[] args) { int num.println("Se ha introducido algún número negativo").print("Introduce número: "). // suponemos que no habrá ningún negativo for (int i=1. num=Entrada.i++) { System.

entero(). // suponemos que en principio no hay ningún suspenso for (int i=0.22. Pedir 5 calificaciones de alumnos y decir al final si hay algún suspenso.out. package bol02ej23.println("No hay suspensos").out. Pedir 5 números e indicar si alguno es múltiplo de 3. public class Main { public static void main(String[] args) { int notas. public class Main { Ejercicios de Programación en Java 60 .out.i<5.println("Hay alumnos suspensos"). boolean suspensos. notas=Entrada. suspensos=false. if(notas<5) suspensos=true. package bol02ej22. } } } if(suspensos) System.i++) { System.print("Introduzca nota (de 0 a 10): "). 23. else System.

print("Introduzca número: "). // si se ejecuta esta instrucción significa que al menos hay un múltiplo } if(multiplo_3 == false) System.out.public static void main(String[] args) { int num. else System.entero().i++){ System.println("Hay múltiplos de 3"). Ejercicios de Programación en Java 61 . multiplo_3=false. if(num %3 == 0) multiplo_3=true.println("no existen múltiplos de 3"). boolean multiplo_3. for (int i=0.i<5. } } de 3. num=Entrada.out.out.

i.1 HASTA 4 PARA j <.Bucles anidados 1. j: ENTERO COMIENZO PARA i <.i*10+j escribir (suma) FIN PARA FIN PARA FIN Boletín 3 Ejercicios de Programación en Java 62 . Realiza detenidamente una traza al siguiente programa y muestra cual seria la salida por pantalla: PROGRAMA ej_1 VARIABLES suma.3 HASTA 0 INC -1 suma <.

j>0. } } } } 2.i<4. System.j--){ suma=i*10+j. j: ENTERO COMIENZO PARA i <. for (int i=0.1 HASTA 3 j <.println(suma). Realiza una traza del siguiente algoritmo y muestra la salida generada por pantalla.i++){ for (int j=3.i+1 MIENTRAS j < 4 escribir (j-i) j <.j+1 FIN MIENTRAS FIN PARA FIN Ejercicios de Programación en Java 63 . PROGRAMA ej_1 VARIABLES i.out.package bol03ej01. public class Main { public static void main(String[] args) { int suma.

package bol03ej03. tabla<=10.i<3.println(j-i).println ("---------------").out. public class Main { public static void main(String[] args) { int j. for (int i=0. System. tabla++) { System. } } } } 3.package bol03ej02. j++. public class Main { public static void main(String[] args) { int tabla. for (tabla=1.i++){ j=i+1.println ("\n\nTabla del " +tabla). for (i=1.out. Diseña una aplicación que muestre las tablas de multiplicar del 1 al 10.i.i<=10.i++) Ejercicios de Programación en Java 64 . while(j<4){ System.out.

col. package bol03ej04. fila<=n. n = Entrada.out.{ } } } } System.println (tabla + " x " + i + " = " + tabla*i).out. } } } Ejercicios de Programación en Java 65 . public class Main { public static void main(String[] args) { int n. fila++) { for (col=1. System. System. col++) System.out. 4. for (fila=1.print ("Lado del cuadrado: "). col<=n.entero(). Dibuja un cuadrado de n elementos de lado utilizando *.println (""). // tamaño del lado int fila.print ("* ").out.

out.out. else System.out.print("E").l<=9.print(k).k++){ for (int l=0.j++){ for (int k=0.print("E").out.m<=9.out.i++){ for (int j=0.m++){ if(i==3) System. con la particularidad que cada vez que aparezca un 3 lo sustituya por una E. public class Main { public static void main(String[] args) { for (int i=0. if(j==3) System.k<=9. Necesitamos mostrar un contador con 5 dígitos (X-X-X-X-X). if(l==3) System.out. que muestre los números del 0-0-0-0-0 al 9-9-9-9-9.print("E"). if(k==3) System.print(i).print(j).out.5. package bol03ej05.out. else System.j<=9. else System.print(l). if(m==3) Ejercicios de Programación en Java 66 .l++){ for (int m=0.i<=9. else System.print("E").

cont_pri=0. // vamos procesando todos los números entre 1. System. boolean primo. System.num for(int i=1.println(" ").print("Introduce numero: ").i<=num. package bol03ej06.else System.out.print(m).out. num=Entrada. } } } } } } } 6.out..cont_pri. Realizar un programa que nos pida un número n.entero().i++){ Ejercicios de Programación en Java 67 . public class Main { public static void main(String[] args) { int j.num. y nos diga cuantos números hay entre 1 y n que son primos.out. System.print("E").

Ejercicios de Programación en Java 68 . } if (primo==true){ cont_pri++. calcularemos si es primo // veremos si el número i es divisible en el rango 2.out..i-1 // El bucle while se puede hacer con menos vuelta. j=2. // si es primo incrementamos el contador de primos System. consultar algoritmos para primos primo=true. while (j<=i-1 && primo==true) { if (i%j==0) primo=false. hay "+ cont_pri + " números primos").println("En el rango 1.println(i+(" es primo")).." + num + ".out.// para cada número i. j++. } } } } System...

println("Los números son:"). t[i]=Entrada.i<5.print("Introduzca un número: ").entero().i++) System.out. t = new int[5].i<5. public class Main { public static void main(String[] args) { int t[].out.println(t[i]). Leer 5 números y mostrarlos en el mismo orden introducido. package bol04ej01. } System.out.i++) { System. } } Ejercicios de Programación en Java 69 .Boletín 4 Tablas 1. for (int i=0. for (int i=0.

out.suma_neg. public class Main { public static void main(String[] args) { int t[]=new int [5].i--) System.i<5. package bol04ej03. public class Main { public static void main(String[] args) { int t[]=new int[5].println(t[i]). Leer 5 números por teclado y a continuación realizar la media de los números positivos.i>=0. package bol04ej02. t[i]=Entrada. int suma_pos.cont_cero.cont_pos.2. for (int i=0.out. } System. } } 3.i++) { System. Leer 5 números y mostrarlos en orden inverso al introducido. for (int i=4.out.cont_neg.print("Introduzca un número: ").entero(). la media de los negativos y contar el número de ceros.println("Los números (en orden inverso):"). Ejercicios de Programación en Java 70 .

else{ if(t[i]>0){ suma_pos=suma_pos+t[i].suma_pos=0. t[i]=Entrada.i++){ System. } } } if(cont_pos==0) System. en un solo bucle for (int i=0. } else{ suma_neg=suma_neg+t[i].println("No se puede realizar la media de números negativos"). cont_neg++.out. suma_neg=0. if(cont_neg==0) System. // utilizamos un bucle para leer los datos y otro para procesarlos // se podrían hacer ambas operaciones.entero(). cont_neg=0. cont_pos=0. leer y procesar. } for (int i=0. cont_cero=0.println("No se puede realizar la media de números positivos"). cont_pos++.print("Introduzca un número: ").out. else Ejercicios de Programación en Java 71 .i<5.out.i<5. else System.println("La media de los positivos: "+(float)suma_pos/cont_pos).i++){ if(t[i]==0) cont_cero++.out.

// mostramos el i-ésimo número por el principio System.println("El resultado es:"). Debemos mostrarlos en el siguiente orden: el primero. el segundo. for (i=0. el último.entero(). for (i=0.System. el tercero.out.print("Introduzca numero: ").println("La media de los negativos: " + (float)suma_neg/cont_neg). } System.out. Leer 10 números enteros.out.out.out. } } 4.println (t[i]). System. t = new int[10].println("La cantidad de cero es de: " + cont_cero). public class Main { public static void main(String[] args) { int i. el penúltimo.println(t[9-i]).i<=4. // y el i-ésimo por el final } Ejercicios de Programación en Java 72 . etc.i<10. t[]. t[i]=Entrada.i++){ System. package bol04ej04.out.i++){ System.

c = new int [20]. } } 5. c[]. el 1º de B.// como en cada vuelta de for se muestran dos números // para mostrarlos todos. el 2º de A.print("número: "). Leer por teclado dos tablas de 10 números enteros y mezclarlas en una tercera de la forma: el 1º de A. // leemos la tabla a System.out. } // leemos la tabla b Ejercicios de Programación en Java 73 . a[i]=Entrada.i<10.j.println("Leyendo la tabla a"). int i.i++){ System. b[]. b=new int[10]. for (i=0. solo necesitaremos la mitad de vueltas. public class Main { public static void main(String[] args) { int a[]. package bol04ej05. a=new int[10].out. el 2º de B. // la tabla c tendrá que tener el doble de tamaño que a y b.entero(). etc.

out. j++. Aunque se podría utilizar i. } System. } // asignaremos los elementos de la tabla c // para las tablas a y b utilizaremos como índice i // y para la tabla c utilizaremos como índice j.i++){ System.out. for (i=0.out. } } System. for (j=0. Ejercicios de Programación en Java 74 . c[j]=b[i]. System.out.i<10.println("").j<20. package bol04ej06. b[i]=Entrada. otros 3 de la B.i<10.println("La tabla c queda: "). 3 de la B. j++. Leer los datos correspondiente a dos tablas de 12 elementos numéricos.System.entero().print(c[j]+" ").out. 6.j++) // seguimos utilizando j.println("Leyendo la tabla b"). para la tabla c. for (i=0. etc. y mezclarlos en una tercera de la forma: 3 de la tabla A.print("número: ").i++){ c[j]=a[i]. j=0. otros 3 de A.

int i. b=new int[12].out.println("Leyendo la tabla a"). a=new int[12].println("Leyendo la tabla b").i++){ System.out.public class Main { public static void main(String[] args) { int a[]. } // asignaremos los elementos de la tabla c // para las tablas a y b utilizaremos como índice i // y para la tabla c utilizaremos como índice j.print("número: "). for (i=0. i=0.out.i<12. b[]. // la tabla c tendrá que tener el doble de tamaño que a y b.entero(). // leemos la tabla a System. } // leemos la tabla b System.entero(). c = new int [24].i++){ System. Ejercicios de Programación en Java 75 . c[]. b[i]=Entrada. a[i]=Entrada.print("número: ").j.i<12. for (i=0. j=0.out.

Ejercicios de Programación en Java 76 .println(""). incrementamos la i en 3. } // copiamos 3 de b for (int k=0. para la tabla c.out.print(c[j]+" "). for (j=0. j++.k<3. i+=3. k++) { c[j]=a[i+k].out. } // como hemos copiado 3 de a y b.while (i<12) { // copiamos 3 de a for (int k=0. } // la j se incrementa cada vez que se añade un elemento a la tabla c. System.println("La tabla c queda: "). System.k<3.out.j++) // seguimos utilizando j. j++.j<24. Aunque se podría utilizar i. } } System.k++) { c[j]=b[i+k].

para algún i.7. // creciente indicará si los números están ordenados de forma creciente // decreciente indicará si la serie está ordenada de forma decreciente // los posible valores para creciente y decreciente son: /* creciente decreciente * false false -> cuando todos los números sean idénticos * false true -> orden decreciente * true false -> orden creciente * true true -> desordenado * * si. decreciente = false. package bol04ej07. se cumple t[i]>t[i+1]: la serie t[i]. int i. Leer por teclado una serie de 10 números enteros. o si están desordenados. decreciente. Ejercicios de Programación en Java 77 . t[i+1] es decreciente * * o el caso contrario. public class Main { public static void main(String[] args) { int numeros[]. decreciente. * */ numeros = new int [10]. creciente = false. La aplicación debe indicarnos si los números están ordenados de forma creciente. boolean creciente.

println("Serie desordenada.out. if (creciente ==false && decreciente ==false) // no hay parejas crecientes ni decrecientes System. if (creciente ==false && decreciente ==true) // todas la parejas están en orden decreciente System. // en este momento es creciente } // dependiendo de los valores de creciente y decreciente daremos un tipo de ordenación if (creciente ==true && decreciente ==false) //toda las parejas están en orden creciente System.out.out.print("número: ").i<10. numeros[i]=Entrada.// leemos los números System. if (creciente ==true && decreciente ==true) // si ha tenido momentos creciente y decrecientes System.out. if (numeros[i] < numeros[i+1]) creciente = true. } // comprobaremos el orden for (i=0. // lo que significa que todos son iguales } } Ejercicios de Programación en Java 78 .i++) // usamos i e i+1.i<9.println("Serie creciente.out. for (i=0.").out.i++){ System.println("Leyendo números:").println("Serie decreciente. por lo que la i solo podrá llegar hasta 8 (ó <9) { if (numeros[i] > numeros[i+1]) // en este momento es decreciente decreciente = true.entero().").println("Todos los números iguales.").").

posicion = Entrada.out. es comprobar esto.. Diseñar una aplicación que declare una tabla de 10 elementos enteros.i<8.out. elemento = Entrada. for (int i=0. // un valor distinto podría dar un error en tiempo de ejecución // una posible mejora."). } // pedimos el nuevo elemento y la posición System. propuesta para el lector. // leemos 8 números System. package bol04ej08.entero().. Después se debe pedir un número y una posición. // ahora desplazaremos los elementos de la tabla // desde posición hasta el último (en este caso 7) Ejercicios de Programación en Java 79 .i++){ System. public class Main { public static void main(String[] args) { int t[]=new int[10]. // supondremos que la posición estará entre 0 y 8. Leer mediante el teclado 8 números.out.print("Introduzca número: ").print("Posición donde insertar (de 0 a 8): ").8.println("Leyendo datos. posicion. t[i]=Entrada. System. desplazando los que estén detrás.entero().entero(). int elemento. insertarlo en la posición indicada.out.print("Nuevo elemento: ").

for (int i=0. El último pasa a ser el primero.for (int i=7.i<9.i++) System. // leemos la tabla for (int i=0. } // guardamos el último elemento de la tabla ultimo = t[9]. Crear un programa que lea por teclado una tabla de 10 números enteros y la desplace una posición hacia abajo: el primero pasa a ser el segundo.print("Introduzca número: "). //insertamos el nuevo elemento t[posicion] =elemento. el segundo pasa a ser el tercero y así sucesivamente.out.i--) t[i+1]=t[i].i>=posicion.i++){ System.println(t[i]). int ultimo.out.i<10. Ejercicios de Programación en Java 80 . t[i]=Entrada. public class Main { public static void main(String[] args) { int t[]=new int[10]. System.out.println("La tabla queda:").entero(). } } 9. package bol04ej09.

} } 10.println("La tabla queda:"). int n.// desplazamos hacia abajo (de 0 hacia la última posición) // al desplazar perdemos el último valor. // preguntamos cuantas posiciones se desea desplazar System. Ejercicios de Programación en Java 81 .i++){ System.out.i--) t[i+1]=t[i]. public class Main { public static void main(String[] args) { int t[]=new int[10]. // el último valor pasa a ser el primero t[0] =ultimo.out. // leemos la tabla for (int i=0.println(t[i]). desplazar N posiciones (N es introducido por el package bol04ej10.i<10.i++) System.i<10.entero(). } usuario). for (int i=8. Ídem.out.out. t[i]=Entrada. por eso lo hemos guardado antes.print("Posiciones a desplazar:" ). int ultimo.print("Introduzca número: "). System. for (int i=0.i>=0.

println("La tabla queda:").i--) t[i+1]=t[i]. pero es muy costoso en tiempo. // // // // del ejercicio anterior tenemos una versión que desplaza una sola posición.out. // un algoritmo más eficiente package bol04ej10. public class Main { Ejercicios de Programación en Java 82 .i++) System. Si repetimos este proceso n veces.vueltas <=n. } } } System. for (int i=8. este algoritmo es muy fácil de implementar. for (int i=0.i>=0.println(t[i]).entero().i<10. conseguiremos desplazar n veces. for (int vueltas=1. vueltas++) { // guardamos el último elemento de la tabla ultimo = t[9]. // desplazamos hacia abajo (de 0 hacia la última posición) // al desplazar perdemos el último valor. // el último valor pasa a ser el primero t[0] =ultimo.n = Entrada. por eso lo tenemos guardado.out.

i<10. } // preguntamos cuantas posiciones desea desplazar System. // leemos la tabla for (int i=0. int n. t[i]=Entrada. n = Entrada.i++) t[i] =copia[(i+n)%10].out. for (int i=0.out. // // // // // // en el caso de desplazar una posición: necesitamos guardar solo un elemento (el último que pasa a ser el primero) en el caso de desplazar dos posiciones: necesitamos guardar dos elementos (penúltimo y último.out. que pasarán a ser primero y segundo) como a priori no sabemos cuantos elementos vamos a desplazar. ni cuantos elementos tenemos que guardar. } } Ejercicios de Programación en Java 83 . // la tabla funciona como si fuese circular por eso utilizamos el módulo System.print("Introduzca número: ").i++) System.i++){ System.print("Posiciones a desplazar:" ).out.i<10.entero(). Una buena solución es hacer una copia de la tabla completa int copia[] = t.entero().public static void main(String[] args) { int t[]=new int[10].i<10.println(t[i]).clone(). // desplazamos hacia abajo n posiciones for (int i=0.println("\n\nLa tabla queda:").

sitio_num. // buscaremos el sitio donde debería ir num while(t[j]<num && j<=4){ sitio_num ++. sitio_num=0.println().11. } System. System.j. t[i]=Entrada. e insertarlo en el lugar adecuado para que la tabla continúe ordenada. Leer 5 elementos numéricos que se introducirán ordenados de forma creciente. int num.i<5. j=0.entero().print("Número a insertar entre los anteriores: ").entero(). Leer un número N. for (int i=0. num=Entrada.out. } // desplazaremos los elementos desde el sitio_num hasta el final // así haremos un hueco para num Ejercicios de Programación en Java 84 . Éstos los guardaremos en una tabla de tamaño 10.print("Introduzca número (ordenado crecientemente): "). public class Main { public static void main(String[] args) { int t[]=new int[10]. package bol04ej11.out. j++.out.i++) { System.

out.print("Elemento ("+i+"): "). public class Main { public static void main(String[] args) { int t[]=new int[10].i<10.for (int i=4. i>=sitio_num. Eliminar el elemento situado en la posición dada sin dejar huecos. i--) t[i+1]=t[i].i++) System. System.i++) { System. } Ejercicios de Programación en Java 85 . int posicion.out.out. Leer por teclado una tabla de 10 elementos numéricos enteros y una posición (entre 0 y 9). t[i]=Entrada. } } 12. for (int i=0. // leemos los 10 números for (int i=0.println("La nueva serie ordenada queda: ").println(t[i]). // por último ponemos num en su sitio para que todo siga ordenado t[sitio_num]=num. package bol04ej12.entero().i<5+1.

9 System. public class Main { /** * En esta versión utilizaremos para ver los elementos pares o impares * los valores de la tabla. Ejercicios de Programación en Java 86 .out.entero(). Realizar dos versiones: una trabajando con los valores y otra trabajando con los índices. Leer 10 enteros..System. Guardar en otra tabla los elementos pares de la primera.i<9..out. for (int i=0. package bol04ej13.. // ya que dentro usamos (i+1) que es la última posición // así evitamos salirnos de la tabla System.i++) // la i llega hasta la penúltima posición. y a continuación los elementos impares.i++) // hay que tener cuidado que ahora hay un System. // elemento útil menos en la tabla } } 13. t[1].out.i<9. posicion=Entrada.println("La tabla queda: ").out. // leemos la posición que nos interesa // suponemos que la posición está en el rango 0. // desplazamos desde posición hasta el final todos los elementos un lugar hacia la izquierda // con lo que el elemento que está en posición se pierde (se borra) for (int i=posicion.print("Posición a eliminar: "). es decir t[0].println().println(t[i]). t[i] = t[i+1]..

// volvemos a procesar para copiar cada elemento en la tabla adecuada cont_par=0. int cont_par.i++) if(t[i]%2==0) cont_par++.i++){ System.*/ public static void main(String[] args) { int t[].entero(). // Leemos los valores de la tabla for (int i=0.out.print("Introduzca un número: "). for (int i=0. // ídem para los impares t = new int[10]. else cont_impar++.i<10. for (int i=0. cont_impar=0.i<10. // creamos las tablas par e impar del tamaño adecuado par=new int[cont_par].i++) Ejercicios de Programación en Java 87 .i<10.impar[]. par[]. t[i]=Entrada. } // contamos la cantidad de elementos pares e impares // también se podía contar solo lo pares y calcular los impares=10 -pares cont_par=0. // contador de números pares y tabla para guardarlos int cont_impar. cont_impar=0. impar=new int[cont_impar].

*/ public static void main(String[] args) { int t[]. } else { impar[cont_impar]=t[i].println(par[i]).. } } package bol04ej13.i<cont_impar.t[4].out. System. public class Main { /* * En esta versión nos fijaremos en los índices pares e impares * en par se incluirá t[2].i++) System.println("\n\nTabla par:").println(impar[i]). t[2]..i++) System. for (int i=0...println("Tabla impar:"). cont_par++.i<cont_par. cont_impar++.. } System.out. int par[]. for (int i=0.if(t[i]%2==0) { par[cont_par]=t[i]. * en impar t[1]. Ejercicios de Programación en Java 88 .out.out.

entero().i<5. } } Ejercicios de Programación en Java 89 . System.println(par[i]).i<10.print("Introduzca un número: "). for (int i=0.println("\n\nTabla par:"). for (int i=0.out.i<10.i++) System.i+=2) // la división entera redondeada hacia el entero más próximo por impar[i/2] = t[i]. 3/2 =1. impar=new int[5]. t = new int[10]. etc.i++) System. System. } // creamos las tablas par e impar del tamaño adecuado (5) par=new int[5].println(impar[i]).int impar[]. // Leemos los valores de la tabla for (int i=0. for (int i=1.out.out.println("Tabla impar:").out.out.i++){ System.i<5. t[i]=Entrada. // copiamos cada elemento en la tabla adecuada for (int i=0.i<10.i+=2) par[i/2] = t[i]. // debajo: 1/2 =0.

i<10.println("\nDatos para b:"). package bol04ej14.i++){ System. } System. } // leemos b System. int i.entero().print("Introduzca numero (orden creciente): ").out.k.out. b[i]=Entrada. for (i=0. for (i=0. c[]. b =new int[10]. de forma que sigan ordenados. que estarán ordenados crecientemente. a =new int[10]. Leer dos series de 10 enteros. b[].i++){ System.i<10. // creamos c Ejercicios de Programación en Java 90 .j.14. // leemos a System.out.println(). Copiar (fusionar) las dos tablas en una tercera.println("Datos para a:").print("Introduzca numero (orden creciente): ").out.entero(). public class Main { public static void main(String[] args) { int a[].out. a[i]=Entrada.

como índice de c while(i<10 && j<10) { if (a[i] < b[j]) // nos interesa el elemento de a { c[k] = a[i]. // incrementamos j para tomar el siguiente elemento de b } k++. j++. // utilizaremos i j=0. } // cuando salimos de while es por que alguna de las tablas (a o b) ha llegado al final if(i==10) // hemos copiado toda la tabla a en c. // incrementamos i para tomar el siguiente elemento de a } else { c[k] = b[j].c = new int [20]. k++. j++. utilizar el siguiente hueco de la tabla Ejercicios de Programación en Java 91 . i++. // comenzamos a fusionar i=0. } else // hay que copiar el resto de a en c while (i<10) // como hemos copiado a c[k]. queda por copiar un resto de b while (j<10) { c[k] = b[j]. incrementamos k. para // en la siguiente vuelta. // utilizaremos k a y b en c como índice de a. como índice de b. // utilizaremos j k=0.

out.print(c[k] + " System. int num.{ c[k] = a[i].k<20.print("Introduzca numero (orden creciente): ").j. k++. for (k=0.println(). 15. } System. package bol04ej15. for (int i=0.out. } System.out. Leer 10 enteros ordenados crecientemente. public class Main { public static void main(String[] args) { int t[]=new int[10].i<10. i++. t[i]=Entrada.println(""). Leer N y buscarlo en la tabla.k++) System. Si no está.out. Ejercicios de Programación en Java 92 . indicarlo con un mensaje. } } "). Se debe mostrar la posición en que se encuentra.println("Mostramos la tabla c:").i++){ System.entero().out.

segundo y tercer trimestre de un grupo.println("Introduzca numero a buscar: "). y la media del alumno que se encuentra en la posición N (N se lee por teclado). while(j<10 && t[j]<num){ j++. package bol04ej16.que j llegue a 10 ó // .println("Encontrado en la posición " + j).out. Debemos mostrar al final: la nota media del grupo en cada trimestre. System. Se pide leer las notas del primer.out. j=0.out. public class Main { Ejercicios de Programación en Java 93 . hemos sobrepasado el lugar donde debería estar num. num=Entrada. else{ // si t[j] < num.entero(). } // cuando me salgo del mientras puede ser por dos motivos: // .System.println("No encontrado"). Queremos desarrollar una aplicación que nos ayude a gestionar las notas de un centro educativo.println("No encontrado"). } } } 16.que encuentre el donde iría num en la tabla if(j==10) // hemos llegado al final y no hemos encontrado nada. sin encontrarlo if(t[j]==num) // num está en la posición i. Cada grupo (o clase) está compuesto por 5 alumnos. else System. Entonces si está ahí System.out.

segundo[].print("Alumno ("+i+"): "). // creamos las tablas necesarias primer = new int [5].out.print("Alumnos ("+i+"): ").i<5.entero().println("Notas del segundo trimestre:").println("Notas de primer trimestre:"). } // leemos las notas del tercer trimestre System. Se podrían procesar las // notas mientras se leen.public static void main(String[] args) { int primer[].i. segundo[i]=Entrada. suma_tercer. for (i=0. tercer[i]=Entrada.entero().i++){ System. primer[i]=Entrada.i<5. int suma_primer.out. segundo y tercer trimestre int num. double media_alumno. for (i=0. // el programa consta de dos partes: entrada de datos y procesado. Preferimos utilizar dos bloques por tener un código más legible.out.print("Alumnos ("+i+"): "). for (i=0.i++){ System.println("Notas del tercer trimestre:"). // leemos las notas del primer trimestre System. } // leemos las notas del segundo trimestre System.i++){ System. tercer[]. Ejercicios de Programación en Java 94 .out. // notas del primer. segundo = new int [5].i<5.out.out.entero(). suma_segundo. tercer = new int [5].

} // calculamos las medias suma_primer = 0; // ponemos a 0 los acumuladores suma_segundo = 0; suma_tercer = 0; for (i =0; i < 5; i++) { suma_primer += primer[i]; suma_segundo += segundo[i]; suma_tercer += tercer[i]; } // mostramos datos System.out.println("Media primer trimestre: "+ suma_primer/5.0); System.out.println("Media segundo trimestre: "+ suma_segundo/5.0); System.out.println("Media tercer trimestre: "+ suma_tercer/5.0); System.out.println(); // leemos la posición del alumnos que nos interesa // una posible mejora es comprobar que el índice se encuentre // entre 0 y 4 System.out.print ("Introduzca posición del alumno (de 0 a 9): "); num=Entrada.entero(); // la media del alumno es la suma de sus notas entre 3 media_alumno = (double) (primer[num]+segundo[num]+tercer[num])/3; } } System.out.println("La media del alumno es: " + media_alumno);

Ejercicios de Programación en Java

95

Tablas n-dimensionales
1. Crear una tabla bidimensional de tamaño 5x5 y rellenarla de la siguiente forma: la posición T[n,m] debe contener n+m. Después se debe mostrar su contenido.
package bol05ej01; public class Main { public static void main(String[] args) { int t[][]; // definimos t como una tabla bidimensional t = new int [5][5]; // creamos la tabla de 5x5

Boletín 5

for (int i=0;i<5;i++) // utilizamos i para la primera dimensión { for (int j=0;j<5;j++) // utilizamos j para la segunda dimensión { t[i][j]=i+j; } } System.out.println("TABLA: ");

Ejercicios de Programación en Java

96

for (int i=4;i>=0;i--) { System.out.println(); for (int j=0;j<5;j++) { System.out.print(t[i][j]+" "); } } } }

2. Crear y cargar una tabla de tamaño 4x4 y decir si es simétrica o no, es decir si se obtiene la misma tabla al cambiar las filas por columnas.
package bol05ej02; public class Main { public static void main(String[] args) { int t[][]; boolean simetrica; int i,j; t = new int[4][4]; for (i=0;i<4;i++) { for (j=0;j<4;j++) { System.out.print("Introduzca elemento ["+i+"]["+j+"]: "); t[i][j]=Entrada.entero(); }

Ejercicios de Programación en Java

97

} simetrica=true; // suponemos que la matriz es simétrica, y en caso de // encontrar un caso donde t[i][j] sea distinta de t[j][i] pondremos // simétrica a falso.

//una solución es mirar todos los elementos de la matriz, pero se hacen comprobaciones // dobles, un ejemplo: comprobamos t[1][2] con t[2][1]... pero más tarde comprobaremos // t[2][1] con t[1][2] // la solución será mirar solo la zona inferior o superior a la diagonal principal. // En el momento que tengamos la constancia de que no es simétrica, pararemos // todas las comprobaciones i=0; while(i<4 && simetrica==true){ j=0; while(j<i && simetrica==true){ if(t[i][j]!=t[j][i]) simetrica=false; j++; } i++; } // si en algún momento se da: t[i][j]!=t[j][i] es que la matriz no es simétrica. // si al llegar aquí y la variable simétrica vale true, indica que no hemos encontrado // ningún valor que indique que la matriz no es simétrica. if(simetrica) System.out.println("SIMETRICA"); else System.out.println("NO ES SIMETRICA"); } }

Ejercicios de Programación en Java

98

j++) { System.i<3.println ("Matriz A:"). sumarlas y mostrar su suma.entero(). for (i=0. package bol05ej03.out.3. // Leemos los datos System. a = new int[3][3]. for (i=0.j++) { System.j<3.print("B["+i+"]["+j+"]: "). int i.print("A["+i+"]["+j+"]: ").println ("Matriz B:").i++) { for (j=0.j<3.i<3.j. b[i][j]=Entrada.out.entero(). } } System.out.i++) { for (j=0. } } Ejercicios de Programación en Java 99 . suma[][].out. a[i][j]=Entrada. Crear y cargar dos matrices de tamaño 3x3. b = new int[3][3]. b[][]. public class Main { public static void main(String[] args) { int a[][].

j++) { suma[i][j] = a[i][j] + b[i][j].println ().j++) { System.j<3.// hacemos la suma suma = new int[3][3]. public class Main { public static void main(String[] args) { int t[][]=new int[3][3].println ("Matriz Suma:").j<3.print (suma[i][j] + " "). } } } 4.i++) { for (j=0.out.i++) { for (j=0. } } // mostramos los resultado System.out. for (i=0. trasponerla y mostrarla. package bol05ej04.out. for (i=0. } System. Ejercicios de Programación en Java 100 .i<3.i<3. Crear y cargar una tabla de tamaño 3x3.

j<3.i++){ System. } } // // // // trasponemos la matriz no podemos transponer todos los elementos. } } Ejercicios de Programación en Java 101 .. Un ejemplo el elemento t[1][2] se convierte en el [2][1].print(t[i][j]+" "). // solo traspondremos los elementos por debajo de la diagonal principal.i<3. } } // mostramos la matriz original System.j<3.println().i<3.int aux. Al intercambiar dos veces los elemento.j++){ System. t[i][j]=Entrada.j++){ System.i++){ for (int j=0.j<i.entero().print("Introduzca elemento["+i+"]["+j+"]: "). pero cuando transpongamos el elemento [2][1] se convierte en el [1][2]. for (int i=0.out.out.out.i++){ for (int j=0.print ("Matriz original:").i<3.out. t[i][j]=t[j][i]..j++){ aux=t[i][j]. for (int j=0. t[j][i]=aux. for (int i=1. for (int i=0. la matriz se quedaría exactamente igual.

i<7.println(). for (int j=0.j++){ System. System. public class Main { public static void main(String[] args) { int t[][]=new int[7][7].i>=0. else t[i][j] = 0.j. System.println().j<7. for (int i=2. int i.out.out. package bol05ej05.i++) for (j=0.println("---------------------").j++) if (i==j) t[i][j] = 1. } } } } 5.out.// mostramos la matriz transpuesta System.println ("Matriz transpuesta").out.j<3. todos los elementos se Ejercicios de Programación en Java 102 .i--){ System. Crear una tabla de tamaño 7x7 y rellenarla de forma que los elementos de la diagonal principal sean 1 y el resto 0.print(t[i][j]+" "). al crear una tabla de enteros. // en java. for (i=0.out.

j<7. final int tamaño=4. Se aña_ // de para que el código sea más comprensible.suma_col.j++) System.. pero desde el punto de vista del algoritmo no es relevante.// inicializan a 0.j<tamaño..i++) { for (j=0.out. mostrar la suma de cada fila y de cada columna. for (i=0. t = new int[tamaño][tamaño].println ().i<tamaño.println ("Matriz:").out.j++){ System.i++){ for (j=0. for (i=0. public class Main { public static void main(String[] args) { int t[][]=new int[4][4]. Ejercicios de Programación en Java 103 . } } } 6. System. int i.out. Por lo que esta instrucción no es necesaria.i<7.print(t[i][j]+" "). // mostramos la matriz // la forma de ver la matriz no es la típica que estamos acostumbrados en // matemática. int suma_fila. Crear y cargar una tabla de tamaño 10x10. System. package bol05ej06.j.print("Elemento ["+i+"]["+j+"]: ").out.

i<tamaño.i++){ suma_col=0. // sumamos columna a columna System. for (i=0. cargar la primera y trasponerla en la segunda. for (i=0. public class Main { public static void main(String[] args) { int a[][].i++){ suma_fila=suma_fila+t[i][j].println("Columna"+" "+i+":"+" "+suma_col). } System. } System. } // sumamos fila a fila for (j=0.println().j<tamaño. for (j=0. package bol05ej07.i<tamaño.j++){ suma_col=suma_col+t[i][j].} } t[i][j]=Entrada.out.out.j<tamaño. } } } 7.j++){ suma_fila=0.entero().println("Fila"+" "+j+":"+" "+suma_fila). Ejercicios de Programación en Java 104 . utilizando dos tablas de tamaño 5x9 y 9x5. b[][].out.

out.out. a[i][j]=Entrada. b = new int [9][5].print (b[i][j] + " "). for (i=0.j<9. } } // mostramos la matriz traspuesta System.j++) System.j++){ System. for (i=0. } } // trasponemos for (i=0.out.out.j++){ b[j][i] = a[i][j].println("Matriz traspuesta").entero().i++){ for (j=0.int i.i<5.i++){ for (j=0.i<5.j<5.i<9. System.j<9.i++){ for (j=0. a = new int[5][9].println (). // si queremos ahorrarnos introducir 5x9 (45) números. podemos comentar las // dos lineas anteriores y utilizar (por ejemplo): // a[i][j] = 10*i+j.print("Elemento ["+i+"]["+j+"]: ").j. } } } Ejercicios de Programación en Java 105 .

// rellenamos la matriz marco for (i=0. package bol05ej08. } } System.out.i<8. Crear una matriz “marco” de tamaño 8x6: todos sus elementos deben ser 0 salvo los de los bordes que deben ser 1.print (t[i][j]+" "). Mostrarla. for (i=0. Creamos un cubo con las caras puestas a 1 y el interior a 0.i<8. } } 9. pero con una matriz 9x9x9. int t[][]. public class Main { public static void main(String[] args) { int i.j++){ System.println().j++) { if(i==0 || i==7) // si nos encontramos en la primera o última columna t[i][j]=1. Ejercicios de Programación en Java 106 .print("Matriz marco: "). for (j=0.println (). } System.j<6. Hacer lo mismo que el ejercicio anterior.8.i++) for (j=0.i++){ System. // se inicializa toda la tabla a 0.j<6.out.out.j. t = new int[8][6].out. if(j==0 || j==5) // si nos encontramos en la primera o última fila t[i][j]=1.

} } } // Mostramos la matriz capa a capa System."). } Ejercicios de Programación en Java 107 .k++){ if(i==0 || i==8 || j==0 || j==8 || k==0 || k==8) // si estamos en la primera o última columna.j<9.k++) { System.println ().out.k.out.k<9. for (i=0.j++) { for (k=0. for (j=0.println("Capa: " +i). fila o capa de la matriz t[i][j][k]=1.out.print(t[i][j][k] + " ").j<9.j. t = new int[9][9][9].package bol05ej09.j++){ for (k=0.i<9.k<9. } System. } System.println (" -------------. for (i=0.i++){ for (j=0.i++) { System.println("Matriz: "). int i. public class Main { public static void main(String[] args) { int t[][][].out.out.i<9.

8. 8. Mostrar el resultado: PROGRAMA Ej10a VARIABLES i. 5. 2. 6 y 1. i: ENTEROS a. PROGRAMA Ej10b VARIABLES n. a: ENTEROS t: TABLA [5] ENTEROS COMIENZO PARA i0 HASTA 4 leer (t[i]) FIN PARA m  0 PARA i  0 HASTA 4 SI t[i] > m m  t[i] FIN SI FIN PARA a  t[4-m] t[4-m]  t[m] t[m]  a PARA i  0 HASTA 4 escribir (t[i]) FIN PARA FIN PROGRAMA Datos de entrada: -4. 2. 1. 2. 9. 3 y 2.} } 10. 0. b: TABLA [100] ENTEROS COMIENZO n  10 PARA i0 HASTA n-1 leer (a[i]) FIN PARA PARA i  0 HASTA n/2 b[i]  a[n-1-i] b[n-1-i]  a[i] FIN PARA PARA i  0 HASTA n-1 SI i mod 2 = 0 escribir (a[i]) SINO escribir (b[i]) FIN SI FIN PARA FIN PROGRAMA Datos de entrada: 6. Ejercicios de Programación en Java 108 . Los siguientes programas piden una serie de datos y tras procesarlos ofrecen unos resultados por pantalla. m.

y tras ésta. Debemos destacar que este algoritmo no tiene sentido ni hace nada en concreto incluso con otros datos de entrada el algoritmo puede dar un error. i++) System. for (i=0.out. i<=4. // podemos sustituir la lectura de datos por la siguiente línea: //int t[] = {-4. } } Ejercicios de Programación en Java 109 . a. i<=4. a = t[4-m]. al utilizar datos como índices de tablas sin las pertinentes comprobaciones.package bol05ej10. t[m] = a. t[4-m] = t[m]. m = 0. for (i=0. 1. 2}. // // // // // // la idea de este ejercicio es hacer una traza de forma manual.entero(). 0. escribir el código equivalente para comprobar el resultado. int t = new int [5]. m. i<=4. for (i=0. i++) if (t[i] > m ) m = t[i]. public class Main { public static void main(String[] args) { int i.println (t[i]). 3. i++) t[i] = Entrada.

i. else System. b[n-1-i] = a[i]. y tras ésta. escribir el código equivalente para comprobar el resultado.package bol05ej10. i<=n. 2. 2. i<n. i++) if (i % 2 == 0) System. n = 10. public class Main { public static void main(String[] args) { int n. */ int a[] = new int [10].println (b[i]). 8. i++) { b[i] = a[n-1-i]. for (i=0. /* la idea de este ejercicio es hacer una traza de forma manual. i<=n/2. int b[] = new int [10]. } for (i=0. 9. Debemos destacar que este algoritmo no tiene sentido ni hace nada en concreto incluso con otros datos de entrada el algoritmo puede dar un error. 6. i++) a[i] = Entrada.println (a[i]). for (i=0. 2.out. al utilizar datos como índices de tablas sin las pertinentes comprobaciones. // podemos sustituir la declaración de a y la lectura de datos por la siguiente línea: // int a[] = {6. 1}. } } Ejercicios de Programación en Java 110 .entero(). 8. 5.out.

M1=2. El número de plazas disponible es de 10. Ejercicios de Programación en Java 111 . int part[][]=new int[TAM][4]. // TAM: Número máximo de participantes // D: número de dorsal // M0. hasta que se seleccione la opción 4. Si se selecciona 1. boolean d_rep. Sus datos se irán introduciendo en el mismo orden que vayan inscribiéndose los atletas. se debe mostrar un listado por número de dorsal. 2001. que terminará el programa.aux. mejor marca del 2001 y mejor marca del 2000. Mostrar listado por marcas. se debe mostrar de nuevo el menú inicial. package bol05ej11.dorsal.M2=3. M1.numc. numc=0.i. Tras procesar cada opción. opc=0. Si se elige la opción 2. Diseñar el programa que muestre las siguientes opciones: 1234Inscribir un participante.M0=1.11-Se pretende realizar un programa para gestionar la lista de participaciones en una competición de salto de longitud. M2: Marca del 2000. public class Main { public static void main(String[] args) { final int TAM=10. Mostrar listado de datos. Finalizar el programa.inter. se introducirán los datos de uno de los participantes: Nombre. mejor marca del 2002. La opción 3 mostrará un listado ordenado por la marca del 2002. y 2002 int opc. de mayor a menor.D=0.

out. System.do{ System.println("Por favor intente de nuevo").out.out.out.println("Listado completo"). introduzca una opción: "). switch(opc){ case 1: if(numc==20) System.out.out. System. i=0. Ejercicios de Programación en Java 112 .entero(). Mostrar listado por marcas").print("Introduzca dorsal: ").println(). while(i<numc && d_rep==false){ if(part[i][D]==dorsal){ System. System.out.println("--------------------------------"). dorsal=Entrada.entero()."). Salir").entero().println("3. } }while(d_rep==true).out.print("Dorsal registrado.print("Por favor. opc=Entrada.out. if(d_rep==false){ part[numc][D]=dorsal. System. System. System. System. else{ do{ System. part[numc][M0]=Entrada.out.out. } i++. Mostrar listado por datos").out.println("1. d_rep=false.println("--------------------------------").println("4.out. System. System. Inscribir participantes").print("Introduzca marca del 2000: "). d_rep=true. System.println("2.println().out.

k++){ aux=part[j][k]. for (int k=0. part[j][k]=part[j+1][k]. System. System.out.print(part[j][k]+" ").out.j++){ if(part[j][D]>part[j+1][D]){ for (int k=0. controlado por intercambio inter=true. part[numc][M1]=Entrada.marcas").print("Introduzca marca del 2001: "). } } break.System.out.j<numc. } inter=true. case 2: // método de ordenación por burbuja.out. case 3: Ejercicios de Programación en Java 113 . } } } System. part[numc][M2]=Entrada.k++){ System.println().entero(). for (int j=0.println().print("Introduzca marca del 2002: "). for (int j=0. while(inter==true){ inter=false. part[j+1][k]=aux.out.out.println ("dorsal .out. System.j<=numc-1-1.k<4.println("LISTADO DE DATOS.k<4. } } break.SEGUN DORSAL:").entero().j++){ System. numc++.

part[j][k]=part[j+1][k]. while(inter==true){ inter=false.j<=numc-1-1.k<4. System.k++){ System.j<numc.out. for (int j=0.k<4. part[j+1][k]=aux.out. } } break.println(). for (int k=0.marcas"). } } } System.out.j++){ if(part[j][M2]>part[j+1][M2]){ for (int k=0. } } inter=true.println ("dorsal .println("LISTADO POR MARCAS :").k++){ aux=part[j][k]. } inter=true.} } while(opc!=4). Ejercicios de Programación en Java 114 .print(part[j][k]+" ").out. for (int j=0.j++){ System.

out. mostrar(num).out. a la que se le pase como parámetro un número N. el mensaje: “Módulo ejecutándose” package bol06ej01. y muestre por pantalla N veces.out.Boletín 6 Funciones 1.i++){ System.entero(). num=Entrada. System.println("---------------------------").i<num. System.print("Introduzca un numero: ").println("---------------------------"). } } static void mostrar(int num){ for (int i=0. public class Main { public static void main(String[] args) { int num. System.out.println("Módulo ejecutándose"). } } Ejercicios de Programación en Java 115 . Realizar una función.

y que calcule el máximo.entero(). int a. // suponemos que los tres números serán distintos public static void main(String[] args) { int max. b=Entrada. Diseñar una función que tenga como parámetros dos números.print("Introduzca un numero: "). max =maximo (a.println("El número mayor es: " +max).print("Introduzca otro numero: "). System. public class Main { static int maximo(int a.out.out. } return(max). package bol06ej02.out.b. System.entero(). a=Entrada.2. System. if(a>b) max=a. else max=b. } } Ejercicios de Programación en Java 116 . int b){ int max. b).

Ídem una versión que calcule el máximo de 3 números. int c){ int max.entero(). entonces a es el máximo max=a. package bol06ej03.out. a=Entrada. System. System. public class Main { static int maximo(int a. Ejercicios de Programación en Java 117 . } return(max).print("Introduzca un numero: ").entero(). else if(b>a && b>c) // si b es el mayor de todos. int b. int a. if(a>b && a>c) // si a es mayor que b y c. c. será c max=c.print("Introduzca el último: ").out.out. entonces b es el máximo max=b. else // si el máximo no es a ni b.3. public static void main(String[] args) { int max.print("Introduzca otro numero: ").entero(). b=Entrada. b. System. c=Entrada.

int t[].length. b. c). entonces t[i] es el nuevo máximo max=t[i]. Ídem una versión que calcule el máximo de una tabla de n elementos. return(max). } } 4. for (int i = 0. i++) if (t[i]>max) // si t[i] es mayor que max.println("").println("El número mayor es: " +max). i < t.System. package bol06ej04. max =maximo (a. max = t[0].out. System. public class Main { /** * Esto funciona solo para tablas con un tamaño mínimo de 1 * */ static int maximo(int t[]){ int max.out. Ejercicios de Programación en Java 118 . } public static void main(String[] args) { int max.

public class Main { static void mostrar(int a.t=new int [6].. i < t.random()*100+1). i++) System.out. max = maximo (t).println("\nEl número mayor es: " +max). } else{ // en este caso b será el mayor Ejercicios de Programación en Java 119 . mayor=a. Función a la que se le pasan dos enteros y muestra todos los números comprendidos entre ellos. i < t. i++) // llenamos la tabla con valores aleatorios entre 1 y 100 t[i]=(int)(Math.out. menor.out.println("Los valores son:"). inclusive. // desconocemos el orden en el que vienen a y b. menor. for (int i = 0.length.length.print(t[i] +" "). menor=b.int b){ int mayor. System. } } 5. // Lo que haremos es poner los valores correctos en mayor. Se podría utilizar la función maximo() implementada anteriormente. for (int i = 0. if(a>b){ // a es el mayor. package bo0l6ej05. System.

print("Introduzca segundo numero: "). Función que muestra en pantalla el doble del valor que se le pasa como parámetro.entero().out. } public static void main(String[] args) { int a. } } 6.out.entero(). mostrar(a.b).b.print("Introduzca primer numero: ").println().i++) System. System. menor=a.out. public class Main { static void doble(int num) { Ejercicios de Programación en Java 120 .i<=mayor. System. } for (int i=menor.mayor=b.out. System.print(i+" "). b=Entrada. package bol06ej06. a=Entrada.

double altura. // calculamos el doble de num } System.entero(). Realizar una función que calcule (muestre en pantalla) el área o el volumen de un cilindro. char opcion){ double volumen.PI*radio*radio*altura.area.out. num=Entrada. // radio*radio es el radio al cuadrado System.println("El volumen es de: " +volumen). public static void main(String[] args) { int num.int doble.out. doble(num). Para distinguir un caso de otro se le pasará el carácter 'a' (para área) o 'v' (para el volumen). Ejercicios de Programación en Java 121 . package bol06ej07. según se especifique.print("Introduzca un número: "). public class Main { static void area_o_volumen_cilindro(double radio.println("El doble es: " +doble). switch (opcion) { case 'v': volumen =Math. System.out. doble=2*num. } } 7. Además hemos de pasarle a la función el radio y la altura.

alt.println("").out. area_o_volumen_cilindro(radio. System.print("Introduzca radio: ").print("Que desea calcular (a/v): ").tipo_calculo).out. Ídem que devuelva una tabla con el área y el volumen.out.println("El área es de: "+area).alt.real(). alt=Entrada. radio=Entrada. public static void main(String[] args) { double radio. System.println("Indicador del cálculo erróneo"). default: System. char tipo_calculo. System. System.real(). } } 8.} } break. break. tipo_calculo =Entrada.out. System. case 'a': area = 2*Math.PI*radio*radio.out.print("Introduzca altura: ").out. public class Main { Ejercicios de Programación en Java 122 . package bol06ej08.PI*radio*altura + 2*Math.caracter().

out. System. } public static void main(String[] args) { double radio. // [0] para el volumen y [1] para el área calculo[0] =Math.PI*radio*altura + 2*Math. calculo = new double [2].alt.print("Introduzca altura: "). return (calculo).real().out. double resultado[].real().PI*radio*radio*altura.out.PI*radio*radio.area. // radio*radio es el radio al cuadrado calculo[1] =2*Math. } } Ejercicios de Programación en Java 123 . ya que apunta a // la tabla creada dentro de la función System.static double[] area_y_volumen_cilindro(double radio.out. //esta tabla no necesita new. System. System. resultado =area_y_volumen_cilindro(radio.print("Introduzca radio: "). radio=Entrada. double calculo[]. alt=Entrada.println("El área es de: " +resultado[1]). // resultado hace referencia a la tabla devuelta // por la función.alt).println("El volumen es de: " +resultado[0]). double altura) { double volumen.

// suponemos que el número es primo // // // // // // este algoritmo se puede mejorar sabiendo que si un número no es divisible entre 2 y su raíz cuadrada.9. Módulo al que se le pasa un número entero y devuelve el número de divisores primos que tiene. // si hemos entrado aquí significa que el número no es primo i++. entonces ya no será divisible por ningún otro números -> será primo con esta mejora podemos ahorrar muchas vueltas del while para números grandes i=2. } } return(primo). int i. public class Main { // la función es_primo indica si el número pasado es o no primo // recordamos que un número primo es solo divisible por el mismo y 1 static boolean es_primo(int num) { boolean primo. package bol06ej09. Ejercicios de Programación en Java 124 . while(i<num && primo==true) // en realidad bastaría probar hasta la raíz cuadrada de num { if( num %i == 0) // si es divisible primo=false. primo=true.

div. for (int i=2. Ejercicios de Programación en Java 125 .// // // // // // esta función devuelve el número de divisores primos del número pasado como parámetro. un ejemplo: los divisores de 24 son: 2 y 3 aunque 4 y 6 también dividen a 24.entero(). } } System. al no ser primos por lo que 24 tiene tres divisores primos: el 1. System. // siempre habrá un divisor seguro.out. num=Entrada. // incrementamos el número de divisores primos return(cont). cont=1. el 1.i<=num.print("Introduce numero: ").println("Tiene " +div+ " divisores"). static int num_divisores (int num){ int cont. el 2 y el 3. no se consideran divisores primos. div=num_divisores(num).i++) if(es_primo (i) && num %i == 0) // si i es primo y divide a num cont++.out. } public static void main(String[] args) { int num.

package bol06ej10. primo=true.10. Ejercicios de Programación en Java 126 . // si hemos entrado aquí significa que el número no es primo i++. // suponemos que el número es primo // // // // // // este algoritmo se puede mejorar sabiendo que si un número no es divisible entre 2 y su raíz cuadrada. int i. } } return(primo). public class Main { // la función es_primo indica si el número pasado es o no primo // recordamos que un número primo es solo divisible por el mismo y 1 static boolean es_primo(int num) { boolean primo.Ídem diseñar una función que devuelve una tabla con los divisores. entonces ya no será divisible por ningún otro números -> será primo con esta mejora podemos ahorrar muchas vueltas del while para números grandes i=2. while(i<num && primo==true) { if( num %i == 0) // si es divisible primo=false.

i<=num. num_div = num_divisores (num). cont=1. el 2 y el 3) static int num_divisores(int num){ int cont.// // // // // // // esta función me devuelve el número de divisores del número los divisores a tener en cuenta solo son aquellos que son primos un ejemplo: los divisores de 24 son: 2 y 3 aunque 4 y 6 también dividen a 24.i++) if(es_primo (i) && num %i == 0) // si i es primo y divide a num Ejercicios de Programación en Java 127 . for (int i=1. // tabla donde guardaremos los divisores. int div[]. no se consideran divisores. el 1. div =new int[num_div]. // incrementamos el número de divisores return(cont). for (int i=2.i++) if(es_primo (i) && num %i == 0) // si i es primo y divide a num cont++. int num_div. // siempre habrá un divisor seguro.i<=num. al no ser primos por lo que 24 tiene tres divisores (el 1. // número de divisores primos que tiene num. } static int [] divisores(int num){ int cont=0.

i++) System. for (int i = 0.entero(). System.print("Introduce numero: "). divisores[].out.out.println(""). Ejercicios de Programación en Java 128 . i < divisores. // incrementamos el número de divisores public static void main(String[] args) { int num.out.{ } return(div). cont++.out.Escribir una función que calcule el máximo común divisor de dos números. public class Main { // // // // el máximo común divisor de dos números es el número más grande que es capaz de dividir a ambos números Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja". divisores =divisores(num). } } 11.print(divisores[i] + " "). num=Entrada. } div[cont] =i.length. package bol06ej11. System. System.println("Los divisores de " + num + " son:").

int b) { int mcd=1. } return(min). static int max_comun_divisor (int a. mcd. int b){ int min. b) // y quedarnos con el mayor. min = minimo (a. else min=a. for (int i=2.b). public static void main(String[] args) { int a. // i será el nuevo mcd. int min. el 1. mcd=1. que divide a y b. b. // existe un mcd seguro. } static int minimo(int a.i++) if( a%i==0 && b%i==0) // si i divide a "a" y "b" mcd=i.i<=min. if(a>b) min=b. Ejercicios de Programación en Java 129 .// La idea es dividir por todos los números desde 1 hasta mínimo(a. return(mcd).

System. } } System. int c) { int mcd=1. int min.out.print("Introduce numero: "). b.println(""). 12. // para no implementar la función mínimo para tres números Ejercicios de Programación en Java 130 .out. System.entero(). package bol06ej12.Ídem con tres números. b=Entrada. c) y quedarnos con el mayor.System.out. mcd = max_comun_divisor (a.println("El mcd de "+a+" y "+b+" es: "+mcd). public class Main { // // // // // // el máximo común divisor de tres números es el número más grande que es capaz de dividir a todos números Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja".print("Introduce otro: ").out.entero(). La idea es dividir por todos los números desde 1 hasta mínimo(a. a=Entrada. static int max_comun_divisor (int a. b). int b.

print("Introduce a: ").entero(). min = minimo (a. // existe un mcd seguro. System.i<=min. System.print("Introduce c: ").minimo(b.// utilizaremos la función con solo dos parámetros. a=Entrada. b=Entrada. else min=a. Ejercicios de Programación en Java 131 .c . el 1.out. if(a>b) min=b.entero(). static int minimo(int a. a 'b' y a 'c' mcd=i. return(min). que divide a y b.i++) if( a%i==0 && b%i==0 && c%i==0) // si i divide a 'a'. // i será el nuevo mcd. for (int i=2. } public static void main(String[] args) { int a. System.c)). b. mcd=1.print("Introduce b: "). int b){ int min. } return(mcd).out.out. mcd.

entero(). "+b+".println("El mcd de ("+a+". System.c=Entrada. */ static int max_comun_divisor (int t[]) { int mcd=1.Ídem con una tabla. La idea es dividir por todos los números desde 1 hasta mínimo(a. int min.println(""). } } 13. b. boolean divide_a_todos. // una bandera para saber si un número divide // a todos los elementos de la tabla Ejercicios de Programación en Java 132 .out. package bol06ej13. c). public class Main { /* el máximo común divisor es el número más grande que es capaz de dividir a todos los números Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja". b. System. c) y quedarnos con el mayor. mcd = max_comun_divisor (a. "+c+") es: "+mcd).out.

if(a>b) min=b. // al terminar el for. for (int i=2.k++) if( t[k]%i!=0) // si i divide a t[i] divide_a_todos=false. static int minimo(int a. int b){ int min.i<=min. // entonces i es el nuevo mcd } } return(mcd). else min=a. // existe un mcd seguro. return(min). el 1. mcd=1. Ejercicios de Programación en Java 133 .i++) { divide_a_todos =true.length. min debe tener el valor mínimo de toda la tabla.length. for (int k=0. i++) min = minimo (min. i < t. // utilizaremos la función con solo dos parámetros. // entonces la i no divide a todos los elementos de t.k<t. if (divide_a_todos == true) // i es capaz de dividir a todos los elementos de t mcd =i.// esto funciona para tabla con al menos un valor min = t[0].t[i]). for (int i = 0.

out. mcd = max_comun_divisor (t). System.length. t = new int [4]. package bol06ej14.out. for (int i = 0. // llenamos t con números aleatorios entre 1 y 1000 System. i < t.out. System.println("").length. public class Main { Ejercicios de Programación en Java 134 .out. for (int i = 0.} public static void main(String[] args) { int t[].Escribir una función que calcule el mínimo común múltiplo de dos números. mcd. } } 14. i++) t[i] = (int)(Math.random()*1000+1). i < t.println("El mcd es: " +mcd). i++) System.println("Los números son: ").print(t[i] +" ").

mcm=max*i. max = maximo (a. int b){ int max. int max. // el nuevo mcm sera el mayor por i } return(mcm). // en principio el mcm es el mayor de los dos números while (mcm%a!=0 || mcm%b!=0) // si el mcm no es divisible por a y b { i++. es el número más pequeño que es divisible por a y b./* el mínimo común múltiplo de a y b. hasta que el número resultante sea divisible por el menor de a y b */ static int min_comun_multiplo (int a. int b) { int mcm. mcm =max. int i. if(a>b) max=a. i=1. b). static int maximo (int a. La idea es elegir el mayor de a y b. } Ejercicios de Programación en Java 135 . y multiplicarlo por i. Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja".

} } package bol06ej14. System. public class Main { // aprovechando que tenemos hecha la función max_comun_divisor. System. System.entero().println(""). mcm. } public static void main(String[] args) { int a. b=Entrada.print ("Introduce b: ").out.out. b. return(max). mcm = min_comun_multiplo (a. calcularemos Ejercicios de Programación en Java 136 .print ("Introduce a: ").entero(). System. a=Entrada.else max=b.out.out.b).println("El mcm es: " +mcm).

for (int i=2. } static int minimo(int a. int b) { int mcm.b). int min. que divide a y b. return(mcd).// el mínimo común múltiplo de dos números como la multiplicación de ambos // divido por el mcd static int min_comun_multiplo (int a. el 1. if(a>b) min=b. else Ejercicios de Programación en Java 137 .b). mcm = a*b / max_comun_divisor (a. } static int max_comun_divisor (int a. min = minimo (a. int b) { int mcd=1.i++) if( a%i==0 && b%i==0) // si i divide a "a" y "b" mcd=i. // existe un mcd seguro. int b){ int min. return (mcm). mcd=1.i<=min. // i será el nuevo mcd.

System. b=Entrada.out.print("Introduce a: "). b. mcm. es el número más pequeño que // es divisible por a.print("Introduce b: "). } return(min).min=a. b y c.out. System. System. b).out.Ídem con tres números. System. Ejercicios de Programación en Java 138 . package bol06ej15.println("El mcm de "+a+" y "+b+" es: "+mcm). b y c.entero().entero().out. public static void main(String[] args) { int a. mcm = min_comun_multiplo (a. public class Main { // el mínimo común múltiplo de a.println(""). a=Entrada. } } 15.

int c) { int mcm=1. La idea es elegir el mayor de ellos. i=1.. int max. max = maximo (a. mcm =max. static int maximo (int a. mcm=max*i.// // // // Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja". // el nuevo mcm sera el mayor por i } return(mcm). } Ejercicios de Programación en Java 139 . y multiplicarlo por i (1. int i. hasta que el número resultante sea divisible por todos static int min_comun_multiplo (int a. int b. if(a>b) max=a. maximo(b. // en principio el mcm es el mayor de los dos números while (mcm%a!=0 || mcm%b!=0 || mcm%c!=0) // mientras el mcm no sea divisible por todos { i++.c)). else max=b.). int b){ int max.

entero().println(""). System.out.entero().out. b. mcm = min_comun_multiplo (a. System. System. c. es el número más pequeño que Ejercicios de Programación en Java 140 .out.return(max).print ("Introduce c: "). c).out. public class Main { // el mínimo común múltiplo de a y b. System. System. } public static void main(String[] args) { int a. a=Entrada.print ("Introduce b: "). } } package bol06ej15.entero(). b. mcm.println("El mcm es: " +mcm). c=Entrada. b=Entrada.print ("Introduce a: ").out.

else Ejercicios de Programación en Java 141 . int max. mcm =max.// // // // // es divisible por a y b. hasta que el número resultante sea divisible por el menor(a. max = maximo (a. mcm=max*i. if(a>b) max=a. b). } static int maximo (int a. y multiplicarlo por i. La idea es elegir el mayor de a y b. // el nuevo mcm sera el mayor por i } return(mcm). // en principio el mcm es el mayor de los dos números while (mcm%a!=0 || mcm%b!=0) // si el mcm no es divisible por a y b { i++. Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja". int i. int b){ int max. int b) { int mcm=1. i=1.b) static int min_comun_multiplo (int a.

public static void main(String[] args) { int a. mcm = min_comun_multiplo (mcm. b=Entrada. } } Ejercicios de Programación en Java 142 .max=b. b.out.out. a=Entrada.out.print ("Introduce c: ").print ("Introduce a: "). b).entero().out. System.println("").println("El mcm es: " +mcm). c.entero().entero(). // reutilizamos la función mcm pensada para dos números y aprovechamos // la propiedad conmutativa del mcm. System. System. System. mcm.print ("Introduce b: "). mcm = min_comun_multiplo (a. System. c). c=Entrada. } return(max).out.

public class Main { // // // // // // el mínimo común múltiplo de a y b. package bol06ej16. hasta que el número resultante sea divisible por ambos static int min_comun_multiplo (int a. // el nuevo mcm sera el mayor por i } return(mcm). b). int b) { int mcm=1. La idea es elegir el mayor de ellos. int i. int max.). mcm=max*i. Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja". // en principio el mcm es el mayor de los dos números while (mcm%a!=0 || mcm%b!=0) // mientras el mcm no sea divisible por todos { i++. i=1.16.. y multiplicarlo por i (1. mcm =max. Ejercicios de Programación en Java 143 . max = maximo (a. es el número más pequeño que es divisible por ambos.Ídem con una tabla.

random()*100+1). for (int i = 0. i++) t[i]=(int)(Math.length.out. public static void main(String[] args) { int t[]. } return(max). i++) mcm = min_comun_multiplo (t[i]. for (int i = 0. i < t.out.. for (int i = 0. System. i < t. mcm.out.mcm). mcm = t[0].} static int maximo (int a. System. t = new int[4]. i++) System.length.println("Los datos son:"). if(a>b) max=a. Ejercicios de Programación en Java 144 .print(t[i]+" "). i < t. else max=b. int b){ int max.println("").length.

while(i<num && primo==true) { Ejercicios de Programación en Java 145 . } } 17.println("El mcm es: " +mcm). public class Main { // la función es_primo indica si el número pasado es o no primo // recordamos que un número primo es solo divisible por el mismo y 1 static boolean es_primo(int num) { boolean primo.Escriba una función que decida si dos números enteros positivos son amigos. primo=true.System. // suponemos que el número es primo // // // // // // este algoritmo se puede mejorar sabiendo que si un número no es divisible entre 2 y su raíz cuadrada. package bol06ej17. entonces ya no será divisible por ningún otro números -> será primo con esta mejora podemos ahorrar muchas vueltas del while para números grandes i=2.out. si la suma de sus divisores (distintos de ellos mismos) son iguales. Dos números son amigos. int i.

// // // // // esta función me devuelve la suma de los divisores propios. 12 static int suma_divisores_propios (int num){ int suma. Es decir cualquier número que divida a num en el rango 1.num-1 un ejemplo: los divisores propios de 24 son: 1. for (int i=1. } } return(primo). 3.i++) // al ser hasta i<num no tenemos en cuenta el propio num if(num %i == 0) // si i divide a num suma+=i. 2.. Ejercicios de Programación en Java 146 . 4. // si hemos entrado aquí significa que el número no es primo i++. } public static void main(String[] args) { int a. // acumulamos i return(suma). 8.i<num.b. suma=0.if( num %i == 0) // si es divisible primo=false. 6.

} } 18.out.. primo=true.\nLa siguiente vez prueba con 220.out. i=2. package bol06ej18.out. // si llego aquí es que num es divisible-> no es primo Ejercicios de Programación en Java 147 . if (a==suma_divisores_propios (b) && b==suma_divisores_propios (a)) System. while(i<num && primo==true) { if(num%i==0) // si num es divisible por i primo=false. else System.entero().Diseña una función (en adelante DUF) que decida si un número es primo.. b=Entrada.entero(). System. public class Main { static boolean es_primo(int num){ boolean primo.out.System.print("Introduce b: ").println(a+" y "+b+" no son amigos.").").print("Introduce a: "). a=Entrada.println(a+ " y " +b+ " son amigos. int i. 284.

System.out. } } return(primo). res=1. package bol06ej19. ya que iremos multiplicando if(n==0) // por definición cualquier número elevado a 0 es 1 Ejercicios de Programación en Java 148 .println("Es primo").entero(). num=Entrada.out. public static void main(String[] args) { boolean res.print("Introduce numero: "). int num. int n){ int res. } } 19.out.println("No es primo").i++.DUF que calcule an. public class Main { static int a_elevado_n(int a. // el resultado se inicializa a 1. else System. if(es_primo(num)) System.

for (int i=1. public class Main { static void binario(int num) { Ejercicios de Programación en Java 149 .entero(). public static void main(String[] args) { int num.res.else res=1.out. System.entero().print("Introduzca su exponente: ").out. } return(res). } } 20. package bol06ej20. num=Entrada.out. res=a_elevado_n (num.DUF que muestre en binario un número entre 0 y 255.exp).println(num + " elevado a " + exp +" = " +res). System.print("Introduzca base: "). System.i<=n.i++) res=res*a.exp. exp=Entrada.

cont++.int t[].out. num =num/2. int cont. else { cont =0.print(t[i]).255)"). Ejercicios de Programación en Java 150 . cont++.println("Número fuera de rango (0.out.out.out.i>=0. if (num<0 || 255<num) System. // en t guardaremos los dígitos binarios // un número en binario entre 0 y 255 tiene 8 bits t = new int [8]. } System. // como t tiene los dígitos en orden inverso for (int i=cont-1.println("En binario: "). } // iremos dividiendo y cogiendo el resto while(num!=0) { t[cont] =num%2. if (num==0) { t[cont]=0. } System..i--) System.println("").

out.print("Introduzca un numero (0. 21.print("Introduzca un numero: ").255): "). public class Main { static int suma_n_impares (int n) { int suma=0. num=Entrada. System. // así calculamos el i-ésimo impar return (suma). i <=n . } public static void main(String[] args) { int n. package bol06ej21. i++) suma += 2*i-1. Ejercicios de Programación en Java 151 .. System. } } binario(num). Escriba una función que sume los n primeros números impares.out. for (int i =1.} public static void main(String[] args) { int num.entero().

n =Entrada. } } // el for irá 1. for (int i =1.out. 3.. i <= 2*n-1 . } public static void main(String[] args) { int n. public class Main { static int suma_n_impares (int n) { int suma=0.out.print("Introduzca un numero: ").n =Entrada.. i+=2) suma += i.entero(). // hasta 2*n-1 (el n-ésimo impar) Ejercicios de Programación en Java 152 . 5. System.. } } package bol06ej21. .println("La suma de los " +n+ " primeros impares es: " +suma_n_impares (n)).println("La suma de los " +n+ " primeros impares es: " +suma_n_impares (n)).entero(). return (suma). System.out. System.

package bol06ej22.. public class Main { static void informacion_angulo (double n) { // como las funciones que calculan el seno. angulo =Entrada. Dado el valor de un ángulo. coseno y tangente. } public static void main(String[] args) { double angulo.360): ").sin(n)).println("coseno: " + Math. hemos de pasar n de grados a radianes n = Math. } } 23.22. Diseñar una función que calcule la distancia euclídea de dos puntos. // otra forma sería n = Math.out.real().out.PI/180*n. System. coseno y tangente trabajan en // radianes. Ejercicios de Programación en Java 153 . System.tan(n)).out. System. Escribir una función que muestre en pantalla los datos anteriores.println("tangente: " + Math.toRadians(n).println("seno: " + Math.print("Introduzca un ángulo (0. System. informacion_angulo (angulo).cos(n)).out. sería interesante saber su seno.

out.sqrt( Math. Ejercicios de Programación en Java 154 . int y1.print("y: ").entero(). y2.y2). y1 = Entrada. l =distancia_euclidea (x1. System.out.pow (x1-x2. y1. System. 2) + Math.print("y: ").print("x: "). x1 = Entrada. int x2.entero(). 2))).println("\nPunto 2").println("Punto 1"). public class Main { static double distancia_euclidea (int x1.pow (y1-y2. System. System.out.entero(). int y2) { // aquí no hay más que tirar de la fórmula de la distancia euclídea // y desempolvarla de los apuntes return (Math. // distancia euclídea System. // el otro punto double l.print("x: ").y1. x2.out. y2 = Entrada.out. } public static void main(String[] args) { int x1. x2 = Entrada.package bol06ej23.entero(). System.out. // primer punto int x2.

public class Main { static int rellena_tabla_pares(int t[]){ int i. impares_ignorados = 0. } } 24. impares_ignorados. num = Entrada.entero(). También hay que devolver la cantidad de impares ignorados. } Ejercicios de Programación en Java 155 . i = 0.System. // lo guardamos i++. if(num %2 == 0) // si es par { t[i] = num.num.out.out. } else impares_ignorados++.print("Introduzca número: ").length) { // terminaremos de rellenar la tabla cuando el número // de pares sea igual que el tamaño de la tabla System. while (i<t. Se leerá por teclado una serie de números: guardaremos solo los pares e ignoraremos los impares.println("\nDistancia euclídea: " +l). DUF a la que se le pasa como parámetro una tabla que debe rellenar. package bol06ej24.

out. igno = rellena_tabla_pares(t).t[].println("La tabla queda: "). public class Main { static boolean busca(int t[].print(t[i]+ " System.println("El numero de impares ignorados es de: " +igno).out. for(int i=0.out. package bol06ej25. 25. DUF a la que se le pasa una tabla de enteros y un número. Debemos buscar el número en la tabla e indicar si se encuentra o no.out.int n) { int i. } } "). Ejercicios de Programación en Java 156 .println(""). t = new int[5].i++) System.return(impares_ignorados). } public static void main(String[] args) { int igno. System. System.i<5.

i++) System. Ejercicios de Programación en Java 157 . System. num=Entrada. // es un ejemplo de posibles valores int num. 12.out. puede ser por dos motivos: // .entero(). // cuando termina el mientras.length && t[i]!=n) // si no es t[i]. 38. } public static void main(String[] args) { int a[]={1. 11}. i=0.out. while (i<t.out. for (int i=0. ya que si i está fuera de rango da un error esta =true. 5. paso al siguiente // con cuidado de no salirme de la tabla i++.boolean esta.println("La tabla es: ").length) // si no llego al final de la tabla es por que lo he encontrado // t[i] == num no es válido. System. else esta =false. return(esta).i<5.println(a[i]).que he buscado por toda la tabla sin encontrarlo y al final me salgo de la tabla // .o que lo he encontrado if (i<t.print("\introduce numero a buscar: "). boolean esta.

} } 26. public class Main { static boolean busca(int t[].println("EL número está"). boolean esta. int tam) { int i. while (i<tam && t[i]!=n) // si no es t[i]. i=0. if (esta) System. Igual que el ejercicio anterior. y el número de elementos se pasa también como parámetro. package bol06ej26.int n. pero suponiendo que la tabla no está siempre llena.out.que he buscado por toda la tabla sin encontrarlo y al final me salgo de la tabla // . else System. paso al siguiente // con cuidado de no salirme de la tabla i++.esta=busca(a.o que lo he encontrado Ejercicios de Programación en Java 158 .out. // cuando termina el mientras. puede ser por dos motivos: // .println("El número no está").num).

println(a[i]). 38. 5. ya que si i está fuera de rango // t[i] es basura esta =true.entero(). System. tam = 5. a[0] a[1] a[2] a[3] a[4] = = = = = 1. System. num.out. tam). num=Entrada. int tam.i++) System. for (int i=0. else esta =false. esta=busca(a. boolean esta.if (i<tam) // si no llego al final de la tabla es por que lo he encontrado // t[i] == num no es válido. Ejercicios de Programación en Java 159 . return(esta). int num. } public static void main(String[] args) { int a[]= new int [20]. 11.out.i<tam.out. 12.println("La tabla es: ").print("\nIntroduce numero a buscar: ").

restar. 'r'. el número de elementos útiles y que operación se desea realizar: sumar. case 'r': for(i=0.i++) result[i] = a[i] + b[i]. int b[]. public class Main { static int[] opera_tabla(int a[]. a la que se le pasa dos tablas.i++) result[i] = a[i] . package bol06ej27. multiplicar o dividir (mediante un carácter: 's'. } } 27.if (esta) System. int nelem){ int i. result = new int[nelem]. break.println("El número no está"). switch(opc) { case 's': for(i=0. result[].out. break. else System. char opc. La función debe devolver una tabla con los resultados. 'd').out. Ejercicios de Programación en Java 160 .b[i]. 'm'.println("El número está").i<=nelem-1.Diseñar la función opera_tabla.i<=nelem-1.

tabla2 = new int[15]. tabla2[]. resultado[].i<num_datos_utiles. public static void main(String[] args) { int num_datos_utiles.i++) result[i] =a[i] * b[i]. =-3.case 'm': for(i=0.i<=nelem-1. =6. =2. char operacion. case 'd': for(i=0. num_datos_utiles =4. System. =7. tabla1 = new int[10].i<=nelem-1. break. int tabla1[]. =17.println("tabla1 tabla2"). tabla1[0] tabla1[1] tabla1[2] tabla1[3] tabla2[0] tabla2[1] tabla2[2] tabla2[3] =4.out. for(int i=0. break.i++) Ejercicios de Programación en Java 161 .i++) result[i] = a[i] / b[i]. =3. =7. } } return (result).

j<tam-i-1. m.out.length. package bol06ej28. // los intercambiamos Ejercicios de Programación en Java 162 . resultado =opera_tabla (tabla1. // ordenaremos utilizando la ordenación por intercambio for (int i=0. r.caracter().i<tam-1-1. int aux.i++){ for (int j=0.i<num_datos_utiles.System. num_datos_utiles). DUF que ordene la tabla que se le pasa.println (resultado[i]).j++){ if(a[j]>a[j+1]) // si el elemento j es mayor que el j+1 { aux=a[j]. operacion.out.println("El resultado de la operación es:").i++) System.out. operacion = Entrada. tabla2.println("Operación (s.println (tabla1[i]+ " " +tabla2[i]).out. public class Main { static void ordenar(int a[]){ int tam=a. for(int i=0. } } 28. d): "). System. System.

println("\n\nTabla ordenada"). mostrar_tabla(t).length. for (int i=0. } System. } } } } static void mostrar_tabla(int t[]){ int tam=t. } } Ejercicios de Programación en Java 163 .print(t[i] + " } ").out. } public static void main(String[] args) { int t[]=new int[8]. System.out. mostrar_tabla(t).a[j]=a[j+1].i<tam.i++){ System.i<8.random()*100)+1. ordenar(t). a[j+1]=aux. for (int i=0.out.println("Tabla aleatoria").i++){ t[i]=(int)(Math.

if(p<premiado. int premiado[]){ int aciertos. La primera con los 6 números de una apuesta de la primitiva. que debe ser 6 */ static int primitiva(int apuesta[].29. int p..length) aciertos++. y la segunda con los 6 números ganadores. // utilizaremos a como índice de la tabla apuesta // y p para recorrer premiado aciertos=0. pero con el while evitamos vueltas innecesarias while(p<premiado. // para cada número de la apuesta recorremos premiado // se podría hacer con un for.a<apuesta. La función debe devolver el número de aciertos.comprobar que los números están en el rango 1. int a. } // si p indica un elemento de la tabla // tenemos un acierto más Ejercicios de Programación en Java 164 . for (a=0.length && apuesta[a]!=premiado[p]) p++. public class Main { /* algunas mejoras propuestas para el alumno son: * .comprobar que no hay números repetidos en las tablas * .length.49 * .mirar el tamaño de las tablas. package bol06ej29.a++) // recorremos la tabla de apuesta { p=0. DUF que toma como parámetros dos tablas.

println("Lo importante no es ganar.i<primitiva.random()*49+1).out.random()*49+1). System. int aciertos=0. if (aciertos == 0) System.length..out. for (int i=0.out.println("\n\nTiene "+aciertos+" aciertos\n").i<apuesta. } public static void main(String[] args) { int primitiva[]=new int[6]. System.println("\nLa combinación ganadora es: ").println("Su apuesta es: "). System. System.out. } aciertos=primitiva(primitiva..i++) { primitiva[i]=(int)(Math.print(primitiva[i] + " ").print(apuesta[i] +" ").out.apuesta). for (int i=0. } } Ejercicios de Programación en Java 165 . es participar.length. } System. int apuesta[]=new int[6].return(aciertos).out.\n").i++) { apuesta[i]=(int)(Math.

package bol06ej30. if (n == 0) res = 1. DUF recursiva que calcule an. } static double potencia (double a. n . else // caso recursivo: a^n = a *a^n-1 res = a * potencia(a. n . else res = a * potencia(a. return (res). return (res).1). if (n == 0) // el caso base: cuando el exponente es 0 res = 1.1). int n) { int res.30. public class Main { /* sobrecargamos la función para que funcione tanto con bases enteras * como reales * */ static int potencia (int a. } Ejercicios de Programación en Java 166 . int n) { double res.

} } 31. public class Main { static int factorial(int num){ int res. Ejercicios de Programación en Java 167 . System.real()..out. System. if(num==0) // caso base: 0! es igual a 1 res=1. int potencia.public static void main(String[] args) { double num. package bol06ej31. potencia). potencia = Entrada. else res=num*factorial(num-1). Calcular el factorial de n recursivamente. num = Entrada.out. // n!= n*(n-1)*(n-2). resultado = potencia(num.println("El resultado es: " + resultado).entero().. System.print("Introduzca la potencia: "). resultado.print("Introduzca base (real): "). un ejemplo 3!=3*2*1 // también ocurre que n!=n*(n-1)! // como ejemplo 4!=4*3! } return(res).out.

resultado. DUF que calcule el valor máximo de una tabla de forma recursiva. int pos) { int res.entero().out. resultado=factorial(num).println(num+"! es igual a "+resultado). * a partir de las posición pos.public static void main(String[] args) { int num. package bol06ej32. // caso base: pos indica el último elemento de t // en este caso este será el máximo Ejercicios de Programación en Java 168 . public class Main { /** la función máximo busca el mayor número entre los elementos de t. int k. } } System.print("Introduzca el numero: "). if(pos==t.length-1) else { res=t[pos]. 32. num=Entrada. */ static int maximo (int t[]. System.out.

} public static void main(String[] args) { int datos[]. max =maximo(datos).println("Los datos son:"). datos = new int[10]. i++) datos[i] = (int) (Math. // k será el mayor desde la posición pos+1 hasta el último elemento if (t[pos]>k) // si t[pos] es mayor que k res = t[pos].length. for (int i = 0. i++) System.pos+1). i < datos. // el usuario utilizará esta función por comodidad static int maximo (int t[]) { return (maximo (t. int max. for (int i = 0. i < datos.length.print(datos[i] + " ").0)). System.out.out. //t[pos] es el máximo else res = k.k = maximo (t.random()*1000+1). // en caso contrario será k el máximo } } return(res). Ejercicios de Programación en Java 169 .

out. t. static int maximo(int t[]) { return (maximo(t.println("\n\nEl máximo es: " + max). System. // un ejemplo para probar la función int max.System. indicando el primer índice donde se empezará a buscar el máximo. public class Main { public static void main(String[] args) { int t[]={7. 10.println("El máximo es: " +max). Vamos acortando la tabla. El caso base será una tabla donde solo se busca en un elemento elemento. } // // // // // // // // El máximo de una tabla será el máximo entre el primer elemento de la tabla y el resto de la tabla (es decir del segundo elemento hasta el último). 0. Está claro que ese único elemento será el mayor de la tabla (de 1 elemento). max =maximo(t). 5.out. 1. } } package bol06ej32. 2. 9}. } Ejercicios de Programación en Java 170 .length-1 )).

if(num==0) res=0. public class Main { static int fibo(int num) { int res. } return (mayor). package bol06ej33. if (mayor < t[desde]) mayor = t[desde].static int maximo(int t[]. En esta serie el n-ésimo valor se calcula sumando los dos valores anteriores. DUF que calcule el n-ésimo término de la serie de Fibonacci. int hasta) { int mayor. siendo fibonacci(0)=1 y fibonacci(1)=1. int desde. desde+1. Es decir fibonacci(n) = fibonacci(n1)+fibonacci(n-2). if (desde == hasta) // caso base // la tabla solo tiene un elemento mayor=t[desde]. else { mayor = maximo(t. } } 33. else{ if(num==1) // primer caso base // segundo caso base Ejercicios de Programación en Java 171 . hasta).

package bol06ej34. System. pero pudiendo configurar los valores de los dos primeros término de la serie. public class Main { /** * sobrecargamos la función para que funcione de la siguiente forma: * . 34.print("Vamos calcular fibonacci(n).entero(). // caso general recursivo return(res). } } "). resultado=fibo(num).out.println("\nfibonacci(" + num + ") = " +resultado). System. } public static void main(String[] args) { int num.\nIntroduzca n (se recomienda n<40): num=Entrada. // si n es muy grande esto puede tardar bastante. Igual que el ejercicio anterior.resultado.si solo se le pasa el término a calcular: utiliza los casos bases típicos Ejercicios de Programación en Java 172 .else } res=1.out. res=fibo(num-1)+fibo(num-2).

se le puede pasar los valores de los casos bases: fibo(0) y fibo(1) */ static int fibo(int num) { int res. else res=fibo(num-1. } static int fibo(int num. fibo1)+fibo(num-2. } return(res). fibo1).* . if(num==0) // primer caso base res=0. también configurable res=fibo1. int fibo1) { int res.fibo0. else res=fibo(num-1)+fibo(num-2). int fibo0. if(num==0) // primer caso base. que tendrá el valor indicado por el usuario res=fibo0. fibo0. else{ if(num==1) // segundo caso base. else{ if(num==1) // segundo caso base res=1. // caso general recursivo // hemos de acordarnos de utilizar la función fibo que // tiene 3 parámetros } // caso general recursivo Ejercicios de Programación en Java 173 .

entero(). System.println("Vamos calcular fibonacci(n)\n"). } } ").out. fibo0 = Entrada. package bol06ej35. fibo1 = Entrada. System.print("Introduzca el valor de fibonacci(1): "). resultado=fibo(num.fibo1. fibo1). System. // si n es muy grande esto puede tardar bastante. int fibo0.out. System. System.entero(). public class Main { Ejercicios de Programación en Java 174 .out.print("Introduzca el valor de fibonacci(0): ").out.println("\nfibonacci(" + num + ") = " +resultado). } public static void main(String[] args) { int num.print ("\nIntroduzca n (se recomienda n<40): num=Entrada. 35. DUF que realice la búsqueda dicotómica en una tabla. de forma recursiva. fibo0.entero().resultado.return(res).out.

por que el elemento mitad ya pertenece a la // primera parte. int elem. la tabla. int ultimo) { int pos. el elemento a buscar. // buscamos en la segunda parte de la tabla: mitad+1. y se cogerá el valor de pos2 (-1) return(pos). else { int pos1..mitad pos1 = busca (t. // llamada recursiva //buscamos en la primera mitad de la tabla: 0.. if(primero >= ultimo) // caso base: solo hay un elemento donde buscar if (t[primero]==elem) pos =primero. Ejercicios de Programación en Java 175 . static int busca (int t[]..// a la función se le pasa. (primero+ultimo)/2+1. if (pos1 != -1) // si lo encuentro en la primera parte pos =pos1. pos2. int primero.ultimo // se pone mitad+1. por no repetirlo pos2 = busca (t. ultimo). y la primera // y última posición donde buscar.. else pos =-1. primero. (primero+ultimo)/2). elem. else pos =pos2. elem. // en caso contrario debo encontrarlo en la segunda parte } // en caso de no encontrarse pos1 y pos2 serán -1.

0. num).} // el usuario utilizará esta función por comodidad // solo es necesario pasarle la tabla y el elemento a buscar // devuelve el índice del elemento si lo encuentra o -1 en caso contrario static int busca (int t[].random()*1000+1). // para no teclearlos. i++) System. int elem) { return (busca (t. // llamamos a la función buscar pos =busca(datos. num =Entrada.out.length. if (pos == -1) Ejercicios de Programación en Java 176 .print(datos[i] + " ").out. cagamos datos aleatorios for (int i = 0. System. } public static void main(String[] args) { int datos[].print("\n\nElemento a buscar: "). elem.out. int pos.length. System.println("Los datos son:").entero(). i < datos. int num.length-1)). for (int i = 0. t. i < datos. datos = new int[10]. i++) datos[i] = (int) (Math.

Disponemos de las constantes PB (peón blanco). D=4. CN=12. TN (torre negra).println("\n\nEncontrado en la posición: " +pos).else } } System. System. etc. T. A. DN=14. que indique si el rey negro está amenazado. C. RN=15.out. R=5. D). P=0. C=2. (P.out. public class Main { final final final final final final final final final final final final final static static static static static static static static static static static static static int int int int int int int int int int int int int V=-1. public static void main(String[] args) { Ejercicios de Programación en Java 177 .println("\n\nNo encontrado"). Dicho módulo debe devolver un valor booleano. DUF que toma una tabla bidimensional de enteros. 36. A=3. package bol06ej36. T=1. representando un tablero de ajedrez. // // // // // // // escaque vacío peón torre caballo alfil dama rey // igual para los negros PN=10. TN=11. AN=13. R.

AN}. } static boolean jaque(int tablero[][]) { boolean amenaza=false. V. V. V. V. V. Ya que hemos de imaginarlo // rotado 90 grados hacia la izquierda. {V. {V. V. V. V. V. V}}. V}. V. V. R. V. {V. V.out. V. int pieza. T. V. V. V. V.final int tablero[][] = { {V. V. P. V}. V. V. V. // ahora iremos viendo las posibles amenazas una a una: Ejercicios de Programación en Java 178 . DN. V. V}. V. V. V. V}. V. {V. // hay que tener con el tablero: como lo visualizamos y sus índices. V. // pieza que no está amenazando int pos_rey[]. // En realidad el tablero no es como se ve arriba. V. P. V. V. {V. V. V. {V. {V. boolean amenaza. // posición del rey en el tablero pos_rey = new int [2]. V. // mostramos se existe amenaza System. V. V}. V. CN. V. V.println("Jaque: " +amenaza). // // // // una posible mejora es indicar en la variable amenaza la primera pieza contraria nos está acechando e indicar con un escaque vacío que no existe peligro amenaza = jaque (tablero). V. V}. pos_rey = busca_rey (tablero). V. V. V.

if (pieza ==DN || pieza ==TN) amenaza=true. 0). dy:1) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. pos_rey. // AHORA // miraremos hacia la derecha (dx:1. dy:-1) // aquí no puede amenazar un alfil o una dama Ejercicios de Programación en Java 179 . dy:1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. 0. pos_rey. pos_rey. dy:-1) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. if (pieza ==DN || pieza ==TN) amenaza=true. pos_rey. -1). -1. 1. if (pieza ==DN || pieza ==TN) amenaza=true. 1. if (pieza ==DN || pieza ==TN) amenaza=true. 1). if (pieza ==DN || pieza ==AN) amenaza=true. 0). // miraremos en la diagonal derecha arriba (dx:1. dy:0) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero.// en primer lugar veremos si nos amenaza un caballo: amenaza =amenaza_caballo (tablero. // miraremos hacia abajo (dx:0. 0. // miraremos hacia arriba (dx:0. dy:0) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. // miraremos en la diagonal derecha abajo (dx:1. 1). // miraremos hacia la izquierda (dx:-1. pos_rey. pos_rey).

static int[] busca_rey (int tablero[][]) { int i. int posicion[]. 1). -1.j. -1). // esta función busca el rey blanco y devuelve su posición // en una tabla de dos elementos. // miraremos en la diagonal izquierda abajo (dx:-1. -1). pos_rey. if (pieza ==DN || pieza ==AN) amenaza=true. 1. dy:-1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. -1. pos_rey. dy:1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. if (pieza ==DN || pieza ==AN) amenaza=true. // falta que nos amenace un peón // el posible peón se encuentra arriba a la derecha o a la izquierda if ( (pos_rey[0]+1<8 && pos_rey[1]+1<8 && tablero[pos_rey[0]+1][pos_rey[1]+1]==PN) || (0<=pos_rey[0]-1 && pos_rey[1]+1<8 && tablero[pos_rey[0]-1][pos_rey[1]+1]==PN) ) amenaza=true. if (pieza ==DN || pieza ==AN) amenaza=true. } return (amenaza). Siendo posicion[0] la columna y // posicion[1] la fila. // miraremos en la diagonal izquierda arriba (dx:-1. pos_rey.pieza =primera_pieza(tablero. Ejercicios de Programación en Java 180 .

j++) if (tablero[i][j]==R) { posicion[0] =i. int dy) { int posx. posx =pos[0]. i <8. } return (posicion). for (i=0. } // esta función busca la primera pieza que existe desde la posición pos. dy son: // dx dy dirección // 1 1 diagonal derecha arriba // 1 0 derecha // 1 -1 diagonal derecha abajo // 0 1 hacia arriba // 0 0 ESTE CASO NO SE DARÁ NUNCA // 0 -1 hacia abajo // -1 1 diagonal izquierda arriba // -1 0 hacia la izquierda // -1 -1 diagonal izquierda abajo static int primera_pieza (int tablero[][]. posicion[1] =j. //posición del tablero en la que estamos mirando int pieza. int pos[]. j <8. int dx. dy.posicion = new int [2]. i++) for (j=0. posy. // Los valores de dx. Ejercicios de Programación en Java 181 . // en la dirección indicada por dx. posy =pos[1].

posy += dy. posx +=dx. Algunas de estas posiciones pueden ( ( pos[0]+2 <8 && pos[1]+1 ( pos[0]+2 <8 && 0<= pos[1]-1 (0<= pos[0]-2 && pos[1]+1 (0<= pos[0]-2 && 0<= pos[1]-1 posibles ocho posiciones desde donde estar <8 && && <8 && && "fuera" del tablero tablero[pos[0]+2][pos[1]+1] tablero[pos[0]+2][pos[1]-1] tablero[pos[0]-2][pos[1]+1] tablero[pos[0]-2][pos[1]-1] ==CN) ==CN) ==CN) ==CN) || || || || Ejercicios de Programación en Java 182 .pieza = V. // Hay que tener cuidado al comprobar los caballos de no salirse del // tablero // // // if Desde la posición actual vemos los puede amenazarnos un caballo. int pos[]) { boolean amenaza=false. // mientras no nos salgamos del tablero y no encontremos una pieza while ( 0<=posx && posx<=7 && 0<=posy && posy<=7 && pieza ==V) { pieza = tablero[posx][posy]. posy +=dy. static boolean amenaza_caballo (int tablero[][]. posx += dx. } } return (pieza). // en principio suponemos que no hay ninguna pieza // damos el primer paso: es decir pasamos a la primera casilla // después del rey.

RN=15. } } return (amenaza). Ejercicios de Programación en Java 183 . Igual que el ejercicio anterior. R=5. DN=14. package bol06ej37. TN=11. P=0. CN=12. AN=13. public class Main { final final final final final final final final final final final final final static static static static static static static static static static static static static int int int int int int int int int int int int int V=-1. || || || ) 37. T=1. D=4. C=2. // // // // // // // escaque vacío peón torre caballo alfil dama rey // igual para los negros PN=10.( pos[0]+1 <8 && pos[1]+2 <8 && tablero[pos[0]+1][pos[1]+2] ==CN) ( pos[0]+1 <8 && 0<= pos[1]-2 && tablero[pos[0]+1][pos[1]-2] ==CN) (0<= pos[0]-1 && pos[1]+2 <8 && tablero[pos[0]-1][pos[1]+2] ==CN) (0<= pos[0]-1 && 0<= pos[1]-2 && tablero[pos[0]-1][pos[1]-2] ==CN) amenaza = true. A=3. pero indicando si existe jaque mate a las negras.

{ V. V. V. V. V. V. 0. P. V}. V. num_jaque += mover_rey (tablero. { V. V. int pos_rey[]. DN}. {CN. 1). V. V. V}. V}. V. V. if ( jaque (tablero) == true ) { amenaza =true. V. num_jaque += mover_rey (tablero. V. V. V. V. V. V. { V. V}. V. V. V}. V. PN. V}. V. int num_jaque=0. V. V. V. { V. V. V.public static void main(String[] args) { int tablero[][] = { { V. V. { V. P. V. V. // En realidad el tablero no es como se ve arriba. R. V. V. Ejercicios de Programación en Java 184 . V. V. V. boolean amenaza=false. -1). // intentaremos mover el rey a las casillas adyacentes // y comprobar si en la nueva ubicación recibe jaque num_jaque += mover_rey (tablero. Ya que hemos de imaginarlo // rotado 90 grados hacia la izquierda. V. V. V. -1). V. V. DN. V. 1. num_jaque=0. 0. V}}. V. { V. V. // hay que tener con el tablero: como lo visualizamos y sus índices. // // // // una posible mejora es indicar en la variable amenaza la primera pieza contraria nos está acechando e indicar con un escaque vacío que no existe peligro pos_rey = busca_rey(tablero).

// pieza que no está amenazando int pos_rey[]. else System. pos_rey = busca_rey (tablero). -1. (tablero. // ahora iremos viendo las posibles amenazas una a una: // en primer lugar veremos si nos amenaza un caballo: amenaza =amenaza_caballo (tablero. // posición del rey en el tablero pos_rey = new int [2]. 0). // AHORA // miraremos hacia la derecha (dx:1.out.println("El rey no está amenazado"). else System. -1.println("Jaque Mate").").} num_jaque num_jaque num_jaque num_jaque num_jaque += += += += += mover_rey mover_rey mover_rey mover_rey mover_rey (tablero. (tablero. 1. 0). } static boolean jaque(int tablero[][]) { boolean amenaza=false. (tablero. // mostramos se existe amenaza if (amenaza) if (num_jaque<8) System. -1). 1). pos_rey). 1).println("Solo es jaque. 1. dy:0) // aquí no puede amenazar una torre o dama Ejercicios de Programación en Java 185 . int pieza. (tablero.out. -1.out.

pos_rey. pos_rey. // miraremos hacia arriba (dx:0. 1). pos_rey. if (pieza ==DN || pieza ==TN) amenaza=true. 0. dy:-1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. // miraremos en la diagonal izquierda arriba (dx:-1. if (pieza ==DN || pieza ==AN) amenaza=true. // miraremos hacia la izquierda (dx:-1. 1. -1. 0). dy:1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. 0). if (pieza ==DN || pieza ==TN) amenaza=true. pos_rey. 1). -1). // miraremos hacia abajo (dx:0. dy:-1) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. 1. // miraremos en la diagonal derecha abajo (dx:1. 1.pieza =primera_pieza(tablero. dy:0) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. // miraremos en la diagonal derecha arriba (dx:1. pos_rey. 0. dy:1) // aquí no puede amenazar un alfil o una dama Ejercicios de Programación en Java 186 . -1). dy:1) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. pos_rey. if (pieza ==DN || pieza ==AN) amenaza=true. if (pieza ==DN || pieza ==TN) amenaza=true. if (pieza ==DN || pieza ==TN) amenaza=true.

static int[] busca_rey (int tablero[][]) { int i. pos_rey. -1. // esta función busca el rey blanco y devuelve su posición // en una tabla de dos elementos. Siendo posicion[0] la columna y // posicion[1] la fila. -1. posicion = new int [2]. } return (amenaza). pos_rey. if (pieza ==DN || pieza ==AN) amenaza=true. int posicion[]. for (i=0. if (pieza ==DN || pieza ==AN) amenaza=true. j <8. i <8. 1). j++) if (tablero[i][j]==R) Ejercicios de Programación en Java 187 . -1). i++) for (j=0. dy:-1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. // miraremos en la diagonal izquierda abajo (dx:-1.j.pieza =primera_pieza(tablero. // falta que nos amenace un peón // el posible peón se encuentra arriba a la derecha o a la izquierda if ( (pos_rey[0]+1<8 && pos_rey[1]+1<8 && tablero[pos_rey[0]+1][pos_rey[1]+1]==PN) || (0<=pos_rey[0]-1 && pos_rey[1]+1<8 && tablero[pos_rey[0]-1][pos_rey[1]+1]==PN) ) amenaza=true.

int pos[]. dy son: // dx dy dirección // 1 1 diagonal derecha arriba // 1 0 derecha // 1 -1 diagonal derecha abajo // 0 1 hacia arriba // 0 0 ESTE CASO NO SE DARÁ NUNCA // 0 -1 hacia abajo // -1 1 diagonal izquierda arriba // -1 0 hacia la izquierda // -1 -1 diagonal izquierda abajo static int primera_pieza (int tablero[][]. posx +=dx. return (posicion). //posición del tablero en la que estamos mirando int pieza. int dy) { int posx. pieza = V. Ejercicios de Programación en Java 188 . posy +=dy.{ } } posicion[0] =i. posy. int dx. // en la dirección indicada por dx. // esta función busca la primera pieza que existe desde la posición pos. // en principio suponemos que no hay ninguna pieza // damos el primer paso: es decir pasamos a la primera casilla // después del rey. posx =pos[0]. posy =pos[1]. posicion[1] =j. dy. // Los valores de dx.

static boolean amenaza_caballo (int tablero[][]. Algunas de estas posiciones pueden ( ( pos[0]+2 <8 && pos[1]+1 ( pos[0]+2 <8 && 0<= pos[1]-1 (0<= pos[0]-2 && pos[1]+1 (0<= pos[0]-2 && 0<= pos[1]-1 ( pos[0]+1 <8 && pos[1]+2 ( pos[0]+1 <8 && 0<= pos[1]-2 (0<= pos[0]-1 && pos[1]+2 (0<= pos[0]-1 && 0<= pos[1]-2 amenaza = true.// mientras no nos salgamos del tablero y no encontremos una pieza while ( 0<=posx && posx<=7 && 0<=posy && posy<=7 && pieza ==V) { pieza = tablero[posx][posy]. } } return (pieza). posibles ocho posiciones desde donde estar <8 && && <8 && && <8 && && <8 && && "fuera" del tablero tablero[pos[0]+2][pos[1]+1] tablero[pos[0]+2][pos[1]-1] tablero[pos[0]-2][pos[1]+1] tablero[pos[0]-2][pos[1]-1] tablero[pos[0]+1][pos[1]+2] tablero[pos[0]+1][pos[1]-2] tablero[pos[0]-1][pos[1]+2] tablero[pos[0]-1][pos[1]-2] ==CN) ==CN) ==CN) ==CN) ==CN) ==CN) ==CN) ==CN) || || || || || || || ) Ejercicios de Programación en Java 189 . // Hay que tener cuidado al comprobar los caballos de no salirse del // tablero // // // if Desde la posición actual vemos los puede amenazarnos un caballo. posy += dy. posx += dx. int pos[]) { boolean amenaza=false.

if ( 0<=pos[0]+dx && pos[0]+dx<8 && 0<=pos[1]+dy && pos[1]+dy<8 && ( tablero[pos[0]+dx][pos[1]+dy]==V tablero[pos[0]+dx][pos[1]+dy]==PN tablero[pos[0]+dx][pos[1]+dy]==TN tablero[pos[0]+dx][pos[1]+dy]==CN tablero[pos[0]+dx][pos[1]+dy]==AN tablero[pos[0]+dx][pos[1]+dy]==DN { int pieza. // movemos el rey tablero[pos[0]][pos[1]] =V. tablero[pos[0]+dx][pos[1]+dy] =R. static int mover_rey (int tablero[][].} return (amenaza). int dx. // existe_jaque vale 0 si no hay peligro y 1 si // el rey está amenazado o no puede moverse a esta // casilla. if (jaque(tablero)) existe_jaque=1. int dy) { int existe_jaque=0. Ejercicios de Programación en Java 190 . int pos[]. pos = new int [2]. pos = busca_rey(tablero). || || || || || ) ) // guardamos la pieza que ocupa la posición a ocupar por el rey // esta pieza puede ser V (vacío) o una pieza negra que el // rey capturará pieza=tablero[pos[0]+dx][pos[1]+dy].

} else // no podemos mover el rey. } } Ejercicios de Programación en Java 191 .. en la practica esta casilla no es utilizable // por el rey para escapar.. es lo mismo que una amenaza (jaque).//volvemos el rey a su posición inicial tablero[pos[0]][pos[1]] =R. tablero[pos[0]+dx][pos[1]+dy] =pieza. return (existe_jaque). existe_jaque=1.

Pedir un número e indicar si es positivo o negativo. Apéndice I Ejercicios de Programación en Java 192 . y muestre sus soluciones reales. Pedir el radio de un círculo y calcular su área. 2. Pedir dos números y decir cual es el mayor. A=PI*r^2. Pedir dos números y decir si son iguales o no. Pedir dos números y decir cual es el mayor o si son iguales. 8. 5.Boletines completos BOLETÍN 1 Variables y condicionales 1. 7. Si no existen. 6. debe indicarlo. Pedir dos números y mostrarlos ordenados de mayor a menor. 3. Pedir los coeficientes de una ecuación se 2º grado. L=2*PI*r. 4. Pedir dos números y decir si uno es múltiplo del otro. 9. Pedir el radio de una circunferencia y calcular su longitud.

minutos y segundos. Suponiendo todos los meses de 30 días.999 y decir cuantas cifras tiene. Pedir el día. Pedir un número entre 0 y 9. Pedir el día. mes y año de una fecha correcta y mostrar la fecha del día siguiente. 11. 17. Pedir el día. 30 y 31 días. decir si es capicúa. y mostrar dicha nota de la forma: cero. Suficiente. para 56 mostrar: cincuenta y seis. Sin años bisiestos.. suponiendo que cada mes tiene un número distinto de días (suponer que febrero tiene siempre 28 días)... 13. 21. Pedir dos fechas y mostrar el número de días que hay de diferencia. 19. Con meses de 28. Pedir un número de 0 a 99 y mostrarlo escrito. Suponiendo todos los meses de 30 días. y mostrar la hora en el segundo siguiente. mes y año de una fecha e indicar si la fecha es correcta. 15. 18. uno. dos.. Bien. Pedir un número entre 0 y 9. 12. Por ejemplo. 17. Ídem que el ej. 14. tres. mes y año de una fecha e indicar si la fecha es correcta.999. Pedir una nota de 0 a 10 y mostrarla de la forma: Insuficiente.999 y mostrarlo con las cifras al revés. 22. Pedir una hora de la forma hora. suponer que todos los meses tienen 30 días. 20. Pedir tres números y mostrarlos ordenados de mayor a menor. Ejercicios de Programación en Java 193 .10. Pedir un número entre 0 y 9. Pedir una nota numérica entera entre 0 y 10. 16.

11. 6. Pedir 10 sueldos. Leer números hasta que se introduzca un 0. 4. 5. Pedir un número y calcular su factorial. 14. y mostrar cuántos números se han introducido. la media de los números negativos y la cantidad de ceros. Pedir un número N. Mostrar su suma y cuantos hay mayores de 1000€. Para cada uno indicar si es par o impar. Ejercicios de Programación en Java 194 . Leer un número y mostrar su cuadrado. 3. Realizar un juego para adivinar un número. 10. y mostrar todos los números del 1 al N. Para ello pedir un número N. El proceso se repetirá hasta que se introduzca un 0. 2. El proceso termina cuando el usuario acierta. Mostrar la media de los números positivos. Pedir números hasta que se teclee uno negativo. Pedir 10 números. y luego ir pidiendo números indicando “mayor” o “menor” según sea mayor o menor con respecto a N. 13. mostrar la suma de todos los números introducidos. Escribir todos los números del 100 al 0 de 7 en 7. y calcular la media. repetir el proceso hasta que se introduzca un número negativo. 8. Leer un número e indicar si es positivo o negativo. Diseñar un programa que muestre el producto de los 10 primeros números impares. 7.BOLETÍN 2 Condicionales y bucles 1. Pedir números hasta que se teclee un 0. Pedir números hasta que se introduzca uno negativo. 9. Pedir 15 números y escribir la suma total. 12.

3 €/litro y 3. 19. 18. 23.25 €/litro. Una empresa que se dedica a la venta de desinfectantes necesita un programa para gestionar las facturas. la cantidad vendida en litros y el precio por litro.1. escribir la cantidad de alumnos aprobados. 17.75. cantidad en litros vendidos del artículo 1 y cuantas facturas se emitieron de más de 600 €. y mostrar el sueldo máximo.6 €/litro.0. mostrar la edad y la estatura media. Solo existen tres productos con precios: 1. Se pide de 5 facturas introducidas: Facturación total. introducir N sueldos. 2. Pedir un número N. En cada factura figura: el código del artículo.15. condicionados (=4) y suspensos. 21. Igual que el anterior pero suponiendo que no se introduce el precio por litro. Pedir 10 números. Dadas 6 notas. Pedir 5 calificaciones de alumnos y decir al final si hay algún suspenso. Pedir 5 números e indicar si alguno es múltiplo de 3. Dadas las edades y alturas de 5 alumnos. y la cantidad de alumnos que miden más de 1. y mostrar al final si se ha introducido alguno negativo. Pide un número (que debe estar entre 0 y 10) y mostrar la tabla de multiplicar de dicho número. 16. la cantidad de alumnos mayores de 18 años. Ejercicios de Programación en Java 195 . 22. 20.

PROGRAMA ej_1 VARIABLES i. j: ENTERO COMIENZO PARA i <. Ejercicios de Programación en Java 196 . Realiza una traza del siguiente algoritmo y muestra la salida generada por pantalla. Diseña una aplicación que muestre las tablas de multiplicar del 1 al 10. i.BOLETÍN 3 Bucles anidados 1. j: ENTERO COMIENZO PARA i <.i*10+j escribir (suma) FIN PARA FIN PARA FIN 2. Realiza detenidamente una traza al siguiente programa y muestra cual seria la salida por pantalla: PROGRAMA ej_1 VARIABLES suma.1 HASTA 3 j <.3 HASTA 0 INC -1 suma <.j+1 FIN MIENTRAS FIN PARA FIN 3.1 HASTA 4 PARA j <.i+1 MIENTRAS j < 4 escribir (j-i) j <.

Realizar un programa que nos pida un número n. 5.4. y nos diga cuantos números hay entre 1 y n que son primos. 6. Ejercicios de Programación en Java 197 . con la particularidad que cada vez que aparezca un 3 lo sustituya por una E. que muestre los números del 0-0-0-0-0 al 9-9-9-9-9. Necesitamos mostrar un contador con 5 dígitos (X-X-X-X-X). Dibuja un cuadrado de n elementos de lado utilizando *.

Leer por teclado dos tablas de 10 números enteros y mezclarlas en una tercera de la forma: el 1º de A. etc. Leer por teclado una serie de 10 números enteros. la media de los negativos y contar el número de ceros. Leer 5 números y mostrarlos en el mismo orden introducido. 2. 3 de la B. otros 3 de la B. 3. el 1º de B. el 2º de B. Leer mediante el teclado 8 números. Debemos mostrarlos en el siguiente orden: el primero. 6. el segundo. el 2º de A. el último. etc. decreciente.BOLETÍN 4 Tablas 1. o si están desordenados. 9. Leer 5 números por teclado y a continuación realizar la media de los números positivos. otros 3 de A. insertarlo en la posición indicada. desplazando los que estén detrás. el penúltimo. el tercero. etc. 8. Diseñar una aplicación que declare una tabla de 10 elementos enteros. Crear un programa que lea por teclado una tabla de 10 números enteros y la desplace una posición hacia abajo (el último pasa a ser el primero). 4. Leer los datos correspondiente a dos tablas de 12 elementos numéricos. La aplicación debe indicarnos si los números están ordenados de forma creciente. Después se debe pedir un número y una posición. Leer 5 números y mostrarlos en orden inverso al introducido. Ejercicios de Programación en Java 198 . Leer 10 números enteros. 7. 5. y mezclarlos en una tercera de la forma: 3 de la tabla A.

Se pide leer las notas del primer. Leer 10 enteros. que estarán ordenados crecientemente. Guardar en otra tabla los elementos pares de la primera. Leer 5 elementos numéricos que se introducirán ordenados de forma creciente. Eliminar el elemento situado en la posición dada sin dejar huecos. y a continuación los elementos impares. 11. Cada grupo (o clase) está compuesto por 5 alumnos. segundo y tercer trimestre de un grupo. 13. Éstos los guardaremos en una tabla de tamaño 10. 14. Si no está. Se debe mostrar la posición en que se encuentra. Queremos desarrollar una aplicación que nos ayude a gestionar las notas de un centro educativo. 12. 15.10. Leer dos series de 10 enteros. Copiar (fusionar) las dos tablas en una tercera. Debemos mostrar al final: la nota media del grupo en cada trimestre. Realizar dos versiones: una trabajando con los valores y otra trabajando con los índices. indicarlo con un mensaje. 16. e insertarlo en el lugar adecuado para que la tabla continúe ordenada. desplazar N posiciones (N es introducido por el usuario). y la media del alumno que se encuentra en la posición N (N se lee por teclado). de forma que sigan ordenados. Leer 10 enteros ordenados crecientemente. Leer un número N. Leer N y buscarlo en la tabla. Ídem. Leer por teclado una tabla de 10 elementos numéricos enteros y leer una posición (entre 0 y 9). Ejercicios de Programación en Java 199 .

Crear una tabla bidimensional de tamaño 5x5 y rellenarla de la siguiente forma: la posición T[n. Crear una matriz “marco” de tamaño 8x6: todos sus elementos deben ser 0 salvo los de los bordes que deben ser 1. si se obtiene la misma tabla al cambiar filas por columnas. Crear una tabla de tamaño 7x7 y rellenarla de forma que los elementos de la diagonal principal sean 1 y el resto 0. 2. m. creamos un cubo con las caras puestas a 1 y el interior a 0. Los siguientes programas piden una serie de datos y tras procesarlos ofrecen unos resultados por pantalla. 4. 10. 8. 6. Mostrar el resultado: PROGRAMA Ej10a VARIABLES i. a: ENTEROS t: TABLA [5] ENTEROS COMIENZO PARA i0 HASTA 4 leer (t[i]) PROGRAMA Ej10b VARIABLES n. es decir. Crear y cargar una tabla de tamaño 10x10. cargar la primera y trasponerla en la segunda. pero con una matriz 9x9x9. 7. Mostrarla. 9. sumarlas y mostrar su suma. b: TABLA [100] ENTEROS COMIENZO n  10 Ejercicios de Programación en Java 200 . 3. utilizando dos tablas de tamaño 5x9 y 9x5. i: ENTEROS a. Hacer lo mismo que el ejercicio anterior. Crear y cargar una tabla de tamaño 3x3. Es decir. Crear y cargar una tabla de tamaño 4x4 y decir si es simétrica o no.m] debe contener n+m. 5.BOLETÍN 5 Tablas n-dimensionales 1. Después se debe mostrar su contenido. trasponerla y mostrarla. mostrar la suma de cada fila y de cada columna. Crear y cargar dos matrices de tamaño 3x3.

8. se debe mostrar de nuevo el menú inicial. Mostrar listado de datos. mejor marca del 2002. Si se selecciona 1. se debe mostrar un listado por número de dorsal. 2. 0. Mostrar listado por marcas. Si se elige la opción 2. Diseñar el programa que muestre las siguientes opciones: 1234Inscribir un participante. 6 y 1. de mayor a menor. El número de plazas disponible es de 10. que terminará el programa. 2. Tras procesar cada opción. Sus datos se irán introduciendo en el mismo orden que vayan inscribiéndose los atletas. 3 y 2. 5. 11-Se pretende realizar un programa para gestionar la lista de participaciones en una competición de salto de longitud. 9. hasta que se seleccione la opción 4. Ejercicios de Programación en Java 201 . mejor marca del 2001 y mejor marca del 2000. 1. PARA i0 HASTA n-1 leer (a[i]) FIN PARA PARA i  0 HASTA n/2 b[i]  a[n-1-i] b[n-1-i]  a[i] FIN PARA PARA i  0 HASTA n-1 SI i mod 2 = 0 escribir (a[i]) SINO escribir (b[i]) FIN SI FIN PARA FIN PROGRAMA Datos de entrada: 6. 2. 8. Finalizar el programa. se introducirán los datos de uno de los participantes: Nombre.FIN PARA m  0 PARA i  0 HASTA 4 SI t[i] > m m  t[i] FIN SI FIN PARA a  t[4-m] t[4-m]  t[m] t[m]  a PARA i  0 HASTA 4 escribir (t[i]) FIN PARA FIN PROGRAMA Datos de entrada: -4. La opción 3 mostrará un listado ordenado por la marca del 2002.

Ídem una versión que calcule el máximo de una tabla de n elementos. 6. Módulo al que se le pasa un número entero y devuelve el número de divisores primos que tiene. 9. Realizar una función que calcule (muestre en pantalla) el área o el volumen de un cilindro.Escribir una función que calcule el máximo común divisor de dos números. Ejercicios de Programación en Java 202 . 10. 5. el mensaje: “Módulo ejecutándose” 2. y muestre por pantalla N veces. 12. 11.Ídem diseñar una función que devuelve una tabla con los divisores. y que calcule el máximo. 7. 3. Ídem que devuelva una tabla con el área y el volumen. Ídem una versión que calcule el máximo de 3 números. Diseñar una función que tenga como parámetros dos números. Función que muestra en pantalla el doble del valor que se le pasa como parámetro. 8. Para distinguir un caso de otro se le pasará el carácter 'a' (para área) o 'v' (para el volumen). Además hemos de pasarle a la función el radio y la altura. 4. inclusive.BOLETÍN 6 Funciones 1. según se especifique. Función a la que se le pasan dos enteros y muestra todos los números comprendidos entre ellos. Realizar una función.Ídem con tres números. a la que se le pase como parámetro un número N.

Ídem con una tabla. DUF a la que se le pasa una tabla de enteros y un número.Diseña una función (en adelante DUF) que decida si un número es primo. Escriba una función que sume los n primeros números impares. 24. coseno y tangente. Dos números son amigos.Escribir una función que calcule el mínimo común múltiplo de dos números. Dado el valor de un ángulo. Ejercicios de Programación en Java 203 . Se leerá por teclado una serie de números: guardaremos solo los pares e ignoraremos los impares. 15. 17. si la suma de sus divisores (distintos de ellos mismos) son iguales. Escribir una función que muestre en pantalla los datos anteriores. 20. 25. 16. 22. 23. Diseñar una función que calcule la distancia euclídea de dos puntos. sería interesante saber su seno.13.Ídem con una tabla.Escriba una función que decida si dos números enteros positivos son amigos. DUF a la que se le pasa como parámetro una tabla que debe rellenar.DUF que calcule an. 18. 19. Debemos buscar el número en la tabla e indicar si se encuentra o no.DUF que muestre en binario un número entre 0 y 255. 14.Ídem con tres números. 21. También hay que devolver la cantidad de impares ignorados.

representando un tablero de ajedrez. 35. restar. DUF que toma una tabla bidimensional de enteros.26. T.Diseñar la función opera_tabla. pero pudiendo configurar los valores de los dos primeros término de la serie. 28. a la que se le pasa dos tablas. DUF que calcule el valor máximo de una tabla de forma recursiva. 29. R. A. 27. 36. de forma recursiva. 'r'. La función debe devolver el número de aciertos. DUF que calcule el n-ésimo término de la serie de Fibonacci. 32. 31. Es decir fibonacci(n) = fibonacci(n-1)+fibonacci(n-2). DUF que realice la búsqueda dicotómica en una tabla. pero suponiendo que la tabla no está siempre llena. La función debe devolver una tabla con los resultados. el número de elementos útiles y que operación se desea realizar: sumar. multiplicar o dividir (mediante un carácter: 's'. TN (torre negra). Calcular el factorial de n recursivamente. 'd'). 30. etc. En esta serie el n-ésimo valor se calcula sumando los dos valores anteriores. Disponemos de las constantes PB (peón blanco). La primera con los 6 números de una apuesta de la primitiva. y el número de elementos se pasa también como parámetro. (P. DUF que ordene la tabla que se le pasa. Igual que el ejercicio anterior. y la segunda con los 6 números ganadores. DUF que toma como parámetros dos tablas. D). 33. 34. DUF recursiva que calcule an. Ejercicios de Programación en Java 204 . Igual que el ejercicio anterior. C. 'm'. siendo fibonacci(0)=1 y fibonacci(1)=1.

pero indicando si existe jaque mate a las negras. que indique si el rey negro está amenazado. 37. Ejercicios de Programación en Java 205 .Dicho módulo debe devolver un valor booleano. Igual que el ejercicio anterior.

return valor.io. } catch(Exception e){ System.parseInt(inicializar()). } static double real(){ double valor=Double.*.readLine().in). try{ buzon=teclado. BufferedReader teclado=new BufferedReader(flujo). InputStreamReader flujo=new InputStreamReader(System. } return buzon. public class Entrada { static String inicializar(){ String buzon="". Apéndice II Ejercicios de Programación en Java 206 .append("Entrada incorrecta)").parseDouble(inicializar()).out. } static int entero(){ int valor=Integer.Clase Entrada import java.

static String cadena(){ String valor=inicializar(). return valor. } } Ejercicios de Programación en Java 207 .} return valor. return valor.charAt(0). } static char caracter(){ String valor=inicializar().

Sign up to vote on this title
UsefulNot useful