Serie de Fibonacci en Java
¡Que tal! quiero compartir con ustedes la solución a un ejercicio que viene en el libro que vengo estudiando ("Piensa en Java de Bruce Eckel 4ª Ed.)
1: // Capítulo 4: Flujo de control. Pág 83.
2: /************************* Ejercicio 9 ****************************
3: * Una secuencia Fibonacci es la secuencia de números 1, 1, 2, 3, 5,
4: * 8, 13, 21, 34, etc., donde cada número (a partir del tercero) es
5: * la suma de los dos anteriores. Cree un método que tome un entero
6: * como argumento y muestre esa cantidad de números de Fibonacci co-
7: * menzando por el principio de la secuencia; por ejemlo, si ejecuta
8: * java Fibonacci 5 (donde Fibonacci es el nombre de la clase) la
9: * salida sería: 1, 1, 2, 3, 5.
10: ******************************************************************/
11: import static net.mindview.util.Print.*;
12: public class E09_Fibonacci {
13: public static void imprimir(int cantidad) {
14: int f;
15: int a1 = 0;
16: int a2 = 1;
17: printnb(a2 + ", ");
18: for(int i = 1; i < cantidad; i++) {
19: f = a1 + a2;
20: a1 = a2;
21: a2 = f;
22: printnb(f + ", ");
23: }
24: }
25: public static void main(String[] args) {
26: int cantidad = Integer.parseInt(args[0]);
27: if(cantidad > 0)
28: imprimir(cantidad);
29: else
30: print("La cantidad debe ser mayor a 0");
31: /*print();
32: imprimir(1);
33: print();
34: imprimir(2);
35: print();
36: imprimir(3);*/
37: }
38: }
Existe varias maneras de hacerlo: Recursiva, Iterativa y Divide y vencerás. El método iterativo que emplee es más rápido que el recursivo pero más lento que la versión de divide y vencerás. La solución en Java empleando recursión, se puede checar en este link. La descripción de cada uno de los algoritmos se puede ver en la Wikipedia.
¡Saludos!" y hasta la otra.
¡Bienvenido año 2011!
En esta ocasión, quiero comentar que para este nuevo año tengo como propósito tener más actividad en el blog pues hay tantas cosas que compartir, aprovecho para decir que voy a empezar con unos pequeños cambios, como es el cambio de theme y pues una foto más actual de mi en acerca de…
Me despido no sin antes compartir con ustedes una frase que me guiará este año (tomado en pensamientosyreflexionessobrelavida) y desearles un mejor año, acompañado de ¡mucha felicidad!.
MAMERTO MENAPACE
No pierdas mucho tiempo pensando en el problema. Dedica toda tu energía y sapiencia en buscar soluciones.
JM.
Pasar parámetros de línea de comandos a Geany
¡Hola! quiero compartir con ustedes algo que no encontraba cómo hacer, sucede que probando un ejemplo de Java, necesitaba pasarle unos argumentos desde la línea de comandos, pero pues como lo estaba compilando desde el editor Geany pues estuve buscando como hacerle, tenía mas o menos una idea pues antes ya lo había hecho. En seguida un programa sencillo de ejemplo para probarlo:
1: // Programa de ejemplo donde se le pasa desde la línea de comandos,
2: // argumentos que son recibidos en el programa y se imprimen en la consola.
3:
4: class ImprimeArgumentos {
5: public static void main(String[] args) {
6: System.out.println("Argumento 1 = " + args[0]);
7: System.out.println("Argumento 2 = " = " + args[1]);
8: System.out.println("Argumento 3 = " = " + args[2]);
8: }
9: }
Para esto una vez el código en el editor, nos vamos en Construir de la barra de menú, enseguida se abre una nueva ventana como esta:
Nos vamos en la sección Ejecutar comandos y ponemos delante de java "%e" los argumentos que queremos que reciba nuestro programa, en este caso he colocado : a b c (antes de cada espacio es recibida como una cadena de caracteres en un arreglo de Strings). Una vez hecho esto damos Aceptar y listo ya podemos ejecutar nuestro programa, solo hay que tener cuidado con insertar el numero correcto de argumentos pues el programa no válida que se reciban argumentos, en este caso causaría error en tiempo de ejecución.
Como salida nos debe imprimir:
a
b
b
Esto sería todo, espero le pueda servir a alguien más, me despido hasta la próxima.
Soluciones a ejercicios (Excepciones)
En esta ocasión después de tanto sin postear nada, quiero compartir con ustedes las posibles soluciones a unos ejercicios que vienen en el libro de Piensa en Java de Bruce Eckel edición 4ta. edición, pues ojala le pueda servir a alguién más. Espero estén correctas, sino estaré agradecido por sus correcciones, u otras soluciones:
Ejercicio 1: (2) Cree una clase con un método main() que genere un objeto de la clase Exception dentro de un bloque try. Proporcione al constructor de Exception un argumento String. Capture la excepción dentro de una cláusula catch e imprima el argumento String. Añada una clausula finally e imprima un mensaje para demostrar que pasó por allí.
1: public class ClaseGeneraExcepciones {
2: public static void main(String[] args){
3: try {
4: throw new Exception("Esto es una Excepción");
5: } catch(Exception e) {
6: System.out.println("Se produjo un excepción: " + e.getMessage());
7: } finally {
8: System.out.println("Esto se ejecuta sin importar si se presentan errores");
9: }
10: }
11: }
salida del programa:
Se produjo una excepción: Esto es una Excepción
Esto se ejecuta sin importar si se presentan errores
Después, iré actualizando el post con las demás soluciones de los restantes ejercicios del tema de Excepciones, hasta pronto.
Actualización [15/11/2010]
Aquí están las siguientes soluciones:
Ejercicio 2: (1) Defina una referencia a un objeto e inicializela a null. Trate de invocar un método a través de esta referencia. Ahora rodee el código con una clausula try-catch para probar la nueva excepción.
1: // Ejercicio 2
2:
3: class ExcepcionNull {
4: String s = "ejercico 2 sobre Excepciones";
5: String getString() {
6: return s;
7: }
8:
9: public static void main(String[] args) {
10: ExcepcionNull en = null;
11: try {
12: en.getString();
13: } catch (Exception e){
14: System.out.println("Se produjo una expción. " + e.getMessage());
15: }
16: }
17: }
Salida: Se produjo una expción. null
Ejercicio 3: Escriba código para generar y capturar una excepción ArrayIndexOutOfBoundsException (Índice de matriz fuera de límites).
1: public class ExcepcionEnArray {
2: int[] array = {0, 1, 2, 3, 4, 5};
3: int getValor(int indice) {
4: return array[indice];
5: }
6:
7: public static void main(String[] args) {
8: ExcepcionEnArray ea = new ExcepcionEnArray();
9: try {
10: ea.getValor(6);
11: } catch (ArrayIndexOutOfBoundsException e) {
12: System.out.println("Excepción: indice de array fuera de limites" + e.getMessage());
13: }
14: }
15: }
salida: Excepción: indice de array fuera de limites 6
Actualización [16/11/2010]
Continuó con las soluciones a los ejercicios, si detectarán alguna barbaridad, les agradecería corregirme.
Ejercicio 4: (2) Cree su propia clase de excepción utilizando la palabra clave extends. Escriba un constructor para dicha clase que tome un argumento String y lo almacene dentro del objeto como una referencia de tipo String. Escriba un método que muestre la cadena de caracteres almacenada. Cree una cláusula try-catch para probar la nueva excepción.
1: class MiExcepcion extends Exception {
2: String mensaje;
3: public MiExcepcion(String mensaje) {
4: this.mensaje = mensaje;
5: }
6: public String getMensaje() {
7: return mensaje;
8: }
9: }
10:
11: public class PropiaClaseExcepcion {
12: public static void main(String[] args) {
13: try {
14: throw new MiExcepcion("mi propia Excepción");
15: } catch(MiExcepcion e) {
16: System.out.println("excepción: " + e.getMensaje());
17: }
18: }
19: }
20:
Salida: Excepción generada: mi propia Excepción
Ejercicio 5: (3) Defina un comportamiento de tipo reanudación utilizando un bucle while que se repita hasta que se deje de generar una excepción.
1: import java.io.*;
2:
3: public class ExcepcionConReanudacion {
4:
5: public static void main(String[] args) {
6: boolean continuar = true;
7: while(continuar) {
8: try {
9: System.out.print("Introduce un número entero: ");
10: InputStreamReader datosInsertados = new InputStreamReader(System.in);
11: BufferedReader datos = new BufferedReader(datosInsertados);
12: String cadenaDatos = datos.readLine();
13: int numero = Integer.parseInt(cadenaDatos);
14: int cuadrado = numero * numero;
15: System.out.println("El cuadrado de " + numero + " = " + cuadrado);
16: continuar = false;
17: } catch(Exception e) {
18: System.out.println(e.getMessage());
19: }
20: };
21: }
22: }
Salida:
Introduce un número entero: r
For input string: “r”
Introduce un número entero: t
For input string: “t”
Introduce un número entero: 3
El cuadrado de 3 = 9
Este ejercicio lo pude terminar gracias al apoyo de un tutorial en la parte de la entrada de datos por el teclado.
La palabra clave final (1)
¡Que tal! desgraciadamente tengo abandonado este espacio por muchas razones que creo no tiene caso mencionar, pero hoy decidi agregar esta entrada donde pretendo mostrar lo que aprendi de este tema del libro que ando leyendo. Espero no decir cosas fuera de la realidad.
La palabra clave final
Se emplea final para impedir cambios tanto para elementos de datos, métodos y clases. Se puede querer evitar cambios debido a nuestro diseño o la búsqueda de eficiencia.
Datos final
En los datos se pueden tener constantes de tiempo de compilación (valor que definimos de antemano y nunca va a cambiar) y de tiempo de ejecución (valor calculado). Estos tipos de constantes deben ser de tipos primitivos que se definen con la palabra final al momento de definirlos, hacerlo implica indicar su valor. Si se antepone la palabra static a final lo que sucedería es que el valor constante existirá en un único espacio de almacenamiento que no se podrá cambiar.
Usar final en referencias a objetos hace que sean constantes las referencias no los objetos. No se podrá hacer que la referencia apunte a otro objeto, pero el objeto si podrá modificarse.Lo mismo sucede con las matrices pues también son objetos.
Un ejemplo que nos propone Bruce Eckel es el siguiente, donde se describe el comportamiento de los elementos de datos de una clase utilizando final y static:
Espero pronto agregar otros temas que vaya viendo, ¡hasta pronto!
//: reusing/FinalData.java
//Efecto de final sobre los campos.
import java.util.*;
import static access.net.mindview.util.Print.*;
class Value {
int i; // Acceso de paquete
public Value(int i) { this.i = i; }
}
public class FinalData {
private static Random rand = new Random(47);
private String id;
public FinalData(String id) { this.id = id; }
// Pueden ser constantes de compilación:
private final int valueOne = 9;
private static final int VALUE_TWO = 99;
// Constante pública típica:
public static final int VALUE_THREE = 39;
// No pueden ser constantes de tiempo de compilación:
private final int i4 = rand.nextInt(20);
static final int INT_5 = rand.nextInt(20);
private Value v1 = new Value(11);
private final Value v2 = new Value(22);
private static final Value VAL_3 = new Value(33);
// Matrices:
private final int[] a = { 1, 2, 3, 4, 5, 6 };
public String toString() {
return id + ": " + "i4 = " + i4 + ", INT_5 = " + INT_5 + " a[0] = " + a[0] ;
}
public static void main(String[] args) {
FinalData fd1 = new FinalData("fd1");
//! fd1.valueOne++; //Error: no se puede modificar el valor
fd1.v2.i++; // EL objeto no es constante
fd1.v1 = new Value(9); // Ok -- no es final
for(int i = 0; i < fd1.a.length; i++)
fd1.a[i]++; // ¡El objeto no es constante!
//! fd1.v2 = new Value(0); // Error: no se puede cambiar la referencia
//! fd1.VAL_3 = new Value(1);
//! fd1.a = new int[3];
print(fd1);
print("Creating new FinalData");
FinalData fd2 = new FinalData("fd2");
print(fd1);
print(fd2);
}
}
Aprendiendo a programar en Java
¡Hola! llevo tiempo tratando de aprender a programar sobre el lenguaje de programación Java y pues sinceramente hasta ahora no lo he conseguido como lo deseo. He tratado de desarrollar un proyecto sobre este lenguaje, que creo ya mencione (sino después lo daré a conocer), pero por ahora no quiero decir porqué no lo he conseguido. Lo que ahora quiero decirles es que pretendo ir posteando algunos ejemplos sobre los temas que vaya estudiando y/o aprendiendo y con la ayuda de alguna personita ¿porque no? enriquecerlo de los que sepan más del tema que deseen aportar.
Conocí a Java, en la universidad, tocamos algo de Java, una pequeña introducción, después he hido aprendiendo otros temas por mi cuenta. Hasta ahora sólo sé temas básicos como: Operadores, Control de Flujo, Matrices y ultimamente he estado estudiando sobre el tema de la Inicialización de Objetos y de tipos primitivos. Conocer un poco de POO (Programación Orientada a Objetos) y algo de Java me ayudo a cursar la materia de POO en la maestria en la que ahora estoy, sin tantos problemas.
He decidio crear una serie de post que serán parte de éste, que los iré añadiendolos conforme los vaya aprendiendo. El orden de los temas de los que tratare, es de acuerdo a la organización de los capitulos y subtemas del libro que tengo (Piensa en Java, de Bruce Eckel, 4ta edición), empezaré en el capitulo 3 ya que ahi se inicia la enseñanza de la sintaxís del lenguaje (los primeros capitulos es una introducción a la POO). Espero lograr mi objetivo y tener esta información, como una referencia de todo lo que me encuentre en el camino de mi aprendizaje de este lenguaje, ¡haya vamos!.
- 3 Operadores
- 4 Control de ejecución
- 5 Inicialización y limpieza
- 6 Control de acceso
- 7 Polimorfismo
- 9 Interfaces
- 10 Clases Internas
- 11 Almacenamiento de objetos
- 12 Tratamiento de errores mediante excepciones
- 13 Cadenas de caracteres
- 14 Información de tipos
- 15 Genéricos
- 16 Matrices
- 17 Análisis detallado de los contenedores
- 18 Entrada/Salida
- 19 Tipos enumerados
- 20 Anotaciones
- 21 Concurrencia
- 22 Interfaces gráficas de usuario
Observando la lista puedo decir que es una manera de ver mis avences. Espero que alguien más le sirva 
¡Saludos! nos leemos pronto…
Actualización (25/Enero/10):
- Todo es un objeto
Olvide colocar este capítulo, que es de suma importancia, que nos introduce temas básicos para construir nuestras aplicaciones.
Métodos Matemáticos
La maestría inicio con la materia Métodos Matemáticos que por nombre lleva esta entrada, el profesor responsable de la misma es Ildeberto de los Santos Ruiz. Mi primera clase fue el domingo pasado. Desgraciadamente llegue tarde, fuimos con mi amigo Carlos los últimos en entrar (y también después del receso), pero no nos perdimos de mucho, los temas que vimos ese dia del curso fueron los siguientes:
- Regla del producto
- Regla de la suma
- Permutaciones
- Factorial de un entero no negativo
- Permutaciones con objetos iguales
- Permutaciones parciales
- Variaciones con repetición
- Combinaciones
- Coeficientes binomiales
- Triangulo de Pascal
- Subconjuntos de un conjunto
- Combinaciones con repetición
Este es el documento de donde se pueden ver una descripción de cada tema Combinatoria, ahora estoy revisando unas copias que tengo desde la universidad que no recuerdo de que autor es, pero creo que se titulo Matemáticas Discretas. Tengo la intención de postear en que consiste cada tema, algunos ejemplos y ejercicios. Todo esto con el objetivo de autoobligarme a estudiar, aprender y tener unos apuntes para donde estudiar. Eso es lo que muchos hacen y dicen que es bueno.
Por cierto la pagina oficial de la materia es: http://posgradomm.googlepages.com
Por ahora no me ha parecido difícil comprender estos temas, basta con unas lecturas de que trata cada tema, checar los ejemplos y resolver los ejercicios. Pasado será mi segunda clase, espero me vaya bien. bueno es todo por ahora. Nos vemos luego.
¡Saludos!
PD: Desgraciadamente no pude insertar una imagen para hacer más ilustrativo este post, pero bueno ya será después.
Esta obra está bajo una licencia de Creative Commons
Comentarios recientes