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.

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

Í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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

if(mes==4 || mes==6 || mes==9 || mes==11) dias_del_mes = 30. Ídem que el ej.año.out.out. package bol01ej18. mes=Entrada. System.print("Introduzca mes: "). if(mes==1 || mes==3 || mes==5 || mes==7 || mes==8 || mes==10 || mes==12) dias_del_mes = 31. // guardaremos el número de días que tiene el mes System.out. // suponemos que la fecha introducida es correcta if(mes==2 ) dias_del_mes = 28.print("Introduzca día: ").out.entero(). 17.} } System.entero().println (dia + "/"+ mes + "/" + año).print("Introduzca año: "). // incrementamos el día dia ++. 18. año=Entrada. int dias_del_mes=0. dia=Entrada.mes. System. Ejercicios de Programación en Java 26 . 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).entero().

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ejercicios de Programación en Java

95

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

Boletín 5

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

Ejercicios de Programación en Java

96

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

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

Ejercicios de Programación en Java

97

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

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

Ejercicios de Programación en Java

98

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

while(i<num && primo==true) // en realidad bastaría probar hasta la raíz cuadrada de num { if( num %i == 0) // si es divisible primo=false.9. Ejercicios de Programación en Java 124 . primo=true. package bol06ej09. 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). 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. // si hemos entrado aquí significa que el número no es primo i++. // suponemos que el número es primo // // // // // // este algoritmo se puede mejorar sabiendo que si un número no es divisible entre 2 y su raíz cuadrada. int i. Módulo al que se le pasa un número entero y devuelve el número de divisores primos que tiene.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fibo1). else{ if(num==1) // segundo caso base. también configurable res=fibo1.* . else res=fibo(num-1. int fibo0. else{ if(num==1) // segundo caso base res=1. } return(res). fibo0. if(num==0) // primer caso base res=0. // 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 . 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. else res=fibo(num-1)+fibo(num-2). } static int fibo(int num. int fibo1) { int res.fibo0. fibo1)+fibo(num-2. if(num==0) // primer caso base.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sign up to vote on this title
UsefulNot useful