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

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

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

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

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

ÍNDICE

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

1 4 6

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

I

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

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

1

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

Ejercicios de Programación en Java

2

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

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

Ejercicios de Programación en Java

3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

c. d. d. d. //si el número tiene 2 cifras (0. 0. 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"). num = num / 10. // centenas c = num % 10. d.// decenas d = num % 10. 0. c. num = num / 10. 0. //si el número tiene 3 cifras (0. u) if (dm == u && um == d) capicua = true. num = num / 10. c. //si el número tiene 4 cifras (0. um. //si el número tiene 5 cifras (dm. um. u) if (dm == 0 && um == u && c == d) capicua = true. u) if (dm == 0 && um == 0 && c == 0 && d == u) capicua = true. u) if (dm == 0 && um==0 && c == u) capicua = true.out. // decenas de millar dm = num. // unidades de millar um = num % 10.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

factorial=1.out. Mostrar la media de los números positivos.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 . // suma de los números positivos y negativos float media_pos. // contador de positivos int cont_neg.i--) { factorial=factorial*i. 13. Pedir 10 números.suma_neg. int cont_ceros. package bol02ej13. la media de los números negativos y la cantidad de ceros.println("El factorial de " + num + " es: " + factorial).media_neg. // es importante inicializarlo a 1. public class Main { public static void main(String[] args) { int num. } } } System. // el contador de ceros int cont_pos. // contador de negativos int suma_pos.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

while (j<=i-1 && primo==true) { if (i%j==0) primo=false. // si es primo incrementamos el contador de primos System. Ejercicios de Programación en Java 68 ." + num + ".// para cada número i. } } } } System. } if (primo==true){ cont_pri++..out..println(i+(" es primo")).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. j++...println("En el rango 1.out. consultar algoritmos para primos primo=true. hay "+ cont_pri + " números primos"). j=2.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} public static void main(String[] args) { int max.println("El número mayor es: " +max). Ejercicios de Programación en Java 118 . int t[].out. max =maximo (a. } } 4. entonces t[i] es el nuevo máximo max=t[i]. b. for (int i = 0.println(""). 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. return(max). i < t.System.length. package bol06ej04. System.out. Ídem una versión que calcule el máximo de una tabla de n elementos. max = t[0]. c).

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

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

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

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

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

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. Ejercicios de Programación en Java 124 . // si hemos entrado aquí significa que el número no es primo i++.9. // 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. Módulo al que se le pasa un número entero y devuelve el número de divisores primos que tiene. } } return(primo). public class Main { // la función es_primo indica si el número pasado es o no primo // recordamos que un número primo es solo divisible por el mismo y 1 static boolean es_primo(int num) { boolean primo. primo=true. package bol06ej09. int i. entonces ya no será divisible por ningún otro números -> será primo con esta mejora podemos ahorrar muchas vueltas del while para números grandes i=2.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

if(num==0) res=0. } } 33. hasta). desde+1. else{ if(num==1) // primer caso base // segundo caso base Ejercicios de Programación en Java 171 . if (mayor < t[desde]) mayor = t[desde]. int hasta) { int mayor. package bol06ej33. Es decir fibonacci(n) = fibonacci(n1)+fibonacci(n-2). public class Main { static int fibo(int num) { int res. 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 { mayor = maximo(t. int desde. if (desde == hasta) // caso base // la tabla solo tiene un elemento mayor=t[desde]. siendo fibonacci(0)=1 y fibonacci(1)=1.static int maximo(int t[]. } return (mayor).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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. } } return (pieza). int pos[]) { boolean amenaza=false. // 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. posx += dx. static boolean amenaza_caballo (int tablero[][].// mientras no nos salgamos del tablero y no encontremos una pieza while ( 0<=posx && posx<=7 && 0<=posy && posy<=7 && pieza ==V) { pieza = tablero[posx][posy]. posy += dy. 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 .

|| || || || || ) ) // 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]. if (jaque(tablero)) existe_jaque=1. pos = busca_rey(tablero). if ( 0<=pos[0]+dx && pos[0]+dx<8 && 0<=pos[1]+dy && pos[1]+dy<8 && ( tablero[pos[0]+dx][pos[1]+dy]==V tablero[pos[0]+dx][pos[1]+dy]==PN tablero[pos[0]+dx][pos[1]+dy]==TN tablero[pos[0]+dx][pos[1]+dy]==CN tablero[pos[0]+dx][pos[1]+dy]==AN tablero[pos[0]+dx][pos[1]+dy]==DN { int pieza. // movemos el rey tablero[pos[0]][pos[1]] =V.} return (amenaza). int dy) { int existe_jaque=0. // existe_jaque vale 0 si no hay peligro y 1 si // el rey está amenazado o no puede moverse a esta // casilla. int pos[]. int dx. Ejercicios de Programación en Java 190 . pos = new int [2]. static int mover_rey (int tablero[][]. tablero[pos[0]+dx][pos[1]+dy] =R.

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

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

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

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

y la cantidad de alumnos que miden más de 1. 21.25 €/litro.1. introducir N sueldos. Dadas las edades y alturas de 5 alumnos. Pide un número (que debe estar entre 0 y 10) y mostrar la tabla de multiplicar de dicho número. 20. y mostrar el sueldo máximo. 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.75. 19. la cantidad vendida en litros y el precio por litro. 16. Se pide de 5 facturas introducidas: Facturación total. 23. Pedir 5 calificaciones de alumnos y decir al final si hay algún suspenso. 17. 2.6 €/litro. y mostrar al final si se ha introducido alguno negativo. Pedir 5 números e indicar si alguno es múltiplo de 3. Pedir un número N.0. mostrar la edad y la estatura media. cantidad en litros vendidos del artículo 1 y cuantas facturas se emitieron de más de 600 €. escribir la cantidad de alumnos aprobados. Dadas 6 notas.15. 18. Pedir 10 números. Solo existen tres productos con precios: 1. Igual que el anterior pero suponiendo que no se introduce el precio por litro. 22. la cantidad de alumnos mayores de 18 años. Ejercicios de Programación en Java 195 .3 €/litro y 3. condicionados (=4) y suspensos.

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

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

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

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

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

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

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

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

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

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

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

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