Investigación de Producción Lechera de Cariamanga

La investigación en Ganadería de Cariamanga, busca la optimización de recursos para lograr producir el mayor número de productos lacteos y sus derivados, teniendo en cuenta entre otros motivos, temas como el cuidado veterinario (el tratamiento de enfermedades y la higiene), como el mantenimiento, mejoramiento y cambio de pastizales, además del desarrollo tecnológico.

Por esta  razon los Profesionales en Formación de IV Ciclo de Administración de Empresas e Informática de la UTPL Extensión Cariamanga, en la materia de INVESTIGACION DE OPERACIONES, hemos  creido conveniente investigar la producción lechera de Cariamanga, ya que uno de los factores que contribuyen a la subsistencia y el progreso de las sociedades es el que se refiere al desarrollo de los métodos de cría, engorde y reproducción de animales para obtener un provecho de ellos, es decir, la Ganadería. Los métodos de investigación basados en la producción animal han supuesto una mejora en la calidad de vida y el bienestar de la sociedad ocasionados por la abundancia y la diversificación de la alimentación de los individuos. Vacas productoras de leche Para la elaboración de este reportaje contamos con la colaboración de algunos productores de leche de la ciudad, se logro determinar que la producción lechera de la ciudad es de aproximadamente 1000 litros diarios de leche, que es comercializada de algunas maneras: leche por botellas, en quesillo y en queso. Luego de esta investigación creemos que es conveniente dar valor agregado a nuestra producción, por lo que se planteó un modelo matemático referente a la posibilidad de producir queso y yogurt , los resultados de esta investigación se exponen el dia 26 deEnero en las Instalaciones de la UTPL EXTENSION CARIAMANGA.

LISTAS ENLAZADAS,SIMPLES Y DOBLES

     /*********LISTAS ENLAZADAS********/

//programa que presenta el menu de metodos de desarrollar
// las LISTAS ENLASADAS SIMPLES

DEFINICIÒN

Una lista de enlace simple es una lista enlazada de nodos, donde cada nodo tiene un único campo de enlace. Una variable de referencia contiene una referencia al primer nodo, cada nodo (excepto el último) enlaza con el nodo siguiente, y el enlace del último nodo contiene NULL  para indicar el final de la lista. Aunque normalmente a la variable de referencia se la suele llamar top, usted puede elegir el nombre que quiera. La siguiente figura presenta una lista de enlace simple de tres nodos, donde top referencia al nodo A, A conecta con B y B conecta con C y C es el nodo final:

 :

//Ejemplo
#include<iostream.h>
#include<conio.h>
#include<math.h>
#include<string.h>
#include<stdio.h>
#include<fcntl.h>
#include<io.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys\stat.h>
#include<io.h>
#include<process.h>
#include<alloc.h>
#include”iomanip.h”

 
//ESTRUCTURA CON NODOS
typedef struct nodo
{
    int num;
    struct nodo *sig;

}tipoNodo;
 //DECLARACION DE LOS PORTOTIPOS

 void menupuntero();
 void presentar();

 //PARA UZAR LOS PUNTEROS
 tipoNodo *crearNuevo();
 void crear();
 void nuevo();
 void modificar();
 void buscar();
 void eliminacion();
 void eliminarcabeza();
 void eliminar();
 void ordenar();
 void as();
 void des();
 void oras();
 void ordes();
 void insertar();
 void insertar_ordenado();
 void insertar_cabeza();
 void insertar_final();
 void presentar();
 tipoNodo *cab;

 //OPCION BUSCAR
 void busquedaC();

 //CONSTANTES
 const npun=20;
 //FUNCION PRINCIPAL
 void main()
 {
    menupuntero();

 }
 //CONPARTIMINETO DEL PROYECTO

 //MENUS DE PRESENTACION

 void menupuntero()
 {
    textmode(BW80);
    cprintf(“ABC”);

  char opl=’0′;
  do
  {
     clrscr();
   cout<<”\t\t//////////////////////////////////////////\n”;
   cout<<”\t\t ***MENU LISTAS ENLAZADAS  SIMPLES***    \n”;
   cout<<”\t\t                                         \n”;
   cout<<”\t\t [1]  CREAR                              \n”;
   cout<<”\t\t [2]  NUEVO                              \n”;
   cout<<”\t\t [3]  MODIFICAR                          \n”;
   cout<<”\t\t [4]  BUSCAR                             \n”;
   cout<<”\t\t [5]  ELIMINAR                           \n”;
   cout<<”\t\t [6]  ORDENAR                            \n”;
   cout<<”\t\t [7]  INSERTAR                           \n”;
   cout<<”\t\t [8]  PRESENTAR                          \n”;
   cout<<”\t\t [x]  SALIR                              \n”;
   cout<<”\t\t///////////////////////////////////////   \n”;

   gotoxy (30,20);cout<<”SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1′ :crear();break;
 case ‘2′ :nuevo(); break;
 case ‘3′ :modificar(); break;
 case ‘4′ :buscar(); break;
 case ‘5′ :eliminacion(); break;
 case ‘6′ rdenar(); break;
 case ‘7′ :insertar(); break;
 case ‘8′ :presentar(); break;

 
   }

  }
 while(opl!=’x');
}
 //PARA EL MANEJO DE LAS LISZTAS ENLAZADAS SIMPLES

 //ME PERMITE CREAR CABEZA

void crear()
{
   textcolor(4);
  clrscr();
  cab=crearNuevo();
  cout<<”INGRESE CABEZA:\t”;
  cin>>cab->num;
  cab->sig=NULL;

 

 

}
//ME PERMITE INGRESAR UN NUEVO NUMERO

void nuevo()
{
   textcolor(41);
  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<”INGRESE VALOR:\t”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)
  {
    recorrer= recorrer->sig;
  }
  recorrer->sig=elem;
  elem->sig=NULL;

}

//ESTA OPCION ME PERMINTE MODIFICAR

void modificar()
{

    textcolor(42);
    clrscr();
    tipoNodo * elem,* nuevo;
    elem=crearNuevo();
    cout<<”INGRESE VALOR QUE SE VA HA MODIFICAR:\t “;
    cin>>elem->num;
    // elem->sig=NULL;
    tipoNodo * recorrer;
    recorrer=cab;
    while(recorrer->sig == elem)
    cout<<”INGRESE NUMERO:\t”;
    cin>>nuevo->num;
    recorrer=recorrer->sig;
    recorrer->sig=elem;
    elem->sig=NULL;
}

//ME PERMIOTE BUSCAR

void buscar()
{
    textcolor(30);
   clrscr();
   tipoNodo *elem;
   int x;
   cout<<”VALOR QUE VA A BUSCAR:\t”;
   cin>>x;
   while(elem!=NULL && elem->num!=x)
   {
      elem=elem->sig;
   }

}
//ESTE MENU ES DE ELIMINACION

void eliminacion()
{
  char opl=’0′;
  do
  {
     clrscr();
   cout<<”\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<”\t\tº***MENU DE FORMAS DE ELIMINACIONº\n”;
   cout<<”\t\tº                                º\n”;
   cout<<”\t\tº 1.-  ELIMINAR                  º\n”;
   cout<<”\t\tº 2.-  ELIMINAR CABEZA           º\n”;
   cout<<”\t\tº x.-  SALIR                     º\n”;
   cout<<”\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<”SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1′ :eliminar();break;
 case ‘2′ :eliminarcabeza(); break;

   }

  }
 while(opl!=’x');

}

//ME PERMITE ELIMINAR CABEZA
void eliminarcabeza()
{
    clrscr();
    tipoNodo *aux;
    cab=cab->sig;
    aux->sig=NULL;
    free(aux);
}

//ME PERMITE ELIMINAR UNO DE LOS NUMEROS INGRESADOS

void eliminar()
{
   clrscr();
   tipoNodo *aux;
   int n;
   cout<<”INGRESE ELEMENTO QUE VA HA ELIMINAR:\t”;
   cin>>n;
    if(n==cab->num)
  eliminarcabeza();
    else{
     tipoNodo *ant=cab;
     aux=cab->sig;
     while((aux!=NULL)&&(aux->num!=n))
     {
       ant=aux;
       aux=aux->sig;

     }
     if(aux!=NULL)
     {
 ant->sig=aux->sig;
 aux->sig=NULL;
 free(aux);

     }
     else
       cout<<”NO SE ENCUENTRA”;

    }

}

//ESTA OPCION ES DE ORDENAMIENTO

void ordenar()
{

   textcolor(3);
  char opl=’0′;
  do
  {
     clrscr();
   cout<<”\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<”\t\tº***MENU FORMAS DE ORDENAMIENTO**º\n”;
   cout<<”\t\tº                                º\n”;
   cout<<”\t\tº 1.-  ORDENAMIENTO ASCENDENTE   º\n”;
   cout<<”\t\tº 2.-  ORDENAMIENTO DESCENDENTE  º\n”;
   cout<<”\t\tº x.-  SALIR                     º\n”;
   cout<<”\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<”SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1′ :as();break;
 case ‘2′ :des(); break;

   }

  }
 while(opl!=’x');
}

//ME PERMITE ORDENAR DE FORMA ASCENDENTE
void as()
{
   clrscr();
   tipoNodo *aux,*aux1;
   int b;
   aux=cab;
   while(aux!=NULL)
   {
     aux1=aux;
     aux1=aux1->sig;
     while(aux1!=NULL)
     {
       if(aux->num>aux1->num)
       {
  b=aux1->num;
  aux1->num=aux->num;
  aux->num=b;
  aux1=aux1->sig;
       }
       else
       {
   aux1=aux1->sig;
       }
     }
     aux=aux->sig;
   }
}
void oras()
{
  as();
  clrscr();
  tipoNodo *aux;
  int w;
  aux = cab;
  w=10;
  while (aux!= NULL)
  {
    gotoxy(15,8);cout<<”ORDENACION ASCENDENTE”;
    gotoxy(w,10);
    cout<< aux->num;
    aux = aux->sig;
    w=w+5;
  }
  getch();

}
void des()
{
  clrscr();
  tipoNodo *aux,*aux1;
  int b;
  aux=cab;
  while(aux1!=NULL)
  {
    aux1=aux;
    aux1=aux1->sig;
    while(aux1!=NULL)
    {
      if(aux->num>aux1->num)
      {
 b=aux1->num;
 aux1->num=aux->num;
 aux->num=b;
 aux1=aux1->sig;
      }
      else
      {
 aux1=aux1->sig;
      }
    }
    aux=aux->sig;
  }
}

 

void ordes()
{

  des();
  tipoNodo *aux;
  int w;
  aux = cab;
  w=10;
  while (aux!= NULL)
  {
    gotoxy(15,8);cout<<”ORDENACION DESCENDENTE”;
    gotoxy(w,10);
    cout<< aux->num;
    aux = aux->sig;
    w=w+5;
  }
  getch();

}
//ESTA OPCION ME PERMITE INSERTAR

void insertar()
{
    textcolor(5);
   char opl=’0′;
  do
  {
     clrscr();
   cout<<”\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<”\t\tº***MENU FORMAS DE INSERTAMIENTO**º\n”;
   cout<<”\t\tº                                º\n”;
   cout<<”\t\tº 1.-  INSERTAR ORDENADO         º\n”;
   cout<<”\t\tº 2.-  INSERTAR FINAL            º\n”;
   cout<<”\t\tº 3.-  INSERTAR CABEZA           º\n”;
   cout<<”\t\tº x.- SALIR                      º\n”;
   cout<<”\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<”SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1′ :insertar_ordenado();break;
 case ‘2′ :insertar_final(); break;
 case ‘3′ :insertar_cabeza(); break;
   }

  }
 while(opl!=’x');

}
//ME PERMITE INSERTAR UN NUMERO PERO YA ORDENADO

void insertar_ordenado()
{

  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<”INGRESE UN VALOR:\t”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)
  {
    recorrer= recorrer->sig;
  }
  recorrer->sig=elem;
  elem->sig=NULL;

  as();
  oras();

 

}

//ME PERMITE INSERTAR UN NUMERO AL FINAL
void insertar_final()
{
  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<”INGRESE EL VALOR FINAL:\t”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)
  {
    recorrer= recorrer->sig;
  }
  recorrer->sig=elem;
  elem->sig=NULL;

}

//ME PERMITE INSERTAR UNA NUEVA CABEZA
void insertar_cabeza()
{
   cab=crearNuevo();
  cout<<”INGRESE CABEZA:\t”;
  cin>>cab->num;
  cab->sig=NULL;

}
/*ESTA OPCION ME PERMITE PRESENTAR TODOS LOS NUMEROS
 QUE INGRESE, ELIMINE ORDENE Y INSERTE*/

void presentar()
{
   textcolor(6);
  clrscr();
  tipoNodo *recorrer;
  recorrer=cab;
  while(recorrer!=NULL)
  {
   cout<<recorrer->num;
    recorrer=recorrer->sig;
  }
  getch();
}
tipoNodo *crearNuevo()

{
   tipoNodo *nodo1;
   nodo1 =(tipoNodo*)malloc(sizeof(tipoNodo)) ;
   if(!nodo1)
   cout<<”No se ha reservado memoria\n”;
   return nodo1; //devuelve la direccion de la memoria reservada
}

 

 

 

 

 
  //****  LISTAS ENLAZADAS DOBLES***//

Definiciones

• Es un tipo de lista enlazada que permite moverse hacia delante y hacia atras.
• Cada nodo de una lista doblemente enlazada tiene dos enlaces, ademas de los campos de datos. Un enlace, el derecho, se utiliza para navegar la lista hacia delante. El otro enlace, el isquierdo, se utiliza para navegar la lista hacia atras.

Ejemplo:

#include<iostream.h>
#include<conio.h>
#include<math.h>
#include<string.h>
#include<stdio.h>
#include<fcntl.h>
#include<io.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys\stat.h>
#include<io.h>
#include<process.h>
#include<alloc.h>
#include”iomanip.h”

 
//ESTRUCTURA CON NODOS
typedef struct nodo
{
    int num;
    struct nodo *sig,*ante;

}tipoNodo;
 //DECLARACION DE LOS PORTOTIPOS

 void menupuntero();
 void presentar();

 //PARA UZAR LOS PUNTEROS
 tipoNodo *crearNuevo();
 void crear();
 void nuevo();
 void modificar();
 void buscar();
 void eliminacion();
 void eliminarcabeza();
 void eliminar();
 void ordenar();
 void as();
 void des();
 void oras();
 void ordes();
 void insertar();
 void insertar_ordenado();
 void insertar_cabeza();
 void insertar_final();
 void presentar();
 tipoNodo *cab;
  tipoNodo *cola;

 //OPCION BUSCAR
 void busquedaC();

 //CONSTANTES
 const npun=20;
 //FUNCION PRINCIPAL
 void main()
 {
    menupuntero();

 }
 //CONPARTIMINETO DEL PROYECTO

 //MENUS PARA LA  PRESENTACION

 void menupuntero()
 {

    textmode(BW80);
    cprintf(“ABC”);

  char opl=’0′;
  do
  {
     clrscr();
   cout<<”\t\t/////////////////////////////////\n”;
   cout<<”\t\t**MENU LISTAS ENLAZADAS DOBLES \n”;
   cout<<”\t\t                               \n”;
   cout<<”\t\t 1:  CREAR                     \n”;
   cout<<”\t\t 2:  NUEVO                     \n”;
   cout<<”\t\t 3:  MODIFICAR                 \n”;
   cout<<”\t\t 4:  BUSCAR                    \n”;
   cout<<”\t\t 5:  ELIMINAR                  \n”;
   cout<<”\t\t 6:  ORDENAR                   \n”;
   cout<<”\t\t 7:  INSERTAR                  \n”;
   cout<<”\t\t 8:  PRESENTAR                 \n”;
   cout<<”\t\t x:  SALIR                     \n”;
   cout<<”\t\t////////////////////////////////\n”;

   gotoxy (30,20);cout<<”SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1′ :crear();break;
 case ‘2′ :nuevo(); break;
 case ‘3′ :modificar(); break;
 case ‘4′ :buscar(); break;
 case ‘5′ :eliminacion(); break;
 case ‘6′ rdenar(); break;
 case ‘7′ :insertar(); break;
 case ‘8′ :presentar(); break;

 
   }

  }
 while(opl!=’x');
}
 // CODIGOS PARA EL MANEJO DE LAS LISZTAS ENLAZADAS DOBLES
 //ME PERMITE CREAR CABEZA

void crear()
{
   textcolor(4);

   clrscr();
   cab=NULL;
   cab=crearNuevo();
   cout<<”INGRESE CABEZA:\t”;
   cin>>cab->num;
   cab->ante=NULL;
   cab->sig=NULL;
   cola=cab;

 

     }
//ME PERMITE INGRESAR UN NUEVO NUMERO

void nuevo()
{
   textcolor(41);
  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<”INGRESE VALOR:”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)

    recorrer= recorrer->sig;

  recorrer->sig=elem;
  elem->sig=NULL;

}

//ESTA OPCION ME PERMINTE MODIFICAR

void modificar()
{

    textcolor(42);
    clrscr();
    tipoNodo * elem,* nuevo;
    elem=crearNuevo();
    cout<<”INGRESE VALOR QUE SE VA HA MODIFICAR:\t “;
    cin>>elem->num;
    // elem->sig=NULL;
    tipoNodo * recorrer;
    recorrer=cab;
    while(recorrer->sig == elem)
    cout<<”INGRESE NUMERO:\t”;
    cin>>nuevo->num;
    recorrer=recorrer->sig;
    recorrer->sig=elem;
    elem->sig=NULL;
}

//ME PERMITE BUSCAR

void buscar()
{
    textcolor(30);
   clrscr();
   tipoNodo *elem;
   int x;
   cout<<”VALOR QUE VA A BUSCAR:\t”;
   cin>>x;
   while(elem!=NULL && elem->num!=x)
   {
      elem=elem->sig;
   }

}
//ESTE MENU ES DE LA FORMAS DE ELIMINACION

void eliminacion()
{
  char opl=’0′;
  do
  {
     clrscr();
   cout<<”\t\tÉ//////////////////////////////////////»\n”;
   cout<<”\t\tº***MENU DE FORMAS DE ELIMINACION**   º\n”;
   cout<<”\t\tº                                     º\n”;
   cout<<”\t\tº 1.-  ELIMINAR                       º\n”;
   cout<<”\t\tº 2.-  ELIMINAR CABEZA                º\n”;
   cout<<”\t\tº x.-  SALIR                          º\n”;
   cout<<”\t\tÈ//////////////////////////////////////\n”;

   gotoxy (30,20);cout<<”SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1′ :eliminar();break;
 case ‘2′ :eliminarcabeza(); break;

   }

  }
 while(opl!=’x');

}

//ME PERMITE ELIMINAR CABEZA
void eliminarcabeza()
{
    clrscr();
    tipoNodo *aux;
    cab=cab->sig;
    aux->sig=NULL;
    free(aux);
}

//ME PERMITE ELIMINAR UNO DE LOS NUMEROS INGRESADOS

void eliminar()
{
   clrscr();
   tipoNodo *aux;
   int n;
   cout<<”INGRESE ELEMENTO QUE VA HA ELIMINAR:\t”;
   cin>>n;
    if(n==cab->num)
  eliminarcabeza();
    else{
     tipoNodo *ant=cab;
     aux=cab->sig;
     while((aux!=NULL)&&(aux->num!=n))
     {
       ant=aux;
       aux=aux->sig;

     }
     if(aux!=NULL)
     {
 ant->sig=aux->sig;
 aux->sig=NULL;
 free(aux);

     }
     else
       cout<<”NO SE ENCUENTRA”;

    }

}

//ESTA OPCION ES DE ORDENAMIENTO

void ordenar()
{

   textcolor(3);
  char opl=’0′;
  do
  {
     clrscr();
   cout<<”\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<”\t\tº***MENU FORMAS DE ORDENAMIENTO**º\n”;
   cout<<”\t\tº                                º\n”;
   cout<<”\t\tº 1.-  ORDENAMIENTO ASCENDENTE   º\n”;
   cout<<”\t\tº 2.-  ORDENAMIENTO DESCENDENTE  º\n”;
   cout<<”\t\tº x.-  SALIR                     º\n”;
   cout<<”\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<”SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1′ :as();break;
 case ‘2′ :des(); break;

   }

  }
 while(opl!=’x');
}

//ME PERMITE ORDENAR DE FORMA ASCENDENTE
void as()
{
   clrscr();
   tipoNodo *aux,*aux1;
   int b;
   aux=cab;
   while(aux!=NULL)
   {
     aux1=aux;
     aux1=aux1->sig;
     while(aux1!=NULL)
     {
       if(aux->num>aux1->num)
       {
  b=aux1->num;
  aux1->num=aux->num;
  aux->num=b;
  aux1=aux1->sig;
       }
       else
       {
   aux1=aux1->sig;
       }
     }
     aux=aux->sig;
   }
}
void oras()
{
  as();
  clrscr();
  tipoNodo *aux;
  int w;
  aux = cab;
  w=10;
  while (aux!= NULL)
  {
    gotoxy(15,8);cout<<”ORDENACION ASCENDENTE”;
    gotoxy(w,10);
    cout<< aux->num;
    aux = aux->sig;
    w=w+5;
  }
  getch();

}
void des()
{
  clrscr();
  tipoNodo *aux,*aux1;
  int b;
  aux=cab;
  while(aux1!=NULL)
  {
    aux1=aux;
    aux1=aux1->sig;
    while(aux1!=NULL)
    {
      if(aux->num>aux1->num)
      {
 b=aux1->num;
 aux1->num=aux->num;
 aux->num=b;
 aux1=aux1->sig;
      }
      else
      {
 aux1=aux1->sig;
      }
    }
    aux=aux->sig;
  }
}

 

void ordes()
{

  des();
  tipoNodo *aux;
  int w;
  aux = cab;
  w=10;
  while (aux!= NULL)
  {
    gotoxy(15,8);cout<<”ORDENACION DESCENDENTE”;
    gotoxy(w,10);
    cout<< aux->num;
    aux = aux->sig;
    w=w+5;
  }
  getch();

}
//ESTA OPCION ME PERMITE INSERTAR

void insertar()
{
    textcolor(5);
   char opl=’0′;
  do
  {
     clrscr();
   cout<<”\t\tÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»\n”;
   cout<<”\t\tº***MENU FORMAS INSERTAMIENTO**  º\n”;
   cout<<”\t\tº                                º\n”;
   cout<<”\t\tº 1.-  INSERTAR ORDENADO         º\n”;
   cout<<”\t\tº 2.-  INSERTAR FINAL            º\n”;
   cout<<”\t\tº 3.-  INSERTAR CABEZA           º\n”;
   cout<<”\t\tº x.- SALIR                      º\n”;
   cout<<”\t\tÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ\n”;

   gotoxy (30,20);cout<<”SELECCIONE OPCION:”;
   cin>>opl;
   switch(opl)
   {
 case ‘1′ :insertar_ordenado();break;
 case ‘2′ :insertar_final(); break;
 case ‘3′ :insertar_cabeza(); break;
   }

  }
 while(opl!=’x');

}
//ME PERMITE INSERTAR UN NUMERO PERO YA ORDENADO

void insertar_ordenado()
{

  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<”INGRESE UN VALOR:\t”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)
  {
    recorrer= recorrer->sig;
  }
  recorrer->sig=elem;
  elem->sig=NULL;

  as();
  oras();

 

}

//ME PERMITE INSERTAR UN NUMERO AL FINAL
void insertar_final()
{
  clrscr();
  tipoNodo *elem;
  elem=crearNuevo();
  cout<<”INGRESE EL VALOR FINAL:\t”;
  cin>>elem->num;
  nodo *recorrer;
  recorrer=cab;
  while(recorrer->sig!=NULL)
  {
    recorrer= recorrer->sig;
  }
  recorrer->sig=elem;
  elem->sig=NULL;

}

//ME PERMITE INSERTAR UNA NUEVA CABEZA
void insertar_cabeza()
{

   tipoNodo *elem;
  elem=crearNuevo();
  cout<<”INGRESE NUEVA CABEZA:”;
  cin>>elem->num;
  cab->ante = elem;
  elem->sig = cab;
  elem->ante = NULL;
  cab = elem;

 

}
/*ESTA OPCION ME PERMITE PRESENTAR TODOS LOS NUMEROS
 QUE INGRESE, ELIMINE ORDENE Y INSERTE*/

void presentar()
{
   textcolor(6);
  clrscr();
  tipoNodo *recorrer;
  recorrer=cab;
  while(recorrer!=NULL)
  {
   cout<<recorrer->num;
    recorrer=recorrer->sig;
  }
  getch();
}
tipoNodo *crearNuevo()

{
   tipoNodo *nodo1;
   nodo1 =(tipoNodo*)malloc(sizeof(tipoNodo)) ;
   if(!nodo1)
   cout<<”No se ha reservado memoria\n”;
   return nodo1; //devuelve la direccion de la memoria reservada
}

SOLUCIONES DE FIBONACCI UTILIZANDO RECURSIVIDAD

ESTRUCTURA DE DATOS

//programa para presentar los numeros fibonaci  con
//recursividad  esta es una solucion

#include<iostream.h>
#include<conio.h>
void  fibo( int n,int b,int c, int f);
void main()

{

 clrscr();
 fibo(5,1,1,0);
 getch();
}
void  fibo (int n,int b,int c, int f)
{
 cout<<f<<”\n”;
 if(n>1)
 {

  fibo((n-1),c,b,(f+c));

 }

}

//programa que permita la serie de los n numeros de la  fibonaci esta vien
// con recursividad
#include<iostream.h>
#include<conio.h>
//prototipo
void  funcion1( int n);
//variables globales
int b=1,c=1,f=0;
//funcion principal
void main()
{
 int a;
 clrscr();
 cout<<”ingrese los n numeros e la fibonaci”;
 cin>>a;
 funcion1(a);
 getch();
}
void funcion1(int n)
{
 cout<<f;
 b=c;
 c=f;
 f=b+c;
 if(n>1)
 {
  n–;
  funcion1(n);
 }
}
//ejercicio que presenta la serie del fibonaci de n numeros
// con recursividad
//esta es otra solucion
#include<iostream.h>
#include<conio.h>
void  fibo( int n,int f, int aux);
void main()

{

 clrscr();
 fibo(5,0,1);
 getch();
}
void  fibo (int n,int f,int aux)
{
 cout<<f<<”\n”;
 if(n>1)
 {

       fibo((n-1),(f+aux),(f));
 }

}

ALMACENAMIENTO DE DATOS

Algunas personas nos asombramos de lo que puede hacer una computadora: con una velocidad increíble, una exactitud sorprendente, etc, la forma en que la computadora realiza sus tareas puede parecer muy compleja, pero en realidad se basa en procesos  bastante simple. No importa qué ponga usted en una computadora texto. Números, gráficos, sonidos, ésta los trate de la misma forma traduciendo la información a códigos simples. Vamos a ver cuales son estos códigos que permiten a la computadora operar de manera casi mágica.

Entonces, tenemos dos tipos de señales electrónicas;

 Estas son:

                     Analógicas y Digitales.

-Las analógicas son ondas que la señal no es fija ejemplo; las que se usan para representar el sonido, temperatura.etc

- las digítales son dígitos definidos entre  0 y 1  ejemplo; de una aplicación práctica de estos dos tipos de señales tenemos: El reloj analógico que representa la rotación de la tierra con el movimiento de las agujas del reloj , mientras que el reloj digital utiliza números.

Cualquier empresa genera montones de datos fundamentales que se deben guardar en un lugar seguro, es decir, se deben almacenar en puntos a los que se pueda obtener acceso y de donde se puedan recuperar con facilidad.

 En el mundo de los negocios, nadie sabe qué puede pasar. Nadie está a salvo de cortes de la alimentación, incendios, robos, inundaciones o daños por accidente. Si no se hacen copias de seguridad de la información o de los datos cruciales, el resultado es devastador. Su recuperación puede acarrear un enorme coste.

 Guarde copias de seguridad de la información en discos (CD) o cintas con frecuencia. Si genera gran cantidad de datos, le conviene preguntar por una solución para el almacenamiento de red.

 Estas soluciones de almacenamiento de red automatizan muchas tareas ordinarias de copia de seguridad a la vez que las facilitan.

Ofrecen amplias capacidades de almacenamiento, funciones de búsqueda inmediata e instantánea, así como enorme flexibilidad para agregar dispositivos que obtengan acceso a los archivos desde cualquier ubicación.

 

 

Hello world!

Welcome to WordPress.com. This is your first post. Edit or delete it and start blogging!