Cesar Systems

en C#, Cursis C++, Cursos gratuitos C++, MANEJO DE ARCHIVOS C++

Otro trabajo que nos dejaron en vacaciones
Ojo poner los archivos con extensión .H en la carpeta INCLUDE de Borland
CONDUCTO.H

   1: /******************************************************************************************************************************

   2:  *                                                                                                                            *

   3:  *                               25 de marzo de 2010                                                                          *

   4:  *                                                                                                                            *

   5:  *                 El programa guarda los datos del conductor en un archivo binario                                           *

   6:  *                                                                                                                            *

   7:  * Programador Julio Cesar Leyva Rodriguez                Instituto Tecnologico de Los Mochis                                 *

   8:  *                                                                                                                            *

   9:  ******************************************************************************************************************************/

  10: #include

  11: #include

  12: #include

13:

  14: struct registro

  15: {

  16: int     numeroC;

  17: char     nombre[10];

  18: char     domicilio[20];

  19: float     estatura;

  20: char     activo;

  21: }conductores;

22:

  23: void registrarConductor()

  24: {

  25: clrscr();

  26: printf("tt REGISTRO DE CONDUCTORES n");

  27: cout<<"Numero de conductor ";         cin>>conductores.numeroC;

  28: cout<<"Nombre ";                gets(conductores.nombre);

  29: cout<<"Domicilio ";            gets(conductores.domicilio);

  30: cout<<"Estatura ";            cin>>conductores.estatura;

31:

  32: conductores.activo='a';

33:

  34: FILE *registro;

35:

  36: registro=fopen("conductores.dat","ab");

  37: fwrite(&conductores,sizeof(conductores),1,registro);

  38: fclose(registro);

  39: }

40:

  41: void reporteConductores()

  42: {

  43: clrscr();

  44: FILE *rep;

45:

  46: rep=fopen("conductores.dat","rb");

  47: fread(&conductores,sizeof(registro),1,rep);

  48: printf("# CONDUCTOR  tt NOMBRE tt DOMICILIO t ESTATURA");

49:

  50:     do

  51:     {

  52:     if(conductores.activo=='a')

  53:             {

  54:         cout<<"n"<<conductores.numeroC<<"ttt "<<conductores.nombre<<"ttt "<<conductores.domicilio<<"tt "<<conductores.estatura;

  55:             }

  56:     fread(&conductores,sizeof(registro),1,rep);

  57:     }while(!feof(rep));

  58: fclose(rep);

  59: getch();

  60: }

61:

  62: void consultaC(int n)

  63: {

  64: clrscr();

  65: FILE *rep;

66:

67:

  68: rep=fopen("conductores.dat","rb");

69:

  70: fseek(rep,(n-1)*(sizeof(conductores)),SEEK_SET);

  71: fread(&conductores,(n)*(sizeof(conductores)),1,rep);

72:

  73: printf("# CONDUCTOR  tt NOMBRE tt DOMICILIO t ESTATURA");

  74: if(conductores.activo=='a')

  75:     {

  76:     cout<<"n"<<conductores.numeroC<<"ttt "<<conductores.nombre<<"ttt "<<conductores.domicilio<<"tt "<<conductores.estatura;

  77:         }

  78: else

  79:     {

  80:     cout<<"n El conductor no exite";

  81:         }

  82: fclose(rep);

  83: }

84:

85:

86:

  87: void eliminarC()

  88: {

  89: FILE *reg;

  90: int d;

91:

  92: cout<<"Inserte el conductor que desee dar de baja: ";    cin>>d;

93:

  94: reg=fopen("conductor.dat","rb+");

95:

  96: fseek(reg,(d-1)*(sizeof(conductores)),SEEK_SET);

  97: fread(&conductores,(d)*(sizeof(conductores)),1,reg);

98:

99:

 100: conductores.activo='b';

 101:

 102: fseek(reg,(d-1)*(sizeof(conductores)),SEEK_SET);

 103: fwrite(&conductores,sizeof(conductores),1,reg);

 104: fclose(reg);

 105: }

 106:

 107:

 108: void menuC()

 109: {

 110: conductores.activo=NULL;

 111: int op;

 112: int b;

 113: while(op!=5)

 114:     {

 115:     clrscr();

 116:     gotoxy(25,1);    cout<<"REGISTRO DE CONDUCTORES";

 117:     gotoxy(1,3);    cout<<"1.- Registrar conductor";

 118:     gotoxy(1,5);    cout<<"2.- Reporte";

 119:     gotoxy(1,7);    cout<<"3.- Consulta";

 120:     gotoxy(1,9);    cout<<"4.- Eliminar";

 121:     gotoxy(1,11);    cout<<"5.- Regresar";

 122:     gotoxy(1,14);    cout<<"t Eliga una opcion [   ]";

 123:     gotoxy(24,14);    cin>>op;

 124:

 125:     switch(op)

 126:                 {

 127:         case 1:

 128:             registrarConductor();

 129:

 130:             break;

 131:         case 2:

 132:             reporteConductores();

 133:                         break;

 134:         case 3:

 135:             clrscr();

 136:             cout<<"Inserte el numero de conductor que desee consultar ";    cin>>b;

 137:             consultaC(b);

 138:                         getch();

 139:             break;

 140:         case 4:

 141:             clrscr();

 142:                         eliminarC();

 143:                 break;

 144:

 145:         }

 146:     }

 147: }

 148: void eslogan()

 149: {

 150: cout<<"   ******      **     *******   *******   ******** *******       **    ";

 151: cout<<"n  **////**    ****   /**////** /**////** /**///// /**////**     ****   ";

 152: cout<<"n **    //    **//**  /**   /** /**   /** /**      /**   /**    **//**  ";

 153: cout<<"n/**         **  //** /*******  /*******  /******* /*******    **  //** ";

 154: cout<<"n/**        **********/**///**  /**///**  /**////  /**///**   **********";

 155: cout<<"n//**    **/**//////**/**  //** /**  //** /**      /**  //** /**//////**";

 156: cout<<"n //****** /**     /**/**   //**/**   //**/********/**   //**/**     /**";

 157: cout<<"n  //////  //      // //     // //     // //////// //     // //      // ";

 158: }

 159:

AUTOMOVI.H

   1: /************************************************************************************************************

   2:  *                                                                                                          *

   3:  *                                              25 DE MARZO DE 2010                                         *

   4:  *                                                                                                          *

   5:  *  Programa que almacena los datos de los diferentes tipos de carros y los guarda en un archivo binario    *

   6:  *                                                                                                          *

   7:  *  Programador Julio Cesar Leyva Rodriguez            Instituto Tecnologico de Los Mochis                  *

   8:  *                                                                                                          *

   9:  ************************************************************************************************************/

10:

  11: #include

  12: #include

  13: #include

  14: #include

15:

  16: /** Estructura de los datos de los datos */

  17: struct reg

  18: {

  19: int numeroV;

  20: char marca[10];

  21: int anio;

  22: char color[10];

  23: int matricula;

  24: char activo;

  25: }automoviles;

26:

27:

  28: /** Funcion para registrar los datos en el archivo */

  29: void registrar()

  30: {

31:

  32: clrscr();

  33: printf("tt REGISTRO DE AUTOS n");

  34: cout<<"Numero de vehiculo ";         cin>>automoviles.numeroV;

  35: cout<<"Marca ";                    gets(automoviles.marca);

  36: cout<<"Año ";                cin>>automoviles.anio;

  37: cout<<"Matricula ";                     cin>>automoviles.matricula;

  38: cout<<"Color ";                gets(automoviles.color);

39:

  40: automoviles.activo='a';              //Marca que el archivo no esta eliminado logicamente

41:

42:

  43: FILE *registro1;

44:

  45: registro1=fopen("automoviles.dat","ab+");

  46: fseek(registro1,(automoviles.numeroV)-1*(sizeof(automoviles)),SEEK_SET);     //Posicionar el puntero en un lugar definido por la variable vehiculoV

  47: fwrite(&automoviles,sizeof(automoviles),1,registro1);                        //Escrive en el archivo

  48: fclose(registro1);

49:

  50: }

51:

  52: /** Muestra todos los registros del archivo en forma de reporte */

  53: void reporte()

  54: {

  55: clrscr();

  56: FILE *rep;

57:

  58: rep=fopen("automoviles.dat","rb+");

  59: fread(&automoviles,sizeof(automoviles),1,rep);

  60: printf("# VEHICULO tt MARCA tt AÑO t MATRICULA t COLOR");

61:

  62:     do

  63:     {

  64:     if(automoviles.activo=='a')

  65:         {

  66:         cout<<"n "<<automoviles.numeroV<<"t tt "<<automoviles.marca<<"tt "<<automoviles.anio<<"t "<<automoviles.matricula<<"tt "<<automoviles.color;

  67:         }

  68:     fread(&automoviles,sizeof(automoviles),1,rep);

  69:     }while(!feof(rep));

  70: fclose(rep);

  71: getch();

  72: }

73:

  74: /** Consulta un solo registro en el archivo */

  75: void consultaVehiculo(int n)

  76: {

  77: FILE *rep;

78:

79:

80:

  81: rep=fopen("automoviles.dat","rb");

82:

  83: fseek(rep,(n-1)*(sizeof(automoviles)),SEEK_SET);

  84: fread(&automoviles,(n)*(sizeof(automoviles)),1,rep);

85:

  86: printf("n # VEHICULO tt MARCA tt AÑO t MATRICULA t COLOR");

  87: if(automoviles.activo=='a')

  88:     {

  89:     cout<<"n "<<automoviles.numeroV<<"t tt "<<automoviles.marca<<"tt "<<automoviles.anio<<"t "<<automoviles.matricula<<"tt "<<automoviles.color;

  90:     }

  91: else

  92:     {

  93:     cout<<"n El automovil no existe";

  94:     }

  95: fclose(rep);

  96: }

97:

  98: /* Modifica un registro señalado */

  99: void modificar()

 100: {

 101: clrscr();

 102: FILE *reg;

 103: int d;

 104:

 105: cout<<"Inserte el dato que desee modificar: ";    cin>>d;

 106:

 107: reg=fopen("automoviles.dat","rb+");

 108:

 109: printf("tt REGISTRO DE AUTOS n");

 110: cout<<"Numero de vehiculo ";     cin>>automoviles.numeroV;

 111: cout<<"Marca ";                gets(automoviles.marca);

 112: cout<<"Año ";            cin>>automoviles.anio;

 113: cout<<"Matricula ";        cin>>automoviles.matricula;

 114: cout<<"Color ";            gets(automoviles.color);

 115:

 116: automoviles.activo='a';

 117:

 118: fseek(reg,(d-1)*(sizeof(automoviles)),SEEK_SET);

 119: fwrite(&automoviles,sizeof(automoviles),1,reg);

 120: fclose(reg);

 121: }

 122:

 123: /* Elimina el registro seleccionado "logicamente" */

 124: void eliminar()

 125: {

 126: FILE *reg;

 127: int d;

 128:

 129: cout<<"Inserte el registro que desee Eliminar: ";    cin>>d;

 130:

 131: reg=fopen("automoviles.dat","rb+");

 132:

 133: fseek(reg,(d-1)*(sizeof(automoviles)),SEEK_SET);

 134: fread(&automoviles,(d)*(sizeof(automoviles)),1,reg);

 135:

 136:

 137: automoviles.activo='b';

 138:

 139: fseek(reg,(d-1)*(sizeof(automoviles)),SEEK_SET);

 140: fwrite(&automoviles,sizeof(automoviles),1,reg);

 141: fclose(reg);

 142: }

 143:

 144:

 145: /* Menu de opciones */

 146: void menuA()

 147: {

 148: int a;

 149: int op;

 150: while(op!=5)

 151:         {

 152:     automoviles.activo=NULL;

 153:         clrscr();

 154:     gotoxy(25,1);    cout<<"REGISTRO DE AUTOMOTORES";

 155:     gotoxy(1,3);    cout<<"1.- Registrar automotor";

 156:     gotoxy(1,5);    cout<<"2.- Reporte";

 157:     gotoxy(1,7);    cout<<"3.- Consultar";

 158:     gotoxy(1,9);    cout<<"4.- Eliminar";

 159:         gotoxy(1,11);    cout<<"5.- Regresar";

 160:     gotoxy(1,14);    cout<<"t Eliga una opcion [   ]";

 161:     gotoxy(23,14);    cin>>op;

 162:     cout<<"n";

 163:         eslogan();

 164:

 165:     switch(op)

 166:                 {

 167:         case 1:

 168:             registrar();

 169:

 170:             break;

 171:         case 2:

 172:             reporte();

 173:                         break;

 174:         case 3:

 175:             clrscr();

 176:                  cout<<"Inserte el numero de automovil que desee consultar";    cin>>a;

 177:             consultaVehiculo(a);

 178:                         getch();

 179:             break;

 180:         case 4:

 181:             clrscr();

 182:                         eliminar();

 183:                 break;

 184:

 185:         }

 186:     }

 187: }

 188:

EVENTO.H

   1: /******************************************************************************************************************************

   2:  *                                                                                                                            *

   3:  *                               25 de marzo de 2010                                                                            *

   4:  *                                                                                                                            *

   5:  *        Elprograma graba el folio y el numero de conductor y vechiculo para consultar sus datos y registrar sus tiempo         *                                          *

   6:  *                                                                                                                            *

   7:  * Programador Julio Cesar Leyva Rodriguez                Instituto Tecnologico de Los Mochis                                   *

   8:  *                                                                                                                            *

   9:  ******************************************************************************************************************************/

  10: #include

11:

  12: struct evento

  13: {

  14: int folio;

  15: int nC;

  16: int nV;

  17: int tiempo;

  18: }carrera;

19:

20:

21:

  22: void ultimo();

23:

24:

  25: void borrar()

  26: {

  27: carrera.folio=NULL;

  28: carrera.nC=NULL;

  29: carrera.nV=NULL;

  30: carrera.tiempo=NULL;

  31: }

  32: //REGISTRAR AUTO Y CONDUCTOR

33:

  34: void registrarParticipante()

  35: {

36:

  37: borrar();

  38: FILE *e;

  39: FILE *a;

  40: int size;

41:

  42: borrar();

  43: e=fopen("evento.dat","ab+");

  44: a=fopen("evento.dat","rb+");

45:

46:

  47: size=sizeof(carrera);

48:

  49: fseek(a,-size,SEEK_END);

  50: fread(&carrera,size,1,a);

51:

  52: carrera.tiempo=NULL;

  53: carrera.folio=(carrera.folio)+1;

54:

  55: cout<<"nINSERTE EL NUMERO DEL PILOTO ";    cin>>carrera.nC;

56:

  57: cout<<"nINSERTE EL NUMERO DEL VEHICULO ";    cin>>carrera.nV;

58:

  59: fwrite(&carrera,sizeof(carrera),1,e);

60:

  61: fclose(e);

  62: fclose(a);

63:

  64: }

65:

66:

67:

  68: //ULTIMO REGISTRO

69:

  70: void ultimo()

  71: {

  72: FILE *final;

73:

  74: borrar();

  75: final=fopen("evento.dat","ab+");

76:

  77: do

  78:     {

  79:     fread(&carrera,sizeof(carrera),1,final);

  80:     }while(!feof(final));

81:

  82: }

83:

  84: //REPORTE

85:

  86: void reporteEvento()

  87: {

  88: borrar();

  89: FILE *reporte1;

90:

  91: reporte1=fopen("evento.dat","rb+");

92:

  93: do

  94:     {

  95:         if(carrera.folio!=NULL)

  96:             {

  97:             cout<<"n"<<"FOLIO "<<carrera.folio<<" NUMERO DE VEHICULO "<<carrera.nV<<" NUMERO DE CONDUCTOR "<<carrera.nC<<" TIEMPO "<<carrera.tiempo ;

  98:             }

  99:     fread(&carrera,sizeof(carrera),1,reporte1);

 100:     }while(!feof(reporte1));

 101: }

 102:

 103:

 104:

 105: void registrarTiempo()

 106: {

 107: FILE *tiempo;

 108: tiempo=fopen("evento.dat","rb+");

 109: int folio;

 110:

 111: borrar();

 112: cout<<"nnINSERTE EL FOLIO DEL PILOTO QUE DESEE INGRESAR EL TIEMPO ";

 113: cin>>folio;

 114:

 115: fseek(tiempo,(folio-1)*(sizeof(carrera)),SEEK_SET);

 116: fread(&carrera,sizeof(carrera),1,tiempo);

 117:

 118: cout<<"nnINGRESE EL TIEMPO ";cin>>carrera.tiempo;

 119:

 120: fseek(tiempo,(folio-1)*(sizeof(carrera)),SEEK_SET);

 121: fwrite(&carrera,sizeof(carrera),1,tiempo);

 122: fclose(tiempo);

 123: }

 124:

 125:

 126: /* Menu de opciones */

 127: void menuE()

 128: {

 129: int a;

 130: int op;

 131: while(op!=5)

 132:     {

 133:     automoviles.activo=NULL;

 134:     clrscr();

 135:     gotoxy(25,1);    cout<<"EVENTO";

 136:     gotoxy(1,3);    cout<<"1.- Registrar participante";

 137:     gotoxy(1,5);    cout<<"2.- Reporte";

 138:     gotoxy(1,7);    cout<<"3.- Modificar tiempo";

 139:     gotoxy(1,9);    cout<<"4.- Consulta participante";

 140:     gotoxy(1,11);    cout<<"5.- Regresar";

 141:     gotoxy(1,13);    cout<<"t Eliga una opcion [   ]";

 142:     gotoxy(26,13);    cin>>op;

 143:

 144:     switch(op)

 145:         {

 146:         case 1:

 147:             clrscr();

 148:             registrarParticipante();

 149:             getch();

 150:             break;

 151:         case 2:

 152:             reporteEvento();

 153:             getch();

 154:             break;

 155:         case 3:

 156:             clrscr();

 157:             registrarTiempo();

 158:             getch();

 159:             break;

 160:

 161:         case 4:

 162:             cout<<"n INSERTE EL NUMERO DEL PARTICIPANTE QUE DESEE CONSULTAR ";     cin>>a;

 163:             consultaVehiculo(a);

 164:             cout<<"n";

 165:             getch();

 166:             consultaC(a);

 167:             cout<<"nPresione cualquier tecla para continuar";

 168:             getch();

 169:             break;

 170:         case 5:

 171:                     break;

 172:         default:

 173:             cout<<"OPCION NO VALIDA";

 174:             getch();

 175:             break;

 176:         }

 177:     }

 178: }

 179:

VACACION.CPP

   1: /******************************************************************************************************************************

   2:  *                                                                                                                            *

   3:  *                                   11 de abril de 2010                                                                      *

   4:  *                                                                                                                            *

   5:  *                 Paquete de programas para el proyecto de la carrera                                                        *

   6:  *                                                                                                                            *

   7:  * Programador Julio Cesar Leyva Rodriguez                Instituto Tecnologico de Los Mochis                                 *

   8:  *                                                                                                                            *

   9:  ******************************************************************************************************************************/

  10: #include

  11: #include

  12: #include

  13: #include

14:

15:

  16: void main()

  17: {

  18: int op;

  19: while(op!=4)

  20:     {

  21:     clrscr();

  22:     eslogan();

  23:     gotoxy(25,15);    cout<<"PRINCIPAL";

  24:     gotoxy(1,18);    cout<<"1.- Vehiculos";

  25:     gotoxy(1,20);    cout<<"2.- Conductores";

  26:     gotoxy(1,22);    cout<<"3.- Evento";

  27:     gotoxy(1,24);    cout<<"4.- Salir";

  28:     gotoxy(1,26);    cout<<"t Eliga una opcion [   ]";

  29:     gotoxy(22,26);    cin>>op;

30:

  31:     switch(op)

  32:         {

  33:         case 1:

  34:             clrscr();

  35:             menuA();

36:

  37:             break;

  38:         case 2:

  39:             menuC();

  40:                         break;

  41:         case 3:

  42:             clrscr();

  43:             menuE();

  44:             break;

  45:         case 4:

  46:             clrscr();

  47:             break;

  48:         case 5:

  49:             cout<<"nOPCION INCORRECTA";

  50:             break;

51:

  52:         }

  53:     }

  54: }

FRACCIONES EN JAVA

en cursos gratuitos java, cursos java, FUNCIONES JAVA, FUNCIONES MATEMATICAS JAVA, Java, JAVA FRACCIONES, javax.swing.JOptionPane

Les dejo un apunte donde manejamos fracciones

   1: package unidad3;

2:

   3: import javax.swing.JOptionPane;

4:

   5: public class Fraccion

   6: {

   7: private int num;

   8: private int den;

9:

  10: Fraccion()

  11:     {

  12:     num=0;

  13:     den=1;

  14:     }

15:

  16: public Fraccion(int num, int den)

  17:     {

  18:     super();

  19:     this.num = num;

  20:     this.den = den;

  21:     }

22:

  23: /** No la uses no funciona a veces el programa se cicla con esta funcion */

  24: public void divisores()

  25:     {

  26:     int numeroPrimo=2;

  27:     int numero=den;

  28:     while(numero!=1)

  29:         {

  30:         if(numero%numeroPrimo==0)

  31:             {

  32:             numero=numero/numeroPrimo;

  33:             System.out.println("divicion entre numero primo es "+numeroPrimo);

  34:             }

  35:         numeroPrimo++;

36:

  37:         }

38:

  39:     }

  40: /*Maximo común divisor. Busca el numero de mayor valor que pueda dividir al numerador y denominador de la fraccion con la condicion de que no deje residuo */

  41: public int mcd()

  42:     {

  43:     int a=num;

  44:     int b=den;

  45:     int n=1;

  46:     int z=1;;

  47:     if(a>b)

  48:         {

  49:         while(z<=b)

  50:             {

  51:             if(a%z==0 && b%z==0)

  52:                 {

  53:                 n=z;

  54:                 }

  55:             z++;

  56:             }

  57:         }

  58:     if(a<b)

  59:         {

  60:         while(z<=a)

  61:             {

  62:             if(a%z==0 && b%z==0)

  63:                 {

  64:                 n=z;

  65:                 }

  66:             z++;

  67:             }

  68:         }

  69:     return n;

  70:     }

  71: /**Simplifica la fraccion a numeros mas pequeños pero equivalentes */

  72: public void simplificar()

  73:     {

  74:     int ns=num/mcd();

  75:     int ds=den/mcd();

  76:     System.out.println(ns+"/"+ds);

  77:     }

  78: /**Suma la fraccion objeto con otra fraccion para guardarla en otra fraccion */

  79: public Fraccion sumar(Fraccion a)

  80:     {

  81:     Fraccion s=new Fraccion((num*a.den)+(den*a.num),den*a.den);

  82:     return s;

  83:     }

  84: /**Multiplica la fraccion objeto con otra fraccion objeto para guardarla en otra fraccion objeto */

  85: public Fraccion multiplicar(Fraccion a)

  86:     {

  87:     Fraccion m=new Fraccion(num*a.num,den*a.den);

  88:     return m;

  89:     }

  90: /**Divide la fraccion objeto con otra fraccion objeto para guardarla en otra fraccion objeto */

  91: public Fraccion divicion(Fraccion a)

  92:     {

  93:     Fraccion d=new Fraccion(num*a.den,den*a.num);

  94:     return d;

  95:     }

  96: /**Muestra la fraccion completa */

  97: public void mostrarFraccion()

  98:     {

  99:     System.out.println(num+"/"+den);

 100:     }

 101:

 102: public String toString()

 103: {

 104:     return num+"/"+den;

 105: }

 106:

 107: }

Etiquetas de Technorati: JAVA,PROGRAMACION,FRACCIONES,FUNCIONES MATEMATICAS JAVA,SIMPLIFICAR FRACCIONES

POTENCIA MATEMATICA EN JAVA

en cursos gratuitos java, cursos java, FUNCIONES MATEMATICAS JAVA, Java, POTENCIA EN JAVA, POTENCIA MATEMATICA EN JAVA

Que tal compañeros les dejo un apunte, es una función para sacar la potencia, aquí
se manejan excepciones.

   1: package unidad5;

2:

   3: public class Potencia {

4:

   5:     public static long potencia(long numero, long exponente)

   6:         {

   7:         long resultado=1;

   8:         if(exponente<0)    throw new IllegalArgumentException("Exponente incorrecto");

   9:         for(int x=0; x<exponente; x++)

  10:             {

  11:             resultado=resultado*numero;

  12:             }

  13:         return resultado;

  14:         }

  15:     public static void main(String[] args){

  16:         try{

  17:             System.out.println(potencia(3,3));

  18:         }catch(IllegalArgumentException e){

  19:             System.out.println("");

  20:         }catch(IllegalArgumentException e){

  21:             System.out.println("Exponente incorrecto");

  22:         }

  23:     }

24:

  25: }

Etiquetas de Technorati: JAVA,POTENCIA,FUNCIONES MATEMATICAS JAVA,EXCEPCIONES,EXPONENTE

FACTORIAL EN JAVA

en FACTORIAL, FUNCIONES JAVA, FUNCIONES MATEMATICAS JAVA, Java

Bueno compañeros les dejo una función hecha en en JAVA que da como resultado el factorial espero y le sirva

   1: package utilerias;

2:

   3: public class Mate

   4: {

   5: public static int factorial(int x)

   6:     {

   7:     int y;

   8:     int f=1;

   9:     for(y=1; y<=x; y++)

  10:         {

  11:         f=f*y;

  12:         }

  13:     return f;

  14:     }

  15: }

Al usarse

   1: package utilerias;

2:

   3: public class Prueba {

4:

   5:     public static void main(String[] args)

   6:     {

   7:     System.out.println(Mate.factorial(5));

   8:     }

9:

  10: }

Etiquetas de Technorati: JAVA,FACTORIAL,FUNCIONES MATEMATICAS

Microsoft Visual Studio Express 2012 para windows 8

en Microsoft Visual Studio Express 2012 RC, Programacion visual 2012, VISUAL STUDIO, VISUAL STUDIO EXPRESS 2012, Visual studios 2012, Windows 8

en julio 1, 2012

Microsoft Visual Studio Express 2012 RC para Windows 8 proporciona las herramientas básicas necesarias para crear aplicaciones estilo Metro de Windows innovadoras y atractivas.

PAGINA DE DESCARGA

Introducción

Puede usar las herramientas de Visual Studio Express 2012 RC para Windows 8 para crear aplicaciones estilo Metro de Windows innovadoras y atractivas. Las herramientas incluyen un completo editor de código, un eficaz depurador, un generador de perfiles especializado y extensa compatibilidad con lenguajes de programación que le permiten compilar aplicaciones escritas en HTML5/JavaScript, C++, C# o Visual Basic. Visual Studio Express 2012 RC para Windows 8 incluye también un simulador de dispositivos para probar las aplicaciones estilo Metro en varios factores de forma.

Requisitos del sistema

Sistemas operativos admitidos:

Windows 8 Release Preview Windows 8 Release Preview

•Arquitecturas compatibles:

32 bits (x86)
64 bits (x64)

Requisitos de hardware:

Procesador a 1,6 GHz o más rápido
1 GB de RAM (1,5 GB si se ejecuta en una máquina virtual)
4.0 GB de espacio disponible en el disco duro
Unidad de disco duro de 5400 rpm
Tarjeta de vídeo compatible con DirectX 9 con una resolución de pantalla de 1024 x 768 o superior

Simulación en C++

DESCARGAR CODIGO FUENTE COMPLETO

en C#, Simulacion, Simulacion en C++

SIMULACION EN C++

DESCARGAR CABECERA
Este archivo va en la carpeta INCLUDE

SIMULA.CPP

   1: #include

   2: #include

   3: #include

4:

   5: typedef struct simulacion

   6: {

   7: int tiemposimulacion;

   8: int tiemposervicio;

   9: int probabilidad;

10:

  11: int relog;

12:

  13: int cajero;

14:

  15: int tiemposerviciototal;

  16: int clientesatendidos;

  17: };

18:

  19: void parametros(simulacion *p);

  20: int aleatorio(simulacion *a)

  21: {

  22: int x;

  23: float y;

  24: randomize();

  25: y=random(100);

  26: y=y*3.1416;

  27: x=y;

  28: y=y-x;

  29: y=y*100;

  30: if(a->probabilidad<=y)

  31:     {

  32:     return(1);

  33:     }

  34: else

  35:     {

  36:     return(0);

  37:     }

  38: }

39:

40:

  41: void llegacliente(cola *c)

  42: {

  43: if(aleatorio<=aleatorio)

  44:     {

  45:     push(c);

  46:     }

  47: }

48:

  49: void enmarcha(simulacion *e, cola *c)

  50: {

  51: inicializarcola(c);

  52: e->relog=0;

  53: e->cajero=0;

  54: e->clientesatendidos=0;

  55: e->tiemposerviciototal=0;

  56: int v=0;

  57: clrscr();

58:

  59: while(e->relog!=e->tiemposimulacion+1)

  60:     {

  61:     clrscr();

  62:     for(int v=0; v<max; v++)

  63:         {

  64:         *(c->cola+v)=*(c->cola+v)+1;

  65:         }

  66:     gotoxy(1,1);    cout<<"Minutos trancurridos: "<relog;

  67:     (e->relog)++;

68:

  69:     gotoxy(40,1);    cout<<"Probabilidad "<probabilidad;

70:

  71:     gotoxy(1,20);    cout<<"Clientes atendidos "<clientesatendidos;

72:

  73:     gotoxy(40,20);    cout<<"Tiempo de espera total "<tiemposerviciototal;

  74:     if(aleatorio(e)==0)

  75:         {

  76:         insertar(c);

  77:         for(int v=0; v<30; v++)

  78:             {

  79:             gotoxy(1,3);    cout<<"Ha llegado un cliente";

  80:             }

  81:         }

82:

  83:     if(e->cajero==0)

  84:         {

  85:         gotoxy(1,4);    borrar(c);

  86:         e->cajero=e->tiemposervicio;

  87:         }

  88:     (e->cajero)--;

89:

90:

  91:     if(e->cajero==0 && colavacia(c)==0)

  92:         {

  93:         (e->clientesatendidos)++;

  94:         e->tiemposerviciototal=e->tiemposerviciototal+*(c->cola+c->frente);

  95:         }

96:

  97:     getch();

  98:     }

  99: }

 100:

 101:

 102:

 103: main()

 104: {

 105: clrscr();

 106: cola fila;

 107: tipodatocola colas[max];

 108: fila.cola=&colas[0];

 109:

 110: simulacion simula;

 111: parametros(&simula);

 112: enmarcha(&simula, &fila);

 113: }

 114:

 115:

 116:

 117:

 118: void parametros(simulacion *p)

 119: {

 120: cout<<"Tiempo de duracion de la simulacion: ";            cin>>p->tiemposimulacion;

 121: cout<<"Tiempo limite del servicio del servidor: ";        cin>>p->tiemposervicio;

 122: cout<<"probabilidad de llegada de un cliente en un minuto ";    cin>>p->probabilidad;

 123: }

.csharpcode, .csharpcode pre
{
font-size: small;
color: black;
font-family: consolas, “Courier New”, courier, monospace;
background-color: #ffffff;
/*white-space: pre;*/
}
.csharpcode pre { margin: 0em; }
.csharpcode .rem { color: #008000; }
.csharpcode .kwrd { color: #0000ff; }
.csharpcode .str { color: #006080; }
.csharpcode .op { color: #0000c0; }
.csharpcode .preproc { color: #cc6633; }
.csharpcode .asp { background-color: #ffff00; }
.csharpcode .html { color: #800000; }
.csharpcode .attr { color: #ff0000; }
.csharpcode .alt
{
background-color: #f4f4f4;
width: 100%;
margin: 0em;
}
.csharpcode .lnum { color: #606060; }

COLAS.H

   1: //COLAS

   2: //JULIO CESAR LEYVA RODRIGUEZ

   3: #include

   4: #include

   5: #define max 100

   6: typedef int tipodatocola;

   7: typedef struct cola

   8: {

   9: tipodatocola *cola;

  10: int frente;

  11: int final;

  12: int contador;

  13: };

14:

  15: //INICIALIZAR COLA

  16: void inicializarcola(cola *inicializar)

  17: {

  18: inicializar->frente=max-1;

  19: inicializar->final=-1;

  20: gotoxy(40,5);    cout<<"SE HA INICIALIZADO LA COLA";

  21: }

22:

  23: //COLA LLENA

  24: int colallena(cola *llena)

  25: {

  26: if(llena->final==llena->frente-1)

  27:     {

  28:     return(1);

  29:     }

  30: else

  31:     {

  32:     return(0);

  33:     }

  34: }

35:

  36: //COLA VACIA

  37: int colavacia(cola *v)

  38: {

  39: if((v->frente==v->final) || (v->final==-1 && v->frente==max-1))

  40:     {

  41:         return(1);

  42:     }

  43: else

  44:     {

  45:     return(0);

  46:         }

  47: }

48:

  49: void push(cola *z)

  50: {

  51: if(z->final==max-1)

  52:     {

  53:     (z->final)=-1;

  54:     *(z->cola+z->final+1)=0;

  55:     }

  56: else

  57:     {

  58:     (z->final)++;

  59:         *(z->cola+z->final)=0;

  60:         }

  61: }

62:

  63: void insertar(cola *i)

  64: {

  65: tipodatocola cliente;

  66: if(colallena(i)==1)

  67:     {

  68:     cout<<"La cola esta llena";

  69:     }

  70: else

  71:     {

  72:     push(i);

  73:     }

  74: }

75:

  76: tipodatocola pop(cola *c)

  77: {

  78: tipodatocola dato;

  79: if(c->frente==max-1 && c->final>-1)

  80:     {

  81:     c->frente=0;

  82:     dato=*(c->cola+c->frente);

  83:     return(dato);

  84:     }

  85: else

  86:     {

  87:     c->frente=c->frente+1;

  88:     dato=*(c->frente+c->cola);

  89:     return(dato);

  90:         }

  91: }

92:

  93: void borrar(cola *borrar)

  94: {

  95: if(colavacia(borrar)==1)

  96:     {

  97:     cout<<"La cola esta vacia";

  98:     }

  99: else

 100:     {

 101:     cout<<"El cliente a pasado al cajero con "<<pop(borrar)<<" minutos de espera";

 102:     }

 103: }

 104:

 105: void visualizarcola(cola *v)

 106: {

 107: if(colavacia(v)==1)

 108:     {

 109:     cout<<"No hay datos";

 110:     }

 111: else

 112:     {

 113:     for(int x=v->frente; xfinal; x++)

 114:         {

 115:         if(x==max-1)

 116:             {

 117:             x=0;

 118:                         }

 119:         gotoxy(x+20,25);    cout<cola+1;

 120:         }

 121:         }

 122:

 123: }

 124:

 125:

 126:

 127:

 128: //MENU

 129: void menu(cola *menu)

 130: {

 131: int op;

 132: do

 133:

 134:     {

 135:     clrscr();

 136:     cout<<"Frente "<frente;

 137:         cout<<"nFinal "<final;

 138:         cout<<"nCola "<cola+menu->frente);

 139:      gotoxy(1,5);    cout<<"MENU";

 140:     gotoxy(1,6);    cout<<"1. INICIALIZAR";

 141:     gotoxy(1,7);    cout<<"2. INSERTAR";

 142:     gotoxy(1,8);    cout<<"3. BORRAR";

 143:     gotoxy(1,9);    cout<<"ELIGA UNA OPCION [   ]";

 144:     gotoxy(20,9);    cin>>op;

 145:     switch(op)

 146:         {

 147:         case 1:

 148:             inicializarcola(menu);

 149:             getch();

 150:             break;

 151:         case 2:

 152:             insertar(menu);

 153:             getch();

 154:             break;

 155:         case 3:

 156:                 borrar(menu);

 157:             getch();

 158:                         break;

 159:         case 4:

 160:             visualizarcola(menu);

 161:             getch();

 162:                         break;

 163:         }

 164:     }

 165:     while(op!=5);

 166: }

 167:

Pilas en C++

DESCARGAR CODIGO FUENTE COMPLETO

en C#, Pilas, Pilas en C++

PILAS EN C++

   1: //PILAS

2:

   3: #include

   4: #include

   5: #include

   6: #define max 5

7:

   8: typedef int tipodatopila;

9:

  10: tipodatopila pila[max];

  11: int tope;

12:

  13: void visualizarpila(tipodatopila *pila);

  14: void inicializarpila(int *tope);

  15: void menu(int *tope, tipodatopila *pila);

  16: int pilavacia(int *tope);

  17: int pilallena(int *tope);

  18: void push(int *tope, tipodatopila *pila, tipodatopila *dato);

  19: void alta(int *tope);

  20: tipodatopila pop(int *tope, tipodatopila *pila)

  21: {

  22: tipodatopila b=*(tope)+*(pila);

  23: *(tope)=*(tope)-1;

  24: return(b);

25:

  26: }

  27: void baja(int *tope, tipodatopila *pila)

  28: {

  29: if(pilavacia(tope)==1)

  30:     {

  31:     gotoxy(40,4);    cout<<"LA PILA ESTA VACIA";

  32:     }

  33: else

  34:     {

  35:     gotoxy(40,4);    cout<<"EL DATO ELIMINADO FUE "<<pop(tope,pila);

  36:     }

  37: }

38:

39:

  40: main()

  41: {

  42: menu(&tope,&pila[0]);

  43: }

44:

  45: void menu(int *tope, tipodatopila *pila)

  46: {

  47: int op;

48:

  49: do

  50:     {

  51:         clrscr();

  52:         gotoxy(10,10);    visualizarpila(pila);

  53:     gotoxy(30,2);     cout<<"PILAS";

  54:     gotoxy(10,4);     cout<<"1. INICIALIZAR PILA";

  55:     gotoxy(10,5);     cout<<"2. ALTA";

  56:     gotoxy(10,6);     cout<<"3. BAJA";

  57:     gotoxy(10,7);     cout<<"4. SALIR";

  58:     gotoxy(10,8);     cout<<"ELIGA UNA OPCION [   ]";

  59:     gotoxy(29,8);    cin>>op;

  60:     switch(op)

  61:         {

  62:         case 1:

  63:             inicializarpila(tope);

  64:             break;

  65:            case 2:

  66:             alta(tope);

  67:                         getch();

  68:             break;

  69:         case 3:

  70:                         baja(tope,pila);

  71:             getch();

  72:             break;

  73:         case 4:

  74:                         clrscr();

  75:             cout<<"ADIOS ;D";

  76:             getch;

  77:             break;

78:

  79:         default:

  80:             cout<<"HAZ TECLADO UNA LETRA";

  81:                         break;

82:

  83:         }

84:

  85:     }while(op!=4);

86:

  87: }

88:

89:

90:

91:

92:

93:

94:

95:

96:

97:

98:

99:

 100:

 101:

 102:

 103:

 104:

 105:

 106:

 107:

 108:

 109: int pilallena(int *tope)

 110: {

 111: if(*(tope)==max-1)

 112:     {

 113:     return(1);

 114:     }

 115: else

 116:     {

 117:     return(0);

 118:     }

 119: }

 120:

 121: //Pila vacia

 122: int pilavacia(int *tope)

 123: {

 124: if(*(tope)==-1)

 125:     {

 126:     return(1);

 127:     }

 128: else

 129:     {

 130:     return(0);

 131:     }

 132: }

 133:

 134:

 135:

 136:

 137:

 138:

 139:

 140: //Funcion inicializar pila

 141: void inicializarpila(int *tope)

 142: {

 143: *(tope)=-1;

 144: }

 145:

 146: //Visualizar pila

 147: void visualizarpila(tipodatopila *pila)

 148: {

 149: for(int f=0; f<max; f++)

 150:     {

 151:     cout<<"n"<<*(pila+f);

 152:     }

 153: }

 154:

 155: void push(int *tope, tipodatopila *pila, tipodatopila *dato)

 156: {

 157: *(tope)=*(tope)+1;

 158: *(pila+*tope)=*dato;

 159: }

 160:

 161: void alta(int *tope)

 162: {

 163: tipodatopila dato;

 164: if(pilallena(tope)==1)

 165:     {

 166:     gotoxy(40,4);    cout<<"LA PILA ESTA LLENA";

 167:     }

 168: else

 169:     {

 170:     gotoxy(40,5);    cout<<"INSERTE EL DATO ";    cin>>dato;

 171:     gotoxy(40,6);    push(tope,pila,&dato);

 172:     }

 173: }

Segundo examen C++

DESCARGAR CODIGO PRINCIPAL

en Arreglo, examen, matriz C++

DESCARGAR CABECERA DE CODIGO
Este archivo lo colocaras en la carpeta include, se necesita para correr el programa

EXAMEN2.CPP

   1: //EXAMEN 2 JULIO CESAR LEYVA RODRIGUEZ

2:

   3: #include

   4: #include

   5: #include

6:

   7: #define renglones 5

   8: #define columnas 5

9:

  10: int arreglo[renglones][columnas];

  11: #include

12:

13:

  14: void main()

  15: {

  16: inicializar(&arreglo[0][0]);

  17: numerosaleatorios(&arreglo[0][0]);

  18: mostrararreglo();

  19: sumardiagonales(&arreglo[0][0]);

  20: sumardiagonalesinvertida(&arreglo[0][0]);

  21: }

22:

FJULIO.H

   1: //FUNCIONES JULIO CESAR LEYVA RODRIGUEZ

   2: //MARTES 29 DE SEPTIEMBRE DEL 2009

3:

4:

   5: //SUMAR DIAGONALES DE UN ARREGLO

6:

   7: void sumardiagonales(int *d)

   8: {

   9: int c=0;

  10: for(int x=0; x<renglones; x++)

  11:     {

  12:     cout<<"n"<<*(d+x+c);

  13:     c=c+columnas;

14:

  15:     }

  16: }

17:

18:

  19: //SUMAR DIAGONALES DE UN ARREGLO INVERTIDO

20:

  21: void sumardiagonalesinvertida(int *d)

  22: {

  23: int c=columnas-1;

  24: for(int x=0; x<renglones; x++)

  25:     {

  26:     cout<<"n t"<<*(d+c);

  27:     c=c+columnas-1;

28:

  29:     }

  30: }

31:

  32: //MUESTRAR EN PANTALLA EL ARREGLO

33:

  34: void mostrararreglo()

  35: {

  36: for(int x=0; x<renglones; x++)

  37:     {

  38:     for(int y=0; y<columnas; y++)

  39:         {

  40:         gotoxy(5+y,5+x); cout<<arreglo[x][y];

  41:         }

  42:     }

  43: }

44:

  45: //GENERAR NUMEROS ALEATORIOS EN UN ARREGLO

46:

  47: void numerosaleatorios(int *n)

  48: {

  49: randomize();

  50: for(int x=0; x<renglones*columnas; x++)

  51:     {

  52:     *(n+x)=random(9);

  53:     }

  54: }

55:

  56: //INICIALIZA UN ARREGLO

57:

  58: void inicializar(int *i)

  59: {

  60: for(int x=0; x<renglones*columnas; x++)

  61:     {

  62:     *(i+x)=0;

  63:     }

  64: }

Primer examen C++ Apuntadores

DESCARGAR CODIGO COMPLETO

en Apuntadores, Apuntadores C++, Arreglos, Examen C++

EXAMEN1.CPP

   1: //EXAMEN PRIMER SEMESTRE

2:

   3: //JULIO CESAR LEYVA RODRIGUEZ

4:

   5: #include

   6: #include

   7: #include

   8: #include

   9: #include

10:

  11: #define max 10

  12: int arreglo[max];

  13: int x;

  14: int *p;

15:

  16: void i(int *p);

17:

  18: void buscar(int *p)

  19: {

  20: int n;

  21: int z;

  22: int c;

  23: cout<<"INGRESE EL NUMERO QUE DESEA BUSCAR: ";    cin>>n;

  24: c=0;

  25: for(z=0; z<max; z++)

  26:     {

27:

  28:     if(*(p+z)==n)

  29:         {

  30:                 c=0;

  31:         cout<<"n EL NUMERO SE REPITE EN LA POSICION: "<<z+1;

  32:                 c++;

  33:         }

34:

35:

  36:     }

  37: if(c==0)

  38:         {

  39:         cout<<"EL NUMERO NO SE REPITE";

  40:         }

  41: }

42:

43:

44:

  45: main()

  46: {

  47: i(&arreglo[0]);

  48: for(x=0; x<max; x++)

  49:     {

  50:     cout<<arreglo[x]<<"n";

  51:         }

  52: buscar(&arreglo[0]);

  53: }

54:

55:

56:

57:

58:

  59: void i(int *p)

  60: {

  61: randomize();

  62: for(x=0; x<max; x++)

  63:     {

64:

  65:         *(p+x)=random(100);

66:

  67:     }

  68: }

Generar numeros aleatorios C++