Deitel_Java_6.36 (Distancia entre dos puntos en Java)

6.36 Escriba un método llamado distancia, para calcular la distancia entre dos puntos (x1, y1) y (x2, y2). Todos los números y valores de retorno deberán ser de tipo double. Incorpore este método en un a aplicación que permita al usuario introducir las coordenadas de los puntos.

Este código debe guardarse con el nombre UsaDeitel_6_36.java

 public class UsaDeitel_6_36

 {     // Abre clas UsaDeitel_6_36
 
 public static void main(String args[])
 {      // Abre main

 Deitel_6_36 miObjeto = new Deitel_6_36();
 
 miObjeto.Recibe(); 

 }      // Cierra main 
 }     // Cierra clase UsaDeitel_6_36

Este código debe guardarse con el nombre Deitel_6_36.java

 
 import java.util.Scanner;


 public class Deitel_6_36

 {    // Abre clase Deitel_6_36
 
 public void Recibe( )
 {   // Abre metodo Recibe
 double x1;
 double y1;
 double x2;
 double y2;
 double distancia;

 Scanner entrada = new Scanner(System.in);
  
 System.out.println("\nPor favor introduzca la coordenada x del primer punto: ");
 x1 = entrada.nextDouble();
   
 System.out.println("\nPor favor introduzca la coordenada y del primer punto: ");
 y1 = entrada.nextDouble();
  
 System.out.println("\nPor favor introduzca la coordenada x del segundo punto: ");
 x2 = entrada.nextDouble();
  
 System.out.println("\nPor favor introduzca la coordenada y del segundo punto: ");
 y2 = entrada.nextDouble();

 distancia = Math.sqrt( (x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1) );

 System.out.printf("\nLa distancia entre los puntos es: %.2f\n", distancia);
     
    
 }       // Cierra metodo Recibe


 }    // Cierra clase Deitel_6_36

Kernighan_Ritchie_2.3 (Convertir de Hexadecimal a Decimal en C)

___________________________________________________________________________________
2.3 Escriba la función htoi(s), que convierte una cadena de dígitos hexadecimales (incluyendo 0x ó 0X en forma optativa) en su valor entero equivalente. Los dígitos permitidos son del 0 al 9, de la a a la f, y de la A a la F.
___________________________________________________________________________________
Solución: Este programa convierte de hexadecimal a decimal. El programa está bien comentado y creo que es fácil de seguir y entender. Es posible realizar éste problema de otras maneras, ésta es una de ellas. El usuario puede introducir los numeros 0, 1, ....9 y las literales A, a, B, b,.....F, f. El uso de minúsculas hace el programa más largo. Cualquier otro dígito envía un mensaje de error. Tal vez le convenga leer la entrada Los números hexadecimales. Una tabla de equivalencias entre números binarios, octales, decimales y hexadecimales, aparece en Ésta página.

/*Este programa convierte de hexadecimal
   a decimal */

 #include <stdio.h>

 #define Tamano 35
 // La variable Tamano se fija en 35
 // porque los enteros de dos bytes
 // ocupan 32 bits y la ultima entrada
 // de una cadena en un arreglo es \n

 /*Prototipo de funcion Recibe*/
 /* Esta funcion recibe la cadena
    pero no verifica que sea valida */

 void Recibe( int a[]);

 /*Prototipo de funcion Imprime*/
 /* Si la cadena es valida se calcula
 e imprime su equivalente decimal, si no
 se manda un mensaje al usuario y se termina
 el programa */

 void Imprime( int b[]);

 /*///////////////////////////////
 // MAIN
 ////////////////////////////////*/ 

 int main()

 {       // Abre main 

 int arreglo[Tamano];
 // En este arreglo se recibiran los valores
 // de la cadena hexadecimal
 int evaluar;
 // La variable evaluar lleva el control
 // de la legalidad de la cadena, es decir
 // se introducen digitos validos como e, 1
 // o se introducen valores invalidos como
 // s, z

 // Un  mensaje que avisa al usuario que
 // hace el programa
 printf("\nEste programa recibe un numero "     
        "hexadecimal y lo convierte a decimal.\n");

 // Se invoca a la funcion Recibe y se le envia
 // la direccion de la primera posicion de arreglo

 Recibe(arreglo);

 // Se calcula e imprime el valor decimal, de 
 // nuevo por referencia 

 Imprime(arreglo);

 return 0;

 }       // Cierra main

 /*////////////////////////////////////
 // FUNCION RECIBE
 ////////////////////////////////////*/

 void Recibe( int a[])

 {  // Abre Recibe 

 /* En el arreglo a se guardaran las 
   entradas de la cadena*/

 int i = 0;
 /* La variable i sirve como contador
    en varios ciclos */

 for( i = 0; i < Tamano; i++ )
 a[i] = ' ';
 // Las entradas se inicializan a ' ' 

 printf("\nIntroduzca un numero hexadecimal: \n");
 /*El siguiente while recibe la cadena y la
   asigna al arreglo en una sola linea.
   Observe que al final hay un ;  */

 i = 0;
 // Se pone i = 0

 while ( (a[i++] = getchar()) != '\n' && Tamano > i );
 printf("\n");

 }  // Cierra Recibe 

 /*/////////////////////////////////////
 // FUNCION IMPRIME
 /////////////////////////////////////*/

 void Imprime( int b[] )

 {  // Abre Imprime

 int i;
 int potencia = 1;
 // La variable potencia lleva el valor de la
 // potencia de 16 por la cual se va a multiplicar
 // el digito almacenado dependiendo de su posicion
 int decimal = 0;
 // El equivalente decimal de la cadena hexadecimal
 // se inicia a 0
 int inicio;
 // La variable inicio se encarga de registrar
 // en donde empieza el primer digito de la cadena.
 // Esta cadena debe leerse de izquierda a derecha.

 // Este ciclo for busca de atras para 
 // adelante el primer digito distinto
 // de ' ' en el arreglo. A partir de
 // ahi se empieza a evaluar el numero
 // hexadecimal

 for ( i = Tamano - 1; i >= 0; i-- )

 {  // Abre for
 if ( ' ' != b[i] )
 {  // abre if  
 inicio = i;
 break; // sale de for
 }   // Cierra if
 }  // Cierra for

 // Este ciclo for evalua cada una de las
 // entradas del arreglo que fueron introducidas 
 // por el usuario, las multiplica por la potencia 
 // de 16 correspondiente a su posicion y los
 // productos los va sumando. La suma total sera
 // el valor decimal del numero. 

 int valido = 1;
 // Si el hexadecimal recibido no es valido, no 
 // se puede calcular su valor decimal. Esta 
 // variable controla eso. En principio se establece
 // en 1 o cierto, ya que se asume que el usuario 
 // introdujo un numero valido

  for ( i = inicio; i >= 0; i-- )
 {  // Abre for
 switch( b[i] )
 {  // Abre switch
 case '0':
 decimal += 0*potencia;
 potencia *= 16;
 break;
 case '1':
 decimal += 1*potencia;
 potencia *= 16;
 break;
 case '2':
 decimal += 2*potencia;
 potencia *= 16;
 break;
 case '3':
 decimal += 3*potencia;
 potencia *= 16;
 break;
 case '4':
 decimal += 4*potencia;
 potencia *= 16;
 break;
 case '5':
 decimal += 5*potencia;
 potencia *= 16;
 break;
 case '6':
 decimal += 6*potencia;
 potencia *= 16;
 break;
 case '7':
 decimal += 7*potencia;
 potencia *= 16;
 break;
 case '8':
 decimal += 8*potencia;
 potencia *= 16;
 break;
 case '9':
 decimal += 9*potencia;
 potencia *= 16;
 break;
 case 'A':
 decimal +=  10*potencia;
 potencia *= 16;
 break;
 case 'a':
 decimal +=  10*potencia;
 potencia *= 16;
 break;
 case 'B':
 decimal +=  11*potencia;
 potencia *= 16;
 break;
 case 'b':
 decimal +=  11*potencia;
 potencia *= 16;
 break;
 case 'C':
 decimal +=  12*potencia;
 potencia *= 16;
 break;
 case 'c':
 decimal +=  12*potencia;
 potencia *= 16;
 break;
 case 'D':
 decimal +=  13*potencia;
 potencia *= 16;
 break;
 case 'd':
 decimal +=  13*potencia;
 potencia *= 16;
 break;
 case 'E':
 decimal +=  14*potencia;
 potencia *= 16;
 break;
 case 'e':
 decimal +=  14*potencia;
 potencia *= 16;
 break;
 case 'F':
 decimal +=  15*potencia;
 potencia *= 16;
 break;
 case 'f':
 decimal +=  15*potencia;
 potencia *= 16;
 break;
 default:
 if ( '\n' != b[i])
 {  // Abre if
 printf("\nERROR. LA CADENA NO ES VALIDA!\n");
 valido = 0;  // El hexadecimal recibido no 
              // es valido
 printf("\nEste caracter no es valido: ");
 putchar(b[i]);
 printf("\n");
 } // Cierra if
 break;
 }   // Cierra switch
 }  // Cierra for  

 if ( 1 == valido )
 printf("\nEl valor decimal es: %d\n", decimal);
 else
 printf("\nEl numero introducido no es valido.\n");

 }  // Cierra Imprime

__________________________________________________________________________________________
Esta entrada es parte de los problemas resueltos del libro El Lenguaje de Programación C de B. Kernighan y D. Ritchie
Entrada Anterior
Entrada Siguiente

__________________________________________________________________________________________

Convertir de Octal a Decimal en C

Este programa recibe un número en notación octal y lo convierte e imprime en binario. Está bien comentado y creo que es fácil de entender. Primero se solicita la entrada del número, se recibe en un arreglo y luego se analiza en orden inverso. El hecho de que los números incrementen su valor de derecha a izquierda y que se escriban de izquierda a derecha en el teclado complica un poco las cosas. Sin embargo el algoritmo es sencillo.

/*Este programa convierte de octal 
  a decimal */

 #include <stdio.h>
 #define Tamano 35
 // La variable Tamano se fija en 35
 // porque los enteros de cuatro bytes
 // ocupan 32 bits y la ultima entrada
 // de una cadena en un arreglo es \n
 
 /*Prototipo de funcion Recibe*/
 /* Esta funcion recibe la cadena
    pero no verifica que sea valida */
 void Recibe( int a[]);

 /*Prototipo de funcion Imprime*/
 /* Si la cadena es valida se calcula
 e imprime su equivalente decimal, si no
 se manda un mensaje al usuario y se termina
 el programa */

 void Imprime( int b[]);

 /*///////////////////////////////
 // MAIN
 ////////////////////////////////*/  

 int main()

 {       // Abre main 
 int arreglo[Tamano];
 // En este arreglo se recibiran los valores
 // de la cadena octal 
 int evaluar; 
 // La variable evaluar lleva el control
 // de la legalidad de la cadena, es decir
 // se introducen digitos validos como 2, 1
 // o se introducen valores invalidos como
 // 9, e, h, etcetera
 
 // Un  mensaje que avisa al usuario que
 // hace el programa
 printf("\nEste programa recibe un numero "
         "octal y lo convierte a decimal.\n");

 // Se invoca a la funcion Recibe y se le envia
 // la direccion de la primera posicion de arreglo
 
 Recibe(arreglo);

 // Se calcula e imprime el valor decimal, de 
 // nuevo por referencia 

 Imprime(arreglo);

 return 0; 

 }       // Cierra main

 /*////////////////////////////////////
 // FUNCION RECIBE
 ////////////////////////////////////*/

 void Recibe( int a[])

 {  // Abre Recibe 

 /* En el arreglo a se guardaran las 
   entradas de la cadena*/

 int i = 0;
 /* La variable i sirve como contador
    en varios ciclos */

 for( i = 0; i < Tamano; i++ )
 a[i] = ' '; 
 // Las entradas se inicializan a ' ' 

 printf("\nIntroduzca un numero octal: \n");

 /*El siguiente while recibe la cadena y la
   asigna al arreglo en una sola linea.
   Observe que al final hay un ;  */ 

 i = 0;
 // Se pone i = 0
 while ( (a[i++] = getchar()) != '\n' && Tamano > i );
 printf("\n");
 }  // Cierra Recibe 

 /*/////////////////////////////////////
 // FUNCION IMPRIME
 /////////////////////////////////////*/

 void Imprime( int b[] )

 {  // Abre Imprime
 int i;
 int potencia = 1;
 // La variable potencia lleva el valor de la
 // potencia de 8 por la cual se va a multiplicar
 // el digito almacenado dependiendo de su posicion

 int decimal = 0;
 // El equivalente decimal de la cadena octal 
 // se inicia a 0

 int inicio;
 // La variable inicio se encarga de registrar
 // en donde empieza el primer digito de la cadena.
 // Esta cadena debe leerse de izquierda a derecha.
 // Este ciclo for busca de atras para 
 // adelante el primer digito distinto
 // de ' ' en el arreglo. A partir de
 // ahi se empieza a evaluar el numero
 // octal 

 for ( i = Tamano - 1; i >= 0; i-- )
 {  // Abre for
 if ( ' ' != b[i] )
 {  // abre if  
 inicio = i; 
 break; // sale de for
 }   // Cierra if
 }  // Cierra for

 // Este ciclo for evalua cada una de las
 // entradas del arreglo que fueron introducidas 
 // por el usuario, las multiplica por la potencia 
 // de 8 correspondiente a su posicion y los
 // productos los va sumando. La suma total sera
 // el valor decimal del numero. 

 int valido = 1;

 // Si el octal recibido no es valido, no 
 // se puede calcular su valor decimal. Esta 
 // variable controla eso. En principio se establece
 // en 1 o cierto, ya que se asume que el usuario 
 // introdujo un numero valido

  for ( i = inicio; i >= 0; i-- )
 {  // Abre for

 switch( b[i] )

 {  // Abre switch
 case '0':
 decimal += 0*potencia; 
 potencia *= 8;
 break;
 case '1':
 decimal += 1*potencia; 
 potencia *= 8;

 break;
 case '2':
 decimal += 2*potencia; 
 potencia *= 8;
 break;
 case '3':
 decimal += 3*potencia; 
 potencia *= 8;
 break;
 case '4':
 decimal += 4*potencia; 
 potencia *= 8;
 break;
 case '5':
 decimal += 5*potencia; 
 potencia *= 8;
 break;
 case '6':
 decimal += 6*potencia; 
 potencia *= 8;
 break;
 case '7':
 decimal += 7*potencia; 
 potencia *= 8;
 break;
 default:
 if ( '\n' != b[i])
 {  // Abre if
 printf("\nERROR. LA CADENA NO ES VALIDA!\n");
 valido = 0;  // El octal recibido no 
              // es valido
 printf("\nEste caracter no es valido: ");
 putchar(b[i]);
 printf("\n");
 } // Cierra if
 break;

 }   // Cierra switch
 }  // Cierra for  

 if ( 1 == valido )
 printf("\nEl valor decimal es: %d\n", decimal);
 else
 printf("\nEl numero introducido no es valido.\n");
 }  // Cierra Imprime

Convertir de Binario a Decimal en C

Este programa convierte numeros binarios a decimales. Es, creo, completo y fácil de usar y de entender. Es de alguna manera el complemento a el programa anterior que convierte un decimal a binario.

 /*Este programa convierte de binario 
   a decimal */

 #include <stdio.h>
 #define Tamano 35

 // La variable Tamano se fija en 35
 // porque los enteros de cuatro bytes
 // ocupan 32 bits y la ultima entrada
 // de una cadena en un arreglo es \n
 /*Prototipo de funcion Recibe*/
 /* Esta funcion recibe la cadena
    pero no verifica que sea valida */

 void Recibe( int a[]);

 /*Prototipo de funcion Imprime*/
 /* Si la cadena es valida se calcula
 e imprime su equivalente decimal, si no
 se manda un mensaje al usuario y se termina
 el programa */

 void Imprime( int b[]);

 /*///////////////////////////////
 // MAIN
 ////////////////////////////////*/ 

 int main()
 {       // Abre main 
 int arreglo[Tamano];
 // En este arreglo se recibiran los valores
 // de la cadena binaria 
 int evaluar;
 // La variable evaluar lleva el control
 // de la legalidad de la cadena, es decir
 // se introducen los unicos digitos validos 0, 1
 // o se introducen valores invalidos como
 // 9

 // Un  mensaje que avisa al usuario que
 // hace el programa
 printf("\nEste programa recibe un numero "
         "binario y lo convierte a decimal.\n");

 // Se invoca a la funcion Recibe y se le envia
 // la direccion de la primera posicion de arreglo
 Recibe(arreglo);
 // Se calcula e imprime el valor decimal, de 
 // nuevo por referencia 
 Imprime(arreglo);
 return 0;

 }       // Cierra main

 /*////////////////////////////////////
 // FUNCION RECIBE
 ////////////////////////////////////*/

 void Recibe( int a[])
 {  // Abre Recibe 
 /* En el arreglo a se guardaran las 
   entradas de la cadena*/
 int i = 0;
 /* La variable i sirve como contador
    en varios ciclos */
 for( i = 0; i < Tamano; i++ )
 a[i] = ' ';
 // Las entradas se inicializan a ' ' 
 printf("\nIntroduzca un numero binario: \n");

 /*El siguiente while recibe la cadena y la
   asigna al arreglo en una sola linea.
   Observe que al final hay un ;  */

 i = 0;
 // Se pone i = 0
 while ( (a[i++] = getchar()) != '\n' && Tamano > i );
 printf("\n");
 }  // Cierra Recibe 

 /*/////////////////////////////////////
 // FUNCION IMPRIME
 /////////////////////////////////////*/

 void Imprime( int b[] )

 {  // Abre Imprime

 int i;
 int potencia = 1;
 // La variable potencia lleva el valor de la
 // potencia de 2 por la cual se va a multiplicar
 // el digito almacenado dependiendo de su posicion

 int decimal = 0;
 // El equivalente decimal de la cadena binaria 
 // se inicia a 0
 int inicio;
 // La variable inicio se encarga de registrar
 // en donde empieza el primer digito de la cadena.
 // Esta cadena debe leerse de izquierda a derecha.

 // Este ciclo for busca de atras para 
 // adelante el primer digito distinto
 // de ' ' en el arreglo. A partir de
 // ahi se empieza a evaluar el numero
 // binario 

 for ( i = Tamano - 1; i >= 0; i-- )
 {  // Abre for
 if ( ' ' != b[i] )
 {  // abre if  
 inicio = i;
 break; // sale de for
 }   // Cierra if
 }  // Cierra for

 // Este ciclo for evalua cada una de las
 // entradas del arreglo que fueron introducidas 
 // por el usuario, las multiplica por la potencia 
 // de 2 correspondiente a su posicion y los
 // productos los va sumando. La suma total sera
 // el valor decimal del numero. 

 int valido = 1;
 // Si el binario recibido no es valido, no 
 // se puede calcular su valor decimal. Esta 
 // variable controla eso. En principio se establece
 // en 1 o cierto, ya que se asume que el usuario 
 // introdujo un numero valido

  for ( i = inicio; i >= 0; i-- )
 {  // Abre for
 switch( b[i] )
 {  // Abre switch
 case '0':
 decimal += 0*potencia;
 potencia *= 2;
 break;
 case '1':
 decimal += 1*potencia;
 potencia *= 2;
 break;
 default:
 if ( '\n' != b[i])
 {  // Abre if
 printf("\nERROR. LA CADENA NO ES VALIDA!\n");
 valido = 0;  // El binario recibido no 
              // es valido
 printf("\nEste caracter no es valido: ");
 putchar(b[i]);
 printf("\n");
 } // Cierra if
 break;
 }   // Cierra switch
 }  // Cierra for  

 if ( 1 == valido )
 printf("\nEl valor decimal es: %d\n", decimal);
 else
 printf("\nEl numero introducido no es valido.\n");

 }  // Cierra Imprime

Deitel_Java_6.38 (De Decimal a Binario, Octal y Hexadecimal en Java)

Este programa recibe decimales y los imprime en binario, octal y hexadecimal.

El siguiente código debe guardarse con el nombre UsaConvertir.java

import java.util.Scanner;

 public class UsaConvertir

 {   // Abre clase UsaConvertir

 public static void main( String args[])

 {    // Abre main

 System.out.print("\nEste programa convierte decimales a ");
 System.out.print("binario, octal y hexadecimal.\n");
 Scanner entrada = new Scanner(System.in);

 Convertir miObjeto = new Convertir();

 int numero;

 System.out.print("\nPor favor introduzca un numero ");
 System.out.println("y se imprimira su equivalente en binario: ");

 numero = entrada.nextInt();

 miObjeto.Binario( numero );

 System.out.print("\nPor favor introduzca un numero ");
 System.out.println("y se imprimira su equivalente en octal: ");

 numero = entrada.nextInt();

 miObjeto.Octal( numero );

 System.out.print("\nPor favor introduzca un numero ");
 System.out.println("y se imprimira su equivalente en hexadecimal: ");

 numero = entrada.nextInt();

 miObjeto.Hexadecimal( numero );

 }    // Cierra main

 }   // Cierra clase UsaConvertir

El siguiente código debe guardarse con el nombre Convertir.java

 public class Convertir

 {    // Abre clase Convertir

 // La variable Tamano controla el numero de 
 // simbolos que se requieren para hacer la conversion
 // Para llevar un registro de los simbolos se usa un
 // arreglo. Estos se deben guardar porque se van generando
 // de derecha a izquierda, pero la impresion es de 
 // izquierda a derecha.

 private int Tamano = 20;
 private int[] a = new int[Tamano];

 /////////////////////////////////////
 // METDODO BINARIO 
 /////////////////////////////////////

 public void Binario( int x )

 {     // Abre metodo Binario 

 System.out.println("\nAqui esta el numero en notacion binaria: ");

 // Se llena el arreglo con ceros

 for ( int i = 0; i < Tamano; i++ )
 {  // Abre for
 a[i] = 0;
 }  // Cierra for

 int j = 0;

 while ( 0 != x )
 {   // Abre while

 if ( 0 != x % 2 )
 {   // Abre if
 a[j++] = x % 2;

 // Se resta el residuo
 x -= x % 2;

 // Se divide entre 2
 x /= 2;

 }   // Cierra if

 else

 {     // Abre else
 a[j++] = 0;

 // Se cambia x
 x /= 2;

 }     // Cierra else

 }   // Cierra while

 // El numero en binario, que se ha guardado
 // en el arreglo, se manda a imprimir

 Imprimir();

 }     // Cierra metodo Binario 



 /////////////////////////////////////
 // METDODO OCTAL
 /////////////////////////////////////

 public void Octal( int x )

 {     // Abre metodo Octal
 System.out.println("\nAqui esta el numero en notacion octal: ");

 // Las entradas del arreglo se llenan con 0

 for ( int i = 0; i < Tamano; i++ )
 {  // Abre for

 a[i] = 0;

 }  // Cierra for

 int j = 0;

 while ( 0 != x )

 {   // Abre while

 if ( 0 != x % 8 )

 {   // Abre if

 a[j++] = x % 8;
 // Se resta el residuo
 x -= x % 8;
 // Se divide entre 8
 x /= 8;

 }   // Cierra if

 else

 {     // Abre else

 a[j++] = 0;
 // Se cambia x
 x /= 8;

 }     // Cierra else

 }   // Cierra while

 // El numero en octal, que se ha guardado
 // al reves en el arreglo a, se manda a 
 // imprimir

 Imprimir();

 }     // Cierra metodo Octal 



 /////////////////////////////
 // METODO HEXADECIMAL
 /////////////////////////////



 public void Hexadecimal ( int x )

 {     // Abre metodo Hexadecimal

 // El arreglo se llena con 0 

 for ( int i = 0; i < Tamano; i++ )
 {  // Abre for

 a[i] = 0;

 }  // Cierra for

 System.out.print("\nAqui esta el numero en notacion ");
 System.out.println("hexadecimal: ");

 int contador = 0;

 while ( 0 != x )

 {       // Abre while

 // Si el  numero no es multiplo de 16
 // lo cual es lo mas probable (por eso
 // se coloca primero esta condicion)

 if ( 0 != x % 16 )

 {   // Abre if

 // Se imprime el residuo de la division
 //Imprimir( x % 16 );

 a[contador++] = x % 16;

 // Ahora x es x - residuo 
 x -= x % 16; 

 // Ahora se divide x entre 16
 x /= 16;

 }   // Cierra if

 // De lo contrario
 // Esto es, si x es multiplo de 16

 else

 {     // Abre else

 // System.out.print("0");

 a[contador++] = 0;

 //Ahora x es x/16
 x /= 16;

 }     // Cierra else

 }     // Cierra while

 System.out.println("\n");

 // El numero en notacion hexadecimal, que se ha
 // guardado en el arreglo a se manda a imprimir 

 Imprimir();

 }     // Cierra metodo Hexadecimal

     



 ///////////////////////////////////
 //METODO IMPRIMIR
 ///////////////////////////////////

 public void Imprimir(  )

 {      // Abre metodo Imprimir

 // El arreglo se imprime de la ultima posicion
 // a la primera. Sin embargo, es muy probable 
 // que las ultimas sean 0. Como estan a la derecha
 // no es necesario imprimirlos. La variable estatus
 // inicia con "afuera", lo cual indica que los ceros 
 // no deben imprimirse

 String estatus = "afuera";



 for ( int i = Tamano - 1; i >= 0; i-- )

 switch ( a[i] )

 {       // Abre switch

 case 0:

 if ( "adentro" == estatus )

 System.out.printf("0");
 break;

 case 1:
 System.out.printf("1");
 estatus = "adentro";

 break;
 case 2:
 System.out.printf("2");
 estatus = "adentro";
 break;

 case 3:
 System.out.printf("3");
 estatus = "adentro";
 break;

 case 4:
 System.out.printf("4");
 estatus = "adentro";
 break;

 case 5:
 System.out.printf("5");
 estatus = "adentro";
 break;

 case 6:
 System.out.printf("6");
 estatus = "adentro";
 break;

 case 7:
 System.out.printf("7");
 estatus = "adentro";
 break;

 case 8:
 System.out.printf("8");
 estatus = "adentro";

 break;
 case 9:
 System.out.printf("9");
 estatus = "adentro";
 break;

 case 10:
 System.out.printf("A");
 estatus = "adentro";
 break;

 case 11:
 System.out.printf("B");
 estatus = "adentro";
 break;
 case 12:

 System.out.printf("C");
 estatus = "adentro";
 break;

 case 13:
 System.out.printf("D");
 estatus = "adentro";
 break;

 case 14:
 System.out.printf("E");
 estatus = "adentro";
 break;

 case 15:
 System.out.printf("F");
 estatus = "adentro";
 break;

 }       // Cierra switch

 // Es probable que se haya introducido el numero 0
 // y en este caso la variable estatus permanecio
 // como "afuera" y no se imprimio el 0.

 if ( "afuera" == estatus )

 System.out.printf("0");
 System.out.println("\n");

 }      // Cierra metodo Imprimir  

 }    // Cierra clase Convertir

Unos Consejos para Programar

Esta entrada contiene algunos consejos que no por conocidos dejan de ser útiles a la hora de programar. Con ellos se puede evitar algunos errores de programación.

1) Comentar. Los lenguajes de alto nivel como C o Java son "amables" con el programador, pero no tanto. Un código muy compacto y optimizado puede ser muy bueno para la máquina, pero no para el humano. Esos códigos son difíciles de mantener y comprender. Es un error pensar que no se cambiarán o que recordaremos siempre qué hace un segmento de programa. Y aún cuando esto último sea cierto, es probable que el autor del programa no sea el único que lo leerá. Me ha pasado más de una vez que después de dejar un programa por un tiempo, cuando trato de mejorarlo lo encuentro a tal punto incomprensible que prefiero hacerlo de nuevo, aún cuando ésto me puede tomar un día completo. Ésto puede evitarse con un buen uso de los comentarios. He visto algunos programadores que piensan que es inútil y redundante. En mi experiencia es necesario. Una forma que uso para programar es escribir primero el seudocódigo en un editor y a partir de ahí escribirlo en el lenguaje de programación. Así el seudocódigo se transforma en comentarios.

2) Pensar en el usuario final. Un consejo muy bueno cuando se hace un programa es poner un comentario al principio explicando brevemente qué hace el código. Por cortesía con el usuario, es necesario no sólo comentarlo, sino imprimirlo al principio de la ejecución. Quien corre el programa puede no tener acceso al código fuente y no puede estar adivinando qué hace el programa o qué requiere como entrada. Si se requiere una entrada, es necesario que el usuario pueda saber en cualquier momento las carácterísitcas de ésta. Sin embargo, hay que tener en cuenta que muchas veces, el usuario de un programa no es una persona, sino otro programa. En buena medida ésto esta de acuerdo con la filosofía Unix. Algunos programas pueden ser comandos requeridos por otros comandos. Hay que poder hacer una diferencia entre cuándo un programa ha de ser usado por una persona o cuando por otro programa.

3) Cuidado con los condicionales. En C y C++, la instrucción

if (condicion)
  Instrucciones

puede resultar en un error lógico no fatal si se combina un error de sintaxis con una mala práctica de programación. En esos lenguajes, una asignación como x = 2 es una expresión con un valor, el del lado izquierdo después de la asignación. Esto hace que pueda aparecer como parte de una expresión más larga y es aprovechado por programadores experimentados para escribir código más compacto. Por otro lado, un error muy común es escribir el operador de asignación '=' en lugar del de relación '=='. Cuando estas dos cosas ocurren en un programa, como en la instrucción

if ( x = 2)
printf("\nx = %d", x)

se realiza primero la asignación x = 2, se verifica la condición y se ejecuta la instrucción printf, imprimiéndose no el valor que x tenía, sino 2. El usuario puede pensar que se ha cumplido la condición, cuando en realidad se ha cambiado el valor de la variable. ¿Por qué se realiza el cuerpo de if?, es decir ¿Por qué es cierta la condición? la respuesta es que la condición de if se evalúa como un número booleano, que toma sólo los valores 0 y 1. La computadora toma como 1 cualquier cosa que no sea 0, y, como se dijo arriba, la expresión x = 2 tiene en realidad el valor de 2, lo cual es diferente de 0 y se evalúa como 1 o "verdadero". Si el segmento varía un poco, como se muestra abajo:

if ( x = 0)
printf("\nx = %d", x)

entonces el cuerpo de if no se ejecuta, porque el valor de la asignación x = 0 es 0 ó "falso".
Abajo se muestra un programa con estos errores.

#include <stdio.h>

int main()
{     /* Abre main*/

/* Inicialmente x = 1*/
int x = 1;

/* Buena practica de programacion*/
if( 1 == x )
printf("\nx = %d\n", x);

/*Una mala practica de programacion,
 combinada con un error, genera una asignacion
 sin advertencia y la condicion es verdadera*/
if( x = 2 )
printf("\nx = %d\n", x);

/* De nuevo se genera una asignacion,
 se asigna 0 a x, y la condicion es falsa */
if ( x = 0 ) 
printf("\nx = %d\n", x);

/* El valor final de x*/
printf("\nx = %d\n", x);

return 0;

}     /* Cierra main */

el programa se compila sin problemas y se genera el ejecutable. (En Java sí hay un aviso). Aquí la salida:

x = 1

x = 2

x = 0

¿Qué hay que hacer para evitar estos problemas? Crearse la buena práctica de programación de escribir siempre los condicionales como ( 2 == x ) en lugar de ( x == 2 ). Las dos formas son correctas, pero en caso de olvidar un '=', la segunda puede provocar un error sutil difícil de detectar si está inserto en programa grande. Recuerde que las asignaciones no se hacen de la forma 2 = x; sino como x = 2;

Aquí el mismo programa con ésta convención:

#include <stdio.h>

int main()
{     /* Abre main*/

/* Inicialmente x = 1*/
int x = 1;

/* Buena practica de programacion*/
if( 1 == x )
printf("\nx = %d\n", x);

/*Con una buena practica de programacion,
un error genera una advertencia del compilador*/
if( 2 = x )
printf("\nx = %d\n", x);

/* De nuevo se genera una advertencia
del compilador*/
if ( 0 = x ) 
printf("\nx = %d\n", x);

/* El valor final de x*/
printf("\nx = %d\n", x);

return 0;

}     /* Cierra main*/

Aquí está un mensaje del compilador indicando un error.

Archivo.c: En la función ‘main’:
Archivo.c:15:7: error: se requiere un l-valor como operando izquierdo de la asignación
Archivo.c:20:8: error: se requiere un l-valor como operando izquierdo de la asignación

4) El orden de las condiciones afecta la rapidez con la que se ejecuta el programa. Cuando se escribe un segmento del tipo

if (condicion)
  Instrucción1

else
  Instrucción2

se debe poner como condición aquello que tenga más probabilidades de ser evaluado como "verdadero", de lo contrario el programa evaluará if y else cada vez que se ejecute, cuando podría evaluar solamente if, así se gana un poco de tiempo.
De igual manera, cuando se evalúa una instrucción de la forma

( (condición1) && (condición2) )

condición1 debe de ser la más probablemente falsa de las dos, ya que basta con que la primera sea falsa para que toda la expresión lo sea, y por lo tanto no es necesario verificar la condición2, así el programa se ejecuta más rápido.

Cuando se evalúa una instrucción

( (condición1) || (condición2) )

condición1 debe ser la más probablemente verdadera, porque basta con que la primera lo sea para que toda la expresión sea verdadera y no es necesario evaluar condicion2.
Seguir cada una de éstas recomendaciones tal vez provoque una diferencia marginal en la ejecución de un programa, pero en conjunto en un ciclo largo pueden hacer que el programa se ejecute más rápido.

Convertir de Decimal a Octal en Java

Este programa recibe un número decimal y lo convierte a notación Octal.

Este código debe guardarse con el nombre UsaconvertirOctal.java

 import java.util.Scanner;

 public class UsaConvertirOctal

 {   // Abre clase UsaConvertirOctal

 public static void main( String args[])

 {    // Abre main

 System.out.print("\nEste programa convierte decimal a ");

 System.out.print("octal. \n");

 Scanner entrada = new Scanner(System.in);

 ConvertirOctal miObjeto = new ConvertirOctal();

 int numero;

 

 System.out.print("\nPor favor introduzca un numero ");

 System.out.println("y se imprimira su equivalente en octal: ");

 numero = entrada.nextInt();

 miObjeto.Octal( numero );



 }    // Cierra main

 }   // Cierra clase UsaConvertir

Este código debe guardarse con el nombre ConvertirOctal.java

 public class ConvertirOctal

 {    // Abre clase ConvertirOctal

 // La variable Tamano controla el numero de 

 // simbolos que se requieren para hacer la conversion

 // Para llevar un registro de los simbolos se usa un

 // arreglo. Estos se deben guardar porque se van generando

 // de derecha a izquierda, pero la impresion es de 

 // izquierda a derecha.

 private int Tamano = 35;

 private int[] a = new int[Tamano];

 /////////////////////////////////////

 // METDODO OCTAL

 /////////////////////////////////////

 

 public void Octal( int x )

 {     // Abre metodo Octal

 System.out.println("\nAqui esta el numero en notacion octal: ");

 // Las entradas del arreglo se llenan con 0

 for ( int i = 0; i < Tamano; i++ )

 {  // Abre for

 a[i] = 0;

 }  // Cierra for



 int j = 0;

 while ( 0 != x )

 {   // Abre while

 

 if ( 0 != x % 8 )

 {   // Abre if

 a[j++] = x % 8; 

  

 // Se resta el residuo

 x -= x % 8;

 // Se divide entre 8

 x /= 8;

 }   // Cierra if

 else 

 {     // Abre else

 a[j++] = 0; 

 // Se cambia x

 x /= 8;

 }     // Cierra else

 }   // Cierra while

 // El numero en octal, que se ha guardado

 // al reves en el arreglo a, se manda a 

 // imprimir

 Imprimir();

 }     // Cierra metodo Octal 







 ///////////////////////////////////

 //METODO IMPRIMIR

 ///////////////////////////////////

 public void Imprimir(  )

 {      // Abre metodo Imprimir

 // El arreglo se imprime de la ultima posicion

 // a la primera. Sin embargo, es muy probable 

 // que las ultimas sean 0. Como estan a la derecha

 // no es necesario imprimirlos. La variable estatus

 // inicia con "afuera", lo cual indica que los ceros 

 // no deben imprimirse

 String estatus = "afuera";

 

 for ( int i = Tamano - 1; i >= 0; i-- )

 switch ( a[i] )

 {       // Abre switch

 case 0:

 if ( "adentro" == estatus )

 System.out.printf("0");

 break;

 case 1:

 System.out.printf("1");

 estatus = "adentro";

 break;

 case 2:

 System.out.printf("2");

 estatus = "adentro";

 break;

 case 3:

 System.out.printf("3");

 estatus = "adentro";

 break;

 case 4:

 System.out.printf("4");

 estatus = "adentro";

 break;

 case 5:

 System.out.printf("5");

 estatus = "adentro";

 break;

 case 6:

 System.out.printf("6");

 estatus = "adentro";

 break;

 case 7:

 System.out.printf("7");

 estatus = "adentro";

 break;

 default:

 System.out.printf("ERROR. EL PROGRAMA ESTA MAL");

 break;

 }       // Cierra switch

 // Es probable que se haya introducido el numero 0

 // y en este caso la variable estatus permanecio

 // como "afuera" y no se imprimio el 0.

 if ( "afuera" == estatus )

 System.out.printf("0");



 System.out.println("\n");

 }      // Cierra metodo Imprimir  

 }    // Cierra clase ConvertirOctal