Source: https://www.scribd.com/doc/58071238/Java
Timestamp: 2017-03-23 23:22:38+00:00

Document:
BrowseInterestsStay InformedCareerPersonal GrowthFiction & BiographiesHealth & FitnessLifestyleCultureBrowse byBooksAudiobooksNews & MagazinesSheet MusicBrowse allUploadSign inJoinAfianza tus conocimientos de programación mediante la resolución de ejerciciosEjercicios de Programación en Java
Condicionales, Bucles, Tablas y Funciones
F.M. Pérez Montes
Esta obra está publicada bajo una licencia: Creative Commons Reconocimiento-No Comercial-Sin Obra Derivada 3.0 España, que le permite copiar, distribuir y comunicar públicamente la obra, siempre y cuando reconozca el crédito del autor, lo haga sin fines comerciales y no altere, transforme o genere una obra derivada a partir de ésta. Dispone del texto legal completo en la siguiente dirección: http://creativecommons.org/licenses/by-nc-nd/3.0/es/ ©2011, Francisco Manuel Pérez Montes. Algunos derechos reservados. Edita Asoc. Por la Innovación Educativa Eduinnova. Esta obra se encuentra disponile en: http://www.eduinnova.es/monografias2011/ene2011/java.pdf Depósito legal: SE 1211-2011. ISBN: 978-84-614-7595-7.
A mi hija Claudia, la solución a todos los problemas.
por sus innumerables correcciones y por la clase Entrada. En especial a mi amigo y compañero: Alfonso Jiménez.AGRADECIMIENTOS
Prólogo ............................................... Página Introducción .......................................... Página Boletín 1 (Variables y condicionales) ................. Página
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
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
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
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
escuela técnica o ciclo formativo de grado superior...... utilizando distintos enfoques.. Bucles anidados Boletín 4.......... Tablas n-dimensionales Boletín 6... Funciones
Los ejercicios no tienen solución única. dejando de lado la eficiencia. aquí se plantea la más didáctica y fácil de entender... son el complemento ideal para las clases de programación impartidas en una facultas.. Cuando existen distintas soluciones.. En cada boletín se resuelven ejercicios con una temática común..
... de la siguiente forma:
Boletín 1.INTRODUCCIÓN
Este libro está compuesto como una colección de boletines de ejercicios (se encuentran disponibles en el Apéndice I).. Variables y condicionales Boletín 2... La resolución de los ejercicios de programación... Condicionales y bucles Boletín 3. se incluye más de una solución por ejercicio.. Tablas Boletín 5.
lo que plantea el problema de empezar a explicar código y funciones que se escapan al programador novel. Las funciones que proporciona la clase Entrada son:
Entrada.entero() Entrada. que permite realizar de forma transparente la entrada por teclado. algo primordial para poder introducir datos y probar nuestros programas. La clase Entrada se encuentra en el Apéndice II.Otro aspecto importante es la entrada por teclado. Aprender a utilizarla es sencillo y proporciona una herramienta cómoda y fiable para dejar de preocuparnos por la entrada de datos. Por todo esto. En un principio el alumno no debe tener los conocimientos necesarios para escribir el código que le proporcione dicha entrada.real() Entrada.cadena() Entrada. se ha diseñado la clase Entrada. Algo similar ocurre en las asignaturas de programación.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
d. // coeficientes ax^2+bx+c=0 double x1.out.println("No existen soluciones reales"). System.Variables y condicionales
1. b=Entrada. if(d<0) System.out. debe indicarlo.c.x2.out. a=Entrada. // soluciones y determinante System.entero(). System.b.println("Introduzca primer coeficiente (a):"). else{ // queda confirmar que a sea distinto de 0. c=Entrada. Si no existen. // calculamos el determinante d=((b*b)-4*a*c).
package bol01ej01.entero().println("Introduzca tercer coeficiente: (c):").println("Introduzca segundo coeficiente: (b):"). public class Main { public static void main(String[] args) { double a. y muestre sus soluciones reales.
.entero().out. Pedir los coeficientes de una ecuación se 2º grado.
sqrt(d))/(2*a).out.out. x1=(-b+Math. public class Main { public static void main(String[] args) { double a.
package bol01ej02. Pedir el radio de una circunferencia y calcular su longitud. System.out. x2=(-b-Math. 2) System.println("Solución: " + x2).pow (r.
package bol01ej03. A=PI*r^2. Pedir el radio de un círculo y calcular su área. // para elevar al cuadrado otra opción es: Math. public class Main {
. // área y radio System.sqrt(d))/(2*a). } } }
2. r=Entrada. a=Math.print("Introduce el radio de un circulo: "). System.real().println("Solución: " + x1).r. } }
3.println("El área de una circunferencia de radio " + r+ " es: " + a).PI*(r*r).out.// si a=0 nos encontramos una división por cero.
public class Main { public static void main(String[] args) { int n1. System. if(n1==n2) System.println("La longitud de una circunferencia de radio " + r+ " es: " + l). r=Entrada. else System.println("No son iguales").public static void main(String[] args) { double l. Pedir dos números y decir si son iguales o no. n1=Entrada. } }
4.r.entero().real(). System.
package bol01ej04. // longitud y radio System. System. l=2*Math. } }
.out.out.out.print("Introduce el radio de una circunferencia: ").n2.entero().out.out.println("Son iguales").print("Introduce un número: ").out. n2=Entrada.PI*r.print("Introduce otro número: ").
n1=Entrada.out.
package bol01ej05.
.print("Introduce un número: ").entero(). Pedir un número e indicar si es positivo o negativo.
6. public class Main { public static void main(String[] args) { int num. System.entero(). num=Entrada.
package bol01ej06.n2. System.print("Introduce un número: "). System. System.println("Negativo").out.out.entero().out. public class Main { public static void main(String[] args) { int n1.println("Positivo").out. n2=Entrada. if( num < 0) System.5. Pedir dos números y decir si uno es múltiplo del otro. else // suponemos que el 0 es positivo.print("Introduce otro número: ").
. public class Main { public static void main(String[] args) { int n1.out. System.println("Son múltiplos").
7.print("Introduce un número: ").
package bol01ej07.println(n1 + " es mayor que " + n2). n1=Entrada. Pedir dos números y decir cual es el mayor.println("No son múltiplos"). n2=Entrada.println(n2 + " es mayor que " + n1).entero().} }
if(n1%n2==0) System.print("Introduce otro número: ").entero().out. // si ambos números son iguales diría que n2 es mayor que n1 if(n1>n2) System.out. else System. System. else System.out.out.out.n2.
. else System. else { if(n1>n2) System. Pedir dos números y mostrarlos ordenados de mayor a menor.8.out.entero().print("Introduce un número: "). public class Main { public static void main(String[] args) { int n1. }
package bol01ej09.entero().
package bol01ej08.out.out.println("Son iguales").n2.n2. n1=Entrada.println(n2 + " es mayor que " + n1). n2=Entrada.out. public class Main { public static void main(String[] args) { int n1. if(n1==n2) System.print("Introduce otro número: ").println(n1 + " es mayor que " + n2).out. System. Pedir dos números y decir cual es el mayor o si son iguales. System.
out.println(a+". c=Entrada. System.
.System.out. if(a>b && b>c) System. else System.c.
package bol01ej10. n2=Entrada. n1=Entrada.out. System. } }
10. System.entero().out. System. if(n1>n2) System.entero().print("Introduzca segundo número: "). "+c).entero(). public class Main { public static void main(String[] args) { int a.out. else{ if(a>c && c>b) System. Pedir tres números y mostrarlos ordenados de mayor a menor.println(n1 + " y " + n2).out.print("Introduzca primer número: "). a=Entrada. "+c+".print("Introduce otro número: ").println(n2 + " y " + n1).out.println( a+". "+b).print("Introduzca tercer número: ").entero().out.print("Introduce un número: ").entero(). "+b+".b. b=Entrada.out.
else{ if(c>a && a>b) System. else{ if(b>c && c>a) System. public class Main { public static void main(String[] args) { int num.out.print("Introduzca un número entre 0 y 99.out. "+c).println("tiene 1 cifra"). num=Entrada. "+a).out.
package bol01ej11.else{ if(b>a && a>c) System.println(b+".out. if(num<10) System.entero(). "+c+". Pedir un número entre 0 y 9.999 y decir cuantas cifras tiene. "+b+". } } } } } } }
11. System.
. "+b). "+a).println(c+".println(c+". "+a+".out.999: ").println(b+". else{ if(c>b && b>a) System. "+a+".out.
println("tiene 5 cifras"). else{ if(num<100000) System. c.println("tiene 2 cifras").999 y mostrarlo con las cifras al revés. u: (unidades)
.out.out. 9 9 9 a cada guarismo lo llamaremos: //dm um c d u: dm (decenas de millar). u. else{ if(num<10000) System. // 9 9 . um:(unidades de millar) // c: (centenas). d: (decenas). int dm.println("tiene 3 cifras").println("tiene 4 cifras").out. d. else{ if(num<1000) System. } } } } } }
package bol01ej12.else{ if(num<100) System. um. public class Main { public static void main(String[] args) { int num.out. Pedir un número entre 0 y 9.
num = num / 10.System. num = num / 10. } }
13.entero().
. // decenas de millar dm = num.out. decir si es capicúa. Pedir un número entre 0 y 9.println (num). num = num / 10.999.print("Introduzca un número entre 0 y 99.999: "). // decenas d = num % 10. // unidades de millar um = num % 10. // lo imprimimos al revés: System.
package bol01ej13. num = num / 10. // unidad u = num % 10. // otra forma de hacerlo es num = 10000*u + 1000*d + 100*c + 10*um + dm. num=Entrada.out.println (u + " " + d + " " + c + " " + um + " " + dm). // centenas c = num % 10. System.out.
public class Main { public static void main(String[] args) { int num. // centenas c = num % 10. // decenas de millar dm = num. // unidad u = num % 10.out. num = num / 10. c. num = num / 10.entero().print("Introduzca un número entre 0 y 99. u. num = num / 10. int dm. // decenas d = num % 10. u: (unidades) System. // el número será capicúa si las cifras son iguales dos a dos por los extremos // las centenas no las tenemos en cuenta
. num=Entrada. // unidades de millar um = num % 10. num = num / 10. d. um:(unidades de millar) // c: (centenas). d: (decenas). um.999: "). // 9 9 . 9 9 9 a cada guarismo lo llamaremos: //dm um c d u: dm (decenas de millar).
.out. pero nuestro código lo identifica como NO capicúa. // suponemos que el número no es capicúa. c. Ya // que trabajamos con el 00121. num=Entrada.entero().out. // hay que tener en cuenta que en este ejercicio el número 121 es similar al 00121 y // resulta que 121 es capicúa. // unidad u = num % 10. um. // 9 9 .if (dm == u && um == d) System. public class Main { public static void main(String[] args) { int num. else System. u: (unidades) // En esta versión haremos que el número 121 ó el 33 sea visto como capicúa. 9 9 9 a cada guarismo lo llamaremos: //dm um c d u: dm (decenas de millar).println ("el número NO es capicúa"). boolean capicua = false. d.print("Introduzca un número entre 0 y 99.out.println ("el número es capicúa"). num = num / 10. System. // La idea es no tener en cuenta los ceros por la derecha. No tendremos en cuenta este pequeño error. int dm.999: "). u. } }
package bol01ej13. um:(unidades de millar) // c: (centenas). d: (decenas).
um.println ("el número es capicúa"). c. //si el número tiene 2 cifras (0. num = num / 10. um. u) if (dm == u && um == d) capicua = true. 0. // unidades de millar um = num % 10. //si el número tiene 4 cifras (0.
. 0. // se entiende que un número de una cifra no es capicúa if (capicua) System. 0. c. u) if (dm == 0 && um==0 && c == u) capicua = true. u) if (dm == 0 && um == u && c == d) capicua = true. //si el número tiene 3 cifras (0. d. //si el número tiene 5 cifras (dm. num = num / 10.// decenas d = num % 10. d. // centenas c = num % 10. d. u) if (dm == 0 && um == 0 && c == 0 && d == u) capicua = true. c. num = num / 10. // decenas de millar dm = num. d.out.
nota=Entrada.println ("el número NO es capicúa"). Suficiente.else } }
System. Bien. else if(nota==5) System.print("Introduzca una nota: "). else
.println("BIEN").entero(). public class Main { public static void main(String[] args) { int nota.out. else if(nota==7 || nota==8) System.println("INSUFICIENTE"). // 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.println("SUFICIENTE").
14.out.out. Pedir una nota de 0 a 10 y mostrarla de la forma: Insuficiente. else if(nota==6) System..out.println("NOTABLE").out.
package bol01ej14.out.. System.
out.out. break.out.println("SUFICIENTE").println("NOTABLE").print("Introduzca una nota: "). case 6: System.out.entero(). break.println("SOBRESALIENTE"). case 5: System.out. public class Main { public static void main(String[] args) { int nota.out. case 9:
package bol01ej14b.if(nota==9 || nota==10 ) System.println("INSUFICIENTE"). nota=Entrada.println("BIEN"). break. break. case 7: case 8: System. System. switch(nota){ case 0: case 1: case 2: case 3: case 4: System.
.case 10: System.30 mes en el rango 1. año=Entrada.entero().out.out.
package bol01ej15. Suponiendo todos los meses de 30 días. public class Main { public static void main(String[] args) { int dia.println("ERROR"). if (dia >= 1 && dia <=30) if (mes >= 1 && mes <= 12)
.entero().out.entero().12 año cualquiera distinto del 0
System. break. } } }
15. break. mes y año de una fecha e indicar si la fecha es correcta. System. // // // // para que una fecha sea correcta se tiene que cumplir día en el rango 1.. default: System.print("Introduzca día: "). Pedir el día. dia=Entrada.mes.out. mes=Entrada.print("Introduzca año: ").println("SOBRESALIENTE").año.out. System.print("Introduzca mes: ").
out. dia=Entrada.out.
16.println("Día incorrecto").print("Introduzca día: "). Pedir el día. mes=Entrada.mes.entero().out.println("Mes incorrecto"). else else } } System. mes y año de una fecha e indicar si la fecha es correcta. System.out.print("Introduzca año: "). else System.print("Introduzca mes: ").out.println ("Fecha correcta").entero().
System.out. Con meses de 28.println("Fecha incorrecta"). System.println ("Año incorrecto").out.out. Sin años bisiestos. System.año.entero().
package bol01ej16. else{ if(mes==2 && (dia>=1 && dia<=28))
. 30 y 31 días.if (año != 0) System. public class Main { public static void main(String[] args) { int dia. año=Entrada. // el único año que no existe es el 0 if(año==0) System.
package bol01ej16. dia=Entrada.out.año. int dias_del_mes.out.out.println("Fecha incorrecta"). mes=Entrada.System.println(dia + "/" + mes + "/" + año+": Fecha correcta"). System. año=Entrada.
.print("Introduzca día: "). public class Main { public static void main(String[] args) { int dia.entero().entero().print("Introduzca mes: ").println(dia + "/" + mes + "/" + año+": Fecha correcta").out. System.out.println(dia + "/" + mes + "/" + año+": Fecha correcta").mes. boolean fecha_correcta=true. else System. else{ if((mes==4 || mes==6 || mes==9 || mes==11) && (dia>=1 && dia<=30)) System.out. else{ if( (mes==1 || mes==3 || mes==5 || mes==7 || mes==8 || mes==10 || mes==12) && (dia>=1 && dia<=31)) System.out.entero(). System.print("Introduzca año: ").
if (mes<1 || mes >12) // un mes fuera del rango 1.12 no tiene sentido fecha_correcta = false. mes y año de una fecha correcta y mostrar la fecha del día siguiente. if (dia > dias_del_mes) fecha_correcta = false. if(mes==2 ) dias_del_mes = 28.out.println("Fecha incorrecta").println(dia + "/" + mes + "/" + año+": Fecha correcta"). if(mes==4 || mes==6 || mes==9 || mes==11) dias_del_mes = 30.. // si se utiliza un mes fuera del rango 1. if(año==0) // el único año que no existe es el 0 fecha_correcta = false. else System.31 no tiene sentido fecha_correcta = false. if (dia<1 || dia >31) // un día fuera del rango 1.out. suponer que todos los meses tienen 30 días. if (fecha_correcta) System.. public class Main {
package bol01ej17.dias_del_mes = 0.12 // supondremos que los días del mes son 0.
17. if(mes==1 || mes==3 || mes==5 || mes==7 || mes==8 || mes==10 || mes==12) dias_del_mes = 31. Pedir el día.
entero().print("Introduzca año: "). mes ++. System. // si el mes supera 12.out. año=Entrada.entero(). lo reiniciamos a 1 e incrementamos el mes if (dia >= 30) { dia = 1.print("Introduzca día: "). dia=Entrada.año.
. mes=Entrada.print("Introduzca mes: ").entero(). System. System.out.mes. // suponemos que la fecha introducida es correcta // incrementamos el día dia ++.out. // si el día supera 30.public static void main(String[] args) { int dia. año ++. lo reiniciamos a 1 e incrementamos el año if (mes >= 12) { mes = 1. } } // 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.
if(mes==1 || mes==3 || mes==5 || mes==7 || mes==8 || mes==10 || mes==12) dias_del_mes = 31. año=Entrada. // incrementamos el día dia ++.entero(). public class Main { public static void main(String[] args) { int dia.mes.entero(). System.out.out.} }
System. Ídem que el ej. mes=Entrada.año.print("Introduzca mes: ").
18.out.println (dia + "/"+ mes + "/" + año).out.print("Introduzca día: "). // guardaremos el número de días que tiene el mes System.
package bol01ej18. suponiendo que cada mes tiene un número distinto de días (suponer que febrero tiene siempre 28 días). System. if(mes==4 || mes==6 || mes==9 || mes==11) dias_del_mes = 30. 17. // suponemos que la fecha introducida es correcta if(mes==2 ) dias_del_mes = 28.print("Introduzca año: ").
. dia=Entrada. int dias_del_mes=0.entero().
Pedir dos fechas y mostrar el número de días que hay de diferencia.// si el día supera el número de días del mes. lo reiniciamos a 1 e incrementamos el año if (mes >= 12) { mes = 1. System.out.println (dia + "/"+ mes + "/" + año).
package bol01ej19. // si el mes supera 12. } }
19. // lo reiniciamos a 1 e incrementamos el mes if (dia >= dias_del_mes) { dia = 1. mes ++. Suponiendo todos los meses de 30 días. año ++. public class Main {
} // habría que tener en cuenta que el año pasa del -1 al +1 // en este código pasaríamos del año -1 al 0 (que nunca existió) // para corregirlo: if (año == 0) año = 1.
out. System.print("Introduzca día: "). dia1=Entrada.out. System.entero().out. System.public static void main(String[] args) { int dia1. int dia2.
package bol01ej20. año2=Entrada.año2.entero(). mes1=Entrada. System.out. System. mes2=Entrada. año1=Entrada. int total_dias.print("Introduzca mes: ").out.print("Introduzca año: ").println ("Fecha 1:").out.out.println ("Fecha 2:").out. } } System. Pedir una hora de la forma hora.mes2.entero().entero().print("Introduzca año: ").año1. System. dia2=Entrada.entero(). minutos y segundos.mes1.println ("Días de diferencia: " + total_dias). y mostrar la hora en el segundo siguiente. // 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).
20.print("Introduzca día: "). System.entero().out.
. System.print("Introduzca mes: ").
public class Main { public static void main(String[] args) { int h.out. // si los minutos superan 59.entero(). } } System.out.out. } }
. // hora.print("Introduzca hora: "). los reiniciamos a 0 e incrementamos los minutos if (s >= 60) { s = 0.s.println ("Fecha: "+ h + ":"+ m + ":" + s).entero().print("Introduzca segundos: "). h ++. // si los segundos superan 59. System. m=Entrada.out. minutos y segundos System. h=Entrada. la reiniciamos a 0 if (h>=24) h=0. System. // si la hora supera 23. s=Entrada. m ++.m. // suponemos que la hora introducida es correcta // incrementamos los segundos s ++.entero().print("Introduzca minutos: "). los reiniciamos a 0 e incrementamos la hora if (m >= 60) { m = 0.
break.entero().out. case 5: System.. break.out.println("DOS").print("Introduzca una nota numérica entre 0 y 10: ").21.out. public class Main { public static void main(String[] args) { int num.
package bol01ej21. break. case 2: System. tres. System.println("TRES"). break. case 4: System. case 3: System.
. dos. y mostrar dicha nota de la forma: cero. num=Entrada.out..println("UNO").out. case 1: System.out. uno. switch(num){ case 0: System. break. break.out.println("CUATRO").println("CINCO").println("CERO"). Pedir una nota numérica entera entre 0 y 10.
Pedir un número de 0 a 99 y mostrarlo escrito.out. break. break.println("OCHO").
22. break. para 56 mostrar: cincuenta y seis.
. decenas. // esta versión muesrta 11 como diez y uno. break. public class Main { public static void main(String[] args) { int num. case 7: System.case 6: System. break. case 10: System.out. // es una forma de hacerlo bastante burda. case 9: System.println("SEIS"). Por ejemplo.
package bol01ej22. case 8: System.println("NUEVE").out.out.println("DIEZ").println("SIETE"). int unidades.out.
print("cincuenta").out. break. case 4: System. break.out. case 2: System. decenas = num / 10..print("diez").out.out. case 1: System.print("Introduzca un número (0 a 99): ")..entero(). break.out.print("cuarenta"). unidades = num % 10.
. // y otro condicional para mostrar "y" System.print("treinta").. case 3: System. break. switch(decenas){ case 0: System.print("").print("veinte"). case 6: System.out. num=Entrada. break. case 5: System. break.12.out.print("sesenta").// se puede poner algunos condicionales para los números especiales: 11.out.
println("cuatro").println("dos").print("noventa").print (" y ").out. case 1: System. break. break. case 7: System. switch(unidades){ case 0: System.out. case 8: System. break. break. break.out. break.out. case 4: System.out.println("").out.
.println("tres").print("setenta").print("ochenta"). case 2: System. case 3: System.break.out.out.println("uno"). case 9: System.out. break.
break.println("seis").
. break.break. break.println("cinco").println("ocho"). break.println("nueva").out. case 8: System. case 9: System.println("siete").out. case 7: System.out.out. case 5: System. case 6: System.out. break.
while(num>=0){ // repetimos el proceso mientras el número leído no sea negativo cuadrado=num*num. public class Main { public static void main(String[] args) { int num.out. System.
package bol02ej01. // volvemos a leer num } } }
. Leer un número y mostrar su cuadrado.entero().out.out.entero(). repetir el proceso hasta que se introduzca un número negativo.print("Introduzca otro número: ").cuadrado. num=Entrada. num=Entrada. System.Condicionales y bucles
1. // num guardará el número que leamos // y cuadrado guardará el cuadrado de num System.println(num+ "² es igual a "+ cuadrado).print("Introduzca número: ").
println("Positivo"). public class Main { public static void main(String[] args) { int num.out.out.print("Introduzca otro número: ").
package bol02ej02. else // si no es positivo: es negativo System. while(num!=0) // mientras num sea distinto de 0 { if(num>0) // mayor que cero: positivo System. // repetimos el proceso y volvemos a leer num System.2. System. Para cada uno indicar si es par o impar.println("Negativo"). Leer un número e indicar si es positivo o negativo. } // al salir del mientras tenemos la certeza que num es 0 } }
3. num=Entrada.out. Leer números hasta que se introduzca un 0.out.
package bol02ej03. num=Entrada.entero(). El proceso se repetirá hasta que se introduzca un 0.entero().print("Introduzca un número: ").
println("Impar").out. contador.
} // al salir del mientras tenemos la certeza que num es 0
4.out. // repetimos el proceso y volvemos a leer num System.println("Par").out.out.entero(). 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. public class Main { public static void main(String[] args) { int num.entero(). System. num=Entrada.print("Introduzca otro número: "). Pedir números hasta que se teclee uno negativo.public class Main { public static void main(String[] args) { int num. num=Entrada.
. y mostrar cuántos números se han introducido.print("Introduzca un número: ").
package bol02ej04. else // en caso contrario: impar System.
// num guardará los números introducidos // y contador se incrementará para llevar la cuenta de los números introducidos System. num=Entrada.out. num=Entrada.
package bol02ej05. // al comienzo el número de números introducidos es 0
while(num>0) // mientras num sea positiva { contador =contador+1. num.println("Se han introducido: " +contador + " números"). public class Main { public static void main(String[] args) { int n. Para ello pedir un número N. // sin tener en cuenta el último número negativo.print("Introduzca un número: "). contador=0.out.out.
System.entero(). // contador toma el valor que tuviera en este momento más uno // en definitiva: contador se incrementa en uno System. Realizar un juego para adivinar un número. El proceso termina cuando el usuario acierta.
5. y luego ir pidiendo números indicando “mayor” o “menor” según sea mayor o menor con respecto a N.entero().print("Introduzca otro número: ").
System.out.out. System.// n es el número que hay que acertar // num guarda los números introducidos System. num=Entrada. num=Entrada.println("mayor").
.entero().println("menor"). num.out. n =Entrada. public class Main { public static void main(String[] args) { int n... while(num!=n) // mientras no coincidan ambos números { if(num>n) System.entero().print("Introduce número: ").out. // n es el número que hay que acertar // num guarda los números introducidos System.print("Introduce N: ").entero().print("Introduce número: ").out.out."). else System. } // al salir del mientras tenemos la certeza que num es igual a n } } package bol02ej05.println("acertaste.
print("Introduce número: "). System.
package bol02ej06. while(num!=n) // mientras no coincidan ambos números { if(num>n) System.println("menor").println("mayor").
// al salir del mientras tenemos la certeza que num es igual a n System. num=Entrada.n=(int)(Math. System.")... } }
6. num=Entrada.out.out..entero(). Pedir números hasta que se teclee un 0.print("Introduce número: ").entero().out. mostrar la suma de todos los números introducidos.println("acertaste. // en lugar de pedir n. // Así el juego es algo más entretenido.out. public class Main { public static void main(String[] args) {
..random()*100)+1. else System.out. podemos hacer que se n tome un valor // aleatorio entre 1 y 100.
System.println("La suma de todos los números es: "+suma). System. y calcular la media.int num. suma=suma+num.suma.
while(num!=0). Pedir números hasta que se introduzca uno negativo. // 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
. num=Entrada.out.
package bol02ej07. } }
7. suma=0. public class Main { public static void main(String[] args) { int num.out.entero(). float media. elementos.print("Introduzca un número: "). 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) {
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 { }
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,
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();
media_neg.i--) { factorial=factorial*i. // las medias 8positivas y negativa9 pueden tener decimales
.i>0. int cont_ceros. // el contador de ceros int cont_pos. // es importante inicializarlo a 1. ya que multiplicará// por ejemplo: el factorial de 10 es: // 10*9*8*7*6*5*4*3*2*1 for (int i=num.out. Pedir 10 números.
package bol02ej13. // contador de positivos int cont_neg. // contador de negativos int suma_pos.factorial=1. public class Main { public static void main(String[] args) { int num.println("El factorial de " + num + " es: " + factorial). } } } System. Mostrar la media de los números positivos. la media de los números negativos y la cantidad de ceros.suma_neg.
13. // suma de los números positivos y negativos float media_pos.
. num=Entrada.entero(). //Tratamos los positivos if (cont_pos ==0) System. for (int i=1.out.i<=10. } else { cont_neg++. } } } // tratamos los ceros System.println("No se puede hacer la media de los positivos").out. suma_pos+=num. if(num==0) cont_ceros++.i++) { System.out. suma_neg=0.println("El número de ceros introducidos es de: "+cont_ceros). else { if(num>0) { cont_pos++.print("Introduce número: "). cont_pos=0. suma_pos=0. suma_neg+=num. cont_neg=0.cont_ceros=0.
package bol02ej14. else { media_neg= (float)suma_neg/cont_neg. } } }
14.mayor_1000. if(sueldo>1000) mayor_1000++.
. suma=0. } // tratamos los negativos if (cont_pos ==0) System. System. for (int i=1. public class Main { public static void main(String[] args) { int sueldo.println("No se puede hacer la media de los negativos").entero().println("Media de los positivos: "+ media_pos).i++) { System.println("Media de los negativos: "+ media_neg). mayor_1000=0. sueldo =Entrada.suma.out.out. Pedir 10 sueldos. System.out.print("Escribe un sueldo: ").out. Mostrar su suma y cuantos hay mayores de 1000€.i<10.else { media_pos= (float)suma_pos/cont_pos.
i<5. public class Main { public static void main(String[] args) { int edad.println("la suma es de: "+suma).
package bol02ej15.out.out.media_edad.out. suma_edad=0.
15.print("Introduzca edad: "). mayor_175=0.out.suma_edad. edad=Entrada.real(). for (int i=1. media_altura=0.i++){ System.entero().75. y la cantidad de alumnos que miden más de 1.suma_alt.println("Alumno " +i). la cantidad de alumnos mayores de 18 años. System. System. if(edad>18) mayor_edad++.media_altura.suma=suma+sueldo. Dadas las edades y alturas de 5 alumnos.print("Introduzca altura: "). suma_alt=0.out. mayor_edad=0. altura=Entrada.mayor_edad.mayor_175.println("Mayores de 1000 hay: "+mayor_1000). } System. //mayor_edad: mayores de 18 años double altura. System. mostrar la edad y la estatura media.
if(altura>1.out. System. num=Entrada.75) mayor_175++.println("La altura media es de: " +media_altura).println("Mayor de 1.out. suma_alt=suma_alt+altura. public class Main { public static void main(String[] args) { int num.out. System.entero().print("Introduce número (de 0 a 10): ").
package bol02ej16.println("Mayor de 18 años: " +mayor_edad). } media_edad=suma_edad/5. do { System.75: " +mayor_175). System.
16. suma_edad=suma_edad+edad. System.out. Pide un número (que debe estar entre 0 y 10) y mostrar la tabla de multiplicar de dicho número. }
. media_altura=suma_alt/5.out.println("\n\nLa edad media es de: " +media_edad).
for (int i=1. Una empresa que se dedica a la venta de desinfectantes necesita un programa para gestionar las facturas.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
. la cantidad vendida en litros y el precio por litro.out. // el precio por litro en cada factura float importe_factura. // el código del artículo en cada factura int litros.out.i++) { System.
System. public class Main { public static void main(String[] args) { int codigo.i<=10. En cada factura figura: el código del artículo. Se pide de 5 facturas introducidas: Facturación total.
package bol02ej17. int litros_cod1. cantidad en litros vendidos del artículo 1 y cuantas facturas se emitieron de más de 600 €.println("\n\nTabla del " + num). // la cantidad de litros en cada factura float precio. float facturacion_total.
print("cantidad (litros): "). if(importe_factura >= 600) mas_600 ++.print("precio (litro): "). facturacion_total += importe_factura. codigo=Entrada.out.println("La facturación total es de: " +facturacion_total + "€").
. if (codigo == 1) litros_cod1 += litros. litros=Entrada.
// contador que sirve para llevar la cuenta de cuantas facturas hay de
for (int i=1.out.entero(). System. // facturación total System.int mas_600.i<=5. System. mas_600 = 0.out.entero().real().out.print("código de producto: "). importe_factura = litros*precio. System. precio= (float)Entrada. litros_cod1 = 0.println("Factura nº " + i).out.i++) { System. más de 600 € facturacion_total = 0.println("\n\n\nResumen de ventas\n").out. } System.
// la cantidad de litros en cada factura float precio. // guardará el importe de la factura con la que estemos trabajando // el importe de todas las facturas // el total de litros vendidos del producto 1 en todas las facturas // contador que sirve para llevar la cuenta de cuantas facturas hay de
. float facturacion_total. // el código del artículo en cada factura int litros. // ahora el precio no se pide por teclado float importe_factura.
package bol02ej18. int litros_cod1.1.3 €/litro y 3. Solo existen tres productos con precios: 1.out.6 €/litro. int mas_600.// litros del articulo 1 System. más de 600 € facturacion_total = 0. } }
18. Igual que el anterior pero suponiendo que no se introduce el precio por litro.25 €/litro. public class Main { public static void main(String[] args) { int codigo.println("Ventas del producto 1: " + litros_cod1 + " litros"). // factura de mas de 600 euros System.0.println("Factura superior a 600€: " + mas_600). 2.out.
println("Factura nº " + i). // este caso no debe darse
importe_factura = litros*precio.out. for (int i=1.entero(). case 2: precio = 3f.i++) { System. break.6f. if (codigo == 1)
.25f. break. default: precio = 0. break. System. mas_600 = 0. facturacion_total += importe_factura.print("cantidad (litros): ").out.i<=5.print("código de producto: ").entero().out. codigo=Entrada. System. switch (codigo) { case 1: precio = 0. litros=Entrada. case 3: precio = 1.litros_cod1 = 0.
aprobados=0.
. } System. } }
19. suspensos=0. Dadas 6 notas. // litros del articulo 1 System. escribir la cantidad de alumnos aprobados. // factura de mas de 600 euros System.println ("\n\n\nResumen de ventas\n").out. if(importe_factura >= 600) mas_600 ++.println("Ventas del producto 1: " + litros_cod1 + " litros"). condicionados (=4) y suspensos.println("Factura superior a 600€: " + mas_600).println("La facturación total es de: " +facturacion_total + "€").aprobados. public class Main { public static void main(String[] args) { int nota.condicionados.litros_cod1 += litros.suspensos.out.
package bol02ej19. // facturación total System.out.out.
20. nota=Entrada.out. y mostrar el sueldo máximo. introducir N sueldos. for (int i=1. if(nota == 4) condicionados++.println("Condicionados: "+condicionados). else if(nota >= 5) aprobados++. else if(nota < 4) // este if sobra.out. System.out.println("Aprobados: " +aprobados).i<=6.i++) { System.print("Introduzca nota entre 0 y 10: ").println("Suspensos: " +suspensos).
package bol02ej20. System.out.condicionados=0. public class Main { public static void main(String[] args) {
. ya que es el único caso posible suspensos++. Pedir un número N. } System.entero().
println("--------"). int n. // si leemos un sueldo mayor que el máximo. n = Entrada. sueldo_max = 0. public class Main { public static void main(String[] args) { int sueldo. inicializamos el sueldo // máximo a cero.int sueldo. System.i<=n. int n. sueldo_max=0.println("\nEl sueldo máximo es: " +sueldo_max). System. este sueldo será el nuevo máximo. sueldo=Entrada.out. } } } package bol02ej20. if (sueldo > sueldo_max) sueldo_max = sueldo.entero(). sueldo_max.i++) { System.entero().print("Introduce sueldo: ").out. // como los sueldos son positivos.out. for (int i=1.
.out.print("Número de sueldos: "). System.
System.boolean primer_sueldo_asignado. } if (sueldo > sueldo_max) sueldo_max = sueldo.println("--------"). }
.i<=n. for (int i=1. // esta bandera indica si hemos asignado el primer sueldo como sueldo máximo // con esto podremos tener sueldos negativos primer_sueldo_asignado = false. este sueldo será el nuevo máximo.println("\nEl sueldo máximo es: " +sueldo_max).i++) { System. System. sueldo=Entrada.out.print("Introduce sueldo: "). if (primer_sueldo_asignado == false) { // asignamos como máximo el primer sueldo leído sueldo_max = sueldo.
System. primer_sueldo_asignado = true.entero().entero(). n = Entrada.out.print("Número de sueldos: ").out.out. // si leemos un sueldo mayor que el máximo.
package bol02ej21. boolean hay_negativo.print("Introduce número: "). Pedir 10 números. } }
.i<=10.out. if(num<0) hay_negativo =true. public class Main { public static void main(String[] args) { int num.out. cambiamos el valor de hay_negativo a true } if(hay_negativo == true) System.println("Se ha introducido algún número negativo"). num=Entrada. else System.out. y mostrar al final si se ha introducido alguno negativo. // la variable hay_negativo según los dos posibles valores indica: // false: no se ha introducido ningún número negativo // true: al menos hay un número negativo hay_negativo =false. // si num es menor que cero.21.i++) { System. // suponemos que no habrá ningún negativo for (int i=1.entero().println("No hay ningún número negativo").
i++) { System. if(notas<5) suspensos=true.out. boolean suspensos.
if(suspensos) System.println("No hay suspensos"). public class Main {
.22.print("Introduzca nota (de 0 a 10): ").out.out.
package bol02ej22. Pedir 5 calificaciones de alumnos y decir al final si hay algún suspenso.entero(). Pedir 5 números e indicar si alguno es múltiplo de 3.
package bol02ej23.println("Hay alumnos suspensos"). notas=Entrada. public class Main { public static void main(String[] args) { int notas.
23. suspensos=false.i<5. // suponemos que en principio no hay ningún suspenso for (int i=0. else System.
out.println("Hay múltiplos de 3").out. multiplo_3=false.println("no existen múltiplos de 3"). boolean multiplo_3.public static void main(String[] args) { int num. if(num %3 == 0) multiplo_3=true. // si se ejecuta esta instrucción significa que al menos hay un múltiplo } if(multiplo_3 == false) System. } }
.i++){ System.print("Introduzca número: ").i<5. num=Entrada. for (int i=0.out.entero(). else System.
Realiza detenidamente una traza al siguiente programa y muestra cual seria la salida por pantalla: PROGRAMA ej_1 VARIABLES suma. i.3 HASTA 0 INC -1 suma <.i*10+j escribir (suma) FIN PARA FIN PARA FIN
.1 HASTA 4 PARA j <. j: ENTERO COMIENZO PARA i <.Bucles anidados
for (int i=0.i+1 MIENTRAS j < 4 escribir (j-i) j <.i<4. public class Main { public static void main(String[] args) { int suma.i++){ for (int j=3.out.package bol03ej01. Realiza una traza del siguiente algoritmo y muestra la salida generada por pantalla.j--){ suma=i*10+j.1 HASTA 3 j <.
PROGRAMA ej_1
VARIABLES i. System. j: ENTERO COMIENZO PARA i <.j+1 FIN MIENTRAS FIN PARA
.j>0.println(suma). } } } } 2.
for (tabla=1.println ("\n\nTabla del " +tabla).i.i++){ j=i+1. System.package bol03ej02.out.out.println ("---------------"). j++. tabla++) { System.i<=10.
package bol03ej03.i<3. public class Main { public static void main(String[] args) { int j. tabla<=10. } } }
3.out.println(j-i). for (i=1. while(j<4){ System. Diseña una aplicación que muestre las tablas de multiplicar del 1 al 10.i++)
. public class Main { public static void main(String[] args) { int tabla. for (int i=0.
.out. System.out. Dibuja un cuadrado de n elementos de lado utilizando *.out.println ("").
package bol03ej04.print ("Lado del cuadrado: "). col++) System. // tamaño del lado int fila. col<=n.entero().out. for (fila=1.println (tabla + " x " + i + " = " + tabla*i). System. n = Entrada.print ("* "). fila++) { for (col=1.
4.{ } } } }
System. fila<=n. public class Main { public static void main(String[] args) { int n. col.
if(j==3) System.
package bol03ej05.5.print(k).l<=9.i++){ for (int j=0. else System.print("E").out.out. if(k==3) System. else System.print(i).print("E"). public class Main { public static void main(String[] args) { for (int i=0.k<=9.j++){ for (int k=0. if(l==3) System.out. que muestre los números del 0-0-0-0-0 al 9-9-9-9-9.print("E"). else System.print(j).j<=9. else System. Necesitamos mostrar un contador con 5 dígitos (X-X-X-X-X).m<=9.out.l++){ for (int m=0. con la particularidad que cada vez que aparezca un 3 lo sustituya por una E.out. if(m==3)
.k++){ for (int l=0.m++){ if(i==3) System.out.out.print(l).print("E").out.i<=9.
y nos diga cuantos números hay entre 1 y n que son primos.out..num. boolean primo.
System.print("E").print("Introduce numero: "). System.out.out.i<=num.cont_pri.num for(int i=1.out.print(m). System.i++){
. Realizar un programa que nos pida un número n. // vamos procesando todos los números entre 1.entero().
package bol03ej06. } } } } } } }
6. num=Entrada. public class Main { public static void main(String[] args) { int j.println(" "). cont_pri=0.else
// si es primo incrementamos el contador de primos System. j=2.println("En el rango 1... consultar algoritmos para primos primo=true. }
} System." + num + ". calcularemos si es primo // veremos si el número i es divisible en el rango 2.out. while (j<=i-1 && primo==true) { if (i%j==0) primo=false.println(i+(" es primo")).// para cada número i..out.. } if (primo==true){ cont_pri++. hay "+ cont_pri + " números primos").
. j++.i-1 // El bucle while se puede hacer con menos vuelta.
println("Los números son:"). t[i]=Entrada. public class Main { public static void main(String[] args) { int t[].print("Introduzca un número: "). t = new int[5].out.i<5.Boletín 4
1. } }
.entero().i++) { System.println(t[i]).i<5. Leer 5 números y mostrarlos en el mismo orden introducido. } System.i++) System.out. for (int i=0. for (int i=0.out.
package bol04ej01.
i<5.println(t[i]).entero().i>=0.
.cont_neg. Leer 5 números por teclado y a continuación realizar la media de los números positivos.i++) { System. t[i]=Entrada.
package bol04ej03.i--) System.suma_neg. public class Main { public static void main(String[] args) { int t[]=new int[5].print("Introduzca un número: ").out.out.
3. } System.cont_pos.
package bol04ej02.2.println("Los números (en orden inverso):").cont_cero. int suma_pos. Leer 5 números y mostrarlos en orden inverso al introducido. la media de los negativos y contar el número de ceros. for (int i=0.out. for (int i=4. public class Main { public static void main(String[] args) { int t[]=new int [5].
out. } } } if(cont_pos==0) System. else
. t[i]=Entrada. cont_pos++.println("La media de los positivos: "+(float)suma_pos/cont_pos). cont_neg++. else System.out. leer y procesar.i++){ if(t[i]==0) cont_cero++. else{ if(t[i]>0){ suma_pos=suma_pos+t[i].i<5. cont_cero=0.out.out.suma_pos=0. } for (int i=0.entero(). cont_neg=0. } else{ suma_neg=suma_neg+t[i]. // utilizamos un bucle para leer los datos y otro para procesarlos // se podrían hacer ambas operaciones.println("No se puede realizar la media de números positivos").print("Introduzca un número: ").i++){ System.println("No se puede realizar la media de números negativos"). cont_pos=0. if(cont_neg==0) System.i<5. en un solo bucle for (int i=0. suma_neg=0.
println("El resultado es:"). el penúltimo.out. System. el segundo.i++){ System.println (t[i]). Debemos mostrarlos en el siguiente orden: el primero. public class Main { public static void main(String[] args) { int i. Leer 10 números enteros.out.System.i<10. t[i]=Entrada.out. } }
4. // mostramos el i-ésimo número por el principio System.out.out. for (i=0.entero(). el tercero. } System.i++){ System.print("Introduzca numero: "). etc.out.println("La media de los negativos: " + (float)suma_neg/cont_neg). // y el i-ésimo por el final }
.println(t[9-i]).println("La cantidad de cero es de: " + cont_cero). for (i=0.i<=4. t = new int[10]. t[]. package bol04ej04. el último.
c = new int [20]. b=new int[10]. b[]. int i.out. el 2º de A. c[]. solo necesitaremos la mitad de vueltas.out. package bol04ej05.println("Leyendo la tabla a"). } // leemos la tabla b
. a[i]=Entrada. for (i=0.i++){ System. // la tabla c tendrá que tener el doble de tamaño que a y b. el 1º de B.print("número: "). el 2º de B. public class Main { public static void main(String[] args) { int a[]. a=new int[10]. // leemos la tabla a System.// como en cada vuelta de for se muestran dos números // para mostrarlos todos.entero().j. etc. } }
5. Leer por teclado dos tablas de 10 números enteros y mezclarlas en una tercera de la forma: el 1º de A.i<10.
println("La tabla c queda: "). y mezclarlos en una tercera de la forma: 3 de la tabla A. 3 de la B.i++){ System. package bol04ej06. para la tabla c. for (j=0. for (i=0. System. otros 3 de A. j++.System.println(""). } System.i++){ c[j]=a[i].
6. j=0.print(c[j]+" ").out. Aunque se podría utilizar i.j++) // seguimos utilizando j. c[j]=b[i].out.i<10.entero(). j++. for (i=0. etc.out.j<20.print("número: "). otros 3 de la B. } // 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. Leer los datos correspondiente a dos tablas de 12 elementos numéricos.i<10. b[i]=Entrada.out.out.
.println("Leyendo la tabla b"). } } System.
out.out.i<12.out. b=new int[12].j. for (i=0. for (i=0.entero(). c[]. j=0.print("número: ").println("Leyendo la tabla a"). } // leemos la tabla b System.public class Main { public static void main(String[] args) { int a[]. // la tabla c tendrá que tener el doble de tamaño que a y b. c = new int [24].print("número: "). b[].i<12. // leemos la tabla a System.println("Leyendo la tabla b").
. int i.entero(). i=0. } // asignaremos los elementos de la tabla c // para las tablas a y b utilizaremos como índice i // y para la tabla c utilizaremos como índice j.out. a[i]=Entrada.i++){ System. a=new int[12]. b[i]=Entrada.i++){ System.
incrementamos la i en 3.println("").while (i<12) { // copiamos 3 de a for (int k=0.j++) // seguimos utilizando j. i+=3.out.out.println("La tabla c queda: "). k++) { c[j]=a[i+k]. for (j=0. } // copiamos 3 de b for (int k=0.out. System.
.print(c[j]+" "). j++. } // la j se incrementa cada vez que se añade un elemento a la tabla c. para la tabla c. } // como hemos copiado 3 de a y b.
System. } } System. j++. Aunque se podría utilizar i.k<3.j<24.k<3.k++) { c[j]=b[i+k].
para algún i. La aplicación debe indicarnos si los números están ordenados de forma creciente. Leer por teclado una serie de 10 números enteros.7. se cumple t[i]>t[i+1]: la serie t[i].
. decreciente. public class Main { public static void main(String[] args) { int numeros[]. decreciente = false. package bol04ej07. creciente = false. o si están desordenados. decreciente. // creciente indicará si los números están ordenados de forma creciente // decreciente indicará si la serie está ordenada de forma decreciente // los posible valores para creciente y decreciente son: /* creciente decreciente * false false -> cuando todos los números sean idénticos * false true -> orden decreciente * true false -> orden creciente * true true -> desordenado * * si. t[i+1] es decreciente * * o el caso contrario. * */ numeros = new int [10]. int i. boolean creciente.
if (numeros[i] < numeros[i+1]) creciente = true. numeros[i]=Entrada.println("Todos los números iguales.out.print("número: ").i++){ System. if (creciente ==true && decreciente ==true) // si ha tenido momentos creciente y decrecientes System.i<10. // lo que significa que todos son iguales } }
.println("Serie creciente.out.out."). if (creciente ==false && decreciente ==false) // no hay parejas crecientes ni decrecientes System.println("Serie decreciente.i<9.i++) // usamos i e i+1.// leemos los números System.out. // en este momento es creciente
// dependiendo de los valores de creciente y decreciente daremos un tipo de ordenación if (creciente ==true && decreciente ==false) //toda las parejas están en orden creciente System.out. for (i=0."). por lo que la i solo podrá llegar hasta 8 (ó <9) { if (numeros[i] > numeros[i+1]) // en este momento es decreciente decreciente = true.println("Leyendo números:").").entero().").println("Serie desordenada. } // comprobaremos el orden for (i=0. if (creciente ==false && decreciente ==true) // todas la parejas están en orden decreciente System.out.
System.out. posicion = Entrada.i++){ System..out. public class Main { public static void main(String[] args) { int t[]=new int[10].println("Leyendo datos. Leer mediante el teclado 8 números. propuesta para el lector. Después se debe pedir un número y una posición.print("Nuevo elemento: "). elemento = Entrada.print("Posición donde insertar (de 0 a 8): "). es comprobar esto. // ahora desplazaremos los elementos de la tabla // desde posición hasta el último (en este caso 7)
. desplazando los que estén detrás. package bol04ej08. for (int i=0.out.entero().out.entero().entero(). // leemos 8 números System."). int elemento. // un valor distinto podría dar un error en tiempo de ejecución // una posible mejora.print("Introduzca número: "). } // pedimos el nuevo elemento y la posición System. t[i]=Entrada.i<8. // supondremos que la posición estará entre 0 y 8.. posicion. insertarlo en la posición indicada. Diseñar una aplicación que declare una tabla de 10 elementos enteros.8.
//insertamos el nuevo elemento t[posicion] =elemento.i++) System.print("Introduzca número: "). } // guardamos el último elemento de la tabla ultimo = t[9].out.println(t[i]). el segundo pasa a ser el tercero y así sucesivamente. package bol04ej09.i<9. 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.out.i--) t[i+1]=t[i]. El último pasa a ser el primero.i>=posicion. for (int i=0.
9.i<10.println("La tabla queda:"). int ultimo.out. System. // leemos la tabla for (int i=0. public class Main { public static void main(String[] args) { int t[]=new int[10].for (int i=7. t[i]=Entrada.
.entero().i++){ System.
i<10.i>=0.
.entero(). for (int i=8. int n.print("Introduzca número: ").out.// desplazamos hacia abajo (de 0 hacia la última posición) // al desplazar perdemos el último valor.i++) System. for (int i=0.println("La tabla queda:"). // leemos la tabla for (int i=0.i--) t[i+1]=t[i].out. t[i]=Entrada.
10.i++){ System. int ultimo. System.out. Ídem.print("Posiciones a desplazar:" ). desplazar N posiciones (N es introducido por el package bol04ej10.i<10.out. por eso lo hemos guardado antes.println(t[i]).
// preguntamos cuantas posiciones se desea desplazar System. // el último valor pasa a ser el primero t[0] =ultimo. public class Main { public static void main(String[] args) { int t[]=new int[10]. }
println(t[i]). // desplazamos hacia abajo (de 0 hacia la última posición) // al desplazar perdemos el último valor. por eso lo tenemos guardado. vueltas++) { // guardamos el último elemento de la tabla ultimo = t[9].vueltas <=n.out.i--) t[i+1]=t[i]. este algoritmo es muy fácil de implementar.i>=0.
// un algoritmo más eficiente package bol04ej10.entero(). pero es muy costoso en tiempo.
del ejercicio anterior tenemos una versión que desplaza una sola posición. for (int i=8. conseguiremos desplazar n veces.i++) System. Si repetimos este proceso n veces.println("La tabla queda:").out. public class Main {
. for (int i=0.i<10.
for (int vueltas=1.n = Entrada.
System. // el último valor pasa a ser el primero t[0] =ultimo.
println("\n\nLa tabla queda:"). // leemos la tabla for (int i=0.i++){ System.i<10. } // preguntamos cuantas posiciones desea desplazar System.print("Introduzca número: ").clone().i<10. n = Entrada.print("Posiciones a desplazar:" ).println(t[i]).
.i++) t[i] =copia[(i+n)%10].i++) System.entero(). for (int i=0.out. int n.out. // desplazamos hacia abajo n posiciones for (int i=0. que pasarán a ser primero y segundo) como a priori no sabemos cuantos elementos vamos a desplazar.out. // la tabla funciona como si fuese circular por eso utilizamos el módulo System. t[i]=Entrada.public static void main(String[] args) { int t[]=new int[10].i<10. // // // // // // en el caso de desplazar una posición: necesitamos guardar solo un elemento (el último que pasa a ser el primero) en el caso de desplazar dos posiciones: necesitamos guardar dos elementos (penúltimo y último.out. Una buena solución es hacer una copia de la tabla completa
int copia[] = t. ni cuantos elementos tenemos que guardar.entero().
j=0.entero(). int num.println().print("Número a insertar entre los anteriores: ").j. // buscaremos el sitio donde debería ir num while(t[j]<num && j<=4){ sitio_num ++. num=Entrada. public class Main { public static void main(String[] args) { int t[]=new int[10].11.entero(). t[i]=Entrada.out.i<5.i++) { System. } System.out. j++. System. Leer un número N. package bol04ej11. for (int i=0. e insertarlo en el lugar adecuado para que la tabla continúe ordenada.print("Introduzca número (ordenado crecientemente): "). } // desplazaremos los elementos desde el sitio_num hasta el final // así haremos un hueco para num
sitio_num=0. Éstos los guardaremos en una tabla de tamaño 10.sitio_num.out. Leer 5 elementos numéricos que se introducirán ordenados de forma creciente.
System. for (int i=0. } }
12. package bol04ej12.out.out.print("Elemento ("+i+"): "). // leemos los 10 números for (int i=0. public class Main { public static void main(String[] args) { int t[]=new int[10].println("La nueva serie ordenada queda: ").out. Eliminar el elemento situado en la posición dada sin dejar huecos.entero().i<5+1.i<10. Leer por teclado una tabla de 10 elementos numéricos enteros y una posición (entre 0 y 9).println(t[i]). int posicion.for (int i=4. i>=sitio_num.i++) { System. // por último ponemos num en su sitio para que todo siga ordenado t[sitio_num]=num.i++) System. t[i]=Entrada. }
. i--) t[i+1]=t[i].
entero().
// 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. // elemento útil menos en la tabla } }
13. public class Main { /** * En esta versión utilizaremos para ver los elementos pares o impares * los valores de la tabla. package bol04ej13..println("La tabla queda: ").. // ya que dentro usamos (i+1) que es la última posición // así evitamos salirnos de la tabla System. es decir t[0]. for (int i=0.i<9. // leemos la posición que nos interesa // suponemos que la posición está en el rango 0.println(t[i]).print("Posición a eliminar: ").out.println().out..
.out. y a continuación los elementos impares.9 System.out. t[i] = t[i+1].i++) // hay que tener cuidado que ahora hay un System. Leer 10 enteros.i++) // la i llega hasta la penúltima posición.i<9. Realizar dos versiones: una trabajando con los valores y otra trabajando con los índices. posicion=Entrada.System.. t[1]. Guardar en otra tabla los elementos pares de la primera.
// contador de números pares y tabla para guardarlos int cont_impar. // creamos las tablas par e impar del tamaño adecuado par=new int[cont_par].*/ public static void main(String[] args) { int t[]. par[]. // Leemos los valores de la tabla for (int i=0.i++){ System.print("Introduzca un número: "). cont_impar=0.i<10.i++) if(t[i]%2==0) cont_par++.i<10.i++)
. // volvemos a procesar para copiar cada elemento en la tabla adecuada cont_par=0. t[i]=Entrada.entero(). // ídem para los impares t = new int[10]. cont_impar=0. for (int i=0. else cont_impar++.impar[].i<10. } // contamos la cantidad de elementos pares e impares // también se podía contar solo lo pares y calcular los impares=10 -pares cont_par=0. int cont_par.out. for (int i=0. impar=new int[cont_impar].
if(t[i]%2==0) { par[cont_par]=t[i].i<cont_impar.println(par[i]).out.out..i++) System. t[2]. */ public static void main(String[] args) { int t[].i<cont_par. } else { impar[cont_impar]=t[i]. * en impar t[1].
.. System. int par[]. for (int i=0..out.. cont_impar++. public class Main { /* * En esta versión nos fijaremos en los índices pares e impares * en par se incluirá t[2].println("Tabla impar:"). } System.t[4].println("\n\nTabla par:").println(impar[i]). } }
package bol04ej13. cont_par++. for (int i=0.i++) System..out.
i+=2) // la división entera redondeada hacia el entero más próximo por impar[i/2] = t[i].i<5.i<10.i++){ System. etc. 3/2 =1. for (int i=1. impar=new int[5].i+=2) par[i/2] = t[i]. for (int i=0. // debajo: 1/2 =0.println("Tabla impar:"). t = new int[10].i++) System.print("Introduzca un número: ").out.println(par[i]). // Leemos los valores de la tabla for (int i=0.out.i<10.out.i++) System.out. for (int i=0. } // creamos las tablas par e impar del tamaño adecuado (5) par=new int[5].i<5. System.entero(). // copiamos cada elemento en la tabla adecuada for (int i=0. } }
.i<10.println(impar[i]).out.println("\n\nTabla par:").int impar[]. System. t[i]=Entrada.
println().print("Introduzca numero (orden creciente): "). } System.out.out.i<10.println("\nDatos para b:").out.out.entero(). public class Main { public static void main(String[] args) { int a[]. Copiar (fusionar) las dos tablas en una tercera. a[i]=Entrada. c[].j. int i.i<10. b[i]=Entrada. a =new int[10].
package bol04ej14.out.i++){ System. // creamos c
.i++){ System.14. // leemos a System. que estarán ordenados crecientemente. b[].k. for (i=0.println("Datos para a:"). Leer dos series de 10 enteros. de forma que sigan ordenados.entero(). } // leemos b System. b =new int[10]. for (i=0.print("Introduzca numero (orden creciente): ").
k++. j++. } else // hay que copiar el resto de a en c while (i<10) // como hemos copiado a c[k]. i++. // utilizaremos i j=0. incrementamos k. para // en la siguiente vuelta. como índice de b. // incrementamos i para tomar el siguiente elemento de a } else { c[k] = b[j]. como índice de c
while(i<10 && j<10) { if (a[i] < b[j]) // nos interesa el elemento de a { c[k] = a[i]. // utilizaremos k a y b en c como índice de a. queda por copiar un resto de b while (j<10) { c[k] = b[j]. // incrementamos j para tomar el siguiente elemento de b } k++.c = new int [20]. j++. // utilizaremos j k=0. // comenzamos a fusionar i=0. utilizar el siguiente hueco de la tabla
. } // 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.
int num. i++.out.k++) System.println(""). } System. t[i]=Entrada.j. for (int i=0.
package bol04ej15.i<10.out. } } "). indicarlo con un mensaje.println("Mostramos la tabla c:"). public class Main { public static void main(String[] args) { int t[]=new int[10].
. Leer N y buscarlo en la tabla. Se debe mostrar la posición en que se encuentra. Si no está. k++.print(c[k] + " System.out.entero(). Leer 10 enteros ordenados crecientemente.println().
15.out.k<20.out.print("Introduzca numero (orden creciente): ").
} System. for (k=0.i++){ System.{
c[k] = a[i].
y la media del alumno que se encuentra en la posición N (N se lee por teclado).println("Encontrado en la posición " + j).que j llegue a 10 ó // .que encuentre el donde iría num en la tabla if(j==10) // hemos llegado al final y no hemos encontrado nada.println("No encontrado").entero(). } // cuando me salgo del mientras puede ser por dos motivos: // . public class Main {
. Cada grupo (o clase) está compuesto por 5 alumnos.out. System.out. num=Entrada.println("No encontrado"). else System.out. sin encontrarlo if(t[j]==num) // num está en la posición i.System. } } }
16.println("Introduzca numero a buscar: "). hemos sobrepasado el lugar donde debería estar num. Se pide leer las notas del primer.out. while(j<10 && t[j]<num){ j++.
package bol04ej16. j=0. segundo y tercer trimestre de un grupo. else{ // si t[j] < num. Entonces si está ahí System. Debemos mostrar al final: la nota media del grupo en cada trimestre. Queremos desarrollar una aplicación que nos ayude a gestionar las notas de un centro educativo.
segundo = new int [5]. } // leemos las notas del tercer trimestre System.entero().out. suma_segundo. Se podrían procesar las // notas mientras se leen.out.i++){ System.entero(). segundo[].i<5.print("Alumnos ("+i+"): ").println("Notas del tercer trimestre:").
// creamos las tablas necesarias primer = new int [5]. // notas del primer. primer[i]=Entrada. double media_alumno.print("Alumno ("+i+"): "). for (i=0. tercer[i]=Entrada.out. segundo y tercer trimestre int num. Preferimos utilizar dos bloques por tener un código más legible.out. } // leemos las notas del segundo trimestre System.
. int suma_primer.println("Notas de primer trimestre:").i<5.i++){ System.i. segundo[i]=Entrada. for (i=0.println("Notas del segundo trimestre:"). tercer[].out.public static void main(String[] args) { int primer[]. for (i=0.print("Alumnos ("+i+"): ").i<5.entero(). tercer = new int [5]. suma_tercer.i++){ System. // leemos las notas del primer trimestre System.out. // el programa consta de dos partes: entrada de datos y procesado.
} // 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);
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
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: ");
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(); }
} 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"); } }
for (i=0.out.println ("Matriz B:").j++) { System. b = new int[3][3].j. Crear y cargar dos matrices de tamaño 3x3. suma[][].print("B["+i+"]["+j+"]: "). a = new int[3][3]. // Leemos los datos System.j<3.i<3.i<3. public class Main { public static void main(String[] args) { int a[][].entero(). } }
package bol05ej03.j++) { System. b[][].out.out.println ("Matriz A:").i++) { for (j=0.j<3.print("A["+i+"]["+j+"]: ").i++) { for (j=0. } } System. sumarlas y mostrar su suma.3. b[i][j]=Entrada. int i. a[i][j]=Entrada.entero().out. for (i=0.
j++) { suma[i][j] = a[i][j] + b[i][j].out.out.println (). } } // mostramos los resultado System.
.print (suma[i][j] + " "). Crear y cargar una tabla de tamaño 3x3. for (i=0. public class Main { public static void main(String[] args) { int t[][]=new int[3][3]. } } }
4.i++) { for (j=0. trasponerla y mostrarla.println ("Matriz Suma:").
package bol05ej04.// hacemos la suma suma = new int[3][3].i<3.i++) { for (j=0.j<3. } System. for (i=0.j++) { System.i<3.j<3.out.
for (int i=0. Al intercambiar dos veces los elemento.i<3.j<3.i++){ System. pero cuando transpongamos el elemento [2][1] se convierte en el [1][2]. Un ejemplo el elemento t[1][2] se convierte en el [2][1]. } } // // // // trasponemos la matriz no podemos transponer todos los elementos.j<3. for (int i=0. la matriz se quedaría exactamente igual.i++){ for (int j=0.i<3.print("Introduzca elemento["+i+"]["+j+"]: ").j++){ System.println(). t[i][j]=Entrada.out. t[i][j]=t[j][i].out. } } // mostramos la matriz original System.print ("Matriz original:").i++){ for (int j=0. t[j][i]=aux.j++){ System.i<3.
// solo traspondremos los elementos por debajo de la diagonal principal. for (int j=0.out. } }
..out.entero()..int aux.j++){ aux=t[i][j]. for (int i=1.j<i.print(t[i][j]+" ").
// mostramos la matriz transpuesta System.out.i--){ System.i++) for (j=0.i>=0. System. } }
5.j<3.println("---------------------"). Crear una tabla de tamaño 7x7 y rellenarla de forma que los elementos de la diagonal principal sean 1 y el resto 0. int i. public class Main { public static void main(String[] args) { int t[][]=new int[7][7]. for (int i=2.
package bol05ej05. al crear una tabla de enteros.println(). else t[i][j] = 0.println ("Matriz transpuesta").i<7.j++) if (i==j) t[i][j] = 1. // en java.println().out.print(t[i][j]+" ").j. System.out. todos los elementos se
.out.j<7.j++){ System. for (int j=0. for (i=0.out.
j++) System.
. t = new int[tamaño][tamaño]. for (i=0.i++){ for (j=0.j<7. public class Main { public static void main(String[] args) { int t[][]=new int[4][4].. System. int i. System. int suma_fila.out. pero desde el punto de vista del algoritmo no es relevante.i<tamaño. Se aña_ // de para que el código sea más comprensible. // mostramos la matriz // la forma de ver la matriz no es la típica que estamos acostumbrados en // matemática.println ("Matriz:"). final int tamaño=4.print(t[i][j]+" "). Por lo que esta instrucción no es necesaria.out.. for (i=0.println ().j<tamaño.j.j++){ System.i++) { for (j=0. } } }
6.out. Crear y cargar una tabla de tamaño 10x10.suma_col.print("Elemento ["+i+"]["+j+"]: ").out.i<7. mostrar la suma de cada fila y de cada columna.// inicializan a 0.
package bol05ej06.
} // sumamos fila a fila for (j=0.println().out. } } }
7.i++){ suma_fila=suma_fila+t[i][j].j<tamaño.println("Columna"+" "+i+":"+" "+suma_col).} }
t[i][j]=Entrada.entero().out.j<tamaño. } System.
// sumamos columna a columna System.out.
package bol05ej07. for (i=0. utilizando dos tablas de tamaño 5x9 y 9x5.
. public class Main { public static void main(String[] args) { int a[][]. b[][].j++){ suma_col=suma_col+t[i][j].i++){ suma_col=0. for (i=0.println("Fila"+" "+j+":"+" "+suma_fila).i<tamaño.i<tamaño. for (j=0.j++){ suma_fila=0. } System. cargar la primera y trasponerla en la segunda.
j++){ System.print (b[i][j] + " "). } } // mostramos la matriz traspuesta System.i++){ for (j=0. a = new int[5][9]. b = new int [9][5]. } } }
.j.j<9. // si queremos ahorrarnos introducir 5x9 (45) números. } } // trasponemos for (i=0.out.i<9.out. a[i][j]=Entrada.println ().i++){ for (j=0.j++){ b[j][i] = a[i][j].i<5.i<5.i++){ for (j=0. System.print("Elemento ["+i+"]["+j+"]: "). for (i=0.j<9.int i.out. podemos comentar las // dos lineas anteriores y utilizar (por ejemplo): // a[i][j] = 10*i+j.entero().j<5.out.j++) System. for (i=0.println("Matriz traspuesta").
i<8.j<6.println().i<8. public class Main { public static void main(String[] args) { int i.i++) for (j=0.
package bol05ej08. for (j=0.
9.out.out.out.print (t[i][j]+" ").
. int t[][]. t = new int[8][6]. } System.j. // se inicializa toda la tabla a 0. } } System. Hacer lo mismo que el ejercicio anterior. Crear una matriz “marco” de tamaño 8x6: todos sus elementos deben ser 0 salvo los de los bordes que deben ser 1. if(j==0 || j==5) // si nos encontramos en la primera o última fila t[i][j]=1.j++){ System. Creamos un cubo con las caras puestas a 1 y el interior a 0. for (i=0.out. pero con una matriz 9x9x9. Mostrarla.j++) { if(i==0 || i==7) // si nos encontramos en la primera o última columna t[i][j]=1.println ().8.print("Matriz marco: ").j<6. // rellenamos la matriz marco for (i=0.i++){ System.
k<9. for (j=0.k++){ if(i==0 || i==8 || j==0 || j==8 || k==0 || k==8) // si estamos en la primera o última columna.j++) { for (k=0.println (" -------------. t = new int[9][9][9].k<9.i++){ for (j=0.out. for (i=0.").j. } } } // Mostramos la matriz capa a capa System. } System.i<9.out.i<9.println (). }
.j<9. for (i=0.println("Capa: " +i).print(t[i][j][k] + " "). } System.j<9.println("Matriz: ").j++){ for (k=0.package bol05ej09. public class Main { public static void main(String[] args) { int t[][][].out.i++) { System.out.out. int i.k.k++) { System. fila o capa de la matriz t[i][j][k]=1.
6 y 1. PROGRAMA Ej10b VARIABLES n. 5. Los siguientes programas piden una serie de datos y tras procesarlos ofrecen unos resultados por pantalla. 3 y 2. 2. b: TABLA [100] ENTEROS COMIENZO n  10 PARA i0 HASTA n-1 leer (a[i]) FIN PARA PARA i  0 HASTA n/2 b[i]  a[n-1-i] b[n-1-i]  a[i] FIN PARA PARA i  0 HASTA n-1 SI i mod 2 = 0 escribir (a[i]) SINO escribir (b[i]) FIN SI FIN PARA FIN PROGRAMA Datos de entrada: 6. a: ENTEROS t: TABLA [5] ENTEROS COMIENZO PARA i0 HASTA 4 leer (t[i]) FIN PARA m  0 PARA i  0 HASTA 4 SI t[i] > m m  t[i] FIN SI FIN PARA a  t[4-m] t[4-m]  t[m] t[m]  a PARA i  0 HASTA 4 escribir (t[i]) FIN PARA FIN PROGRAMA Datos de entrada: -4. 1. 2.
. 9. 8. Mostrar el resultado: PROGRAMA Ej10a VARIABLES i. 0. 2.}
10. 8. i: ENTEROS a. m.
m = 0. t[4-m] = t[m].
int t = new int [5]. al utilizar datos como índices de tablas sin las pertinentes comprobaciones. // podemos sustituir la lectura de datos por la siguiente línea: //int t[] = {-4.out. i++) t[i] = Entrada. i<=4. i<=4. i++) if (t[i] > m ) m = t[i]. i<=4.package bol05ej10. m. a. 1. 2}. a = t[4-m]. for (i=0.entero(). 0. for (i=0. escribir el código equivalente para comprobar el resultado. 3. // // // // // // la idea de este ejercicio es hacer una traza de forma manual. public class Main { public static void main(String[] args) { int i. for (i=0.
. Debemos destacar que este algoritmo no tiene sentido ni hace nada en concreto incluso con otros datos de entrada el algoritmo puede dar un error.println (t[i]). t[m] = a. y tras ésta. i++) System.
public class Main { public static void main(String[] args) { int n. } for (i=0. int b[] = new int [10]. 1}. 6.println (b[i]). 5. } }
. 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. escribir el código equivalente para comprobar el resultado. 2. i++) a[i] = Entrada. i<=n/2. else System.entero(). i++) { b[i] = a[n-1-i]. i<=n. i++) if (i % 2 == 0) System. // podemos sustituir la declaración de a y la lectura de datos por la siguiente línea: // int a[] = {6. n = 10. i<n.package bol05ej10.println (a[i]). b[n-1-i] = a[i].out. i. 2. /* la idea de este ejercicio es hacer una traza de forma manual. y tras ésta. */ int a[] = new int [10]. 8. 8. for (i=0. for (i=0.out. 9. 2.
aux. que terminará el programa.i. La opción 3 mostrará un listado ordenado por la marca del 2002. 2001. y 2002 int opc. int part[][]=new int[TAM][4]. numc=0. M2: Marca del 2000. Tras procesar cada opción.M0=1. M1. Si se elige la opción 2. Mostrar listado por marcas. El número de plazas disponible es de 10. opc=0. // TAM: Número máximo de participantes // D: número de dorsal // M0. se introducirán los datos de uno de los participantes: Nombre.D=0. mejor marca del 2002. de mayor a menor. Mostrar listado de datos. Sus datos se irán introduciendo en el mismo orden que vayan inscribiéndose los atletas. se debe mostrar un listado por número de dorsal.dorsal.M2=3. hasta que se seleccione la opción 4.11-Se pretende realizar un programa para gestionar la lista de participaciones en una competición de salto de longitud.
package bol05ej11.M1=2.numc. Finalizar el programa.
Si se selecciona 1. Diseñar el programa que muestre las siguientes opciones: 1234Inscribir un participante. public class Main { public static void main(String[] args) { final int TAM=10. mejor marca del 2001 y mejor marca del 2000.inter. boolean d_rep.
. se debe mostrar de nuevo el menú inicial.
i=0.out. d_rep=false. System.out. else{ do{ System. while(i<numc && d_rep==false){ if(part[i][D]==dorsal){ System.out. System.do{ System. Inscribir participantes").println("3.out.out. Salir").out. switch(opc){ case 1: if(numc==20) System. } }while(d_rep==true).println(). Mostrar listado por marcas"). Mostrar listado por datos"). } i++.println().println("1.println("--------------------------------").println("2.entero(). if(d_rep==false){ part[numc][D]=dorsal. System.out. System.
. dorsal=Entrada.println("--------------------------------").out. d_rep=true.print("Por favor. part[numc][M0]=Entrada.out. System. System. System.out.out."). System. introduzca una opción: "). opc=Entrada. System.out.print("Dorsal registrado. System.print("Introduzca dorsal: ").println("Por favor intente de nuevo").print("Introduzca marca del 2000: ").entero().println("4.println("Listado completo").out.out.entero().
part[numc][M2]=Entrada. numc++.j++){ System. System.out. part[numc][M1]=Entrada. for (int j=0.j<numc.entero().entero(). } } break. while(inter==true){ inter=false.j++){ if(part[j][D]>part[j+1][D]){ for (int k=0. part[j+1][k]=aux.out.System. System. part[j][k]=part[j+1][k].k<4.println().println("LISTADO DE DATOS.out. controlado por intercambio inter=true. case 3:
.println ("dorsal .j<=numc-1-1.SEGUN DORSAL:"). case 2: // método de ordenación por burbuja.print("Introduzca marca del 2001: ").println(). } } } System.k++){ System. } } break. for (int j=0.print("Introduzca marca del 2002: ").out. } inter=true.out.marcas").out.print(part[j][k]+" ").out.k<4. System. for (int k=0.k++){ aux=part[j][k].
j++){ if(part[j][M2]>part[j+1][M2]){ for (int k=0.j++){ System.out. } inter=true. } } break. System.k++){ System.marcas").println().println("LISTADO POR MARCAS :").j<numc.
.print(part[j][k]+" ").} } while(opc!=4). part[j][k]=part[j+1][k].out.println ("dorsal .out. part[j+1][k]=aux. for (int k=0. for (int j=0.k++){ aux=part[j][k]. } } } System.k<4.k<4. while(inter==true){ inter=false.j<=numc-1-1. for (int j=0. } }
inter=true.out.
public class Main { public static void main(String[] args) { int num.println("---------------------------"). } }
.i++){ System.i<num. Realizar una función.println("---------------------------").out.out. System. mostrar(num).
static void mostrar(int num){ for (int i=0.println("Módulo ejecutándose"). y muestre por pantalla N veces.Boletín 6
1. a la que se le pase como parámetro un número N.out. System.print("Introduzca un numero: "). num=Entrada. el mensaje: “Módulo ejecutándose”
package bol06ej01.entero(). System.out.
} return(max). System.println("El número mayor es: " +max). else max=b. y que calcule el máximo.b.print("Introduzca otro numero: ").entero().out.
package bol06ej02. }
. System.out. int b){ int max. public class Main { static int maximo(int a. max =maximo (a. // suponemos que los tres números serán distintos
public static void main(String[] args) { int max.out. b).2. System. Diseñar una función que tenga como parámetros dos números.print("Introduzca un numero: ").entero(). int a. if(a>b) max=a. a=Entrada. b=Entrada.
public class Main { static int maximo(int a. c=Entrada.entero(). System. Ídem una versión que calcule el máximo de 3 números.print("Introduzca el último: ").out.
. será c max=c. int a. System. else // si el máximo no es a ni b. if(a>b && a>c) // si a es mayor que b y c.entero(). } return(max). entonces a es el máximo max=a. else if(b>a && b>c) // si b es el mayor de todos.out. c.
package bol06ej03.out. a=Entrada. b=Entrada.
public static void main(String[] args) { int max.entero(). int b. System. int c){ int max. entonces b es el máximo max=b.print("Introduzca otro numero: ").print("Introduzca un numero: ").3. b.
out. return(max). max =maximo (a.length.
package bol06ej04. System.println("El número mayor es: " +max). entonces t[i] es el nuevo máximo max=t[i].println(""). c). i++) if (t[i]>max) // si t[i] es mayor que max. i < t.
. for (int i = 0. } public static void main(String[] args) { int max. b.System. }
4. max = t[0].out. int t[]. public class Main { /** * Esto funciona solo para tablas con un tamaño mínimo de 1 * */ static int maximo(int t[]){ int max. Ídem una versión que calcule el máximo de una tabla de n elementos.
println("\nEl número mayor es: " +max). public class Main { static void mostrar(int a. System. i++) System. for (int i = 0. Se podría utilizar la función maximo() implementada anteriormente. menor. mayor=a.. i < t. i++) // llenamos la tabla con valores aleatorios entre 1 y 100 t[i]=(int)(Math. System. // Lo que haremos es poner los valores correctos en mayor.length.print(t[i] +" ").random()*100+1).
package bo0l6ej05.int b){ int mayor. menor=b. max = maximo (t).t=new int [6]. } }
5.out.println("Los valores son:"). for (int i = 0.out. if(a>b){ // a es el mayor. i < t.length. inclusive. } else{ // en este caso b será el mayor
.out. // desconocemos el orden en el que vienen a y b. Función a la que se le pasan dos enteros y muestra todos los números comprendidos entre ellos. menor.
entero(). a=Entrada. System. menor=a.
package bol06ej06.print("Introduzca segundo numero: "). public class Main { static void doble(int num) {
. System. System. Función que muestra en pantalla el doble del valor que se le pasa como parámetro.print(i+" "). mostrar(a. } for (int i=menor. } }
6.i<=mayor.out.b. b=Entrada.out.b).println().entero().out.i++) System. } public static void main(String[] args) { int a.mayor=b.out.print("Introduzca primer numero: ").
public class Main { static void area_o_volumen_cilindro(double radio.out. doble=2*num.
public static void main(String[] args) { int num. Además hemos de pasarle a la función el radio y la altura.
7.print("Introduzca un número: ").
.PI*radio*radio*altura. char opcion){ double volumen.area. // radio*radio es el radio al cuadrado System. num=Entrada.
package bol06ej07. Para distinguir un caso de otro se le pasará el carácter 'a' (para área) o 'v' (para el volumen).println("El volumen es de: " +volumen). // calculamos el doble de num } System.out. System.int doble. doble(num).out. Realizar una función que calcule (muestre en pantalla) el área o el volumen de un cilindro. según se especifique. double altura. switch (opcion) { case 'v': volumen =Math.entero().println("El doble es: " +doble).
PI*radio*radio. System.real().print("Introduzca altura: ").out.
public static void main(String[] args) { double radio. default: System. System. Ídem que devuelva una tabla con el área y el volumen.} }
break.println("El área es de: "+area).print("Introduzca radio: ").alt. alt=Entrada.alt. } }
8.caracter(). System.println("Indicador del cálculo erróneo").out. System.PI*radio*altura + 2*Math.real(). break.out. tipo_calculo =Entrada. public class Main {
.out. System.out. area_o_volumen_cilindro(radio.
package bol06ej08.print("Que desea calcular (a/v): "). case 'a': area = 2*Math.println(""). radio=Entrada.tipo_calculo). char tipo_calculo.out.
println("El área es de: " +resultado[1]).alt). // [0] para el volumen y [1] para el área calculo[0] =Math. resultado =area_y_volumen_cilindro(radio.println("El volumen es de: " +resultado[0]). double calculo[].out. double altura) { double volumen.static double[] area_y_volumen_cilindro(double radio. calculo = new double [2].real(). radio=Entrada.alt.print("Introduzca radio: ").real(). System.PI*radio*radio.out.out. double resultado[]. ya que apunta a // la tabla creada dentro de la función System. //esta tabla no necesita new. System. return (calculo). alt=Entrada. } public static void main(String[] args) { double radio.out. System. } }
.PI*radio*altura + 2*Math.print("Introduzca altura: "). // radio*radio es el radio al cuadrado calculo[1] =2*Math. // resultado hace referencia a la tabla devuelta // por la función.area.PI*radio*radio*altura.
primo=true. public class Main { // la función es_primo indica si el número pasado es o no primo // recordamos que un número primo es solo divisible por el mismo y 1 static boolean es_primo(int num) { boolean primo. Módulo al que se le pasa un número entero y devuelve el número de divisores primos que tiene.9. // suponemos que el número es primo // // // // // // este algoritmo se puede mejorar sabiendo que si un número no es divisible entre 2 y su raíz cuadrada. // si hemos entrado aquí significa que el número no es primo i++. } } return(primo).
package bol06ej09. 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. int i. entonces ya no será divisible por ningún otro números -> será primo con esta mejora podemos ahorrar muchas vueltas del while para números grandes
i=2.
no se consideran divisores primos.
. div=num_divisores(num).out. cont=1. // incrementamos el número de divisores primos return(cont). // siempre habrá un divisor seguro. num=Entrada.entero().i<=num. for (int i=2.out.print("Introduce numero: "). el 1.// // // // // //
esta función devuelve el número de divisores primos del número pasado como parámetro.println("Tiene " +div+ " divisores").
static int num_divisores (int num){ int cont. el 2 y el 3. al no ser primos por lo que 24 tiene tres divisores primos: el 1.i++) if(es_primo (i) && num %i == 0) // si i es primo y divide a num cont++.div. System.
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. } } System.
// si hemos entrado aquí significa que el número no es primo i++.
. } } return(primo). int i.10. 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. public class Main { // la función es_primo indica si el número pasado es o no primo // recordamos que un número primo es solo divisible por el mismo y 1 static boolean es_primo(int num) { boolean primo. while(i<num && primo==true) { if( num %i == 0) // si es divisible primo=false. // suponemos que el número es primo // // // // // // este algoritmo se puede mejorar sabiendo que si un número no es divisible entre 2 y su raíz cuadrada. primo=true.
package bol06ej10.
i<=num. al no ser primos por lo que 24 tiene tres divisores (el 1. // tabla donde guardaremos los divisores. for (int i=1. for (int i=2. num_div = num_divisores (num). }
static int [] divisores(int num){ int cont=0. // siempre habrá un divisor seguro.i<=num. el 1. // incrementamos el número de divisores return(cont). // número de divisores primos que tiene num.i++) if(es_primo (i) && num %i == 0) // si i es primo y divide a num cont++. int num_div. div =new int[num_div].// // // // // // //
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. no se consideran divisores. cont=1. el 2 y el 3)
static int num_divisores(int num){ int cont. int div[].i++) if(es_primo (i) && num %i == 0) // si i es primo y divide a num
length.println("Los divisores de " + num + " son:"). divisores[].{ } return(div).
// incrementamos el número de divisores
public static void main(String[] args) { int num.out. System. for (int i = 0.out.print(divisores[i] + " "). System.
package bol06ej11. num=Entrada.Escribir una función que calcule el máximo común divisor de dos números.out.println(""). }
div[cont] =i.print("Introduce numero: "). cont++.entero(). divisores =divisores(num). 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".out. i < divisores. i++) System. } }
min = minimo (a. b) // y quedarnos con el mayor.i<=min. int b) { int mcd=1. int min. int b){ int min. el 1. b. else min=a. // i será el nuevo mcd.
public static void main(String[] args) { int a. // existe un mcd seguro. } return(min).// La idea es dividir por todos los números desde 1 hasta mínimo(a. mcd. } static int minimo(int a.
. static int max_comun_divisor (int a. return(mcd). if(a>b) min=b. mcd=1. que divide a y b. for (int i=2.i++) if( a%i==0 && b%i==0) // si i divide a "a" y "b" mcd=i.b).
print("Introduce numero: "). b). b=Entrada.entero().print("Introduce otro: "). // para no implementar la función mínimo para tres números
. c) y quedarnos con el mayor.out.Ídem con tres números.entero().out.println("El mcd de "+a+" y "+b+" es: "+mcd). System. int min. } } System. a=Entrada.out.
static int max_comun_divisor (int a.
package bol06ej12. int b.
12. mcd = max_comun_divisor (a. System. La idea es dividir por todos los números desde 1 hasta mínimo(a. b.System. int c) { int mcd=1.out.println(""). 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".
if(a>b) min=b.out.// utilizaremos la función con solo dos parámetros. static int minimo(int a. el 1.out. que divide a y b.
.c . min = minimo (a.print("Introduce c: "). int b){ int min.entero(). a 'b' y a 'c' mcd=i. return(min). // existe un mcd seguro.minimo(b. b=Entrada.print("Introduce a: "). for (int i=2. // i será el nuevo mcd. b.c)).out. System. System.i<=min.print("Introduce b: "). mcd. System. mcd=1. }
public static void main(String[] args) { int a. } return(mcd). else min=a.i++) if( a%i==0 && b%i==0 && c%i==0) // si i divide a 'a'.entero(). a=Entrada.
println(""). boolean divide_a_todos. b. } }
13. mcd = max_comun_divisor (a. c) y quedarnos con el mayor.c=Entrada. c).
package bol06ej13.out. int min.Ídem con una tabla. System.entero(). La idea es dividir por todos los números desde 1 hasta mínimo(a. */ static int max_comun_divisor (int t[]) { int mcd=1.println("El mcd de ("+a+".out. System. 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". "+b+". "+c+") es: "+mcd). // una bandera para saber si un número divide // a todos los elementos de la tabla
// entonces i es el nuevo mcd } } return(mcd).k++) if( t[k]%i!=0) // si i divide a t[i] divide_a_todos=false. // utilizaremos la función con solo dos parámetros.k<t.length. i < t.length.i++) { divide_a_todos =true.
.i<=min. int b){ int min. for (int i = 0. // entonces la i no divide a todos los elementos de t. // al terminar el for. min debe tener el valor mínimo de toda la tabla. if (divide_a_todos == true) // i es capaz de dividir a todos los elementos de t mcd =i. // existe un mcd seguro. for (int k=0. else min=a. el 1. return(min).// esto funciona para tabla con al menos un valor min = t[0]. if(a>b) min=b. mcd=1.t[i]). i++) min = minimo (min. static int minimo(int a. for (int i=2.
print(t[i] +" ").
System.out. t = new int [4].out. i++) System.length.println("").Escribir una función que calcule el mínimo común múltiplo de dos números. } }
14. System.println("El mcd es: " +mcd).println("Los números son: "). mcd. for (int i = 0.
package bol06ej14.length. i < t.random()*1000+1).out. i < t. // llenamos t con números aleatorios entre 1 y 1000 System.} public static void main(String[] args) { int t[].out. for (int i = 0. mcd = max_comun_divisor (t). public class Main {
. i++) t[i] = (int)(Math.
y multiplicarlo por i. La idea es elegir el mayor de a y b. // el nuevo mcm sera el mayor por i } return(mcm)./* el mínimo común múltiplo de a y b. int i. es el número más pequeño que es divisible por a y b. static int maximo (int a. hasta que el número resultante sea divisible por el menor de a y b */ static int min_comun_multiplo (int a. mcm=max*i. Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja". // 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++. if(a>b) max=a. max = maximo (a. int b) { int mcm. int b){ int max. int max. b). mcm =max.
. i=1.
System.print ("Introduce b: ").out. mcm = min_comun_multiplo (a.out. calcularemos
return(max). public class Main { // aprovechando que tenemos hecha la función max_comun_divisor. b=Entrada. System.out. }
public static void main(String[] args) { int a. b. } }
package bol06ej14. System.println("").
System.println("El mcm es: " +mcm). mcm.else
max=b.print ("Introduce a: "). a=Entrada.entero().b).entero().out.
i++) if( a%i==0 && b%i==0) // si i divide a "a" y "b" mcd=i.i<=min. return(mcd). else
. mcd=1. // i será el nuevo mcd. if(a>b) min=b. for (int i=2. int b) { int mcm. el 1. int b){ int min.b). } static int minimo(int a. que divide a y b. min = minimo (a. return (mcm).// 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. int min. } static int max_comun_divisor (int a.b). mcm = a*b / max_comun_divisor (a. // existe un mcd seguro. int b) { int mcd=1.
entero().println(""). } return(min). System.print("Introduce a: ").println("El mcm de "+a+" y "+b+" es: "+mcm). b y c. mcm. System.min=a. es el número más pequeño que // es divisible por a.out.
public static void main(String[] args) { int a. b y c. b. } }
15.out.out. System.
.entero().
package bol06ej15.print("Introduce b: "). public class Main { // el mínimo común múltiplo de a. a=Entrada. System.Ídem con tres números. mcm = min_comun_multiplo (a.out. b=Entrada. b).
int b){ int max. mcm =max. // el nuevo mcm sera el mayor por i } return(mcm). mcm=max*i.). int b. maximo(b. y multiplicarlo por i (1. int max. int i.// // // //
Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja". i=1. La idea es elegir el mayor de ellos. else max=b.. hasta que el número resultante sea divisible por todos
static int min_comun_multiplo (int a. static int maximo (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 c) { int mcm=1. max = maximo (a. if(a>b) max=a.c)).
out.return(max). b. System. } }
package bol06ej15. b.out.println("El mcm es: " +mcm).out. System.print ("Introduce b: "). b=Entrada.println(""). mcm = min_comun_multiplo (a.out. }
public static void main(String[] args) { int a. System.entero(). a=Entrada. mcm. System.
System. c).out. public class Main { // el mínimo común múltiplo de a y b. c=Entrada.entero().print ("Introduce a: "). c. es el número más pequeño que
.print ("Introduce c: ").entero().
hasta que el número resultante sea divisible por el menor(a. b). int i.// // // // //
es divisible por a y b. mcm=max*i. // el nuevo mcm sera el mayor por i } return(mcm). else
. // en principio el mcm es el mayor de los dos números
while (mcm%a!=0 || mcm%b!=0) // si el mcm no es divisible por a y b { i++. i=1. int max. y multiplicarlo por i. max = maximo (a. La idea es elegir el mayor de a y b. mcm =max.b)
static int min_comun_multiplo (int a. int b) { int mcm=1. if(a>b) max=a. int b){ int max. } static int maximo (int a. Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja".
out.entero().out. b).out. c). mcm = min_comun_multiplo (a. c. b.println("El mcm es: " +mcm). // reutilizamos la función mcm pensada para dos números y aprovechamos // la propiedad conmutativa del mcm.entero().entero(). System. System.out.
System.println(""). a=Entrada. mcm = min_comun_multiplo (mcm.
public static void main(String[] args) { int a.out. b=Entrada. } return(max). } }
.max=b.print ("Introduce a: "). System. c=Entrada.print ("Introduce c: ").print ("Introduce b: "). mcm. System.
Para calcularlo podríamos utilizar algún algoritmo existente o hacerlo un poco por la "cuenta de la vieja".Ídem con una tabla. mcm=max*i. b). y multiplicarlo por i (1. La idea es elegir el mayor de ellos. mcm =max. es el número más pequeño que es divisible por ambos. // en principio el mcm es el mayor de los dos números
while (mcm%a!=0 || mcm%b!=0) // mientras el mcm no sea divisible por todos { i++. max = maximo (a. i=1.). int b) { int mcm=1. hasta que el número resultante sea divisible por ambos
static int min_comun_multiplo (int a. int i. int max.
package bol06ej16. // el nuevo mcm sera el mayor por i } return(mcm).16. public class Main { // // // // // // el mínimo común múltiplo de a y b.
. for (int i = 0.length.} static int maximo (int a.mcm). else max=b.println(""). i < t. } return(max). mcm = t[0]. i < t.print(t[i]+" ").println("Los datos son:"). for (int i = 0. if(a>b) max=a.random()*100+1).out. System. i < t. mcm. i++) t[i]=(int)(Math. for (int i = 0.length.out.length. i++) System. int b){ int max.out.
public static void main(String[] args) { int t[].
. t = new int[4]. System. i++) mcm = min_comun_multiplo (t[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. 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. Dos números son amigos. si la suma de sus divisores (distintos de ellos mismos) son iguales.println("El mcm es: " +mcm). primo=true. // 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.System. } }
17. int i. while(i<num && primo==true) {
.out.Escriba una función que decida si dos números enteros positivos son amigos.
package bol06ej17.
num-1 un ejemplo: los divisores propios de 24 son: 1. // acumulamos i return(suma). 6.if( num %i == 0) // si es divisible primo=false. 2. 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. 12
static int suma_divisores_propios (int num){ int suma. 8. // si hemos entrado aquí significa que el número no es primo i++. 3.. }
public static void main(String[] args) { int a.
.b. } } return(primo). Es decir cualquier número que divida a num en el rango 1. for (int i=1.
esta función me devuelve la suma de los divisores propios. suma=0.i<num.
println(a+" y "+b+" no son amigos.print("Introduce b: "). while(i<num && primo==true) { if(num%i==0) // si num es divisible por i primo=false.out.print("Introduce a: ")..entero().\nLa siguiente vez prueba con 220. System.out."). i=2. primo=true. // si llego aquí es que num es divisible-> no es primo
. 284.. if (a==suma_divisores_propios (b) && b==suma_divisores_propios (a)) System. b=Entrada.out. } }
18. a=Entrada.Diseña una función (en adelante DUF) que decida si un número es primo.System.out. int i.println(a+ " y " +b+ " son amigos. else System.
package bol06ej18.entero(). public class Main { static boolean es_primo(int num){ boolean primo.").
if(es_primo(num)) System. public class Main { static int a_elevado_n(int a. } } return(primo). res=1. int num. ya que iremos multiplicando if(n==0) // por definición cualquier número elevado a 0 es 1
package bol06ej19.out.out.
public static void main(String[] args) { boolean res. num=Entrada.out.i++.entero().print("Introduce numero: ").println("No es primo"). else System. int n){ int res.println("Es primo").DUF que calcule an. // el resultado se inicializa a 1. System. } }
exp=Entrada.DUF que muestre en binario un número entre 0 y 255. System. }
20.entero().print("Introduzca su exponente: ").exp). public class Main { static void binario(int num) {
.out.println(num + " elevado a " + exp +" = " +res).
package bol06ej20.
public static void main(String[] args) { int num. num=Entrada. System.entero().print("Introduzca base: ").
return(res).i++) res=res*a. System. res=a_elevado_n (num.out.else
res=1.exp.res. for (int i=1.i<=n.out.
num =num/2.out. } // iremos dividiendo y cogiendo el resto while(num!=0) { t[cont] =num%2.255)").print(t[i]).println("").. else { cont =0. int cont.
if (num<0 || 255<num) System.i--) System. if (num==0) { t[cont]=0. cont++.
.i>=0. } System. cont++.out.out.out.println("Número fuera de rango (0. // como t tiene los dígitos en orden inverso for (int i=cont-1.println("En binario: ").
// en t guardaremos los dígitos binarios // un número en binario entre 0 y 255 tiene 8 bits
t = new int [8].int t[]. } System.
} public static void main(String[] args) { int n. System. } } binario(num). i <=n .255): ").
21. for (int i =1. num=Entrada. System.
package bol06ej21. i++) suma += 2*i-1. // así calculamos el i-ésimo impar return (suma).} public static void main(String[] args) { int num.print("Introduzca un numero (0. Escriba una función que sume los n primeros números impares.out.
. public class Main { static int suma_n_impares (int n) { int suma=0.out.print("Introduzca un numero: ")..entero().
System. i <= 2*n-1 . . return (suma)..n =Entrada. // hasta 2*n-1 (el n-ésimo impar)
.entero(). System.println("La suma de los " +n+ " primeros impares es: " +suma_n_impares (n)).out..out.print("Introduzca un numero: "). i+=2) suma += i. } public static void main(String[] args) { int n. for (int i =1.. 5. } }
package bol06ej21.out.println("La suma de los " +n+ " primeros impares es: " +suma_n_impares (n)).entero(). } } // el for irá 1. System. 3. n =Entrada. public class Main { static int suma_n_impares (int n) { int suma=0.
Dado el valor de un ángulo.sin(n)). // otra forma sería n = Math.real().out. sería interesante saber su seno.. } }
23.toRadians(n).360): "). Escribir una función que muestre en pantalla los datos anteriores. public class Main { static void informacion_angulo (double n) { // como las funciones que calculan el seno.
. } public static void main(String[] args) { double angulo. coseno y tangente trabajan en // radianes. System.cos(n)). System.println("seno: " + Math. Diseñar una función que calcule la distancia euclídea de dos puntos.print("Introduzca un ángulo (0. hemos de pasar n de grados a radianes n = Math. coseno y tangente.out.
package bol06ej22.println("tangente: " + Math. System.out.
System.PI/180*n.tan(n)). angulo =Entrada.22.out.println("coseno: " + Math. informacion_angulo (angulo).
out. x2. int x2. y1. } public static void main(String[] args) { int x1. System.entero().out.print("x: "). y1 = Entrada.out.entero().sqrt( Math.
. 2))).out. l =distancia_euclidea (x1. 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.print("x: "). int y1.out. y2.out.print("y: ").pow (x1-x2.println("Punto 1").entero(). // distancia euclídea System.entero(). System. // primer punto int x2. System. // el otro punto double l.print("y: "). x1 = Entrada. System.pow (y1-y2. System.println("\nPunto 2"). y2 = Entrada.y2). 2) + Math. public class Main { static double distancia_euclidea (int x1.package bol06ej23. x2 = Entrada.y1.
if(num %2 == 0) // si es par { t[i] = num. } else impares_ignorados++.println("\nDistancia euclídea: " +l). Se leerá por teclado una serie de números: guardaremos solo los pares e ignoraremos los impares. i = 0. while (i<t. impares_ignorados = 0. num = Entrada.print("Introduzca número: ").out.
. public class Main { static int rellena_tabla_pares(int t[]){ int i.System.
package bol06ej24.num. impares_ignorados.length) { // terminaremos de rellenar la tabla cuando el número // de pares sea igual que el tamaño de la tabla
System. } }
24. DUF a la que se le pasa como parámetro una tabla que debe rellenar. // lo guardamos i++.out. También hay que devolver la cantidad de impares ignorados.entero().
t = new int[5].
25. System.println("El numero de impares ignorados es de: " +igno).i<5.
package bol06ej25.println("La tabla queda: "). DUF a la que se le pasa una tabla de enteros y un número. igno = rellena_tabla_pares(t). } public static void main(String[] args) { int igno.out.print(t[i]+ " System.out. System.out.int n) { int i.out.println("").i++) System.
. public class Main { static boolean busca(int t[].t[]. for(int i=0. Debemos buscar el número en la tabla e indicar si se encuentra o no.return(impares_ignorados). } } ").
ya que si i está fuera de rango da un error esta =true. 38. for (int i=0.
public static void main(String[] args) { int a[]={1.
.que he buscado por toda la tabla sin encontrarlo y al final me salgo de la tabla // .length && t[i]!=n) // si no es t[i]. i=0. puede ser por dos motivos: // .println(a[i]).entero().out. System. boolean esta.out.boolean esta. // cuando termina el mientras. 11}. return(esta).length) // si no llego al final de la tabla es por que lo he encontrado // t[i] == num no es válido. else esta =false.print("\introduce numero a buscar: "). // es un ejemplo de posibles valores int num.out. num=Entrada.i<5. while (i<t. paso al siguiente // con cuidado de no salirme de la tabla i++.o que lo he encontrado if (i<t.println("La tabla es: "). System. 12. 5.i++) System.
paso al siguiente // con cuidado de no salirme de la tabla i++. else System. if (esta) System. y el número de elementos se pasa también como parámetro.out.int n. i=0. while (i<tam && t[i]!=n) // si no es t[i]. pero suponiendo que la tabla no está siempre llena.out. Igual que el ejercicio anterior.num). int tam) { int i. boolean esta.println("EL número está").que he buscado por toda la tabla sin encontrarlo y al final me salgo de la tabla // . puede ser por dos motivos: // .o que lo he encontrado
.println("El número no está"). } }
26. // cuando termina el mientras.esta=busca(a. public class Main { static boolean busca(int t[].
package bol06ej26.
esta=busca(a. a[0] a[1] a[2] a[3] a[4] = = = = = 1.entero().i++) System. System. 38.out. 11.
tam = 5. num.
.println("La tabla es: ").print("\nIntroduce numero a buscar: "). int tam. boolean esta.out. else esta =false. System. tam). 12.out. for (int i=0.if (i<tam) // si no llego al final de la tabla es por que lo he encontrado // t[i] == num no es válido.i<tam.println(a[i]).
public static void main(String[] args) { int a[]= new int [20]. 5. int num. return(esta). ya que si i está fuera de rango // t[i] es basura esta =true. num=Entrada.
package bol06ej27. a la que se le pasa dos tablas.if (esta) System. 'r'. switch(opc) { case 's': for(i=0.
27.b[i].i<=nelem-1.i<=nelem-1. result = new int[nelem].Diseñar la función opera_tabla.out. case 'r': for(i=0. result[].i++) result[i] = a[i] .out. char opc. int nelem){ int i. multiplicar o dividir (mediante un carácter: 's'. 'm'.println("El número está").println("El número no está"). public class Main { static int[] opera_tabla(int a[]. break. else System. La función debe devolver una tabla con los resultados. el número de elementos útiles y que operación se desea realizar: sumar.i++) result[i] = a[i] + b[i]. 'd'). break. restar. int b[].
public static void main(String[] args) { int num_datos_utiles. break.i++) result[i] = a[i] / b[i]. =6.case 'm': for(i=0. =17. =7. =-3.out. tabla1 = new int[10]. case 'd': for(i=0.println("tabla1 tabla2"). tabla2[]. int tabla1[]. =7.i++)
.i<=nelem-1. break. =3. System. char operacion.i++) result[i] =a[i] * b[i].
num_datos_utiles =4. resultado[].
return (result).i<=nelem-1. tabla2 = new int[15].i<num_datos_utiles. =2. tabla1[0] tabla1[1] tabla1[2] tabla1[3] tabla2[0] tabla2[1] tabla2[2] tabla2[3] =4.
for(int i=0.
// ordenaremos utilizando la ordenación por intercambio for (int i=0.out.println("Operación (s. System. public class Main { static void ordenar(int a[]){ int tam=a.println (tabla1[i]+ "
" +tabla2[i]).out.out.out.j<tam-i-1. DUF que ordene la tabla que se le pasa. r. operacion.caracter(). // los intercambiamos
. tabla2.j++){ if(a[j]>a[j+1]) // si el elemento j es mayor que el j+1 { aux=a[j].println("El resultado de la operación es:"). m.length.i++) System. for(int i=0.System. resultado =opera_tabla (tabla1.i<num_datos_utiles.i++){ for (int j=0.i<tam-1-1.println (resultado[i]).
package bol06ej28. d): "). operacion = Entrada. num_datos_utiles).
System. int aux. } }
out.i<tam.out. } System.println("\n\nTabla ordenada"). ordenar(t).i++){ t[i]=(int)(Math. mostrar_tabla(t).i++){ System.random()*100)+1.println("Tabla aleatoria"). System.print(t[i] + " } ").length. a[j+1]=aux.
public static void main(String[] args) { int t[]=new int[8].i<8.a[j]=a[j+1]. } }
} } static void mostrar_tabla(int t[]){ int tam=t. for (int i=0.out. for (int i=0. mostrar_tabla(t). } }
length && apuesta[a]!=premiado[p]) p++. La primera con los 6 números de una apuesta de la primitiva. int a. pero con el while evitamos vueltas innecesarias while(p<premiado.49 * . public class Main { /* algunas mejoras propuestas para el alumno son: * .a++) // recorremos la tabla de apuesta { p=0. que debe ser 6 */ static int primitiva(int apuesta[]. } // si p indica un elemento de la tabla // tenemos un acierto más
. // para cada número de la apuesta recorremos premiado // se podría hacer con un for.comprobar que no hay números repetidos en las tablas * . for (a=0..mirar el tamaño de las tablas.a<apuesta. int premiado[]){ int aciertos.length) aciertos++.length. int p. if(p<premiado. DUF que toma como parámetros dos tablas.comprobar que los números están en el rango 1. La función debe devolver el número de aciertos.29. y la segunda con los 6 números ganadores.
package bol06ej29. // utilizaremos a como índice de la tabla apuesta // y p para recorrer premiado
aciertos=0.
out. if (aciertos == 0) System.println("\nLa combinación ganadora es: ").i<primitiva.apuesta). } }
.random()*49+1). es participar.println("Su apuesta es: ").out. System. System.out.out.println("\n\nTiene "+aciertos+" aciertos\n").i++) { apuesta[i]=(int)(Math.random()*49+1). } public static void main(String[] args) { int primitiva[]=new int[6].out. } aciertos=primitiva(primitiva. for (int i=0.return(aciertos).. System. } System.print(apuesta[i] +" "). int aciertos=0.\n")..print(primitiva[i] + " ").i++) { primitiva[i]=(int)(Math. for (int i=0.out.i<apuesta. System. int apuesta[]=new int[6].length.println("Lo importante no es ganar.length.
else // caso recursivo: a^n = a *a^n-1 res = a * potencia(a. return (res). }
. } static double potencia (double a.1).
package bol06ej30.1).30. public class Main { /* sobrecargamos la función para que funcione tanto con bases enteras * como reales * */ static int potencia (int a. int n) { double res. n . DUF recursiva que calcule an. else res = a * potencia(a. return (res). if (n == 0) res = 1. int n) { int res. if (n == 0) // el caso base: cuando el exponente es 0 res = 1. n .
package bol06ej31.out.entero(). System.public static void main(String[] args) { double num.real(). if(num==0) // caso base: 0! es igual a 1 res=1. resultado. else res=num*factorial(num-1). num = Entrada. System..
.out.print("Introduzca la potencia: ").print("Introduzca base (real): "). // n!= n*(n-1)*(n-2). int potencia. un ejemplo 3!=3*2*1 // también ocurre que n!=n*(n-1)! // como ejemplo 4!=4*3! } return(res). potencia = Entrada. Calcular el factorial de n recursivamente.println("El resultado es: " + resultado).. resultado = potencia(num.out. potencia). public class Main { static int factorial(int num){ int res. System. } }
int k. // caso base: pos indica el último elemento de t // en este caso este será el máximo
. */ static int maximo (int t[].entero(). DUF que calcule el valor máximo de una tabla de forma recursiva.out. public class Main { /** la función máximo busca el mayor número entre los elementos de t.length-1) else { res=t[pos]. resultado=factorial(num). num=Entrada.
package bol06ej32. } } System.println(num+"! es igual a "+resultado).out. if(pos==t.
32. System.resultado. * a partir de las posición pos. int pos) { int res.print("Introduzca el numero: ").public static void main(String[] args) { int num.
out.print(datos[i] + " "). for (int i = 0.println("Los datos son:"). i++) System. int max. // en caso contrario será k el máximo } } return(res). } public static void main(String[] args) { int datos[].random()*1000+1). i < datos.length.
// el usuario utilizará esta función por comodidad static int maximo (int t[]) { return (maximo (t. datos = new int[10]. for (int i = 0. System. i < datos.k = maximo (t.
. max =maximo(datos).length. //t[pos] es el máximo else res = k.0)). // k será el mayor desde la posición pos+1 hasta el último elemento if (t[pos]>k) // si t[pos] es mayor que k res = t[pos]. i++) datos[i] = (int) (Math.pos+1).out.
out. max =maximo(t).out. } // // // // // // // // El máximo de una tabla será el máximo entre el primer elemento de la tabla y el resto de la tabla (es decir del segundo elemento hasta el último). 10. 1. public class Main { public static void main(String[] args) { int t[]={7. 2. System. Vamos acortando la tabla. t. }
. 0.println("El máximo es: " +max).length-1 )). 9}. El caso base será una tabla donde solo se busca en un elemento elemento. Está claro que ese único elemento será el mayor de la tabla (de 1 elemento). } }
package bol06ej32. indicando el primer índice donde se empezará a buscar el máximo. // un ejemplo para probar la función int max.
static int maximo(int t[]) { return (maximo(t.println("\n\nEl máximo es: " + max). 5.System.
desde+1. DUF que calcule el n-ésimo término de la serie de Fibonacci. int hasta) { int mayor. if (mayor < t[desde]) mayor = t[desde]. else { mayor = maximo(t. Es decir fibonacci(n) = fibonacci(n1)+fibonacci(n-2). public class Main { static int fibo(int num) { int res. siendo fibonacci(0)=1 y fibonacci(1)=1.static int maximo(int t[].
package bol06ej33. if (desde == hasta) // caso base // la tabla solo tiene un elemento mayor=t[desde]. hasta). int desde. } }
33. if(num==0) res=0. En esta serie el n-ésimo valor se calcula sumando los dos valores anteriores. } return (mayor). else{ if(num==1) // primer caso base // segundo caso base
} } ").resultado. // si n es muy grande esto puede tardar bastante.\nIntroduzca n (se recomienda n<40): num=Entrada.
package bol06ej34. } public static void main(String[] args) { int num. System.entero(). // caso general recursivo
return(res). public class Main { /** * sobrecargamos la función para que funcione de la siguiente forma: * .else }
res=1.out. pero pudiendo configurar los valores de los dos primeros término de la serie.print("Vamos calcular fibonacci(n). res=fibo(num-1)+fibo(num-2). resultado=fibo(num).si solo se le pasa el término a calcular: utiliza los casos bases típicos
. System.println("\nfibonacci(" + num + ") = " +resultado).
34. Igual que el ejercicio anterior.out.
fibo0. fibo1). int fibo1) { int res. else{ if(num==1) // segundo caso base res=1. else{ if(num==1) // segundo caso base. } return(res). } static int fibo(int num.se le puede pasar los valores de los casos bases: fibo(0) y fibo(1) */ static int fibo(int num) { int res.fibo0. else res=fibo(num-1)+fibo(num-2). if(num==0) // primer caso base. también configurable res=fibo1. int fibo0. if(num==0) // primer caso base res=0. else res=fibo(num-1. fibo1)+fibo(num-2.* . // caso general recursivo // hemos de acordarnos de utilizar la función fibo que // tiene 3 parámetros }
// caso general recursivo
. que tendrá el valor indicado por el usuario res=fibo0.
resultado. System. fibo1).
35. System.print ("\nIntroduzca n (se recomienda n<40): num=Entrada.entero().print("Introduzca el valor de fibonacci(0): ").out.out.fibo1.println("\nfibonacci(" + num + ") = " +resultado).entero(). // si n es muy grande esto puede tardar bastante. DUF que realice la búsqueda dicotómica en una tabla. fibo1 = Entrada.out. resultado=fibo(num. de forma recursiva. System. System.entero(). public class Main {
.out. int fibo0.out. } } "). fibo0 = Entrada.return(res).println("Vamos calcular fibonacci(n)\n"). System.print("Introduzca el valor de fibonacci(1): "). fibo0.
package bol06ej35. } public static void main(String[] args) { int num.
else pos =pos2. int elem.. int ultimo) { int pos. else { int pos1. elem. (primero+ultimo)/2).ultimo // se pone mitad+1.mitad pos1 = busca (t. la tabla.. // buscamos en la segunda parte de la tabla: mitad+1.
. el elemento a buscar. y se cogerá el valor de pos2 (-1)
return(pos). static int busca (int t[]. if(primero >= ultimo) // caso base: solo hay un elemento donde buscar
if (t[primero]==elem) pos =primero. // en caso contrario debo encontrarlo en la segunda parte } // en caso de no encontrarse pos1 y pos2 serán -1. // llamada recursiva //buscamos en la primera mitad de la tabla: 0. primero. pos2. (primero+ultimo)/2+1. int primero.. else pos =-1. por no repetirlo pos2 = busca (t. y la primera // y última posición donde buscar. por que el elemento mitad ya pertenece a la // primera parte. ultimo).// a la función se le pasa. if (pos1 != -1) // si lo encuentro en la primera parte pos =pos1.. elem.
out. i < datos. } public static void main(String[] args) { int datos[].println("Los datos son:"). t.print("\n\nElemento a buscar: ").length. int num.print(datos[i] + " ").entero(). cagamos datos aleatorios for (int i = 0. i++) datos[i] = (int) (Math.length-1)).random()*1000+1). num). for (int i = 0.out. elem.} // el usuario utilizará esta función por comodidad // solo es necesario pasarle la tabla y el elemento a buscar // devuelve el índice del elemento si lo encuentra o -1 en caso contrario static int busca (int t[]. int elem) { return (busca (t. num =Entrada. 0. i < datos. i++) System. if (pos == -1)
.length. // para no teclearlos. datos = new int[10]. System. int pos. // llamamos a la función buscar pos =busca(datos.out. System.
package bol06ej36. D). CN=12. R. que indique si el rey negro está amenazado.
36. DN=14. DUF que toma una tabla bidimensional de enteros. (P. A=3. A. public class Main { final final final final final final final final final final final final final static static static static static static static static static static static static static int int int int int int int int int int int int int V=-1. D=4.out. RN=15. representando un tablero de ajedrez. System. Disponemos de las constantes PB (peón blanco).else } }
System.out. P=0. AN=13.
. C=2. // // // // // // // escaque vacío peón torre caballo alfil dama rey
// igual para los negros PN=10. Dicho módulo debe devolver un valor booleano. C.println("\n\nNo encontrado"). TN (torre negra). TN=11. R=5.println("\n\nEncontrado en la posición: " +pos). T. T=1. etc.
V. pos_rey = busca_rey (tablero). {V. V}. V. V. V. V}.
V.out. V. DN. V. V}}. T. {V. V}. V. // ahora iremos viendo las posibles amenazas una a una:
. } static boolean jaque(int tablero[][]) { boolean amenaza=false. V. V.
V. V. V. V}. CN. V}. V. V. V. V. V. // mostramos se existe amenaza System. R.println("Jaque: " +amenaza). V. V. Ya que hemos de imaginarlo // rotado 90 grados hacia la izquierda. // En realidad el tablero no es como se ve arriba. {V. V. V. V. boolean amenaza.
V. V. P. int pieza. P. V. V. V. {V. // pieza que no está amenazando int pos_rey[]. V. {V. V. V. V. V.final int tablero[][] = {
{V. V. {V. V. V}.
// hay que tener con el tablero: como lo visualizamos y sus índices. V. // posición del rey en el tablero pos_rey = new int [2]. // // // // una posible mejora es indicar en la variable amenaza la primera pieza contraria nos está acechando e indicar con un escaque vacío que no existe peligro
amenaza = jaque (tablero). V. V. V. AN}. V. V. {V.
// en primer lugar veremos si nos amenaza un caballo: amenaza =amenaza_caballo (tablero. pos_rey). dy:1) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. -1). dy:1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. dy:-1) // aquí no puede amenazar un alfil o una dama
. // miraremos hacia abajo (dx:0. // AHORA // miraremos hacia la derecha (dx:1. 1. // miraremos en la diagonal derecha arriba (dx:1. dy:0) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. 1). pos_rey. // miraremos en la diagonal derecha abajo (dx:1. 1). 0). pos_rey. 0. 1. // miraremos hacia arriba (dx:0. 0. if (pieza ==DN || pieza ==TN) amenaza=true. 0). pos_rey. if (pieza ==DN || pieza ==TN) amenaza=true. // miraremos hacia la izquierda (dx:-1. pos_rey. if (pieza ==DN || pieza ==AN) amenaza=true. dy:0) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. if (pieza ==DN || pieza ==TN) amenaza=true. dy:-1) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. if (pieza ==DN || pieza ==TN) amenaza=true. pos_rey. -1.
-1). // falta que nos amenace un peón // el posible peón se encuentra arriba a la derecha o a la izquierda if ( (pos_rey[0]+1<8 && pos_rey[1]+1<8 && tablero[pos_rey[0]+1][pos_rey[1]+1]==PN) || (0<=pos_rey[0]-1 && pos_rey[1]+1<8 && tablero[pos_rey[0]-1][pos_rey[1]+1]==PN) ) amenaza=true. } return (amenaza). dy:-1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero.
. if (pieza ==DN || pieza ==AN) amenaza=true. -1). pos_rey. // miraremos en la diagonal izquierda abajo (dx:-1. -1. Siendo posicion[0] la columna y // posicion[1] la fila. int posicion[]. if (pieza ==DN || pieza ==AN) amenaza=true.pieza =primera_pieza(tablero. -1. static int[] busca_rey (int tablero[][]) { int i. // miraremos en la diagonal izquierda arriba (dx:-1. 1. pos_rey. 1). pos_rey. dy:1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero.
// esta función busca el rey blanco y devuelve su posición // en una tabla de dos elementos.j. if (pieza ==DN || pieza ==AN) amenaza=true.
posicion = new int [2]. //posición del tablero en la que estamos mirando int pieza. } // esta función busca la primera pieza que existe desde la posición pos. // Los valores de dx. int pos[]. posy =pos[1]. i++) for (j=0. for (i=0. int dx. i <8. int dy) { int posx. } return (posicion).
. j++) if (tablero[i][j]==R) { posicion[0] =i. posx =pos[0]. dy son: // dx dy dirección // 1 1 diagonal derecha arriba // 1 0 derecha // 1 -1 diagonal derecha abajo // 0 1 hacia arriba // 0 0 ESTE CASO NO SE DARÁ NUNCA // 0 -1 hacia abajo // -1 1 diagonal izquierda arriba // -1 0 hacia la izquierda // -1 -1 diagonal izquierda abajo static int primera_pieza (int tablero[][]. // en la dirección indicada por dx. dy. posicion[1] =j. posy. j <8.
posy +=dy.pieza = V.
static boolean amenaza_caballo (int tablero[][]. 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) || || || ||
. // Hay que tener cuidado al comprobar los caballos de no salirse del // tablero // // // if Desde la posición actual vemos los puede amenazarnos un caballo.
// en principio suponemos que no hay ninguna pieza
// damos el primer paso: es decir pasamos a la primera casilla // después del rey. posy += dy. // mientras no nos salgamos del tablero y no encontremos una pieza while ( 0<=posx && posx<=7 && 0<=posy && posy<=7 && pieza ==V) { pieza = tablero[posx][posy]. posx += dx. } } return (pieza). posx +=dx. int pos[]) { boolean amenaza=false.
DN=14. P=0.
package bol06ej37. D=4. A=3.
. R=5. RN=15. CN=12. AN=13.( 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. 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. Igual que el ejercicio anterior.
|| || || )
37. pero indicando si existe jaque mate a las negras. T=1. } } return (amenaza). C=2. // // // // // // // escaque vacío peón torre caballo alfil dama rey
// igual para los negros PN=10. TN=11.
V. num_jaque += mover_rey (tablero. V. { V. boolean amenaza=false. V.
V. V. V}. V. V. V}. V}. V. { V. if ( jaque (tablero) == true ) { amenaza =true. V. V}}. { V.
. V. V. V. // En realidad el tablero no es como se ve arriba. -1). V. V. V. R. DN}. V. { V.
V. -1). DN. num_jaque += mover_rey (tablero. {CN. // // // // 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. num_jaque=0. V. V. { V. V.public static void main(String[] args) { int tablero[][] = { { V. V. 1). V. V. int pos_rey[]. P. 1. { V. Ya que hemos de imaginarlo // rotado 90 grados hacia la izquierda. V.
V. V. V. V. V. V}. 0. V. 0.
// hay que tener con el tablero: como lo visualizamos y sus índices. int num_jaque=0. V}. V. V}. V. PN. V. V. P. V. V. // intentaremos mover el rey a las casillas adyacentes // y comprobar si en la nueva ubicación recibe jaque num_jaque += mover_rey (tablero. V. V. V. V.
} static boolean jaque(int tablero[][]) { boolean amenaza=false. // ahora iremos viendo las posibles amenazas una a una: // en primer lugar veremos si nos amenaza un caballo: amenaza =amenaza_caballo (tablero. 1. -1.out."). -1. (tablero.println("Jaque Mate"). int pieza. -1.out. else System.println("Solo es jaque. (tablero. -1). // pieza que no está amenazando int pos_rey[]. // posición del rey en el tablero pos_rey = new int [2]. 1).println("El rey no está amenazado"). 1.}
num_jaque num_jaque num_jaque num_jaque num_jaque
+= += += += +=
mover_rey mover_rey mover_rey mover_rey mover_rey
(tablero. 0). // AHORA // miraremos hacia la derecha (dx:1. dy:0) // aquí no puede amenazar una torre o dama
. 0).out.
// mostramos se existe amenaza if (amenaza) if (num_jaque<8) System. pos_rey). 1). pos_rey = busca_rey (tablero). else System. (tablero. (tablero.
pieza =primera_pieza(tablero. if (pieza ==DN || pieza ==AN) amenaza=true. if (pieza ==DN || pieza ==TN) amenaza=true. dy:-1) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. // miraremos en la diagonal derecha abajo (dx:1. pos_rey. -1). // miraremos en la diagonal derecha arriba (dx:1. if (pieza ==DN || pieza ==TN) amenaza=true. dy:1) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero. 1). -1. 1. 1. pos_rey. dy:1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. -1). // miraremos hacia arriba (dx:0. if (pieza ==DN || pieza ==TN) amenaza=true. 0). pos_rey. // miraremos hacia abajo (dx:0. pos_rey. // miraremos en la diagonal izquierda arriba (dx:-1. 0. dy:-1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. 1). pos_rey. 0. pos_rey. dy:1) // aquí no puede amenazar un alfil o una dama
. if (pieza ==DN || pieza ==TN) amenaza=true. 1. if (pieza ==DN || pieza ==AN) amenaza=true. // miraremos hacia la izquierda (dx:-1. 0). dy:0) // aquí no puede amenazar una torre o dama pieza =primera_pieza(tablero.
static int[] busca_rey (int tablero[][]) { int i. int posicion[]. j++) if (tablero[i][j]==R)
. -1). } return (amenaza). if (pieza ==DN || pieza ==AN) amenaza=true. j <8. pos_rey.j. pos_rey.pieza =primera_pieza(tablero. posicion = new int [2]. dy:-1) // aquí no puede amenazar un alfil o una dama pieza =primera_pieza(tablero. for (i=0. if (pieza ==DN || pieza ==AN) amenaza=true. -1. // miraremos en la diagonal izquierda abajo (dx:-1. 1). -1. i++) for (j=0. // falta que nos amenace un peón // el posible peón se encuentra arriba a la derecha o a la izquierda if ( (pos_rey[0]+1<8 && pos_rey[1]+1<8 && tablero[pos_rey[0]+1][pos_rey[1]+1]==PN) || (0<=pos_rey[0]-1 && pos_rey[1]+1<8 && tablero[pos_rey[0]-1][pos_rey[1]+1]==PN) ) amenaza=true. Siendo posicion[0] la columna y // posicion[1] la fila.
// esta función busca el rey blanco y devuelve su posición // en una tabla de dos elementos. i <8.
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[][].
return (posicion). posy +=dy. posicion[1] =j.{ } }
posicion[0] =i.
. // en la dirección indicada por dx. //posición del tablero en la que estamos mirando int pieza. dy. int dx. posx =pos[0]. posy. pieza = V. posy =pos[1]. // Los valores de dx. posx +=dx. int pos[]. int dy) { int posx. // esta función busca la primera pieza que existe desde la posición pos. // en principio suponemos que no hay ninguna pieza
// damos el primer paso: es decir pasamos a la primera casilla // después del rey.
// 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[][]. } } return (pieza). // Hay que tener cuidado al comprobar los caballos de no salirse del // tablero // // // if Desde la posición actual vemos los puede amenazarnos un caballo. Algunas de estas posiciones pueden ( ( pos[0]+2 <8 && pos[1]+1 ( pos[0]+2 <8 && 0<= pos[1]-1 (0<= pos[0]-2 && pos[1]+1 (0<= pos[0]-2 && 0<= pos[1]-1 ( pos[0]+1 <8 && pos[1]+2 ( pos[0]+1 <8 && 0<= pos[1]-2 (0<= pos[0]-1 && pos[1]+2 (0<= pos[0]-1 && 0<= pos[1]-2 amenaza = true. 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) || || || || || || || )
. posy += dy. posx += dx. int pos[]) { boolean amenaza=false.
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.
if ( 0<=pos[0]+dx && pos[0]+dx<8 && 0<=pos[1]+dy && pos[1]+dy<8 && ( tablero[pos[0]+dx][pos[1]+dy]==V tablero[pos[0]+dx][pos[1]+dy]==PN tablero[pos[0]+dx][pos[1]+dy]==TN tablero[pos[0]+dx][pos[1]+dy]==CN tablero[pos[0]+dx][pos[1]+dy]==AN tablero[pos[0]+dx][pos[1]+dy]==DN { int pieza. tablero[pos[0]+dx][pos[1]+dy] =R. pos = busca_rey(tablero). int pos[].}
return (amenaza).
|| || || || || ) )
// guardamos la pieza que ocupa la posición a ocupar por el rey // esta pieza puede ser V (vacío) o una pieza negra que el // rey capturará pieza=tablero[pos[0]+dx][pos[1]+dy]. int dy) { int existe_jaque=0. // movemos el rey tablero[pos[0]][pos[1]] =V. pos = new int [2].
static int mover_rey (int tablero[][].
. int dx.
return (existe_jaque)..//volvemos el rey a su posición inicial tablero[pos[0]][pos[1]] =R. existe_jaque=1.. } }
. } else // no podemos mover el rey. en la practica esta casilla no es utilizable // por el rey para escapar. tablero[pos[0]+dx][pos[1]+dy] =pieza. es lo mismo que una amenaza (jaque).
7. 9. Pedir dos números y decir cual es el mayor. Pedir los coeficientes de una ecuación se 2º grado. 5. 4. 8. 3.Boletines completos
BOLETÍN 1 Variables y condicionales
1. Pedir el radio de una circunferencia y calcular su longitud. Pedir dos números y mostrarlos ordenados de mayor a menor. Pedir un número e indicar si es positivo o negativo. Pedir el radio de un círculo y calcular su área. Pedir dos números y decir si son iguales o no. Si no existen. 2. A=PI*r^2. Pedir dos números y decir cual es el mayor o si son iguales. 6.
. debe indicarlo. Pedir dos números y decir si uno es múltiplo del otro. L=2*PI*r. y muestre sus soluciones reales.
Pedir tres números y mostrarlos ordenados de mayor a menor. Pedir un número de 0 a 99 y mostrarlo escrito. Pedir una hora de la forma hora. suponer que todos los meses tienen 30 días. Pedir un número entre 0 y 9. dos.999 y decir cuantas cifras tiene. mes y año de una fecha correcta y mostrar la fecha del día siguiente. decir si es capicúa. 15. 20. y mostrar dicha nota de la forma: cero.999 y mostrarlo con las cifras al revés. Pedir un número entre 0 y 9. Suponiendo todos los meses de 30 días. Pedir el día.. 21.. minutos y segundos. para 56 mostrar: cincuenta y seis.. 17.10. Por ejemplo. 11. 18.999. Ídem que el ej. mes y año de una fecha e indicar si la fecha es correcta.
. Suponiendo todos los meses de 30 días. mes y año de una fecha e indicar si la fecha es correcta. 12. 22. 17. 19. y mostrar la hora en el segundo siguiente. 16. Pedir el día. Pedir un número entre 0 y 9. 30 y 31 días.. suponiendo que cada mes tiene un número distinto de días (suponer que febrero tiene siempre 28 días). Pedir una nota de 0 a 10 y mostrarla de la forma: Insuficiente. Suficiente. Bien. 14. uno. Sin años bisiestos. Con meses de 28. Pedir el día. tres. Pedir dos fechas y mostrar el número de días que hay de diferencia. 13. Pedir una nota numérica entera entre 0 y 10.
repetir el proceso hasta que se introduzca un número negativo. 7. Leer números hasta que se introduzca un 0. Escribir todos los números del 100 al 0 de 7 en 7. 2. Leer un número e indicar si es positivo o negativo. 11. 3. Diseñar un programa que muestre el producto de los 10 primeros números impares. Pedir números hasta que se teclee uno negativo. 9. Mostrar la media de los números positivos.
. y luego ir pidiendo números indicando “mayor” o “menor” según sea mayor o menor con respecto a N.BOLETÍN 2 Condicionales y bucles
1. 13. Pedir números hasta que se introduzca uno negativo. Leer un número y mostrar su cuadrado. Realizar un juego para adivinar un número. Pedir 10 números. El proceso termina cuando el usuario acierta. Pedir un número y calcular su factorial. Para ello pedir un número N. y mostrar todos los números del 1 al N. Pedir números hasta que se teclee un 0. El proceso se repetirá hasta que se introduzca un 0. 6. Pedir un número N. mostrar la suma de todos los números introducidos. Para cada uno indicar si es par o impar. y mostrar cuántos números se han introducido. 12. 10. y calcular la media. 4. 8. Pedir 10 sueldos. 5. Mostrar su suma y cuantos hay mayores de 1000€. la media de los números negativos y la cantidad de ceros. 14. Pedir 15 números y escribir la suma total.
3 €/litro y 3.0. 21. y mostrar el sueldo máximo.1. Una empresa que se dedica a la venta de desinfectantes necesita un programa para gestionar las facturas. Se pide de 5 facturas introducidas: Facturación total. 17. 18.15. cantidad en litros vendidos del artículo 1 y cuantas facturas se emitieron de más de 600 €. 20. Dadas 6 notas. escribir la cantidad de alumnos aprobados. la cantidad de alumnos mayores de 18 años. Dadas las edades y alturas de 5 alumnos. En cada factura figura: el código del artículo. y la cantidad de alumnos que miden más de 1. introducir N sueldos. Solo existen tres productos con precios: 1. 22. y mostrar al final si se ha introducido alguno negativo.6 €/litro. Pedir 5 calificaciones de alumnos y decir al final si hay algún suspenso.25 €/litro. 19.
. Pedir 10 números. la cantidad vendida en litros y el precio por litro. Pide un número (que debe estar entre 0 y 10) y mostrar la tabla de multiplicar de dicho número.75. 23. 16. Pedir un número N. mostrar la edad y la estatura media. condicionados (=4) y suspensos. Pedir 5 números e indicar si alguno es múltiplo de 3. 2. Igual que el anterior pero suponiendo que no se introduce el precio por litro.
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 <. i. PROGRAMA ej_1 VARIABLES i.i*10+j escribir (suma) FIN PARA FIN PARA FIN 2.1 HASTA 3 j <.1 HASTA 4 PARA j <. Realiza una traza del siguiente algoritmo y muestra la salida generada por pantalla.
. j: ENTERO COMIENZO PARA i <.BOLETÍN 3 Bucles anidados
1. j: ENTERO COMIENZO PARA i <. Diseña una aplicación que muestre las tablas de multiplicar del 1 al 10.j+1 FIN MIENTRAS FIN PARA FIN 3.i+1 MIENTRAS j < 4 escribir (j-i) j <.
. 5. Necesitamos mostrar un contador con 5 dígitos (X-X-X-X-X).4. Realizar un programa que nos pida un número n. y nos diga cuantos números hay entre 1 y n que son primos. Dibuja un cuadrado de n elementos de lado utilizando *. con la particularidad que cada vez que aparezca un 3 lo sustituya por una E. 6. que muestre los números del 0-0-0-0-0 al 9-9-9-9-9.
3 de la B. la media de los negativos y contar el número de ceros. 6. decreciente. Leer 10 números enteros. desplazando los que estén detrás. el 2º de B. etc. etc. el 2º de A. Después se debe pedir un número y una posición. 5. el segundo. Leer mediante el teclado 8 números. 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). el tercero. 9. 7. Leer por teclado dos tablas de 10 números enteros y mezclarlas en una tercera de la forma: el 1º de A.
4. otros 3 de A.
. el 1º de B. insertarlo en la posición indicada. Leer los datos correspondiente a dos tablas de 12 elementos numéricos. o si están desordenados. el último. y mezclarlos en una tercera de la forma: 3 de la tabla A. Diseñar una aplicación que declare una tabla de 10 elementos enteros.BOLETÍN 4 Tablas
1. 8. el penúltimo. Leer 5 números y mostrarlos en el mismo orden introducido. La aplicación debe indicarnos si los números están ordenados de forma creciente. Debemos mostrarlos en el siguiente orden: el primero. 3. etc. Leer por teclado una serie de 10 números enteros. Leer 5 números y mostrarlos en orden inverso al introducido. Leer 5 números por teclado y a continuación realizar la media de los números positivos. otros 3 de la B. 2.
Ídem. Cada grupo (o clase) está compuesto por 5 alumnos. desplazar N posiciones (N es introducido por el
usuario). Se debe mostrar la posición en que se encuentra.
11. 12. Se pide leer las notas del primer. indicarlo con un mensaje. Éstos los guardaremos en una tabla de tamaño 10. de forma que sigan ordenados. Leer dos series de 10 enteros. Guardar en otra tabla los elementos pares de la primera. Leer un número N. Queremos desarrollar una aplicación que nos ayude a gestionar las notas de un centro educativo.
. 14. y a continuación los elementos impares.10. que estarán ordenados crecientemente. Leer N y buscarlo en la tabla. Eliminar el elemento situado en la posición dada sin dejar huecos. Leer por teclado una tabla de 10 elementos numéricos enteros y leer una posición (entre 0 y 9). 16. e insertarlo en el lugar adecuado para que la tabla continúe ordenada. Copiar (fusionar) las dos tablas en una tercera. Leer 10 enteros. Realizar dos versiones: una trabajando con los valores y otra trabajando con los índices. 13. Si no está. y la media del alumno que se encuentra en la posición N (N se lee por teclado). 15. segundo y tercer trimestre de un grupo. Leer 5 elementos numéricos que se introducirán ordenados de forma creciente. Leer 10 enteros ordenados crecientemente. Debemos mostrar al final: la nota media del grupo en cada trimestre.
si se obtiene la misma tabla al cambiar filas por columnas. 6. Después se debe mostrar su contenido. 7. Crear y cargar una tabla de tamaño 10x10. m. 8. mostrar la suma de cada fila y de cada columna.BOLETÍN 5 Tablas n-dimensionales
1. 4. i: ENTEROS a. 5. 10. Crear y cargar una tabla de tamaño 3x3. Hacer lo mismo que el ejercicio anterior. Crear una tabla bidimensional de tamaño 5x5 y rellenarla de la siguiente forma: la posición T[n. Mostrarla. b: TABLA [100] ENTEROS COMIENZO n  10
. Mostrar el resultado:
PROGRAMA Ej10a VARIABLES i. es decir. a: ENTEROS t: TABLA [5] ENTEROS COMIENZO PARA i0 HASTA 4 leer (t[i]) PROGRAMA Ej10b VARIABLES n. creamos un cubo con las caras puestas a 1 y el interior a 0. cargar la primera y trasponerla en la segunda. trasponerla y mostrarla. Crear una matriz “marco” de tamaño 8x6: todos sus elementos deben ser 0 salvo los de los bordes que deben ser 1. sumarlas y mostrar su suma. Crear y cargar dos matrices de tamaño 3x3.m] debe contener n+m. utilizando dos tablas de tamaño 5x9 y 9x5. 3. pero con una matriz 9x9x9. Los siguientes programas piden una serie de datos y tras procesarlos ofrecen unos resultados por pantalla. Crear y cargar una tabla de tamaño 4x4 y decir si es simétrica o no. 9. 2. Es decir. Crear una tabla de tamaño 7x7 y rellenarla de forma que los elementos de la diagonal principal sean 1 y el resto 0.
Mostrar listado por marcas. Sus datos se irán introduciendo en el mismo orden que vayan inscribiéndose los atletas. Mostrar listado de datos. 8. mejor marca del 2001 y mejor marca del 2000.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. Si se elige la opción 2.
. 2. que terminará el programa. mejor marca del 2002. El número de plazas disponible es de 10. de mayor a menor. se debe mostrar un listado por número de dorsal. Finalizar el programa.
Si se selecciona 1. 3 y 2. 1. se debe mostrar de nuevo el menú inicial. La opción 3 mostrará un listado ordenado por la marca del 2002. 2. 6 y 1. 9. Tras procesar cada opción. 2. se introducirán los datos de uno de los participantes: Nombre. 5. Diseñar el programa que muestre las siguientes opciones: 1234Inscribir un participante. 8. hasta que se seleccione la opción 4.
11-Se pretende realizar un programa para gestionar la lista de participaciones en una competición de salto de longitud. 0.
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.
Ídem una versión que calcule el máximo de 3 números. según se especifique. 4.Ídem diseñar una función que devuelve una tabla con los divisores. el mensaje: “Módulo ejecutándose” 2. 10. y que calcule el máximo. inclusive. Realizar una función. a la que se le pase como parámetro un número N. 11. Función a la que se le pasan dos enteros y muestra todos los números comprendidos entre ellos. Diseñar una función que tenga como parámetros dos números. Función que muestra en pantalla el doble del valor que se le pasa como parámetro.Escribir una función que calcule el máximo común divisor de dos números.BOLETÍN 6 Funciones
1. Ídem que devuelva una tabla con el área y el volumen. 8. Para distinguir un caso de otro se le pasará el carácter 'a' (para área) o 'v' (para el volumen). 7.Ídem con tres números. 5. 6. y muestre por pantalla N veces. Realizar una función que calcule (muestre en pantalla) el área o el volumen de un cilindro. 3. Ídem una versión que calcule el máximo de una tabla de n elementos.
. 9. Además hemos de pasarle a la función el radio y la altura. 12. Módulo al que se le pasa un número entero y devuelve el número de divisores primos que tiene.
sería interesante saber su seno.Diseña una función (en adelante DUF) que decida si un número es primo.
. 25. Diseñar una función que calcule la distancia euclídea de dos puntos.Ídem con tres números. Debemos buscar el número en la tabla e indicar si se encuentra o no. 15. 24. 18. También hay que devolver la cantidad de impares ignorados. 23.DUF que calcule an. si la suma de sus divisores (distintos de ellos mismos) son iguales. DUF a la que se le pasa como parámetro una tabla que debe rellenar.Escriba una función que decida si dos números enteros positivos son amigos. 16. Dado el valor de un ángulo. Se leerá por teclado una serie de números: guardaremos solo los pares e ignoraremos los impares. 20. DUF a la que se le pasa una tabla de enteros y un número. Dos números son amigos. 17. Escribir una función que muestre en pantalla los datos anteriores.13.Ídem con una tabla. 21.Ídem con una tabla. coseno y tangente. 14.Escribir una función que calcule el mínimo común múltiplo de dos números. 22. Escriba una función que sume los n primeros números impares.DUF que muestre en binario un número entre 0 y 255. 19.
TN (torre negra). 'm'. DUF que calcule el valor máximo de una tabla de forma recursiva. el número de elementos útiles y que operación se desea realizar: sumar. 'r'. 'd'). y la segunda con los 6 números ganadores. Disponemos de las constantes PB (peón blanco). Es decir fibonacci(n) = fibonacci(n-1)+fibonacci(n-2). representando un tablero de ajedrez. 32. D). multiplicar o dividir (mediante un carácter: 's'. Igual que el ejercicio anterior. 30. C. 27. 36. DUF recursiva que calcule an. Igual que el ejercicio anterior. 34.
. La primera con los 6 números de una apuesta de la primitiva.Diseñar la función opera_tabla. T. DUF que calcule el n-ésimo término de la serie de Fibonacci. 29. 35.26. siendo fibonacci(0)=1 y fibonacci(1)=1. DUF que toma como parámetros dos tablas. 28. restar. DUF que toma una tabla bidimensional de enteros. La función debe devolver el número de aciertos. a la que se le pasa dos tablas. 31. pero suponiendo que la tabla no está siempre llena. etc. R. (P. La función debe devolver una tabla con los resultados. y el número de elementos se pasa también como parámetro. DUF que realice la búsqueda dicotómica en una tabla. pero pudiendo configurar los valores de los dos primeros término de la serie. Calcular el factorial de n recursivamente. A. En esta serie el n-ésimo valor se calcula sumando los dos valores anteriores. de forma recursiva. 33. DUF que ordene la tabla que se le pasa.
Dicho módulo debe devolver un valor booleano. pero indicando si existe jaque mate a las negras. 37.
. que indique si el rey negro está amenazado. Igual que el ejercicio anterior.
public class Entrada { static String inicializar(){ String buzon="". return valor.parseInt(inicializar()).parseDouble(inicializar()). } return buzon.out. } static double real(){ double valor=Double.
.*. } static int entero(){ int valor=Integer. InputStreamReader flujo=new InputStreamReader(System.io. try{ buzon=teclado. } catch(Exception e){ System.append("Entrada incorrecta)").Clase Entrada
import java.readLine().in). BufferedReader teclado=new BufferedReader(flujo).
return valor.charAt(0).
static String cadena(){ String valor=inicializar(). } }
. } static char caracter(){ String valor=inicializar().}
return valor. return valor.
More From This UserSkip carouselExam en Final
Sign up to vote on this titleUsefulNot usefulJava by Rocio Dominguez0.0 (0)EmbedDownloadRead on Scribd mobile: iPhone, iPad and Android.Copyright: Attribution Non-Commercial (BY-NC)List price: $0.00Download as PDF, TXT or read online from ScribdFlag for inappropriate contentMore informationShow less
RelatedJava Eclipseby Victor David Montañezjavaby Daniel Ipanaque MazaProgramacion en Javaby Carlita CamilaJAVA7by Jonathan GuzmanProgramacion Java 7 - Rogers Cadenheadby huma2225Programación en Javaby sable14A Prende Javaby Fernando Trujillo BenítezJava soluciones de programaciónby Csar PalaciosLa Biblia del Java.pdfby Aida Tatiana Lopez MorenoFundamentos de Lenguajeby TAtiizz VillalobosManual Javaby Armando Beltran GProgramacion Orientada a Objetos Con Javaby roggerarmasSoluciones Ejercicios Curso Javaby api-3732355Programación Orientada a Objetos en Javaby Amanda Suárez JaenLibro-solucionario ACMICPC Bolivia v1by Jose Torres CardenasJava 20by api-3818173Manual de Javaby miguelmejia1235828ENI Introducción Java EEby Pedro Pablo Juarez Javaby Kakokunk .... O OriginalGuia de Ejercicios Resueltos Javaby gus9801Ejercicios Javaby jjuarez27Ejer Cici Osby Juan Francisco Ruiz DiazAprender a desarrollar un sitio Web con PHP y MySQL.pdfby GA QAENI Patrones de Diseño en JavaLos 23 Modelos de Diseñoby Pedro Pablo Juarez Ceballos: Java 2 - Interfaces Gráficas y Aplicaciones para Internet 4Edby Fco. Javier Ceballos SierraHack x Crack Javaby Armando Valeriano HernandezPensando en Javaby fxbianJavaby gilder fonseca salvadorSimilar To Ejercicios de Programacion en JavaSkip carouselJava EclipsejavaProgramacion en JavaJAVA7Programacion Java 7 - Rogers CadenheadProgramación en JavaA Prende JavaJava soluciones de programaciónLa Biblia del Java.pdfFundamentos de LenguajeManual JavaProgramacion Orientada a Objetos Con JavaSoluciones Ejercicios Curso JavaProgramación Orientada a Objetos en JavaLibro-solucionario ACMICPC Bolivia v1Java 20Manual de JavaENI Introducción Java EEJavaGuia de Ejercicios Resueltos JavaEjercicios JavaEjer Cici OsAprender a desarrollar un sitio Web con PHP y MySQL.pdfENI Patrones de Diseño en JavaLos 23 Modelos de DiseñoCeballosHack x Crack JavaPensando en JavaJavaAnalisis y Disenio de AlgoritmosEjercicios de Programacion en Java

References: resolución 
in fine
 resolución 
 resolución 
 artículo 1
 artículo 1