PORTAFOLIO DE
EVIDENCIAS
PROYECTO INTEGRADOR Y COMPRENSIVO I
Integrantes: Adriana Medina Beltrán Alejandro Astrolabio Zavala Ramírez Mauricio López Camacho
Grupo: E15-429
Profesor: Gilberto Santillán Tovar
Fecha: 19/02/15
Contenido
Introducción a Lenguajes de Programación ............................................................................................... 4
Breve historia ......................................................................................................................................................... 4
Diagramas de flujo ............................................................................................................................................... 6
Lenguaje algorítmico .......................................................................................................................................... 7
Lenguaje C ...................................................................................................................................................................... 7
Compilador .................................................................................................................................................................. 7
Biblioteca estándar de C ................................................................................................................................. 8
Partes de un programa ........................................................................................................................................ 9
Variables .................................................................................................................................................................. 11
Por su tipo de datos .................................................................................................................................... 11
Por su tipo de almacenamiento ............................................................................................................... 12
Instrucciones de E/S ........................................................................................................................................ 13
Operadores y expresiones ............................................................................................................................... 14
Operadores aritméticos ................................................................................................................................ 14
Operadores relacionales y lógicos ...................................................................................................... 14
Condicionales ......................................................................................................................................................... 15
Sentencia if ....................................................................................................................................................... 15
Sentencia if completa .................................................................................................................................. 16
Operador condicional .................................................................................................................................... 17
Instrucción “switch” ........................................................................................................................................ 17
Sentencias de repetición ............................................................................................................................... 18
Instrucción “”while” .................................................................................................................................... 18
La instrucción do-while ............................................................................................................................. 19
La instrucción “for” .................................................................................................................................... 19
Funciones .................................................................................................................................................................. 20
Arreglos ..................................................................................................................................................................... 21
Prácticas desarrolladas ..................................................................................................................................... 24
Prácticas .................................................................................................................................................................. 24
Calculadora .......................................................................................................................................................... 24
5.7.6 Divisores de un número.................................................................................................................. 26
5.4.1 Tablero de ajedrez ........................................................................................................................... 27
5.4.1 Tablero de ajedrez definido por el usuario .................................................................. 28
5.3.7 Promediador ............................................................................................................................................ 30
5.3.2 Cuadrados y cubos ............................................................................................................................. 32
Portafolio de evidencias PIC I
4.6.1 Sueldos e incentivos ...................................................................................................................... 33
4.5.6 Cajero automático ............................................................................................................................. 35
4.4.6 Tipos de curva .................................................................................................................................... 37
4.3.5 Elecciones de candidatos ............................................................................................................. 39
3.6.8 Lectura de datos ................................................................................................................................ 41
3.5.2 Horas, minutos y segundos .......................................................................................................... 43
3.5.2b Horas, minutos y segundos 2 ................................................................................................... 44
3.5.1 Fuerza entre dos cargas eléctricas ..................................................................................... 45
3.4.3 Volumen y área de un cilindro ................................................................................................. 47
3.4.2.b Operaciones con variables asignadas .............................................................................. 48
3.1.4 Sentencias de salida y uso de tabulador ......................................................................... 49
3.1.2 Sentencias de salida ...................................................................................................................... 50
Ejemplos ..................................................................................................................................................................... 51
Volumen y área de una esfera.................................................................................................................. 51
Menú de opciones .............................................................................................................................................. 52
Lectura de datos .............................................................................................................................................. 53
Condicional if ................................................................................................................................................... 54
Asignaciones 1 ................................................................................................................................................... 55
Asignaciones 2 ................................................................................................................................................... 56
Conclusión .................................................................................................................................................................... 56
Universidad Politécnica de San Luis Potosí
Página 3
Portafolio de evidencias PIC I
Introducción a Lenguajes de Programación
Breve historia
La historia de la computación se
remonta al uso del ábaco, el cual
es considerado como una de las
primeras herramientas de cómputo.
En el siglo XVII John Napier
inventó los logaritmos para
simplificar las operaciones de
multiplicación y división, las
estructuras de Napier (unos
palillos impresos con las tablas
del 1 al 9) se pueden realizar
rápidamente operaciones de
multiplicación mediante simples
sumas de un solo dígito.
Otra herramienta que ayudo al avance en la computación fue la regla de cálculo,
la cual está basada en algoritmos. Con la regla de cálculo es posible hacer
operaciones de multiplicación y división de forma muy rápida con una precisión de
2 o 3 dígitos.
En 1642 pascal creo la primera calculadora mecánica, la cual realizaba sumas
mediante ruedas dentadas. En base a primera calculadora mecánica se fueron
creando mejores versiones.
En 1945 se desarrolló el Calculador e Integrador Numérico Digital Electrónico
(ENIAC), Algunas características de la ENIAC eran:
18,000 tubos de vacío
70,000 resistores
10,000 capacitores
150 kilovatios de potencia
15,000 metros cuadrados de superficie
30 toneladas de peso trabajo
80223 horas
Se programaba mediante alambrado
Después de ENIAC se desarrollaron 5 generaciones de
computadoras
Primera Generación (1951-1958)
La primera generación se basó en tubos de vacío,
tarjetas perforadas, tambores magnéticos y eran
grandes y pesadas y consumían una gran cantidad de
potencia eléctrica.
Segunda generación (1958 – 1964)
Uso de transistores que vinieron a sustituir a los
bulbos. Memoria de núcleos de ferrita. Se
desarrollaron lenguajes como FORTRAN y COBOL.
Universidad Politécnica de San Luis Potosí
Página 4
Portafolio de evidencias PIC I
Tercera Generación (1964-1971)
Desarrollo de los circuitos integrados que permitieron compactar una gran
cantidad de transistores. Los circuitos integrados recuerdan los datos, ya que
almacenan la información como cargas eléctricas.
Cuarta Generación (1971-1983)
Computadoras basadas en el microprocesador que integra en un solo chip toda la
lógica de control de la computadora.
Quinta Generación (1983 al presente)
Se expande el uso de las computadoras personales. Aparecen nuevos equipos
personales como las Laptop, Palmtop, Netbook, etc.
La programación es parte de nuestra vida cotidiana ya que la mayoría de los
aparatos electrónicos están programados.
Universidad Politécnica de San Luis Potosí
Página 5
Portafolio de evidencias PIC I
Diagramas de flujo
Se conoce como diagramas de flujo a
aquellos gráficos representativos que se
utilizan para esquematizar conceptos
vinculados a la programación.
Para que el diagrama de flujo tenga sentido
como tal, debe existir un camino hacia una
solución que parte de un único inicio y
arriba a un único punto final.
Con el propósito de desarrollar un diagrama
de estas características, se recomienda
definir el propósito y destinatario del
gráfico, identificar las ideas principales,
determinar los límites y alcance del
proceso a detallar, establecer el nivel de
detalle requerido, identificar acciones,
procesos y subprocesos, construir el
diagrama y finalmente titularlo con exactitud.
Estos son los elementos que conforman un diagrama de flujo:
Universidad Politécnica de San Luis Potosí
Página 6
Portafolio de evidencias PIC I
Lenguaje algorítmico
Para resolver un problema mediante programación, es fundamental comprender el
problema en sí. Una vez que el problema se entiende, se procede al diseño del
algoritmo para resolverlo. Después de que el algoritmo ha sido escrito y probado
en forma de pseudo código, se puede proceder a traducirlo a algún lenguaje que la
computadora entienda para que pueda ser ejecutado por ésta.
Definiremos un lenguaje para expresar los algoritmos de una forma conveniente. El
lenguaje algorítmico será cercano al lenguaje C para facilitar la traducción a
programas ejecutables. Veamos el siguiente ejemplo:
Algoritmo Volumen de esfera. Este algoritmo calcula el volumen de una esfera dado
su radio. Se utiliza la variable RADIO para representar el radio de la esfera y
la variable VOLUMEN para representar su volumen. Suponemos ambas variables como
números reales.
1. [Leer el radio de la esfera]
Leer(RADIO)
2. [Calcular el volumen de la esfera]
VOLUEN = 4*3.1416*RADIO^3
3. [Se imprimen el dato y el resultado]
Escribe(“El radio de la esfera es “, RADIO)
Escribe(“El volumen de la esfera es ”, VOLUMEN)
4. [Termina]
Salir
El algoritmo se llama “volumen de esfera”. Es conveniente siempre asignar un
nombre a cada algoritmo para poder identificarlo claramente además de hacer una
breve descripción del propósito del algoritmo al inicio, también en esta sección
se puede definir el tipo y propósito de cada una de las variables utilizadas.
Cada paso del algoritmo esta numerado secuencialmente. Los comentarios los
encerraremos en paréntesis cuadrados ( [ ] ). Estos comentarios solo sirven para
aclarar cada uno de los pasos del algoritmo. Se ha utilizado la palabra “Salir”
para indicar la terminación del algoritmo en la última línea.
Otros podrán tener varios finales, esto implica que algunos finales no se
encuentren en la última línea.
Lenguaje C
Compilador
Antes de poder ejecutar programas debemos de disponer de algún compilador de C.
En Internet se encuentran algunos compiladores de uso gratuito como Dev-C. Una
vez que dispongamos del compilador, escribimos el programa en el editor de texto
y lo guardamos con algún nombre. Algunos compiladores suponen que los programas
tienen extensión “.c” o “.cpp” generalmente. Una vez guardado en un archivo
podemos proceder a traducirlo a lenguaje máquina para que pueda ser ejecutado. El
proceso de traducción lo realiza el compilador, si no hay errores el compilador
generara un archivo ejecutable que podemos correr.
Si el compilador encuentra cualquier tipo de error, enviara el mensaje adecuado,
sobre todo si el compilador es del tipo de ambiente de trabajo como Dev-C. En
todo caso, deberá corregir los errores encontrados y volver a compilar hasta que
no haya errores.
El proceso de ejecución podemos separarlo en varias fases. La primera fase es la
escritura del programa en el editor de texto. Luego tenemos la fase de
Universidad Politécnica de San Luis Potosí
Página 7
Portafolio de evidencias PIC I
compilación del programa, estas dos fases pueden repetirse en caso de que haya
errores. La fase de compilación genera el programa ejecutable también llamado
programa objeto. Por ultimo esta la fase de ejecución en la que el programa es
ejecutado por la computadora, en este punto se introducen los datos de entrada,
si los hay, y se despliega la salida que se haya especificado, también si la hay.
También en la fase de ejecución se presentan errores, si los hay, estos errores
se deberán quizá a que el programa no cumple con las especificaciones para
Resolver el problema dado. Se deberá a proceder a corregir los errores que se
presenten en la ejecución repitiendo todo el proceso de escritura-compilaciónejecución nuevamente.
Biblioteca estándar de C
La biblioteca estándar de C (también conocida como libc) es una recopilación de
ficheros cabecera y bibliotecas con rutinas, estandarizadas por un comité de
la Organización Internacional para la Estandarización (ISO), que implementan
operaciones comunes, tales como las de entrada y salida o el manejo de cadenas.
A diferencia de otros lenguajes como COBOL, Fortran, o PL/1, C no incluye
palabras clave para estas tareas, por lo que prácticamente todo programa
implementado en C se basa en la biblioteca estándar para funcionar.
El lenguaje C contiene numerosas funciones, cuando se emplean funciones de esta
biblioteca estándar, se incrementa la transportabilidad de los programas.
Las funciones estándar se dividen en grupos, todas las funciones que pertenecen
al mismo grupo están declaradas en el archivo de cabecera, la letra "h" significa
header en inglés y es lo que se llama cabecera.
Para incluir alguna función perteneciente a estas cabeceras debemos escribir
líneas de código como se muestra de ejemplo:
#include
En la siguiente tabla se muestran los nombres de las bibliotecas más comunes y su
descripción.
BIBLIOTECAS Y DESCRIPCIONES DE USO
NOMBRE DE
BIBLIOTECA
assert.h
alloc.h
ctype.h
dir.h
errno.h
float.h
limits.h
math.h
setjmp.h
signal.h
DESCRIPCIÓN
Es proporcionar una definición de la macro assert, que imprime un
mensaje de error y aborta el programa
Existen funciones para asignar, liberar memoria, u obtener
información de bloques de memoria.
Son funciones que nos permiten conocer la naturaleza de un
caractér, o bien para convertir de mayúsculas a minúsculas y
viceversa; y valores enteros a códigos ASCII.
Esto permite ordenar, crear, modificar, mover y eliminar
directorios
Representa los números de error, después que ocurre un error se
puede consultar el valor de la variable del sistema deerrno para
obtener más información sobre ese error.
Define los límites de los tipos de coma flotante
Define los límites de los diferentes tipos de enteros
Contiene las funciones matemáticas estándar utilizadas en C y C++
Define el tipo de jmp_buf para algunas funciones.
Contiene funciones de estado.
Universidad Politécnica de San Luis Potosí
Página 8
Portafolio de evidencias PIC I
stdarg.h
stdef.h
stdio.h
stlib.h
string.h
time.h
Define funciones que pueden ser llamadas con diferentes números de
argumentos, de modo que se pueda escribir f(a) y f(a,b).
Se definen algunos tipos especiales
Incorporan las funciones de Entrada - Salida E/S estándar, tipos y
macros
Declara funciones que son útiles para diferentes propósitos, en
especial de búsqueda y ordenación.
Este archivo contiene funciones para manejo de cadenas de
caracteres.
Contiene funciones relativas a fechas y horas
Partes de un programa
Todo programa en C consta de uno o más módulos llamados funciones. Una de las
funciones se llama main. El programa siempre comenzará por la ejecución de la
función main, la cual puede acceder a las demás funciones. Las definiciones de
las funciones adicionales se deben realizar aparte, bien precediendo a main o
siguiendo a main.
Ejemplo:
/*Primer programa en C */
#include <stdio.h> /*biblioteca para entrada y salida*/
#include <conio.h> /*biblioteca para la función getch*/
int main()/*aquí inicia el programa */
{
printf("Hola mundo!.\n");/*sentencia de salida*/
getch();
return 0;/*terminación normal del programa*/
}/*fin del programa*/
La primera línea es un comentario. Los comentarios inician con “/*” y
terminan con “*/”.
La segunda línea sirve para incluir la biblioteca de entrada y salida. El
lenguaje C no tiene instrucciones de entrada y salida propias, por tanto
debemos siempre incluir alguna biblioteca para realizar estas operaciones.
La función main es la que contiene las sentencias ejecutables del programa.
Todo
programa en C debe tener una función main. La palabra int antes de main
indica que la función regresa un valor entero. La palabra int es una palabra
reservada, a lo largo del texto las palabras reservadas serán representadas
con tipo negrita.
Los paréntesis después de la palabra main se usan para definir los
parámetros de la función, en este caso no tiene ningún parámetro. En algunas
ocasiones los parámetros van a ser necesarios.
La llave que abre inicia un bloque de instrucciones. La primera instrucción
es
printf("Hola mundo!\n");/*sentencia de salida*/ Esta instrucción es una
sentencia de salida. Note que se ha incluido un comentario para aclarar el
significado de esta línea.
Universidad Politécnica de San Luis Potosí
Página 9
Portafolio de evidencias PIC I
La palabra printf se utiliza para desplegar letreros y valores de variables
o expresiones. Esta palabra designa a una función encargada de dichas
operaciones.
Los paréntesis sirven para delimitar los elementos de salida. En este caso
es un
letrero el cual debe ir encerrado entre comillas, las comillas no se
despliegan. En este caso se desplegara la cadena "Hola mundo!\n".
La secuencia de caracteres \n indica que se mueva el cursor a la siguiente
línea, a este tipo de controles se les llama secuencias de escape.
La sentencia getch()es una función que lee un caractér desde el teclado,
esto permite que el programa se detenga hasta que el usuario presione una
tecla.
Por último, la sentencia return 0 indica una terminación normal (sin
errores) del programa.
Note que todas las sentencias deben terminarse con un punto y coma, esto va
a ser necesario en la mayoría de los casos de las sentencias en C.
La función printf imprime un letrero y deja el cursor en la posición que
sigue al último caractér impreso.
El siguiente ejemplo imprime una sola línea utilizando tres sentencias printf.
/*Ejemplo de varias sentencias printf una sola línea de salida */
#include <stdio.h> /*biblioteca para entrada y salida*/
#include <conio.h> /*biblioteca para la función getch*/
int main(){
printf("Esta es una");
printf(" cadena impresa ");
printf("en una sola línea\n");
getch();
return 0;
}
También pueden imprimirse varias líneas mediante una sola sentencia printf, por
ejemplo:
/*Ejemplo de printf, una sentencia varias líneas*/
#include <stdio.h>
#include <conio.h>
int main(){
printf("Línea 1\nEsta es la línea 2\ny está es la 3\n");
getch();
return 0;
}
Otra secuencia de escape para formatear la salida es \t (tabulador). Mediante el
tabulador
se pueden imprimir varias cadenas en columnas predeterminadas. Ejemplo:
#include <stdio.h>
#include <conio.h>
int main(){
Universidad Politécnica de San Luis Potosí
Página 10
Portafolio de evidencias PIC I
printf("nombre\tdirección\tteléfono\n");
printf("juan\tolmo 204 \t8-12-12-34\n");
printf("maria\tpino 565 \t8-34-27-16\n");
getch();
return 0;
}
Variables
Una variable es un identificador que se utiliza para representar cierto tipo de
información dentro de una determinada parte del programa.
En su forma más sencilla, una variable es un identificador que se utiliza para
representar un dato individual; es decir, una cantidad numérica o una constante
de carácter. En alguna parte del programa se asigna el dato a la variable. Este
valor se puede recuperar después en el programa con simplemente hacer referencia
al nombre de la variable.
Hay dos formas diferentes de caracterizar variables, por su tipo de datos y por
tipo de almacenamiento.
Por su tipo de datos
Las variables permiten almacenar números de varias clases, así como otro tipo de
datos. Analizaremos as variables que almacenan números enteros.
Los nombres de las variables deben ser identificadores válidos. Un identificador
es válido si es una secuencia de letras, dígitos y guiones bajos (_) que no
comience con un dígito. Cabe destacar que el lenguaje C distingue entre letras
mayúsculas y minúsculas, de tal manera que x2 es diferente de X2.
Es conveniente utilizar palabras significativas para definir variables, de esta
manera será más sencillo la escritura y depuración de programas.
Todas las variables en C deben declararse antes de ser utilizadas. La declaración
de las variables consiste en la definición de su tipo y nombre, opcionalmente se
puede dar un valor inicial a la variable.
La sintaxis es la siguiente:
Tipo nombre;
Tipo nombre = valor;
Se pueden declarar varias variables del mismo tipo simultáneamente.
Ejemplos:
int suma;
Declara la variable suma de tipo entero.
int cuenta, promedio, suma = 0;
Declara las variables siguientes: cuenta, promedio y suma de tipo entero y asigna
0 a la variable suma.
Universidad Politécnica de San Luis Potosí
Página 11
Portafolio de evidencias PIC I
El lenguaje C suministra varios tipos de números enteros y reales que se utilizan
con diferentes propósitos. La siguiente tabla resume estos tipos:
La asignación es la operación más elemental que puede aplicarse a una variable.
El operador “=” se utiliza para esta propósito.
El siguiente ejemplo asigna valores a dos variables enteras y calcula la división
de los dos números. El operador de división es la diagonal normal “/”.
/*asignación de variables*/
#include <stdio.h>
#include <conio.h>
int main(){
int divisor, dividendo, cociente;
divisor = 13;
dividendo = 45;
cociente = dividendo / divisor;
printf("dividendo: %d\n",dividendo);
printf("divisor: %d\n",divisor);
printf("cociente: %d\n",cociente);
getch();
return 0;
}
Por su tipo de almacenamiento
Hay cuatro especificaciones diferentes de tipo de almacenamiento en C;
automática, externa, estática y de registro, que se identifican con las palabras
reservadas auto, extern, static y register respectivamente. Abordaremos ahora los
dos tipos más comunes que son automatic y extern.
A veces se puede establecer el tipo de almacenamiento asociado a una variable
simplemente por la posición de su declaración en el programa. En otras
situaciones, sin embargo, la palabra reservada que especifica un tipo particular
de almacenamiento se tiene que colocar al comienzo de la declaración de la
variable.
Universidad Politécnica de San Luis Potosí
Página 12
Portafolio de evidencias PIC I
A continuación se muestran varias declaraciones típicas de variables que incluyen
la especificación de un tipo de almacenamiento:
auto int a, b,c;
extern float raiz1, raiz2;
static int cont=0;
extern char asterisco;
Variables automáticas
Se declaran siempre dentro de la función y son locales a la función donde han
sido declaradas, es decir, su ámbito está confinado a esa función . Las variables
automáticas declaradas en otras funciones serán independientes unas de otras,
incluso si tienen el mismo nombre.
Variables externas o globales
Es contraste con las variables automáticas, no está confinada a funciones
simples. }su ámbito se extiende desde el punto de definición hasta el resto del
programa . Por tanto, generalmente abarcan dos o más funciones y frecuentemente
todo el programa.
Como las variables externas se reconocen globalmente, se puede acceder a las
mismas desde cualquier función que se encuentre dentro de su ámbito. Mantienen
los valores asignados dentro de este ámbito. Por tanto a una variable externa se
le puede asignar un valor dentro de una función y este valor puede usarse (al
acceder a la variable externa) dentro de otra función.
Instrucciones de E/S
Lenguaje C va acompañado de una colección de funciones de biblioteca que incluye
un cierto número de funciones de entrada/salida. Las más comunes son getchar,
putchar, scanf, printf, gets y puts. Estas seis funciones nos permiten la
transferencia de información entre la computadora y los dispositivos de
entrada/salida estándar, como un teclado y un monitor por mencionar un ejemplo.
Las dos primeras funciones, getchar y putchar, permiten la transferencia de
caracteres individuales hacia adentro y hacia afuera de la computadora, scanf y
printf son más complicadas, pero permiten la transferencia de caracteres
individuales, valores numéricos y cadenas de caracteres; gets y puts permiten la
entrada y salida de cadenas de caracteres.
El siguiente es un esquema de un programa de C que hace uso de varias rutinas de
entrada/salida de la biblioteca estándar de C.
#include<stdio.h>
int main(){
char c,d;
/*declaraciones */
float x, y;
Int i, j, k;
c=getchar();
/*entrada de un carácter*/
scanf(“%f”,&x);
/*entrada de número en coma flotante*/
Universidad Politécnica de San Luis Potosí
Página 13
Portafolio de evidencias PIC I
scanf(“%d %d”,&I, &j);
/*entrada de enteros*/
. . . . . .
/*instrucciones de acción*/
putchar(d);
/*salida de un caractér*/
printf(“%3d
%7.4f”, k,y);
/*salida de números*/
}
Operadores y expresiones
Las constantes, variables, elementos de una formación y referencias a funciones
se pueden unir con varios operadores para formar expresiones. En el lenguaje C
existen un gran número de operadores que se pueden agrupar en distintas
categorías, por ahora sólo abordaremos dos tipos; los operadores aritméticos y
los operadores lógicos.
Operadores aritméticos
Existen cinco operadores aritméticos en C:
Operador
Propósito
+
Suma
Resta
*
Multiplicación
/
División
%
Residuo de división entera
Los operandos sobre los que actúan los operadores aritméticos deben representar
valores numéricos. Por tanto, los operadores deben de ser cantidades enteras, en
coma flotante o caracteres (éstos representan valores enteros, determinados por
el conjunto de caracteres de la computadora). El operador (%) requiere que los
dos operandos sean enteros y el segundo operando no nulo. Análogamente el
operador de división (/) requiere que el segundo operando no sea nulo.
Cabe destacar que si uno de los operandos tiene signo negativo, las operaciones
de suma, resta, multiplicación y división tendrán resultados cuyo signo estará
determinado por las reglas del álgebra.
Operadores relacionales y lógicos
En C existen 4 operadores relacionales:
Operador
<
<=
>
>=
Significado
Menor que
Menor o igual que
Mayor que
Mayor o igual que
Estos operadores se encuentran dentro del mismo grupo de precedencia, que es
menor que la de los operadores unarios y aritméticos. La asociatividad de estos
operadores es de izquierda a derecha. Muy asociados a los operadores relacionales
existen dos operadores de igualdad:
Operador Significado
==
Igual que
!=
No igual que
Universidad Politécnica de San Luis Potosí
Página 14
Portafolio de evidencias PIC I
Los operadores de igualdad se encuentran en otro grupo de precedencia, por debajo
de los operadores relacionales. La asociatividad de estos operadores es también
de izquierda a derecha. Estos seis operadores se utilizan para formar expresiones
lógicas que representan condiciones que pueden ser verdaderas o falsas. LA
expresión resultante será de tipo entero, ya que verdadero será representado por
el valor entero 1 y falso por el valor 0.
Condicionales
Sentencia if
Permite decidir ejecutar una o más instrucciones dependiendo del valor de una
expresión.
La sintaxis de la sentencia if es:
if( condición )
Instrucción o bloque;
Un bloque está formado por una serie de instrucciones encerrado entre llaves {}.
La condición es cualquier expresión que genere un valor numérico real o entero.
La instrucción o bloque se ejecutará si la condición toma un valor diferente de
cero.
En el lenguaje algorítmico usaremos la construcción siguiente.
SI condición ENTONCES
Sentencias
El programa siguiente determina si un número tecleado es positivo o negativo:
#include <stdio.h>
#include <conio.h>
main(){
float numero;
printf("Teclee un número: ");
scanf(“%d”,&numero);
if(numero>=0)
printf("número positivo\n");
getch();
}
Universidad Politécnica de San Luis Potosí
Página 15
Portafolio de evidencias PIC I
Sentencia if completa
Consta de una parte que se ejecuta cuando la condición es 1 y otra cuando es 0.
La sintaxis es:
if( condición )
instrucción o bloque;
else
Instrucción o bloque;
En el lenguaje algorítmico usaremos la construcción siguiente.
SI condición ENTONCES
Sentencias
SI NO
Sentencias
El siguiente ejemplo es un programa que determina si dos rectas se intersecan o
no, y si se intersecan determina las coordenadas (x, y) de la intersección.
Suponga que las rectas se representan mediante una ecuación de la forma y = mx
+b.
Supondremos que el usuario introduce los valores de m y b para cada recta. Para
que dos rectas se intercepten es necesario que las pendientes sean diferentes,
usaremos esta condición para resolver el problema.
#include <stdio.h>
#include <conio.h>
int main(){
float pendiente1, pendiente2, ordenada1 ,ordenada2,x,y;
printf("teclee la pendiente y ordenada al origen 1: ");
scanf("%f%f",&pendiente1,&ordenada1);
/*Leer datos de las dos rectas*/
printf("teclee la pendiente y ordenada al origen 2: ");
scanf("%f%f",&pendiente2,&ordenada2);
/*Leer datos de las dos rectas*/
if(pendiente1 != pendiente2){ /*Determina intersección, si existe*/
x = (ordenada2 - ordenada1)/( pendiente1- pendiente2);
y = pendiente1*x+ ordenada1;
printf("Las rectas se interceptan en: %f, %f",x,y);
}else
printf("Las rectas no se interceptan...");
getch();
Universidad Politécnica de San Luis Potosí
Página 16
Portafolio de evidencias PIC I
}
Operador condicional
Una instrucción que hace uso del operador condicional (?: )se denomina expresión
condicional. Se puede escribir una instrucción de este tipo en lugar de la
instrucción if-else.
Una instrucción condicional se escribe de la siguiente forma:
expresión 1? expresión 2: expresión 3
Primero se evalúa expresión 1, si ésta es verdadera, es decir que su valor no sea
nulo, entonces expresión 2 es evaluada y éste sería el valor de la expresión
condicional. Sin embargo si expresión 1 es falsa, o sea que su valor es 1,
entonces se evalúa la expresión 3 y éste es el valor de expresión condicional.
Nótese que solo se evalúa una de las expresiones (expresión 2 o expresión 3)
cuando se determina el valor de una expresión condicional.
Ejemplo:
En la expresión condicional que se muestra a continuación, supongamos que i es
una variable entera.
(i<0)? 0:100
Se evalúa primero la expresión (i<0). Si es verdadera (si el valor de i es menor
que cero), el valor de toda la expresión condicional es 0. En cualquier otro caso
(si el valor de i no es menor que cero), el valor de toda la expresión
condicional es 100.
Instrucción “switch”
Esta instrucción hace que se seleccione un grupo de instrucciones entre varios
grupos disponibles. La selección se basa en el valor de una expresión que se
incluye en la instrucción switch.
La forma general de la instrucción switch es:
Switch(expresión) instrucción
En donde expresión devuelve un valor entero. Hay que tener en cuenta que
expresión también puede ser de tipo char, ya que los caracteres individuales
también tienen valores enteros.
Generalmente la instrucción incluida comprende posibles opciones a seguir, y cada
una de estas opciones se expresa como un grupo de una o más instrucciones
individuales dentro de las mismas.
switch (<expresión>){
case <constante>:[case <constante>:]<sentencias>;break;
...
[default:<sentencias>;break;]
}
Cada caso se precede por la palabra reservada case y una constante numérica, al
final debe colocarse la sentencia break para que el control pase al final de la
sentencia switch, de no hacerlo así, se ejecutará la siguiente sentencia case. La
parte default es opcional y se ejecuta en caso de que no se cumpla ningún caso.
Universidad Politécnica de San Luis Potosí
Página 17
Portafolio de evidencias PIC I
El siguiente programa utiliza una sentencia switch para desplegar un día de la
semana, si el usuario escribe un número no válido, se desplegará el letrero “día
no válido”.
#include <stdio.h>
#include <conio.h>
int main(){
int dia;
printf("teclee el número del día: ");
scanf("%d",&dia);
switch(dia){
case 1:printf("Lunes");break;
case 2:printf("Martes");break;
case 3:printf("Miércoles");break;
case 4:printf("Jueves");break;
case 5:printf("Viernes");break;
case 6:printf("Sabado");break;
case 7:printf("Domingo");break;
default: printf("día no válido");
}
getch();
}
Sentencias de repetición
Instrucción “”while”
La instrucción while se utiliza para generar bucles, en los cuales un grupo de
instrucciones se ejecuta repetidamente, hasta que se satisface alguna condición.
La forma general de la instrucción while es la siguiente:
While (expresión) instrucción
La instrucción se ejecutará repetidamente, mientras el valor de la expresión sea
verdadero, es decir mientras ésta tenga un valor no nulo. Esta instrucción puede
ser simple o compuesta, aunque suele ser compuesta. Debe incluir algún elemento
que altere el valor de expresión, proporcionando así la condición de salida del
bucle.
Ejemplo:
El programa para sumas 20 números es el siguiente.
Universidad Politécnica de San Luis Potosí
Página 18
Portafolio de evidencias PIC I
#include <stdio.h>
#include <conio.h>
int main(){
float suma = 0.0, num;
int contador = 0;
while(contador < 20){
printf("Teclee un número:");
scanf("%f",&num);
suma = suma + num;
contador = contador + 1;
}
printf("\nLa suma de los 20 números es: %5.0f\n",suma);
getch();
}
La instrucción do-while
Cuando se utiliza la instrucción while, la comprobación para la continuación del
bucle se realiza al comienzo de cada pasada, sin embargo, a veces es deseable
disponer de un bucle en el que se realice la comprobación al final de cada
pasada. Esto se puede hacer mediante la instrucción do-while.
La sintaxis es la siguiente:
Do instrucción while (expresión)
La instrucción se ejecutará repetidamente mientras que el valor de expresión sea
verdadero, es decir no nulo, es importante notar que la instrucción se ejecutará
al menos una vez ya que la comprobación de la condición de repetición no se
realiza hasta el final de la primera pasada por el bucle. La instrucción puede
ser simple o compuesta y debe incluir algún elemente que altere el valor de
expresión para que el bucle tenga un final.
Ejemplo:
El siguiente programa que imprime los primeros 10 enteros y sus cuadrados.
#include <stdio.h>
#include <conio.h>
main(){
int n = 1;
do{
printf(“%2d\t%d\n”,n,n*n);
n++;
}while(n<11);
getch();
}
La instrucción “for”
Esta instrucción incluye una expresión que especifica el valor inicial de un
índice, otra expresión que determina cuando se continúa o no el bucle y una
tercera expresión que permite que el índice se modifique al final de cada pasada.
La sintaxis es la siguiente:
For(expresión 1; expresión 2; expresión 3) instrucción
Universidad Politécnica de San Luis Potosí
Página 19
Portafolio de evidencias PIC I
En donde instrucción 1 se utiliza para inicializar algún parámetro (denominado
índice) que controla la repetición del bucle, expresión 2 representa una
condición que debe ser satisfecha para que continúe la ejecución del bucle y
expresión 3 se utiliza para modificar el valor del parámetro inicialmente
asignado por expresión 1. Típicamente expresión 1 es una expresión de asignación,
expresión 2 es una expresión lógica y expresión 3 una expresión unaria o de
asignación.
Ejemplo: El siguiente programa utiliza un ciclo for para imprimir el monto
del capital acumulado año por año de un capital al 5% de interés.
#include <stdio.h>
#include <conio.h>
#include <math.h>
int main() {
81
float monto; // monto del depósito
float principal = 1000.0; // monto principal (al inicio)
float tasa = .05; // tasa de interés
int anio;
printf("Anio Monto del depósito\n");
for (anio = 1; anio <= 10; anio++ ) {
monto = principal * pow( 1.0 + tasa, anio );
printf("%4d%21.2f\n",anio,monto);
}
getch();
}
Funciones
Las funciones son los bloques de construcción más fundamentales en C. El
uso de funciones permite la construcción de programas más grandes, mejor
diseñados y en general más eficientes en su ejecución y depuración. Las
funciones son bloques de instrucciones que efectúan un proceso específico
y en algunos casos regresan valores.
El propósito fundamental de las funciones es dividir los programas en
módulos más manejables que permitan resolver problemas más complejos.
Las funciones en C se declaran mediante el siguiente formato:
Tipo_devuelto nombre_de_funcion(lista de parámetros o argumentos){
Sentencias (declaraciones, instrucciones, etc.)
}
Tradicionalmente en C se declaran como prototipos al inicio del programa.
Después se declara la función main, y después se hace la declaración
formal de las funciones.
También pueden declararse las funciones al inicio del programa y después
declarar la función main sin declarar prototipo. Los prototipos constan de
solo el encabezado, es decir, el tipo devuelto, el nombre de la función y
la lista de parámetros, en este caso la lista de parámetros puede constar
solo de los nombres de los tipos de cada parámetro.
Universidad Politécnica de San Luis Potosí
Página 20
Portafolio de evidencias PIC I
Prototipo
Significado
Funcion f que devuelve un valor entero
int f(int a, float x, float y);
y tiene como argumentos un valor
entero y dos de punto flotante.
Funcion g que devuelve un valor de
double g(double a, int c);
doble precisión y tiene como
argumentos un valor de doble precisión
y un valor entero.
Funcion m que devuelve un entero
short m(int n, char c);
corto y tiene como parámetros un
entero y un caractér.
El siguiente programa define una función para calcular el área de una
esfera y la llama dentro de la función main. El usuario debe escribir el
radio de la esfera.
#include <stdio.h>
#include <conio.h>
/*prototipo de función, devuelve un flotante y lleva
un parámetro de tipo flotante*/
float areaEsfera(float);
main(){
float r,area;
printf("radio: ");
scanf("%f",&r);
/*llamada a la función areaEsfera*/
area = areaEsfera(r);
printf("El area de la esfera es: %f\n",area);
getch();
}
/*definición de la función areaEsfera*/
float areaEsfera(float radio){
return 4*3.14159265358979*radio*radio;
}
Arreglos
Un arreglo es una colección ordenada de elementos del mismo tipo. Los arreglos
permiten referirse a una colección de valores mediante un solo nombre. Para
acceder a los elementos individuales de un arreglo se utiliza uno o más índices
que deben ser un número entero o una expresión de tipo entero.
Los arreglos pueden ser de cualquier tipo: int, float, double, char, o se puede
tener elementos que sea estructuras más complejas.
Los arreglos de una dimensión solo utilizan un índice para localizar cada uno de
sus elementos componentes. Para referirse a un elemento del arreglo se utilizan
corchetes ([ , ]) para encerrar el índice del elemento del arreglo.
En el lenguaje C los índices varían entre cero y un máximo igual al número de
elementos del arreglo menos uno.
Universidad Politécnica de San Luis Potosí
Página 21
Portafolio de evidencias PIC I
Una representación gráfica es la de la figura siguiente.
Tipo nombre[tamaño];
El tamaño es cualquier constante entera positiva mayor que cero.
Ejemplos:
Arreglo
float m[120];
char c[256];
unsigned char y[1024];
int a[23];
Descripción
Declara un arreglo de 120 elementos
de tipo flotante.
Declara un arreglo de 256 elementos
de tipo caractér.
Declara un arreglo de 1024 elementos
de tipo caractér sin signo.
Declara un arreglo de 23 elementos
de tipo entero
Al igual que las variables de tipo simple, se pueden iniciar los valores de un
arreglo al momento de declararlo.
El siguiente programa inicializa y despliega dos arreglos de caracteres y muestra
cada uno de los elementos. En el ejemplo se despliega cada arreglo utilizando el
formato %s que sirve para desplegar o leer cadenas de caracteres. También se
despliega cada elemento como un caractér y como un número entero.
#include <stdio.h>
#include <conio.h>
main(){
char a[10]="hola";
char b[10]={'h','o','l','a'};
printf("%s\n",a);
printf("%s\n",b);
for(int i=0;i<10;i++)
printf("%4d %c%4d %c\n",a[i],a[i],b[i],b[i]);
getch();
}
El programa desplegara los siguientes valores:
hola
hola
104 h 104 h
111 o 111 o
108 l 108 l
97 a 97 a
0 0
0 0
0 0
0 0
0 0
0 0
En el caso de arreglo de caracteres solo podrán iniciarse usando la notación de
cadenas si la cadena es de longitud más corta que el tamaño del arreglo, ya que C
inserta automáticamente un caractér nulo (‘\0’) al final de la cadena.
Se puede omitir el tamaño de un arreglo si se inicializa en la declaración. En el
caso de arreglos de caracteres se agrega al final un caractér nulo. Si no se
inicializa es forzoso declarar el tamaño del arreglo.
Universidad Politécnica de San Luis Potosí
Página 22
Portafolio de evidencias PIC I
Por ejemplo.
int a[] = {1, 2, 3, 4};
char m[] = {‘F’,’i’,’n’};
char s[] = “color”;
Se declara un arreglo de enteros de 4 elementos con los siguientes valores.
a[0] = 1;
a[1] = 2;
a[2] = 3;
a[3] = 4;
El arreglo de caracteres m tendrá tres elementos con el siguiente contenido.
m[0] = ‘F’;
m[1] = ‘i’;
m[2] = ‘n’;
Si se despliega, por ejemplo utilizando printf(m) aparecerá basura, después de la
cadena “Fin”, que se encuentre en la memoria ya que no se agrega el terminador
nulo. El
arreglo s se inicia con seis elementos con el siguiente contenido.
s[0] = ‘c’;
s[1] = ‘o’;
s[2] = ‘l’;
s[3] = ‘o’;
s[4] = ‘r’;
s[5] = ‘\0’;
En los siguientes ejemplos se inician los arreglos elemento por elemento. El
siguiente
ejemplo inicializa la variable x con números impares consecutivos:
int x[100], i;
for(i = 0; i<100 ; i++)
x[i] = 2*i + 1;
Universidad Politécnica de San Luis Potosí
Página 23
Portafolio de evidencias PIC I
Prácticas desarrolladas
Prácticas
Calculadora
Mediante el uso de funciones el usuario puede decidir qué operación matemática
desea realizar, con dos números que introdujo previamente.
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
int multiplicacion(int, int);
/*Definición de prototipos de función*/
int suma(int, int);
int resta(int, int);
int main(){
int num1, num2;
/*Definición de variables*/
char op;
printf("Ingresar operacion a realizar (s-suma) (r-resta) (m-multiplicacion):
");
scanf("%c", &op);
/*Impresión en pantalla y lectura de datos*/
printf("Ingresar dos numeros: \n");
scanf("%d", &num1);
scanf("%d", &num2);
switch(op){
/*Sentencia switch para multiopcionales*/
case 'm': printf("El resultado de multiplicar %d x %d = %d", num1,
num2, multiplicacion(num1,num2));break; /*Llamadas a función*/
case 's': printf("El resultado de sumar %d + %d = %d", num1, num2,
suma(num1,num2));break;
/*Llamadas a función*/
Universidad Politécnica de San Luis Potosí
Página 24
Portafolio de evidencias PIC I
case 'r': printf("El resultado de restar %d de %d es igual a %d",
num2,num1, resta(num1,num2));break;
/*Llamadas a función*/
default: printf("Operación no valida");
}
getch();
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 25
Portafolio de evidencias PIC I
5.7.6 Divisores de un número
Escriba un programa que encuentre los divisores de un número.
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
int main(){
int numero, divisor;
/*Definición de variables*/
printf("Indique el numero a obtener sus divisores: "); /*Impresión en
pantalla y lectura de
datos*/
scanf("%d", &numero);
divisor=numero;
/*Asignación de valor a variable*/
while(divisor>0){
/*Ciclo while*/
if(numero%divisor==0)
printf("%d\n", divisor);
divisor--;
}
getch();
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 26
Portafolio de evidencias PIC I
5.4.1 Tablero de ajedrez
Escriba un programa para dibujar un patrón de tablero de ajedrez de tamaño 8:
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
main(){
for(int num=1; num<=20; num++){
/*Ciclo for para recorrer contador*/
if((num%2)!=0)
/*Condicional if-else*/
printf("* * * * * * * * * * \n");
else
printf(" * * * * * * * * * *\n");
}
getch();
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 27
Portafolio de evidencias PIC I
5.4.1 Tablero de ajedrez definido por el usuario
Variante del ejercicio anterior donde ahora el usuario puede definir las
dimensiones del tablero de ajedrez, esto se logra mediante condicionales if
anidadas dentro de un ciclo while.
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
int main(){
int ancho, alto, ancho1;
/*Definición de variables*/
printf("Ingresar ancho del tablero: "); scanf("%d", &ancho); /*Impresión en
pantalla y lectura de datos*/
printf("Ingresar alto del tablero: "); scanf("%d", &alto);
pantalla y lectura de datos*/
ancho1=ancho;
/*Inicialización de variables*/
while(alto>0){
/*Ciclos while anidados*/
/*Impresión en
while(ancho1>0){
if(alto%2==0){
/*Condicional if-else*/
if(ancho1%2==0)
printf("
");
else
printf("*");
}
else{
/*Condicional if-else*/
if(ancho1%2==0)
printf("*");
else
printf("
Universidad Politécnica de San Luis Potosí
");
Página 28
Portafolio de evidencias PIC I
}
ancho1--;
/*Alteración de expresión de
condición para el ciclo*/
}
printf("\n");
ancho1=ancho;
alto--;
}
getch();
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 29
Portafolio de evidencias PIC I
5.3.7 Promediador
Desarrolle un algoritmo para calcular el promedio ponderado de n números:
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
int main(){
float num=0,num1,cont=0,prom;
/*Definición de variables*/
int resp;
do{
/*Ciclo do-while para
verificación de la condición de
repetición después de la
ejecución de instrucciones*/
printf("Ingresar numero a promediar: "); /*Impresión en pantalla y lectura
de datos*/
scanf("%f", &num1);
num=num+num1;
/*Reasignación de valores a variable*/
printf("Desea ingresar otro numero? SI-1 NO-0: ");
/*Impresión en
pantalla y lectura de
datos*/
scanf("%d", &resp);
cont++;
}
while(resp==1);
prom=num/cont;
Universidad Politécnica de San Luis Potosí
Página 30
Portafolio de evidencias PIC I
printf("El promedio es %f", prom);
getch();
/*Se despliega en pantalla el
resultado*/
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 31
Portafolio de evidencias PIC I
5.3.2 Cuadrados y cubos
Diseñe un algoritmo para imprimir los cuadrados y cubos de los primeros 20
números enteros.
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
int main(){
printf("NUMERO\t\tCUADRADO\tCUBO\n");
/*Se despliegan los
encabezados de las columnas/*
for(int i=1; i<=20;i++){
/*Se declaran e
inicializa una variable para índice
del ciclo for*/
printf("%d\t\t%d\t\t%d\n",i,i*i,i*i*i);
/*Se despliega en pantalla los
resultados de las operaciones*/
}
getch();
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 32
Portafolio de evidencias PIC I
4.6.1 Sueldos e incentivos
Una empresa paga a sus empleados de acuerdo a su categoría. Además si un empleado
tiene 60 o más años recibe un bono del 5%. Los sueldos por categoría se muestran
en la siguiente tabla:
Categoría
Sueldo
1
$7,000
2
$7,800
3
$8,500
4
$9,000
Haga un programa que lea la categoría y edad del empleado y determine el monto de
su sueldo.
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
int main(){
int categoria, anios;
/*Definición de variables*/
printf("Ingrese su categoría: ");
/*Impresión en
pantalla y lectura de datos*/
scanf("%d", &categoria);
printf("Ingrese sus años de antiguedad: ");
/*Impresión en
pantalla y lectura de datos*/
scanf("%d",&anios);
if(anios<60){
switch(categoria){
/*Sentencia switch para multiopcionales*/
case 1: printf("Su sueldo es de $ 7000" );break;
Universidad Politécnica de San Luis Potosí
Página 33
Portafolio de evidencias PIC I
case 2: printf("Su sueldo es de $ 7800" );break;
case 3: printf("Su sueldo es de $ 8500" );break;
case 4: printf("Su sueldo es de $ 9000" );break;
default: printf("Categoria no valida");
}
}
else{
/*Sentencia switch para multiopcionales*/
switch(categoria){
case 1: printf("Su sueldo es de $ 7350" );break;
case 2: printf("Su sueldo es de $ 8190" );break;
case 3: printf("Su sueldo es de $ 8925" );break;
case 4: printf("Su sueldo es de $ 9450" );break;
default: printf("Categoria no valida");
}
}
getch();
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 34
Portafolio de evidencias PIC I
4.5.6 Cajero automático
Un cajero automático dispone de billetes de 500, 200, 100, 50 y 20. Desarrolle un
programa que lea una cantidad y exhiba el número de billetes de cada denominación
para entregar ese importe.
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
main(){
int quinientos, doscientos, cien, cincuenta, veinte, cantidad; /*Definición de
variables*/
printf("Indicar la cantidad de dinero a retirar: "); /*Impresión en
pantalla y lectura de
datos*/
scanf("%d", &cantidad);
veinte=((((cantidad%500)%200)%100)%50)/20; /*Asignación de valores a variables*/
cincuenta=(((cantidad%500)%200)%100)/50;
cien=((cantidad%500)%200)/100;
doscientos=(cantidad%500)/200;
quinientos=cantidad/500;
if((veinte%20)!=0)
/*Condicionales if para validación de datos*/
printf("No se cuenta con la denominación para entregar la
cantidad completa pues sobran $%d", veinte);
if((((cantidad%500)%200)%100)==60)
cincuenta=0;
veinte=3;
;
if((((cantidad%500)%200)%100)==80)
cincuenta=0;
veinte=4;
Universidad Politécnica de San Luis Potosí
Página 35
Portafolio de evidencias PIC I
printf("Se le entregará su dinero en: \n");
/*Se despliega en pantalla el
resultado*/
printf("%d billetes de $500\n", quinientos);
printf("%d billetes de $200\n", doscientos);
printf("%d billetes de $100\n", cien);
printf("%d billetes de $50\n", cincuenta);
printf("%d billetes de $20\n", veinte);
getch();
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 36
Portafolio de evidencias PIC I
4.4.6 Tipos de curva
Dada la ecuación de una cónica Ax2 + Bxy + Cy2 + Dx + Ey + F = 0 el discriminante
permite saber de qué tipo de cónica se trata de acuerdo con la siguiente tabla:
Donde discr = B*B–4*A*C y N es el término cuadrático (B2 – 4AC)x2+2(BE–2CD)x+E2–
4CF. Escriba un programa que dados los coeficientes A, B, C, D, E y F determine
de qué tipo de cónica se trata. Utilice condiciones compuestas.
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
main(){
float a,b,c,d,e,f, discr,n;
/*Definición de variables*/
printf("Indicar el coeficiente para x2: ");
/*Impresión en pantalla y lectura
de datos*/
scanf("%f", &a);
printf("Indicar el coeficiente para xy: ");
scanf("%f", &b);
printf("Indicar el coeficiente para y2: ");
scanf("%f", &c);
printf("Indicar el coeficiente para x: ");
scanf("%f", &d);
printf("Indicar el coeficiente para y: ");
scanf("%f", &e);
printf("Indicar la constante: ");
Universidad Politécnica de San Luis Potosí
Página 37
Portafolio de evidencias PIC I
scanf("%f", &f);
discr=b*b-4*a*c;
/*Asignación de valor a la variable*/
if(discr < 0)
/*Validación de datos mediante condicional if*/
printf("La ecuacion describe una elipse");
if(discr == 0)
printf("La ecuacion describe una parabola");
if(discr > 0)
printf("La ecuacion describe una hiperbola");
getch();
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 38
Portafolio de evidencias PIC I
4.3.5 Elecciones de candidatos
En una elección el candidato que obtiene más votos que la suma de votos de los
demás gana la elección, sino se hace una segunda ronda de elecciones. Desarrolle
un algoritmo que lea el número de votos de una elección entre 4 candidatos y
determine si habrá o no una segunda vuelta.
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
main(){
int can1, can2, can3, can4, suma ;
/*Definición de variables*/
printf("Introducir cantidad de votos para el Candidato 1: ");
/*Impresión en
pantalla y
lectura de
datos*/
scanf("%d",&can1);
printf("Introducir cantidad de votos para el Candidato 2: ");
scanf("%d",&can2);
printf("Introducir cantidad de votos para el Candidato 3: ");
scanf("%d",&can3);
printf("Introducir cantidad de votos para el Candidato 4: ");
scanf("%d",&can4);
if(can1>(can2+can3+can4))
/*Validación de datos mediante condicional if-else*/
printf("El ganador de la eleccion es el candidato 1");
else
{
if(can2>(can1+can4+can3))
printf("El ganador de la eleccion es el candidato
2");
else
{
if(can3>(can1+can2+can4))
Universidad Politécnica de San Luis Potosí
Página 39
Portafolio de evidencias PIC I
printf("El ganador de la
eleccion es el candidato 3");
else
{
if(can4>(can1+can2+can3))
printf("El candidato ganador es el candidato 4");
else
printf("Se hará otra ronda de elecciones");
}
}
}
getch();
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 40
Portafolio de evidencias PIC I
3.6.8 Lectura de datos
La aceleración de dos cuerpos de masa m1 y m2, unidos por una cuerda en un plano
inclinado como se muestra en la figura, está dada por la fórmula:
Donde g es la aceleración de la gravedad (9.8 m/s2). Escriba un programa que lea
los valores de las masas m1 y m2 y el ángulo q (en grados) del plano inclinado y
calcule la aceleración de los cuerpos.
#include <stdio.h> /*biblioteca para entrada y salida*/
#include <conio.h> /*biblioteca para la función getch*/
#include <math.h> /*biblioteca para funciones matemáticas*/
int main(){
float ang, m1, m2; /*Declaración de variables de entrada*/
float PI=3.14163264, g=9.81; /*Declaración de constantes*/
float a; /*Declaración de variables de salida*/
printf("Ingrese el ángulo [grados] de inclinacion del plano: "); /*Solicitud
de ingreso de datos*/
scanf("%f", &ang); /*Lectura de datos de entrada*/
printf("Ingrese el valor de la masa [kg] del cuerpo que se desplaza por el
plano: "); /*Solicitud de ingreso de datos*/
scanf("%f", &m1); /*Lectura de datos de entrada*/
printf("Ingrese el valor de la masa [kg] del cuerpo que se desplaza
verticalmente: "); /*Solicitud de ingreso de datos*/
scanf("%f", &m2); /*Lectura de datos de entrada*/
Universidad Politécnica de San Luis Potosí
Página 41
Portafolio de evidencias PIC I
ang= ang*PI/180; /*Se hace la conversión de grados a radianes*/
a=g*(m2*sin(ang)-m1)/(m1+m2); /*Se calcula el resultado*/
printf("El valor de la aceleración de los cuerpos es de %f m/s^2", a); /*Se
muestra el resultado*/
getch();
return 0; /*terminación normal del programa*/
} /*fin del programa*/
Universidad Politécnica de San Luis Potosí
Página 42
Portafolio de evidencias PIC I
3.5.2 Horas, minutos y segundos
Escriba un programa que lea un número entero representando segundos y despliegue
el equivalente en días, horas, minutos y segundos. Por ejemplo: 34,622 segundos
es equivalente a 0 días, 9 horas, 37 minutos, 2 segundos.
#include <stdio.h> /*biblioteca para entrada y salida*/
#include <conio.h> /*biblioteca para la función getch*/
int main(){
int dias, horas, minutos, segundos ; /*Se declaran las variables de tipo entero*/
printf("Introduzca el numero de segundos: "); /*Solicitud de datos de entrada*/
scanf("%d",&segundos); /*Lectura de datos de entrada*/
dias= segundos/86400; /*Se calculan los días*/
horas=(segundos%86400)/3600; /*Se calculan las horas*/
minutos=(segundos%3600)/60; /*Se calculan los minutos*/
segundos=(segundos%3600)%60; /*Se calculan los segundos*/
printf("\nEquivale a %d dias, %d horas, %d minutos y %d segundos", dias, horas,
minutos, segundos); /*Se muestra el resultado calculado*/
getch();
return 0; /*terminación normal del programa*/
} /*fin del programa*/
Universidad Politécnica de San Luis Potosí
Página 43
Portafolio de evidencias PIC I
3.5.2b Horas, minutos y segundos 2
Escriba un programa que lea un número entero representando segundos y despliegue
el equivalente en días, horas, minutos y segundos. Por ejemplo: 34,622 segundos
es equivalente a 0 días, 9 horas, 37 minutos, 2 segundos.
#include<stdio.h>
/*Biblioteca de entrada/salida*/
#include<conio.h>
/*Biblioteca para getchar*/
main(){
int segundos, minutos, horas;
/*Definición de variables*/
int segundos1, minutos1;
printf("Ingrese la cantidad de segundos:\t ");
/*Impresión en
pantalla y lectura de
datos*/
scanf("%d",&segundos);
printf("Ingrese la cantidad de horas:\t\t ");
scanf("%d",&horas);
printf("Ingrese la cantidad de minutos:\t\t ");
scanf("%d",&minutos);
printf("Ingrese la cantidad de segundos:\t ");
scanf("%d",&segundos1);
segundos=segundos+segundos1;
segundos1= (segundos%3600)%60;
/*Cálculos y reasignación de valores a
variables*/
minutos1= ((segundos%3600)/60 + minutos%60)%60;
horas=
segundos/3600 + minutos/60 + minutos1/60 + horas;
printf("\nLa cantidad total de tiempo es %d H %d M %d S", horas, minutos1,
segundos1);
getch();
/*Fin del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 44
Portafolio de evidencias PIC I
3.5.1 Fuerza entre dos cargas eléctricas
Escriba un programa para calcular la magnitud de la fuerza entre dos cargas
eléctricas dadas las coordenadas de las cargas y la magnitud de cada carga. La
fuerza se calcula con la expresión siguiente donde k = 8.99 x10 9.
Donde q1 y q2 son los valores de las cargas 8positivas o negativas), (x1, y1) y
(x2, y2) son las coordenadas de q1 y q2 respectivamente. Deberá leer los valores
de: x1, y1, x2, y2, q1 y q2.
#include <stdio.h> /*biblioteca para entrada y salida*/
#include <conio.h> /*biblioteca para la función getch*/
int main() {
float q1, q2, x1, x2, y1, y2, k, F;
k=8.99e9;
printf("Ingrese la magnitud de la carga 1: "); /*Solicitud de ingreso de
datos*/
scanf("%f",&q1); /*Lectura de datos de entrada*/
printf("Ingrese la magnitud de la carga 2: "); /*Solicitud de ingreso de
datos*/
scanf("%f",&q2); /*Lectura de datos de entrada*/
printf("Ingrese la coordenada x de la carga 1: "); /*Solicitud de ingreso de
datos*/
scanf("%f",&x1); /*Lectura de datos de entrada*/
printf("Ingrese la coordenada y de la carga 1: "); /*Solicitud de ingreso de
datos*/
scanf("%f",&y1); /*Lectura de datos de entrada*/
printf("Ingrese la coordenada x de la carga 2: "); /*Solicitud de ingreso de
datos*/
scanf("%f",&x2); /*Lectura de datos de entrada*/
printf("Ingrese la coordenada y de la carga 2: "); /*Solicitud de ingreso de
datos*/
scanf("%f",&y2); /*Lectura de datos de entrada*/
Universidad Politécnica de San Luis Potosí
Página 45
Portafolio de evidencias PIC I
F= q1*q2*k/((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)); /*Cálculo del resultado*/
printf("La fuerza entre las dos cargas es: %e\n", F); /*Se muestra el
resultado*/
getch();
} /*Fin del programa*/
Universidad Politécnica de San Luis Potosí
Página 46
Portafolio de evidencias PIC I
3.4.3 Volumen y área de un cilindro
Escriba un programa que calcule el área y el volumen de un cilindro de radio 3.3
unidades y altura 2.5 unidades.
#include <stdio.h> /*biblioteca para entrada y salida*/
#include <conio.h> /*biblioteca para la función getch*/
int main() {
float radio, altura, area, volumen; /*Se declaran variables de tipo float*/
radio=3.3; /*Se asignan valores a las variables*/
altura=2.5; /*Se asignan valores a las variables*/
area=9; /*Se asignan valores a las variables*/
volumen=3.14163264*radio*radio*altura; /*Se calcula el resultado*/
area=2*3.14163264*radio*altura+3.14163264*radio*radio; /*Se calcula el
resultado*/
printf("El valor del radio del cilindro es %f\n", radio); /*Se muestra en
pantalla el valor asignado a las variables*/
printf("El valor de la altura del cilindro es %f\n", altura); /*Se muestra en
pantalla el valor asignado a las variables*/
printf("El valor del volumen es %f\n", volumen); /*Se muestra en pantalla el
valor del primer resultado*/
printf("El valor del area es %f\n", area); /*Se muestra en pantalla el valor
del primer resultado*/
getch();
} /*Fin del programa*/
Universidad Politécnica de San Luis Potosí
Página 47
Portafolio de evidencias PIC I
3.4.2.b Operaciones con variables asignadas
Escriba las siguientes expresiones algebraicas en C utilizando un mínimo de
paréntesis.
#include <stdio.h> /*biblioteca para entrada y salida*/
#include <conio.h> /*biblioteca para la función getch*/
int main() {
float a, b, c, d; /* Se declaran las variables de tipo float*/
a=2; /*Se asignan valores a las variables*/
b=3; /*Se asignan valores a las variables*/
c=4; /*Se asignan valores a las variables*/
d= (3*a-4*b)*(5*a-3)/(2*c*(b-1)); /*Se asignan valores a las variables en
función de otras*/
printf("El valor de a es %f\n", a); /*sentencia de salida llamando a una
variable mediante %f en este caso*/
printf("El valor de b es %f\n", b); /*sentencia de salida llamando a una
variable mediante %f en este caso*/
printf("El valor de c es %f\n", c); /*sentencia de salida llamando a una
variable mediante %f en este caso*/
printf("La operacion (3a-4b)(5a-3)/(2c(b-1) da como resultado %f\n", d);
/*sentencia de salida llamando a una variable mediante %f en este caso*/
getch();
} /*fin del programa*/
Universidad Politécnica de San Luis Potosí
Página 48
Portafolio de evidencias PIC I
3.1.4 Sentencias de salida y uso de tabulador
Escriba una sola sentencia printf que despliegue las siguientes líneas. Utilice
secuencias de escape para tabuladores y alimentos de línea.
a)
Equipo
Cruz Azul
jj
5
Guadalajara
jg
2
6
je
1
4
jp
6
2
pts
7
0
14
#include <stdio.h> /*biblioteca para entrada y salida*/
#include <conio.h> /*biblioteca para la función getch*/
int main() {
printf("Equipo \t\tjj \tjg \tje \tjp \tpts\n"); /*sentencia de salida se usa
\t como tabulador y \n como enter*/
printf("Cruz Azul \t5 \t2 \t1 \t6 \t7\n"); /*sentencia de salida se usa \t
como tabulador y \n como enter*/
printf("Guadalajara \t6 \t4 \t2 \t0 \t14\n"); /*sentencia de salida se usa \t
como tabulador y \n como enter*/
getch();
return 0;/*terminación normal del programa*/
} /*fin del programa*/
Universidad Politécnica de San Luis Potosí
Página 49
Portafolio de evidencias PIC I
3.1.2 Sentencias de salida
Escriba un programa que muestre la siguiente salida utilizando cuatro sentencias
printf, todas con cadenas no vacías.
#include <stdio.h> /*biblioteca para entrada y salida*/
#include <conio.h> /*biblioteca para la función getch*/
int main() {
printf("Lenguaje de "); /*sentencia de salida*/
printf("programacion C. "); /*sentencia de salida*/
printf("Primer curso de "); /*sentencia de salida*/
printf("Programacion.\n"); /*sentencia de salida*/
getch();
return 0; /*terminación normal del programa*/
} /*fin del programa*/
Universidad Politécnica de San Luis Potosí
Página 50
Portafolio de evidencias PIC I
Ejemplos
Volumen y área de una esfera
El programa calcula el volumen y área
asignados
de una esfera con datos previamente
#include <stdio.h>
#include <conio.h>
/*calcula el área y el volumen de una esfera*/
int main(){
float r,area,volumen;/*radio, área y volumen de la esfera*/
r = 4.5;
area = 4*3.1416*r*r;
volumen = 4*3.1416*r*r*r/3;
printf("el radio de la esfera es %f\n",r);
printf("el área de la esfera es %f\n",area);
printf("el volumen de la esfera es %f\n",volumen);
getch();
return 0;
}
Universidad Politécnica de San Luis Potosí
Página 51
Portafolio de evidencias PIC I
Menú de opciones
El programa permite al usuario elegir dos opciones de instrucción, esto se hace
mediante operadores lógicos.
#include <stdio.h>
#include <conio.h>
main(){
float tempOriginal,tempConvertida;
int opcion;
printf("Teclee temperatura: ");
scanf("%f",&tempOriginal);
printf("Tipo de conversión (1 - C a F, 2 - F a C, 3 - C a K): ");
scanf("%d",&opcion); //solicita tipo de conversión
tempConvertida = (opcion==1)*(9*tempOriginal/5+32)+
(opcion==2)*(5.0/9*(tempOriginal-32))+(opcion==3)*(tempOriginal+273.16);
printf("Valor convertido: %f\n",tempConvertida);
getch();
}
Universidad Politécnica de San Luis Potosí
Página 52
Portafolio de evidencias PIC I
Lectura de datos
El siguiente programa permite que el usuario introduzca valores que son asignados
a variables y posteriormente se realizan cálculos matemáticos con éstas.
#include <stdio.h>
#include <conio.h>
int main(){
int divisor, dividendo, cociente;
printf("Teclee el divisor: ");/*informa que se va a leer*/
scanf("%d",&divisor); /*Lee El divisor */
printf("Teclee el dividendo: ");
scanf("%d",&dividendo); /*Lee el dividendo*/
cociente = dividendo / divisor;
printf("dividendo: %d\n",dividendo);
printf("divisor: %d\n",divisor);
printf("cociente: %d\n",cociente);
getch();
return 0;
}
Universidad Politécnica de San Luis Potosí
Página 53
Portafolio de evidencias PIC I
Condicional if
En el siguiente ejemplo se ilustra cómo mediante el condicional if y operadores
lógicos se puede determinar si un número es positivo o negativo.
#include <stdio.h>
#include <conio.h>
main(){
float numero;
printf("Teclee un numero: ");
scanf("%f",&numero);
if(numero>=0)
printf("Numero positivo\n");
else
printf("Numero negativo\n");
getch();
}
Universidad Politécnica de San Luis Potosí
Página 54
Portafolio de evidencias PIC I
Asignaciones 1
En el ejemplo se realiza la operación fundamental con variables que es la
asignación, después se usan estas variables para hacer una división.
#include <stdio.h> /*biblioteca para entrada y salida*/
#include <conio.h> /*biblioteca para la función getch*/
int main() { /*aquí inicia el programa */
int divisor, dividendo;
float cociente;
divisor=13;
dividendo=45;
cociente= dividendo / divisor;
printf("Dividendo: %d\n", dividendo); /*sentencia de salida*/
printf("Divisor: %d\n" , divisor); /*sentencia de salida*/
printf("Cociente: %f\n", cociente); /*sentencia de salida*/
getch();
return 0; /*terminación normal del programa*/
}
Universidad Politécnica de San Luis Potosí
Página 55
Portafolio de evidencias PIC I
Asignaciones 2
En el ejemplo se realiza la operación fundamental con variables que es la
asignación, después mediante funciones de entrada y salida se muestran sus
valores en la pantalla.
/*Ejemplo de asignaciones*/
#include <stdio.h>
#include <conio.h>
int main(){
int a,b,c; /* 3 variables enteras */
float x,y,z; /* 3 variables reales */
a = 5;
b = -2;
c = 8;
x = a;
a = b;
y = x;
z = 8.5;
x = z;
a = 1e10*x;
printf("a=%d\nb=%d\nc=%d\n",a,b,c);
printf("x=%f\ny=%f\nz=%f\n",x,y,z);
getch();
return 0;
}
Conclusión
A lo largo de este primer parcial aprendimos aspectos generales sobre la
programación, consideramos que la manera en que analizamos los problemas se
volvió más minuciosa, ya que el diseñar un algoritmo como fase previa al
desarrollo de un programa, requiere poner atención en todos los detalles para no
dar lugares a ambigüedades en el código.
El conocimiento obtenido en este mes fue y será de gran provecho para futuros
proyectos, además de haber servido como preámbulo para el desarrollo de
prototipos físicos con el uso de la placa de prototipado Arduino.
Universidad Politécnica de San Luis Potosí
Página 56
