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