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.

.AGRADECIMIENTOS A todos los que han hecho posible este libro. por sus innumerables correcciones y por la clase Entrada. 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

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

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

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

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

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

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

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

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

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

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

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

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

u. num=Entrada.public class Main { public static void main(String[] args) { int num. d. num = num / 10.print("Introduzca un número entre 0 y 99.out. um:(unidades de millar) // c: (centenas). u: (unidades) System. num = num / 10. num = num / 10.999: "). // 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 . num = num / 10. 9 9 9 a cada guarismo lo llamaremos: //dm um c d u: dm (decenas de millar). d: (decenas). // unidades de millar um = num % 10. int dm. // centenas c = num % 10. // decenas de millar dm = num. // decenas d = num % 10. c. // unidad u = num % 10. um. // 9 9 .entero().

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

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

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

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

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

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

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

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

dia=Entrada. // si el mes supera 12. // si el día supera 30.out.public static void main(String[] args) { int dia. lo reiniciamos a 1 e incrementamos el año if (mes >= 12) { mes = 1. System. mes=Entrada.mes. mes ++.print("Introduzca día: "). año=Entrada.entero().entero().año.entero().out.print("Introduzca año: "). } } // 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 ++.out. Ejercicios de Programación en Java 25 . System. // suponemos que la fecha introducida es correcta // incrementamos el día dia ++.print("Introduzca mes: "). System. lo reiniciamos a 1 e incrementamos el mes if (dia >= 30) { dia = 1.

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

Suponiendo todos los meses de 30 días. package bol01ej19.// si el día supera el número de días del mes. } } // 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. System. // si el mes supera 12. } } 19. lo reiniciamos a 1 e incrementamos el año if (mes >= 12) { mes = 1.println (dia + "/"+ mes + "/" + año). año ++. mes ++. Pedir dos fechas y mostrar el número de días que hay de diferencia. // lo reiniciamos a 1 e incrementamos el mes if (dia >= dias_del_mes) { dia = 1.out. public class Main { Ejercicios de Programación en Java 27 .

minutos y segundos.entero(). // 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). mes2=Entrada. año1=Entrada. System.entero().print("Introduzca mes: "). System. System. } } System.out. package bol01ej20.entero(). System. System.println ("Días de diferencia: " + total_dias). 20. System. dia2=Entrada. Ejercicios de Programación en Java 28 .print("Introduzca día: ").println ("Fecha 2:").entero().out.año2.public static void main(String[] args) { int dia1. int dia2.mes1. System.out.out.año1. dia1=Entrada.out.print("Introduzca año: "). System.out.entero(). mes1=Entrada.out.out.entero(). y mostrar la hora en el segundo siguiente. año2=Entrada.print("Introduzca día: ").println ("Fecha 1:"). Pedir una hora de la forma hora.mes2. int total_dias.print("Introduzca mes: ").print("Introduzca año: ").out.

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

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

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

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

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

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

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

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

public class Main { public static void main(String[] args) { int num.entero(). else // en caso contrario: impar System.out. y mostrar cuántos números se han introducido. Pedir números hasta que se teclee uno negativo. } } } // al salir del mientras tenemos la certeza que num es 0 4. package bol02ej04.out.print("Introduzca otro número: ").public class Main { public static void main(String[] args) { int num.out.entero(). num=Entrada. contador. num=Entrada.println("Par").println("Impar").out. 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.print("Introduzca un número: "). Ejercicios de Programación en Java 37 . // repetimos el proceso y volvemos a leer num System.

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

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

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

elementos.out. suma. do { System. System. package bol02ej07.println("La suma de todos los números es: "+suma).suma. public class Main { public static void main(String[] args) { int num. suma=0.int num. } while(num!=0). suma=suma+num. float media.out.print("Introduzca un número: "). y calcular la media.entero(). Pedir números hasta que se introduzca uno negativo. num=Entrada. } } 7. // 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 .

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

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

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

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

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

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

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

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

// ahora el precio no se pide por teclado float importe_factura. Igual que el anterior pero suponiendo que no se introduce el precio por litro. // la cantidad de litros en cada factura float precio.out. más de 600 € facturacion_total = 0. float facturacion_total.1. package bol02ej18.// litros del articulo 1 System.println("Factura superior a 600€: " + mas_600). // factura de mas de 600 euros System. Solo existen tres productos con precios: 1. int litros_cod1. public class Main { public static void main(String[] args) { int codigo. // 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 .out.25 €/litro. 2. // el código del artículo en cada factura int litros.3 €/litro y 3.6 €/litro. } } 18.0.println("Ventas del producto 1: " + litros_cod1 + " litros"). int mas_600.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// la tabla c tendrá que tener el doble de tamaño que a y b.entero().j. int i. for (i=0. b[i]=Entrada.out.print("número: "). c = new int [24]. c[]. // leemos la tabla a System.out. } // 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.entero().i++){ System.println("Leyendo la tabla b"). Ejercicios de Programación en Java 75 .out.println("Leyendo la tabla a"). i=0. } // leemos la tabla b System. b[]. b=new int[12]. j=0.i++){ System.out.i<12.print("número: ").public class Main { public static void main(String[] args) { int a[]. a[i]=Entrada. a=new int[12]. for (i=0.i<12.

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

* */ numeros = new int [10]. boolean creciente. package bol04ej07. Leer por teclado una serie de 10 números enteros. // 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. La aplicación debe indicarnos si los números están ordenados de forma creciente. se cumple t[i]>t[i+1]: la serie t[i].7. public class Main { public static void main(String[] args) { int numeros[]. para algún i. t[i+1] es decreciente * * o el caso contrario. decreciente = false. creciente = false. decreciente. int i. decreciente. Ejercicios de Programación en Java 77 . o si están desordenados.

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

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

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

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

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

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

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

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

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

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

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

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

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

j++. j++. k++. // utilizaremos i j=0. como índice de b. i++. utilizar el siguiente hueco de la tabla Ejercicios de Programación en Java 91 . } // 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. // utilizaremos j k=0. // comenzamos a fusionar i=0. para // en la siguiente vuelta.c = new int [20]. } else // hay que copiar el resto de a en c while (i<10) // como hemos copiado a c[k]. // incrementamos j para tomar el siguiente elemento de b } k++. 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 i para tomar el siguiente elemento de a } else { c[k] = b[j]. incrementamos k. queda por copiar un resto de b while (j<10) { c[k] = b[j]. // utilizaremos k a y b en c como índice de a.

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

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

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

} // 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

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

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

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

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

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

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

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

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

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

Ejercicios de Programación en Java 108 . Los siguientes programas piden una serie de datos y tras procesarlos ofrecen unos resultados por pantalla. 2. 1. 2. 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. m.} } 10. 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. PROGRAMA Ej10b VARIABLES n. 9. i: ENTEROS a. 3 y 2. 6 y 1. 2. 5. Mostrar el resultado: PROGRAMA Ej10a VARIABLES i. 8. 8.

println (t[i]). i<=4. escribir el código equivalente para comprobar el resultado. m. i++) if (t[i] > m ) m = t[i]. } } Ejercicios de Programación en Java 109 . t[m] = a. al utilizar datos como índices de tablas sin las pertinentes comprobaciones. for (i=0. 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. public class Main { public static void main(String[] args) { int i. 1. for (i=0. i<=4. // // // // // // la idea de este ejercicio es hacer una traza de forma manual. 3. i++) System. m = 0. a = t[4-m].package bol05ej10. 2}. int t = new int [5]. i<=4. a. y tras ésta. i++) t[i] = Entrada. t[4-m] = t[m]. 0.out. // podemos sustituir la lectura de datos por la siguiente línea: //int t[] = {-4. for (i=0.entero().

} for (i=0. 2. i<=n.out.entero(). escribir el código equivalente para comprobar el resultado. // podemos sustituir la declaración de a y la lectura de datos por la siguiente línea: // int a[] = {6. 6.out.println (a[i]). */ int a[] = new int [10]. 1}. al utilizar datos como índices de tablas sin las pertinentes comprobaciones. /* la idea de este ejercicio es hacer una traza de forma manual. i<n. i++) if (i % 2 == 0) System. 8. 8. 2. 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.println (b[i]). 9. for (i=0. y tras ésta. else System. b[n-1-i] = a[i]. 5. 2. public class Main { public static void main(String[] args) { int n. } } Ejercicios de Programación en Java 110 . n = 10. for (i=0. i<=n/2. i++) a[i] = Entrada. i.package bol05ej10. i++) { b[i] = a[n-1-i]. int b[] = new int [10].

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

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

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

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

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

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

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

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

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

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

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

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

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

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.9. int i. // si hemos entrado aquí significa que el número no es primo i++. Ejercicios de Programación en Java 124 . // 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. } } return(primo). Módulo al que se le pasa un número entero y devuelve el número de divisores primos que tiene. primo=true. 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. 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. package bol06ej09.

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

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. } } return(primo). primo=true. 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. // 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 bol06ej10. Ejercicios de Programación en Java 126 . while(i<num && primo==true) { if( num %i == 0) // si es divisible primo=false. // si hemos entrado aquí significa que el número no es primo i++.10.Ídem diseñar una función que devuelve una tabla con los divisores.

num_div = num_divisores (num). // tabla donde guardaremos los divisores. } static int [] divisores(int num){ int cont=0. el 2 y el 3) static int num_divisores(int num){ int cont. el 1. div =new int[num_div]. no se consideran divisores.i++) if(es_primo (i) && num %i == 0) // si i es primo y divide a num cont++. al no ser primos por lo que 24 tiene tres divisores (el 1. // incrementamos el número de divisores return(cont). // siempre habrá un divisor seguro. cont=1. for (int i=2. int num_div. for (int i=1. // número de divisores primos que tiene num. int div[].i<=num.// // // // // // // 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 .i<=num.

divisores[]. divisores =divisores(num). System. System.print(divisores[i] + " ").Escribir una función que calcule el máximo común divisor de dos números. Ejercicios de Programación en Java 128 .out. for (int i = 0.entero(). // incrementamos el número de divisores public static void main(String[] args) { int num.println("Los divisores de " + num + " son:").out. cont++. i < divisores. } } 11. num=Entrada. 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". } div[cont] =i.out.out.length. System. package bol06ej11.println(""). i++) System.print("Introduce numero: ").{ } return(div).

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

println(""). int b. System. // para no implementar la función mínimo para tres números Ejercicios de Programación en Java 130 . 12.entero(). c) y quedarnos con el mayor. b). static int max_comun_divisor (int a. System. b=Entrada. b. package bol06ej12.out.Ídem con tres números.println("El mcd de "+a+" y "+b+" es: "+mcd).out. int c) { int mcd=1.out.print("Introduce otro: ").System. La idea es dividir por todos los números desde 1 hasta mínimo(a. int min. mcd = max_comun_divisor (a. 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 numero: "). a=Entrada.entero().out. } } System.

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

out. System. b.println("El mcd de ("+a+". b. "+c+") es: "+mcd). System. // una bandera para saber si un número divide // a todos los elementos de la tabla Ejercicios de Programación en Java 132 . c) y quedarnos con el mayor.Ídem con una tabla. mcd = max_comun_divisor (a. } } 13. int min. 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". c). package bol06ej13. La idea es dividir por todos los números desde 1 hasta mínimo(a. */ static int max_comun_divisor (int t[]) { int mcd=1. boolean divide_a_todos. "+b+".entero().println("").c=Entrada.out.

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

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

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

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

if(a>b) min=b. el 1. } static int max_comun_divisor (int a.b). for (int i=2. else Ejercicios de Programación en Java 137 .// 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. return (mcm).b). return(mcd). int b) { int mcm. // existe un mcd seguro. que divide a y b. int min. mcm = a*b / max_comun_divisor (a.i<=min.i++) if( a%i==0 && b%i==0) // si i divide a "a" y "b" mcd=i. int b) { int mcd=1. mcd=1. min = minimo (a. } static int minimo(int a. // i será el nuevo mcd. int b){ int min.

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

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

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

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

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

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

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

si la suma de sus divisores (distintos de ellos mismos) son iguales. int i.println("El mcm es: " +mcm).Escriba una función que decida si dos números enteros positivos son amigos. primo=true.System. } } 17. // 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. Dos números son amigos. 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) { Ejercicios de Programación en Java 145 . 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.out.

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

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

} } return(primo). res=1. int n){ int res.out. 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 . System. package bol06ej19.println("No es primo").entero().print("Introduce numero: "). public static void main(String[] args) { boolean res. } } 19. // el resultado se inicializa a 1.out. int num.i++. num=Entrada. if(es_primo(num)) System. else System.DUF que calcule an. public class Main { static int a_elevado_n(int a.out.println("Es primo").

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

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

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

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

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

entero().out.y2). y2. System.println("Punto 1"). System.package bol06ej23. y2 = Entrada.sqrt( Math.entero().pow (y1-y2.print("x: "). System. int y1. x1 = Entrada. // primer punto int x2. int x2. x2. Ejercicios de Programación en Java 154 . } public static void main(String[] args) { int x1.print("y: "). // distancia euclídea System. public class Main { static double distancia_euclidea (int x1. 2))). 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.pow (x1-x2. x2 = Entrada.print("x: "). // el otro punto double l.print("y: ").out.println("\nPunto 2").out.entero().y1. System. 2) + Math.out.out.entero(). l =distancia_euclidea (x1.out. y1. System. y1 = Entrada.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

i < datos. // el usuario utilizará esta función por comodidad static int maximo (int t[]) { return (maximo (t. //t[pos] es el máximo else res = k. for (int i = 0.0)).print(datos[i] + " ").length. Ejercicios de Programación en Java 169 .pos+1).k = maximo (t. i++) System. datos = new int[10].length.out. int max. } public static void main(String[] args) { int datos[].println("Los datos son:").random()*1000+1). i++) datos[i] = (int) (Math. for (int i = 0. // en caso contrario será k el máximo } } return(res).out. max =maximo(datos). i < datos. // 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]. System.

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

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

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

else res=fibo(num-1. else{ if(num==1) // segundo caso base. fibo0. } static int fibo(int num. int fibo1) { int res. if(num==0) // primer caso base. que tendrá el valor indicado por el usuario res=fibo0.* . también configurable res=fibo1. fibo1)+fibo(num-2. // 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 . int fibo0. fibo1). } return(res). else res=fibo(num-1)+fibo(num-2).fibo0. if(num==0) // primer caso base res=0. else{ if(num==1) // segundo caso base res=1.se le puede pasar los valores de los casos bases: fibo(0) y fibo(1) */ static int fibo(int num) { int res.

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

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

i++) datos[i] = (int) (Math. System. int num. int elem) { return (busca (t.out. System. int pos.} // 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[].entero().length.length-1)). num). } public static void main(String[] args) { int datos[].print(datos[i] + " ").out.random()*1000+1). for (int i = 0. 0. num =Entrada.length. i < datos.out.println("Los datos son:"). datos = new int[10]. // llamamos a la función buscar pos =busca(datos. elem. i++) System.print("\n\nElemento a buscar: "). cagamos datos aleatorios for (int i = 0. // para no teclearlos. i < datos. if (pos == -1) Ejercicios de Programación en Java 176 . t.

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

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

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

int posicion[].pieza =primera_pieza(tablero. pos_rey. 1.j. if (pieza ==DN || pieza ==AN) amenaza=true. if (pieza ==DN || pieza ==AN) amenaza=true. -1. } return (amenaza). pos_rey. -1). 1). pos_rey. dy:1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. -1). Siendo posicion[0] la columna y // posicion[1] la fila. // esta función busca el rey blanco y devuelve su posición // en una tabla de dos elementos. 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. // miraremos en la diagonal izquierda abajo (dx:-1. Ejercicios de Programación en Java 180 . -1. static int[] busca_rey (int tablero[][]) { int i. dy:-1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. // miraremos en la diagonal izquierda arriba (dx:-1.

} // esta función busca la primera pieza que existe desde la posición pos. i <8. int dy) { int posx. posx =pos[0]. dy. posy =pos[1]. int pos[]. } return (posicion). int dx. //posición del tablero en la que estamos mirando int pieza. for (i=0. // en la dirección indicada por dx. Ejercicios de Programación en Java 181 .posicion = new int [2]. i++) for (j=0. 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[][]. // Los valores de dx. posicion[1] =j. posy. j++) if (tablero[i][j]==R) { posicion[0] =i. j <8.

posy +=dy. static boolean amenaza_caballo (int tablero[][]. // 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. // en principio suponemos que no hay ninguna pieza // damos el primer paso: es decir pasamos a la primera casilla // después del rey. } } return (pieza).pieza = V. posx +=dx. posy += dy. 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]. 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 . posx += dx.

package bol06ej37. || || || ) 37. DN=14. TN=11. RN=15. D=4.( 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. C=2. // // // // // // // escaque vacío peón torre caballo alfil dama rey // igual para los negros PN=10. 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. T=1. A=3. P=0. R=5. pero indicando si existe jaque mate a las negras. CN=12. } } return (amenaza). Igual que el ejercicio anterior. AN=13. Ejercicios de Programación en Java 183 .

V. 0. V. { V. V. V. V}. { V. V. V}. V. V. V. V. V. 1). V}. V}. V. // hay que tener con el tablero: como lo visualizamos y sus índices. V. V. V. if ( jaque (tablero) == true ) { amenaza =true. V. V. int pos_rey[]. V. V. V}}. Ya que hemos de imaginarlo // rotado 90 grados hacia la izquierda. V. -1). V. 0. V. DN. { V. V. P. V. V. V. V. V. int num_jaque=0. V}. V. V. // En realidad el tablero no es como se ve arriba. V. num_jaque += mover_rey (tablero. { V. { V. // intentaremos mover el rey a las casillas adyacentes // y comprobar si en la nueva ubicación recibe jaque num_jaque += mover_rey (tablero. V. V}. V. -1). num_jaque += mover_rey (tablero. {CN. V. 1. V. V. V. Ejercicios de Programación en Java 184 . V.public static void main(String[] args) { int tablero[][] = { { V. V. V. V. V. num_jaque=0. P. R. DN}. V. // // // // 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). PN. boolean amenaza=false. V. { V.

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

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

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

// Los valores de dx. 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 =pos[0]. int dy) { int posx. posy. posy +=dy. // esta función busca la primera pieza que existe desde la posición pos. //posición del tablero en la que estamos mirando int pieza. // en principio suponemos que no hay ninguna pieza // damos el primer paso: es decir pasamos a la primera casilla // después del rey. posy =pos[1]. // en la dirección indicada por dx. posx +=dx. return (posicion). posicion[1] =j. int pos[]. dy. int dx. Ejercicios de Programación en Java 188 .{ } } posicion[0] =i. pieza = V.

} } 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 . 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]. 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. // 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. static boolean amenaza_caballo (int tablero[][]. posx += dx.

int dx.} return (amenaza). || || || || || ) ) // 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]. pos = new int [2]. 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. pos = busca_rey(tablero). // movemos el rey tablero[pos[0]][pos[1]] =V. int pos[]. static int mover_rey (int tablero[][]. // 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. Ejercicios de Programación en Java 190 . int dy) { int existe_jaque=0. tablero[pos[0]+dx][pos[1]+dy] =R.

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

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

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

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

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

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

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).4. 5. 6. Ejercicios de Programación en Java 197 . Dibuja un cuadrado de n elementos de lado utilizando *. y nos diga cuantos números hay entre 1 y n que son primos. Realizar un programa que nos pida un número n.

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

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

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

Ejercicios de Programación en Java 201 . 2. Tras procesar cada opción. de mayor a menor. que terminará el programa. hasta que se seleccione la opción 4. se introducirán los datos de uno de los participantes: Nombre. 6 y 1. se debe mostrar un listado por número de dorsal. Diseñar el programa que muestre las siguientes opciones: 1234Inscribir un participante. 5. Sus datos se irán introduciendo en el mismo orden que vayan inscribiéndose los atletas. 8. 3 y 2. 11-Se pretende realizar un programa para gestionar la lista de participaciones en una competición de salto de longitud. 0. 8. 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. 9. mejor marca del 2002.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. Mostrar listado de datos. 2. 2. La opción 3 mostrará un listado ordenado por la marca del 2002. Mostrar listado por marcas. Finalizar el programa. se debe mostrar de nuevo el menú inicial. 1. El número de plazas disponible es de 10. mejor marca del 2001 y mejor marca del 2000. Si se selecciona 1. Si se elige la opción 2.

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

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

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

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

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

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

Sign up to vote on this title
UsefulNot useful