juliocesar20200413 - Cesar Systems

PAQUETE DE HOJAS DE PRESENTACION DE LA UNIVERSIDAD DE OCCIDENTE

SON 8 DIFERENTES

DESCARGAR

HOJA DE PRESENTACION DE LA UAS

por juliocesar20200413

en junio 10, 2011

en HOJA DE PRESENTACION DE LA UAS UNIVERSIDAD AUTONOMA DE SINALOA PORTADA PORTADAS LOS MOCHIS

PAQUETE DE HOJAS DE PRESENTACION DE LA UNIVERSIDAD AUTONOMA DE SINALOA “UAS”

EL PAQUETE TIENE 17 PORTADAS DIFERENTES

DESCARGAR

HOJA DE PRESENTACION DE LA UNIVERSIDAD DE DURANGO

por juliocesar20200413

en junio 10, 2011

en Hoja de presentacion universidad de durango UDG Portada portadas Los Mochis

Les dejo aqui un paquete de hojas de presentación de la universidad de durango

Son mas de 10 portadas diferentes

DESCARGAR

TIPICA HOJA DE PRESENTACION DEL CBTIS 43

por juliocesar20200413

en junio 9, 2011

en HOJAS DE PRESENTACION HOJAS DE PRESENTACION DEL CBTIS PENTACION DEL CBTIS POWER POINT MOCHIS CULIACAN MONTEREY PORTADAS PORTADA

Buenos dias

Les dejo las tipicas hojas de presentacion del CBTIS

Estan en formato de power point

EJEMPLOS

DESCARGAR

LISTAS ENLAZADAS C++

por juliocesar20200413

en junio 5, 2011

en Listas enlazadas estructura de datos

Aquí les dejo el código fuente de listas enlazadas, espero y les sirva

   1: //Julio César Leyva Rodriguez

   2: //Instituto Tecnologico de Los Mochis

   3: //Listas enlazadas

   4: #include

   5: #include

6:

7:

8:

9:

  10: typedef int tipodatolista;

11:

12:

  13: typedef struct nodo

  14: {

  15: tipodatolista dato;

  16: struct nodo *siguiente;

  17: }tiponodo;

18:

19:

  20: typedef tiponodo *pnodo;

21:

22:

  23: //Funcion para insertar un nodo

24:

  25: void insertar(pnodo *n)

  26: {

  27: tipodatolista d;

  28: cout<<"Inserte el dato ";    cin>>d;

29:

30:

  31: pnodo nuevo;

  32: pnodo anterior;

33:

34:

35:

36:

  37: nuevo=new tiponodo;

  38: nuevo->dato=d;

  39: nuevo->siguiente=NULL;

40:

41:

42:

43:

44:

45:

  46: if(*n==NULL)

  47:     {

  48:         *n=nuevo;

  49:         anterior=nuevo;

  50:     }

  51: else

  52:     {

  53:         anterior->siguiente=nuevo;

  54:     anterior=nuevo;

  55:         }

56:

57:

58:

59:

60:

61:

  62: }

63:

64:

  65: //Imprimir lista

66:

67:

  68: void imprimir(pnodo *p)

  69: {

  70: pnodo aux;

  71: aux=*p;

  72: while (aux!=NULL)

  73:     {

  74:     cout<<"  "<dato;

  75:     aux=aux->siguiente;

  76:     }

  77: getch();

  78: }

79:

80:

  81: //RESETEAR LISTA

  82: void inicializar(pnodo *i)

  83: {

  84: *i=NULL;

  85: cout<<"Se ha inicializado la lista";

  86: }

87:

88:

89:

90:

  91: void menu(pnodo *menu)

  92: {

  93: int op;

  94: while(op!=5)

  95:     {

  96:         clrscr();

  97:     gotoxy(5,1);    cout<<"Menu";

  98:     gotoxy(1,2);    cout<<"1. Inicializar";

  99:         gotoxy(1,3);    cout<<"2. Insertar";

 100:     gotoxy(1,4);    cout<<"Eliga una opcion [     ]";

 101:         gotoxy(21,4);    cin>>op;

 102:

 103:

 104:     switch(op)

 105:         {

 106:         case 1:

 107:             gotoxy(40,2);    inicializar(menu);

 108:             break;

 109:         case 2:

 110:             gotoxy(40,2);    insertar(menu);

 111:                         break;

 112:          }

 113:

 114:

 115:     }

 116: }

 117:

 118:

 119: main()

 120: {

 121: pnodo lista;

 122: menu(&lista);

 123: }

 124: //Listas enlazadas estructura de datos

CREAR LIBRERIAS EN BORLAND C++ Y COMO INVOCARLAS

por juliocesar20200413

en junio 5, 2011

en TRUCOS BORLAND C++ HACER LIBRERIAS

Mucho saben que cada quien puede hacer sus propias funciones e invocarlas

Es facil haces tus funciones segùn lo que tu ocupes

los guardas con la extencion .h en lugar de .cpp

Despues las llamas como #include

Ejemplo este es el codigo donde estan las funciones

//FUNCIONES JULIO CESAR LEYVA RODRIGUEZ
//MARTES 29 DE SEPTIEMBRE DEL 2009

//El archivo se llama FJULIO.H se tiene que guardar en la carpeta INCLUDE

//SUMAR DIAGONALES DE UN ARREGLO

void sumardiagonales(int *d)
{
int c=0;
for(int x=0; x<renglones; x++)
    {
    cout<<"n"<<*(d+x+c);
    c=c+columnas;

    }
}

//SUMAR DIAGONALES DE UN ARREGLO INVERTIDO

void sumardiagonalesinvertida(int *d)
{
int c=columnas-1;
for(int x=0; x<renglones; x++)
    {
    cout<<"n t"<<*(d+c);
    c=c+columnas-1;

    }
}

//MUESTRAR EN PANTALLA EL ARREGLO

void mostrararreglo()
{
for(int x=0; x<renglones; x++)
    {
    for(int y=0; y<columnas; y++)
        {
        gotoxy(5+y,5+x); cout<<arreglo[x][y];
        }
    }
}

//GENERAR NUMEROS ALEATORIOS EN UN ARREGLO

void numerosaleatorios(int *n)
{
randomize();
for(int x=0; x<renglones*columnas; x++)
    {
    *(n+x)=random(9);
    }
}

//INICIALIZA UN ARREGLO

void inicializar(int *i)
{
for(int x=0; x<renglones*columnas; x++)
    {
    *(i+x)=0;
    }
}

//Ahora el archivo donde invocamos las funciones EXAMEN2.CPP

//EXAMEN 2 JULIO CESAR LEYVA RODRIGUEZ

#include

#define renglones 5

#define columnas 5

int arreglo[renglones][columnas];

#include

void main()

{

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

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

mostrararreglo();

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

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

}

PUEDES TRABAJAR CON 4 ARCHIVOS DIFERENTE A LA VEZ, EDITAR LAS CABEZERAS “LOS INCLUDES” Y LOS .CPP PARA AGILIZAR EL TRABAJO

POR EJEMPLO ASI, DALE CLIC EN LA IMAGEN PARA VER MEJOR

PARA TRABAJAR ASY SOLO DE VAS A LA PESTAÑA WINDOWS Y SELECCIONAS TILE

CUALQUIER DUDA O CORRECCION PUEDEN DEJAR SU COMENTARIO COMO ANONIMO

ESPERO Y LES HALLA SERVIDO 🙂

PILAS EN C++ USANDO STRUCT

por juliocesar20200413

en junio 4, 2011

en PILAS EN C++ Estructura de datos instituto tecnologico de los mochis funciones, STRUCT metodo PEPS

/JULIO CESAR LEYVA RODRIGUEZ
//PILA CON ESTRUCTURAS

#include
#include
#include
#define max 5

typedef int tipodatopila;

typedef struct pila
{
int tope;
int *pila;
};

//RESETEA LA PILA
void resetearpila(pila *resetea)
{
resetea->tope=-1;
gotoxy(40,6);    cout<<"SE HA RESETEADO LA PILA";
}

//PILA VACIA

int pilavacia(pila *vacia)
{
if(vacia->tope==-1)
        {
    return (1);
    }
else
    {
    return (0);
    }
}

//PILA LLENA

int pilallena(pila *llena)
{
if(llena->tope==max-1)
    {
    return (1);
    }
else
    {
    return (0);
    }
}

//PUSH
void push(pila *push, tipodatopila dato)
{
(push->tope)++;
*(push->pila+push->tope)=dato;
}

//INSERTAR EL DATO

void insertareldato(pila *insertar)
{
tipodatopila dato;
if(pilallena(insertar)==1)
    {
    gotoxy(40,6);    cout<<"LA PILA ESTA LLENA";
    }
else
    {
    gotoxy(40,6);    cout<>dato;
    push(insertar,dato);
    }
}

//POP

tipodatopila pop(pila *pop)
{
tipodatopila dato;
dato=*(pop->pila+pop->tope);
(pop->tope)–;
return(dato);
}

//BORRAR
void borrar(pila *borrar)
{
if(pilavacia(borrar)==1)
    {
    gotoxy(40,6);    cout<<"LA PILA ESTA VACIA";
    }
else
    {
    gotoxy(40,6);    cout<<"EL DATO "<<pop(borrar)<<" HA SIDO ELIMINADO";
    }
}

//MOSTRAR PILA
void mostrarpila(pila *mostrar)
{
if(pilavacia(mostrar)==1)
    {
    gotoxy(20,6);    cout<<"NO HAY DATOS";
    }
else
    {
    for(int x=0; xtope+1; x++)
        {
        gotoxy(40,5+x);    cout<pila[x];
        }
    }
}

//MENU
void menu(pila *menu)
{
int op;
do
    {
    clrscr();
    gotoxy(20,5);    cout<<"MENU";
    gotoxy(1,6);    cout<<"1. RESETEAR PILA";
    gotoxy(1,7);    cout<<"2. INSERTAR DATO";
    gotoxy(1,8);    cout<<"3. BORRAR DATO";
    gotoxy(1,9);    cout<<"4. VER PILA";
        gotoxy(1,10);    cout<<"ELIGA UNA OPCION [   ]";
        gotoxy(20,10);    cin>>op;
    switch(op)
        {
        case 1:
               resetearpila(menu);
               gotoxy(40,7);    getch();
               break;
        case 2:
               insertareldato(menu);
                       getch();
               break;
        case 3:
            borrar(menu);
                        getch();
            break;
        case 4:
            mostrarpila(menu);
            getch();
            break;

        }
    }
    while(op!=5);
}

main()
{
pila pilota;
tipodatopila pila[max];
pilota.pila=&pila[0];
menu(&pilota);
}

PILAS EN C++

por juliocesar20200413

en junio 4, 2011

en PILAS EN C++ Estructura de datos instituto tecnologico de los mochis funciones

ARCHIVO QUE CONTIENE LAS FUNCIONES DEL PAQUETE PILAS

DESCARGAR EN CPP

/*********************************************************************************
*                            TAREA: FUNCIONES DEL PAQUETE PILAS                    *
*                            PROGRAMADOR: JULIO CESAR LEYVA RODRIGUEZ             *
*                            INSTITUTO TECNOLOGICO DE LOS MOCHIS                     *
*                            HTTP://SHALOM-NOW.BLOGSPOT.COM                        *
**********************************************************************************
#include
#include
#include
# define MAX 5

//DECLARA UN ALIAS
typedef int tipodatopila;

//GENERA UNA ESTRUCTURA UN PAQUETE DE VARIABLES EN UNA SOLA
typedef struct tipopila
{
tipodatopila *pila;
int tope;
};

//ESTA FUNCION INICIALIZA LA PILA
void inicializarpila(tipopila *p)
{
p->tope=-1;
}

//ESTA FUNCION INSERTA UN DATO EN LA PILA
void push(tipopila *p ,tipodatopila dato)
{
(p->tope)=p->tope+1;

*(p->pila+p->tope)=dato;
}

//ESTA FUNCION TE AVISA SI LA PILA ESTA LLENA
int pilallena(tipopila *p)
{
if (p->tope==MAX-1)
return(1);
else
return(0);
}

//ESTA FUNCION TE AVISA SI LA PILA ESTA VACIA
int pilavacia(tipopila *p)
{
if (p->tope==-1)
return(1);
else
return(0);
}

//ESTA FUNCION BORRA UN ELEMENTO DE LA PILA
tipodatopila pop(tipopila *p)
{
tipodatopila dato;
dato=*(p->pila+p->tope);
(p->tope)–;
return(dato);
}

//FUNCION QUE VISUALIZA LA PILA
void imprimepila(tipopila *p)
{
int x;
for (x=p->tope;x>-1;x–)
{
   cout<pila+x)<<"n";
   getch();
}
getch();
}

//MENU
void menu(tipopila *tipopila)
{
int op;
do
    {
    clrscr();
         imprimepila(tipopila);
    gotoxy(10,1);    cout<<"                  MENU";
    gotoxy(10,2);    cout<<"1. INICIALIZAR";
    gotoxy(10,3);    cout<<"2. ALTA";
    gotoxy(10,4);    cout<<"3. BAJA";
    gotoxy(10,5);    cout<<"4. VISUALIZAR";
    gotoxy(10,6);    cout<<"5. SALIR";
    gotoxy(10,7);    cout<<"    ELIJA UNA OPCION [   ]";
    gotoxy(36,7);    cin>>op;
    switch(op)
        {
        case 1:
            inicializarpila(pilita);
            getch();
                        break;
                }
    }
    while(op!=5);
}

void main()
{
tipodatopila pila[MAX];

tipopila pilita;
pilita.pila=&pila[0];
menu(&pilita);
}

COLAS EN C++

por juliocesar20200413

en junio 4, 2011

en Estructura de datos Colas C++ Programacion funciones instituto tecnologico de los mochis menu de opciones typedef struct

Lo mejor en colas “En C++” aclarando

Aqui les dejo el codigo fuente del manejo de colas

Vienen todas sus funciones por separado como borrar, push, inicializar, ETC.

DESCARGAR EN .CPP

/*****************************************************************************
*            Tarea: Colas C++                                                                                                            *
*            Programador: Julio César Leyva Rodrirguez                *
*            Instituto Tecnonolgico de Los Mochis                     *
*            HTTP://Shalom-now.blogspot.com                           *
*****************************************************************************

#include
#include
#define max 100
typedef int tipodatocola;
typedef struct cola
{
tipodatocola *cola;
int frente;
int final;
};

//INICIALIZAR COLA
void inicializarcola(cola *inicializar)
{
inicializar->frente=max-1;
inicializar->final=-1;
gotoxy(40,5);    cout<<"SE HA INICIALIZADO LA COLA";
}

//COLA LLENA
int colallena(cola *llena)
{
if(llena->final==llena->frente-1)
    {
    return(1);
    }
else
    {
    return(0);
    }
}

//COLA VACIA
int colavacia(cola *v)
{
if((v->frente==v->final) || (v->final==-1 && v->frente==max-1))
    {
        return(1);
    }
else
    {
    return(0);
        }
}

void push(cola *z)
{
if(z->final==max-1)
    {
    (z->final)=-1;
    cout<>*(z->cola+z->final+1);
    }
else
    {
    (z->final)++;
        cout<>*(z->cola+z->final);
        }
}

void insertar(cola *i)
{
tipodatocola cliente;
if(colallena(i)==1)
    {
    cout<<"La cola esta llena";
    }
else
    {
    push(i);
    }
}

tipodatocola pop(cola *c)
{
tipodatocola dato;
if(c->frente==max-1 && c->final>-1)
    {
    c->frente=0;
    dato=*(c->cola+c->frente);
        return(dato);
    }
else
    {
    c->frente=c->frente+1;
    dato=*(c->frente+c->cola);
        return(dato);
        }
}

void borrar(cola *borrar)
{
if(colavacia(borrar)==1)
    {
    cout<<"La cola esta vacia";
    }
else
    {
    cout<<"Se ha eliminado el dato "<<pop(borrar);
    }
}

void visualizarcola(cola *v)
{
if(colavacia(v)==1)
    {
    cout<<"No hay datos";
    }
else
    {
    for(int x=v->frente; xfinal; x++)
        {
        if(x==max-1)
            {
            x=0;
                        }
        gotoxy(x+20,25);    cout<cola+1;
        }
        }

}


//MENU
void menu(cola *menu)
{
int op;
do

    {
    clrscr();
    cout<<"Frente "<frente;
        cout<<"nFinal "<final;
        cout<<"nCola "<cola+menu->frente);
     gotoxy(1,5);    cout<<"MENU";
    gotoxy(1,6);    cout<<"1. INICIALIZAR";
    gotoxy(1,7);    cout<<"2. INSERTAR";
    gotoxy(1,8);    cout<<"3. BORRAR";
    gotoxy(1,9);    cout<<"ELIGA UNA OPCION [   ]";
    gotoxy(20,9);    cin>>op;
    switch(op)
        {
        case 1:
            inicializarcola(menu);
            getch();
            break;
        case 2:
            insertar(menu);
            getch();
            break;
        case 3:
                borrar(menu);
            getch();
                        break;
        case 4:
            visualizarcola(menu);
            getch();
                        break;
        }
    }
    while(op!=5);
}
main()
{
cola colita;
tipodatocola cola[max];
colita.cola=&cola[0];
menu(&colita);
}