Convertidor de sistemas ( binario - hexadecimal - decimal )

/** IMAGEN DE PROGRAMA EN EJECUCION **/

 /** PROGRAMA JAR EJECUTABLE SI TIENES JAVA **/
http://www.4shared.com/file/YhUm3tF1/Convertidor.html

/** PROYECTO PARA LEVANTAR EN NETBEANS **/
http://www.4shared.com/file/1nRX6IiM/Convertidor.html

/** Espero le sea de utilidad el código que posteare a continuación **/


********************************************************************
* CODIGO DE LA INTERFAZ GRÁFICA DE USUARIO *
********************************************************************

/*
* Codigo creado y modificado por ZoidHack
* Elvis Leonardo Pérez Alcántara
* elvis_1245@hotmail.com
* Ultima fecha de modificacion : 19 - 04 - 2011
*/

package convertidor;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class Ventana extends JFrame
{
private JLabel etiqueta[] = new JLabel[3];
private JTextField campo[] = new JTextField[3];

private GridBagLayout gbl = new GridBagLayout();
private GridBagConstraints cons = new GridBagConstraints();

public Ventana()
{
super("Producciones TIBITO");

Preparar();
Eventos();
GUI();

setSize(300,400);
setVisible(true);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

private void GUI()
{
Container contenedor = getContentPane();
contenedor.setLayout(gbl);
cons.fill = GridBagConstraints.HORIZONTAL;
cons.weightx = 0.1;
cons.weighty = 1.0;
cons.gridx = 0;
cons.gridy = 0;
contenedor.add(etiqueta[0],cons);
cons.gridx = 0;
cons.gridy = 1;
contenedor.add(etiqueta[1],cons);
cons.gridx = 0;
cons.gridy = 2;
contenedor.add(etiqueta[2],cons);

cons.weightx = 1.0;
cons.gridx = 1;
cons.gridy = 0;
contenedor.add(campo[0],cons);
cons.gridx = 1;
cons.gridy = 1;
contenedor.add(campo[1],cons);
cons.gridx = 1;
cons.gridy = 2;
contenedor.add(campo[2],cons);
}

private void Eventos()
{
campo[0].addKeyListener(
new KeyListener() {

public void keyTyped(KeyEvent e)
{
}

public void keyPressed(KeyEvent e)
{
}

public void keyReleased(KeyEvent e)
{
try
{
String a = campo[0].getText();
if( a.equals("") )
{
campo[1].setText("");
campo[2].setText("");
}
int n = Integer.parseInt( a );
campo[1].setText( Funciones.DectoHexadecimal( n ) );
campo[2].setText( Funciones.DectoBinario( n ) ) ;
}
catch(NumberFormatException N)
{
JOptionPane.showMessageDialog(null, "Cadena ingresada no representa un numero.");
campo[0].setText("");
}
}
});
campo[1].addKeyListener(
new KeyListener() {

public void keyTyped(KeyEvent e)
{
}

public void keyPressed(KeyEvent e)
{
}

public void keyReleased(KeyEvent e)
{
try
{
String n = campo[1].getText();
if( n.equals("") )
{
campo[0].setText("");
campo[2].setText("");
}
campo[0].setText( Funciones.HextoDecimal( n ) );
campo[2].setText( Funciones.HextoBinario( n ) ) ;
}
catch(NumberFormatException N)
{
JOptionPane.showMessageDialog(null, "Cadena ingresada no representa un numero.");
campo[0].setText("");
}
}
});
campo[2].addKeyListener(
new KeyListener() {

public void keyTyped(KeyEvent e)
{
}

public void keyPressed(KeyEvent e)
{
}

public void keyReleased(KeyEvent e)
{
try
{
String n = campo[2].getText();
if( n.equals("") )
{
campo[0].setText("");
campo[1].setText("");
}
campo[0].setText( Funciones.BintoDecimal( n ) );
campo[1].setText( Funciones.BintoHexadecimal( n ) ) ;
}
catch(NumberFormatException N)
{
JOptionPane.showMessageDialog(null, "Cadena ingresada no representa un numero.");
campo[0].setText("");
}
}
});
}

private void Preparar()
{
etiqueta[0] = new JLabel("Decimal : ");
etiqueta[1] = new JLabel("Hexadecimal : ");
etiqueta[2] = new JLabel("Binario : ");

for(int i = 0; i< campo.length; ++i)
campo[i] = new JTextField();
}

private String DectoBinario(int n)
{
String dev = "";
while(n > 0)
{
dev += (n&1);
n >>= 1;
}
StringBuffer dev1 = new StringBuffer(dev);
dev = dev1.reverse().toString();
return dev;
}
}


*****************************************************************************
* CODIGO DE LA CLASE QUE CONTIENE LAS FUNCIONES *
* DE CONVERSION ENTRE SISTEMAS *
*****************************************************************************

package convertidor;

/*
* Codigo creado y modificado por ZoidHack
* Elvis Leonardo Pérez Alcántara
* elvis_1245@hotmail.com
* Ultima fecha de modificacion : 19 - 04 - 2011
*/

public class Funciones
{
public static String DectoBinario(int n)
{
return Integer.toBinaryString(n);
}

public static String DectoHexadecimal(int n)
{
return Integer.toHexString(n).toUpperCase();
}

public static String HextoDecimal(String n)
{
Integer dev = Integer.parseInt( n , 16 );
return dev.toString();
}

public static String BintoDecimal(String n)
{
Integer dev = Integer.parseInt( n , 2 );
return dev.toString();
}

public static String BintoHexadecimal(String n)
{
Integer dev = Integer.parseInt( n , 2 );
String dev1 = DectoHexadecimal(dev);
return dev1;
}

public static String HextoBinario(String n)
{
Integer dev = Integer.parseInt( n , 16 );
String dev1 = DectoBinario(dev);
return dev1.toString();
}
}

/*** Posteen sus dudas, y si necesitan aplicaciones ya saben ps, me comunican y alli arreglamos xD... **/

Leithold 7ª edición

http://www.4shared.com/document/SiQzobgl/Leithold_-_El_Calculo_-_espaol.html

Aplicacion de manejo de Teoria de Conjuntos

Hola chicos del foro, este espacio ah sido mas que todo creado para compartir códigos y/o aplicaciones realizadas por nosotros los informáticos. Asi que acá va mi primer aporte.

Este fin de semana me propuse realizar un programa que realice algunas de las operaciones de conjuntos.

Interseccion ( Conseguido )
Union ( Conseguido )
Diferencia
Diferencia simétrica
Potencia

Así que aquí pongo parte de mi código y sin más que decir los reto a proponer otra forma de resolución de este problema que a mi parecer es un poco complejo, les posteo el método que programe en C++.

/* Esta es la libreria para las operaciones */

#ifndef CONJUNTO_H_INCLUDED
#define CONJUNTO_H_INCLUDED
/*
 * CODIGO CREADO POR ZOIDHACK
 * Elvis Leonardo Pérez Alcántara
 */
#include

int buscar( int, lista &);
lista Union(lista&,lista&);
lista Interseccion( lista &, lista & );

lista Union( lista &a , lista &b )
{
    int i = 0;
    int tam = a.tamano();
    lista c = (a + b);
    /*cout<<"Salida union : "<
    c.Mostrar();*/
    return c;
}

lista Interseccion( lista &a, lista &b )
{
    int tam = a.tamano();
    int i = 0;
    /*for(int i = 0; i < tam ; ++i )
        cout << "Elemento["<<<"] = "<<

    lista dev;
    int k = 0;
    while( i < tam )
    {
        k = buscar( a[i] , b );
        /*cout << "Valor encontrado ( a [" << i << "] = " << a[i] << ", b ) = " << k << endl;
        cin.get();*/
        if( k != -1 )
            dev.Insertar(k);
        ++i;
    }
    return dev;
}

int buscar(int numero, lista &valores)
{
    int min = 0;
    int max = valores.tamano() - 1;
    float medio = max/2.0;
    int pos = (int)(medio+0.5);
    while( min < max )
    {

    /*cout << " ******************************* " << endl
         << " * min = " << min << " max = " << max << " medio = " << medio << " * " << endl
         << " ******************************* " << endl << endl
         << "valor = " << valores[pos] << endl
         << "posicion : " << pos << endl << endl << endl ;
        cin.get();*/
        if( numero == valores[pos] )
            return numero;
        else if( numero < valores[pos] )
        {
            max = medio;
            medio = (min + max)/2.0;
            pos = (int)(medio);
        }
        else
        {
            min = medio;
            medio = (min + max)/2.0;
            pos = (int)(medio+0.5);
        }
    }
    if( numero == valores[pos] )
        return numero;
    return -1;
}

#endif // CONJUNTO_H_INCLUDED

 /* Esta es la libreria con la lista modificada de c.conclase, ahora no permite insertar elementos repetidos, y los ordena de menos a mayor */

#ifndef LISTAENTEROS_H_INCLUDED
#define LISTAENTEROS_H_INCLUDED
// Lista en C++
// (C) Abril 2001, Salvador Pozo
// C con Clase: http://c.conclase.net
/*
 * Modificado el 16 de abril del 2011 por ZOIDHACK
 * Elvis Leonardo Pérez Alcántara
 */

#include
using namespace std;

class nodo {
   public:
    nodo(int v, nodo *sig = NULL)
    {
       valor = v;
       siguiente = sig;
    }

   private:
    int valor;
    nodo *siguiente;

   friend class lista;
};

typedef nodo *pnodo;

class lista {
   public:
    lista() { primero = actual = NULL; }
    //lista(lista&);
    ~lista();

    void Insertar(int v);
    void Borrar(int v);
    bool ListaVacia() { return primero == NULL; }
    void Mostrar();
    void Siguiente();
    void Primero();
    void Ultimo();
    bool Actual()const { return actual != NULL; }
    int ValorActual() const { return actual->valor; }
    int operator[](unsigned int);
    //lista &operator=(lista);
    lista operator+(lista &l);
    int tamano();

   private:
    pnodo primero;
    pnodo actual;
};

lista lista::operator+(lista &l)
{
    lista tmp = l;
    //tmp.Mostrar();
    //Mostrar();
    nodo *aux = primero;
    while(aux)
    {
        //cout<<"Inserto..."<< aux->valor << endl;
        tmp.Insertar(aux->valor);
        aux = aux->siguiente;
    }
    /*cout<<"Salida operador :"<
    tmp.Mostrar();*/
    return tmp;
}

lista::~lista()
{
   pnodo aux;

   while(primero) {
      aux = primero;
      primero = primero->siguiente;
      delete aux;
   }
   actual = NULL;
}

void lista::Insertar(int v)
{
   pnodo anterior;

   // Si la lista está vacía
   if(ListaVacia() || primero->valor > v)
   {
      // Asignamos a lista un nievo nodo de valor v y
      // cuyo siguiente elemento es la lista actual
      primero = new nodo(v, primero);
   }
   else
   {
      // Buscar el nodo de valor menor a v
      anterior = primero;
      // Avanzamos hasta el último elemento o hasta que el siguiente tenga
      // un valor mayor que v
      while(anterior->siguiente && anterior->siguiente->valor <= v)
      {
          if( anterior->siguiente->valor == v )
                return;
          anterior = anterior->siguiente;
      }
      if( anterior->valor == v )
          return;
      // Creamos un nuevo nodo después del nodo anterior, y cuyo siguiente
      // es el siguiente del anterior
      anterior->siguiente = new nodo(v, anterior->siguiente);
   }
}

void lista::Borrar(int v)
{
   pnodo anterior, nodo;

   nodo = primero;
   anterior = NULL;
   while(nodo && nodo->valor < v) {
      anterior = nodo;
      nodo = nodo->siguiente;
   }
   if(!nodo || nodo->valor != v) return;
   else { // Borrar el nodo
      if(!anterior) // Primer elemento
         primero = nodo->siguiente;
      else  // un elemento cualquiera
         anterior->siguiente = nodo->siguiente;
      delete nodo;
   }
}

void lista::Mostrar()
{
   nodo *aux;

   aux = primero;
   while(aux) {
      cout << aux->valor << "-> ";
      aux = aux->siguiente;
   }
   cout << endl;
}

void lista::Siguiente()
{
   if(actual) actual = actual->siguiente;
}

void lista::Primero()
{
   actual = primero;
}

void lista::Ultimo()
{
   actual = primero;
   if(!ListaVacia())
      while(actual->siguiente) Siguiente();
}

int lista::operator[](unsigned int j)
{
   nodo *aux;
   aux = primero;
   unsigned int i = 0;
   int n = -1;
   while(aux && i<=j)
   {
        n = aux->valor;
        aux = aux->siguiente;
        ++i;
   }
   if(i<=j) return -1;
   return n;
}

int lista::tamano()
{
   nodo *aux;
   int i = 0;
   aux = primero;
   while(aux)
   {
      aux = aux->siguiente;
      ++i;
   }
   return i;
}

#endif // LISTAENTEROS_H_INCLUDED

/* EXPLICACIÓN DEL MÉTODO EMPLEADO EN LA RESOLUCIÓN DEL PROBLEMA */

Bueno para empezar, al principio me tope con el gran problema de la representación de los conjuntos, pues podría haberlo representado con un simple arreglo, pero, ¿que ganaba con eso?. Después de pensar por casi dos horas, ŕecorde que existían la clase genéricas , que me permitía ir incrementando el numero de elementos sin desperdiciar memoria, pero no ganaba mucho mas que ganancia de memoria, pensando un poco más recordé que existían las colas de prioridades , que también me permitia ahorrar memoria, pero que como era una cola tenía que extraer elemento por elemento, puxa ahora que hago... Pensando... Luego de otro tiempo, me dije tmr tengo k crear una estructura a mano, que me permita, ingresar elementos sin perder memoria, ordenarlos para poder comparar rápidamente elementos entre dos objetos de esta estrucutura, y además que me permita acceder a sus elementos a través de un índice, y ya como algo superficial debería ser capaz de informarme de su tamaño cada vez que se lo pidiese.
Pensando otra vez...
Recorde que las listas abiertas me permitían extraer elementos de cualquier lado y además eliminarlos, escribiendo el elemento que deseaba eliminar, ahora no quería pasarme todo el día programando esa estructura, asi que le di una visita a c.conclase, y me descargue el código de una lista abierta en c++, creada a partir de clases.

RESOLUCIÓN DEL PROBLEMA:
 - INTERSECCIÓN : Bueno dije, como los elementos están ordenados puedo comparar directamente como una función biyectiva, pero como es la vida ksm, si tu analizas bien los elementos aunque estén ordenados puede que no tengan los mismos elementos como espejos, así que tienes que buscar cada uno de los elementos de uno de los conjuntos, en el otro, así que otra vez en problemas, pero antes de pasar a como resolví el problema, pasaré a explicar más detalladamente, el método que encontré haber si alguien encuentra algo más eficiente.

  A = { 1,2,5,7,9,11,13}
  B = { 3,8,9,13}

 1. Buscar el elemento 1 en el conjunto B.
 2. Buscar el elemento 2  en el conjunto B.
 ....
 n. Buscar el elemento n en el conjunto B.

     Luego de hacer esto encontrarán la intersección de los conjuntos, obviamente tendrán que formar una lista nueva, y cada vez que encuentren un elemento en B, tendrán que insertarlo y retornar la nueva lista.

Regresando a la historia, la lista de c.conclase no controla los elementos repetidos, osea que si existe el numero "1" en la lista y tu vuelves a insertar "1" te lo acepta, asi que esta es la primera modificación que hice a la clase.

Ahora lo siguiente es que la lista accede secuencialmente a los elementos, tmr otra vez, ahora como hago para hacerlo parecerse a un arreglo simple, bueno fácil sobrecargo el operador "[]", así que manos a la obra, sobrecargue este operador, y aunque la lista se sigue accediendo secuencialmente tu puedes llamar a un elemento en la posicion "n" ( elemento[n] ).

Ahora eh aquí un error que me di cuenta al editar este artículo, si nos ponemos a pensar bien, en la función que sobrecarga al operador[], aun se accede secuencialmente, un error grave cometido por mi.
    
/* CODIGO A OPTIMIZAR */

lista Interseccion( lista &a, lista &b )
{
    int tam = a.tamano();
    int i = 0;
    /*for(int i = 0; i < tam ; ++i )
        cout << "Elemento["<<<"] = "<<

    lista dev;
    int k = 0;
    while( i < tam )
    {
      k = buscar( a[i] , b );
       /* ¡Error! aunque haga esto se accede secuencialmente a los elementos, pero a parte de eso, al llamar al operador "[]", tenemos que acceder a la clase y acceder también secuencialmente hasta llegar a ese dato, con esto tenemos que con el acceso secuencial de la lista basta. ASI QUE AH OPTIMIZAR EL CÓDIGO. */
        /*cout << "Valor encontrado ( a [" << i << "] = " << a[i] << ", b ) = " << k << endl;
        cin.get();*/
        if( k != -1 )
            dev.Insertar(k);
        ++i;
    }
    return dev;
}

/* FUNCION MODIFICADA y OPTIMIZADA */

lista Interseccion( lista &a, lista &b )
{
    int tam = a.tamano();
    int i = 0;
    /*for(int i = 0; i < tam ; ++i )
        cout << "Elemento["<<<"] = "<<

    lista dev;
    int k = 0;
    a.Primero(); //Ingresamos a la primera posicion de la lista.
    while( a.Actual() ) //Mientras no lleguemos al último elemento.
    {
        k = buscar( a.ValorActual() , b ); //Leemos su valor con ValorActual().
        /*cout << "Valor encontrado ( a [" << i << "] = " << a[i] << ", b ) = " << k << endl;
        cin.get();*/
        if( k != -1 )
            dev.Insertar(k);
        a.Siguiente(); //Pasamos al siguiente elementos.
    }
    /*cout<<"salida funcion " << endl;
    dev.Mostrar();*/
    return dev;
}

Luego de eso de repente hay una u otra cosa que modificar en esta operación, haber si me ayudan...

- UNION :

   Para la union lo que se tiene que hacer es tan solo copiar una de las lista en una nueva, e ir insertando los elementos de la otra lista, y ya que la lista tiene las restricciones de aceptar elementos repetidos, y ordenarlos, esta les hará todo el trabajo demás, al final retornas la lista nueva y ya.

/* RESOLUCION */

Puxa pensando también se me ocurrió que el operador+ me ayudaría en esto, asi que sobrecargue este operador para que cuando sumemos dos listas nos retorne la union de las mismas.

lista lista::operator+(lista &l)
{
    lista tmp = l;
    //tmp.Mostrar();
    //Mostrar();
    nodo *aux = primero;
    while(aux)
    {
        //cout<<"Inserto..."<< aux->valor << endl;
        tmp.Insertar(aux->valor);
        aux = aux->siguiente;
    }
    /*cout<<"Salida operador :"<
    tmp.Mostrar();*/
    return tmp;
}

Y ya asi cuando tengo una lista a y una lista b, al hacer " a + b ", nos devolverá todos los elementos que estén dentro de a y de b, resultado que se podrá almacenar en otra variable.

Aun estoy trabajando en las otras operaciones así que si alguien puede ayudar a seguir en el desarrollo de las demás operaciones será xvr., o si alguien busca orrores en el código también se agradece postear las correcciones o la idea para postdesarrollo.