jueves, 24 de marzo de 2011

Diagrama de Flujo del ejercicio #1 de estructuras secuenciales

1. Dada una cantidad en pesos, obtener la equivalenciqa en dólares, asumiendo que la unidad cambiaría es un dato desconocido.

domingo, 20 de marzo de 2011

Programa 6 del libro Lenguaje de Programación de Kernigahan & Ritchie

#include<stdio.h>
/*cuenta los caracteres de la entrada;1ª version*/
main( )
{
    long nc; 
    nc=0;
    while(getchar( )!= EOF)
                        ++nc;
    printf("%1d\n",nc);
}


/*La proposición ++nc; presenta un nuevo operador, ++, que significa incrementa en uno. Es posible escribir nc= nc+1. Los operadores -- y ++ pueden ser operadores prefijos(++nc) como postfijos (n++).

int es del tamaño de 16 bits
long es del valor máximo de 32767 bits*/




#include<stdio.h>
/*cuenta los caracteres dew entrada; 2ª version*/
main( ) 
{
     double nc;
      for(nc=0;getchar( )!=EOF; ++nc)
                 ;
       printf("%.0f\n", nc);
}


/*El cuerpo de este ciclo for esta vacio, debido a que todo el trabajado se realiza en las secciones de prueba e incremento. */

Programa 5 del libro Lenguaje de Programación de Kernigahan & Ritchie

  /* Descripcion: Programa que copia la entrada en la salida, un caracter a la vez.*/

Pseudocodigo:
inicio
Lee un carácter.

while(caracter no es indicador de fin de archivos)
         manda a la salida el caracter recien leido 
         leer un caracter
fin

Código en C:

#include<stdio.h>
/* Copia la entrada a la salida; 1ª version*/
main( )
{
     int c;
     c = getchar( );
     while(c!=EOF){
              putchar(c);
              c=getchar( );
}

/*El operador de relación != significa "no igual a"
EOF= "end of file(fin de archivo)". No se puede utilizar char puesto que c debe ser suficientemente grande como para mantener a EOF además de cualquier otro carácter. Por lo tanto, se emplea int.  */

#include<stdio.h>
/*copia la entrada a la salida;2ª version*/
main( )
{
    int c;
   while((c=getchar( )) !=EOF)
             putchar(c);
}


/*El while obtiene un carácter, lo asigna a c, y entonces prueba si el carácter fue la señal de fin de archivo. De no serlo, el cuerpo del while se ejecuta, escribiendo el caracter; luego se repite el while. Luego, cuando alcanza el final de la entrada, el while termina y tambien lo hace main.


La precedencia de != es más alta que la de =, lo que significa que en ausencia de parentesos la prueba de relacion != se realizará antes de la asignacion =*/

Programa 4 del libro Lenguaje de Programación de Kernigahan & Ritchie

/*Descripción: programa de conversión de grados fahrenheit a celsius utilizando constantes simbolicas*/

#include<stdio.h>

#define LOWER 0/*Límite inferior de la tabla*/
#define UPPER 300 /*Límite superior*/
#define STEP 20 /*tamaño del incremento*/
/*imprime la tabla Fahrenheit-Celsius*/
main( )
{
    int fahr;
    for(fahr=LOWE; fahr<=UPPER; fahr= fahr+STEP)
          printf("%3d %6.1f\n", fahr, (5.0/9.0)*(fahr-32));
}

/*Una línea #define define un nombre simbólico o constante simbólica como una cadena de caracteres especial:

#define nombre texto reemplazo

A partir de esto, cualquier ocurrencia de nombre (que no éste entre comillas ni como parte de otro nombre) se sustituirá por el texto de reemplazo correspondiente.*/

Programa 3 del libro Lenguaje de Programación de Kernigahan & Ritchie

/* Descripción: Programa de conversión de grados Fahrenheit a Celsius utilizando la proposición for*/

#include<stdio.h>
/*Imprime la tabla de Fahrenheit-Celsius*/
main( )
{
     int fahr;
     for(fahr=0; fahr<=300;fahr+20)
           printf("%3d %6.1f\n", fahr, (5.0/9.0)*(fahr-32));
}

/*La proposición for es un ciclo, una forma generalizada del while. Dentro de los paréntesis existen tres secciones, separadas por punto y coma. La primera. la inicialización  fahr=0
se ejecuta una vez antes de entrar propiamente al ciclo. La segunda sección es la condición o prueba que controla el ciclo: fahr<=300  esta condición se evalúa; si es verdadera, el cuerpo del ciclo (en este caso un simple printf) se ejecuta. Después el incremento de avance: fahr= fahr+20 se ejecuta y se vuelve a ejecutar. El ciclo termina si la condición se hace falsa*/

Notas importantes

%d escribe como entero decimal
%6d escribe como entero decimal, por lo menos con 6 caracteres de amplitud
%f escribe como punto flotante
%6f escribe como punto flotante , por lo menos con 6 caracteres de amplitud
%.2f escribe como punto flotante, con dos caracteres después del punto decimal.
%6.2f escribe como punto flotante, por lo menos con 6 caracteres de ancho y 2 después del punto decimal.

La entrada y salida de un texto, sin importar donde fué originada o hacia dónde se dirige, se tratan como flujos (streams) de caracteres. Un flujo de texto es una secuencia de caracteres divididos entre líneas, cada una de las cuales consta de cero o más caracteres seguidos de un caracter nueva línea.

La biblioteca estándar proporciona varias funciones para leer o escribir un caracter a la vez, de las cuales getchar y putchar son las más simples. Cada vez que se invoca, getchar lee el siguiente caracter de entrada de una secuencia de texto y lo devuelve como su valor. Esto es, despues de

c= getchar( )

la variable c contiene el siguiente carácter de entrada. Los carácteres provienen normalmente del teclado.

La función putchar escribe un carácter cada vez que se invoca:

putchar(c)

escribe el contenido de la variable entera c como un caracter, generalmente en la pantalla.Las llamadas a outchar y a printf pueden ser alternadas; la salida aparecerá en el orden en que se realicen las llamadas

Programa 2 del libro Lenguaje de Programación de Kernigahan & Ritchie

/*Descripción: Conversión de grados Farenheit a Celcius mediante la formula ºC=(5/9)(ºF-32)*/
#include<stdio.h>
/*Imprime la tabla far=0,20,...,300*/
main( )
{
   int fahr, celsius;
   int lower, upper, step;
   lower=0; /*Límite inferior de la Tabla de temperaturas*/
   upper =  300; /*Límite superior*/
   step = 20; /* Tamaño del incremento*/
   far = lower;
   while(fahr<=upper){
            celsius = 5*(fahr-32)/9;
            printf("%d\t%d\n", fahr, celsius);
            fahr = fahr + step;
           }
}

/*char=carácter-un solo byte.
short=entero corto.
long=entero largo.
double=punto floante de doble presición.
El ciclo while funciona de esta manera: se prueba  la condición entre paréntesis. De ser verdadera (fahr es menor o igual a upper), el cuerpo del ciclo(las tres proposiciones entre llaves) se ejecuta. Luego la condición se prueba nuevamente, y si es verdadera, el cuerpo se ejecuta de nuevo.Cuando la prueba resulta falsa (fahr excede a upper) la iteración termina, y la ejecución continua en la proposición que sigue al ciclo. El cuerpo while puede tener una o más proposiciones encerradas entre llaves, como en el convertidor de temperaturas, o una sola proposición sin llaves como en
while(i<j)
   i =2*j*/

Programa 1 del libro Lenguaje de Programación de Kernigahan & Ritchie

#include<stdio.h>/*Incluye información acerca de la biblioteca estándar*/
main( )/*Define una función llamada main , que no recibe valores de los argumentos*/
{/*Las proposiciones de main estan encerradas entre llaves*/
         printf("hola mundo\n");/*main llama a la función  de biblioteca printf para escribir esta secuencia de caracteres; \n representa el caracter de nueva línea*/
}

viernes, 18 de marzo de 2011

Programa de evaluacion de una palabra palindroma

/*Autora:Camacho Bolaños Angelica Miriam.
Descripción: Programa que indica si una palabra es palindroma o no mediante estructura de datos*/
#include<stdlib.h>
#include<stdio.h>
#include<conio.h>
#include<string.h>

struct nodop { char palabra[15]; };
struct nodo { struct nodop pal; struct nodo *siguiente; };

typedef struct nodo *COLA;

struct nodoPILA { struct nodop pal2; struct nodoPILA *siguiente2; };

typedef struct nodoPILA *PILA;

void crear(COLA *inicio, COLA *final)
{
    (*inicio)=NULL;
    (*final)=NULL;
}

void crearPILA(PILA *inicio)
{
    (*inicio)=NULL;
}


int vacia(COLA inicio)

{
    if(inicio==NULL){
        return 1;
    }
    else
    {return 0;
    }
}

void ingresar(COLA *inicio, COLA *final, char palabra)
{
    COLA nuevo;
    nuevo=(COLA)malloc(sizeof(struct nodo));
    nuevo->pal.palabra[0]=palabra;
    nuevo->siguiente=NULL;
        if((*final)==NULL)
        {
            (*final)=nuevo;
            (*inicio)=nuevo;
        }
        else
        {
                     (*final)->siguiente=nuevo;
            (*final)=(*final)->siguiente;
        }
}


void ingresarPILA(PILA *inicio, char palabra)
{
    PILA nuevo;
    nuevo=(PILA)malloc(sizeof(struct nodoPILA));
    nuevo->pal2.palabra[0]=palabra;
    nuevo->siguiente2=NULL;
        if((*inicio)==NULL)
        {
            (*inicio)=nuevo;
        }
        else
        {
        nuevo->siguiente2=(*inicio);
        (*inicio)=nuevo;
        }
}


char mostrar(COLA *inicio, COLA *final)
{
    COLA q;
    char a;
    //printf("\n %f", (*inicio)->pal.palabra);
    a=(*inicio)->pal.palabra[0];
    if((*inicio)->siguiente==NULL)
    {
        free(*inicio);
        (*inicio)=NULL;
        (*final)=NULL;
    }
    else
    {
        q=(*inicio);
        (*inicio)=(*inicio)->siguiente;
        q->siguiente=NULL;
        free(q);
    }
    return a;
}
char mostrarPILA(PILA *inicio)
{
    PILA q;
    char b;
    b=(*inicio)->pal2.palabra[0];
    //printf("\nValor inicio = %f - palabra: %s ", (*inicio)->pal2.palabra);
    if((*inicio)->siguiente2==NULL)
    {
        free(*inicio);
        (*inicio)=NULL;
    }
    else
    {
        q=(*inicio);
        (*inicio)=(*inicio)->siguiente2;
        q->siguiente2=NULL;
        free(q);
    }
    return b;
}
void main()
{
    struct nodop pal;
    COLA inicio;
    COLA final;
    PILA inicio2;
    char a,b;
    int i,e,igual;
    igual=0;
    i=0;
    e=0;
    clrscr();
    crear(&inicio,&final);
    crearPILA(&inicio2);
    printf("\n\t Por favor ingrese la palabra que se va a evaluar: ");
    gets(pal.palabra);
    e=strlen(pal.palabra);
    do {
        a=pal.palabra[i];
        ingresar(&inicio,&final,a);
        ingresarPILA(&inicio2,a);
        i++;
    }
           while(i<e);
    while(!vacia(inicio) && igual==0)
    {
        a=mostrar(&inicio, &final);
        b=mostrarPILA(&inicio2);
        printf("\na = %c - b = %c", a, b);
        if(a!=b)
        igual=1;
    }
    if(igual==1){
        printf("\nEsta palabra no es palindrome");
    }
    else
    {printf("\nSi es palindrome");
    }
}

domingo, 6 de marzo de 2011

Criba de Erastostenes

Código Fuente:

void cribaEra(int);
int prueba(int);

void main(void){
    int tope, numero[100],i=o, x;
    printf("\n\t::Bienvenido al programa de la Criba de Erastostenes::");
    printf("Proporciones el numero limite: ");
    scanf("%i",&tope);

    cribaEra(tope);
    printf("\n\t Que tenga buen dia");
}

void cribaEra(int tope){
    int x numero[100]. i=0;

    for (x=2; x<= tope;x++){
        if(prueba(x)){
            printf("%i ",x);
            numero[i]=x;
            i++;
        }
    }
}

int prueba(int i){
    int x, i;
    for(x=i-1; x>= 2;x--)
        if((i % x) == 0)
            return 0;
    return 1;
}

estudiantes.c

/* Camacho Bolaños Angélica Miriam*/
/*Programa para demostrar el uso de registros*/

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

/* Definicion de la estructura Registro */
typedef struct Registro{
        int semestre;
        char nombre[20];
        char califsMat[5];
        char materia[5][20];
}Regis;        /* Se nombra a esta estructura con un alias (Regis) para usarla como tipo */   

/* Definicion de una VARIABLE GLOBAL (Regis) del tipo Regis (la estructura Registro) */
Regis Reg;

/* DECLARACION de las funciones */
void muestra(void);
void main(){
    printf("\n\tBienvenido a la base de datos de la facultad de informatica: ");
    printf("\n\t\tLa estructura es del tipo: \n");
    printf("\n\t\t[ -Semestre                  \n");
    printf(" \n\t\t -Nombre            \n");
    printf("\n\t\t  -Nombres de cada Materia (10)  \n");
    printf(" \n\t\t -Calificaciones de cada Materia(10) ]\n");

    printf("\n\n Este es su contenido:\n");
    llena();
    muestra();
    printf("\n\n Fin ...\n");

}


/* DEFINICION de las funciones */
void muestra(void){
    int x;
    printf("Semestre: %i\n",Reg.semestre);
    scanf("%i", &sem):
    printf("Por favor proporcione el nombre del alumno: %s\n",Reg.nombre);
    scanf("%s, &nombre);
    for (x=0;x<5;x++){
        printf("Materia: %s -\tCalificacion:%i\n",Reg.materia[x],Reg.califsMat[x]);
    }
}

void llena(void){
    int x=0;
    Reg.semestre = *sem;
    /* Funcion para copiar una cadena en otra
     * la sintaxis es strcpy(cadenaDestino,cadenaOrigen) */
   
    strcpy(Reg.nombre,"*nombre");
    strcpy(Reg.materia[x++],"Algoritmos");
    strcpy(Reg.materia[x++],"Programacion");
    strcpy(Reg.materia[x++],"Matematicas");
    strcpy(Reg.materia[x++],"Informatica");
    strcpy(Reg.materia[x++],"Calculo");
    for (x=0;x<5;x++)
        Reg.califsMat[x]= 10;
}