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

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

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

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

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

ÍNDICE

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

1 4 6

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

I

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

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

1

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

Ejercicios de Programación en Java

2

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

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

Ejercicios de Programación en Java

3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

int suma_fila. pero desde el punto de vista del algoritmo no es relevante.i<7. Ejercicios de Programación en Java 103 . 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.j<tamaño.j. int i. } } } 6.println ().i++) { for (j=0.out. package bol05ej06. t = new int[tamaño][tamaño].j++) System.j<7.// inicializan a 0.i++){ for (j=0. Por lo que esta instrucción no es necesaria.println ("Matriz:"). for (i=0.j++){ System.out..print("Elemento ["+i+"]["+j+"]: ").print(t[i][j]+" "). Crear y cargar una tabla de tamaño 10x10. for (i=0.out. mostrar la suma de cada fila y de cada columna.. Se aña_ // de para que el código sea más comprensible. final int tamaño=4.out.suma_col. System.i<tamaño. System.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

switch (opcion) { case 'v': volumen =Math.out.print("Introduzca un número: ").entero(). public class Main { static void area_o_volumen_cilindro(double radio. public static void main(String[] args) { int num. System.out. 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). Realizar una función que calcule (muestre en pantalla) el área o el volumen de un cilindro.area.println("El volumen es de: " +volumen). doble=2*num.out. según se especifique. doble(num). char opcion){ double volumen. Ejercicios de Programación en Java 121 . num=Entrada. // calculamos el doble de num } System. } } 7.println("El doble es: " +doble).PI*radio*radio*altura. // radio*radio es el radio al cuadrado System.int doble. double altura. package bol06ej07.

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

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

Ejercicios de Programación en Java 124 .9. public class Main { // la función es_primo indica si el número pasado es o no primo // recordamos que un número primo es solo divisible por el mismo y 1 static boolean es_primo(int num) { boolean primo. } } return(primo). int i. primo=true. package bol06ej09. Módulo al que se le pasa un número entero y devuelve el número de divisores primos que tiene. 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 hemos entrado aquí significa que el número no es primo i++. 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.

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

// 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. primo=true. int i.10. public class Main { // la función es_primo indica si el número pasado es o no primo // recordamos que un número primo es solo divisible por el mismo y 1 static boolean es_primo(int num) { boolean primo. while(i<num && primo==true) { if( num %i == 0) // si es divisible primo=false. // 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. Ejercicios de Programación en Java 126 . 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. package bol06ej10. } } return(primo).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

while(i<num && primo==true) { Ejercicios de Programación en Java 145 .Escriba una función que decida si dos números enteros positivos son amigos. entonces ya no será divisible por ningún otro números -> será primo con esta mejora podemos ahorrar muchas vueltas del while para números grandes i=2. primo=true. public class Main { // la función es_primo indica si el número pasado es o no primo // recordamos que un número primo es solo divisible por el mismo y 1 static boolean es_primo(int num) { boolean primo.println("El mcm es: " +mcm). // 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. int i. Dos números son amigos. } } 17.out.System. package bol06ej17.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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. que muestre los números del 0-0-0-0-0 al 9-9-9-9-9.4. Realizar un programa que nos pida un número n. 6. con la particularidad que cada vez que aparezca un 3 lo sustituya por una E. 5. Ejercicios de Programación en Java 197 . Dibuja un cuadrado de n elementos de lado utilizando *.

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

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

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

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

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

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

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

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

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

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

Sign up to vote on this title
UsefulNot useful