Cosas para Futuros Ingenieros

Código Fuente en C AFD con Listas

2013-01-10T21:02:00.002-06:00

Este programa en Lenguaje de Programación C es un Autómata Finito Determinista, El AFD esta definido por la expresión regular ε∪(b + ε)(ab)∗∪ (a + ε)(ba)∗. Esta expresión no acepta las subcadenas aa y bb.

El programa puede ser de gran utilidad en las materias sobre Teoría de Autómatas. Para armar un AFD distinto, lo que tienes que cambiar son las conexiones de los nodos, que se encuentran el método crear(), que es donde se arma el AFD, y obviamente, si el AFD que quieres construir tiene mas estados, pues tendrás que declarar mas nodos y si evalúa mas símbolos pues los agregas en el switch, ten en cuenta que agregar mas símbolos implica que tendrás que declarar mas enlaces dentro de la estructura.

El programa en C fue diseñado en Dev-C++, que si no lo tienes te recomiendo que lo descargues aquí.

Código Fuente en C

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

struct lista_elementos
{
  int estado;
  struct lista_elementos *a;
  struct lista_elementos *b;
};

typedef struct lista_elementos nodo;

void crear(nodo *q0,nodo *q1,nodo *q2,nodo *q3,
nodo *actual, nodo *anterior);
void mostrar(nodo *pt,nodo *pt2,int j,char i);

main()
{
nodo *q0,*q1,*q2,*q3,*actual,*anterior;
int j=0,i=0,tamano=0,novalido=0; char cadena[100];
actual=(nodo*)malloc(sizeof(nodo));
q0=(nodo*)malloc(sizeof(nodo));
q1=(nodo*)malloc(sizeof(nodo));
q2=(nodo*)malloc(sizeof(nodo));
q3=(nodo*)malloc(sizeof(nodo));
crear(q0,q1,q2,q3,actual,anterior);

printf("\n\n\n\t AFD Que no acepte las subcadenas aa y bb\n\n");
printf("  Ingrese Cadena: ");
gets(cadena);
tamano = strlen(cadena);

while (i < tamano && novalido==0){
    j=i+1;
    switch(cadena[i]){
        case 'a':
            if(actual->a==NULL){
                anterior=q0;
                actual=anterior->a;
                mostrar(anterior,actual,j,cadena[i]);
            }else{
                anterior=actual;
                actual=anterior->a;
                mostrar(anterior,actual,j,cadena[i]);
            }                        
            break;
        case 'b':
            if(actual->b==NULL){
                anterior=q0;
                actual=anterior->b;
                mostrar(anterior,actual,j,cadena[i]);
            }else{
                anterior=actual;
                actual=anterior->b;
                mostrar(anterior,actual,j,cadena[i]);}                        
            break;
          default:
              novalido=1;
              break;
           }
           i++;
}
if(actual->estado==1||actual->estado==4||novalido==1){
          printf("\n\n\t ------------------------- ");
         printf("\n\t --- Cadena Rechazada! --- \n");
          printf("\t ------------------------- \n\n");
          }
else{
         printf("\n\n\t ------------------------ ");
         printf("\n\t --- Cadena Aceptada! --- \n");
          printf("\t ------------------------ \n\n");
          }
      getchar();
}

void crear(nodo *q0,nodo *q1,nodo *q2,nodo *q3,nodo *actual, nodo *anterior)
{
      
      q0->a=q2;
      q0->b=q1;
      q1->a=q2;
      q1->b=q3;
      q2->a=q3;
      q2->b=q1;
      q3->a=q3;
      q3->b=q3;
      q0->estado=1;
      q1->estado=2;
      q2->estado=3;
      q3->estado=4;
      actual->a=NULL;
      actual->b=NULL;
      anterior->a=NULL;
      anterior->b=NULL;
}

void mostrar(nodo *pt,nodo *pt2, int j,char i)
{     int fuente=0,destino=0;
      fuente=pt->estado;destino=pt2->estado;
      fuente=fuente-1;destino=destino-1;
      printf("\n\n Movimiento: %d",j);
      printf("  Para el simbolo: %c",i);
      if(j==0){
      printf("\n\n\t Desde el Inicio");}
      else{
        printf("\n\n\t Del Estado: q%d",fuente);
        printf("\t A el Estado: q%d",destino);
        }
}

Código Fuente Java: Programa para Inventario de Pacientes

2012-11-11T14:42:00.000-06:00

En este programa aplicamos una lista doblemente ligada, a un caso real, se trata de un programa que lleve el inventario de pacientes, de digamos un hospital. Si bien el programa resulta sencillo, nos da una clara idea de como implementar estructura de datos en la vida real.

El programa como en todos los vistos aquí se constituye de 3 clases: clase nodo de la estructura, clase paciente en donde manipulamos la lista, y clase main que es la que controla todo el programa.

La clase mas importante seria la clase paciente, porque ahí están lo métodos que realizan las operaciones mas importantes. esta clase contiene los métodos que normalmente han llevado las listas aquí vistas, en cuanto a los demás, listanombres() se encarga de imprimir los nombres de todos los pacientes en la lista, contotal() se encarga de contar a todos los pacientes, conniño() cuenta a los pacientes menores a 13 años, conjove() cuenta a los pacientes entre 13 y 24 años, conadul() cuanta a los pacientes mayores de 24 años, totalhom() obtiene el total de hombres en la lista de pacientes y totalmuj() a las mujeres pacientes.

El programa en Java esta compilado en NetBeans, que si no lo tienes te recomiendo que lo descargues aquí.

Aquí el código fuente:

Clase Nodo

class nodo
{
 String nomb,sex,domi; int edad, tel;
 nodo next;
 nodo ant;
 nodo(String n, String s, String d, int e, int t)
 {
  this.nomb=n; this.sex=s;this.domi=d;this.edad=e;this.tel=t;
  this.next=null;
  this.ant=null;
 }
}

Clase Pacientes

public class pacientes
{
 nodo primero;
 nodo ultimo;
 pacientes()
 {
  primero=null;
  ultimo=null;
 }

 public boolean estavacio()
 {
  if(primero==null) return true;
  else return false;
 }

 public pacientes alta(String dat,String dat2,
String dat3,int dat4,int dat5)
 {
  if(estavacio())
  {
   nodo nuevo=new nodo(dat,dat2,dat3,dat4,dat5);
   primero=nuevo;
   ultimo=nuevo;
  }
  else
  {
   nodo nuevo=new nodo(dat,dat2,dat3,dat4,dat5);
   ultimo.next=nuevo;
   nuevo.ant=ultimo;
   ultimo=nuevo;
  }
  return this;
 }


  public void listanombres()
 {
  nodo actual;
  actual=primero;
  while(actual!=ultimo)
  {
   System.out.println(actual.nomb);
   actual=actual.next;
  }
                System.out.println(actual.nomb);

 }

       double tnodos=0,niños=0,jove=0,adul=0,thom=0,tmuj=0,proniños=0,projove=0,pronadul=0,pronhom=0,promuj=0;

       public void contotal(nodo dat)
       {
           if(dat==null) return;
           tnodos=tnodos+1;
           contotal(dat.next);
       }

       public void conniño(nodo dat)
       {
           int n=13;
           if(dat==null) return;
           if(dat.edad<=n){
           niños=niños+1;}
           conniño(dat.next);
       }

       public void conjove(nodo dat)
       {
           int n=13,o=24;
           if(dat==null) return;
           if(dat.edad>n & dat.edad<o){
           jove=jove+1;}
           conjove(dat.next);
       }

        public void conadul(nodo dat)
       {
           int n=24;
           if(dat==null) return;
           if(dat.edad>=n){
           adul=adul+1;}
           conadul(dat.next);
       }

       public void totalhom(nodo dat)
       {
           if(dat==null) return;
           if(dat.sex.equals("masculino")){
           thom=thom+1;}
           totalhom(dat.next);
       }

       public void totalmuj(nodo dat)
       {
           if(dat==null) return;
           if(dat.sex.equals("femenino")){
           tmuj=tmuj+1;}
           totalmuj(dat.next);
       }

       public void conteo(){
           contotal(primero);
           conniño(primero);
           conjove(primero);
           conadul(primero);
           totalhom(primero);
           totalmuj(primero);
           proniños=niños/tnodos;
           projove=jove/tnodos;
           pronadul=adul/tnodos;
           pronhom=thom/tnodos;
           promuj=tmuj/tnodos;
           System.out.println("El Porcentaje:
\nDe niños es: "+proniños+"\nDe jovenes:"+projove+"\nDe adultos: "+pronadul+"\nDe hombres: "+pronhom+"\nDe mujeres:"+promuj);
       }

}

Clase Main

public class Main {

    public static void main(String[] args) {
       java.util.Scanner leer=new java.util.Scanner(System.in);
        pacientes x=new pacientes();
        int z;
        System.out.print("Ingrese el numero de Pacientes a capturar: ");
        z=leer.nextInt();
        for(int i=1;i<=z;i++){
        String n,s,b;int e,t;
        System.out.println("Ingrese Nombre de Paciente Numero "+i+":  ");
        n=leer.next();
        System.out.println("Ingrese Sexo: ");
        s=leer.next();
        System.out.println("Ingrese Domicilio: ");
        b=leer.next();
        System.out.println("Ingrese Edad: ");
        e=leer.nextInt();
        System.out.println("Ingrese Numero Telefonico: ");
        t=leer.nextInt();
        x.alta(n,s,b,e,t);
        }
        System.out.println("\nLista de General de Pacientes:");
     x.listanombres();
        System.out.println("Estadisticas");
        x.conteo();
    }

}

Código Fuente Java: Suma de Elementos de un Árbol Binario

2012-11-11T13:38:00.000-06:00

Este programa, es un árbol binario, que llenamos con números aleatorios a través de la función random, y realizamos un recorrido del árbol al mismo tiempo que vamos sumando sus elementos y almacenando el resultado en una variable para que posteriormente sea imprimida.

El programa esta constituido como lo han hecho los anteriores, una clase nodo, una clase árbol y una clase main.

El programa en Java esta compilado en NetBeans, que si no lo tienes te recomiendo que lo descargues aquí.

Código Fuente en Java de nuestro programa:

Clase Nodo

class nodo
{
    int dato;
    nodo der;
    nodo izq;
    nodo(int dat)
    {
        this.dato=dat;
        this.der=null;
        this.izq=null;
    }
}

Clase Arbol

public class arbol
{
    nodo raiz=null;
    public boolean tieneraiz()
    {
        if(raiz==null) return false;
        else return true;
    }

    public arbol alta(int dat)
    {
        if(!tieneraiz())
        {
            nodo nuevo=new nodo(dat);
            raiz=nuevo;
        }
        else
        {
            boolean izq;
            nodo actual=raiz;
            while(true)
            {
                if(actual.dato<dat) izq=false;
                else izq=true;
                if(!izq)
                {
                    if(actual.der==null)
                    {
                        nodo nuevo=new nodo(dat);
                        actual.der=nuevo;
                        break;
                    }
                    else actual=actual.der;
                }
                else
                {
                    if(actual.izq==null)
                    {
                        nodo nuevo=new nodo(dat);
                        actual.izq=nuevo;
                        break;
                    }
                    else actual=actual.izq;
                }
            }
        }return this;
    }

    public void imprimir()
    {
        ayudantePreorden(raiz);
    }

    public void ayudantePreorden(nodo dat)
    {
        if(dat==null)
                return;
        System.out.printf("%d ",dat.dato);
        ayudantePreorden(dat.der);
        ayudantePreorden(dat.izq);
    }

    public void mayor()
 {
  nodo actual;
  actual=raiz;
  while(actual.der!=null)
  {
   actual=actual.der;
  }
                System.out.println(actual.dato);

 }

    int suma,sumader,sumaizq,aux=0;

    public void ayudantesuma(nodo dat)
    {
        if(dat==null)
                return;
        suma=aux+dat.dato;
        aux=suma;
        ayudantesuma(dat.der);
        ayudantesuma(dat.izq);
    }
    public void sumaizquierda()
    {
        nodo dat=raiz;
        ayudantesuma(dat.der);
        sumaizq=suma;
        System.out.println(sumaizq);

    }

    public void sumaderecha()
    {
        aux=0;
        nodo dat=raiz;
        ayudantesuma(dat.izq);
        sumader=suma;
        System.out.println(sumader);

    }
    public void media()
    {
        double media,s1,s2,s3;
        s1=(double)(sumaizq);s2=(double)(sumader);s3=(double)(raiz.dato);
        media=(s1+s2+s3)/10;
        System.out.println("La media es: \n"+media);
    }
}

Clase Main

public class Main {

    
    public static void main(String[] args) {
       int[] a=new int[10];
       for(int i=0;i<=9;i++)
           a[i]=(int)(Math.random()*50);
       arbol x = new arbol();
       for(int i=0;i<10;i++)
           x.alta(a[i]);
       System.out.println("Los datos son: ");
       x.imprimir();
       System.out.println("\nEl numero mayor es: ");
       x.mayor();
       System.out.println("La suma de los numeros de la Izquierda es: ");
       x.sumaizquierda();
       System.out.println("La suma de los numeros de la Derecha es: ");
       x.sumaderecha();
       x.media();
    }

}

Código Fuente Java: Programa Árbol Binario

2012-11-11T13:11:00.000-06:00

Un árbol binario es una estructura de datos en la cual cada nodo siempre tiene un hijo izquierdo y un hijo derecho. No pueden tener más de dos hijos (de ahí el nombre "binario"). Si algún hijo tiene como referencia a null, es decir que no almacena ningún dato, entonces este es llamado un nodo externo. En el caso contrario el hijo es llamado un nodo interno. Usos comunes de los árboles binarios son los árboles binarios de búsqueda, los montículos binarios y Codificación de Huffman

El programa esta construido de la siguiente manera: consta de 3 clases, una llamada nodo donde alojamos la estructura de nuestro arbol, otra llamada arbol donde escribimos los métodos que manipulan a este, y una ultima llamada Main que alojara al método principal de nuestro programa que se encargara de controlar todo el programa.

El programa en Java esta compilado en NetBeans, que si no lo tienes te recomiendo que lo descargues aquí.

Aquí el código fuente de nuestro programa en Java:

Clase Nodo

class nodo
{
    int dato;
    nodo der;
    nodo izq;
    nodo(int dat)
    {
        this.dato=dat;
        this.der=null;
        this.izq=null;
    }
}

Clase Arbol

public class arbol
{
    nodo raiz=null;
    public boolean tieneraiz()
    {
        if(raiz==null) return false;
        else return true;
    }

    public arbol alta(int dat)
    {
        if(!tieneraiz())
        {
            nodo nuevo=new nodo(dat);
            raiz=nuevo;
        }
        else
        {
            boolean izq;
            nodo actual=raiz;
            while(true)
            {
                if(actual.dato<dat) izq=false;
                else izq=true;
                if(!izq)
                {
                    if(actual.der==null)
                    {
                        nodo nuevo=new nodo(dat);
                        actual.der=nuevo;
                        break;
                    }
                    else actual=actual.der;
                }
                else
                {
                    if(actual.izq==null)
                    {
                        nodo nuevo=new nodo(dat);
                        actual.izq=nuevo;
                        break;
                    }
                    else actual=actual.izq;
                }
            }
        }return this;
    }

    public boolean baja(int dat)
    {
        nodo actual=raiz, anterior=raiz, temp;
        while(true)
        {
            if(actual==null) break;
            if(actual.dato==dat) break;
            anterior=actual;
            if(actual.dato<dat) actual=actual.der;
            else actual=actual.der;
        }
        if(actual==null) return false;
        else
        {
            if(actual==raiz)
            {
                temp=actual.izq;
                raiz=raiz.der;
                anterior=raiz;
            }
            else
            if (anterior.der == actual)
            {
                temp=actual.izq;
                anterior=actual.der;
            }
            else
            {
             temp=actual.izq;
             anterior.der=actual.izq;
            }
            actual=new nodo();
            while(actual.izq!=null)
                actual=actual.izq;
            actual.izq=temp;
            return true;
        }
    }

    public void imprimirpreorden()
    {
        ayudantePreorden(raiz);
    }

    public void ayudantePreorden(nodo dat)
    {
        if(dat==null)
                return;
        System.out.printf("%d ",dat.dato);
        ayudantePreorden(dat.der);
        ayudantePreorden(dat.izq);
    }

    public void impririnorden(nodo dat)
    {
        if(dat!=null)
        {
            impririnorden(dat.izq);
            System.out.println(" "+dat.dato);
            impririnorden(dat.der);
        }
    }
}

Clase Main


public class Main {

   
    public static void main(String[] args) {
        java.util.Scanner leer=new java.util.Scanner(System.in);
        arbol x=new arbol();
        int z;
        System.out.print("Ingrese el numero de Datos a capturar: ");
        z=leer.nextInt();
        for(int i=1; i<=z;i++){
        int m;
        System.out.println("Ingrese Dato "+i+":  ");m=leer.nextInt();
        x.alta(m);
        }
        System.out.println("Valores Capturados en PreOrden:");
     x.imprimirpreorden();
        int q;
        System.out.print("\nIngrese dato a borrar: ");q=leer.nextInt();
     x.baja(q);
        System.out.println("\nDespues de borrar el dato "+q+" :");
     x.imprimir();
    }

}

Código Fuente Java: Programa de Lista Circular Doble

2012-11-11T02:16:00.000-06:00

Entre una Lista Doblemente Ligada (o Lista Doble) y una Lista Circular Doblemente Ligada (o Lista Circular doble) la diferencia es mínima.

La variante seria que ahora el elemento final de nuestra lista, que en este caso se llama ultimo, ya no apuntaría hacia NULL, sino que ahora se enlazaría hacia el elemento inicio, creando así un lasta circular.

El método de construcción de nuestro programa es similar a al usado en las listas anteriores, es decir, consta de 3 clases, una llamada nodo donde alojamos la estructura de nuestra lista, otra llamada listacirculardoble donde escribimos los métodos que manipularan nuestra lista, y una ultima llamada Mainlistacirculardoble que alojara al método principal de nuestro programa que se encargara de controlar la lista completa.

El programa en Java esta compilado en NetBeans, que si no lo tienes te recomiendo que lo descargues aquí.

Bueno para lo alagar demasiado la entrada a continuación el Programa:

Clase Nodo

class nodo
{
 int dato;
 nodo next;
 nodo ant;
 nodo(int a)
 {
  dato=a;
  ant=null;
  next=null;
 }
}

Clase listacirculardoble

public class listacirculardoble
{
 nodo primero;
 nodo ultimo;
 
 listacirculardoble()
 {
  primero=null;
  ultimo=null;
 }
 
 public boolean estavacio()
 {
  if(primero==null) return true;
  else return false;
 }
 
    public listacirculardoble alta(int dat)
    {
     if(estavacio())
     {
      nodo nuevo=new nodo(dat);
      primero=nuevo;
      ultimo=nuevo;
      nuevo.next=nuevo;
      nuevo.ant=nuevo;
     }
     else
     {
      nodo nuevo=new nodo(dat);
      ultimo.next=nuevo;
      nuevo.ant=ultimo;
      primero.ant=nuevo;
      nuevo.next=primero;
      ultimo=nuevo;
     }
     return this;
    }
    
    public boolean bajaxposicion(int dat)
    {
     nodo actual=primero;
     nodo anterior;
     nodo siguiente;
     for(int i=0;i<=dat;i++)
     {
      if(actual==ultimo)
      {
       if(i<dat) return false;
       else
       {
        if(i==dat)
        {
         anterior=actual.ant;
         anterior.next=primero;
         primero.ant=anterior;
         ultimo=anterior;
         return true;
        }
        
       }
      
      }
      else
      {
       if(dat==0)
       {
        siguiente=actual.next;
        siguiente.ant=ultimo;
        ultimo.next=siguiente;
        primero=siguiente;
        return true;
       }
       if(dat==i)
       {
        anterior=actual.ant;
        siguiente=actual.next;
        anterior.next=siguiente;
        siguiente.ant=anterior;
        return true;
       }
      }
      actual=actual.next;
     }
     return false;
    }
    
    
    public void imprimir()
 {
  nodo actual;
  actual=primero;
  while(actual!=ultimo)
  {
   System.out.println(actual.dato);
   actual=actual.next;
  }
        System.out.println(actual.dato);
                
 }
    
}

Clase Mainlistacirculardoble

public class Mainlistacirculardoble {

    public static void main(String[]args)
    {
     listacirculardoble x=new listacirculardoble();
     int a=5;
     int b=10;
     int c=15;
     int d=20;
     int e=25;
     int f=30;
     x.alta(a);
     x.alta(b);
     x.alta(c);
     x.alta(d);
     x.alta(e);
     x.alta(f);
     System.out.println("Valores iniciales:\n");
     x.imprimir();
     x.bajaxposicion(0);
     System.out.println("\nDespues de borrar la Posicion 3:\n");
     x.imprimir();
    }
}

[Código Fuente JAVA]: Lista Doble Agregar, Quitar e Impresión

2012-11-09T22:17:00.000-06:00

Ahora es el turno de las listas doblemente enlazadas. Este tipo de listas se diferencian de las simples en que, ahora cada nodo ademas de contener la un enlace a la dirección siguiente, tendrá una con la dirección del nodo anterior al actual.

La ventaja que nos proporciona este tipo de lista es que podemos recorrer la lista desde el nodo inicial al final y desde el final a el inicial.

Este programa esta dividido en 3 clases, clase nodo, clase listasdobles, y la clase principal main que contiene al método principal. dentro de la clase nodo se declara la estructura de la lista y dentro de la clase listasdobles encontramos el método agregar, borrar, imprimir de inicio a fin e imprimir de fin a inicio.

El programa en Java esta compilado en NetBeans, que si no lo tienes te recomiendo que lo descargues aquí.

El código de la clase nodo :

class nodo
{
	int dato;
	nodo next;
	nodo ant;
	nodo(int a)
	{
		this.dato=a;
		this.next=null;
		this.ant=null;
	}
}

El código de la clase listadobles :

public class listasdobles
{
	nodo primero;
	nodo ultimo;
	listasdobles()
	{
		primero=null;
		ultimo=null;
	}

	public boolean estavacio()
	{
		if(primero==null) return true;
		else return false;
	}

	public listasdobles alta(int dat)
	{
		if(estavacio())
		{
			nodo nuevo=new nodo(dat);
			primero=nuevo;
			ultimo=nuevo;
		}
		else
		{
			nodo nuevo=new nodo(dat);
			ultimo.next=nuevo;
			nuevo.ant=ultimo;
			ultimo=nuevo;
		}
		return this;
	}

	public listasdobles borrar(int a)
	{
		nodo w=primero;
		nodo y;
		for(int i=0;i<a;i++)
		{
			y=w.ant;
			w=w.next;
		}
		y=w.ant;
		return this;
	}

	public boolean delete(int num)
	{
		nodo anterior=null;
		nodo actual=primero;
		while(actual!=ultimo)
		{
			if(actual.dato==num)
			{
				if(anterior==null)
				{
					primero=actual.next;
					primero.ant=null;
				}
				else{
					anterior.next=actual.next;
					nodo temporal;
					temporal=actual.next;
					temporal.ant=anterior;
				}
				return true;
			}
			anterior=actual;
			actual=actual.next;
		}
		if(num==ultimo.dato)
		{
			ultimo=actual.ant;
			return true;
		}
		return false;
	}

        public void imprimir2()
	{
		nodo actual;
		actual=ultimo;
		while(actual!=primero)
		{
			System.out.println(actual.dato);
			actual=actual.ant;
		}
                System.out.println(actual.dato);

	}
        public void imprimir()
	{
		nodo actual;
		actual=primero;
		while(actual!=ultimo)
		{
			System.out.println(actual.dato);
			actual=actual.next;
		}
                System.out.println(actual.dato);
                
	}
}

El código de la clase Main :

public class Main {    
    public static void main(String[] args) {
       int b=5;
       int c=10;
       int d=15;
       int e=20;
       int f=25;
       listasdobles a=new listasdobles();
       a.alta(b);
       a.alta(c);
       a.alta(d);
       a.alta(e);
       a.alta(f);
       a.imprimir2();
       a.delete(25);
       a.imprimir2();
    }
}

[Código Fuente JAVA]: Lista Simple Agregar, Quitar e Impresión

2012-10-13T19:08:00.000-05:00

Este código es similar al anterior con la diferencia de que en este implementamos un nuevo método baja, el cual se encarga de quitar nodos de nuestra lista.

Podemos notar también que la estructura declarada en la clase nodo esta vez cuanta con mas elementos, lo que significa que podremos guardar mas información dentro de cada nodo de nuestra lista.

El programa en Java esta compilado en NetBeans, que si no lo tienes te recomiendo que lo descargues aquí.

Esta IDE (en español Entorno de Desarrollo Integrado o en ingles integrated development environment ), te hace mas amigable la vista del código, ademas de que te van indicando los errores casi simultáneamente a la escritura. Otra de sus ventajas es que facilita el desarrollo de una GUI (Interfaz Gráfica de Usuario).

El código fuente java:

Clase prog

class Nodo
{
 int id;
 String nom;
 int tel;
 Nodo next;
 Nodo(int _id, String _nom, int _tel)
 {
  this.id=_id;
  this.nom=_nom;
  this.tel=_tel;
  this.next=null;
 }
}

public class prog
{

    Nodo primero;
    Nodo ultimo;
    prog()
    {
     primero=null;
     ultimo=null;
    }
    public boolean estavacio()
    {
     if(primero==null)return true;
     else return false;
    }
    public prog alta(int _id, String _nom, int _tel)
    {
     if(estavaio())
     {
      Nodo nuevo=new Nodo(int _id, String _nom, int _tel);
      primero=nuevo;
      ultimo=nuevo;
     }
     else
     {
      Nodo nuevo=new Nodo(int _id, String _nom, int _tel);
      ultimo.next=nuevo;
      ultimo=nuevo;
     }
     return this;
    }
    public boolean baja(int _id)
    {
     Nodo anterior=null;
     Nodo actual=primero;
     while(actual!=ultimo)
     {
      if(actual id==_id)
      {
       if(anterior==null)
       {
        primero=actual.next;
       }
       else
       {
        if(actual.next==null) ultimo=anterior;
        else anterior.next=actual.next;
       }
       return true;
      }
      anterior=actual;
      actual=actual.next;
     }
     return false;
    }
    public void imprimir()
    {
      nodo actual;
      actual=primero;
      while(actual!=ultimo)
      {
       System.out.println(actual.dato);
       actual=actual.next;
      }
    }
    public static void main(String[]args)
    {
     int a;
     String b;
     int c;
     prog d=new prog();
     Sytem.out.println("Por favor indique su ID: ");
     a=sc.nextInt();
    
    }
}

[Código Fuente JAVA]: Lista Simple Agregar e Impresion

2012-10-13T18:37:00.000-05:00

Este pequeño programa en java nos permitirá crear una lista simple, la cual solo tiene un enlace apuntando hacia la siguiente dirección de memoria.

Usaremos una clase llamada nodo donde se declara la estructura de la lista, que en este caso contendrá un dato y un la dirección siguiente.

Dentro del código tenemos dos métodos: agregarnodo e imprimir, ademas de el método principal Main.

El programa en Java esta compilado en NetBeans, que si no lo tienes te recomiendo que lo descargues aquí.

Esta IDE (en español Entorno de Desarrollo Integrado o en ingles integrated development environment ), te hace mas amigable la vista del código, ademas de que te van indicando los errores casi simultáneamente a la escritura. Otra de sus ventajas es que facilita el desarrollo de una GUI (Interfaz Gráfica de Usuario).

Bueno sin mas que agregar el código:

Clase Main

class nodo
{
 int dato;
 nodo next;
 nodo(int a)
 {
  this.dato=a;
  this.next=null;
 }

}

public class Main {
nodo primero;
 nodo ultimo;
 Main()
        {
  primero=null;
  ultimo=null;
 }
 public boolean estavacio()
 {
  if(primero==null) return true;
  else return false;
 }
    public Main agregarnodo(int dat)
    {
     if(estavacio())
     {
      nodo nuevo=new nodo(dat);
      primero=nuevo;
      ultimo=nuevo;
     }
     else
     {
      nodo nuevo=new nodo(dat);
      ultimo.next=nuevo;
      ultimo=nuevo;
     }
     return this;
    }
     public void imprimir()
      {
      nodo actual;
      actual=primero;
      while(actual!=ultimo)
      {
       System.out.println(actual.dato);
       actual=actual.next;
      }
     }

 public static void main(String[]args)
 {
  int c=1;
  Main a=new Main();
  for(int i=1; i<=10; i++)
  {
   c*=i;
   a.agregarnodo(c);
  }
  a.imprimir();
 }
    

}

Código Fuente Java: La Sucesión de Fibonacci

2012-06-16T01:27:00.001-05:00

Código Fuente Java que resuelve la Sucesión de Fibonacci a través de la creación de una lista en Java. Estas Series fueron ideadas por Leonardo de Pisa.

La Sucesión de Fibonacci inicia con 1 y 1,y a partir de ahí cada elemento es la suma de los dos anteriores. Usualmente a los números de esta serie se les conoce como números de Fibonacci.

EL programa en Java esta compilado en NetBeans, que si no lo tienes te recomiendo que lo descargues aquí.

Esta IDE (en español Entorno de Desarrollo Integrado o en ingles integrated development environment ), te hace mas amigable la vista del código cuando programas, ademas de que te van indicando los errores casi inmediatamente, otra de sus ventajas es que facilita el desarrollo con GUI (Interfaz Gráfica de Usuario).

Este Código Fuente Java resulta un poco mas complejo que los anteriores aquí vistos, puesto que en este caso controlaremos los métodos de una clase (en este caso la clase lista en Java ) a través de una clase principal( en este caso fibonacci), y por ultimo la clase nodo es la que nos permitirá crear los nodos necesarios en nuestra lista en Java.

Bueno aquí el Código Fuente Java de la clase nodo:

class nodo
{
      int dato;
      nodo next;
      nodo (int a)
      {
            this.dato=a;
            this.next=null;
      }
}

Ahora el Código Fuente Java de la clase lista:

public class listas
{
      nodo primero;
      nodo ultimo;
      listas()
      {
            primero=null;
            ultimo=null;
      } 

      public boolean estavacio()
      {
            if(primero==null) return true;
            else return false;
      }

      public listas alta(int dat)
      {
            if(estavacio())
            {
                  nodo nuevo=new nodo(dat);
                  primero=nuevo;
                  ultimo=nuevo;
            }
            else
            {
                  nodo nuevo=new nodo(dat);
                  ultimo.next=nuevo;
                  ultimo=nuevo;
            }
            return this;
      }

      public boolean baja(int dat)
      {
            nodo anterior=null;
            nodo actual=primero;
            while(actual!=ultimo)
            {
            if(actual.dato==dat)
                  {
                        if(anterior==null)
                        {
                              primero=actual.next;
                        }
                        else
                        {
                              if(actual.next==null)
                              {
                                    ultimo=anterior;
                              }
                              else
                              {
                                    anterior.next=actual.next;
                              }
                        }
                        return true;
                  }
                  anterior=actual;
                  actual=actual.next;
            }
            return false;
      } 

      public void imprimir()
      {
            nodo actual;
            actual=primero;
            while(actual!=ultimo)
            {
                  if(actual.dato%2==0) System.out.println(actual.dato+" Es par");
                  else System.out.println(actual.dato+" Es impar");
                  actual=actual.next;
            }
      } 

       public boolean esprimo(int x)
      {
            int y=1;
            for(int i=2;i<10;i++)
            {
                  y=x%i;
                  if(y!=0) return true;
                  else return false;
            }
            return false;
      }
 
      public void imprimo()
      {
            nodo actual;
            actual=primero;
            while(actual!=ultimo)
            {
                  for (int i=actual.dato; i>=1; i--)
            {
                  if(esprimo(i))
                  {
                        if(i!=actual.dato)
                        {
                              System.out.println(i+":Es el numero primo inmediato inferior al fibonacci:"+actual.dato);
                              break;
                        }
                  }
            }
            actual=actual.next;   
            }
      }
}

Y por ultimo el Código Fuente Java de la clase principal fibonacci:

public class fibanocci {
    public static void main(String[]args)
    {
     listas a=new listas();
     int d=1;
     int b=1;
     int f=0;
     a.alta(d);
     a.alta(b);
     for(int i=0;i<=10;i++)
     {
     f=d+b;
     a.alta(f);
     d=b;
     b=f;
     }
     a.imprimir();
     a.imprimo();
    }
}

Es importante que las tres clases se encuentren en la misma carpeta al momento de compilar y ejecutar el Código Fuente Java que resuelve la Sucesión de Fibonacci.

Código Fuente Java: Torres de Hanoi

2012-06-16T00:55:00.002-05:00

Este código fuente Java, es para recrear el famoso rompecabezas o juego del matematico Édouard Lucas:

Las Torres de Hanoi.

Para los que no lo saben, se trata de un juego matematicose trata de un juego de ocho discos de radio creciente que se apilan insertándose en una de las tres estacas de un tablero. El objetivo del juego es crear la pila en otra de las estacas siguiendo dos reglas: Las piezas se trasladan de una en una y no se puede colocar una pieza mayor sobre una menor. El problema es muy conocido en la ciencia de la computación y aparece en muchos libros de texto como introducción a la teoría de algoritmos.

El problema de las Torres de Hanói es curiosísimo porque su solución es muy rápida de calcular, pero el número de pasos para resolverlo creceexponencialmente conforme aumenta el número de discos. Existen algunas versiones del problema con un número diferente de varillas. Aunque se conocen algoritmos eficientes que resuelven el problema con 3 varillas de manera óptima, no se han encontrado aún sus contrapartidas para cualquier número (N igual o superior a 3) de ellas.

EL programa en Java esta compilado en NetBeans, que si no lo tienes te recomiendo que los descargues aquí. Esta IDE (en español Entorno de Desarrollo Integrado o en ingles integrated development environment ), te hace mas amigable la vista del código cuando programas, ademas de que te van indicando los errores casi inmediatamente, otra de sus ventajas es que facilita el desarrollo con GUI (Interfaz Gráfica de Usuario).

Aquí el código fuente Java de la clase torres:

class torres
{
        private static int movimientos=0;
        public static int mover(int n, char a,char b, char c)
        {
                if(n>0){
                        mover(n-1, a,c,b);
                        System.out.println("mover disco "+a+" a "+c);
                        movimientos++;
                        mover(n-1,b,a,c);
   }
                return movimientos;
         }
}

Aquí el código fuente Java de la clase Hanoi:

public class Hanoi
{

    public static void main(String[]args)
    {
     java.util.Scanner leer = new java.util.Scanner(System.in)
     int movimientos;
     System.out.println("Numero de discos: ");
     int n=leer.nextInt();
     movimientos = torres.mover(n, 'A', 'B', 'C');
     System.out.println("\nMovimientos efectuados: "+movimientos);
    }  
   
}

Código Fuente Java: Numero Par o Primo

2012-06-16T00:20:00.004-05:00

Codigo fuente Java que te permite ingresar un numero y te dirá si este es Par o Primo.

El código fuente Java la verdad que es muy sencillo, pero no faltará a quien le sirva el método para emplearlo en un programa mas grande, donde tengas que disponer de un método propio para evaluar la condición de un numero (Par o Primo).

Bueno el Código Fuente Java:

public class Numeroprimo{
 public static void main(String[] args){
  java.util.Scanner leer = new java.util.Scanner(System.in)
  int x=leer.nextInt();
  int y=0;
  for (int i=2; i&lt,;x; i++)
  {
   y= x%i;
   if(y==0){
    System.out.println(x+": Este Numero es Par");
    break;
    }
  }
  if(y!=0){
    System.out.println(x+": Este Numero es Primo");
   }
 }
}

Código Fuente Java: Factorial

2012-06-15T23:51:00.000-05:00

Otro sencillo programa en Java, que seguramente será una tarea para los que estudia algo relacionado con Java. Este Programa en Java lo que hace es que le ingresas un valor y te calcula el factorial de este.

Aquí el codigo Java de la clase Ma:in:

public class factotial {
     static long factorial(int v) {
            if (v>1)
                   return(v*factorial(v-1));
            return(1);
     }
     public static void main(String[] args) {
       java.util.Scanner leer = new java.util.Scanner(System.in)
       int k=leer.nextInt();
          System.out.println(factorial(k));
     }
}

Es importante resaltar que cuando programamos en Java el nombre del archivo código fuente Java (nombredelarchivo.java) deberá coincidir con el nombre de la clase de ese archivo.

Código Fuente Java: Programa Es Vocal o Consonante

2012-06-15T23:11:00.002-05:00

Este es un Pequeño Programa en Java, que si estas en una materia de Programación Orientada a Objetos, de seguro te lo van a pedir de tarea.

EL programa en Java  esta compilado en NetBeans, que si no lo tienes te recomiendo que los descargues aquí. Esta IDE (en español Entorno de Desarrollo Integrado o en ingles integrated development environment ), te hace mas amigable la vista del código cuando programas, ademas de que te van indicando los errores casi inmediatamente, otra de sus ventajas es que facilita el desarrollo con GUI (Interfaz Gráfica de Usuario).

En caso de que no quieras instalar NetBeans entonces pues puedes compilarlo con JCreator.

Bueno sin mas preámbulo el programa. Este Programa en Java  lo que haces es que le ingresas un valor char y el programa en java te dice si es vocal o consonante.

El Código Java  del Programa:

public class bocalono {
      public static void main(String[] args) {
    java.util.Scanner leer = new java.util.Scanner(System.in)
    char a=leer.nextChar();
    switch(a){
        case 'a':
            System.out.println(a+" es vocal");
            break;
        case 'e':
            System.out.println(a+" es vocal");
            break;
        case 'i':
            System.out.println(a+" es vocal");
            break;
        case 'o':
            System.out.println(a+" es vocal");
            break;
        case 'u':
            System.out.println(a+" es vocal");
            break;
        default:
            System.out.println(a+" es consonante");
    }
  }
}

App Creada por Egresado ESIME Culhuacan

2012-03-13T08:51:00.003-06:00

Un egresado de la Escuela Superior de Ingeniería Mecánica y Eléctrica Unidad Culhucan se dio a la tarea de facilitar la vida de aquellas personas que gustan de los placeres carnales (sexo) a cualquier hora del día, su nombre Mario Alba.

Hoteles Paco Heart es tu guia de hoteles y moteles para tu iPhone y iPod.

Cuantas veces te ha pasado que no sabes a que hotel ir con tu pareja. No sabes si tiene jacuzzi. O cuanto te puede costar.

Tienes que estar preguntando con tus amigos recomendaciones.

Y Lo mas importante no sabes como llegar a ese motel. Con Hoteles Paco Heart eso ha terminado:

Guia de Hoteles y Moteles de Paso del Distrito Federal y Area Metropolitana (DF y Estado de México).

Si quieres tener una noche de pasión nosotros te decimos donde.

- Te damos los 5 hoteles y Moteles mas cercanos a tu posicion.

- Google maps y streetviews de cada hotel para que puedas trazar la ruta y nunca perderte.

- Rankings por hotel, puedes votar el hotel favorito y ver las calificaiones de otros usuarios para saber si la velada sera fabulosa en ese lugar.

- Precios por habitación: Te damos los precios de cada habitacion que ofrece el hotel.

- Restaurante y otros servicios: Te decimos si el hotel al que planeas ir tiene servicio de restaurante. Cochera para guardar tu auto (villas), y muchos servicios mas.

- Telefonos del hotel: Las cosas cambian muy rapido hoy en dia, si tienes dudas de alguna habitación, o quieres saber la promoción del dia, te facilitamos el telefono directo de cada hotel en la ciudad de mexico.

- Favoritos: Puedes guardar en tus favoritos los hoteles que mas te gusta.

- No necesitas conexion de internet para la mayoria de funciones, asi que funcionará perfecto en tu ipod.

Con esta guía de Hoteles y Moteles, Siempre sabrás a cual ir, en cualquier momento y en cuestión de segundos..

Sin mas que agregar aquí el enlace:

Hoteles Paco Heart

Objetivo de este Blog

2012-03-07T09:55:00.001-06:00

Este Blog se creó con el fin de proporcionar a Estudiantes de Ingeniería algunas herramientas que posiblemente serán de gran utilidad.

La principal especialidad de ingeniería a la que va dirigida es la de Computación, sin embargo, al ser una ingeniería implica las ciencias fundamentales de una ingeniería: Física, Química, Matemáticas. Entonces si una carrera que se dice llamar a si misma ingeniería no tiene estas tres ciencias significa que es cualquier otra cosa menos ingeniería.

Espero les sea de Utilidad.