Factoriales y Números de Fibonacci en java.

El siguiente programa en java recibe un número entero positivo. Si el número es par, se imprime el factorial, de lo contrario se imprime el número de fibonacci correspondiente a dicho entero. En los comentarios se esbozan los algoritmos.
Éste archivo debe guardarse con el nombre Main.

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
* Programa que recibe un entero positivo y verifica si es par +
* o impar                                                     *
* Si es par                                                   *
*   Se calcula e imprime el factorial del numero              *
* Si es impar                                                 *
*   Se calcula e imprime los primeros n numeros de fibonacci  *
*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

import java.util.Scanner;

public class Main
{  // Abre clase Main
public static void main(String args[])
{  // Abre main

int n = 0; // Esta variable almacenara el numero
Scanner entrada = new Scanner(System.in);

while ( 0 >= n )
 // con este condicional while se garantiza que el usuario introduzca numeros positivos.
{  // Abre while
System.out.print("\nPor favor introduzca un numero entero. Si el numero es par ");
System.out.print("se imprimira el factorial, de lo contrario, se imprimiran los primeros n terminos ");
System.out.println("de la serie de Fibonacci. "); 
n = entrada.nextInt();

}  // Cierra while

if ( 0 == n%2 )  // Si el numero es par
System.out.printf("\nEl factorial del numero es: %d\n\n", factorial(n));
else  // Si el numero es impar
fibonacci(n);

}  // Cierra main

///////////////////////////////
//Metodo fibonacci
//////////////////////////////

/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *                                                                             *
 *                              ALGORITMO                                      *
 *                              _________                                      *
 *                                                                             *
 * El primer numero de fibonacci (fib1) es 0                                   *
 * El segundo numero de Fibonacci (fib2) es 1                                  *
 *                                                                             *
 * Si el usuario introduce 1 o 2, entonces es necesario desplegar f1 o f2      *
 * Si el usuario introduce un entero positivo mayor que 2, entonces            *
 *     desde 2 hasta n (el numero introducido)                                 *
 *     fibn = fib1 + fib2                                                      *
 *     temp =  fib2                                                            *
 *     fib2 = fibn                                                             *
 *     fib1 = temp                                                             *
 *                                                                             *
 * Imprimir el valor de fibn                                                   * 
 *+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++*/

public static void fibonacci( int x)
{  // Abre Metodo fibonacci

int fib1 = 0;
int fib2 = 1;
int fibn;

if (1 != x)
{  // Abre if
System.out.printf("\nEl primer numero de Fibonacci es: %d", fib1);
System.out.printf("\nEl segundo numero de Fibonacci es: %d", fib2);

for ( int i = 3; i <= x; i++ )
{  // Abre for
fibn = fib2 + fib1;
fib1 = fib2;
fib2 = fibn;

System.out.printf("\nEl numero de Fibonacci %d es %d", i, fibn);

}  // Cierra for  
System.out.println();
}  // Cierra if
else
System.out.println("\nEl primer numero de Fibonacci es: 0");


}  // Cierra Metodo fibonacci


/////////////////////////////////////////////////////
//Metodo factorial
/////////////////////////////////////////////////////

/*++++++++++++++++++++++++++++++++++++++++++++++++++*
*                                                   *
* fact = 1;                                         *
* Desde i = 1 hasta i = n                           *
*    fact = fact * i;                               *
*    i  =  i + 1;                                   *
*+++++++++++++++++++++++++++++++++++++++++++++++++++*/

public static int factorial( int n)
{  // Abre metodo factorial
int i; // La variable i servira como contador
int fact = 1; // Esta variable almacena el factorial

for ( i = 1; i <= n; i++ )
fact *= i;

return fact; // El valor de retorno es el factorial
}  // Cierra metodo factorial

}  // Cierra clase Main

Abajo aparece un par de ejecuciones del programa, una con un número par y otra con un número impar.

[hernandez@localhost Programas]$ java Main

Por favor introduzca un numero entero. Si el numero es par, se imprimira el factorial, de lo contrario, se imprimiran los primeros n terminos de la serie de Fibonacci. 
4

El factorial del numero es: 24

[hernandez@localhost Programas]$ java Main

Por favor introduzca un numero entero. Si el numero es par se imprimira el factorial, de lo contrario, se imprimiran los primeros n terminos de la serie de Fibonacci. 
7

El primer numero de Fibonacci es: 0
El segundo numero de Fibonacci es: 1
El numero de Fibonacci 3 es 1
El numero de Fibonacci 4 es 2
El numero de Fibonacci 5 es 3
El numero de Fibonacci 6 es 5
El numero de Fibonacci 7 es 8

El Operador ~ de bits

El operador ~ de bits, también llamado operador de complemento a uno, actúa sobre tipos enteros (char, int, shor, long) a nivel de bits. Lo que hace es cambiar 0 por 1 y viceversa. Por ejemplo, si se tiene el la constante int x = 47 en una representación binaria de 6 bits, 101111, la instrucción ~x da como resultado el número 010000. Hay que tener cuidado antes de apresurarnos a decir cual será el resultado aplicando éste operador en un programa en C. El punto importante aquí es que si nosotros imprimimos el valor actual de x, mediante una instrucción printf, obtendremos -48.

La acción del operador complemento a uno

Sea el siguiente programa

/*+++++++++++++++++++++++++++++++++++++++++++++
 * Este programa cambia un numero sin sigo a  +
 * su complemento a uno a nivel de bits       +
 * ++++++++++++++++++++++++++++++++++++++++++*/

#include 

int main()
{  /* Abre main*/
unsigned contador;
unsigned x;
unsigned temporal;

printf("\nIntroduzca un número: ");
scanf("%d", &x);

temporal = ~x;

printf("\nEl complemento a uno de %d es: %d\n", x, temporal);

printf("\nEl valor final de x: %d\n", x);

return 0;
}  /* Cierra main*/

Una ejecución con 47 como entrada es la siguiente:

Introduzca un número: 47

El complemento a uno de 47 es: -48

El valor final de x: 47

Si las computadoras representaran los enteros con signo mediante el complemento a 1, el número al aplicar ~x sería -47, sin embargo, las computadoras almacenan los enteros con signo mediante la representación en complemento a dos. En ésta entrada hay más información al respecto.

El operador & de bits

El operador &, llamado AND de bits, compara dos números de tipo entero (int, short, long, char) bit por bit, dando por resultado un tercer número, que se forma al colocar un 0 ó 1 en el bit correspondiente a la comparación realizada de acuerdo con la siguiente regla: si los dos bits son iguales a 1, entonces se obtiene 1, de otra forma se obtiene un 0. Sean, por ejemplo, los números 19 y 25, que en representación binaria de 5 bits se escriben 19 = 1 0 0 1 1, 25 = 1 1 0 0 1. Si se realiza la comparación, se verá que los bits de la derecha son los dos iguales a 1, por lo tanto el número resultante tendrá un 1 en el bit de la extrema derecha. De manera similar, el segundo bit de 19 tiene un 1, en tanto que el de 25 tiene un 0, el resultado, por lo tanto, es 0. La comparación completa aparece en la figura de abajo.

El operador lógico & de bits.

El operador & también es utilizado para hacer referencia a una localidad de memoria,por ejemplo en la función scanf. Los usuarios de C++, que utilizan un lenguaje orientado a objetos, le llamarían a ésto una sobrecarga: el mismo operador se utiliza en situaciones distintas para realizar distintas tareas. La razón por la cual & no puede operar sobre tipos flotantes es porque la representación de números enteros es distinta a la de los tipos float. El programa que aparece abajo hace uso de el operador de bits &.

/*+++++++++++++++++++++++++++++++++++++++*
*Este programa recibe un par de numeros  *
*e imprime el resultado de aplicarles el *
*operador binario &                      *
*+++++++++++++++++++++++++++++++++++++++*/

#include 

int main()
{   /*Abre main*/
 int x; 
 int y;
 
 printf("\nEste programa hace uso del operador binario &\n");
 printf("\nIntroduzca un entero: ");
 scanf("%d", &x);
 printf("\nIntroduzca un segundo entero: ");
 scanf("%d", &y);

 printf("\n%d & %d = %d\n", x, y, x&y);

 return 0;
}   /*Cierra main*/

Una ejecución del programa, co los números 19 y 25 es:

Este programa hace uso del operador binario &                                        
                                                                                     
Introduzca un entero: 19                                                             
                                                                                     
Introduzca un segundo entero: 25                                                     
                                                                                     
19 & 25 = 17  

En ocasiones es conveniente fijar una constante entera mediante un número binario, por ejemplo para crear una máscara de bits. La forma de hacer ésto en C es escribiendo la constante en sistema de numeración octal o en hexadecimal. Toda constante que es precedida por un 0, como 0177, es tomada como una cantidad octal (127 en éste caso); en tanto que las cantidades precedidas de 0x ó 0X, como 0x7F (también igual al 127 decimal) son cantidades hexadecimales. En particular el número 0x7F se representa, en notación binaria, como 01111111 por lo cual, una instrucción como x & 0x7F, hará 0 todos los bits de x, salvo los primeros 7 de la derecha.