INSTITUTO POLITECNICO NACIONAL

ESCUELA SUPERIOR DE INGENIERIA MECANICA Y ELECTRICA

ENTREGA DE PRÁCTICAS DE PROGRAMACIÓN

Marín Zavaleta Andrés Arturo

 ÍNDICE
1.- Medida en Ft a Yardas, pulgadas, metros, centímetros y
milímetros.

2.-Cantidad de n años a meses, semanas, días, horas y segundos.

3.-Lee la masa y la distancia entre dos cuerpos para calcular e

imprimir la fuerza gravitacional entre los dos cuerpos, sabiendo
que: F=(G*m1*m2)/d^2, donde G=6.673*10-8

4.-Calcula e imprime la cantidad que recorre un haz de luz en 6

horas, en kilómetros y millas.

5.-Lee la temperatura en grados Celsius, y obtenga su equivalencia

en Fahrenheit, Kelvin y Rankine.

6.- Calcula la pendiente y distancia.

7.- Imprime en pantalla las iniciales de su nombre utilizando

asteriscos.

8.-Evalúa en una tabla la función seno y coseno de los ángulos 20,

45 y 90 en RAD y DEG.

9.-Evalúa el valor un ángulo en la función seno y coseno y da el

resultado en RAD Y DEG.

10.- Calcula el área de un círculo de r=5 usando Pow y definiendo PI.

11.-Evalúa el voltaje que debería de suministrar una pila para que

por una bombilla con una resistencia de 3.75 ohms pasen 4A y así
mismo la potencia máxima que necesita para encender.
Esta es una breve introducción al pequeño compendio de prácticas de
programación orientado a la realización de ciertos programas utilizando los
temas vistos de la unidad I y unidad II en el lenguaje de programación conocido
como “Lenguaje C”, entre los cuales están las operaciones básicas, así mismo,
su propia sintaxis que se debe de llevar a cabo de manera correcta para que el
programa se ejecute de la manera esperada y otorgue el resultado final como
correcto, a la par de esto el uso adecuado de los diagramas de flujos con el fin
de ayudar a visualizar el código para programar ciertas operaciones, como
sumas, algunas formulas, etc., que al principio puedan ser tediosas de plantear
de manera mental.

Con esto se espera lograr un mayor entendimiento tanto teórica, como de

manera práctica a cada uno de los programas contenidos en este compendio,
así mismo se espera que este mismo funcione como “herramienta” de estudio
para dar una cierta solidez a los conocimientos base vistos de la materia durante
las unidades previamente mencionadas.

Durante cada uno de los programas en el compendio se constará de 4 puntos a

tratar:

• Desarrollo (Ejercicio Resuelto)

• Diagrama de flujo
• Programa
• Pantalla de salida

Estos mismos ayudarán a que la lectura de los programas sea más sencilla y a
la par, sea concisa.
El primer programa por tratar es aquel que se encarga de realizar una
conversión de unidades, tal que de Pies (ft) se pase cualquier cantidad de esta;
a yardas, a metros, a pulgadas, a centímetros y milímetros.

Para esto se necesitan conoce las operaciones y equivalencias respectivas

necesarias para llevar a cabo este proceso, las cuales son:

yd=.33333 Pies a yardas=ft*yd

in=12 Pies a pulgadas=ft*in

Pies a metros=ft*m
m=.3048
Pies a centímetros=ft*cm
mm=304.8
Pies a milímetros=ft*mm
cm=30.48

Dando a conocer estos datos, se plantea el siguiente diagrama de flujo para

analizar de manera un poco más “visual” al código que se usará en la creación
de este programa.
Al visualizar el diagrama de flujo, nos damos cuenta de que el programa es
sencillo y nada largo, por lo siguiente el código de manera textual quedaría de
la
#include<stdio.h>
siguiente
#include<math.h>
manera:
int main()

float
ft,ftyd,ftin,ftm,ftcm,ftmm,yd=.33333,in=12,m=.3048,mm=304.8,cm=30.48;

printf("\n\n\tConvertir FT a varias unidades");

printf("\n\n\tDame el valor en Ft:");

scanf("%f",&ft);

ftyd=ft*yd;

ftin=ft*in;

ftm=ft*m;

ftcm=ft*cm;

ftmm=ft*mm;

printf("\n\n\tFt a Yardas=%g",ftyd);

printf("\n\n\tFt a pulgadas=%g",ftin);

printf("\n\n\tFt a metros=%g",ftm);

printf("\n\n\tFt a centimetros=%g",ftcm);

printf("\n\n\tFt a milimetros=%g",ftmm);

Al ejecutar el programa veremos una pantalla de salida que lucirá de esta

manera:
Por lo tanto, podemos concluir este programa es útil y se puede llevar a la
práctica si durante nuestro día a día se está en contacto con el sistema inglés,
además ayuda a comprender mejor la importancia de declarar variables fijas,
para determinar cierto resultado de alguna operación.

El segundo programa por tratar es el encargado de realizar la conversión de

determinado número de años a su respectiva equivalencia a meses, días, horas
y segundos. Para lo cual es necesario conocer la equivalencia de estos mismos
y sus operaciones, las cuales se muestran a continuación:

Meses:12 Meses=n*12
Semanas=n*52
Semanas:52
Días=n*=365
Días:365
Horas=n*8760
Horas:8760 Segundos=n*31536
Segundos:31536

Posteriormente el diagrama de flujo para la resolución de este programa es:

Veremos cómo sigue, el código para desarrollar este programa queda de la
siguiente manera:
#include <stdio.h>

#include <math.h>

int main()

float n,meses,semanas,dias,horas,segundos;

printf("De anos a meses,semanas,dias,horas y segundos");

printf("\n\n\tInserte una cantidad de anos:");

scanf("%f",&n);

meses=n*12;

semanas=n*52;

dias=n*=365;

horas=n*8760;

segundos=n*31536;

printf("\n\n\tSu equivalencia a meses es: =%g",meses);

printf("\n\n\tSu equivalencia a semanas es: =%g",semanas);

printf("\n\n\tSu equivalencia a dias es: =%g",dias);

printf("\n\n\tSu equivalencia a horas es: =%g",horas);

printf("\n\n\tSu equivalencia a segundos es: =%g",segundos);

}
Y finalmente su pantalla de salida para visualizar la conversión sería la mostrada
debajo:
Este programa nos ayuda a comprender mejor la duración de un año con sus
respectivas equivalencias y así mismo al aplicar de mejor manera la sintaxis del
scanf(), ya qué permite introducir una n cantidad de años.

Por consiguiente, se seguirá con el tercer programa, el cual se encarga de

calcular la fuerza entre dos masas a determinada distancia, todas estas
variables mencionadas respectivamente son propuestas por el usuario. Para ello
se debe de conocer la constante G y su fórmula.

G=6.673e-8

F=(g*m1*m2) /(d*d)

Previamente conociendo la constante y su valor, con la formula requerida para

el calculo de la fuerza, el diagrama de flujo queda como sigue:
Conociendo el diagrama de flujo se procede a realizar el código para
posteriormente visualizar el resultado en la pantalla de salida:

#include <stdio.h>

#include <math.h>

int main()

float f,m1,m2,d,g=6.673e-8;

printf("\n\n\tCalcular la fuerza
gravitacional");

printf("\n\n\tDeme la masa 1:");

scanf("%f",&m1);

printf("\n\n\tDeme la masa 2:");

scanf("%f",&m2);

printf("\n\n\tDeme la distancia:");

scanf("%f",&d);

f=(g*m1*m2)/(d*d);

printf("\n\n\tLa fuerza es = %g",f);

Entonces la pantalla de salida queda como:

Por esta pantalla de salida, se logra concluir el como desarrollar la formula de la
fuerza dentro del lenguaje C dando cualquier valor a la masa1, a la masa 2 y a la
distancia entre estos dos cuerpos haciendo un uso más extenso de la sintaxis del
scanf().

El cuarto programa se encarga de calcular la distancia que recorre un haz de

luz en un periodo de 6 horas y arroja el resultado en kilómetros y millas. Para
ello debemos conocer la constante de la velocidad de la luz en kilómetros y
millas junto a su operación.
km=luzenkm*21600
Luz en kilómetros=299792458
millas=luzenmillas*6
Luz en millas=186282.397

Conociendo los datos anteriores, se analizará el procedimiento en un diagrama

de flujo para analizarlo de manera visual y después plasmarlo en código para
finalmente observar el resultado en la pantalla de salida.
Y el código ya realizado se mira de la siguiente forma:

#include <stdio.h>

#include <math.h>

int main()

float km,millas,luzenkm=299792458,luzenmillas=186282.397;

printf("\n\n\tCalcula la cantidad de km que recorre un haz de luz en 6 horas");

km=luzenkm*21600;

millas=luzenmillas*6;

printf("\n\n\tLa cantidad de km en 6 horas es = %g",km);

printf("\n\n\tAhora la cantidad de millas en 6 horas es = %g",millas);

Y la pantalla de salida luce así:

Este programa ayuda a concluir la importancia que se tiene al momento de

declarar alguna constante, ya que, aunque no se haya declarado con la sintaxis
#define, se ve claramente que el uso de estas es algo que no se puede omitir
en programas similares, ya que simplifican de cierto modo el código.
En este quinto programa, se realiza una conversión de unidades de temperatura,
la cual va de Celsius a su respectiva equivalencia en Fahrenheit, Kelvin y
Rankine, para ello debemos conocer sus formulas para obtener su equivalente.

Fahrenheit=(Celsius*1.8) +32

kelvin=Celsius+ 273.15

Rankine=Celsius=(Celsius*1.8) +459,67

Posteriormente se analiza el diagrama de flujo para posteriormente observar

como es que el código se mira al final para al concluir se vea la pantalla de
salida la conversión correcta.
Observando el diagrama de flujo, se determina que el código queda como sigue:

#include <stdio.h>

#include <math.h>

int main()

float celsius,fahrenheit,kelvin,rankine;

printf("\n\n\tEquivalencia de celsius a Fahrenheit, Kelvin y Rankine");

printf("\n\n\tDame Celsius:");

scanf("%f",&celsius);

fahrenheit=(celsius*1.8)+32;

kelvin=celsius+ 273.15;

rankine=celsius=(celsius*1.8)+459,67;

printf("\n\n\tEl valor de celsius a fahrenheit es= %g",fahrenheit);

printf("\n\n\tEl valor de celsius a kelvin es= %g",kelvin);

printf("\n\n\tEl valor de celsius a rankine es= %g",rankine);

Y
finalmente la pantalla de salida donde se mira el resultado queda de la siguiente
forma:
Por este programa, nos permite simplificar el método que se tiene que realizar
al momento de convertir Celsius a sus otras unidades de temperatura, como el
Rankine o el Kelvin demostrando como es que se debe de colocar la sintaxis
para obtener el resultado deseado.

El quinto programa se encarga de calcular la distancia y la pendiente entre dos

puntos, dando el usuario como variable x1, x2, y1, y2, para ello es necesario
conocer las formulas necesarias para realizar la operación, las cuales son:

d=sqrt((x2-x1) *(x2-x1)+(y2-y1)*(y2-y1))

m=(y2-y1) /(x2-x1)

Habiendo conocido las formulas correspondientes, se procede a realizar el

diagrama de flujo, como antes ya fue mencionado, para la visualización del
programa de una manera más visual, el cual es el siguiente:
Conociendo el diagrama de flujo se procede a realizar el código para dicho
calculo, el cual queda como sigue:

#include <stdio.h>

#include <math.h>

int main ()

float d,m,x1,x2,y1,y2;

printf("\n\n\tCalcula la pendiente y la distancia entre dos

puntos");

printf("\n\n\tDame el valor de x1:");

scanf("%f",&x1);

printf("\n\n\tDame el valor de x2:");

scanf("%f",&x2);

printf("\n\n\tDame el valor de y1:");

scanf("%f",&y1);

printf("\n\n\tDame el valor de y2:");

scanf("%f",&y2);

d=sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));

m=(y2-y1)/(x2-x1);

printf("\n\n\tDame el valor de la distancia=%g",d);

printf("\n\n\tDame el valor de la pendiente=%g",m);

}
Y la pantalla de salida posterior a la ejecución del programa, se visualiza así:
Al observar el código y la pantalla de salida de este programa, podemos deducir
que es de suma importancia declarar las variables correctas, ya que al momento del
procedimiento, es importante almacenar los respectivos valores que el usuario
proporcione para que la operación sea hecha correctamente.
El programa a continuación se encarga de realizar una pantalla de salida en la cual
se observa, la inicial de mi nombre con asteriscos. Por lo cual mi inicial es:
*A*
Dicho eso, a partir de aquí se omitirá el diagrama de flujo y se pasará enseguida
con el programa para así mostrar finalmente su pantalla de salida.

#include <stdio.h>

int main()

printf(" **\n ****\n ** **\n********\n********\n**

**\n** **\n\n");

Finalmente, al ejecutarse, la pantalla de salida luce así:

Se concluye que tras la realización de este programa, se hace enfasis al uso de la

sintaxis \n, ya que nos permite cambiar de linea para así poder hacer un texto con
cierta creatividad y a la vez manejar este tipo de sintaxis de mejor manera.
Este programa a continuación evalúa los angulos 20, 45 y 90 en las funciones Seno
y Coseno tanto en Radianes como en grados. Por lo tanto en este programa se
deben de conocer las funciones trigonómetricas.
Sin(x)
Cos(x)
Por lo tanto, el programa queda como sigue:
#include<stdio.h>
#include<math.h>
#define PI 3.141592
int main()
{
float s1,c1,s2,c2,s3,c3,a,b,c;
printf("\n\n\t\t\tANGULOS EN RADIANES Y GRADOS");
printf("\n\n\tDame el primer angulo:");
scanf("%f",&a);
printf("\n\n\tDame el segundo angulo:");
scanf("%f",&b);
printf("\n\n\tDame el tercer angulo:");
scanf("%f",&c);
s1=sin(a);
s2=sin(b);
s3=sin(c);
c1=cos(a);
c2=cos(b);
c3=cos(c);
printf("\n\n\n\tRADIANES\n\n\n\t ANG SIN COS");
printf("\n\t20\t%f %f",s1,c1);
printf("\n\t45\t%f %f",s2,c2);
printf("\n\t90\t%f %f",s3,c3);
s1=sin(a*(PI/180));
s2=sin(b*(PI/180));
s3=sin(c*(PI/180));
c1=cos(a*(PI/180));
c2=cos(b*(PI/180));
c3=cos(c*(PI/180));
printf("\n\n\n\tGRADOS\n\n\n\t ANG SIN COS");
printf("\n\t20\t%f %f",s1,c1);
printf("\n\t45\t%f %f",s2,c2);
printf("\n\t90\t%f %f",s3,c3);
}
Y la pantalla de salida se mira así:

Se concluye tras la realización de este programa el uso correcto de la sintaxis Sin()

y Cos() para cualquier valor, pero en este especifico, solo de 20, 45 y 90, con su
respectiva equivalencia en radianes y grados, de la misma forma el uso de la sintaxis
#define para poner constantes globales.
El programa a continuación realiza una función similar al anterior, sin embargo esta
pasa de un valor en Radianes a Deg, por lo tanto los valores en la pantalla final
serán distintos. Para hacerlo es necesario conocer las funciones trigonometricas.
Sin(x)
Cos(x)
A continuación se presentará el código del programa, que es bastante similar al
anterior, solo que más corto.
#include<stdio.h>
#include<math.h>
#define PI 3.141592
int main()
{
float s1, c1,a;
printf ("\n\n\t\t\tFUNCIONES TRIGONOMETRICAS");
printf ("\n\n\tDame el valor del angulo:");
scanf ("%f",&a);
s1=sin(a);
c1=cos(a);
printf("\n\n\n\tVALORES EN RADIANES");
printf("\n\tEl valor de Seno=%f",s1);
printf("\n\tEl valor de Coseno=%f",c1);
a=a*PI/180;
s1=sin(a);
c1=cos(a);
printf("\n\n\n\tVALORES EN DEG");
printf("\n\tEl valor de Seno=%.5f",s1);
printf("\n\tEl valor de Coseno=%f",c1);
}
Al ejecutar el código, la pantalla de salida queda así:

De conclusión de este programa, tenemos una bastante similar, sin embargo, en

este se calcula el valor de seno y coseno en radianes y a su vez en DEG, que es
como los arroja la calculadora, y esa es su distinción del anterior.
El penúltimo programa de este compendio de prácticas se encarga de calcular el
área de un circulo con un radio determinado de valor 5 y a la par del uso de la
función Pow.
Para ello debemos conocer el valor de PI y conocer la fórmula para el área del
círculo.
PI
Area=PI*pow(r,2)
Al realizar el programa el código queda como sigue:
#include<stdio.h>
#include<math.h>
#define PI 3.141592
int main()
{
float r=5,Area;
printf("\n\n\tEl area de un circulo de radio 5");
Area=PI*pow(r,2);
printf("\n\n\t Area=%g",Area);
}
La pantalla de salida se ve de la siguiente manera:

Posterior a la ejecución del programa se concluye la importancia en la sintaxis de

pow, ya que esta misma nos ayudará a utilizar potencias durante todo este
programa y posteriores a este. Así mismo volevemos a ver el uso de la constante
PI usando la sintaxis #define.
Finalmente, el último programa de este compendio se encarga de calcular el voltaje
y la potencia de un circuito con ciertos valores ya dados, como es su resistencia y
corriente electrica. Para ello se deben de conocer las formulas del voltaje y la
potencia, las cuales son:
V=AxΩ
P=V*I
Con estos datos se procede a la construcción del código, y queda como sigue:
#include<stdio.h>
#include<math.h>
int main()
{
float rbombilla=3.75,corriente=4,voltaje,potencia;
printf("\n\n\tEL VOLTAJE Y POTENCIA DE UN CIRCUITO");
voltaje=rbombilla*corriente;
printf("\n\n\tEl voltaje necesitado es =%g",voltaje);
potencia=voltaje*corriente;
printf("\n\n\tLa potencia maxima que necesita para encender es=%g",potencia);
}
Al final, la pantalla de salida queda como sigue:
Para concluir, el ultimo programa nos enseña a como resolver un circuito con cierta
resistencia y corriente, para así determinar el voltaje y la potencia del mismo,
usando la función Pow o simplemente usando la sintaxis correcta durante la
operación en el código.
En conclusión, podemos decir que la realización de los diagramas de flujos a la hora
anterior a programar nos lleva a un mejor entendimiento del código próximo a
realizar, ya que funciona como un material de guía para realizarlo de forma correcta.

Además, este tipo de compendio funciona como material de estudio, ya que, en el

proceso de su realización, así mismo durante su lectura, se permite repasar y
analizarlo durante el mismo logrando así un mayor entendimiento de la sintaxis, ya
que el conocimiento se volverá aún más sólido de lo que es.

Así mismo al realizar cada uno de los problemas se hace énfasis a que la revisión
minuciosa del código es esencial, ya que a pesar de que “CodeBlocks” resalte los
errores de sintaxis, es muy fácil que al usuario deje pasar alguna coma, algún punto
y coma, alguna comilla, algún paréntesis, por lo tanto, se sugiere que, al realizar
cada código, por mas pequeño que sea; se de una revisión detallada y minuciosa
del mismo.

REFERENCIAS:

FUNDAMENTOS DE PROGRAMACIÓN Algoritmos, estructura de datos y objetos.

Luis Joyanes

Aguilar, Editorial Mc Graw Hill, Cuarta edición,2008