P. 1
Ejercicios de Programacion en Java

Ejercicios de Programacion en Java

|Views: 3|Likes:
Publicado porelkinvillas9898

More info:

Published by: elkinvillas9898 on Apr 12, 2013
Copyright:Attribution Non-commercial

Availability:

Read on Scribd mobile: iPhone, iPad and Android.
download as PDF, TXT or read online from Scribd
See more
See less

04/08/2015

pdf

text

original

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ejercicios de Programación en Java

42

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

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

} }

Ejercicios de Programación en Java

43

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

} }

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

Ejercicios de Programación en Java

44

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

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

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

Ejercicios de Programación en Java

45

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1 HASTA 4 PARA j <. Realiza detenidamente una traza al siguiente programa y muestra cual seria la salida por pantalla: PROGRAMA ej_1 VARIABLES suma.3 HASTA 0 INC -1 suma <. 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 . i.Bucles anidados 1.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Ejercicios de Programación en Java

95

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

Boletín 5

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

Ejercicios de Programación en Java

96

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

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

Ejercicios de Programación en Java

97

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

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

Ejercicios de Programación en Java

98

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.Ídem diseñar una función que devuelve una tabla con los divisores. // si hemos entrado aquí significa que el número no es primo i++. public class Main { // la función es_primo indica si el número pasado es o no primo // recordamos que un número primo es solo divisible por el mismo y 1 static boolean es_primo(int num) { boolean primo. int i. } } return(primo).10. // 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. Ejercicios de Programación en Java 126 . package bol06ej10. while(i<num && primo==true) { if( num %i == 0) // si es divisible primo=false. primo=true.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static boolean amenaza_caballo (int tablero[][]. posy += dy. int pos[]) { boolean amenaza=false. 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. posx += dx.// 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]. 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. } } return (pieza).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

You're Reading a Free Preview

Descarga
scribd
/*********** DO NOT ALTER ANYTHING BELOW THIS LINE ! ************/ var s_code=s.t();if(s_code)document.write(s_code)//-->