Este código hace parte de un reto de sinfocol, básicamente lo que hace es lo siguiente :
- Lee un fichero linea por linea, donde cada linea representa una ecuacion cuadratica.
- Resuelve la ecuación cuadratica evaluando los resultados de x1 y x2 para tomar el valor entero. (Un valor entero es aquel que no tiene punto flotante)
- Suma todos los valores enteros y arroja en un archivo “salida.txt” el resultado de la suma de todas las ‘x’ enteras y la cantidad de operaciones realizadas.

No siendo más aqui esta el código un poco documentado

/* Codigo mejorado 
 * Encuentra la suma de todos los valores enteros de la solucion de las
 * formulas cuadraticas tomadas de un archivo
 * @author  DMK
 * Agradecimientos especiales al señor HaDeS por su buen reto =)
 */

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.math.*;

public class Cuadraticas2 {
    public static void main(String args[]) throws IOException, ArrayIndexOutOfBoundsException{
        //String archivo = "quadratic.txt";
		try{
			String archivo = args[0];
			sumarCuadraticasEnteras(archivo);
		}catch(ArrayIndexOutOfBoundsException ex){
			System.out.println("Por favor ingrese el nombre del fichero a procesar  ");
			System.out.println("Ejemploe : java Cuadraticas2 miFichero.txt");
		}
    }

    public static void sumarCuadraticasEnteras(String archivo) throws IOException{
        //Variables de control
        int necuaciones     = 0;
        String formulaError = "";
        //Variables para la formula
        long a,b,c,suma = 0;     //Valores de la ecuacion cuadratica
        int pos;        //Posicion para el substring
        String chunk;   //Trozo que va guardando la operacion
        double x1 = 0, x2 = 0, h = 0, raiz = 0; //Valores de salida

        //Verifico si el archivo existe
        try{
            //Variables para el manejo de archivos
            //Fichero de entrada
            File fe = new File(archivo);
            BufferedReader br = new BufferedReader(new FileReader(fe));
            //Fichero de salida
            PrintWriter out = new PrintWriter(new FileWriter("salida.txt"));

            //Leo el fichero
            String linea = "";
            while( (linea = br.readLine())!= null){
                //Remplazo caracteres en blanco

                linea = linea.replace("	", "");
                linea = linea.replace("--", "+");
                linea = linea.replace("x+-", "x-");
                linea = linea.replace("x--", "x+");
                linea = linea.replace("x++-", "x-");
                linea = linea.replace("+++", "+");      

                //Obtengo el valor de a
                pos = linea.indexOf("x^2");
                chunk = linea.substring(0, pos);
                a = Long.parseLong(chunk);
                //System.out.println(a);

                //Obtengo el valor de b
                pos = linea.indexOf("+");
                chunk = linea.substring((pos + 1),linea.indexOf("x",pos));
                if(chunk.length() == 0)
                    b = 1;
                else
                    b = Long.parseLong(chunk);

                //Obtengo el valor de c
                pos = linea.indexOf("x",pos);
                if(linea.indexOf("x+",pos) > 1)
                    chunk = linea.substring((pos + 2),linea.length());
                else
                    chunk = linea.substring((pos + 1),linea.length());

                if(chunk.length() == 0)
                    c = 0;
                else
                    c = Long.parseLong(chunk);

               //Realizo operacion de la raiz
               h = (b*b - 4*a*c);
               //Evaluo si h es negativo
                if(h >  x1  " + x1 + "   ==    x2: " + x2);

                //Realizo la suma de los numeros sin parte decimal
                if(x1 % 1 == 0){
                    necuaciones++;
                    suma += (long)x1;
                    out.println("#" + necuaciones + " : " + x1);
                }

                //Sumo los valores enteros de x1 y x2
                //Imprimo resultados
                if(x2 % 1 == 0){
                    necuaciones++;
                    suma += (long)x2;
                    out.println("#" + necuaciones + " : " + x2);
                }
                if( (x1 % 1 != 0 && x2 % 1 != 0)){
                    necuaciones++;
                    formulaError = "#" + necuaciones + " : " + linea + "\n";
                }

                //out.println(linea);
            }
            br.close();         //Cierro el archivo de lectura

            //Muestro varios resultados para comparar la respuesta
            out.println("Total de ecuaciones identificadas : " + necuaciones);
            out.println("La suma de los numeros es : " + suma);
            out.println("Las siguientes formulas tienen error : " + formulaError);

            out.flush();
            out.close();
        }catch(FileNotFoundException ex){
            System.out.println(" ERROR : Lo siento tio, pero el archivo "  + archivo + " no esta en ");
        }
    }
}

Hakuna matata!, Greetings to all and happy Bandwidth.

Hola parceros, bueno luego de terminar la solución del reto de yashira “Trial Version”, aqui expongo el código que use para tal reto. Adicional a esto pues me pareció muy interesante la forma de cifrar y descifrar datos =).

Si pueden observar el código tiene cositas adicionales, como un menú, lee un archivo “entrada.txt” y arroja una “salida.txt”. No siendo más ahora si vamos a la acción . He colocado algunos comentarios documentando el código, sin embargo creo que esta muy claro

/****
 *  msg : /&4=91 5)?1= 5$35==14& 5$ {$1 31)31=1 45 ${5+ - )5$?9=m5 =5- 45 {$ 5)/139& 9$69$9?&
 *  @description : Reto para yashira
 *  @author       :  D-m-K
 ***/

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;

public class TrialRamon {
    //Miembros de clase

    static BufferedReader br;
    //Patron de cadenas para cifrar y descifrar
    public final static String str1 = "1234567890!#$%&/(=)?{¡@*-+";
    public final static String str2 = "abcdefghijklnñopqrstuvwxyz";
    public static File fe;
    public static boolean abierto;

    //Main 
    public static void main(String[] args) throws IOException {
        //Instacio y defino los datos de entrada
        fe = new File("entrada.txt");
        BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
        int op;
        do{
            System.out.println(" 1. Cifrar datos");
            System.out.println(" 2. Descifrar datos");
            System.out.println(" 3. Salir  ");
            System.out.print("    Opcion >>");
            op = Integer.parseInt(entrada.readLine());
            //Evaluo la opcion ingresada
            switch(op){
                case 1:
                    Criptar();
                    break;
                case 2:
                    DesCriptar();
                    break;
                case 3:
                    System.out.println("Hasta luego!");
                    System.exit(0);
                    break;
            }
        }while(op != 3);
    }

    //Codifico los datos del fichero de entrada
    public static void Criptar() throws IOException {
        //Evaluo si el fichero pudo ser abierto
        if(fe.exists()){
            br = new BufferedReader(new FileReader(fe));
            abierto = true;
        }else{
			System.out.println("El archivo no existe");
		}
        if(abierto){
            //Creo el fichero de salida
            PrintWriter out = new PrintWriter(new FileWriter("salida.txt"));
            //Realizo el cifrado de los datos
            String linea = "";
            while ((linea = br.readLine()) != null) {
                System.out.println(linea);
                for (int i = 0; i < str1.length(); i++) {
                    linea = linea.toLowerCase();
                    linea = linea.replace(str2.charAt(i), str1.charAt(i));
                }
                System.out.println(linea);
                //Escribo la linea cifrada en el archivo
                out.println(linea);
            }
            //Aseguro los datos de salida y cierro los ficheros
            br.close();
            out.flush();
            out.close();
        }else{
            System.out.println("\n ERROR : El archivo no pudo ser abierto");
        }
        System.out.println("leyendo");
    }

    //Decodifica los datos del fichero de entrada
    public static void DesCriptar() throws IOException{
    //Evaluo si el fichero pudo ser abierto
        if(fe.exists()){
            br = new BufferedReader(new FileReader(fe));
            abierto = true;
        }else{
			System.out.println("El archivo no existe");
		}
        if(abierto){
            //Creo el fichero de salida
            PrintWriter out = new PrintWriter(new FileWriter("salida.txt"));
            //Realizo el cifrado de los datos
            String linea = "";
            while ((linea = br.readLine()) != null) {
                System.out.println(linea);
                for (int i = 0; i < str1.length(); i++) {
                    linea = linea.toLowerCase();
                    linea = linea.replace(str1.charAt(i), str2.charAt(i));
                }
                System.out.println(linea);
                //Escribo la linea cifrada en el archivo
                out.println(linea);
            }
            //Aseguro los datos de salida y cierro los ficheros
            br.close();
            out.flush();
            out.close();
        }else{
            System.out.println("\n ERROR : El archivo no pudo ser abierto");
        }
        System.out.println("leyendo");
    }
}

Hakuna Matata! Greetings to all and happy bandwidth.

Hoy es el final trágico de la historia que siempre estuvo maquinando
en la mente de este noble guerrero (Fantasia). Hoy la realidad muestra
su verdadero rostro ante el arquetipo elaborado de un sencillo plan
maestro (Conquista). Hoy se manifiestan los sentimientos de odio en una
sola palabra que genera temor a esta insulsa humanidad (Desilución),
tal vez mis creaturas han decido aceptar ser los oidos y el cuerpo de
un instinto fraternal e inevitable (Amor). Hoy es un día cualquiera,
en un lugar indeterminable, de una vida sin precedentes, donde los
personajes han sido simplemente, títeres seleccionados al azar de una
obra con un contenido vacuo.

¿El guionista?….

El mismo que escribe estas palabras y deja un sabor amargo en cada espacio que concluye al terminar. Solo el punto final marcará el comienzo de una nueva historia y el pensamiento creativo e inmune de todo sentimiento.

¿El dilema?…

Saber que por cualquier medio, habiendo hecho lo correcto y lo incorrecto, sin importar la morfológica apariencia que se muestre ante ese ser omnisciente (Ella), sin tener en cuenta las justificaciones de cualquier realidad o fantasia de este mundo, SIEMPRE se llegara a la misma conclusion, en pocas palabras mi estimado lector, yo le llamaria la cuspide de la ironía.

“Nada me pertenece y aun asi, quiero dejar de ser EL esclavo de este “TODO” que se vuelve mas obsesivo por poseerme…”

Greetings to All and Happy BandWidth.
By [D-m-K]

Bueno este es un simple codigo que saque por una duda que tenia referente a los ASCII

//*********************************************
// Ingresa una serie de caracteres y devulve
// su codificaci¢n en ASCII
//*********************************************

#include
#include

using namespace std;

void getAscii(char *);

int main(){

   char phrase[200];

   system("cls");
   cout<> ";
   cin.getline(phrase,200);
   getAscii(phrase);    //Function for get the code ASCII
   system("pause>nul");
   return 0;
}

//*********************************************
// Funcion : getAscii()
// Recibe como parametro un arreglo de chars
// y convierte los caracteres a ASCII
//*********************************************
void getAscii(char *msg){

   int i;
   cout<<"\n\tCONVERSION CHARS TO ASCII \n";
   cout<<"\t------------------------------------\n";

   cout<<"\n\t [ORIGINAL]\n\t ";
   i = 0;
   while(true){
     cout<<msg[i];
     i++;
     if(msg[i] == '')   break;
     if(i%15 == 0)        cout<<"\n\t ";
     cout<<"-";
   }

   cout<<"\n\n\t [ASCII]\n\t ";
   i = 0;
   while(true){
     cout<<(int)msg[i];
     i++;
     if(msg[i] == '')   break;
     if(i%15 == 0)        cout<<"\n\t ";
     cout<<"-";
   }

   cout<<"\n\n\t------------------------------------";
   cout<<"\n\t # Chars : "<<i;
   //# The END  #
}

Greetings to all and happy Bandwidth

Bien, despues de tantas veces reiniciar a ‘Athena’ y cambiar de SO para poder tener acceso a ciertos archivos decidí deseperadamente buscar una manera de poder compartir mis archivos entre los dos SO. (Debian lenny ‘Athena’ Vs Windows SP). Finalmente despues de leer sobre la documentación sobre Samba, el protocolo que usa SMB (Send Message Block) y en varios foros de debian llegue a la siguiente conclusión.

1.Instalar Samba :

Se puede configurar el sources.list (/etc/apt/sources.list) y agregar la siguiente linea para que tome los archivos
directamente desde el repositorio oficial de debian

   deb http://ftp.debian.org etch main contrib non-freelist

Para instalar samba se requieren los siguientes paquetes

   #apt-get install smb-client smb smbfs samba-common

*Nota : La instalacción de los paquetes se puede hacer también desde Synaptics, pero para aquellos usuarios que les gusta la consola (como Phicar xD), pues toca así con comandos en la shell.

2. Instalando ntfs-3g

Para poder tener acceso a los archivos de windows usando samba se requiere de un paquete llamadao ntfs-3g.

  #apt-get install ntfs-3g

3.Crear directorio para compartir.

Normalmente cuando se monta una unidad, volumen o dispositivo se le asigna una carpeta para el montaje. En este caso he decido crear una subcarpeta para mi athena, dentro del directorio windows. Dependiendo la cantidad de particiones que se vallan a montar, pues se crean más carpetas.

  #mkdir /media/windows
  #mkdir /media/windows/athena

4. Mirar las particiones disponibles y montar volumen

 root@athena:~# fdisk -l

 Disco /dev/sda: 81.9 GB, 81964302336 bytes
 255 heads, 63 sectors/track, 9964 cylinders
 Units = cilindros of 16065 * 512 = 8225280 bytes
 Disk identifier: 0x15ea15e9

 Disposit. Inicio    Comienzo      Fin      Bloques  Id  Sistema
 /dev/sda1   *           1        2839    22804236    7  HPFS/NTFS
 /dev/sda2            2840        5099    18153450    f  W95 Ext'd (LBA)
 /dev/sda3            5100        9963    39070048+   7  HPFS/NTFS
 /dev/sda5            2840        5099    18153418+   7  HPFS/NTFS

 Disco /dev/sdb: 500.1 GB, 500107862016 bytes
 255 heads, 63 sectors/track, 60801 cylinders
 Units = cilindros of 16065 * 512 = 8225280 bytes
 Disk identifier: 0x862df882

 Disposit. Inicio    Comienzo      Fin      Bloques  Id  Sistema
 /dev/sdb1               1       12749   102406311    7  HPFS/NTFS
 /dev/sdb2           12750       38247   204812685   83  Linux
 /dev/sdb4           38248       60801   181165005    f  W95 Ext'd (LBA)
 /dev/sdb5           38248       38885     5124703+  82  Linux swap / Solaris
 /dev/sdb6           38886       60801   176040238+  83  Linux

Nota : El * indica que esa es la partición primaria. En la columan sistema se puede saber el tipo de partición, para este caso solo nos interesan los que tienen como sistema de archivos HPFS/NTFS.

para montar el volumén :

 root@athena:~# mount -t ntfs-3g /dev/sda3 /media/windows/
 root@athena:~# mount
 /dev/sdb2 on / type ext3 (rw,errors=remount-ro)
 --->>> /dev/sda3 on /media/windows type fuseblk (rw,allow_other,blksize=4096)

5. Dejar por defecto la partición montada

Para esto solo debes editar el archivo /etc/fstab (Este contiene la configuracion montajes del equipo) y dejar hecho el montaje.

#nano /etc/fstab
# /etc/fstab: static file system information.
#
#
proc            /proc           proc    defaults        0       0
/dev/sdb2       /               ext3    defaults,errors=remount-ro 0       1
/dev/sdb6       /home           ext3    defaults        0       2
/dev/sdb5       none            swap    sw              0       0
/dev/hda        /media/cdrom0   udf,iso9660 user,noauto     0       0
/dev/sdb1       /media/windows/athena   ntfs-3g defaults        0       0

Man del comando fstab

6. Desmontarme de un disco

Para desomantarte simplemente debes usar el comando umount y el punto de montaje

  umount /media/windows/athena

Listo!!!. Eso es todo lo necesario.

Nota : En caso que se quiera montar una unidad con un sistema de archivos FAT32 queda solucionar el problema con las particiones W95 Ext’d (LBA).

Greetings to all and happy bandWidth

Hola, por recomendación de mi viejo amigo phi mejore el código utilizando recursión y el tipo de dato BigInteger para no limitar al usuario a ingresar máximo un N de 20.

package javacertificationdmk.capitulo2;
import java.math.BigInteger;
import java.io.*;

/***
 *

Nombre      : FactorialSencillo.java

 *

Descripción : Se obtiene el factorial por recursividad usando BigInteger

 *

Fecha       : Marzo 7 de 2009

 * @author        : [D-m-K]
 * @version       : 1.0.0
 ***/

public class FactorialSencillo2 {
  public static void main(String[] args) throws IOException{
        //Pido el número
        System.out.println("\n\t O B T E N E R   F A C T O R I A L \n");
        int n = leerN("\t Ingresa el valor de N para obtener factorial : ");
        BigInteger factorial = obtenerFactorial(n);

        //Obtengo el factorial del número ingresado
        System.out.println("\n\t [R E S U L T A D O]\n");
        System.out.println("\t El factorial de " + n + " es : " + factorial);

  }

  /**
   * @param msg - Mensaje a mostrar para solicitar el valor de entrada
   * @return n - Valor ingresado de tipo entero
   * @throws java.io.IOException
   */
  public static int leerN (String msg) throws IOException{
      int n = 0;
      boolean error;
      BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

      do{
        error = false;
        try{
            System.out.print(msg);
            n = Integer.parseInt(br.readLine());
            if(n < 1){
                System.out.println("\t ERROR : El numero no puede ser negativo\n");
                error = true;
            }
        }catch(NumberFormatException e){
            System.out.println("\t ERROR : El valor ingresado no es numerico\n");
            error = true;
        }
      }while(error);

      return n;
  }

  /**
   * @param n - numero a calcular
   * @return fac - Factorial del numero a calcular de tipo BigInteger
   */
  public static BigInteger obtenerFactorial(int n){
      if(n <= 1){
          return (new BigInteger("1"));
      }else{
          BigInteger fac = new BigInteger(String.valueOf(n));
          return (fac.multiply(obtenerFactorial(n - 1)));
      }
  }

}

PTA: Por fín estoy usando bien la documentación xDDD

Greetings to all and happy BandWidth.

Bien al parecer estaba tan aburrido que esto fue lo unico que se me ocurrió… Básicamente obtiene el fáctorial de un número N (no mayor a 20, pues el resultado sería muy grande y sin precisión). Valida también el número ingresado.

/***
 * @Nombre      : FactorialSencillo.java
 * @Descripción : Obtiene el factorial de un numero cualquiera ingresado por el usuario
 * @Fecha       : Marzo 7 de 2009
 * @Autor       : [D-m-K]
 ***/

package javacertificationdmk.capitulo2;

//importo los packages necesarios para la entrada de datos
import java.io.*;

public class FactorialSencillo {
    public static void main(String[] args) throws IOException{

        //Pido el número
        System.out.println("\n\t O B T E N E R   F A C T O R I A L \n");
        int n = leerN("\t Ingresa el valor de N para obtener factorial : ");
        long factorial = obtenerFactorial(n);

        //Obtengo el factorial del número ingresado
        System.out.println("\n\t [R E S U L T A D O]\n");
        System.out.println("\t El factorial de " + n + " es : " + factorial);

    }

    static long obtenerFactorial(int n) throws IOException{
        long fac = 1;
        //Calculo factorial
        for(int i=1; i 20){
                System.out.println("\t ERROR : Changos ese numero generaria un resultado muy grande.\n");
                error = true;
             }
          }catch(NumberFormatException e){
              System.out.println("\t ERROR : El valor ingresado no corresponde a un numero.\n");
              error = true;
          }
       }while(error);
       //Retorno el número ingresado de tipo entero
        return num;
    }

}

Greetings to All and Happy BandWidth

Bueno por ahi jodiendo un rato y teniendo en cuenta el dominio del ingreso de datos por consola quise demostrar que este código si funcaba. xD

/***
 * @Nombre      : CompruebaPar.java
 * @Descripción : Comprueba si un numero es par o no. usando datos de ingreso
 *                por teclado.
 * @Fecha       : Marzo 5 de 2009
 * @Autor       : [D-m-K]
 ***/

//Importo librerias necesarias
import java.io.*;

public class CompruebaPar {
    public static void main(String[] args) throws IOException{

        //Definición de variables
        int numero = 0;
        boolean error;
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));

        do{
            error = false;
            try{
                System.out.print("\n\t Ingresa un numero para comprobar si es PAR o IMPAR : ");
                numero = Integer.parseInt(in.readLine());
            }catch(NumberFormatException e){
                System.out.println("\t ERROR : Eso no es un numero :O, intenta de nuevo LOL.");
                error = true;
            }
        }while(error);

        //Valido numero.
        if(numero % 2 == 0){
            System.out.println("\t El número ingresado es PAR");
        }else{
            System.out.println("\t El número ingresado es IMPAR.");
        }

    }

}

Greetings to all and happy bandwidth.

Bueno, de puro desparche estaba leyendo un librito de JAVA en el cuál colocaban el siguiente retillo .

Desarrollar un programa que, a partir de dos numeros enteros dados, muestre en pantalla la suma de todos los numeros pares entre el rango de los dos numeros.

/***
 * @Nombre      : SumaPares.java
 * @Descripción : A partir de dos numeros ingresados por teclado, calcula la
 *                suma de todos los numeros pares existentes en el rango de los
 *                numeros ingresados
 * @Fecha       : Marzo 5 de 2009
 * @Autor       : [D-m-K]
 ***/

//Paquete principal de clases
package javacertificationdmk.capitulo2;

//importo librerias necesarias
import java.io.*;

public class SumaPares {
    public static void main(String[] args) throws IOException{

        //Definición de variables
        int a, b, mayor, menor, suma = 0;

        System.out.println("\n\tPor favor ingresa dos numeros para calcular la suma de los pares : \n");
        a = leer("\tNumero a : ");
        b = leer("\tNumero b : ");

        //Evaluo cual es mayor
        if(a > b)
        {
            mayor = a;
            menor = b;
        }else{
            mayor = b;
            menor = a;
        }

        //Calculo el rango.
        for (int i=menor; i<=mayor;i++){
            if(i%2 == 0)
                suma+=i;
        }

        System.out.println("\n\tLa suma de los pares entre " + menor + " y " + mayor + " : " + suma);

    }

    static int leer(String msg) throws IOException{
        int num = 0;
        boolean error;
        BufferedReader in =  new BufferedReader(new InputStreamReader(System.in));

        do{
            error = false;
            try{
                System.out.print(msg);
                num = Integer.parseInt(in.readLine());
            }catch(NumberFormatException e){
                System.out.println("\n\tEl Valor ingresado no es numerico :S");
                error = true;
            }
        }while(error);
        return num;
    }
}

Greetings to All and Happy bandwidth

Bien este humilde código sólo contiene un simple ejemplo del còmo se pueden restringir entrada de datos NO numericos en un campo que guardará un dato de tipo entero. Modificando el código o creando un método más agresivo se pueden usar metodos sobrecargados para evaluar el tipo de dato y seria mucho mejor.

/***
 * @Nombre      : ValidaDatoEntero.java
 * @Descripción : Valida un dato entero ingresado por teclado
 * @Fecha       : Marzo 5 de 2009
 * @Autor       : [D-m-K]
 ***/
package javacertificationdmk.capitulo2;

import java.io.*;

public class validaDatoEntero{
    public static void main(String[] args) throws IOException{
        int numero;
        boolean error;
        BufferedReader dato = new BufferedReader(new InputStreamReader(System.in));

        do{
            error = false;
            try{
                System.out.print("\n\t Ingresa un numero : ");
                numero = Integer.parseInt(dato.readLine());
            }catch(NumberFormatException e){
                System.out.println("\t ERROR : Eso no es un numero :O, intenta de nuevo LOL.");
                error = true;
            }
        }while(error);

        System.out.println("\n\t Bien parce Si llegaste hasta aquí todo funca bien.");
    }
}

Greetings to all and happy BandWidth