Recursividad (Factorial)

/*Rodriguez Paez Luz Angelica*/

#include <stdio.h>
#include <conio.h>

int factorial(int n);

int main (){
     int num;
     char res;
     printf("** FACTORIAL ** \n\n");
     do
      {
             int num;
                       printf("Ingrese un numero: ");
                       scanf("%i",&num);
                       printf("\tEl resultado es: %i\n", factorial(num));
                       {
                              printf("\n\n hacer otravez?(s/n) \n");}
                              scanf("%s",&res);
      } while(res == 's');
                   
                      getch();
                      }
   

int factorial(int n){
  if(n<=1)
    return 1;
  else
    return n * factorial(n-1);
}

//Martinez Baca Eric Omar

#include <stdio.h>

#include <conio.h>

#include <stdlib.h>

int factorial(int);

int numero;

main(){

       system("cls");

       printf("\n\nEscriba el numero del cual desea saber el factorial: ");

       scanf("%d", &numero);

       printf("\n\nEl resultado es: %d ", factorial(numero) );

       getch();

     

}

int factorial(int Num){

                  if(Num == 1)

                  return Num;

                  

                  return Num * factorial(Num-1);

                  }

Examen 2

#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <stdlib.h>
#include <string.h>
struct lista1 {
char nombre [30];
struct lista1 *sig;
};

typedef  struct lista1 LISTA;
typedef LISTA *LISTAPTR;


void menu();//declarar funciones
void insertar (LISTAPTR*,char[]);
char eliminar(LISTAPTR*,char[]);
void imprimir(LISTAPTR);
int estavacia(LISTAPTR);

   


main(){
       LISTAPTR principio = NULL;
       LISTAPTR final = NULL;
       int opcion;
       char item[30];
       do{

       menu();
       printf("\n\n\n\tSelecciona una opcion: ");
       scanf("%d", &opcion);
     
switch(opcion){
                                  case 1:
                                  fflush(stdin);
                                  system("cls");
                                  printf("\n\n\tIngresa un nombre : ");
                                  scanf("%s", item);
                                 insertar  (&final,item);
                         
                                  imprimir(final);
                                  break;
                                 
                                  case 2:
                                       imprimir(final);
                                       getch();
                                       break;
                                 
                                  case 3:
                                       if (estavacia(principio)){
                                       printf ("imprimir la cadena  a eliminar: ");
                                       scanf("\n%s ", item);
                                       if(eliminar(&principio,item)){
                                       printf("%s Eliminado.\n" ,item);
                                      }
                                       else
                                       printf ("%s no se encontro.\n\n",item);
                                       }
                                       else
                                       printf("La lista esta vacia\n\n");
                                       break;
                                       }
                                       getch();
                                     
}while(opcion!=4);

       getch();
       }

void menu(){
     system("cls");
     printf("\n\n\t\t*** FILA ***");
     printf("\n\t\t1)Insertar un miembro en la fila.");
     printf("\n\t\t2)Imprimir la fila.");
     printf("\n\t\t3)eliminar una fila");
     printf("\n\t\t4)Salir.");
     }
void insertar (LISTAPTR *sptr, char caracter[]){
     LISTAPTR nuevo,principio,final;
     nuevo = malloc (sizeof(LISTA));
     if(nuevo != NULL)
     {
               strcpy( nuevo -> nombre,caracter);
                     nuevo -> sig = NULL;
                     principio=NULL;
                     final=*sptr;
     while (final!=NULL && strcmp(caracter, final->nombre) > 0 ){
           principio=final;
           final=final->sig;
           }
           if (principio == NULL){
           nuevo->sig=*sptr;
           *sptr=nuevo;
           }
           else{
                principio->sig=nuevo;
                nuevo->sig=final;
                }
                }
     }
void imprimir(LISTAPTR  final)
{
     if (final == NULL)
     printf (" La lista esta vacia");
     else {
          printf("la lista es :\n");
          while (final!=NULL){
                printf (" %s \n",final->nombre);
                final=final->sig;
                }
                }        
     }
char eliminar(LISTAPTR *sptr,char valor[]){
     LISTAPTR principio,final,aux1;
     if (valor==(*sptr)->nombre){
     aux1=*sptr;
     *sptr=(*sptr)->sig;
     free(aux1);
   return  valor;
     }
     else{
          principio=*sptr;
          final = (*sptr)->sig;
          while (final != NULL && final -> nombre!=valor){
                principio = final;
                final=final->sig;
                }
          if(final!=NULL){
          aux1 =final;
          principio->sig=final->sig;
          free(aux1);
          return valor;
       
          }
          }
          return '\0';
          }
         
int estavacia(LISTAPTR sptr){
    return sptr==NULL;
}

COLA

#include <stdio.h>
#include <conio.h>
#include <windows.h>
#include <stdlib.h>

struct colanodo{
       char miembro;
       struct colanodo *sig;
       };
     
typedef colanodo COLA;
typedef COLA *COLAPTR;

void menu();
int nohaycola(COLAPTR);
void escribelacola(COLAPTR);
void encolar(COLAPTR *, COLAPTR *, char);
char descolar(COLAPTR *, COLAPTR *);




main(){
       COLAPTR principio = NULL;
       COLAPTR final = NULL;
       int opcion;
       char item;
       do{
       menu();
       printf("\n\n\n\tSelecciona una opcion: ");
       scanf("%d", &opcion);
     
     
                          switch(opcion){
                                  case 1:
                                  fflush(stdin);
                                  system("cls");
                                  printf("\n\n\tDame el nombre del miembro: ");
                                  scanf("%c", &item);
                                  encolar(&principio, &final, item);  //enqueue
                                  break;
                                  case 2:
                                       if(principio == NULL && final == NULL){
                                                    system("cls");
                                                    printf("\n\n\n\n\n\n\t\tNo se puede extraer nada, tienes la cola vacia?!");
                                                    getche();
                                                    }
                                       else{
                                            printf("\n\t %c salio de la cola", descolar(&principio, &final));
                                            getche();
                                            }
                                  break;
                                  case 3:
                                  system("cls");    
                                  escribelacola(principio);
                                 
                                  break;
                                  case 4:
                                  system("exit");
                                  break;
                          }
     
               }while(opcion!=4);
       }

char descolar(COLAPTR *adelante, COLAPTR *atras){
     COLAPTR aux;
     char salemiembro;
   
     if(*adelante == *atras){
                  aux = *adelante;
                  salemiembro = aux -> miembro;
                  *adelante = NULL;
                  *atras = NULL;
                  free(aux);
                  }
     else{
          aux = *adelante;
          salemiembro = aux -> miembro;
          (*adelante) = aux -> sig;
          free(aux);
          }
   
     return (salemiembro);
   
     }



void encolar(COLAPTR *adelante, COLAPTR *atras, char valor){
   
     COLAPTR aux = (COLAPTR) malloc(sizeof(COLA));
     aux->sig = NULL;
     aux->miembro = valor;
   
     if (nohaycola(*adelante)){
                               *adelante = aux;
                               *atras = aux;
                               }
     else{
          (*atras) -> sig = aux;
          *atras = aux;
          }
     }



void menu(){
     system("cls");
     printf("\n\n\t\t***OPERACIONES DE LA COLA***");
     printf("\n\t\t1)Insertar un miembro en la cola.");
     printf("\n\t\t2)Sacar un miembro de la cola.");
     printf("\n\t\t3)Imprimir la cola.");
     printf("\n\t\t4)Salir.");
     }

int nohaycola(COLAPTR aux){
    return aux == NULL;
    }

void escribelacola(COLAPTR aux){
   
     if(nohaycola(aux)){
                        printf("\n\n\n\n\n\n\n\n\n\n\n\t\t\t\tNO HAY COLA!!!!!!");
                        getche();
                        }
     else{
          printf("\n\n\n\t\t***La COLA esta asi***\n\n");
          printf("\nINICIO DE LA COLA -> ");
          while(aux != NULL){
                    printf("%c -> ", aux -> miembro);
                    aux = aux -> sig;
                    }
          printf(" FIN DE LA COLA.");
     getche();
          }
     }

PILA

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <windows.h>
struct pilanodo{
       int dato;
       struct pilanodo *sig;
       };
       typedef struct pilanodo PILA;
       typedef PILA *PILAPTR;
void menu(void);//no regresa valor pero no se pasa una lista de parametros
void push (PILAPTR*,int);
int pop(PILAPTR *);
int estavacia(PILAPTR );
int imprime (PILAPTR);
      
       main()
       {
          PILAPTR pilaptr = NULL;// se asigna valor nulo por que no existe la  pila
             int opcion,valor;//para el menu de main
             //llamado a un menu
menu(); 
do{
printf("\tElige una opcion....\n");
scanf("%d",&opcion);
      switch (opcion)
      {
        
             case 1: printf("dame el valor: \n");
             scanf("%d",&valor);
             push(&pilaptr,valor);
                          break;
             case 2: if (!estavacia(pilaptr))//llama una funcion dice que si no esta vacia
             printf ("\n\n El valor extraido de la pila es : %d\n",pop(&pilaptr));
             break;
             case 3: printf("el contenido de la pila es: \n\n");
             imprime(pilaptr );
             break;
             default: printf("El numero que ingresaste es incorrecto\n");
      }
            } while(opcion!=4);

         
getch();
}
void menu(void)
{
     system ("cls");
          printf("operaciones disponibles con la PILA\n\n"); 
          printf ("1.- insertar un valor en la pila\n");
          printf ("2.- extraer un valor de la pila\n");
          printf ("3.- imprimir la pila\n"); 
          printf ("4.- salir del programa\n\n\n");
}
void push (PILAPTR *aux, int valor ){
     PILAPTR aux1;
     aux1=malloc (sizeof (PILA));//malloc busca en memoria una area del tamanio de pila
     if(aux1!= NULL)
     {      
                    aux1 -> dato = valor;
                    aux1 -> sig =NULL;
                   
                    if(*aux==NULL)
                    *aux =aux1;
                    else{
                    aux1->sig=*aux;
                    *aux=aux1;
                    }  } 
          }
int estavacia(PILAPTR aux){
    return aux ==NULL;//verifica que la pila no esta vacia y manda cero o uno
    }
int pop (PILAPTR*aux)//aux apuntaa pilaptr
{
    if (aux==NULL){
    printf("No se a ingresado ningun valor");
}
else{
PILAPTR aux1;
int salevalor;// se declara un valor entero
aux1=*aux;
*aux=aux1->sig;//sirve para pasar a pilaptr al siguiente nodo
salevalor=aux1->dato;
free (aux1);// libera el espacio en memoria para otra aplicacion
return (salevalor);//regressa un valor y e guarda en pop &pilaptr
}}
int imprime (PILAPTR aux)

{
    if (aux==NULL){
          printf("La pila esta vacia\n");
       }
       else{
   system ("cls");
    printf ("tope de la pila");
    while (aux != NULL){
          printf("\n%d\n",aux->dato);
          aux=aux-> sig;
}
         
          printf("fondo DE LA PILA\n");
          }                
     }
    

examen1 (capturas)

examen 1 (código)

#include <conio.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <io.h>

#include <windows.h>

float TareasTotales;

float TotAsis;

float ParTotales;

struct alumno

       {

       

        int cuenta;

        char Nombre[50];

        char ApMat[15];

        char ApPat[15];

        float asistencias;

        float tareas;

        float participaciones;

        float examen;

        float otros; //uuuuuuuuuuuuuu!!!

        float CFinal;                  

       };

      

struct alumno Alumno;

void captura(){

    

     system("cls");

     printf("\nIngresa los datos:");

     printf("\nIngresa el numero de cuenta: "); scanf("%d", &Alumno.cuenta);

     printf("\nIngresa el Apeido Paterno: "); scanf("%s", Alumno.ApPat);

     printf("\nIngresa el Apeido Materno: "); scanf("%s", Alumno.ApMat);

     printf("\nIngresa los nombres: "); scanf("%s", Alumno.Nombre);

     printf("\nIngrese el numero de asistencias: "); scanf("%f", &Alumno.asistencias);

     printf("\nIngrese el numero de tareas entregadas: "); scanf("%f", &Alumno.tareas);

     printf("\nIngrese el numero de participaciones obtenidas: "); scanf("%f", &Alumno.participaciones);

     printf("\nIngrese la calificacione del examen: "); scanf("%f", &Alumno.examen); 

     printf("\nCalificacion en el trabajo extra: "); scanf ("%f", &Alumno.otros);

     printf("\n\n\n ==== Presiones ENTER para alamacenar los datos === ");

     getch();

     }

void mostrar(){

    

     system("cls");

     printf("\nNUMERO DE CUENTA : %d", Alumno.cuenta);

     printf("\n  APEIDO PATERNO : %s", Alumno.ApPat);

     printf("\n  APEIDO MATERNO : %s", Alumno.ApMat);

     printf("\n       NOMBRE(S) : %s", Alumno.Nombre);

     printf("\nTuvo %2.0f de %2.0f asistencias", Alumno.asistencias, TotAsis);

     printf("\nEntrego %2.0f de %2.0f tareas", Alumno.tareas, TareasTotales);

     printf("\nTuvo %2.0f de %2.0f participaciones totales", Alumno.participaciones, ParTotales);

     printf("\nLa calificacion del examen es : %2.2f", Alumno.examen);

     printf("\nLa calificacion del tabajo extra es: %2.2f", Alumno.otros);

     printf("\n\n\n === Presione ENTER para recibir la clificacion final === ");

     getch();

    

     }

    

main(){

      

       printf("Este programa te pide datos de un alumno ");

       printf("\nLos almacena en una estructura de datos");

       printf("\nY te devuelve la calificacion final del alumno");

       printf(" \n=== Presione ENTER para comenzar === ");

       getch();

       system("cls");

       printf("¿Cuantas asistencias hubo en total?: "); scanf("%f", &TotAsis);

       printf("¿Cuantas tareas hubo en total?: "); scanf("%f", &TareasTotales);

       printf("¿Cuantas participaciones hubo en total?: "); scanf("%f", &ParTotales);

      

       captura();

       mostrar();

      

       Alumno.CFinal = ((Alumno.examen * 0.50) + ( (Alumno.tareas / TareasTotales) * 3 ) + ((Alumno.participaciones/ParTotales)*1) + ((Alumno.asistencias/TotAsis)* .5) + (Alumno.otros * 0.05));

       system("cls");

       printf("La calificacion de %s es: %2.2f ", Alumno.Nombre, Alumno.CFinal);      

       getch();

       }

examen1 (preguntas y respuestas)

EXAMEN PARCIAL 1 - INFORMATICA II CURSO INTERSEMESTRAL 2012-2

-------------------------------------------------------------

1.       Que es una Estructura de Datos? (valor 1 punto)

R= Una Estructura de Datos es cualquier colección o grupo de datos de tal manera organizados que tengan asociados un conjunto de operaciones que permiten manipularlos.

2. Para que sirve una estructura de datos? (valor 1 punto)

R= Sirve como molde, o modelo de un, o una parte de un sistema de información.

3. Para que se utilizan los apuntadores en Estructuras de datos dinámicas? (valor 1 punto)

R= sirven para pasar al siguiente nodo, así como también establecer el tamaño de la estructura.

4. En que consiste la Abstracción de Datos? (valor 1 punto)

R= Técnica, o metodología que permite diseñar estructuras de datos; y consiste en representarlo bajo ciertos criterios y lineamientos las características esenciales de una estructura.

5. Qué es un tipo de Datos Abstracto? (valor 1 punto)

R= Generar una estructura de Datos a base de la Abstracción, y que se pueda implementar en cualquier lenguaje de programación.

6. Haga la abstracción de un sistema de información (libre elección).

   Diseñe una estructura de datos para ese sistema de información.

   Elabore un programa en C, que solicite los datos para almacenarlos en esa estructura,

   y que los despliegue en pantalla.  (valor 5 puntos)