Introducción al Lenguaje C

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
Universidad Politécnica de San Luis Potosí Página 3
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

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.

 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.

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:

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

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ón-
ejecució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 DESCRIPCIÓN
assert.h
Es proporcionar una definición de la macro assert, que imprime un
mensaje de error y aborta el programa
alloc.h
Existen funciones para asignar, liberar memoria, u obtener
información de bloques de memoria.
ctype.h
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.
dir.h
Esto permite ordenar, crear, modificar, mover y eliminar
directorios
errno.h
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.
float.h Define los límites de los tipos de coma flotante
limits.h Define los límites de los diferentes tipos de enteros
math.h Contiene las funciones matemáticas estándar utilizadas en C y C++
setjmp.h Define el tipo de jmp_buf para algunas funciones.
signal.h Contiene funciones de estado.

stdarg.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).
stdef.h Se definen algunos tipos especiales
stdio.h
Incorporan las funciones de Entrada - Salida E/S estándar, tipos y
macros
stlib.h
Declara funciones que son útiles para diferentes propósitos, en
especial de búsqueda y ordenación.
string.h
Este archivo contiene funciones para manejo de cadenas de
caracteres.
time.h 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.

 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 */
int main(){
printf("Esta es una");
printf(" cadena impresa ");
printf("en una sola línean");
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 1nEsta es la línea 2ny está es la 3n");
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(){

printf("nombretdireccióntteléfonon");
printf("juantolmo 204 t8-12-12-34n");
printf("mariatpino 565 t8-34-27-16n");
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.

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: %dn",dividendo);
printf("divisor: %dn",divisor);
printf("cociente: %dn",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.

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*/

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

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 positivon");
getch();
}

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();

}
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.

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.

#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.0fn",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.
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(“%2dt%dn”,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.
For(expresión 1; expresión 2; expresión 3) instrucción

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ósiton");
for (anio = 1; anio <= 10; anio++ ) {
monto = principal * pow( 1.0 + tasa, anio );
printf("%4d%21.2fn",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.

Prototipo Significado
int f(int a, float x, float y);
Funcion f que devuelve un valor entero
y tiene como argumentos un valor
entero y dos de punto flotante.
double g(double a, int c);
Funcion g que devuelve un valor de
doble precisión y tiene como
argumentos un valor de doble precisión
y un valor entero.
short m(int n, char c);
Funcion m que devuelve un entero
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: %fn",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.

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 Descripción
float m[120];
Declara un arreglo de 120 elementos
de tipo flotante.
char c[256];
de tipo caractér.
unsigned char y[1024];
de tipo caractér sin signo.
int a[23];
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("%sn",a);
printf("%sn",b);
for(int i=0;i<10;i++)
printf("%4d %c%4d %cn",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.

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;

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*/

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*/
}

5.7.6 Divisores de un número
Escriba un programa que encuentre los divisores de un número.
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("%dn", divisor);
divisor--;
}
}

5.4.1 Tablero de ajedrez
Escriba un programa para dibujar un patrón de tablero de ajedrez de tamaño 8:
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");
}
}

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.
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); /*Impresión en
ancho1=ancho; /*Inicialización de variables*/
while(alto>0){ /*Ciclos while anidados*/
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(" ");

}
ancho1--; /*Alteración de expresión de
condición para el ciclo*/
}
printf("n");
ancho1=ancho;
alto--;
}
}

5.3.7 Promediador
Desarrolle un algoritmo para calcular el promedio ponderado de n números:
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
datos*/
scanf("%d", &resp);
cont++;
}
while(resp==1);
prom=num/cont;

printf("El promedio es %f", prom); /*Se despliega en pantalla el
resultado*/
}

5.3.2 Cuadrados y cubos
Diseñe un algoritmo para imprimir los cuadrados y cubos de los primeros 20
números enteros.
int main(){
printf("NUMEROttCUADRADOtCUBOn"); /*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("%dtt%dtt%dn",i,i*i,i*i*i); /*Se despliega en pantalla los
resultados de las operaciones*/
}
}

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.
int main(){
int categoria, anios; /*Definición de variables*/
printf("Ingrese su categoría: "); /*Impresión en
scanf("%d", &categoria);
printf("Ingrese sus años de antiguedad: "); /*Impresión en
scanf("%d",&anios);
if(anios<60){
switch(categoria){ /*Sentencia switch para multiopcionales*/
case 1: printf("Su sueldo es de $ 7000" );break;

default: printf("Categoria no valida");
}
}
else{ /*Sentencia switch para multiopcionales*/
switch(categoria){
default: printf("Categoria no valida");
}
}
}

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.
main(){
int quinientos, doscientos, cien, cincuenta, veinte, cantidad; /*Definición de
variables*/
printf("Indicar la cantidad de dinero a retirar: "); /*Impresión en
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;

printf("Se le entregará su dinero en: n"); /*Se despliega en pantalla el
resultado*/
printf("%d billetes de $500n", quinientos);
printf("%d billetes de $200n", doscientos);
printf("%d billetes de $100n", cien);
printf("%d billetes de $50n", cincuenta);
printf("%d billetes de $20n", veinte);
}

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.
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: ");

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");
}

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.
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);
scanf("%d",&can3);
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
{

printf("El ganador de la
eleccion es el candidato 3");
else
{
printf("El candidato ganador es el candidato 4");
else
printf("Se hará otra ronda de elecciones");
}
}
}
}

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 <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*/

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*/

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.
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();

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.
main(){
int segundos, minutos, horas; /*Definición de variables*/
int segundos1, minutos1;
printf("Ingrese la cantidad de segundos:t "); /*Impresión en
datos*/
scanf("%d",&segundos);
printf("Ingrese la cantidad de horas:tt ");
scanf("%d",&horas);
printf("Ingrese la cantidad de minutos:tt ");
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);
}

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 x109.
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.
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*/

F= q1*q2*k/((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)); /*Cálculo del resultado*/
printf("La fuerza entre las dos cargas es: %en", F); /*Se muestra el
resultado*/
getch();
} /*Fin del programa*/

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.
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 %fn", radio); /*Se muestra en
pantalla el valor asignado a las variables*/
printf("El valor de la altura del cilindro es %fn", altura); /*Se muestra en
pantalla el valor asignado a las variables*/
printf("El valor del volumen es %fn", volumen); /*Se muestra en pantalla el
valor del primer resultado*/
printf("El valor del area es %fn", area); /*Se muestra en pantalla el valor
del primer resultado*/
getch();
} /*Fin del programa*/

3.4.2.b Operaciones con variables asignadas
Escriba las siguientes expresiones algebraicas en C utilizando un mínimo de
paréntesis.
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 %fn", a); /*sentencia de salida llamando a una
variable mediante %f en este caso*/
printf("El valor de b es %fn", b); /*sentencia de salida llamando a una
printf("El valor de c es %fn", c); /*sentencia de salida llamando a una
printf("La operacion (3a-4b)(5a-3)/(2c(b-1) da como resultado %fn", d);
/*sentencia de salida llamando a una variable mediante %f en este caso*/
getch();

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 jj jg je jp pts
Cruz Azul 5 2 1 6 7
Guadalajara 6 4 2 0 14
int main() {
printf("Equipo ttjj tjg tje tjp tptsn"); /*sentencia de salida se usa
t como tabulador y n como enter*/
printf("Cruz Azul t5 t2 t1 t6 t7n"); /*sentencia de salida se usa t
como tabulador y n como enter*/
printf("Guadalajara t6 t4 t2 t0 t14n"); /*sentencia de salida se usa t
como tabulador y n como enter*/
getch();
return 0;/*terminación normal del programa*/

3.1.2 Sentencias de salida
Escriba un programa que muestre la siguiente salida utilizando cuatro sentencias
printf, todas con cadenas no vacías.
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();

Ejemplos
Volumen y área de una esfera
El programa calcula el volumen y área de una esfera con datos previamente
asignados
#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 %fn",r);
printf("el área de la esfera es %fn",area);
printf("el volumen de la esfera es %fn",volumen);
getch();
return 0;
}

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: %fn",tempConvertida);
getch();
}

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: %dn",dividendo);
printf("divisor: %dn",divisor);
printf("cociente: %dn",cociente);
getch();
return 0;
}

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 positivon");
else
printf("Numero negativon");
getch();
}

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.
int main() { /*aquí inicia el programa */
int divisor, dividendo;
float cociente;
divisor=13;
dividendo=45;
cociente= dividendo / divisor;
printf("Dividendo: %dn", dividendo); /*sentencia de salida*/
printf("Divisor: %dn" , divisor); /*sentencia de salida*/
printf("Cociente: %fn", cociente); /*sentencia de salida*/
getch();
}

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=%dnb=%dnc=%dn",a,b,c);
printf("x=%fny=%fnz=%fn",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.

Introducción al Lenguaje C

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (18)

Similar a Introducción al Lenguaje C

Similar a Introducción al Lenguaje C (20)

Último

Último (20)

Introducción al Lenguaje C