LOS SIGUIENTES PROGRAMAS SON PARA UN CURSO DE C BÁSICO. ESTÁN

COMPILADOS EN BORLAND C v1.00, PERO TAMBIEN ESTAN PROBADOS

EN BORLAND C++ v3.0 Y FUNCIONAN PERFECTAMENTE.

INCLUYE DESDE OPERACIONES MUY SENCILLAS HASTA OPERACIONES

CON ARREGLOS (VECTORES) Y MATRICES. ¡¡SUERTE!!

POR CIERTO... EL CONTEXTO DEL CURSO ES DE INGENIERIA.

/************************************************************************/

/* */

/* Programa que calcula la constante de la gravedad de la tierra */

/* a partir de la aceleración de una partícula que resbala sin fric- */

/* ción sobre un plano inclinado de ángulo conocido. */

/* */

/* Los datos son preguntados al usuario, y g es calculada en la */

/* función paso por valor obt_g. */

/* */

/* Programador: Goofy */

/* Fecha: 09/ene/1998 Materia: Computación I */

/* */

/************************************************************************/

#include <stdio.h>

#include <conio.h>

#include <math.h>

float obt_g (float angulo, float aceleracion);

void main (void) {

float angulo, aceleracion, g;

clrscr ();

printf ("Programa para obtener g a partir de un plano inclinado de");

printf ("\nángulo conocido y una partícula de la cual sabemos su");

printf ("\naceleración al resbalar sobre él (sin fricción).");

printf ("\n\nLos datos que nos darán la constante correcta se deben");

printf ("\nobtener en el laboratorio, pues datos mal obtenidos nos");

printf ("\npueden arrojar resultados sin sentido físico.");

printf ("\n\nValor del ángulo del plano inclinado (en grados): ");

scanf ("%f", &angulo);

printf ("\nIntroduzca el valor de la aceleración (en m/s²): ");

scanf ("%f", &aceleracion);

g=obt_g(angulo, aceleracion);

printf ("\n\nEl valor de g obtenido es: %7f", g);

printf ("\nPulse una tecla para terminar...");

getch ();

}

float obt_g (float angulo, float aceleracion) {

float x;

x=aceleracion/sin(angulo*3.141592/180);

return (x); }

/************************************************************************/

/* */

/* Programa que procesa un conjunto de datos para obtener su promedio */

/* y desviación estándar. */

/* */

/* La función main() pide el número de elementos del conjunto, */

/* cada elemento del conjunto y lo despliega. Posteriormente llama */

/* a las funciones paso por referencia prom() y desv_std() para */

/* imprimir en la misma función main() los resultados. */

/* */

/* Programador: Goofy */

/* Fecha: 09/ene/1998 */

/* Materia: Computación I */

/* */

/************************************************************************/

#include <stdio.h>

#include <conio.h>

#include <math.h>

#include <string.h>

double prom (double *datos, int n);

double desv_std (double *datos, int n);

int PedirEntero (int x, int y, char *mensaje, int min, int max, char *errmsg);

void Aviso (char *mensaje, int fila);

char *err = "El número de elementos es menor que 100 y mayor que cero (entero).";

void main (void) {

int n, /* Número de elementos del conjunto */

i, j, /* Variables temporales (contadores) */

result; /* Resultado de una lectura scanf */

double datos[100]; /* Conjunto de datos */

for (i=0; i<100; i++)

datos[i]=0.0;

clrscr ();

gotoxy (8, 8);

printf ("Programa que procesa un conjunto de datos.");

n=PedirEntero (8, 11, "Introduzca el número de elementos del conjunto: ", 1, 100, err);

clrscr (); /* Este bloque captura el conjunto de datos */

for (i=0,j=0; i<n; i++) { /* en el arreglo "datos" */

if (i%20==19) {

clrscr ();

j++; }

do {result=0;

gotoxy (10, 3+i-20*j);

printf (" ");

gotoxy (10, 3+i-20*j);

printf ("Introduzca elemento %3d: ", i+1);

result=scanf ("%lf", &datos[i]);

if (result!=1)

Aviso ("Vuelva a intentar con un número real.", 24);

} while (result!=1); }

clrscr ();

gotoxy (2, 1);

printf ("El conjunto de datos es el siguiente:");

textcolor (DARKGRAY);

for (i=0,j=0; i<n; i++) {

if ((i-1)%20==19)

j++;

gotoxy (1+j*14, 2+i-20*j);

cprintf ("%13f", datos[i]); }

textcolor (WHITE);

gotoxy (2, 23);

printf ("El promedio es: %.7f ", prom(datos, n));

printf ("La desviación estándar: %.7f", desv_std(datos, n));

Aviso ("Pulse una tecla para terminar...", 25);

getch ();

}

/****************** Fin de la función main() **********************/

double prom (double *datos, int n) {

int i;

double suma=0.0;

for (i=0; i<n; i++)

suma+=datos[i];

suma/=(double) n;

return (suma); }

/*--------- Fin de prom() ---------*/

double desv_std (double *datos, int n) {

int i;

double suma=0.0, p=0.0;

p=prom (datos, n);

for (i=0; i<n; i++)

suma+=pow(datos[i] - p, 2.0);

suma=sqrt(suma/((double) n));

return (suma); }

/*----------- Fin de desv_std() ---------------*/

int PedirEntero (int x, int y, char *mensaje, int min, int max, char *errmsg)

{ int resp, temp;

do { gotoxy (x, y);

printf ("%s\t\t\t", mensaje);

gotoxy (x + strlen(mensaje), y);

scanf ("%d", &resp);

if (resp<min||resp>max)

Aviso (errmsg, 24);

} while (resp<min||resp>max);

}

/*------------------ Fin de PedirEntero() ---------------*/

void Aviso (char *mensaje, int fila)

{ int i;

gotoxy (1, fila); for (i=0; i<79; i++) printf (" ");

gotoxy ((79-strlen(mensaje))/2, fila); printf ("%s", mensaje);

}

/*------------------- Fin de Aviso() ---------------------*/

/************************************************************************/

/* */

/* El programa acepta volumenes cargados de gasolina en un automóvil. */

/* Aceptará también el kilometraje en cada toma de gasolina para */

/* obtener el rendimiento del vehículo. Los datos se guardan en dos */

/* matrices: tomas[] y km[]. La función rendim() retornará el rendi- */

/* miento a la función main(), donde se imprimirá. */

/* */

/* Para pedir las matrices, se utilizará la función captura(), que */

/* retornará el número de tomas de gasolina. */

/* */

/* Programador: Goofy */

/* Fecha: 09/ene/1998 Materia: Computación I */

*/

/* */

/************************************************************************/

#include <stdio.h>

#include <conio.h>

int captura (int *tomas, int *km);

float rendim (int *tomas, int *km, int n);

void main (void) {

int n; /* Número de tomas de gasolina */

int *tomas, *km; /* Arreglos de tomas de gas y lecturas */

float r=0; /* Rendimiento */

clrscr ();

printf ("Introduzca las tomas de gasolina que hizo con sus respectivas");

printf ("\nlecturas de kilometraje. Cuando termine, responda con 0.");

n=captura (tomas, km); /* Llama a la función de captura */

if (n>0) /* Llama a rendim() para obtener rendimientos */

r=rendim (tomas, km, n);

printf ("\n\nEl automóvil está dando %.1f km por litro.", r);

printf ("\nPresione una tecla para terminar...");

getch ();

}

/****************** Fin de la función main() **********************/

int captura (int *tomas, int *km) {

int n; /* Número de tomas */

for (n=0; ; n++) {

printf ("\nToma %3d (0 para terminar), en litros: ", n+1);

scanf ("%d", &tomas[n]);

if (tomas[n]==0)

break;

printf ("Lectura %3d, en km: ", n+1);

scanf ("%d", &km[n]); }

return (n); }

/*----------- Fin captura() ------------*/

float rendim (int *tomas, int *km, int n) {

int i, gas=0, dist=0;

float r;

for (i=0; i<n; i++)

gas+= tomas[i];

dist=km[--i]-km[0];

r=((float) dist)/((float) gas);

return (r); }

/*----------- Fin rendim() -------------*/

/************************************************************************/

/* Programa SNAKE. Es un arreglo de letras introducidas por el usuario */

/* (una cadena) para hacer efectos visuales. */

/* */

/* Se utilizan funciones paso por referencia para pasar los arreglos. */

/* */

/* Programador: Goofy */

/* Fecha: 09/ene/1998 Materia: Computación I */

/* */

/************************************************************************/

#include <stdio.h>

#include <conio.h>

void inicializar (char *nombre, char *i, char *j, char *cnt);

void desplegar (char *nombre, char *i, char *j);

void rotar_pantalla (char *cnt, char *nombre);

int nomlen;

void main (void)

{ char *nombre, *i, *j, *cnt;

int c, x, dirx=-1, diry=-1;

clrscr ();

gotoxy (8,8); printf ("¿Cómo te llamas? ");

gets (nombre);

inicializar (nombre, i, j, cnt); /* Asigna posiciones y otros */

cnt=nombre; /* parámetros varios */

clrscr ();

do {

desplegar (nombre, i, j); /* Despliega la serpiente */

if (i[0]<3||i[0]>77) dirx*=-1; /* Esta sección cambia */

if (j[0]<3||j[0]>23) diry*=-1; /* las posiciones de las */

for (x=nomlen-1; x>0; x--) { /* letras de acuerdo a */

i[x]=i[x-1]; /* la naturaleza de su */

j[x]=j[x-1]; } /* movimiento. */

i[0]+=dirx;

j[0]+=diry;

rotar_pantalla (cnt, nombre); /* Rota orillas de pantalla */

putchar (*(cnt++)); /* Pone el nuevo caracter */

if (*cnt=='\0') /* en la orilla de la pant.*/

cnt=nombre;

delay (80); /* Baja velocidad de corrida */

c=kbhit(); /* Revisa el teclado */

} while (c==0); /* Termina con un teclazo */

}

void inicializar (char *nombre, char *i, char *j, char *cnt) {

int x;

nomlen=strlen(nombre);

nombre[nomlen]=' ';

nombre[nomlen+1]='\0';

nomlen++;

for (x=0; x<nomlen; x++) {

i[x]=10+x;

j[x]=9; } }

void desplegar (char *nombre, char *i, char *j) {

int x;

for (x=0; x<nomlen; x++) {

gotoxy (i[x],j[x]);

printf ("%c", nombre[x]); } }

void rotar_pantalla (char *cnt, char *nombre) {

movetext (79, 1,79,24,79, 2);

movetext ( 1, 1,78, 1, 2, 1);

movetext ( 1, 2, 1,25, 1, 1);

movetext ( 2,25,78,25, 1,25);

gotoxy (78,25); }

/************************************************************************/

/* */

/* Programa RELLENO. Es un dibujo de un teclado musical que rebotará */

/* en la pantalla haciendo ruidos.Se utiliza una función paso por valor.*/

/* */

/* Programador: Goofy */

/* Fecha: 09/ene/1998 Materia: Computación I */

/* */

/************************************************************************/

#include <stdio.h>

#include <conio.h>

#include <dos.h>

char t[] = "_ _ __ _ _ _";

char b[] = "____________";

void *ventana;

void vueltas (int freq);

void main (void) {

clrscr ();

gotoxy (2,2); printf ("%s%s%s%s%s", t,t,t,t,t);

gotoxy (2,3); printf ("%s%s%s%s%s", t,t,t,t,t);

gotoxy (2,4); printf ("%s%s%s%s%s", b,b,b,b,b);

vueltas (50);

nosound ();

}

void vueltas (int freq) {

int i=1, j=1, dir=1, c, di=1;

gettext (1, 1, 62, 5, ventana);

do {

puttext (j, i, j+61, i+4, ventana);

if (i<1) di=1;

if (i>21) di=-1;

if (j>19) dir=-1;

if (j<1) dir=1;

i+=di;

j+=dir;

c=kbhit();

sound (j*freq); delay (30);

} while (c==0);

}