Apuntes de La Clase de Programacion Estructurada para Ing. Electrónica

Instituto Tecnológico de Toluca
Contenido
................................................................................................................................................................... 2
1.1 Clasificación del Software ................................................................................................................................................................................... 2
1.2 Definiciones ........................................................................................................................................................................................................3
1.3 Análisis de problemas ......................................................................................................................................................................................... 4
1.4 Representación de algoritmos: Gráfica y Pseudocódigo .......................................................................................................................................5
1.5 Diseño de algoritmos aplicados a problemas ...................................................................................................................................................... 14
1.6 Diseño algorítmico de funciones ........................................................................................................................................................................ 17
................................................................................................................................................................... 20
2.1 Características del lenguaje de Programación ................................................................................................................................................... 20
2.2 Estructura básica de un programa ..................................................................................................................................................................... 21
2.3 Traducción de un programa: compilación, enlace de un programa, errores en tiempo de compilación ................................................................ 21
2.4 Ejecución de un programa ................................................................................................................................................................................ 22
2.5 Elementos del lenguaje: datos, literales y constantes, identificadores, variables, parámetros, operadores, entrada y salida de datos ................ 22
2.6 Errores en tiempo de ejecución ........................................................................................................................................................................ 26
............................................................................................................................................................................................ 28
3.1 Estructuras secuenciales ................................................................................................................................................................................... 28
3.2 Estructuras selectivas: simple, doble y múltiple................................................................................................................................................. 29
3.3 Estructuras iterativas: for, while, do-while ......................................................................................................................................................... 32
3.4 Diseño e implementación de funciones .............................................................................................................................................................. 34
................................................................................................................................................................... 37
4.1 Unidimensionales: conceptos básicos, operaciones y aplicaciones. .................................................................................................................... 37
4.2 Multidimensionales: conceptos básicos, operaciones y aplicaciones. ................................................................................................................ 40
4.3 Aplicaciones en programas. .............................................................................................................................................................................. 42
....................................................................................................................................................................................................... 46
5.1 Diferencia entre funciones y procedimientos .................................................................................................................................................... 46
5.2 Activación/invocación de Funciones y Procedimientos. ...................................................................................................................................... 47
5.3 Uso de Funciones y Procedimientos con parámetros. ........................................................................................................................................ 49
REFERENCIAS ............................................................................................................................................................................................................ 53
ANEXOS ....................................................................................................................................................................................................................54
Anexo 1 Vínculo para accesar al Video Tema 1 Diseño de Algoritmos en PSeInt ......................................................................................................54
Anexo 2 Solución de ejercicios propuestos del tema 1 de Algoritmos.......................................................................................................................54
Anexo 3 Vínculo para accesar al Video Tema 2 Introducir al tema de desarrollo de programas DevC++ ...................................................................65
Anexo 4 Solución de ejercicios propuestos del tema 2 Introducción a la Programación ...........................................................................................65
Anexo 5 Solución de ejercicios propuestos del tema 3 Control de Flujo ................................................................................................................. 69
Anexo 6 Caso práctico de Aplicación de Estructuras de Control ............................................................................................................................. 80
Anexo 7 Solución de un problema real que incluye arreglos – Proyecto Integral ...................................................................................................... 84
Anexo 8 Vínculo para accesar al Video Tema 4 Diseño de un programa con Arreglos ............................................................................................. 94
Anexo 9 Vínculo para accesar al Video Ejemplo de un programa con Arreglos en lenguaje C .................................................................................. 94
Anexo 10 Solución de un problema real que incluye funciones, punteros y archivos – Proyecto Integral .................................................................95
MTE. Andrea O. Nájera Avila ii

Anexo 11 Vínculo para accesar al Video Tema 5 Diseño de un programa con Módulos ........................................................................................... 104
Anexo 12 Ejemplo de un programa con Módulos en lenguaje C – Control de producción de Motores. .................................................................... 104
MTE. Andrea O. Nájera Avila iii

Índice de Tablas
TABLA 1 DIFERENCIAS ENTRE INTÉRPRETE Y COMPILADOR ............................................................................................................................... 4
TABLA 2 EJEMPLO DE PALABRAS RESERVADAS .............................................................................................................................................. 5
TABLA 3 OPERADORES ARITMÉTICOS............................................................................................................................................................ 6
TABLA 4 OPERADORES RELACIONALES ......................................................................................................................................................... 6
TABLA 5 OPERADORES LÓGICOS .................................................................................................................................................................. 6
TABLA 6 SIMBOLOGÍA ANSI PARA DIAGRAMAS DE FLUJO .................................................................................................................................7
TABLA 7 DIFERENTES TIPOS DE SENTENCIAS EN UN PSEUDOCÓDIGO.................................................................................................................10
TABLA 8 PALABRAS RESERVADAS EN LENGUAJE C ..........................................................................................................................................21
TABLA 9TIPOS DE DATOS EN LENGUAJE C ................................................................................................................................................... 22
TABLA 10TIPOS DE DATOS SIGNED ............................................................................................................................................................. 22
TABLA 11TIPO DE DATOS UNSIGNED ............................................................................................................................................................23
TABLA 12TIPO DE DATOS SHORT .................................................................................................................................................................23
TABLA 13TIPO DE DATOS LONG ..................................................................................................................................................................23
TABLA 14SECUENCIAS DE ESCAPE ...............................................................................................................................................................23
TABLA 15 OPERADORES BINARIOS .............................................................................................................................................................. 24
TABLA 16 OPERADORES UNARIOS .............................................................................................................................................................. 24
TABLA 17 OPERADORES DE ASIGNACIÓN ..................................................................................................................................................... 24
TABLA 18 JERARQUÍA DE OPERADORES ....................................................................................................................................................... 24
TABLA 19 MODIFICADORES EN LENGUAJE C ................................................................................................................................................. 25
TABLA 20 OPERADORES RELACIONALES ...................................................................................................................................................... 25
TABLA 21 OPERADORES LÓGICOS .............................................................................................................................................................. 26
TABLA 22 TABLA DE VERDAD..................................................................................................................................................................... 26
TABLA 23 MODO TEXTO ............................................................................................................................. ¡ERROR! MARCADOR NO DEFINIDO.
TABLA 24 MODO BINARIO........................................................................................................................... ¡ERROR! MARCADOR NO DEFINIDO.
Índice de Figuras
FIGURA 1 TIPOS DE SOFTWARE .................................................................................................................................................................... 2
FIGURA 2 ALGORITMOS EN INFORMÁTICA .......................................................................................................................................................3
FIGURA 3 EJEMPLO DE ERROR EN DF ..............................................................................................................................................................7
FIGURA 4 EJEMPLO DE ERROR EN FLUJO DE DATOS ...........................................................................................................................................7
FIGURA 5 PSEUDOCÓDIGO VS DIAGRAMA DE FLUJO ........................................................................................................................................ 11
FIGURA 6 REPRESENTACIÓN GRÁFICA DE UN ARREGLO UNIDIMENSIONAL ...........................................................................................................38
FIGURA 7 REPRESENTACIÓN GRÁFICA DE UN ARREGLO BIDIMENSIONAL ............................................................................................................. 40
MTE. Andrea O. Nájera Avila iv

“Todo el mundo en este país debería aprender a programar en un ordenador… porque te enseña a pensar.” Steve Jobs.
MTE. Andrea O. Nájera Avila 1

1.1 Clasificación
almacenamiento de información, la digitalización Compiladores: traducen un programa escrito en
de documentos, y en muchas otras diversas un lenguaje de programación de alto nivel en
del Software
actividades o procesos cotidianos que de cierto lenguaje de máquina.
modo han mejorado nuestra calidad de vida y que
seguramente lo seguirán haciendo. En la figura 1 Intérpretes: software que "traduce" los diferentes
podemos ver algunos ejemplos de los diferentes lenguajes de programación, recibe un programa
El avance tecnológico es un proceso evolutivo de tipos de software. en lenguaje de alto nivel, lo analiza y lo ejecuta.
creación de herramientas que modelan y
controlan el entorno, permitiendo hacer a través Editores de texto: crean y modifican archivos de
Tipos de software
de ellos una gran cantidad de actividades que texto, lenguaje de programación o código fuente.
Existen diferentes tipos de software, de acuerdo
anteriormente eran inimaginables, los cuales no
con sus funciones. A continuación, se describe
se deben solamente a los dispositivos como
cada uno de ellos:
computadoras, tabletas, celulares, máquinas,
etc. sino a una herramienta encargada de darles
Software de sistema
vida y funcionalidad especifica, el software.
Es el programa responsable de la ejecución de
todas las aplicaciones necesarias para que un
Qué es Software: sistema opere correctamente. Suele confundirse
El software es la parte intangible de todos los con el sistema operativo pero va más allá, hace
dispositivos, es un término informático que hace referencia a los programas preinstalados en las
referencia a un conjunto de comandos o computadoras o dispositivos móviles que dan
instrucciones que dan órdenes y se encargan del soporte a otros programas para facilitar su
completo funcionamiento de estos. Sin el función y tener el control del hardware.
software las computadoras, tabletas, celulares,
máquinas y otros dispositivos no tendrían vida. Software de programación
Son todas las herramientas que permiten el
En cualquiera de sus tipos (de sistema, aplicación desarrollo de nuevo software. Por ello, no suelen
o programación) en conjunto con el hardware (la ser utilizadas por el usuario final sino por los Figura 1 Tipos de Software
parte tangible de un dispositivo o máquina) nos programadores. Incluye, por mencionar los más http://dis.um.es/~lopezquesada/documentos/IES_1718/LMSGI/curso/UT4
han ayudado con el avance de la comunicación en importantes, los siguientes: /xhtml/xhtml17/imagenes/o.jpg
tiempo real, la programación de actividades,

procesos industriales o manufactureros, el

APUNTES DE PROGRAMACIÓN BÁSICA
Software de aplicación Un programa de computadora son un conjunto control se define mediante bucles anidados,
Un software de aplicación es un programa de instrucciones en forma secuencial, llamado condicionales y subrutinas, en lugar de a través
diseñado para facilitar algunas tareas específicas código, escritas en un lenguaje de programación de GOTO.
para cualquier medio informático, ya sea en y es básicamente un software que se ejecuta en
computadores, tabletas, celulares o máquinas. un dispositivo.
Las herramientas para obtener cálculos
complejos, diseños en 3D o resultados
inmediatos de procesos simulados (AutoCAD
Mechanical, SolidWorks, ANSYS Workbench,
GeoFryPlots, CATiA, etc.) son algunos ejemplos
de este tipo de programas.
Los diferentes tipos de software se encargan de

lograr que las aplicaciones y recursos
informáticos estén al alcance de nuestra mano,
permitiendo desde acceder a un sitio web hasta
automatizar procesos dentro de una empresa y
medir los resultados.
1.2 Definiciones
Algoritmo
Los algoritmos no son algo exclusivo de los
ámbitos computacionales o lógicos, utilizamos
numerosos algoritmos para resolver problemas
en nuestra vida cotidiana, o realizar ciertas
actividades habituales como cocinar.
Programación Programación procedimental: Este paradigma de
“Se denomina algoritmo al conjunto de pasos La programación es el proceso de creación de programación consiste en basarse en un número
ordenados y finitos que permiten resolver un programas informáticos. La idea principal es muy bajo de expresiones repetidas, englobarlas
problema o tarea específica” Corona, M. y crear un algoritmo y traducirlo a un lenguaje de todas en un procedimiento o función y llamarlo
Ancona M. (2011). programación. cada vez que tenga que ejecutarse.
Para que un algoritmo sea útil, debe ayudarnos a Programación modular: consiste en dividir un
encontrar una solución a un problema específico.
Paradigmas de programación
Un paradigma de programación es una manera o programa en módulos o subprogramas con el fin
Para que eso suceda, un algoritmo debe de hacerlo más manejable y legible. Se trata de
estilo de programación de software. Existen
satisfacer cinco características descritas en la una evolución de la programación estructurada
diferentes formas de diseñar un lenguaje de
figura 2. para resolver problemas de programación más
programación y varios modos de trabajar para
obtener los resultados que necesitan los complejos.
Lenguaje de programación programadores para resolver problemas
Paradigma declarativo
“Expresión de un algoritmo en un lenguaje computacionales.
Este paradigma no necesita definir algoritmos
preciso que puede llegar a entender una
Algunos de los paradigmas de la programación puesto que describe el problema en lugar de
computadora” Corona, M. y Ancona M. (2011).
más relevantes son: encontrar una solución al mismo. Este paradigma
utiliza el principio del razonamiento lógico para
De hecho, un lenguaje de programación es un
responder a las preguntas o cuestiones
conjunto de reglas para describir comandos y Paradigma imperativo
consultadas.
funciones predefinidas. Cada lenguaje de Los programas consisten en una sucesión de
programación limita al desarrollador a un instrucciones o conjunto de sentencias, como si el
Este paradigma a su vez se divide en dos:
conjunto estrictamente predeterminado de programador diera órdenes concretas. El
Programación Lógica: Prolog
palabras clave y comandos que pueden ser desarrollador describe en el código paso por paso
Programación funcional: Lisp, Scala, Java, Kotlin
utilizados en el desarrollo. Hay varios niveles de todo lo que hará su programa.
lenguajes entre los cuales se distinguen:
Algunos lenguajes: Pascal, COBOL, FORTRAN, C, Programación orientada a objetos
En este modelo de paradigma se construyen
De bajo nivel (ensamblador): trabaja C++, etc.
modelos de objetos que representan
directamente con los comandos del procesador.
Otros enfoques subordinados al paradigma de elementos (objetos) del problema a resolver
y que tienen características y funciones.
De alto nivel (C, C++, Java, etc.): es más como un programación imperativa son:
Permite separar los diferentes componentes
lenguaje ordinario.
Programación estructurada: es un tipo de de un programa, simplificando así su
programación imperativa donde el flujo de creación, depuración y posteriores mejoras.
Programa

Programación reactiva si hubiésemos hecho previamente un análisis, por Las pruebas de sintaxis se ejecutan primero, son
Este paradigma se basa en escuchar lo que emite lo general se cometen muchos errores, que a la las más sencillas y las realiza el compilador del
un evento o cambios en el flujo de datos, en larga se pierde tiempo. programa cada vez que se ejecuta el programa
donde los objetos reaccionan a los valores que hasta que el código no presente errores, es decir
reciben de dicho cambio. Un buen hábito y como buenos programadores que la sintaxis que requiere el lenguaje sea la
es la de llevar una metodología para solucionar correcta, de lo contrario el propio compilador va
Editores de texto un problema por más mínimo que este sea. mostrando los errores encontrados para que se
Son programas informáticos que permiten a los Corona, M. y Ancona M. (2011, pp. 4-6), nos modifiquen y se pueda ejecutar el código, estos
usuarios editar o crear texto sin formato. Es decir, describen la metodología para solucionar un errores pueden ser falta de paréntesis, o puntos y
archivos que no contengan formato de texto problema a través de un programa: comas o palabras reservadas mal escritas.
específico. Son de gran utilidad en el área de la
programación para el desarrollo y diseño de 1. Definición del problema Las pruebas de lógica son las más complicadas
aplicaciones. Esta fase la proporciona el enunciado del ya que éstas las realiza el programador; consisten
problema, el cual requiere una definición clara y en la captura de diferentes valores y revisar que el
precisa (no debe ser ambiguo). Es importante que resultado sea el deseado, es decir el programador
Compiladores e intérpretes se entienda perfectamente lo que pretendemos tendría que modificar el código hasta que el
Un compilador es un programa que transforma el que haga la computadora para poder continuar programa funcione correctamente.
código fuente de un programa a su equivalente con la siguiente etapa.
en otro lenguaje de programación de más bajo 6. Documentación
nivel. Es la guía o comunicación escrita que permite al
2. Análisis del problema
Un intérprete es un programa que ejecuta Una vez que se ha comprendido lo que se desea programador o al usuario conocer la
directamente las instrucciones escritas en un que la computadora haga, la etapa de análisis es funcionalidad del programa.
lenguaje de programación dado, es decir lee la muy importante ya que en ésta se identifican tres
factores indispensables: La documentación sirve para que el código fuente
instrucción en tiempo real, y la ejecuta. En la sea más comprensible para el programador o
tabla 1, se resumen los aspectos clave que
caracterizan intérpretes y compiladores: 1. Qué información se necesita para obtener el para otros programadores que tengan que
resultado deseado (datos de entrada). utilizarlo, así como para facilitar futuras
Tabla 1 Diferencias entre Intérprete y Compilador 2. Qué información se desea producir (datos de modificaciones (mantenimiento).
salida).
3. Los métodos y fórmulas que se Hay dos tipos de documentación:
necesitan para procesar los datos y
producir esa salida. • Interna. Se generan en el mismo código y
generalmente es mediante comentarios.
• Externa. Son los manuales y es independiente
3. Diseño y técnicas para al programa. También puede ser la ayuda en el
la formulación de un mismo software.
algoritmo
La etapa de diseño se centra en 7. Mantenimiento
desarrollar el algoritmo Se dice que un programa no se termina al 100%,
basándonos en las ya que es necesario hacer algún cambio, ajuste o
especificaciones de la etapa del complementación para que siga funcionando
análisis; podemos representar un algoritmo correctamente, para llevarlo a cabo se requiere
Ejecutables mediante diferentes herramientas como: que el programa esté bien documentado.
Programa compilado y enlazado que puede ✓ Diagrama de flujo
ejecutarse directamente en el dispositivo. ✓ Pseudocódigo. Todos los programas tienen actualizaciones, por
que surgen versiones diferentes. Por ejemplo:
Consola de línea de comandos 4. Codificación Windows 3.11, 95, 98, 2000, Millennium, Xp,
Es un método que permite a las personas dar En la etapa de codificación se transcribe el Vista, 7. etc.
instrucciones a algún programa informático por algoritmo definido en la etapa de diseño en un
medio de una línea de texto simple. código reconocido por la computadora, es decir,
en un lenguaje de programación, a éste se le
conoce como código fuente.
Por ejemplo, el lenguaje “C” es un lenguaje de
programación y es el que utilizaremos en el
1.3 Análisis de presente curso.
problemas 5. Prueba y depuración

La prueba consiste en capturar datos hasta que el
programa funcione correctamente. A la actividad
Muchas de las veces el tiempo que se lleva
de localizar errores se le llama depuración.
programando un problema directamente en la
Existen dos tipos de pruebas: Sintaxis y de lógica.
computadora, sin haber hecho un análisis previo,
es el doble o triple de tiempo el que nos lleva que,

Es un dato cuyo valor puede cambiar durante el
1.4 Representación
desarrollo o ejecución del algoritmo, es decir,
representará un valor almacenado en memoria
de algoritmos:
(localidad de memoria), que se puede modificar
en cualquier momento o conservar para ser usado
tantas veces como se desee.
Gráfica y Pseudocódigo
Palabras reservadas
Son palabras propias o ya predefinidas en la
sintaxis de un lenguaje de programación o
pseudocódigo y no puede ser usada como el
nombre de una variable ya que tienen un
significado especial.
Estas palabras no importan si se escriben en

mayúsculas o minúsculas. En la tabla 2 se
muestran algunos ejemplos de palabras Todos los datos tienen un tipo asociado con ellos,
reservadas en pseudocódigos: el tipo de un dato es el conjunto (rango) de
valores que puede tomar durante el algoritmo.
Tabla 2 Ejemplo de Palabras Reservadas
Por ejemplo, el tipo de dato determina la

naturaleza del conjunto de valores que puede
tomar una variable.
Los tipos de datos predefinidos son: numéricos,

lógicos, caracteres y cadenas.
Identificador Datos numéricos:
Los identificadores, en los lenguajes de Enteros: son aquellos números que no tienen Todas las variables deben ser declaradas antes
programación, son palabras o textos que se fracciones o decimales, pueden ser positivos o de ser usadas. Cada variable por lo tanto tiene
utilizan para nombrar diferentes elementos del negativos (edad de una persona, año de asociado un tipo de dato, un nombre
lenguaje, está formado por una secuencia de nacimiento, número de páginas de un libro etc.) (identificador) y un valor.
caracteres alfabéticos, numéricos y el guion bajo,
con ellos podemos dar nombre a variables, Reales: son los números que contienen Los nombres de variables que se elijan para el
constantes, tipos de datos, etc. decimales y pueden ser positivos o negativos algoritmo deben ser significativos y tener
(promedio final de un alumno, peso de un objeto, relación con el objeto de que representa.
Los nombres de los identificadores deben seguir estatura de una persona, etc.)
unas reglas de sintaxis, establecidas por los
La sintaxis para definir o declarar una variable es:
propios lenguajes de programación, como, por
ejemplo:
Datos carácter :
tipo_dato nombre_variable(s)
1. Debe comenzar con una letra (no números) Cadena: es una sucesión de caracteres que se
mayúsculas o minúsculas y no puede contener encuentran delimitados por comillas (nombre Ejemplos
espacios en blanco. completo de una persona, domicilio, RFC, CURP, entero i,j,k
2. No pueden existir dos identificadores iguales, etc). real promedio
sin embargo, un identificador puede aparecer caracter nombre[25], genero
más de una vez en un algoritmo. Caracteres: es una letra, número o carácter
3. No se puede utilizar una palabra reservada especial mayúscula o minúscula (genero de una
como identificador persona, seleccionar una opción de un menú, Constantes
4. El identificador debe tener un nombre que sea si/no, opción múltiple, etc).
significativo. Es un dato que permanece sin cambio durante el
5. No utilizar nombres muy largos. Datos lógicos o booleanos: desarrollo del algoritmo, es decir valores fijos que
6. El identificador NO puede contener caracteres no pueden ser alterados por el usuario.
Valor que expresa un estado de entre dos,
especiales excepto el “_” guion bajo. La sintaxis para definir o declarar una constante
verdadero o falso.
es:
Tipos de datos nombre_constante = valor
Variables Ejemplos
Los diferentes objetos de información con los que
un algoritmo trabaja se conocen como datos. pi = 3.1416

max = 90
titulo = “INSTITUTO TECNOLÓGICO DE TOLUCA” Tabla 4 Operadores Relacionales ✓ Dentro de una misma expresión o
Operador Descripción Ejemplo subexpresión se evalúan en el siguiente
orden (de mayor a menor prioridad):
Expresiones < Menor que a<b
<= Menor o igual que a<=b
( )
Una expresión es el resultado de unir operandos > Mayor que a>b
Potencia
(variables, constantes u otras expresiones) >= Mayor o igual que a>=b
*, /, %
mediante operadores (aritméticos, lógicos o == Igual a a==b
+, -
relacionales). != Distinto A != b
El resultado de una expresión es un dato

Los operadores en una misma expresión con igual
numérico o un valor lógico. Para agrupar las
nivel de prioridad se evalúan de izquierda a
expresiones utilizamos los paréntesis.
derecha.
Ejemplos
Operadores Lógicos (Booleanos):
¿Cuál es el resultado de la expresión?
Tabla 5 Operadores Lógicos
Operadores
Operación a. 6+2*3-4/2
Operador Ejemplo
lógica 6+6-4/2
Un operador es un símbolo que permite
No No lógica no (x>=y) 6+6-2
relacionar dos datos en una expresión y evaluar el
operando_1 y 12-2
resultado de la operación. Los operadores Y m<n y i>j
operando_2 10
fundamentales son:
operando_1 o m=5 o
0
operando_2 n!=10
✓ Aritméticos
✓ Relacionales
✓ Lógicos
✓ Asignación b. 5*5*(5+(6-2)+1)
5*5*(5+4+1)
Los operadores lógicos tabla 5, se utilizan en 5*5*10
expresiones condicionales y mediante 25*10
Operadores Aritméticos: sentencias Si-sino, Mientras o Para. 250
En la tabla 3 se describe cada uno de los
operadores aritméticos, los cuales pueden ser
c. 7-6/3+2*3/2-4/2
utilizados con tipos de datos enteros o reales, el
7-2+2*3/2-4/2
operador % calcula el residuo que queda al dividir 7-2+6/2-4/2
dos números enteros. 7-2+3-4/2
7-2+3-2
5+3-2
Tabla 3 Operadores Aritméticos
8-2
Operador Descripción Ejemplo
6
* Multiplicación (a*b)
/ División (a/b)
+ Suma (a+b) d. 7*10-5 %3*4+9
- Resta (a-b) 70-5 % 3*4+9
Módulo, o residuo de
70-2*4+9
% o mod (a%b) 70-8+9
una división entera
Prioridad (precedencia) de 62+9
71
operadores
Operadores Relacionales: El orden en que la computadora ejecuta las e. (7*(10-5) %3)*4+9
diferentes operaciones, le llamamos orden de (7*5 % 3)*4+9
Estos operadores describen una relación entre prioridad. (35 % 3)*4+9
dos valores, por lo tanto, se usan para expresar 2*4+9
condiciones y comparar dos valores. El resultado ✓ Todas las expresiones entre paréntesis se 8+9
de una expresión relacional como lo observamos evalúan primero. 17
en la tabla 4, es un valor tipo lógico o booleano,
sólo puede ser verdadero o falso. ✓ Las expresiones con paréntesis anidados se
evalúan de adentro hacia afuera.

Diagrama de flujo
Es la representación gráfica de un algoritmo, se

lleva a cabo cuando varios símbolos (que indican
diferentes procesos en la computadora) se
relacionan entre sí mediante líneas que indican el
orden en que se deben ejecutar las instrucciones * Se deben trazar los símbolos de manera que se
para obtener los resultados deseados. puedan leer de arriba hacia abajo y de izquierda a
derecha.
* Se debe evitar la terminología de un lenguaje de
Se compone de varios símbolos que representan programación o máquina.
el tipo de proceso o acción en la computadora y
líneas que indican el flujo u orden en el que se * Los comentarios se deben utilizar ya sea al
deben ejecutar dichas acciones. margen o mediante el símbolo gráfico
comentarios para que éstos sean entendibles por
cualquier persona que lo consulte.
Los símbolos utilizados han sido reglamentados * Si el diagrama abarca más de una hoja es
por el Instituto Nacional de Normalización conveniente enumerarlo e identificar de dónde Ejemplo 1 Diseñar un diagrama de flujo que
Estadounidense (ANSI, American National viene y a dónde se dirige. permita resolver una ecuación de primer grado de
Standards Institute), la descripción de estos la forma: ax + b = c ingresando el valor de los
símbolos se encuentra en la tabla 6. * Sólo los símbolos de decisión pueden y deben
tener más de una línea de flujo de salida. coeficientes a, b y c por teclado.
Tabla 6 Simbología ANSI para Diagramas de Flujo
Estructura Secuencial
La estructura secuencial es aquella en la que una Ejemplo 2 Modificar el algoritmo anterior para
acción (instrucción) sigue a otra en secuencia. Las que el resultado final sea:
tareas se suceden de tal modo que la salida de
• a toma el valor inicial de b
Características de los diagramas de flujo: una es la entrada de la siguiente y así
sucesivamente hasta el fin del proceso. Una • b toma el valor inicial de c
* Todo diagrama debe tener un inicio y un fin.
estructura secuencial se representa de la • c toma el valor inicial de a
* No se especifica la declaración de variables. siguiente forma: Es decir, si se introducen los valores 1, 2 y 3 para
*Se deben usar solamente líneas de flujo a, b y c respectivamente, la salida por pantalla
horizontales y/o verticales. será: a=2 b=3 c=1
* Se debe evitar el cruce de líneas utilizando los
conectores.
* Se deben usar conectores sólo cuando sea
necesario.
* No deben quedar líneas de flujo sin conectar.

Ejemplo 3 Solicitar la edad del alumno y
desplegar un mensaje si es mayor de edad.
Ejemplo 5 Calcule y despliegue la cantidad de

dinero que recibirá un trabajador. Si el trabajador
laboró tiempo extra entonces calcular el sueldo
base más las horas extras y si no calcular el sueldo
Estructuras de Selección Doble base sin horas extras, sabiendo que cuando las
horas de trabajo exceden de 40, el resto se
consideran horas extras y que estas se pagan al
Las estructuras condicionales dobles permiten doble de una hora normal.
Las estructuras condicionales o de selección elegir entre dos opciones o alternativas posibles
comparan variables, expresiones o constantes, en función del cumplimiento o no de una
para que, con base al resultado de esta determinada condición.
comparación, se siga un curso de acción dentro
del programa. Existen tres tipos básicos de estas Diagrama de flujo que ejemplifica una estructura
estructuras: simples, dobles y múltiples. condicional doble
Simple
Las estructuras condicionales simples permiten

elegir una opción o alternativa posible en función
del cumplimiento de una condición.
Diagrama de flujo que ejemplifica una estructura
condicional simple:
Ejemplo 4 Solicitar tres calificaciones del alumno,

calcular su promedio y desplegar un mensaje
donde diga si el alumno aprobó o reprobó el
curso, tomando en cuenta que la calificación
mínima aprobatoria es de 70.

Ejemplo 7 Determinar cuál es el número mayor

Diagrama de flujo que ejemplifica un caso del de una lista de N números leídos.
ciclo:
El flujo de control del ciclo es el siguiente:
Se inicializa la variable de control, se evalúa la

condición de fin de ciclo, si esta es verdadera se
realizan las sentencias a repetir y se continúa con
el incremento correspondiente de la variable de
control, para nuevamente evaluar la condición de
fin del ciclo, hasta que esta sea falsa y provoque
la salida del ciclo.
Ejemplo 6 Calcular la suma de los primeros 10

números positivos enteros, iniciando en 1 y
desplegar el resultado.
Estructuras de Repetición
Cuando una instrucción o conjunto de

instrucciones deben ejecutarse varias veces se
recurre a una estructura de repetición, también
llamada iterativa, bucle o ciclo. En este tipo de
estructuras se necesita una condición que
indique cuando terminan las repeticiones o
iteraciones.
Estas estructuras se clasifican en ciclos Contador

y Condicionales.
Estructura Para
Es una estructura de control en la que se indica

el número máximo de repeticiones. Este ciclo es
uno de los más usados para repetir una
secuencia de instrucciones, sobre todo cuando se
conoce la cantidad exacta de veces que se quiere
ejecutar una instrucción simple o compuesta.

Al contrario de los lenguajes de programación de

alto nivel no tiene normas que definan con
precisión lo que es y lo que no es pseudocódigo,
por lo tanto, varía de un programador a otro. En
la tabla 7 se describe los diferentes tipos de

sentencias de un pseudocódigo y su sintaxis.
Tabla 7 Diferentes tipos de sentencias en un

Pseudocódigo
Pseudocódigo
Es la combinación del lenguaje natural (español,

inglés o cualquier otro idioma), símbolos y
términos utilizados dentro de la programación.
Se puede definir como un lenguaje de
especificaciones de algoritmos.
El pseudocódigo se creó para superar las dos

principales desventajas del diagrama de flujo: es
lento de crear y difícil de modificar sin un nuevo
redibujo. Por otra parte, el pseudocódigo es más
fácil de utilizar ya que es similar al lenguaje
natural.

1.Cada instrucción se debe escribir en una línea
Una vez diseñado un pseudocódigo la conversión 2.Para su descripción se utilizan una serie de
a lenguaje de programación es más fácil. palabras reservadas, tales como: “Inicio”, “Fin”,
“Si”, “Entonces”, “Si no”, “Mientras”, etc. que
La estructura del Pseudocódigo puede tener una tienen un significado específico.
cabecera con el nombre del pseudocódigo, una 3.Debe escribirse “tabulando” para mostrar
sección de declaración de variables y constantes claramente las dependencias de unas
y el cuerpo formado por las sentencias. instrucciones del programa con respecto a otras.
4.Cada una de las estructuras que definen un
programa tendrá un punto de comienzo y uno de
fin, especificados por las palabras reservadas que
definen la estructura.
5.Se debe tomar en cuenta que cuando existen
más de una instrucción en una estructura se
escriban entre las palabras reservadas Inicio-Fin.
Estructura Secuencial
Una estructura secuencial en Pseudocódigo se

representa de la siguiente forma:
inicio
sentencia 1
sentencia 2
......
sentencia n
fin
Ejemplo 8 Diseñar un pseudocódigo que permita

resolver una ecuación de primer grado de la
forma: ax + b = c ingresando el valor de los
coeficientes a, b y c por teclado.
inicio
Reglas generales para elaborar un

pseudocódigo:

La sintaxis del pseudocódigo de esta estructura inicio
se representa de la siguiente forma: instruccion 1
instruccion 2
…
Sintaxis 1
instruccion n
Si (condicion) fin
instruccion sino
Sintaxis 2 inicio
instruccion 1
Si (condicion) instruccion 2
inicio
…
instruccion 1
instruccion 2 instruccion n
… fin
instruccion n
fin
Ejemplo 11 Elaborar pseudocódigo que calcule y
real a,b,c,x; Se debe tomar en cuenta que cuando existen
despliegue la cantidad de dinero que recibirá un
escribir"Ingresa el valor de a, b y c"; más de una instrucción en una estructura se
trabajador. Si el trabajador, generó horas extras
leer a,b,c; escribirán entre las palabras reservadas inicio y
entonces calcular el sueldo base más las horas
x=(c-b)/a; fin.
extras y si no calcular el sueldo base sin horas
escribir"El resultado de la ecuación de 1er grado extras, sabiendo que cuando las horas de trabajo
de la forma ax + b = c es => ",x; exceden de 40, el resto se consideran horas extras
fin Ejemplo 10 Solicitar la edad del alumno y
y que estas se pagan al doble de una hora normal
desplegar un mensaje si es mayor de edad.
Ejemplo 9 Modificar el pseudocódigo anterior inicio inicio

para que el resultado final sea: entero edad; entero hrs_extras, hrs_trab;
• a toma el valor inicial de b escribir“Ingresa la edad del alumno”; real costo_hra, sueldo_extra,sueldo_base;
• b toma el valor inicial de c leer edad; cadena: nom;
• c toma el valor inicial de a si (edad>=18) escribir“Ingresa el nombre del trabajador”;
Es decir, si se introducen los valores 1, 2 y 3 para escribir“Es mayor de edad”; leer nom;
a, b y c respectivamente, la salida por pantalla escribir“Introduce el total de horas
fin
será: trabajadas”;
a=2 b=3 c=1 leer hrs_trab;
inicio escribir“Introduce el costo por hora”;
entero a,b,c,aux; Doble
leer costo_hra;
escribir"Ingresa el valor de a, b y c"; sueldo_base=costo_hra *40;
leer a,b,c; Las estructuras condicionales dobles permiten
si (hrs_trab > 40)
elegir entre dos opciones o alternativas posibles
aux =a; en función del cumplimiento o no de una inicio
a=b; determinada condición. hrs_extras= hrs_trab-40;
b=c; sueldo_extra=(hrs_extras*costo_hra)*2;
La sintaxis del pseudocódigo de esta estructura
c=aux; sueldo_total=sueldo_base+sueldo_extra;
se representa de la siguiente forma:
escribir" a = ",a; escribir“La cantidad pagada con horas
escribir" b = ",b; extras es”, sueldo_total;
escribir" c = ",c; Sintaxis 1 fin
fin sino
si (condicion) escribir“La cantidad pagada sin horas extras
instrucción 1 es”, sueldo_base;
sino fin
Estructuras de Selección instrucción 2
Ejemplo 12 Que lea tres números diferentes y
determine el número medio del conjunto de los
Sintaxis 2 tres números (el número medio es aquel número
Simple
que no es ni mayor, ni menor).
si (condicion) inicio

real num1,num2,num3; DE – decremento variable de control
escribir"Ingresa 3 números diferentes :";
leer num1,num2,num3;
si (num1>num2 y num2>num3) o (num3>num2 y
• Ciclos con un número
En este ciclo la variable de control toma el valor indeterminado de iteraciones
num2>num1)
inicial del ciclo y el ciclo se repite hasta que la
escribir "El número medio es ",num2;
variable de control ya no cumple la condición, es Mientras y Hacer-Mientras
sino decir, llegue al límite superior, por el incremento
si (num2>num1 y num1>num3) o (num3>num1 y o decremento de esta.
num1>num2) Son aquellos en que el número de iteraciones no
escribir "El número medio es ",num1; se conoce con exactitud, ya que esta dado en
Ejemplo 13 Calcular el promedio final de un función de un dato dentro del programa.
sino
alumno que tiene 7 calificaciones en la materia de
escribir "El número medio es ",num3; Programación básica.
finsi
finSi
inicio
fin
real calif,sum=0, prom;
entero unidad;
✓ Mientras
char nom[25];
Estructuras de Repetición escribir”Nombre del aluno:”;
Esta es una estructura que repetirá un proceso
leer nom; durante “N” veces, donde “N” puede ser fijo o
para (unidad=1; unidad<=7; unidad=unidad+1) variable. Para esto, la instrucción se vale de una
Las estructuras de repetición son aquellas que condición que es la que debe cumplirse para que
inicio
permiten ejecutar repetidamente un conjunto de se siga ejecutando.
instrucciones (iteraciones), es decir, un número escribir”Ingresa la calificación “,unidad;
predeterminado de veces, o bien hasta que se leer calif
verifique una determinada condición. Cuando la condición ya no se cumple, entonces
sum=sum+calif;
ya no se ejecuta el proceso. La forma de esta
Esta cantidad puede ser fija (previamente fin
estructura es la siguiente:
determinada por el programador) o puede ser
prom=sum/7;
variable (estar en función de algún dato dentro
del programa). escribir”El promedio final de “,nom,” es :”,prom; Sintaxis
fin
• Ciclos con un número mientras (condición)

determinado de iteraciones inicio
Ejemplo 14 Encontrar el menor y mayor valor de instrucción 1;
Para un conjunto de n números dados.
instrucción 2;
Son aquellos en que el número de iteraciones se ….
conoce antes de ejecutarse el ciclo. La forma de inicio instrucción n;
esta estructura es la siguiente: entero may,men,num,N,numerito;
fin
may=0;
Sintaxis men=9999;
para (VC = VI; CO; IN o DE) escribir"Cuantos números vas a ingresar? ";
Ejemplo 15 Calcular el promedio final de un
inicio leer N; alumno que tiene 7 calificaciones en la materia de
instrucción 1 para(num=1;num<=N;num=num+1) Programación básica.
instrucción 2 inicio
…. escribir "Ingresa el número ",num,":"; inicio
instrucción n leer numerito; real calif,sum=0, prom;
fin sí numerito>may entero unidad;
may=numerito; char nom[25];
donde: sí numerito<men escribir”Nombre del aluno:”;
men=numerito; leer nom;
VC – variable de control fin unidad=1;
VI – valor inicial escribir "El mayor valor es ",may; mientras(unidad<=7)
CO – condición para terminar escribir "El menor valor es ", men; inicio
IN – incremento variable de control fin escribir”Ingresa la calificación “,unidad;

leer calif si numerito>may
sum=sum+calif; hacer may=numerito;
unidad=unidad+1; instrucción 1; si numerito<men
fin instrucción 2; men=numerito;
prom=sum/7; …. num=num+1;
escribir”El promedio final de “,nom,” es :”,prom; instrucción n; mientras (num<=N);
fin mientras (condición) escribir "El mayor valor es ",may;
escribir "El menor valor es ", men;
fin
1.5 Diseño de
algoritmos aplicados
Ejemplo 16 Encontrar el menor y mayor valor de Ejemplo 17 Calcular el promedio final de un
un conjunto de n números dados. alumno que tiene 7 calificaciones en la materia de a problemas
Programación básica.
inicio
entero may,men,num,N,numerito; inicio Para poder elaborar un buen programa en
real calif,sum=0, prom; cualquier lenguaje de programación de manera
may=0; eficiente es necesario que previo a esto se diseñe
men=9999; entero unidad; el algoritmo.
escribir"Cuantos números vas a ingresar? "; char nom[25];
leer N; escribir”Nombre del aluno:”; La resolución de un problema exige el diseño de
num=1; leer nom; un algoritmo que resuelva el problema, como lo
unidad=1; muestra la siguiente figura:
mientras(num<=N)
inicio hacer
escribir "Ingresa el número ",num,":"; escribir”Ingresa la calificación “,unidad;
leer numerito; leer calif
sum=sum+calif; Diseño del Programa de
si numerito>may Problema
Algoritmo computadora
may=numerito; unidad=unidad+1
si numerito<men mientras(unidad<=7);
men=numerito; prom=sum/7;
num=num+1; escribir”El promedio final de “,nom,” es :”,prom;
fin fin
Ejemplo 19 Escribir un programa que muestre el
escribir "El mayor valor es ",may; resultado de la ecuación de tercer grado y=ax3 +
escribir "El menor valor es ", men; bx2 +cx + d para un valor de x. Para ello, debe leer
fin Ejemplo 18 Encontrar el menor y mayor valor de el valor de los coeficientes (a, b, c y d) y el valor de
un conjunto de n números dados. x y mostrar por pantalla el resultado de la
evaluación de la ecuación resultante.
inicio
✓ Hacer - Mientras entero may,men,num,N,numerito;
El algoritmo que resuelve este problema debe, en
primer lugar, leer cada uno de los coeficientes del
may=0; polinomio y el valor de x. A continuación, debe
Esta es una estructura similar en algunas men=9999; calcular el valor final del polinomio escribiendo
características, a la anterior, pero esta estructura una expresión que lo represente. Por último,
permite realizar el proceso cuando menos una escribir"Cuantos números vas a ingresar? ";
debe mostrar el valor resultante.
vez, ya que la condición se evalúa al final del leer N;
proceso. num=1;
La forma de esta estructura es la siguiente: - Pseudocódigo –
hacer
escribir "Ingresa el número ",num,":";
Sintaxis Inicio
leer numerito;

a,b,c,d,x,y es real; menorerror=999;
escribir “Evaluación del polinomio y=ax3 + bx2 escribir"Ingresa el número de máquinas que se
+cx + d “; van a evaluar ";
escribir”Valor de los coeficientes a, b,c y d:”; leer N;
leer a,b,c,d; para (maq=1;maq<=N;maq=maq+1)
escribir”Ingresa el valor de x :”; inicio
leer x; escribir"Ingresa el número de serie de la
y=a*(x*x*x) + b*(x*x) + c*x + d; máquina # ",maq," (3 dígitos)";
escribir”El resultado del polinomio es “,y; leer serie;
fin escribir"Tiempo de desempeño de la máquina
:";
leer tiempo;
sumatiempo=sumatiempo+tiempo;
- Diagrama de flujo –
escribir"Errores en el desempeño de la
máquina:";
leer numerror;
si tiempo<menortiempo
incio
menortiempo=tiempo; -
seriemenortiempo=serie; -
- Diagrama de flujo –
fin
sí tiempo>mayortiempo
inicio
mayortiempo=tiempo;
seriemayortiempo=serie;
fin
si numerror<menorerror
inicio
menorerror=numerror;
seriemenorerror=serie;
fin
fin
prom=sumatiempo/N;
Ejemplo 20 En este programa se va a administrar
el estado en el que se encuentran las máquinas de escribir"El promedio de tiempo de desempeño
una fábrica, esto facilitará el proceso de de las ",N," máquinas es :", prom;
administración de las máquinas y permitirá escribir"La máquina con mayor desempeño es
programar mantenimiento predictivo para las :",seriemayortiempo," con ",mayortiempo,"
máquinas. horas";
escribir"La máquina con menor desempeño es
- Pseudocódigo – :",seriemenortiempo," con ",menortiempo,"
horas";
escribir"La máquina con menor número de
inicio
errores es :",seriemenorerror," con
entero N,maq,serie,seriemayortiempo,tiempo; ",menorerror," errores";
entero seriemenortiempo,seriemenorerror, fin
numerror;
entero mayortiempo,menortiempo,
menorerror;
real sumatiempo,prom;
sumatiempo=0;
menortiempo=999;
mayortiempo=0;


1.6 Diseño Ejemplo 21 Escribe una función en pseudocódigo
algorítmico de que devuelva el área de un rectángulo dada su

base y su altura, llama a la función en el algoritmo
funciones principal.
funcion area = area_rectangulo (base real, altura

La mejor estrategia para resolver un problema a real)
través de un algoritmo es dividir el problema en
real area;
varios subproblemas y resolverlos de forma
independiente entre sí (funciones), sin embargo, inicio
pueden ser reutilizados varias veces durante la area=base*altura;
ejecución del algoritmo. Y de esta forma, return area
podemos obtener un algoritmo más legible y Ejemplo 22 Calcula el factorial de un número
finfuncion
comprensible, que nos facilitará modificarlo para (entero positivo), a través de un algoritmo,
mejoras o añadir nuevas funcionalidades. utilizando una función.
algoritmo principal
La función se relaciona especificando su nombre real base, altura; funcion suma = factorial (numero)
en una expresión, como si fuera una variable inicio
ordinaria de tipo simple. Las funciones se dividen escribir "Ingresa la base"; suma,contador es entero;
en: suma=numero;
leer base
para (contador=numero-1; contador<=1;
escribir "Ingresa la altura";
- Estándar: son funciones proporcionadas por contador=contador-1)
cualquier lenguaje de programación de alto nivel, Leer altura
suma=suma*contador;
y se dividen en aritméticas y alfabéticas. area=area_rectangulo (base, altura);
finPara
escribir “Area del rectángulo = “,area;
finfuncion
- Definidas por el usuario: son funciones que fin
puede definirlas el programador con el propósito
de ejecutar alguna función específica, y que por lo inicio
general se usan cuando se trata de hacer algún entero numero,resultado:
cálculo que será requerido en varias ocasiones en escribir "Introduce un numero";
la parte principal del algoritmo.
leer numero;
resultado=factorial(numero);
Nos enfocaremos en las funciones definidas por
escribir resultado;
el usuario. El algoritmo principal llama o invoca a
la función, se ejecuta y devuelve un resultado. Se fin
puede usar en varios programas. Una función es
un subprograma que acepta parámetros y
devuelve un único resultado. Los parámetros
serán los datos de entrada para realizar la
función.
En la cabecera de la función se debe indicar los

parámetros formales, indicando su tipo, y el tipo
de valor que devolverá la función. También
debemos declarar las variables que se vayan a
usar y devolver un valor, que corresponda al tipo
de variable.
Sintaxis
Función nombre (lista parámetros formales):tipo
Var: declaración de variables
Inicio
Instrucciones
devolver valor
Fin-función

Ejercicios propuestos
Ejercicios de Algoritmos Simples

1. Al recibir como datos la base y la altura de un
triángulo, calcule su superficie.
2. Al recibir como datos la longitud y el peso de un
objeto expresados en pies y libras, imprima los
datos de este objeto, pero expresados en metros
y kilos, respectivamente.
3. Al recibir como datos el radio y la altura de un
cilindro, calcule e imprima el área y su volumen.
4. Al recibir como dato el radio de un círculo,
calcule e imprima tanto su área como la longitud
de su circunferencia.
5. Al recibir como dato un número de cuatro
dígitos, genere una impresión como la que se
muestra a continuación (el número 6352):
6
3
5
2
Ejercicios de Algoritmos con estructuras de

Selección
1. Al recibir como datos tres valores enteros R, T
y Q, determine si los mismos satisfacen la
siguiente expresión, y que, en caso afirmativo,
escriba los valores correspondientes de R, T y Q.
R4–T3+ 4 * Q2< 820
2. Al recibir como dato un número entero,

determine e imprima si el mismo es par, impar o
nulo.
3. Al recibir como datos de entrada tres valores
enteros diferentes entre sí, determine si los
mismos están en orden creciente.
4. Calcular el valor de f(x) según la siguiente
expresión:
5. Al recibir como datos tres números reales,

identifique cuál es el mayor. Considera que los
números pueden ser iguales.
Ejercicios de Algoritmos con estructuras de

Repetición

1. Al recibir como datos N números enteros,
obtenga solamente la suma de los números
positivos.
2. Al recibir como dato un número entero N,
calcule el factorial de dicho número. Recuerda
que el Factorial (0) es 1, el Factorial (1) es 1, y el
Factorial (n) se calcula como n* Factorial(n-1).
3. Al recibir como datos N números enteros,
obtenga la suma de los números pares y el
promedio de los impares.
4. Al recibir como datos las calificaciones de un
grupo de N alumnos que presentaron su examen
de admisión para ingresar a una universidad
privada en México, calcule y escriba el número de
calificaciones que hay en cada uno de los
siguientes rangos:
0 . . . 3.99
4 . . . 5.99
6 . . . 7.99
8 . . . 8.99
9 . . . 10
5. Los organizadores de un acto electoral

solicitaron realizar un programa de cómputo para
manejar el conteo de los votos. En la elección hay
cinco candidatos, los cuales se representan con
los valores comprendidos de 1 a 5, construye un
pseudocódigo y diagrama de flujo que permita
obtener el número de votos de cada candidato y
el porcentaje que obtuvo respecto al total de los
votantes. El usuario ingresa los votos de manera
desorganizada, tal y como se obtienen en una
elección, el final de datos se representa por un
cero. Observa como ejemplo la siguiente lista:
25543445124312450
Acceso al Video Tema 1 Diseño de Algoritmos en

PSeInt mp4 ANEXO 1
Solución de ejercicios Propuestos ANEXO 2

3. Lenguajes de alto nivel
2.1 Características programación en el mercado porque esto les Son los más utilizados por los programadores.
reportará más beneficios económicos. Están diseñados para que las personas escriban y
del lenguaje de
entiendan los programas de un modo mucho más
Los principales tipos de lenguajes utilizados en la fácil que los lenguajes máquina y ensamblador.
Programación actualidad son tres: Los programas son portables o transportables.
1. Lenguaje máquina Los programas fuente tienen que ser traducidos

por compiladores e intérpretes.
Una vez que se ha visto cómo abordar un Son aquellos que están escritos en lenguajes
problema y cómo diseñar un algoritmo, el directamente inteligibles por la computadora, ya . Intérpretes
siguiente paso es la codificación a través de un
que sus instrucciones son cadenas binarias que Es un traductor que toma un programa fuente, lo
lenguaje de programación, es decir, construir un
especifican una operación y las posiciones traduce y a continuación lo ejecuta, por ejemplo,
programa. Los lenguajes de computación pueden
(dirección) de memoria implicadas en la BASIC, Qbasic y QuickBASIC.
ser de propósito general o específicos. operación se denominan instrucciones de . Compiladores
máquina o código máquina conocido como Es un programa que traduce los programas
C, C++, Java, Pascal, etc. son lenguajes de código binario. fuente escritos en lenguaje de alto nivel a
programación de propósito general SQL, Las instrucciones en lenguaje máquina dependen lenguaje máquina. De programa fuente se
PROMELA, MIDAS, DYSAC, DSL, GASP, GPSS, del hardware de la computadora y, por tanto, traduce al programa objeto o código objeto, por
SIMULA, CSSL son lenguajes específicos. diferirán de una computadora a otra. ejemplo, C, C++, Pascal, Java y COBOL.
Existen distintos tipos de lenguajes de 2. Lenguaje de bajo nivel (ensamblador)

programación porque cada uno de ellos está
especificado para resolver un grupo de Es más fácil de utilizar que el lenguaje máquina,
problemas con características similares, los pero al igual que el lenguaje máquina, dependen
lenguajes de programación han ido de la máquina en particular.
evolucionando hacia una mayor facilidad, Las instrucciones en lenguaje ensamblador son
flexibilidad y potencia. instrucciones conocidas como nemotécnicos;
ejem. ADD, SUB, DIV (ADD M, N, P) requiere una
Las compañías que diseñan software están muy fase de traducción al lenguaje máquina.
interesadas en tener muchos lenguajes de

Lenguaje de Ejemplo
Programación C
Conversión de pulgadas a centímetros.
#include <stdio.h>
C es el lenguaje de programación de propósito #include <conio.h>
general, la popularidad, eficacia y potencia de C, main()
se ha producido porque este lenguaje no está {
prácticamente asociado a ningún sistema float cm; int pulg;
operativo, ni a ninguna máquina, en especial. printf(“Conv. de pulgadas a
Esta es la razón fundamental, por la cual C, es centímetros \n”);
conocido como el lenguaje de programación de printf(“Dame las pulgadas “);
sistemas, por excelencia. Rico en tipo de datos, scanf(“%d”,&pulg);
operadores y variables en C. cm = pulg * 2.54;
printf (“%d pulgadas 5 %7.3f
C nació realmente en 1972, con la publicación de centímetros\n”,pulg,cm);
The C Programming Lenguaje, por Brian }
Kernighan y Dennos Ritchie (Prentice Hall, 1978).
Desde su nacimiento, C fue creciendo en La programación estructurada significa escribir
popularidad y los sucesivos cambios en el
lenguaje a lo largo de los años junto a la creación
de compiladores por grupos no involucrados en
un programa de acuerdo con las siguientes
reglas: 2.3 Traducción de
su diseño, hicieron necesario pensar en la 1. El programa tiene un diseño modular (el un programa:
estandarización de la definición del lenguaje C.
Por ello, y dado que todo programa que se
programa se divide en módulos)
2. Los módulos son diseñados de modo compilación, enlace de
un programa, errores en
desarrolle siguiendo el standard ANSI de C será descendente
fácilmente portable de un modelo de 3. Cada módulo se codifica utilizando las tres
computadora a otro modelo de computadora, y
de igual forma de un modelo de compilador a
estructuras de control básica: secuenciales, tiempo de compilación
selección y repetición.
otro. El lenguaje C posee un número reducido de
palabras reservadas (tan solo 32) que define el Las etapas por las que debe pasar un programa
standard ANSI-C. Estas palabras reservadas escrito en un lenguaje de programación, hasta
pueden verse en la tabla siguiente: poder ser ejecutable son:
Tabla 8 Palabras reservadas en lenguaje C 2.2 Estructura Programa fuente: Programa escrito en un
básica de un lenguaje de alto nivel (texto ordinario que
contiene las sentencias del programa en un
programa lenguaje de programación). Necesita ser

traducido a código máquina para poder ser
ejecutado.
Se define como un lenguaje de programación
estructurado de propósito general. El lenguaje C
Todo programa de C consta, básicamente, de un Compilador: Programa encargado de traducir los
tiene una gran cantidad de ventajas sobre otros
conjunto de funciones, y una función llamada programas fuentes escritos en un lenguaje de alto
lenguajes:
main, esta es la primera que se ejecuta al nivel a lenguaje máquina y de comprobar que las
✓ Es poderoso y flexible, con órdenes, comenzar el programa, desde la cual es posible llamadas a las funciones de librería se realizan
operaciones y funciones de biblioteca que llamar a otras funciones. Cada función debe correctamente.
se pueden utilizar para escribir la mayoría contener: cabecera, argumentos y sentencias. Programa (o código) objeto: Es el programa
de los programas que corren en la Delgado, H. (2020). fuente traducido (por el compilador) a código
computadora. máquina. Aún no es directamente ejecutable.
✓ Se utiliza por programadores profesionales
/*Descripción de Bibliotecas*/ Programa Ejecutable: Traducción completa a
para desarrollar software en la mayoría de #include<stdio.h>
los modernos sistemas de computadora. código máquina, realizada por el enlazador, del
✓ Se puede utilizar C para desarrollar /*Función Principal*/ programa fuente y que ya es directamente
sistemas operativos, compiladores, main() ejecutable.
{
sistemas de tiempo real y aplicaciones de
comunicaciones. Montador o enlazador (Linker ): Es el programa
/* Cuerpo del programa*/
✓ Puede ser escrito para un tipo de printf(“Estructura básica de encargado de insertar al programa objeto el
computadora y trasladarse a otra programa en C \n”); código máquina de las funciones de las librerías
computadora con pocas o ninguna } (archivos de biblioteca) usadas en el programa y
modificación (portabilidad). realizar el proceso de montaje, que producirá un
programa ejecutable .exe.

Las librerías son una colección de código El código de salida debe ser correcto y eficiente, 2.5 Elementos del
lenguaje: datos,
(funciones) ya programado y traducido a código es decir, debe utilizar de forma eficaz los recursos
máquina, listo para utilizar en un programa y que de la computadora. Además, el propio generador
facilita la labor del programador. de código debe ejecutarse eficientemente.
literales y constantes,
Errores en tiempo de compilación Los pasos para seguir para la elaboración y
ejecución de un programa, los podemos resumir
identificadores,
Si el programa fuente no tiene errores de sintaxis, de la siguiente manera: variables, parámetros,
el compilador generará el código objeto, en caso
contrario mostrará una lista con los errores 1. Escribir el código fuente, utilizando cualquier operadores, entrada y
encontrados, no generándose ningún programa editor.
objeto, para que procedamos a su depuración. 2. Compilar el archivo fuente
salida de datos
3. Si se producen errores de sintaxis (o warnings)
Los compiladores emiten mensajes de error o de volver al editor y corregir los errores de sintaxis.
advertencia durante las fases de compilación, de 4. Si no hay errores se obtendrá el código objeto Tipos de datos
enlace o de ejecución de un programa: y el enlazador construirá el archivo ejecutable.
5. Una vez que se tiene el archivo ejecutable, será Para hacer uso de variables debemos declararlas
Los errores en tiempo de compilación son los que el sistema operativo el encargado de colocar el previamente con algún tipo de dato,
se producen antes de la ejecución del programa, programa en la memoria central y ejecutarlo. dependiendo del tipo será el espacio que ocupará
durante el proceso de compilación del programa. 6. Comprobar el funcionamiento del programa. en memoria RAM.
7. Si se detecta errores o un mal funcionamiento
Los errores que se pueden producir en la fase de del programa, activar el depurador para trazar el En C existen básicamente cuatro tipos de datos,
compilación son: programa y ejecutarlo sentencia a sentencia. aunque como se verá después, podremos definir
8. Una vez que se encuentra la causa del error, a nuestros propios tipos de datos a partir de estos
− Errores fatales: Son raros. Indican errores través del editor, se corrige. cuatro.
internos del compilador. Cuando ocurre la 9. El proceso de compilar, enlazar y ejecutar el
compilación se detiene inmediatamente. programa lo repetiremos hasta que no se A continuación, en la tabla 9 se detalla su
produzcan errores. nombre, el tamaño que ocupa en memoria y el
− Errores de sintaxis: Son los errores típicos de rango de sus posibles valores. Delgado, H. (2020).
sintaxis. No detienen la compilación, sino que al
finalizar ésta se mostrará la lista con todos los Fase de ejecución de un programa
errores encontrados. Algunos errores suelen ser Tabla 9Tipos de Datos en Lenguaje C
consecuencia de otros cometidos con Una vez que tenemos el programa en lenguaje
anterioridad. Con este tipo de errores no se máquina, para poderlo ejecutar hay que
puede obtener un programa objeto y por lo tanto introducirlo en la memoria.
tampoco el ejecutable.
✓ Una utilidad del sistema operativo llamada
− Advertencias o avisos (warnings): Indican que cargador colocará el programa, y sus datos
hay líneas de código sospechosas que, a pesar de de entrada, en memoria principal,
no infringir ninguna regla sintáctica, el preparándolo para su ejecución.
compilador las encuentra susceptibles de
Los calificadores de tipo tienen la misión de
provocar un error. Cuando se detecta un warning ✓ El sistema operativo le pasa el control a la
modificar el rango de valores de un determinado
la compilación no se detiene. Si en un programa unidad de control de proceso, para que
tipo de variable. Estos calificadores son cuatro:
fuente sólo se detectan warnings, se podrá comience la ejecución del programa,
obtener un programa objeto, que tras el linkado realizando la unidad de control los
dará lugar a un programa ejecutable. siguientes pasos (fases):
Signed
Captación de la instrucción: Lee de la memoria
principal la instrucción a ejecutar.
Le indica a la variable que va a llevar signo, es el
2.4 Ejecución de un
utilizado por defecto.
Ejecución de la instrucción: Interpreta la
instrucción leída y envía señales de control a las
programa unidades que deban intervenir en su ejecución.
Tras dicha ejecución se establece cuál será la
Tabla 10Tipos de datos signed
siguiente instrucción para ejecutar.

Generación de código ejecutable.
La fase final del compilador es la generación de

código ejecutable. Toma como entrada la
representación intermedia del programa fuente y
produce como salida un programa objeto
equivalente.

Al contrario que las variables, las constantes
Unsigned Ejemplo mantienen su valor a lo largo de todo el
programa.
Le indica a la variable que no va a llevar signo (sin /* Uso de las variables */
valores negativos). #include <stdio.h> Para indicar al compilador que se trata de una
main() /* Suma dos valores */ constante, usaremos la directiva #define:
Tabla 11Tipo de datos unsigned {
int num1=4,num2,num3=6; #define <identificador> <valor>
printf("El valor de num1 es %d",
num1);
Importante observar que no se indica el punto y
printf("\n El valor de num3 es
%d", num3); coma de final de sentencia ni tampoco el tipo de
num2=num1+num3; dato.
printf("\n num1 + num3 =
Short La directiva #define no sólo nos permite sustituir
%d",num2);
} un nombre por un valor numérico, sino también
Rango de valores en formato corto (limitado), es por una cadena de caracteres.
el utilizado por defecto.
Las variables pueden ser de dos tipos según el El valor de una constante no puede ser
Tabla 12Tipo de datos short
lugar en que las declaremos: globales o locales. modificado de ninguna manera.
La variable global se declara antes del main(). Ejemplo

Puede ser utilizada en cualquier parte del
programa y se destruye al finalizar éste. /* Uso de las constantes */
#include <stdio.h>
La variable local se declara después del main(), en #define pi 3.1416
Long la función en que vaya a ser utilizada. Sólo existe #define escribe printf
dentro de la función en que se declara y se main() /* Calcula el perímetro */
Rango de valores en formato largo (ampliado). destruye al finalizar dicha función. {
int r;
Recordemos que el identificador (nombre de la escribe("Introduce el radio: ");
scanf("%d",&r);
variable) no puede ser una palabra reservada y
Tabla 13Tipo de datos long escribe("El perímetro es: %f",
los caracteres que podemos utilizar son las letras: 2*pi*r);
a-z y A-Z (la ñ o Ñ no está permitida), los }
números: 0-9 y el símbolo de subrayado _.
Además, hay que tener en cuenta que el primer
carácter no puede ser un número y no se Secuencias de escape
permiten los espacios en blanco como
También es posible combinar calificadores entre separadores de palabras. Las secuencias de escape se utilizan para definir
sí. ciertos caracteres especiales dentro de cadenas
de texto. Ciertos caracteres no representados
Variables Ejemplo gráficamente se pueden representar mediante lo
que se conoce como secuencia de escape.
/* Declaración de variables */
Los datos son almacenados en variables y en C
#include <stdio.h>
como en otros lenguajes estas variables deben int a; A continuación, vemos la tabla 14 con las
tener un tipo de dato. main() /* Muestra dos valores */ secuencias de escape más significativas:
{
Una variable es un tipo de dato, referenciado int b=4;
mediante un identificador (que es el nombre de la printf("b es local y vale %d", Tabla 14Secuencias de escape
variable). Su contenido podrá ser modificado a lo b);
largo del programa. a=5;
printf("\n a es global y vale
Una variable sólo puede pertenecer a un tipo de %d",a);
dato. Para poder utilizar una variable, primero }
tiene que ser declarada:
[calificador] <tipo> <nombre> Constantes

Es posible inicializar y declarar más de una En C las constantes se declaran con la directiva
variable del mismo tipo en la misma sentencia: #define, esto significa que esa constante tendrá
el mismo valor a lo largo de todo el programa.
[calificador] <tipo>
<nombre1>,<nombre2>=<valor>,<nombre3>
=<valor>,<nombre4>

Ejemplo
OPERADORES UNARIOS: Con estos operadores se pueden escribir, de
/* Uso de las secuencias de escape */ forma más breve, expresiones del tipo:
#include <stdio.h> Tabla 16 Operadores unarios
main() /* Escribe diversas sec. de escape */ n=n+3 se puede escribir n+=3
{ k=k*(x-2) lo podemos sustituir por k*=x-2
printf("Me llamo \"Nemo\" el grande");
printf("\nDirección: C\\ Mayor 25");
printf("\nHa salido la letra \'L\'");
printf("\nRetroceso\b");
Ejemplo
printf("\n\tEsto ha sido todo");
}
/* Uso de los operadores de
Sintaxis asignación */
Inclusión de archivos de cabecera - #include <stdio.h>
Directiva #include Binarios main()
<variable1><operador><variable2> /* Realiza varias operaciones */
{
La directiva de preprocesador #include se usa en int a=1,b=2,c=3,r;
Unitarios
los lenguajes C y C++ para incluir las a+=5;
<variable><operador> y al revés,
declaraciones de otro fichero en la compilación. printf("a + 5 = %d\n",a);
<operador><variable>
c-=1;
En la programación en C es posible utilizar printf("c - 1 = %d\n",c);
funciones que no estén incluidas en el propio b*=3;
Ejemplo printf("b * 3 = %d",b);
programa. Para ello utilizamos la directiva
#include, que nos permite añadir librerías o }
/* Uso de los operadores
funciones que se encuentran en otros ficheros a aritméticos */
nuestro programa. #include <stdio.h>
main()
Para indicar al compilador que vamos a incluir /* Realiza varias operaciones */
ficheros externos podemos hacerlo de dos { Jerarquía de operadores
maneras (siempre antes de las declaraciones). int a=1,b=2,c=3,r;
r=a+b; Será importante tener en cuenta la precedencia
1. Indicándole al compilador la ruta donde se printf("%d + %d = d\n",a,b,r); de los operadores a la hora de trabajar con ellos:
encuentra el fichero. r=c-a;
printf("%d - %d =%d\n",c,a,r);
#include "misfunc.h" b++;
#include "c:\includes\misfunc.h" Tabla 18 Jerarquía de operadores
printf("b + 1 = %d",b);
2. Indicando que se encuentran en el directorio }
por defecto del compilador.
#include <misfunc.h> Operadores de asignación
Operadores Aritméticos
La mayoría de los operadores aritméticos
binarios tienen su correspondiente operador de
Los operadores comunes son: la suma, resta,
asignación:
multiplicación y división, pero también existen
los unarios, de asignación y su jerarquía.
Las operaciones con mayor precedencia se
Existen dos tipos de operadores aritméticos:
Tabla 17 Operadores de asignación realizan antes que las de menor precedencia.
OPERADORES BINARIOS:
Si en una operación encontramos signos del
mismo nivel de precedencia, dicha operación se
realiza de izquierda a derecha. A continuación,
Tabla 15 Operadores binarios
se muestra un ejemplo sobre ello:
a*b+c/d-e
a*b resultado = x
c/d resultado = y
x+y resultado = z
z-e

Fijarse que la multiplicación se resuelve antes que printf ("El valor de a es caracter de conversión. Los argumentos
la división ya que está situada más a la izquierda %d\n" ,a); indicados serán, nuevamente, las variables.
en la operación. Lo mismo ocurre con la suma y la printf ("El valor de b es
resta. %d\n" ,b); La principal característica de la sentencia scanf es
printf ("Por tanto %d+%d=%d" que necesita saber la posición de la memoria del
,a,b,a+b);
ordenador en que se encuentra la variable para
}
Ejemplo poder almacenar la información obtenida. Para
indicarle esta posición utilizaremos el símbolo
/* Jerarquía de los operadores */ ampersand ( & ), que colocaremos delante del
#include <stdio.h>
main() /* Realiza una operación */ Modificadores en lenguaje C nombre de cada variable. ( esto no será necesario
en los arreglos ).
{
int Tabla 19 Modificadores en lenguaje C
a=6,b=5,c=4,d=2,e=1,x,y,z,r; Ejemplo
x=a*b;
printf("%d * %d = %d\n",a,b,x); /* Uso de la sentencia scanf() */
y=c/d; #include <stdio.h>
printf("%d / %d = %d\n",c,d,y); main() /* Solicita dos datos */
z=x+y; {
printf("%d + %d = %d\n",x,y,z); char nombre[10];
r=z-e; int edad;
printf("%d = %d",r,a*b+c/d-e); printf("Introduce tu nombre: ");
} scanf("%s",&nombre);
printf("Introduce tu edad: ");
scanf("%d",&edad);
}
Printf y Scanf
printf() y scanf() son funciones de lenguaje C que
nos permitirán imprimir datos en pantalla o por el
contrario, obtener datos a través del teclado. Operadores relacionales
Salida de datos Se llaman operadores relacionales o de
Ejemplo comparación aquellos que permiten comparar
SENTENCIA / FUNCIÓN PRINTF dos valores evaluando si es menor, mayor o igual
#include <stdio.h> uno que otro, etc.
La rutina printf() permite la aparición de valores main() /* Modificadores 1 */
numéricos, caracteres y cadenas de texto por {
char cad[ ]="El valor de"; Los operadores relacionales se utilizan para
pantalla. comparar el contenido de dos variables.
int a=-15;
unsigned int b=3;
El prototipo de la sentencia printf es el siguiente: float c=932.5; En C existen seis operadores relacionales básicos:
printf("%s a es %d\n",cad,a);
printf(control,arg1,arg2...); printf("%s b es %u\n",cad,b); Tabla 20 Operadores relacionales
printf("%s c es %e o %f",cad,
En la cadena de control indicamos la forma en c,c);
que se mostrarán los argumentos posteriores. }
También podemos introducir una cadena de
texto (sin necesidad de argumentos), o combinar
ambas posibilidades, así como secuencias de Entrada de datos
escape. En el caso de que utilicemos argumentos
deberemos indicar en la cadena de control tantos
modificadores como argumentos vayamos a SENTENCIA / FUNCIÓN SCANF
presentar.
La rutina scanf() permite entrar datos en la
memoria del ordenador a través del teclado.
El modificador está compuesto por el caracter %
seguido por un caracter de conversión, que indica
El prototipo de la sentencia scanf es el siguiente:
de que tipo de dato se trata.
El resultado que devuelven estos operadores es 1
scanf(control,arg1,arg2...); para Verdadero y 0 para Falso.
Ejemplo
En la cadena de control indicaremos, por regla
#include <stdio.h> Si hay más de un operador se evalúan de
main() general, los modificadores que harán referencia izquierda a derecha. Además, los operadores == y
/* Saca por pantalla una suma */ al tipo de dato de los argumentos. Al igual que en != están por debajo del resto en cuanto al orden
{ la sentencia printf los modificadores estarán de precedencia.
int a=20,b=10; formados por el caracter % seguido de un

Ejemplo Ejemplo else
{
/*Uso de los operadores /* Variables globales y locales. if((numero<=100)&&(numero>=25))
relacionales*/ */ printf("El número está entre 25
#include <stdio.h> #include <stdio.h> y 100");
main() int num1=1; else
/* Compara dos números entre main() if((numero<25)||(numero>100))
ellos */ /* Escribe dos cifras */ printf("El número no está entre
{ { 25 y 100");
int a,b; int num2=10; }
printf("Introduce el valor de A: printf("%d\n",num1); }
"); printf("%d\n",num2);
scanf("%d",&a); }
printf("Introduce el valor de B:
");
scanf("%d",&b); 2.6 Errores en
if(a>b)
printf("A es mayor que B"); Operadores lógicos tiempo de ejecución
else
{ Las expresiones conectadas con los operadores
if(a<b) se evalúan de izquierda a derecha y la evaluación Como cada lenguaje de programación tiene unas
printf("B es mayor que A"); se detiene cuando el resultado es verdadero o reglas especiales (sintaxis) debe existir un
else falso. compilador específico para cada lenguaje de
printf("A y B son iguales"); programación.
} Los operadores lógicos básicos son tres:
} Si el programa fuente no tiene errores de sintaxis,
el compilador generará el código objeto, en caso
Tabla 21 Operadores lógicos contrario mostrará una lista con los errores
Variables Locales y Globales encontrados, no generándose ningún programa
objeto, para que procedamos a su depuración.
Una variable local es aquella cuyo ámbito se
restringe a la función que se declaró. Una variable Los compiladores emiten mensajes de error o de
global se define fuera del cuerpo de cualquier advertencia durante las fases de compilación, de
función. enlace o de ejecución de un programa:
Tiempo de vida de los datos. Según el lugar • Los errores en tiempo de compilación son los
donde son declaradas puede haber dos tipos de que se producen antes de la ejecución del
variables. Estos operadores actúan sobre expresiones programa, durante el proceso de compilación del
lógicas. Permiten unir expresiones lógicas programa.
simples formando otras más complejas
Variables Globales • Los errores en tiempo de ejecución son los que
se producen durante la ejecución del programa.
Tabla 22 Tabla de verdad Son los más difíciles de encontrar, no son
Las variables permanecen activas durante todo el
programa. Se crean al iniciarse éste y se detectados por el compilador, ya que son errores
destruyen de la memoria al finalizar. Pueden ser de lógica, no de sintaxis.
utilizadas en cualquier función.
Con respecto a los errores en tiempo de
ejecución, encontrar la causa que los provoca es
Variables Locales una labor en ocasiones complicada, razón por la
cual los EID (Entornos Integrados de Desarrollo,
Las variables son creadas cuando el programa por ejemplo, DevC++) nos proporcionan una
llega a la función en la que están definidas. Al herramienta llamada depurador que nos ayuda a
finalizar la función desaparecen de la memoria. Ejemplo encontrar los errores lógicos y demás errores
producidos en tiempo de ejecución.
Si dos variables, una global y una local, tienen el
/* Uso de los op. lógicos
mismo nombre, la local prevalecerá sobre la AND,OR,NOT*/ Un depurador (debugger), es un programa
global dentro de la función en que ha sido #include <stdio.h> diseñado específicamente para la detección,
declarada. main() verificación y corrección de errores. Los
/* Compara un número introducido depuradores nos permiten trazar el programa
Dos variables locales pueden tener el mismo */ (ejecutarlo sentencia a sentencia) y visualizar el
nombre siempre que estén declaradas en { contenido de las variables y direcciones de
funciones diferentes. int numero;
printf("Introduce un número: "); memoria durante la ejecución del programa.
scanf("%d",&numero); Además, permiten alterar el flujo de ejecución de
if(!(numero>=0)) este, cambiar los valores de las variables e
printf("El número es negativo"); introducir puntos de parada.

A. ¿Cuál es el valor de las siguientes expresiones?
a. 15*14-3*7
b. -4*5*2
c. (24+2*6) / 4
d. 3+4* (8*(4-(9+3)/6))
e. 4*3*5+8*4*2-5
f. 4-40/5
g. (-5)%(-2)
B. Elabora los siguientes programas:
1. Calcular el área del círculo y el volumen de una

esfera con el mismo radio.
2.Calcular la hipotenusa de un triángulo
rectángulo.
3. Leer el lado de un triángulo equilátero. Calcular
el perímetro, la altura, y el área de dicho
triángulo.
4. Leer una cantidad de pesos (número entero) y
calcular a cuántos billetes de 1000, 500, 200,100,
50, 20 y monedas de 10, 5, 1 peso equivale.
5. Multiplicación de dos números reales con tres
cifras decimales. Imprimir el resultado en el
siguiente formato:
0023.72*
0145.14 =
------------
3443.08
Acceso al Video Tema 2 Introducir el tema de

desarrollo de programas DevC mp4
ANEXO 3

Análisis:
#include <stdio.h> El programa que resuelve este problema debe, en
main() primer lugar, leer cada uno de los coeficientes del
{ polinomio y el valor de x.
3.1 Estructuras float precio_neto,precio,margen;
printf("Cual es el precio?");
A continuación, debe calcular el valor final del
polinomio escribiendo una expresión que lo
secuenciales scanf ("%f", &precio);
printf("Cual es el margen?");
represente.
Por último, debe mostrar el valor resultante.
scanf ("%f", &margen);
precio_neto=precio*(100+margen)/100;
Implementación
La estructura secuencial se conoce como una /* Salida de datos */
instrucción que sigue a otra en secuencia, es printf ("El precio neto de este
#include <stdio.h>
decir, la salida de una instrucción es la entrada de producto es de $ %f \n", main()
la siguiente consecuentemente hasta que precio_neto); {
}
termine el proceso. float a, b, c, d, x, y;
/* Lectura de coeficientes */
Es la estructura más sencilla ya que el printf("Evaluación del polinomio
programador identifica los datos de entrada, los y=ax^3 + bx^2 + cx + d.\n");
procesa y muestra o imprime los datos de salida. printf("Valor de los coeficientes
Ejercicio práctico con a, b, c y d:");
La estructura secuencial se puede representar de scanf ("%f%f%f%f",&a,&b,&c,&d);
la siguiente forma: estructura /* Lectura del valor de x */
printf("Introducir el valor de
main() secuencial la variable x:");
{ scanf ("%f", &x);
inst 1; /* Proceso: cálculo del polinomio */
inst 2; y = a*x*x*x + b*x*x + c*x + d;
…… /* Salida */
inst n; Escribir un programa que muestra el resultado de printf("El resultado del
} la ecuación de tercer grado y = ax3 + bx 2 + cx + d polinomio %.2f x^3 + %.2f x^2",
para un valor de x. Para ello, debe leer el valor de a,
los coeficientes (a, b, c y d) y el valor de x y b);
Ejemplo mostrar por pantalla el resultado de la evaluación printf(" + %.2f x + %.2f para
x=%.2f es: %.2f\n",c,d,x,y);
Calcula el precio neto de un producto de una de la ecuación resultante.
}
empresa de venta de refacciones de automóviles

Las sentencias de control if pueden ir anidadas. Análisis
Un if anidado es una sentencia if que es el objeto En este problema, dados los lados de un
de otro if o else. Esta anidación de if/else puede triángulo, se pide, por un lado, clasificar este
3.2 Estructuras presentar la problemática de decidir que else va
asociado a cada if.
triángulo según sus lados y, por otro, hallar el
área de este.
selectivas: simple, if (x)
En primer lugar, se determina cuáles son los
datos de entrada y de salida y un esbozo del
doble y múltiple if (y)
printf(“1”);
proceso a realizar para obtener estos datos de
salida a partir de los datos de entrada:
else
printf(“2”);
✓ datos de entrada - lados del triángulo.
Para diseñar programas capaces de tomar ✓ datos de salida - tipo de triángulo y su área.
decisiones se requiere de las estructuras de ¿A que if se refiere el else?. C soluciona este
control selectivas, también llamadas problema asociando cada else al if más cercano • proceso - comprobar el número de lados iguales
condicionales. Éstas llevan a cabo su función posible y que todavía no tiene ningún else del triángulo para determinar su tipo y aplicar la
(controlar el flujo del programa) mediante una asociado. fórmula de Herón dada en el enunciado para
condición que se representa utilizando hallar el área.
expresiones booleanas, de tal manera que Es por ello por lo que en este caso el if asociado al
cuando la condición se cumple (es verdadera) se else es el if(y). Si queremos que el else este Para poder indicar de qué tipo es el triángulo, hay
ejecuta un conjunto de instrucciones definidas asociado al if(x), deberíamos escribirlo de la que comparar sus lados dos a dos (las expresiones
para este caso y, dependiendo del tipo de siguiente forma: relacionales son binarias) y determinar cuántos
estructura, es posible que se ejecute otro son iguales. Es decir:
conjunto de instrucciones distinto para el caso if (x)
contrario (cuando la condición es falsa); e incluso, { • Si el lado a y el lado b son iguales, ya se tienen
es posible definir diferentes conjuntos de if (y) dos lados iguales. Si además el lado c también lo
instrucciones para valores distintos que pudiera printf(“1”); es (igual al lado a o al lado b, ya que son iguales
} entre sí), entonces los tres lados son iguales y, por
tomar una variable.
else tanto, el triángulo es equilátero. Pero si el lado c
Es así como dependiendo de su estructura se han
printf(“2”); no es igual, entonces sólo se tienen dos lados
definido tres tipos: simples, dobles y múltiples.
iguales y el triángulo es isósceles.
Estructura selectiva simple (if) y doble • Si el lado a y el lado b no son iguales, ya se sabe
(if-else) que el triángulo no puede ser equilátero.
Entonces se debe comprobar si alguno de ellos es
Sintaxis igual al lado c. Si se determina que el lado a o el
lado b son iguales al lado c, entonces el triángulo
if (condición) es isósceles. Si no, todos los lados son distintos
sentencia; entre sí y por tanto el triángulo es escaleno.
else
sentencia; En cuanto al cálculo del área, es necesario
obtener en primer lugar el valor del
semiperímetro p, para utilizarlo en la expresión
Siendo el else opcional. Si la condición es del área. También hay que tener en cuenta que se
verdadera se ejecuta la sentencia asociada al if, debe calcular la raíz cuadrada para obtener el
en caso de que sea falsa la condición se ejecuta la área real del triángulo.
sentencia asociada al else (si existe el else).
Ejercicio práctico con Una vez definidos los datos de entrada y de salida
Veamos algunos ejemplos de sentencias if: y cuál va a ser el proceso a realizar, se diseña un
estructuras selectivas if, algoritmo del funcionamiento del programa:
int a,b;
if… else
1. Leer los lados del triángulo y almacenarlos en
if (a>b)
las variables lado_a, lado_b, y lado_c.
{
b--; 2. Determinar el tipo de triángulo con el siguiente
Diseñar un programa que, dados los lados de un proceso:
a=a+5;
} triángulo a, b y c, indique si es equilátero, a. Si la variable lado_a es igual a la variable
else isósceles o escaleno y que calcule su área lado_b entonces:
{ mediante la fórmula de Herón: ✓ Si la variable lado_a es igual a la
a++; variable lado_c entonces escribir por
b=b-5; A2 = p( p a)( p b)( p c) pantalla que el triángulo es equilátero.
} ✓ Si no, escribir por pantalla que el
if (b-a!=7) 𝑎+𝑏+𝑐 triángulo es isósceles.
donde 𝑝=
b=5; 2
b. Si no:

✓ Si la variable lado_a es igual a la printf ("El triángulo es casos, realizando la comparación desde arriba
variable lado_c o la variable lado_b es isósceles\n"); hacia abajo.
igual a la variable lado_c entonces }
✓ else Si se encuentra un caso cuyo valor coincida con el
{ valor de la variable, se empieza a ejecutar las
if (lado_a==lado_c ||
✓ escribir por pantalla que el triángulo es sentencias hasta encontrar una sentencia break.
lado_b==lado_c)
isósceles. printf ("El triángulo es En caso de que no se encuentre ningún valor que
✓ Si no, escribir por pantalla que el isósceles\n"); coincida, se ejecuta el default (si existe).
triángulo es escaleno. else
3. Calcular el semiperímetro según la expresión printf ("El triángulo es
dada y almacenarlo en la variable p. escaleno\n"); Ejemplos
4. Calcular el área al cuadrado del triángulo según }
la fórmula de Herón, almacenando el resultado } int valor;
en la variable area_cuadrado. /* Calcular el area */ switch(valor)
5. Calcular la raíz cuadrada de la variable p=(lado_a+lado_b+lado_c)/2.0; {
area_cuadrado y almacenar el resultado en la area_cuadrado=p*(p-lado_a)*(p- case 0: cont++;
variable area. lado_b)*(p-lado_c); break;
6. Escribir en pantalla el contenido de la variable area=sqrt(area_cuadrado); case 5: cont--;
printf ("El area del triángulo es break;
area con dos decimales (%.2f).
%.2f\n", area); default: cont=-10;
} /* Se ejecuta si valor no es 0 o 5
Llegados a este punto, se debe decidir cuál va a
*/
ser el tipo de dato de cada una de las variables }
que intervienen en este programa. Como el char d;
enunciado no especifica de qué tipo serán las int cont=0;
medidas de los lados, se supone que pueden ser switch(d)
valores reales, por lo que las variables lado_a, {
lado_b, lado_c serán declaradas de tipo float (se case ‘\r’: cont++; /* Si d es un
considera que la precisión de un float será retorno de carro, se */
suficiente). Estructura selectiva múltiple (switch- /* ejecuta este cont++ y el
siguiente*/
Ya que el resto de variables se calculan a partir de
case) /* al no aparecer un break */
éstas, las variables p, area_cuadrado y area que case ‘\x1B’: cont++;
La estructura selectiva múltiple permite elegir break;
almacenan el semiperímetro, el área al cuadrado
uno de varios caminos posibles. Esta secuencia se default: cont=-1;
y el área final, respectivamente, también serán de
utiliza cuando existen múltiples posibilidades }
tipo float.
para la evaluación de una expresión
(generalmente una variable), pues de acuerdo
con el valor que tome la expresión será el Las sentencias switch pueden aparecer unas
Implementación dentro de otras (anidadas), igual que sucedía con
conjunto de instrucciones que se ejecute.
las sentencias if.
#include<stdio.h>
#include<math.h> La forma general de la sentencia switch es:
#include <locale.h> char d,e;
/* Programa que determina, dados switch(d)
los tres lados, si un triángulo switch(variable) {
es equilátero, isósceles o { case ‘a’:
escaleno y calcula el area */ case const1: sentencia; case ‘A’: switch(e)
main() break; {
{ case const2: sentencia; case ‘1’: d=‘z’;
setlocale(LC_ALL, "spanish"); break; e=‘+’;
float lado_a,lado_b,lado_c,p, ... break;
area,area_cuadrado; default: sentencia; case ‘2’: d=‘Z’;
{ break; e=‘-’;
/* Lectura de datos */ } break;
printf("Introduce los lados de }
un triángulo: "); break;
scanf("%f%f%f",&lado_a,&lado_b, Donde variable debe ser de tipo char o int, y case ‘b’:
&lado_c); donde const1, const2, ..., indican casos de C del case ‘B’: switch(e)
/*Comprobar como es el tipo de datos de la variable. Dichos casos no {
triángulo*/ case ‘0’: d=‘2’;
pueden repetirse dentro del switch. El default es
if (lado_a==lado_b) break;
opcional y puede no aparecer.
{ default: e=‘+’;
if (lado_a==lado_c) break;
printf("El triángulo es La sentencia switch se ejecuta comparando el
}
equilátero \n"); valor de la variable con el valor de cada uno de los
break;
else }

case 4: res=peso*10000;
printf("\nEquivale a %d
Ejercicio práctico con Decigramos",res);
estructura selectiva break;
switch printf("\nEquivale a %d
Centigramos",res);
break;
Diseñar un programa que convierta de Kg a otra
unidad de medida de masa, mostrar en pantalla Miligramos",res);
un menú con las opciones posibles. break;
default: printf("Opción no
Análisis 2. Se diseña el menú con la opción de tipo entero, válida! … elije otra Opción");
el cual especifica las diferentes opciones de break;
La unidad principal es el gramo (g), las unidades conversión. }
más pequeñas que el gramo son: decigramo (dg), }
centigramo (cg) y miligramo (mg) y a estas 3. Dependiendo de la opción seleccionado, se
unidades se les llama submúltiplos. ejecuta la operación de la conversión
correspondiente.
1 g = 10 dg | 1 g = 100 cg | 1 g = 1000 mg 4. Se despliega el resultado al final del programa,
fuera de la estructura switch.
Las unidades más grandes que el gramo(g), se
llaman múltiplos y son: decagramo (dag),
hectogramo (hg) y kilogramo (kg): Implementación
#include <stdio.h>
1 dag = 10 g | 1 hg = 100 g | 1 kg = 1000 g #include <stdlib.h>
#include<locale.h>
main()
Por lo tanto si queremos convertir desde una {
unidad que está "separada" de otra, debemos setlocale(LC_ALL, "spanish");
"acumular las operaciones" según sean múltiplos int peso,res,opcion;
o submúltiplos de los gramos ingresados. printf("\n\n\n\tCalculadora de
Conversión");
printf("\n\nIntroduzca peso en
Por ejemplo, para pasar de gramo a centigramo,
kilogramos:");
debemos multiplicar X10 y X10, es decir,
scanf("%d",&peso);
multiplicaremos X100 (1g=100cg, 5g=500cg), printf("1 - Hectogramos\n");
para pasar de gramo a kilógramo, debemos printf("2 - Decagramos\n");
dividir ÷10, ÷10 y ÷10, es decir dividiremos ÷1000 printf("3 - Gramos\n");
(1000g=1kg, 3000g=3kg) printf("4 - Decigramos\n");
printf("5 - Centigramos\n");
Una vez comprendido las diferentes unidades de printf("6 - Miligramos\n");
medida, definimos los datos de entrada y de printf("\nSeleccione Unidad a
salida y cuál va a ser el proceso a realizar, se convertir:");
diseña un algoritmo del funcionamiento del scanf("%d",&opcion);
programa: switch (opcion)
{
1. Se declaran las variables necesarias como peso printf("\nEquivale a %d
y res que serán datos de tipo entero, se guardara Hectogramos",res);
break;
el peso en kilogramos y el resultado de la
operación de la conversión.
Decagramos",res);
break;
Gramos",res);
break;

En primer lugar, conviene destacar el hecho de la Determinar la cantidad de productos defectuosos
3.3 Estructuras gran flexibilidad de la estructura for de C, ya que

este puede no contener inicialización, condición
y perfectos de una línea de producción.
iterativas: for, o incremento, o incluso pueden no existir dos e

incluso las tres expresiones de la estructura.
Análisis
Una línea de producción bien supervisada
while, do-while
constituye la base de cualquier proceso de
La estructura for se ejecuta siempre que la producción, por ello es importante identificar
condición sea verdadera, es por ello por lo que rápidamente la causa raíz de los productos
puede llegar a no ejecutarse. defectuosos a través de un programa de control
Las estructuras de repetición son las llamadas de calidad.
estructuras cíclicas, iterativas o de bucles. Algunos ejemplos de la estructura for:
Permiten ejecutar un conjunto de instrucciones Para esto es necesario revisar detenidamente si el
de manera repetida (o cíclica) mientras que la producto tiene algún defecto o si este es perfecto
expresión lógica a evaluar se cumpla (sea int i,suma=0; y contabilizarlos, para lo cual se va a diseñar un
verdadera). for(i=1;i<=100;i++) algoritmo del funcionamiento del programa:
suma=suma+i;
En lenguaje C existen tres estructuras de 1. Se declaran las variables necesarias como
repetición: while, do-while y for. Las estructuras producción (pro), variable de control de la
while y do-while son estructuras repetitivas de estructura for (cont), variable p, que almacenará
int i,j;
propósito general. La estructura de repetición for for(i=0,j=100;j>i;i++,j--) la respuesta de si el producto es defectuoso o es
se utiliza, principalmente, para recorrer arreglos. { perfecto y el contador del productos defectuosos
printf(“%d\n”,j-i); (de) y el contador de productos perfectos (per). Y
Elementos indispensables en las estructuras de printf(“%d\n”,i-j); todas estas variables serán del tipo de dato
repetición: } entero “int”.
✓ Valor inicial 2. Preguntar al usuario el número de productos a

evaluar y guardar el dato en la variable pro
✓ Condición para dejar de repetir float a=3e10;
✓ Incremento o decremento del for(;a>2;a=sqrt(a)) 3. Dentro de la estructura for registrar para cada
valor inicial /* sqrt() calcula la raíz producto si este tiene algún defecto o si el
cuadrada de la biblioteca producto es perfecto.
<math.h>*/
printf(“%f\n”,a);
4. Y fuera de la estructura for desplegar el total de
productos defectuosos y el total de productos
perfectos.
char d;
for(;getc(stdin)!=’x’;); Implementación
/* Estructura que espera hasta
que se pulsa la tecla x */ /*calidad de los productos*/
#include<stdio.h>
#include<locale.h>
main()
char d; {
for(;;) setlocale(LC_ALL, "spanish");
{ int pro,cont,p,de=0,per=0;
d=getc(stdin); printf("\n\t\tChecar la calidad
printf(“-%c”,d); de los productos \n");
if (d==‘x’) printf("\nCuantos productos se
break; elaboraron?\n");
} scanf("%d",&pro);
for(cont=1; cont<=pro; cont++)
Como se observa en este último ejemplo, la {
estructura for no posee ninguna expresión, para printf("\nEl producto %d, tiene
salir de él se usa la sentencia break. algún defecto? si=1 o=2\n",cont);
scanf("%d",&p);
if(p==1)
Estructura iterativa for {
printf("desecha el
producto\n");
La sintaxis de la estructura for es: de=de+1; /*contador*/
Ejercicio práctico con
estructura iterativa }
for (inicialización; condición; incremento) else
sentencia; for {

printf("El producto esta /* Bucle que espera hasta que se printf("desecha el
perfecto; empácalo \n"); pulse la tecla X */ producto\n");
per=per+1; /*contador*/ de=de+1; /*contador*/
} }
} /*fin del for*/ /* Recordar que en C lo que no es else
printf("\nSon %d productos cero es verdad */ {
defectuosos ",de); #include<stdio.h> printf("El producto esta
printf("\nSon %d productos main() perfecto; empácalo \n");
perfectos ",per); { per=per+1; /*contador*/
} char d; }
while (1) cont++;
{ } /*fin del while*/
d=getc(stdin); printf("\nSon %d productos
printf("%c\n",d); defectuosos ",de);
if (d=='0') printf("\nSon %d productos
{ perfectos ",per);
printf("... fin del ciclo }
While");
break;
} Y al ejecutarlo nos dará el mismo resultado que
} el ejercicio con for:
}
Ejercicio práctico con

estructura iterativa
while
Determinar la cantidad de productos defectuosos

y perfectos de una línea de producción. Ahora
utilizando una estructura de repetición while.
Análisis
Estructura iterativa while El análisis es el mismo del ejercicio práctico de la
estructura de repetición for, lo único que cambia
es la implementación, es decir, al utilizar la
La sintaxis de la estructura while es: estructura while para resolver este problema lo
único que va a cambiar es la ubicación de los
valor inicial
elementos de la estructura dentro del programa
while (condición)
{ como tal. Estructura iterativa do-while
sentencia;
… Implementación
incremento o decremento Al contrario que las estructuras for y while que
} /*calidad de los productos*/
comprueban la condición al inicio de la
#include<stdio.h>
estructura, esta comprueba la condición en la
Donde la sentencia puede no existir (sentencia #include<locale.h> parte final de la estructura, lo cual provoca que la
vacía), pero siempre debe existir la condición. La main() estructura do-while se ejecute como mínimo una
{
estructura while se ejecuta mientras la condición vez.
setlocale(LC_ALL, "spanish");
sea verdad. int pro,cont,p,de=0,per=0;
printf("\n\t\tChecar la calidad
Algunos ejemplos de estructuras while: de los productos \n"); La sintaxis de la estructura do-while es:
printf("\nCuantos productos se
elaboraron?\n");
int i=1,suma=0; scanf("%d",&pro); valor inicial
while (i<=100) cont=1; do
{ while(cont<=pro) {
suma=suma+i; { sentencia;
i++; printf("\nEl producto %d, tiene …
} algún defecto? si=1 o=2\n",cont); incremento o decremento
scanf("%d",&p); }
if(p==1) while (condición);
while (getc(stdin)!=‘X’); {

3.4 Diseño e
Implementación
La estructura do-while se ejecuta mientras la
condición sea verdadera. Algunos ejemplos de la #include<stdio.h>
estructura: #include<locale.h>
main()
implementación de
int num;
do
{
setlocale(LC_ALL, "spanish"); funciones
scanf(“%d”,&num); int cant1,cant2,cant3,contpieza;
while (num>100); float peso,suma=0;
cant1=0;
cant2=0; Aunque analizaremos el tema de funciones en
cant3=0; detalle en el tema 5, una breve visión general es
int i,j; útil ahora.
do printf("\n\n\n\tPeso de las
{ piezas de Lineas de producción
scanf(“%d”,&i); ");
contpieza=1; Las funciones en un programa son entidades que
scanf(“%d”,&j); dado un conjunto de datos (los parámetros), se
} do
les encarga realizar una tarea muy concreta y se
while (i<j); {
printf("\n\nIngrese el peso de espera hasta obtener el resultado.
la pieza %d (0 para finalizar
):",contpieza); Lo idóneo es dividir tareas complejas en
scanf("%f",&peso); porciones más simples que se implementan
Ejercicio práctico con suma=suma+peso;
como funciones. La división y agrupación de
estructura iterativa if (peso>=9.8 && peso<=10.2)
tareas en funciones es uno de los aspectos más
cant1++;
do-while if (peso>10.2) importantes en el diseño de un programa.
cant2++;
if (peso<9.8) En lenguaje C a cada módulo o subprograma se le
cant3++;
conoce como función, de manera general, los
Realizar un programa que permita ingresar el contpieza++;
programas se elaboran combinando funciones
peso (en kilogramos) de piezas procesadas en }
que el programador escribe (funciones de
una línea de producción. El proceso termina while(peso!=0); usuario) y funciones “predefinidas” disponibles
cuando ingresamos el valor 0 (cero). Se debe printf("\n %d piezas con un peso
en la biblioteca estándar de C.
informar: entre 9.8 Kg. y 10.2 kg.",cant1);
printf("\n %d piezas con un peso
a) ¿Cuántas piezas tienen un peso entre 9.8 Kg. y de más de 10.2 Kg.",cant2); Las funciones de usuario pueden ser escritas para
10.2 Kg.?, ¿Cuántas con más de 10.2 Kg.? y printf("\n %d piezas con menos realizar tareas repetitivas y para reducir el
¿Cuántas con menos de 9.8 Kg.? de 9.8 Kg.",cant3-1);
tamaño de un programa. Segmentar el código en
b) La cantidad total de piezas procesadas. printf("\n La cantidad total de
funciones permite crear piezas de código que
piezas procesadas son %d"
c) El total de la suma de lo que pesan todas las hacen una determinada tarea y volver al área del
,contpieza-2);
piezas. printf(“\nLa suma total del peso código desde la que han sido llamadas. Corona,
de las %d piezas es : %.2f kgs”, M. y Ancona M. (2011).
Análisis contpieza-2,suma);
}
1. Los tres contadores cont1, cont2, cont3 y Las funciones predefinidas de lenguaje C permite
contpieza se inicializan en 0 antes de entrar a la el uso de “bibliotecas”, con funciones
estructura repetitiva do-while. predefinidas que se pueden utilizar en cualquier
programa.
2. A través de estos contadores podremos saber Ejemplo de programas con funciones

el número de piezas que hay de acuerdo con el predefinidas de lenguaje C:
rango de peso solicitado y el total de piezas que
se pesaron. Leer el ángulo en grados y mediante un menú
de 3 opciones calcular: s) seno, c) coseno y t)
3. La estructura se repite hasta que se ingresa el
tangente.
valor CERO en la variable peso. Este valor no se
lo considera un peso menor a 9.8 Kg., sino que
indica que ha finalizado el ingreso de valores por Análisis
teclado. 1. Se declara la variable op como char debido a
que las opciones son de tipo carácter (s, c, t)
4. Se despliegan la información solicitada del
2. Se captura la opción (op) y el ángulo en grados
número de piezas de un determinado peso y el
3. Se elige una opción, se realiza la conversión de
total de piezas que se pesaron.
grados a radianes utilizando las funciones ya
predefinidas de sin, cos y tan de la biblioteca
math.h

4. Se calcula la función elegida y por último se
imprime el resultado obtenido
Implementación
#include <stdio.h>
#include <locale.h>
#include <math.h> Ejercicios propuestos
#define PI 3.1416
main()
{
setlocale(LC_ALL, "spanish"); Programas con Estructuras Secuenciales
int recursivo; 1. Al recibir como datos la base y la altura de un
recursivo=1; triángulo, calcule su superficie.
do
{ 2. Al recibir como datos la longitud y el peso de un
char op; objeto expresados en pies y libras, imprima los
float ang,resp; datos de este objeto, pero expresados en metros
printf("\n\n\n\tMenú funciones y kilos, respectivamente.
trigonométricas\n"); 3. Al recibir como datos el radio y la altura de un
printf(" s)seno\n c)coseno\n cilindro, calcule e imprima el área y su volumen.
t)tangente\n");
printf("dame la opción: "); 4. Al recibir como dato el radio de un círculo,
scanf("%s",&op); Leer el Password, si es correcto imprimir calcule e imprima tanto su área como la longitud
printf("dame el ángulo en “Correcto, puedes continuar” y si no imprimir de su circunferencia.
grados: "); “Password equivocado”. 5. Al recibir como dato un número de cuatro
scanf("%f",&ang); dígitos, genere una impresión como la que se
switch(op) muestra a continuación (el número 6352):
Análisis
{
case 'S':case's': 1. Declaramos una cadena llamada cad con un 6
resp=sin(ang*PI/180); máximo de 80 caracteres incluyendo el \0 3
printf("seno = %.2f",resp); 2. La función strcmp de la biblioteca string.h 5
break; compara la cadena capturada con el letrero
case 'C':case 'c': 2
“acceso1234”, si regresa cero las cadenas son
resp=cos(ang*PI/180); iguales e imprime “Correcto, puedes continuar”
printf("coseno = %.2f",resp);
3. Si la función strcmp regresa un valor diferente
break;
case 'T':case 't': de cero las cadenas son diferentes y por lo tanto Programas con Estructuras Selectivas
imprime “Password equivocado”.
resp=tan(ang*PI/180);
1. Un ángulo se considera agudo si es menor de
printf("tangente =%.2f",resp);
90 grados, obtuso si es mayor de 90 grados y
break; Implementación
default: recto si es igual a 90 grados. Utilizando esta
printf("función no existe"); información, escriba un programa que acepte un
break; #include <string.h> ángulo en grados y visualice el tipo de ángulo
} #include <stdio.h> correspondiente a los grados introducidos.
printf("\n\nIngresa opción <1> #include <conio.h> 2. Dados tres números deducir cuál es el central.
repetir programa o <2> salir main() 3. Ingresar tres números enteros diferentes entre
del programa "); { sí y determinar cuál es el número mayor y cuál es
scanf("%d",&recursivo); char cad[80]; el menor.
} printf("\n\tDame tu Password: 4. Leer un número entero e imprimir si es Múltiplo
while(recursivo==1); ");
de 7 o no múltiplo de 7 (cuando sea impar), por
} scanf("%s",&cad);
ejemplo, para el número 35, imprimirá:
if((strcmp(cad,"acceso1234"))==0)
printf("\nCorrecto, puedes Es un número positivo, es impar y es múltiplo de 7.
continuar!!!\n\n\n");
else 5. Dados dos de los ángulos de un triángulo,
printf("\nPassword calcular el tercer ángulo y determinar si el
equivocado!!!\n\n"); triángulo es rectángulo (un ángulo igual a 90
} grados), acutángulo (sus tres ángulos menores a
90 grados) u obtusángulo (un ángulo mayor a 90
grados).
Programas con Estructuras switch

1. Leer un número entero obtenido al lanzar un
dado de seis caras e imprimir el número en letras
de la cara opuesta.
En las caras opuestas de un dado de seis caras
están los números: 1-6, 2-5 y 3-4. Si el número
del dado capturado es menor que 1 o mayor que
6, se mostrará: “Un DADO no tiene ese número”.
2. El importe anual del seguro de un coche

depende del modelo del coche, del color, de la
edad del conductor y tiempo que tiene
conduciendo. Son tres modelos de coche (A, B y
C) y los precios del seguro según el color:
Programas con Estructuras de Repetición
1. Leer N números y determinar cuál es el mayor

y el menor de todos. (while)
2. Imprimir los números del uno al cien excepto

los múltiplos de 7 , es decir: (for)
1 2 4 5 6 8 9 10 11 12 13 15 16 17 18 19 20 22 ….
3. Calcular el promedio de los números múltiplos

de 9 que hay de 45 a 194 (do-while)

calcule el resultado de la siguiente serie: (while)
1 1 1 1
𝑆𝑒𝑟𝑖𝑒 = 1 + + + + ⋯ . .
2 3 4 𝑛
5. Resolver la siguiente serie a través de un

programa en C. (for)
1 2 3 4 𝑛
𝑆𝑒𝑟𝑖𝑒 = − + − +⋯+ 𝑛
21 22 23 24 2

obtenga el resultado de la siguiente serie:
(do-while)
𝑆𝑒𝑟𝑖𝑒 = 11 − 22 + 33 − 44 + ⋯ ± 𝑛𝑛
Solución de un caso práctico de aplicación de

Estructuras de control ANEXO 6

Los más utilizados son los unidimensionales y los Sintaxis

Un Arreglo es una estructura de datos que bidimensionales, a continuación, se describirá
almacena de manera temporal, bajo el mismo cada uno de ellos. tipo_dato identif_arreglo[tam_arreglo];
nombre (variable) a una colección de datos
limitados y del mismo tipo. Para acceder a un Al igual que cualquier variable, los arreglos
elemento específico de un arreglo se usa un ocupan espacio en memoria. El programador por ejemplo:
índice o subíndice. especifica el tipo de dato y el total de elementos
requerido por el arreglo de tal forma que la
Un arreglo se caracteriza por: computadora pueda reservar la cantidad float calif[8];
char nombre[10][40]:
apropiada de memoria.
int edad[10];
✓ Ser una lista de un número finito de n
elementos del mismo tipo.
En los arreglos unidimensionales se distinguen
✓ Almacenar los elementos del arreglo en
memoria contigua.
4.1 dos partes fundamentales: los componentes y el
índice.
✓ Tener un único nombre de variable que Unidimensionales: Los componentes hacen referencia a los
representa a todos los elementos y éstos se
diferencian por un índice o subíndice. conceptos básicos, elementos que se almacenan en cada una de las
celdas o casillas.
✓ Acceder de manera directa o aleatoria a los operaciones y El índice, por su parte, especifica la forma de
aplicaciones.
elementos individuales del arreglo, por el acceder a cada uno de estos elementos.
nombre del arreglo y el índice o subíndice.
Para hacer referencia a un componente de un
arreglo debemos utilizar tanto el nombre del
Un arreglo unidimensional es un conjunto arreglo como el índice del elemento.
Los arreglos se clasifican en: de n elementos del mismo tipo (enteros, reales,
caracteres, cadenas de caracteres, etc.), En la figura 6 se puede observar la representación
Unidimensionales (vectores o listas) almacenados en memoria continua en un vector gráfica de un arreglo unidimensional.
o lista. Corona, M. y Ancona M. (2011).
Bidimensionales (tablas o matrices)
Para acceder a cada elemento del arreglo se
Multidimensionales (más de dos dimensiones) requiere de un solo índice, el cual representa la
posición en la que se encuentra.

Modificación de un elemento del
arreglo unidimensional
Podemos modificar los elementos de un vector
en cualquier momento, sólo es necesario
especificar el nombre del arreglo unidimensional,
la posición y el nuevo valor.
Sintaxis
Figura 6 Representación gráfica de un arreglo
unidimensional
Este modo de asignación no es válido si lo tipo_dato ident_arr[pos]=valor;
hacemos después de declarar el arreglo. Si el
número de valores es menor al tamaño del
Se pueden asignar valores a los elementos del
arreglo a las posiciones faltantes les asigna cero. por ejemplo:
arreglo antes de utilizarlos tal como se asignan
valores a variables. Una manera es inicializando el
int b[3]=18;
arreglo y la otra leyendo cada elemento de este. Lectura e impresión de un arreglo
unidimensional:
en este ejemplo se le asigna el valor 18 al cuarto
elemento del arreglo que se encuentra en la
Es fácil procesar los elementos de un arreglo
posición 3.
mediante ciclos repetitivos porque facilitan la
lectura, impresión, consulta y modificación de
todos los elementos del arreglo, reduciendo el Arreglos de caracteres:
trabajo a unas cuantas líneas bien empleadas.
Cuando la computadora ejecuta un ciclo y la Los arreglos son necesarios para la
instrucción leer (scanf) el programa almacena los implementación de cadenas de caracteres. Una
valores en la variable arreglo. cadena de texto es un conjunto de caracteres.
En el lenguaje C no existe el tipo de dato cadena

#include <stdio.h> (string) como en otros lenguajes de
main ()
programación, por lo que se utiliza un arreglo de
{
caracteres, para poder almacenar una cadena:
int i,n;
printf (“Dame el tamaño del
arreglo: ”); Sintaxis
scanf (“%d”,&n);
Inicialización de arreglos int lista[n]; char cad[ ]=”Lenguaje”;
unidimensionales: for (i=0; i<n;i++)
{ por ejemplo:
printf(“Dame el elemento %d-“,i);
En el momento de declarar el arreglo, se scanf(“%d”,&lista[i]); char nombre[40][30]; *
especifican los valores. }
printf(“Elementos de la Una cadena de caracteres es un arreglo de
lista\n”); caracteres que contiene al final el carácter nulo
Sintaxis for (i=0; i<n;i++) (\0); por esta razón es necesario que al declarar
printf(“%d\n”,lista[i] ); los arreglos éstos sean de un carácter más que la
tipo_dato identif[tam_arreglo]5{valores};
}
cadena más grande.
El compilador inserta automáticamente un
por ejemplo:
carácter nulo al final de la cadena, de modo que
int lista[5]={10,17,8,4,9}; la secuencia real sería:
La asignación de los valores se realiza al declarar char cad[9]=”Lenguaje”;

el arreglo mediante el operador de asignación (=)
Una opción para almacenar una cadena de
y los valores contenidos dentro de las llaves { } a caracteres es el uso de la palabra reservada scanf
cada posición del arreglo; los valores dentro de (variable) pero, si queremos almacenar una
las llaves se deben separar por una coma ( , ) y no cadena con espacios en blanco no lo podemos
es necesario asignarle un valor a cada posición ya hacer con ella, sino que debemos utilizar la
que el compilador del lenguaje C se encargará de palabra reservada gets, que se encuentra dentro
hacerlo según el lugar donde se haya declarado el de la librería string.h; gets sólo se utiliza para leer
arreglo, comenzando por la posición cero. cadenas de caracteres y scanf para leer cualquier
tipo de variable, de preferencia de tipo numérico.

La biblioteca “string” tiene una gran cantidad de Ejemplo 3

funciones prácticas para trabajar con cadenas de
caracteres. Para utilizarlas debemos de incluir el Ingrese una cadena de caracteres y la muestre al
fichero que define los prototipos de dichas revés.
funciones:
#include <stdio.h>
#include <string.h> main()
{
Algunas de las funciones más importantes son: int indice,x;
char frase[50];
printf("Introduzca una frase:
• strlen(<cadena>):
");
Devuelve la longitud de la cadena sin tomar en scanf(“%s”,&frase);
cuenta el caracter de final de cadena. Ejemplo 2 for(x = 0;x < 50;x++)
• strcpy(<cadena_destino>, <cadena_origen>) : {
Copia el contenido de <cadena_origen> en Ingrese 10 números por teclado, los almacene en if (frase[x]=='\0')
<cadena_destino>. un vector y los ordene de forma ascendente. {
• strcat(<cadena_destino>, <cadena_origen>) : indice=x;
Concatena el contenido de <cadena_origen> al #include <stdio.h> break;
final de <cadena_destino>. main() }
• strcmp(<cadena1>, <cadena2>) : { }
Compara las dos cadenas y devuelve un 0 si las float aux, numeros[10]; printf("La frase al reves es:
int i,j,n=10; \n\n");
dos cadenas son iguales, un número negativo si
for (i=0;i<n;i++) for(x = indice-1;x >=0;x--)
<cadena1> es menor que (precede { {
alfabéticamente a) <cadena2> y un número printf("Escriba número %d : printf("%s”,frase[x]);
positivo (mayor que cero) si <cadena1> es mayor ",i+1); }
que <cadena2>. scanf("%f",&numeros[i]); printf(“\n\n”);
} }
for(i=0;i<n-1;i++)
Ejemplos de programas con arreglos {
unidimensionales: for(j=i+1;j<n;j++)
{
Ejemplo 1 if(numeros[i]<numeros[j])
{
Ingrese 10 números por teclado, los almacene en aux=numeros[i];
un vector y muestre la suma, resta, multiplicación numeros[i]=numeros[j];
y división de todos. numeros[j]=aux;
}
#include <stdio.h> }
main() }
{ for (i=n-1;i>=0;i--) Ejemplo 4
int x,tabla[10]; {
int sum=0,res=0,mul=1; printf("%f\n",numeros[i]); Ingrese una contraseña y la encripte sumando 3 al
for (x=0;x<10;x++) } código ASCII de cada carácter. Mostrar por
{ } pantalla.
printf("Introduzca número
%d",x+1); #include <stdio.h>
scanf("%d",&tabla[x]); main()
} {
sum=tabla[0]; int x;
res=tabla[0]; char frase[50];
mul=tabla[0]; printf("Introduzca una
for (x=1;x<10;x++) contraseña: ");
{ scanf("%s",&frase);
sum=sum+tabla[x]; for(x = 0; x < 50;x++)
res=res-tabla[x]; {
mul=mul*tabla[x]; if (frase[x]!='\0')
} {
printf("Suma: %d\n",sum); frase[x]=frase[x]+3;
printf("Resta: %d\n",res); }
printf("Multiplicación: }
%d\n",mul); printf("\n\nLa nueva contraseña
} encriptada es: ");
printf("%s",frase);
printf("\n\n");
}

4.2 Sintaxis
Multidimensionales: tipo_dato ident_arr[tam_fila][tam_col];
conceptos básicos, por ejemplo:
operaciones y
int b[3][5];
Ejemplo 5
float calif[40][7];
Ingrese un vector con 10 números y luego
busque un número concreto. aplicaciones. Inicialización de arreglos
#include <stdio.h> bidimensionales
main() Existen también arreglos con múltiples
{ dimensiones, a cuyos elementos se debe acceder
int i,x=0,vector[10],n=10,dato; utilizando múltiples índices. El número de En el momento de declarar el arreglo, se
int centro,inf=0,sup=n-1; dimensiones del arreglo depende tanto de las especifican los valores.
printf("-Ingresa 10 números-\n"); características del problema que se va a resolver,
for (i=0;i<10;i++) como de las facilidades del lenguaje de Sintaxis
{ programación que se utilice para implementar la
printf("Escriba número %d:",i+1); solución. Cairó, O. (2006) t_dato identif[fil][col]5{valores};
scanf("%d",&vector[i]);
}
Sin duda, los arreglos bidimensionales — por ejemplo:
printf("Escriba el número a
buscar:"); conocidos también como matrices— son los
scanf("%d",&dato); arreglos multidimensionales más utilizados int a[3][3]={1,2,3,4,5,6,7,8,9};
while(inf<=sup) (figura 7).
{
a012
centro=(sup+inf)/2; 0123
if (vector[centro]==dato) 1456
{
printf("Existe\n"); Arreglos Bidimensionales 2789
x=1;
break;
}
Un arreglo bidimensional es un conjunto de n
else
elementos del mismo tipo almacenados en
Lectura e impresión de unos
if(dato < vector [centro] )
{ memoria contigua en una matriz o tabla. A arreglos bidimensionales
sup=centro-1; diferencia de los arreglos unidimensionales que
} sólo requieren de un índice, los arreglos Para la lectura de datos, el programa requiere de
else bidimensionales para acceder a cada elemento
dos ciclos anidados (para ubicar la fila y la
{ del arreglo requieren de dos índices declarados columna), y la instrucción leer (scanf) o leercad
inf=centro+1; en dos pares de corchetes, donde el primer
} (gets), almacenando con ello los valores en cada
corchete se refiere al tamaño de filas y el segundo celda de la tabla o matriz.
} al tamaño de columnas.
if (x==0)
{ El siguiente segmento de programa muestra
printf("No existe\n"); cómo se pueden almacenar datos en una matriz
} mat de 3 filas y 4 columnas, se utiliza la
} instrucción leer (scanf) para guardar o leer los
datos:
for(i=0;i<3;i++) // Recorre cada fila (i)

for(j=0;j<4;j++)// Recorre cada columna (j)
scanf(“%d”,&mat[i][j]); //Almacena
en la fila i y columna j correspondiente
Figura 7 Representación gráfica de un arreglo
bidimensional

Donde valor es un dato o el resultado de una Ejemplo 7
llamada a función o de alguna operación lógica o
aritmética, etc. En este ejemplo se le asigna Encuentre el elemento mayor y el menor en una
directamente el valor 18 a la matriz b en la cuarta matriz de tamaño (10 x10).
fila y sexta columna.
#include<stdio.h>
Muchas manipulaciones con arreglos utilizan la main()
{
estructura de control repetitiva (for).
int a[10][10],i,j,n,m, may,min;
Ejemplo 6 printf("Total de filas:");
scanf ("%d",&m);
Almacenar en una matriz de n x m (máximo printf("Total de columnas:");
scanf("%d",&n);
10x10) números reales. Imprimir los elementos
for(i=0;i< m;i++)
de la diagonal principal de la matriz e imprimir la
for(j=0;j<n;j++)
suma dichos elementos. {
printf("a(%d,%d)=",i,j);
#include <stdio.h> scanf("%d",&a[i][j]);
main() }
{ may=a[0][0];
float a[10][10], acum=0; min=a[0][0];
int i,j,k,n,m; for(i=0;i<m;i++)
printf("Número de filas: "); for(j=0;j<n;j++)
scanf("%d",&n); {
printf("Número de columnas: "); if (a[i][j] > may)
scanf("%d",&m); may=a[i][j];
for (i=0;i<n;i++) else
{ if(a[i][j]<min)
… en este caso, primero inicializa el ciclo i y hasta min=a[i][j];
que termina con todas las columnas (j) de la printf("Lectura de la fila %d de la matriz a
}
primera fila (0) y continúa con la segunda fila (1), :\n",i+1);
printf("Número mayor %d",may);
iniciando otra vez con la columna (j=0). for (j=0; j<m; j++) printf("\nNúmero menor
{ %d",min);
printf("a(%d,%d)=",i+1,j+1); }
El siguiente segmento de programa muestra scanf("%f",&a[i][j]);
cómo se pueden imprimir los datos almacenados }
en una matriz mat de 3 filas y 4 columnas. Se }
utiliza la instrucción imprimir (printf) para escribir for (i=0;i<n;i++)
o mostrar el resultado: {
acum=acum+a[i][i];
for(i=0;i<3;i++) printf("\nEl elemento que conforman la diagonal
for(j=0;j<4;j++) a sumar son %1.f ",a[i][i]);
printf(“%d”, mat[i][j]); }
// Imprime el valor almacenado en la fila printf(" \nAcumulación de la diagonal principal
i y columna j correspondiente es: %6.2f",acum);
}
Modificación de un elemento de
una matriz
Los elementos de una matriz se pueden modificar

Ejemplo 8
en cualquier momento, sólo es necesario
especificar el nombre del arreglo bidimensional, Genere una matriz 4x4 con las primeras 16 letras
la posición tanto de la fila como de la columna y del abecedario en minúsculas.
el nuevo valor.
#include<stdio.h>
Sintaxis main()
{
tipo_dato ident_arr[fil][col]=valor; char matletra[4][4],let='a';
int ren,col;
for(ren=1;ren<=4;ren++)
{
por ejemplo: for(col=1;col<=4;col++)
{
int b[3][5]518; matletra[ren-1][col-1]=let;
let++;

}
}
// imprime matriz
for(ren=1;ren<=4;ren++)
#include<stdio.h>
main() 4.3 Aplicaciones en
programas.
{ {
printf("\n"); float a[3][2],mayfil,maxval=0;
for(col=1;col<=4;col++) int f,c,posf,posc;
printf("%c ",matletra[ren- //Lectura de los datos de la
1][col-1]); matriz La Ingeniería Mecatrónica combina mecánica,
} printf("\n\n**Introduzca los electrónica, informática y otras áreas. Es así que
} datos de la matriz**\n");
las aplicaciones en programas para esta carrera
for(f=0;f<3;f++)
{ las vemos en muchos campos de nuestra vida
for(c=0;c<2;c++) diaria, como, por ejemplo, la tecnología en casa,
{ mecánica automotriz, , procesos de la robótica,
printf("Elemento[%d][%d]: nuevas tecnologías en las fábricas especializadas,
",f,c); industria manufacturera, tecnología médica,
scanf("%f",&a[f][c]); herramientas tecnológicas, máquinas utilizadas
} en la construcción civil, fábricas e industrias, la
} inteligencia artificial, automatización industrial y
//Despliega matriz la administración eficiente de los recursos son
for(f=0;f<3;f++) detalles que aceleran cualquier proceso,
Ejemplo 9 { reduciendo el esfuerzo en la mano de obra
printf("\n"); humana y dándonos productos de calidad, etc.
Que muestre los primeros 100 números de for(c=0;c<2;c++)
izquierda a derecha usando un arreglo de dos printf("\t%.1f",a[f][c]);
dimensiones, la última fila mostrará la suma de } A continuación, veremos algunos ejemplos de
sus respectivas columnas. printf("\n\n"); programas con diferentes campos en su
for(f=0;f<3;f++) aplicación.
#include <stdio.h> {
main() mayfil=0;
{ for(c=0;c<2;c++) 1. Almacene en un vector las temperaturas de un
int x,y,sum, numeros[11][10]; { día (0-23 horas). Calcule su media e imprimir la
for (y=0;y<10;y++) //Encuentra el mayor elemento de temperatura más alta y la más baja; asimismo
{ cada fila imprimir la hora respectiva. Por ejemplo, la
sum=0; if(a[f][c] > mayfil) temperatura media fue de 21.5 grados Celsius, la
for (x=0;x<10;x++) mayfil = a[f][c];
{ más alta de 29 grados Celsius a las 14 horas y la
if(a[f][c] > maxval) más baja de 9.4 grados Celsius a las 3 horas.
numeros[x][y]=(x*10)+1+y; {
sum=sum+numeros[x][y]; maxval=a[f][c];
} posf=f;
numeros[10][y]=sum; posc=c; #include<stdio.h>
} } #include<locale.h>
for (x=0;x<11;x++) } main()
{ printf("El elemento mayor de {
for (y=0;y<10;y++) la fila [%d] es %.2f\n",f setlocale(LC_ALL,"");
{ ,mayfil); int hora,tem[24];
printf("\t%d ",numeros[x][y]); } int mayor=0,menor=999;
} printf("\nEl elemento mayor del Int mayorhora,menorhora;
printf("\n"); arreglo es: %.2f y se encuentra float sumatem=0,media;
} en la posición [%d][%d]\n\n" printf("\n\t\t*** REGISTRO DE
} ,maxval,posf,posc); TEMPERATURAS *** \n");
} //Captura temperaturas por hora
printf("\nIngresa la
temperatura en grados Celsius en
la hora del día: \n",hora);
for(hora=1;hora<=24;hora++)
{
printf(" %d -> ",hora);
scanf("%d",&tem[hora-1]);
sumatem=sumatem+tem[hora-1];
if(tem[hora-1]>mayor)
Ejemplo 10 {
mayor=tem[hora-1];
Ingresar 6 números en forma de tabla 3x2 , mayorhora=hora;
desplegar los valores máximo y mínimo de cada }
fila y de toda la tabla. if(tem[hora-1]<menor)
{

menor=tem[hora-1]; #include<stdio.h>
menorhora=hora; #include<locale.h>
}
} #include<string.h>
media=sumatem/24; main()
//Despliega vector de {
temperaturas por hora
setlocale(LC_ALL,"");
printf("\n\t Hora /
Temperatura\n"); char nombreprod[6][30];
for(hora=1;hora<=24;hora++) float cant[6][12],prom[6];
printf("\n \t %d %d", int produc,mes;
hora,tem[hora-1]);
printf("\n\nLa temperatura printf("\n\n\n\t\t Fabrica BARROD
media del día fue de %.2f S.A. DE C.V.");
grados celsius. ",media); printf("\n \t\t Captura inicial
printf("\n La mas alta de %d de Producción");
grados celsius de las %d horas for(produc=1;produc<=6;produc++)
del día",mayor,mayorhora);
{
printf("\n La más baja de %d
grados Celsius a las %d horas printf("\n\n\tProducto %d \n",
del día",menor,menorhora); produc);
} printf("\nIngresa nombre del
2. BARROD, S.A. DE C.V, es una empresa producto : ");
mexicana dedicada a la venta, distribución y scanf("%s",&nombreprod[produc-
fabricación de todo tipo de tornillos. Tiene más 1]);
de 35 años de experiencia en el rubro. Cuenta con for(mes=1;mes<=12;mes=mes++)
una planta especializada en la fabricación de {
tornillos de acuerdo con la especificación y
medidas de sus clientes. Ofrece: tornillos, printf("Ingresa la producción
tuercas, arandelas, birlos, herrajes y anclas. del mes %d : ",mes);
También ofrece servicio de fabricación especial scanf("%f",&cant[produc-1]
para atender toda necesidad en sujeción. Esta [mes-1]);
empresa esta solicitando un programa que lleve
}
los registros de los promedios mensuales de
producción de los 6 productos que ofrece }
(tornillos, tuercas, arandelas, birlos, herrajes y //Despliega la matriz de
anclas), y a través de un menú (switch) poder producción mensual
hacer las siguientes consultas para una adecuada printf("\n = Matriz de
toma de decisiones:
producción mensual =\n");
a. El promedio anual de producción de cada for(produc=1;produc<=6;produc++)
producto. {
b. El mes y la mayor y menor cantidad de printf("\n\tProducto : %s \n",
producción y a que producto se refiere. nombreprod[produc-1]);
c. Determinar cuál de los productos con mayor
for(mes=1;mes<=12;mes++)
demanda (tornillos, birlos y herrajes) tienen el
mayor promedio de producción anual. El printf("\t%.1f ",cant[produc-
programa deberá ser recursivo . 1][mes-1]);
}
Considera los siguientes vectores y matrices para recu=1;
que el programa sea eficiente:
do
. Vector para el nombre del producto {
. Vector para almacenar el promedio anual de setlocale(LC_ALL,"");
producción de cada uno de los diferentes char op,mayorproduc[30];
productos. char menorproduc[30];
. Matriz con el registro de la producción mensual
float suma=0;
de cada uno de los productos.
float mayor=0,menor=999;
int mayormes,menormes;
printf("\n\n\n\t\t Fabrica
BARROD S.A. DE C.V.");
printf("\n \t\t Control de

Producción"); }
printf("\n\n a. Promedio anual printf("\nEl producto %s en el
de producción de cada mes %d tuvo la mayor producción
de %.0f ",mayorproduc,mayormes,
producto");
mayor);
printf("\n b. Mayor y menor
printf("\nEl producto %s en el
producción mensual"); mes %d tuvo la menor producción
printf("\n c. Mayor promedio de de %.0f ",menorproduc,menormes,
producción, producto de mayor menor);
demanda"); break;
printf("\n\n Ingresa la opción case 'c':
deseada : "); mayor=0;
scanf("%s",&op); for(produc=1;produc<=6;produc++)
switch(op) {
{ if(prom[produc-1]>mayor)
case 'a': {
for(produc=1;produc<=6;produc++) mayor=prom[produc-1];
{ strcpy(mayorproduc,
printf("\n\tProducto : %s \n", nombreprod[produc-1]);
nombreprod[produc-1]); }
suma=0; }
for(mes=1;mes<=12;mes++) printf("\nEl producto %s tuvo el
suma=suma+cant[produc-1] mayor promedio de producción con
%.2f",mayorproduc,mayor);
[mes-1];
break;
prom[produc-1]=suma/12;
default:
printf("\nEl promedio anual de
printf("\n\n\nOpción NO valida");
producción es %.2f ",
break;
prom[produc-1]);
}
}
printf("\n\n\tIngresa < 1 >
break;
continuar en el programa o < 0 >
case 'b': para salir -> ");
mayor=0; scanf("%d",&recu);
menor=999; }
for(produc=1;produc<=6;produc++) while(recu==1);
{ }
{
if(cant[produc-1][mes-1]
>mayor)
{
mayor=cant[produc-1][mes-
1];
mayormes=mes;
strcpy(mayorproduc,
nombreprod[produc-1]);
}
if(cant[produc-1][mes-1]<menor)
{
menor=cant[produc-1][mes-1];
menormes=mes;
strcpy(menorproduc,
nombreprod[produc-1]);
}
}

El ejercicio propuesto para este tema es

desarrollar un proyecto integral para resolver un
problema real relacionado al perfil de un Ing.
mecatrónico que incluya arreglos.
Se considera un proyecto integral porque incluye

cada uno de los temas vistos hasta este momento
(tema 3) y además de los temas 5, 6 y 7 que están
por verse.
Solución de un problema real que incluye arreglos

– Proyecto Integral - ANEXO 7
Acceso al Video Tema 4 Diseño de un programa

con arreglos. ANEXO 8
Video Ejemplo de un programa con Arreglos en
lenguaje C - Temperaturas de regiones.
ANEXO 9

Conforme seguimos desarrollando programas

nos vamos dando cuenta de que el número de
líneas de éstos va aumentando
5.1 Diferencia Para un procedimiento el Tipo_Dato_Retorno es
siempre void, o lo que es lo mismo, nada. En el
considerablemente, y además se van repitiendo
varias veces determinadas líneas de código.
entre funciones y caso de las funciones se puede poner cualquier
tipo de dato, int, float, char, etc.
La mejor forma de elaborar y dar mantenimiento

procedimientos Por ejemplo: Calcule el área de un triángulo,
mediante un procedimiento y una función:
a un programa complejo es construirlo a partir de
bloques menores o módulos, pues de esta
La diferencia más que nada se da en contexto del
manera es más fácil analizar, programar y darle
lenguaje que estas utilizando. Procedimiento
mantenimiento a cada uno de ellos, que si
estuviera todo el código en el programa principal. Una función hace ciertos cálculos y devuelve un #include <stdio.h>
valor, y un procedimiento es una secuencia de
Dichos módulos se escriben solamente una vez, instrucciones o comandos y no devuelve ningún void areatriangulo (void)
pero pueden ser llamados en diferentes puntos valor. {
del programa principal o de cualquier otro float base, altura;
módulo. Corona, M. y Ancona M. (2011) En lenguajes más actuales, esta distinción ha printf("Introduce base: ");
desaparecido básicamente y los términos se han scanf("%f",&base);
Las ventajas de la programación modular son las tornado básicamente en sinónimos. printf("Introduce altura: ");
siguientes: scanf("%f",&altura);
printf("El área es: %2.2f\n",
Sintaxis (base*altura)/2);
1. Facilita el diseño descendente.
}
2. Se simplifica un algoritmo complejo.
3.Cada módulo se puede elaborar de manera Ambos poseen la misma estructura:
main()
independiente, lo que permite trabajar {
simultáneamente a varios programadores y con areatriangulo();
ello disminuir el tiempo de elaboración del Tipo_Dato_Retorno Nombre (Parámetros) }
algoritmo. {
4. La depuración se lleva a cabo en cada módulo. sentencias;
5. El mantenimiento es más sencillo. retorno; (sólo en el caso de las funciones)
6.Creación de bibliotecas con módulos }
específicos (se pueden utilizar en otros
programas).

El papel más importante del programa principal programa principal, pero si se ubican después es
main() es coordinar a las otras funciones necesario escribir el prototipo de la función (el
Función mediante llamadas o invocaciones. encabezado) antes del programa principal.
#include <stdio.h> La función puede o no recibir valores Una función puede que regrese o no regrese nada
(parámetros), en lenguaje C podemos devolver (void ). En el primer caso se comporta como una
float areatriangulo (void)
cualquier tipo de datos escalares (puntero, tipo variable, ya que la podemos imprimir, asignar a
{
float base, altura; numérico y el tipo carácter o en su caso regresar otra variable, comparar, utilizar como parámetro,
printf("Introduce base: "); un valor nulo). Asimismo, no se pueden devolver etc. En el segundo caso, el resultado lo tenemos
scanf("%f",&base); arreglos ni estructuras. que imprimir dentro de la función (sólo las
printf("Introduce altura: "); variables globales se imprimirán fuera).
scanf("%f",&altura); Para utilizar funciones en un programa es
return (base*altura)/2; necesario declararlas previamente. Existen dos tipos de funciones: Sin paso de
} parámetros y con paso de parámetros.
main() Ámbito de las variables

{ Prototipo de una función
float area; Variable local
area=areatriangulo(); Un prototipo es el encabezado de una función, es
Variable declarada en el programa principal
printf("El área es: %2.2f \n", decir la primera línea de la función.
area); main() o en una función, sólo se encuentra
} disponible durante el funcionamiento del main()
o de la función, es decir está en memoria cuando La ventaja de utilizar prototipos es que las
dicha función está activa. funciones pueden estar en cualquier lugar y en
cualquier orden y pueden ser llamadas desde
Recordemos, un procedimiento siempre se
cualquier punto del programa principal o de otra
declarará con valor de retorno void y una función Variable global
función.
se declarará con cualquier tipo de dato como Variable declarada fuera de cualquier función y
valor de retorno y en su código se añadirá la antes del main() y que puede ser utilizada por
En lenguaje C, lleva punto y coma al finalizar.
sentencia return y el valor que se desea devolver todo el programa, es decir, incluyendo funciones.
al programa que lo llama.
Primero mostramos la sintaxis de funciones sin
En lenguaje C a cada módulo o subprograma se le Llamada o invocación de una paso de parámetros y sin prototipos:
conoce como función, en este lenguaje se trabaja función
a base de funciones y, de manera general, los # librerías
programas se elaboran combinando funciones Para llamar una función es necesario escribir el Variables globales;
que el programador escribe y funciones nombre o identificador de la función y en seguida Constantes
“predefinidas” disponibles en la biblioteca void funcion_a ( )
un par de paréntesis, que estarán vacíos si
{
estándar de C. hablamos de funciones sin paso de parámetros y
variables locales;
tendrán información en caso de ser funciones con instrucción 1;
paso de parámetros. instrucción 2;
5.2 Cómo se ejecuta un programa quevoid funcion_b ( )
}
Activación/invocaci
{
contiene funciones5 variables locales;
instrucción 1;
ón de Funciones y El compilador siempre inicia con la primera
}
instrucción 2;
instrucción que encuentra en el programa
Procedimientos. principal (main) y continúa ejecutándolo según la main( )
estructura de control (secuencial, selectiva o
{
Variables locales;
La base de la programación en C es la función, ya repetitiva) del programa, cuando encuentra la
Cuerpo del programa principal
que constituye una parte fundamental de la llamada a una función éste se traslada y ejecuta ::::::::::::::::::
codificación en el proceso de solución de el cuerpo de la función desde la primera funcion_a( );
problemas. Un programa contiene una o más instrucción hasta encontrar el fin de la misma, funcion_b( );
funciones en uno o más archivos. Corona, M. y cuando esto sucede el compilador regresa a la instrucción 3;
Ancona M. (2011) siguiente instrucción que llamó a la función y ::::::::::::::::::::
continúa de la misma manera. }
Una de las funciones es main(), donde se inicia la
ejecución del programa. El resto de las funciones
se llaman desde main() y desde el interior de otras Ubicación de una función en un Si lo que se quiere es declarar primero los
funciones. programa prototipos de cada función, luego el cuerpo de la
función principal y al final el cuerpo de cada
Las funciones pueden ir antes o después del función, ésta sería su sintaxis :

main( )
# librerías {
Sintaxis Setlocale(LC_ALL,””);
Variables globales
char opc;
Constantes void Identif_funcion ( ) printf (“a)Hipotenusa de un
funcion_a (); { triángulo rectángulo \n“);
// prototipo de la función a Declaración de variables; printf (“b)Área de untriángulo\n“);
funcion_b (); Cuerpo de la función; printf (“c)Tercer ángulo de un
// prototipo de la función b … triángulo \n“);
printf (“Elige una opción\n“);
} scanf (“%c”,&opc);
main()
{ switch (opc)
… diferentes formas de llamar a una función sin {
variables locales case ‘a’:hipotenusa( );
Cuerpo del programa principal paso de parámetros
break;
… case ‘b’:area( );
funcion_a(); printf(“%d 5”,Identif_funcion ( break;
funcion_b(); )); case ‘c’:angulo( );
… break;
Variable = Identif_ funcion(); }
}
if (Identif_funcion()>Expresión); }
funcion_a ()
{
Variables locales
instrucción 1; Ejemplo 1 Desarrolle el programa principal y
instrucción 2; opciones a tres funciones sin paso de parámetros
instrucción 3; que calculen:
} a) La hipotenusa de un triángulo rectángulo
b) El área de un triángulo
funcion_b ();
{ c) El tercer ángulo de un triángulo
Variables locales
#include <stdio.h>
instrucción 1;
#include <locale.h>
instrucción 2; #include <math.h>
}
void hipotenusa ( )
{
int co, ca;
float h;
printf (”Escriba la longitud
del cateto adyacente al ángulo: ”);
scanf (“%d”,&ca);
printf (“Escriba la longitud del
cateto opuesto al ángulo: “);
scanf (“%d”,&co);
h= sqrt (co * co + ca * ca);
printf (“La hipotenusa del
triángulo mide: %f“, h);
}
void area( )
{
int base, alt; float a;
printf (”Escriba la base y la Ejemplo 2 Desarrolle el programa principal con
altura: ”); opciones a cuatro funciones sin paso de
scanf (“%d%d”,&base, &alt); parámetros que conviertan de:
a= base * alt / 2;
printf (“El área del triángulo es: a) Grados centígrados a grados Fahrenheit
%f“, a);
} b) Grados Fahrenheit a grados centígrados
c) Grados centígrados a kelvins
void angulo( ) d) Kelvins a grados centígrados
{
float a1, a2, a3;
Funciones sin paso de parámetros printf (”Escriba el valor de los
#include <stdio.h>
dos ángulos: ”);
#include <locale.h>
scanf (“%f%f”,&a1, &a2);
void convertir_C_F ( );
Son aquellas que no reciben parámetros o a3= 180 - (a1+a2) ; void convertir_F_C ( );
valores, ya que éstos se solicitan dentro de la printf (“El tercer ángulo mide: void convertir_C_K ( );
%f“, a3); void convertir_K_C ( );
función, luego se realizan las instrucciones
} main( )
(cálculos u operaciones) y normalmente se
imprime el resultado. {
char opc;

do
{
printf ("Elige una de las
siguientes conversiones \n");
printf ("a)Grados centígrados a
grados Fahrenheit \n");
printf ("b)Grados Fahrenheit a
grados centígrados \n");
printf ("c)Grados centígrados a
Kelvins\n");
printf ("d)Kelvins a grados
centígrados\n");
scanf ( "%s",&opc);
switch (opc)
{
case 'a' : convertir_C_F( );
break;
case 'b' : convertir_F_C( );
break;
case 'c' : convertir_C_K( );
break; Parámetros de una función
case 'd' : convertir_K_C( );
break;
}
Son una serie de valores que se especifican en la
printf ("\n¿ Deseas repetir el llamada a la función, o en la declaración de esta,
programa S/N?\n"); de los que depende el resultado de la función,
scanf ( "%s",&opc); dichos valores nos permiten la comunicación
}
while (opc== 's'); Este ejercicio tiene prototipos, por ello las entre dos funciones.
} funciones se declararon después de ser llamadas,
después de la función main(). Los parámetros o argumentos de una función se
void convertir_C_F( ) pueden clasificar en:
{
float c , f ;
printf ("Dame los grados centígrados: Formales o ficticios
" );
scanf ("%f",&c);
5.3 Uso de Son los que se encuentran en la definición de la
función. Si una función usa argumentos, éstos se
f = 1.8 *c + 32;
printf ("Los grados Fahrenheit son:
%.2f", f);
Funciones y comportan como variables locales de la función.
}
Procedimientos con Son variables de la función que toman los valores
que se le pasan desde fuera de ella. Por ejemplo:
parámetros.
void convertir_F_C( )
{ float divide (int x, int y)
float c , f ;
printf ("Dame los grados Fahrenheit: {
" ); Estas funciones son las más utilizadas en la int a, b;
scanf ("%f",&f); programación ya que pueden recibir uno o más printf (“Dame dos números enteros: “);
c=(f-32 ) * 5/9;
printf ("Los grados centígrados son: valores llamados parámetros y regresan un solo scanf (“%d%d“,&a,&b);
%.2f", c); valor de tipo entero, real o carácter. Para regresar
} un arreglo de carácter es necesario hacerlo desde Tenemos una función llamada divide, la cual
los parámetros. Los parámetros o valores son regresa un dato de tipo float y los parámetros
void convertir_C_K( ) enviados del programa principal o de otra formales o ficticios son la x y la y.
{
float c , k ; función. Corona, M. y Ancona M. (2011)
printf ("Dame los grados centígrados:
" ); Dentro de la función se realizan solamente las Actuales o reales
scanf ("%f",&c); instrucciones, cálculos u operaciones. Se emplean en la llamada a la función. Pueden ser
k=c + 273;
variables o expresiones cuyos valores se pasan a
printf ("Los grados Kelvins son:
%.2f", k); los argumentos formales. Algunos autores
} llaman argumentos a los parámetros actuales o
reales. Por ejemplo:
void convertir_K_C( )
{
float c , k ;
main ()
printf ("Dame los kelvins: " ); {
scanf ("%f",&k); int m, n;
c= 273 - k; float z;
printf ("Los grados centígrados son: printf (“Dame dos números enteros: “);
%f", c);
} scanf (“%d%d“,&m,&n);
z=divide(m,n); //Llamada o invocación a la
función divide

En el renglón anterior los parámetros actuales o La función main() puede llamar a cualquier Variables locales;
reales son la m y la n. Los parámetros formales función, pero ninguna otra función puede llamar Instrucción 1;
Instrucción 2;
siempre son variables, mientras que los reales a main().
Instrucción 3;
pueden ser variables, constantes, expresiones return (valor);
aritméticas e incluso lo que regrese la llamada a Características de las funciones con paso de }
otra función. parámetros:
tipo_dato funcion_b (parámetros
1. Normalmente el número de parámetros formales)
Paso de parámetros en una actuales es igual a los parámetros formales. Es {
Variables locales;
función decir que, si en la llamada a la función se tienen
Instrucción 1;
dos parámetros, en la declaración de la función C=funcion_a(parámetros actuales);
misma deberá tener dos parámetros. Instrucción 2;
En lenguaje C todos los parámetros se pasan “por 2. Generalmente el tipo de dato de cada return (valor);
valor”, es decir, en cada llamada a la función se parámetro deberá ser del mismo tipo. Es decir }
genera una copia de los valores de los parámetros que, si en la llamada a la función el primero es
actuales, que se almacenan en variables entero y el segundo es real, en la declaración de
temporales en la pila mientras dure la ejecución la función misma el primer parámetro deberá ser
de la función. Sin embargo, cuando sea preciso es entero y el segundo real. Un prototipo de función le da información
posible hacer que una función modifique el valor importante al compilador. En el prototipo se
de una variable que se pase como parámetro Ventajas de utilizar funciones con paso de indican el tipo de dato que regresa la función y el
actual en la llamada a la función. parámetros: número, tipo y orden de parámetros que recibe la
misma.
Para ello, lo que se debe proporcionar a la función ✓ Reducen significativamente el tamaño del
no es el valor de la variable, sino su dirección, lo código. El compilador utiliza los prototipos para verificar
cual se realiza mediante un puntero que señale a ✓ Pueden reutilizarse en otro programa. las llamadas a funciones, por ejemplo:
esa dirección; a estos parámetros los llamamos ✓ Se pueden crear librerías o bibliotecas
por variable o por referencia, en este tipo de personales que incluyan funciones
parámetros los datos salen modificados. desarrolladas por el programador. float promedio(int, float, int); o bien
float promedio(int x, float y, int z);
Sintaxis … diferentes formas de llamar a una función con

paso de parámetros
# Librerías
Variables globales;
Constantes printf (“%d = ”,Identif_funcion Paso de parámetros en funciones
(parametros actuales));
Var = Identif_funcion(parametros con vectores y matrices
tipo_dato funcion_a (parámetros
formales) actuales);
{ if (Identif_funcion(parametros Sintaxis de vectores:
Variables locales; actuales) > Exp);
Instrucción 1;
Instrucción 2; tipo devuelto NombreFunción(tipo nombre_vector[])
Instrucción 3;
return (valor); Sintaxis funciones con parámetros y con Sintaxis de matrices:
} prototipos
tipo_devuelto NombreFunción(tipo nombre_matriz[] [tam])
tipo_dato funcion_b (parámetros # librerías
formales) Variables globales
{ Nota :
Constantes
Variables locales; Es opcional anotar el tamaño dentro del primer
tipo_dato funcion_a (parámetros
Instrucción 1; par de paréntesis. Los arreglos se comportan
formales);
C=funcion_a(parámetros actuales);
tipo_dato funcion_b (parámetros como parámetros por variable ya que existe un
Instrucción 2;
return (valor); formales); puntero que apunta a la primera posición.
}
main( )
main ( ) {
{ Variables locales;
Variables locales; Cuerpo del programa principal Ejemplo 3 Desarrolle el programa principal y
Cuerpo del programa principal … opciones a tres funciones con paso de
… C=funcion_a(parámetros actuales); parámetros que calculen:
C=funcion_a(parámetros actuales)6; D=funcion_b(parámetros actuales); a) la hipotenusa de un triángulo rectángulo
D=funcion_b(parámetros actuales)6; Instrucción 3; b) el área de un triángulo
Instrucción 3; …
… c) el tercer ángulo de un triángulo
}
}
#include <stdio.h>
tipo_dato funcion_a (parámetros #include <locale.h>
formales) #include <math.h>
{

float hipotenusa (int co, int ca)
{
float h;
h = sqrt (co * co + ca * ca);
return h;
}
float area (float base, float alt)

{
float a;
a = base * alt/2;
return a;
}
float angulo (float a1, float a2)

{
float a3;
a3 = 180 - ( a1+a2);
return a3;
}
main( )
{
setlocale(LC_ALL,""); Ejemplo 4 Sume dos vectores de 20 elementos
char opc; int ca, co; como máximo y almacenar el resultado en un Ejemplo 5 Leer un vector de enteros y un número
float base,alt,h,a,a1,a2, a3; tercer vector utilizando funciones con paso de
printf ("a) hipotenusa de un entero x e imprimir la cantidad de:
triángulo rectángulo\n");
parámetros.
printf ("b) área de un a) veces que x aparece en el arreglo.
triángulo\n"); #include<stdio.h>
b) elementos menores a x en el arreglo.
printf ("c) tercer ángulo de un
triángulo\n"); void llenar_vector(int x[20],int tam); c) elementos mayores a x en el arreglo.
void imprimir_vector(int x[20],int tam);
printf ("Elige una opción :"); void sum_v(int x[20],int y[20],int
scanf ("%c",&opc); z[20],int tam); Utiliza funciones por valor con paso de
switch (opc) int i; parámetros (realice el cálculo e impresión
{ respectivas).
case 'a' : printf ("Escriba la main()
longitud del cateto adyacente al {
ángulo: "); #include<stdio.h>
int t,a[20],b[20],c[20]; #include<locale.h>
scanf ("%d",&ca); printf("Total de elementos: ");
printf ("Escriba la longitud del scanf("%d",&t);
cateto opuesto al ángulo: "); void llenar_vector();
printf("Dame los elementos del vector void imprimir_vector();
scanf ("%d",&co); a: ");
h = hipotenusa(co,ca); int cuenta(int X);
llenar_vector(a,t); int menor_numero(int xx);
printf ("La hipotenusa del triángulo printf("Dame los elementos del vector
mide: %f", h); int mayor_numero(int xx);
b: ");
break; llenar_vector(b,t);
case 'b' : printf ("Escriba la base y int vec[50],I,N;
sum_v(a,b,c,t);
la altura : "); printf("\nEl vector a es: ");
scanf ("%f%f",&base,&alt); main()
imprimir_vector(a,t); {
a= area (base,alt); printf("\nEl vector b es: ");
printf ("El área del triángulo es: setlocale(LC_ALL,"");
imprimir_vector(b,t); int x;
%f", a); printf("\nLa suma es: \t");
break; printf("Total de elementos: ");
imprimir_vector(c,t); scanf("%d",&N);
case 'c' : printf ("Escriba el valor }
de los dos ángulos: "); printf("Ingresa el valor de x : ");
scanf ("%f%f",&a1,&a2); scanf("%d",&x);
void llenar_vector(int x[20],int tam) llenar_vector(N);
a3 = angulo (a1,a2); {
printf ("El tercer ángulo mide: %f", printf("\n\nVeces que %d aparece en
for (i=0; i<tam; i++) el arreglo : %d ",x,cuenta(x));
a3); scanf("%d",&x[i]);
break; printf("\nElementos menores a %d en
} el arreglo : %d",x,menor_numero(x));
} void imprimir_vector(int x[20],int
} printf("\nElementos mayores a %d en
tam) el arreglo : d",x,mayor_numero(x));
{ }
for (i=0; i<tam; i++)
printf("\t%d ",x[i]); void llenar_vector()
} {
void sum_v(int x[20],int y[20],int for(i=0;i<N;i++)
z[20],int tam) {
{ printf("Ingresa el número %d :
for (i=0; i<tam; i++) ",i+1);
z[i]= x[i]+ y[i]; scanf("%d",&vec[i]);
} }
printf("\nVector de números
enteros \n");
imprimir_vector();

}
void imprimir_vector()
{
for(i=0;i<N;i++)
printf("%d ",vec[i]);
} Ejercicios propuestos
int cuenta(int xx)
{
int cont=0;
for(i=0;i<N;i++)
{ El ejercicio propuesto para este tema es
if(vec[i]==xx)
cont=cont+1; continuar con el desarrollo del proyecto integral
} para resolver un problema real relacionado al
return cont; perfil de un Ing. mecatrónico que incluya
} módulos.
int menor_numero(int xx)
{
int contmenor=0; Se considera un proyecto integral porque incluye
for(i=0;i<N;i++) cada uno de los temas vistos hasta este momento
{ (tema 5) y además de los temas 6 y 7 que están
if(vec[i]<xx) por verse.
contmenor=contmenor+1;
}
return contmenor; Solución de un problema real que incluye
} módulos – Proyecto Integral - ANEXO 10
int mayor_numero(int xx)
{
Acceso al Video Tema 5 Diseño de un programa
int cont=0,contmayor=0;
for(i=0;i<N;i++) con módulos. ANEXO 11
{
if(vec[i]>xx) Ejemplo de un programa con Módulos en
contmayor=contmayor+1; lenguaje C – Control de producción de Motores.
}
return contmayor;
ANEXO 12
}

REFERENCIAS
Cairó, O. (2006). Fundamentos de programación Piensa en C. 1ra edición Pearson Prentice Hall, México.
Corona, M. y Ancona M. (2011). Diseño de algoritmos y su codificación en lenguaje C. México: Mcgraw-Hill.
Delgado, H. (2020). Estructura general básica de un Programa en Lenguaje C. Recuperado 11 de febrero, 2022, de
https://disenowebakus.net/estructura-programa.php
Delgado, Hugo. (2020). Ficheros - Abrir, cerrar, leer y agregar archivos de texto. Recuperado 13 de julio, 2022, de
https://disenowebakus.net/ficheros.php

ANEXOS
Anexo 1 Vínculo para accesar al Video Tema 1 Diseño de Algoritmos en PSeInt
Video Tema 1 Diseño de Algoritmos en PSeInt.mp4
Anexo 2 Solución de ejercicios propuestos del tema 1 de Algoritmos

Ejercicios de Algoritmos Simples
Ejercicio 1
Pseudocodigo que calcula la superficie de un triangulo
Algoritmo Ejercicio1
Base,Altura,Superficie es real;
escribir"Ingresa la base de tu triangulo en cm:";
leer Base;
escribir"Ingresa la altura de tu triangulo cm:";
leer Altura;
Superficie=(Base*Altura)/2;
Escribir " La base de tu triangulo es de: ",Superficie," cm².";
FinAlgoritmo

Ejercicio 2
Pseudocodigo que transforma pies y libras a metros y kilos
Long_en_pies,Peso_en_libras,Long_en_metros,Peso_en_kilos es real;
escribir"Ingrese el largo de su objeto en pies";
leer Long_en_pies;
escribir"Ingrese el peso de su objeto en libras";
leer Peso_en_libras;
Long_en_metros=Long_en_pies*0.3048;
Peso_en_kilos=Peso_en_libras*0.453592;
Escribir "El largo de su objeto es de: ",Long_en_metros," m.";
Escribir "y el peso de su objeto es de: ", Peso_en_kilos, " kg.";
FinAlgoritmo
Ejercicio 3
Pseudocodigo que calcula el área y volumen de un cilindro
Radio,Altura,Area,Volumen es real;
Escribir "Ingresa el radio";
Leer Radio;
Escribir "Ingresa la altura";
Leer Altura;
Area=2*PI*Radio*Altura+2*PI*(Radio*Radio);
Volumen=PI*(Radio*Radio)*Altura;
Escribir "El área de su cilindro es de:",Area," unidades cuadradas.";
Escribir "El volumen de su cilindro es de:",Volumen, " unidades cubicas.";
FinAlgoritmo

Ejercicio 4
Pseudocodigo que calcula área y longitud de una circunferencia
Radio,Area,Longitud_de_circunferencia es real;
Escribir "Ingrese el radio de su circunferencia";
Leer Radio;
Area=PI*(Radio*Radio);
Longitud_de_circunferencia=2*pi*Radio;
Escribir "El área de su circunferencia es de ",Area, " unidades cuadradas.";
Escribir "La longitud de su circunferencia es de ",Longitud_de_circunferencia, " unidades.";
FinAlgoritmo
Ejercicio 5
Pseudocodigo que imprime un numero de 4 dígitos de forma vertical
Numero_de_cuatro_digitos,C1,C2,C3,C4,R1,R2,R3,R4 es entero;
Escribir "Ingresa tu número de cuatro dígitos";
Leer Numero_de_cuatro_digitos;
C1<-trunc(Numero_de_cuatro_digitos/1000);

R1<- Numero_de_cuatro_digitos mod 1000;
C2<-trunc(R1/100);
C3<-trunc(R2/10);
C4<-trunc(R3/1);
Escribir C1;
Escribir C2;
Escribir C3;
Escribir C4;
FinAlgoritmo
Ejercicios de Algoritmos con estructuras de Selección
Ejercicio 1
Algoritmo dos_numeros
definir num1 como real;
definir resultado como real;
Escribir "se van a utilizar 2 numeros, dependiendo de sus valores se harán diferentes operaciones";
Escribir "introduce el primer numero";
leer num1;
Escribir "introduce el segundo numero";
leer num2;
si num1==nume2 Entonces
resultado=num1*num2;
Escribir "los dos numeros multiplicados dan como resultado:", resultado;
FinSi
si num1>nume2 Entonces
resultado=num1-num2;
Escribir "el primero numero menos el segundo numero da como resultado:", resultado;
FinSi
FinAlgoritmo

Ejercicio 2
Algoritmo analisis_numero
definir num como entero;
Escribir "introduce un numero para determinar si es nulo, par o impar";
Escribir "introduce el numero que quieres analizar";
leer num;
si num==0 Entonces
Escribir "tu numero es nulo";
FinSi
si num%2==0 y num>0 Entonces
Escribir "tu numero es par";
SiNo
si num>0 Entonces
Escribir "tu numero es impar";
FinSi
FinSi
FinAlgoritmo

Ejercicio 3
Algoritmo numeros_orden
definir num como real;
Escribir "introduce tres numeros enteros para determinar si están en orden creciente";
Leer num;
Leer num2;
Escribir "introduce el tercer numero";
Leer num3;
si num>=num2 y num2>=num3 Entonces
Escribir "los numeros no tienen orden creciente";
SiNo
Escribir "los numeros tienen orden creciente";
FinSi
FinAlgoritmo
Ejercicio 4
Algoritmo numero_funcion
Definir var como real;
Definir for Como Real;
Escribir "calcula el valor de una funcion fx";
Escribir "introduce el valor de la variable";
Leer var;
si var%4==0 Entonces
for=(var*var*var);
Escribir "la variable al cubo es:", for;
FinSi
si var%4=1 Entonces
for=((var*var)-14)/(var*var*var);
Escribir "el resultado de la division es:", for;
FinSi
si var%4=2 Entonces
for=(var*var*var)+5;
Escribir "el resultado de la suma es:", for;
FinSi
si var%4=3 Entonces
for=raiz(var);
Escribir "el resultado de la raiz es:", for;
FinSi
FinAlgoritmo

Ejercicio 5
Algoritmo numero_mayor
definir num como real;
Escribir "introduce tres numeros para conocer su orden";
Leer num;
Leer num2;
Escribir "introduce el tercer numero";
Leer num3;
si num>num2 y num2>num3 Entonces
Escribir "el numero mayor es el primero:", num;
FinSi
si num<num2 y num2<num3 Entonces
Escribir "el número mayor es el tercero:", num3;
FinSi
si num<num2 y num2>num3 Entonces
Escribir "el numero mayor es el segundo:", num2;
FinSi
si num=num2 y num2=num3 Entonces
Escribir "los numeros que usas son iguales";
FinSi
FinAlgoritmo

Ejercicios de Algoritmos con estructuras de Repetición
Ejercicio 1
Algoritmo sumanNnumeros
Definir num1, num2, i, acum Como Entero;
Escribir "vamos a hacer la suma de N numeros";
Escribir "dame un conjunto de numeros";
Leer num1;
acum=0;
Para i=1 hasta num1 Con Paso 1 Hacer
Escribir "dame un numero";
Leer num2;
si num2<=0 Entonces
Escribir "tus valores son negativos o 0";
SiNo
acum=acum+num2;
FinSi
FinPara
Escribir "tu suma de numeros es: ",acum;
FinAlgoritmo
Ejercicio 2
Algoritmo factorial
Definir num, val, fact Como Real;
Escribir "Ingresa un el numero que quieres analizar";
leer num;
si num < 0 Entonces
Escribir "el numero no puede se calcularse, es 1.";
SiNo
val = 1;
fact = 1;
Repetir
val = val +1;
fact = fact * val;
Hasta Que val > num
Escribir "El factorial del numero es: ",fact;
FinSi
FinAlgoritmo

Ejercicio 3.
Algoritmo suma_pares_promedio_impar
Definir num1, num2, i, acum, prom Como real;
Escribir "vamos a hacer la suma de N numeros";
Escribir "dame un conjunto de numeros";
Leer num1;
acum=0;
prom=0;
Escribir "dame un numero";
Leer num2;
si num2%2=0 Entonces
acum=acum+num2;
SiNo
prom=num2/num1;
FinSi
FinPara
Escribir "tu suma de numeros pares es: ",acum;
Escribir "tu promedio de numeros impares es: ",prom;
FinAlgoritmo

Ejercicio 4.
Algoritmo calificaciones
Definir num1 Como Entero;
Definir num2, i, acum1, acum2, acum3, acum4, acum5 Como real;
Escribir "vamos a calcular el numero de ingresados";
Escribir "dame el numero de alumnos";
Leer num1;
acum1=0; acum2=0; acum3=0; acum4=0; acum5=0;
Escribir "dame sus calificaciones";
Leer num2;
si num2<=3.99 Entonces
acum1=acum1+1;
FinSi
si num2>=4 y num2<=5.99 Entonces
acum2=acum2+1;
FinSi
acum3=acum3+1;
FinSi
acum4=acum4+1;
FinSi
si num2>=9 y num2<=10 Entonces
acum5=acum5+1;
FinSi
FinPara
Escribir "tu suma de calificacion entre 0 y 3.99 es: ",acum1;
Escribir "tu suma de calificacion entre 9 y 10 es: ",acum5;
FinAlgoritmo

Ejercicio 5.
Algoritmo elecciones
Definir num1 Como Entero;
Definir num2, i, acum1, acum2, acum3, acum4, acum5 Como Real;
Definir acum, prom1, prom2, prom3,prom4, prom5 Como real;
Escribir "vamos a calcular el promedio de votos";
Escribir "dame el total de votantes";
Leer num1;
acum=0; acum1=0; acum2=0; acum3=0; acum4=0; acum5=0;
Escribir "dame el numero del cantidato por el que voto (de 1 a 5)";
Leer num2;
acum=acum+1;
si num2=1 Entonces
acum1=acum1+1;
FinSi
si num2=2 Entonces
acum2=acum2+1;
FinSi
si num2=3 Entonces
acum3=acum3+1;
FinSi
si num2=4 Entonces
acum4=acum4+1;
FinSi
si num2=5 Entonces
acum5=acum5+1;
FinSi
FinPara
prom1=acum1/acum;
prom2=acum2/acum;
prom3=acum3/acum;
prom4=acum4/acum;
prom5=acum5/acum;
Escribir "los votos por candidato 1 son: ",acum1;
Escribir "el promedio de votos por candidato 1 son: ",prom1;
Escribir "el promedio de votos por candidato 2 son: ",prom2;
Escribir "el promedio por votos por candidato 3 son: ",prom3;
FinAlgoritmo

Anexo 3 Vínculo para accesar al Video Tema 2 Introducir al tema de desarrollo de programas DevC++
Video Tema 2 Introducir el tema de desarrollo de programas DevC.mp4
Anexo 4 Solución de ejercicios propuestos del tema 2 Introducción a la Programación
A. Ejercicios con prioridad de Operadores
a. 15*14-3*7 = 189
b. -4*5*2 = -40
c. (24+2*6) / 4 =9
d. 3+4* (8*(4-(9+3)/6)) = 67
e. 4*3*5+8*4*2-5 = 119
f. 4-40/5 = -4
g. (-5)%(-2) = -1
Ejercicio 1
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define pi 3.1416
int main()
{
float r, a, v;
printf("Da el radio\n");
scanf("%f",&r);
a=pi*pow(r,2);
v=(4*pi*pow(r,3))/3;
printf("el area del circulo es: %f",a);
printf( "\nel volumen de la esfera es: %f",v);
return 0;
}

Ejercicio 2
// Ejercicio 2
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main()
{
float cat_1;
float cat_2;
float hipotenusa;
printf("valor del cateto 1: \n");
scanf("%f",&cat_1);
printf("valor del cateto 2: \n");
scanf("%f",&cat_2);
hipotenusa=sqrt((cat_1*cat_1)+(cat_2*cat_2));
printf("la hipotenusa del triangulo es: %.2f \n",hipotenusa);
return 0;
}
Ejercicio 3
#include <stdio.h>
#include <math.h>
main()
{
float perimetro,altura,area,lado;
printf("\n ingresar el lado del triangulo ");
scanf("%f",&lado);
perimetro= lado+lado+lado;
altura= (sqrt(3) * lado)/2;
area= (lado*altura)/4;
printf("\n la altura es %.2f \nel perimetro es %.2f \ny el area es:
%.2f",altura,perimetro,area);
return 0;
}

Ejercicio 4
#include <stdio.h>
main()
{
int cantidad,mil,quinientos,doscientos,cien,cincuenta,veinte,diez,cinco,dos,uno;
printf("ingrese la cantidad:");
scanf("%d",&cantidad);
mil=cantidad/1000;
quinientos=(cantidad-(mil*1000))/500;
doscientos=(cantidad-(mil*1000)-(quinientos*500))/200;
cien=(cantidad-(mil*1000)-(quinientos*500)-(doscientos*200))/100;
cincuenta=(cantidad-(mil*1000)-(quinientos*500)-(doscientos*200)-cien*100))/50;
veinte=(cantidad-(mil*1000)-(quinientos*500)-(doscientos*200)-(cien*100)-cincuenta*50))/20;
diez=(cantidad-(mil*1000)-(quinientos*500)-(doscientos*200)-(cien*100)-(cincuenta*50)-
(veinte*20))/10;
cinco=(cantidad-(mil*1000)-(quinientos*500)-(doscientos*200)-(cien*100)-(cincuenta*50)-
(veinte*20)-(diez*10))/5;
dos=(cantidad-(mil*1000)-(quinientos*500)-(doscientos*200)-(cien*100)-(cincuenta*50)-
(veinte*20)-(diez*10)-(cinco*5))/2;
uno=(cantidad-(mil*1000)-(quinientos*500)-(doscientos*200)-(cien*100)-(cincuenta*50)-
(veinte*20)-(diez*10)-(cinco*5)-(dos*2))/1;
printf("\nBill de 1000 = %d",mil);
printf("\nBill de 500 = %d",quinientos);
printf("\nBill de 200 = %d",doscientos);
printf("\nBill de 100 = %d",cien);
printf("\nBill de 50 = %d",cincuenta);
printf("\nBill de 20 = %d",veinte);
printf("\nMon de 10 = %d",diez);
printf("\nMon de 5 = %d",cinco);
printf("\nMon de 2 = %d",dos);
printf("\nMon de 1 = %d",uno);
return 0;
}
Ejercicio 5
#include <stdio.h>
#include <stdlib.h>
int main()
{
float r1,r2,r3;
printf("Este programa multiplica dos numeros reales con 3 decimales\n");
printf("\tDa el real 1\n");
scanf("%f",&r1);
printf("\n\tDa el real 2\n");

scanf("%f",&r2);
r3=r1*r2;
printf("\n\t%.3f*\t\n",r1);
printf("\n\t%.3f=\t\n",r2);
printf("\n\t--------------\t\n");
printf("\n\t%.3f\t\n",r3);
return 0;
}

Anexo 5 Solución de ejercicios propuestos del tema 3 Control de Flujo
Programas con Estructuras Secuenciales
Ejercicio 1
#include<stdio.h>
main()
{
float base,altura,superficie;
printf("Ingresa la base del triángulo : ");
scanf("%f",&base);
printf("Ingresa la altura del triángulo : ");
scanf("%f",&altura);
superficie=(base*altura)/2;
printf("\n La superficie del triángulo es %.2f ",superficie);
}
Ejercicio 2
#include<stdio.h>
main()
{
float pies,libras,metros,kilos;
printf("\nIngresa la longitud del objeto : ");
scanf("%f",&pies);
printf("Ingresa el peso del objeto : ");
scanf("%f",&libras);
metros=pies*0.3048;
kilos=libras*0.453592;
printf("\nEl objeto mide %.2f metros y pesa %.2f kilos",metros,kilos);
}

Ejercicio 3
#include<stdio.h>
#include<math.h>
#include<locale.h>
#define pi 3.1416
main()
{
float radio,altura,area,volumen;
printf("Ingresa el radio del cilindro : ");
scanf("%f",&radio);
printf("Ingresa la altura del cilindro : ");
scanf("%f",&altura);
area=2*3.1416*radio*(radio+altura);
volumen=pi*(pow(radio,2))*altura;
printf("\nEl área del cilindro es = %.2f",area);
printf("\nEl volumen del cilindro es = %.2f",volumen);
}
Ejercicio 4
#include<stdio.h>
#include<math.h>
#include<locale.h>
#define pi 3.1416
main()
{
float radio,area,longitud;
printf("Ingresa el radio del circulo : ");
scanf("%f",&radio);
area= pi*(pow(radio,2));
longitud=2*pi*radio;
printf("\nEl área del circulo es = %.2f ",area);
printf("\nLa longitud de su circunferencias es = %.2f ",longitud);
}

Ejercicio 5
#include<stdio.h>
#include<math.h>
#include<locale.h>
main()
{
int digito,m,c,d,u;
printf("\nIngresa un número de cuatro dígitos : ");
scanf("%d",&digito);
m=digito/1000;
c=(digito-(m*1000))/100;
d=(digito-(m*1000)-(c*100))/10;
u=digito-(m*1000)-(c*100)-(d*10);
printf("\n%d\n%d\n%d\n%d",m,c,d,u);
}
Programas con Estructuras Selectivas
Ejercicio 1
#include<stdio.h>
main()
{
float angulo;
printf("Ingrese un angulo en grados: ");
scanf("%f",&angulo);
if (angulo<90)
printf("%.1f El angulo es agudo",angulo);
else
{
if(angulo>90)
printf("%.1f El angulo es obtuso",angulo);
if(angulo==90)
printf("%.1f El angulo es recto",angulo);
}
}

Ejercicio 2
#include<stdio.h>
#include<conio.h>
#include<locale.h>
main()
{
float n1,n2,n3;
printf("\ningresa un número ");
scanf("%f",&n1);
printf("ingresa un segundo número ");
scanf("%f",&n2);
printf("ingresa un tercer número ");
scanf("%f",&n3);
if(n1<n2&&n2<n3||n1>n2&&n2>n3)
printf("%.1f es el número central",n2);
if(n2<n1&&n1<n3||n2>n1&&n1>n3)
if(n2<n3&&n3<n1||n2>n3&&n3>n1)
}
Ejercicio 3
#include<stdio.h>
main()
{ int num1,num2,num3,mayor,menor;
printf("ingresa un numero: ");
scanf("%d",&num1);
printf("ingresa un numero diferente: ");
scanf("%d",&num2);
printf("ingresa un numero diferente: ");
scanf("%d",&num3);
if(num1>num2 && num1>num3)
mayor=num1;
mayor=num2;
mayor=num3;
printf("%d es el numero mayor y ",mayor);
if(num1<num2 && num1<num3);
menor=num1;
if(num2<num1 && num2<num3)
menor=num2;
if(num3<num1 && num3<num2)
menor=num3;
printf(" %d es el numero menor",menor);
}

Ejercicio 4
#include<stdio.h>
#include<math.h>
main()
{
int num;
printf("Ingresa un numero entero positivo: ");
scanf("%d",&num);
if(num%7==0)
printf("El numero %d es positivo, es impar y es multiplo de 7",num);
else
printf("El numero %d no es multiplo de 7",num);
}
Ejercicio 5
#include<stdio.h>
#include<conio.h>
#include<locale.h>
main()
{
int a1,a2,a3;
printf("ingresa un ángulo ");
scanf("%d",&a1);
printf("ingresa el segundo ángulo ");
scanf("%d",&a2);
a3=180-(a1+a2);
if (a1==90||a2==90||a3==90)
printf("el tercer ángulo es: %d, y por lo tanto es un triángulo rectángulo",a3);
if (a1<90&&a2<90&&a3<90)
printf("el tercer ángulo es %d, y por lo tanto es un triángulo acutángulo",a3);
if (a1>90||a2>90||a3>90)
printf("el tercer ángulo es %d, y por lo tanto es un triángulo obstusángulo",a3);
}
Programas con Estructura Switch

Ejercicio 1
#include<stdio.h>
main()
{
int carasuperior;
printf ("¿Que numero está en la cara superior de tu dado? ");
scanf ("%d", &carasuperior);
switch(carasuperior)
{
case 1: printf("La cara opuesta es seis");
break;
case 2: printf("La cara opuesta es cinco");
break;
case 3: printf("La cara opuesta es cuatro");
break;
case 4:printf("La cara opuesta es tres");
break;
case 5:printf("La cara opuesta es dos");
break;
case 6: printf("La cara opuesta es uno");
break;
default: printf("OPCION NO VALIDA");
break;
}
}
Ejercicio 2
#include<stdio.h>
#include<locale.h>
main()
{
setlocale(LC_CTYPE, "spanish");
int modobscuro, modclaro, edad, anosmanej;
char modelo, color;
float preciomasedad, preciomasanosman, preciofinal;
printf ("Modelos \n");
printf ("Modelo A [A] \n");
printf ("Modelo B [B] \n");
printf ("Modelo C [C] \n");
printf ("Ingresa el modelo de tu vehiculo: ");
scanf ("%s", &modelo);
switch (modelo)
{
case 'A':{
printf("Ingresa el color de tu vehiculo \n");
printf ("Claro, ingresa [1] \n");
printf ("Obscuro, ingresa [2] \n");
scanf("%d", &color);
printf ("Ingrese su edad: ");
scanf ("%d", &edad);
printf("¿Cuantos años tienes manejando? ");
scanf ("%d", &anosmanej);
switch (color)
{
case 1: modclaro=3800;
if (edad<20)

preciomasedad=modclaro+(modclaro*.25);
if (edad>=20 && edad<=30)
preciomasedad=modclaro;
if (edad>65)
if (anosmanej<2)
preciomasanosman=modclaro*.25;
else
preciomasanosman=modclaro;
preciofinal=modclaro+preciomasedad+preciomasanosman;
break;
case 2: modobscuro=4340;
if (edad<20)
preciomasedad=modobscuro+(modobscuro*.25);
preciomasedad=modobscuro;
if (edad>65)
if (anosmanej<2)
preciomasanosman=modobscuro*.25;
else
preciomasanosman=modobscuro;
preciofinal=modobscuro+preciomasedad+preciomasanosman;
break;
}
break;
}
case 'B': {
printf("¿Cuantos años tienes manejando? ");
switch (color)
{
if (edad<20)
if (edad>65)
if (anosmanej<2)
else
break;
if (edad<20)
if (edad>65)

if (anosmanej<2)
else
break;
}
break;
}
case 'C': {
printf("¿Cuantos años tienes manejando?");
switch (color)
{
if (edad<20)
if (edad>65)
if (anosmanej<2)
else
break;
if (edad<20)
if (edad>65)
if (anosmanej<2)
else
break;
}
break;
}
break;
}
printf("Usted debe: %.3f ", preciofinal);
}

Programas con Estructuras Iterativas
Ejercicio 1
#include<stdio.h>
main()
{
int N,num,numm,mayor,menor;
num=1;
mayor=0;
menor=999999999;
printf("\n\tIngrese cuantos numeros enteros positivos va a ingresar: ");
scanf("%d",&N);
while(num<=N)
{
printf("\n\tIngrese el numero %d: ",num);
scanf("%d",&numm);
if (numm>mayor)
mayor=numm;
if(numm<menor)
menor=numm;
num=num+1;
}
printf("\nEl numero mayor es: %d",mayor);
printf("\n\nEl numero menor es: %d",menor);
}
Ejercicio 2
#include<stdio.h>
main()
{
int num;
for(num=0;num<=100;num=num+1)
{

if (num%7!=0)
printf("%d ",num);
}
}
Ejercicio 3
#include<stdio.h>
main()
{
int num,sum=0,prome,numm=0;
num=45;
do
{
if (num%9==0)
{
numm=numm+1;
sum=sum+num;
printf("%d ",num);
}
num=num+1;
}
while(num<=194);
prome=sum/numm;
printf("\n\nEl promedio de los multiplos de 9 que hay de 45 a 194 es de: %d",prome);
}
Ejercicio 4
#include<stdio.h>
main()
{
int N,num=1;
float serie=0,auxnum;
printf("\n\tIngrese un numeros entero positivo para resolver la serie: ");
scanf("%d",&N);
while(num<=N)
{
auxnum=num;
serie=serie+(1/auxnum);
num=num+1;
}
printf("\n\nEl resultado de la serie es = %.3f",serie);
}

Ejercicio 5
#include<stdio.h>
#include<math.h>
main()
{
int N,num;
float serie=0,auxnum,result;
printf("\n\tIngrese un numeros entero positivo para resolver la serie: ");
scanf("%d",&N);
for(num=1;num<=N;num=num+1)
{
auxnum=num;
if(num%2!=0)
{
result=(auxnum/(pow(2,auxnum)));
serie=serie+result;
}
else
{
result=(auxnum/(pow(2,auxnum)));
serie=serie-result;
}
}
printf("\n\nEl resultado de la serie es = %.3f",serie);
}

Anexo 6 Caso práctico de Aplicación de Estructuras de Control
Planteamiento del Problema:
BARROD, S.A. DE C.V, es una empresa mexicana dedicada a la venta, distribución y fabricación de todo tipo de tornillos. Tiene más de 35 años de
experiencia en el rubro. Cuenta con una planta especializada en la fabricación de tornillos de acuerdo con la especificación y medidas de sus clientes.
Ofrece: tornillos, tuercas, arandelas, birlos, herrajes y anclas. También ofrece servicio de fabricación especial para atender toda necesidad en sujeción.
Esta empresa esta solicitando un programa que lleve los registros de los promedios mensuales de producción de los 6 productos que ofrece (tornillos,
tuercas, arandelas, birlos, herrajes y anclas), y a través de un menú (switch)poder hacer las siguientes consultas para una adecuada toma de decisiones:
a. El promedio anual de producción de cada producto (for)

b. El mes y la mayor y menor cantidad de producción y a que producto se refiere (while)
c. Determinar cuál de los productos con mayor demanda (tornillos, birlos y herrajes) tienen el mayor promedio de producción anual. (do-while)
El programa deberá ser recursivo (do-while).
Análisis:
1. La primera estructura de repetición que utilizamos es el do-while para hacer recursivo (repetitivo) el programa, es decir que el menú se repita las
veces que el usuario lo desee, y utilizamos una variable llamada recu de tipo entero, y mientras recu=1, el programa se va a estar ejecutando o repitiendo
hasta que le usuario ingrese el número cero.
2. Utilizamos la librería setlocale de la biblioteca #include<locale.h> para que al escribir en los printf palabras acentuadas, estas puedan desplegarse tal
cual en la pantalla y no caracteres especiales, es decir, para darle presentación al texto que se despliega.
3. Declaramos una variable de tipo caracter (char) llamada op, en donde guardaremos la opción que selecciono el usuario, a, b o c.
4. Las estructuras de repetición for, while y do-while utilizan las variables produc (los 6 productos que fabrican) y mes (toman los valores de los 12 meses
del año), y por lo tanto serán variables de tipo entero (int).
5. La variable suma, sera una sumatoria, en donde acumulará la producción de los 12 meses para cada uno de los productos, y al ser una sumatoria a
parte de declararla, se le tiene que asignar un valor inicial en este caso se inicializa con cero, y este valor de cero se le va asignar cada vez que cambie de
producto, es decir va acumular la producción de los doce meses para cada producto, y para cada producto va iniciar con cero, no va a acumular la
producción de los productos anteriores.
6. En la variable cant almacenamos la producción mensual de cada producto y esta declarada de tipo real, con decimales (float), porque posteriormente
vamos a calcular el promedio anual de producción (al dividir dos variables de tipo float, da como resultado un número float) y será guardada en la variable
prom que tambien es de tipo float.
7. En la variable mayor y menor vamos a guardar la mayor y menor cantidad producida mensualmente de cada producto y también será declarada de
tipo float.
8. En las variables de tipo entero (int) mayormes,mayorproduc,menormes,menorproduc, se almacenará la mayor y menor cantidad producida
mensualmente del producto y el mes que corresponde.
9.Al ejecutar el programa se despliega como referencia que el producto 1 serán los tornillos, el producto 2 seran las tuercas, el producto 3 serán las
arandelas etc. para que sea más facil programarlo y no tener que programarlo como tipo de dato string (nombre del producto).
[1]Tornillos [2]Tuercas [3]Arandelas [4]Birlos [5]Herrajes [6]Anclas
10. Se despliega un menu de tipo char con tres opciones
11. Dentro de cada caso se solicitara los mismos datos de entrada (cantidad producida mensual para cada producto), cuando se vea el tema de arreglos,
esto podrá evitarse ya que se podrá almacenar los datos de manera temporal.
Implementación:
#include<stdio.h>
#include<locale.h>
main()
{
int recu;
recu=1;
do
{

char op;
float suma=0,cant,prom,mayor=0,menor=9999999;
int mes,produc,mayormes,mayorproduc,menormes,menorproduc;
printf("\n\n\n\t\t Fabrica BARROD S.A. DE C.V.");
printf("\n \t\t Control de Producción");
printf("\n\nProductos: [1]Tornillos [2]Tuercas [3]Arandelas [4]Birlos [5]Herrajes [6]Anclas");
printf("\n\n a. Promedio anual de producción de cada producto");
printf("\n b. Mayor y menor producción mensual");
printf("\n c. Mayor promedio de producción de los productos de mayor demanda");
printf("\n\n Ingresa la opción deseada : ");
scanf("%s",&op);
switch(op)
{
case 'a':for(produc=1;produc<=6;produc=produc+1)
{
printf("\n\n\tProducto %d \n",produc);
suma=0;
for(mes=1;mes<=12;mes=mes+1)
{
printf("Ingresa la producción del mes %d : ",mes);
scanf("%f",&cant);
suma=suma+cant;
}
prom=suma/12;
printf("\nEl promedio anual de producción es %.2f ",prom);
}
break;
case 'b':mayor=0;
menor=9999999;
produc=1
while(produc<=6)
{
mes=1;
while(mes<=12)
{
scanf("%f",&cant);
if(cant>mayor)
{
mayor=cant;
mayormes=mes;
mayorproduc=produc;
}
if(cant<menor)
{
menor=cant;
menormes=mes;
menorproduc=produc;
}
mes=mes+1;
}
produc=produc+1;
}
printf("\nEl producto %d en el mes %d tuvo la mayor producción de %.0f " ,
mayorproduc,mayormes,mayor);
printf("\nEl producto %d en el mes %d tuvo la menor producción de %.0f ",
menorproduc,menormes,menor);
break;
case 'c':mayor=0;
produc=1;
do
{
if(produc==1 || produc==4 || produc==5)
{

suma=0;
mes=1;
do
{
scanf("%f",&cant);
suma=suma+cant;
mes=mes+1;
}
while(mes<=12);
prom=suma/12;
if(prom>mayor)
{
mayor=prom;
mayorproduc=produc;
}
}
produc=produc+1;
}
while(produc<=12);
printf("\nEl producto %d tuvo el mayor promedio de producción con %.2f",mayorproduc,mayor);
break;
default: printf("\n\n\nOpción NO valida");
break;
}
printf("\n\n\tIngresa < 1 > continuar en el programa o < 0 > para salir -> ");
scanf("%d",&recu);
}
while(recu==1);
}


Anexo 7 Solución de un problema real que incluye arreglos – Proyecto Integral
Planteamiento del problema
Desarrolla un programa de seguimiento sobre la producción de engranajes tomando en cuenta los diferentes tipos y características de cada engranaje
y en base a esas propiedades realiza los cálculos necesarios para el funcionamiento industrial de un tren de engranajes, así como el cálculo estadístico
para definir el promedio y medidas de dispersión. A su vez, contiene cálculos básicos de las ventas generadas por cada pedido pagado y una agenda de
proveedores.
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<locale.h>
#include<iostream>
#include<stdlib.h>
main()
{
system("color F4");
int recur,recur5;
recur=0;
do{
float eng[15][5],vendido[3],promedio[3],promediovent[3],sumaprom, promrecto, promheli, promdoble,promtotal,

promgen,rest,restcua,varianza,acumuprom,desvest;
float acumulador,datook,diente,tabdien[15],modulo,tabmodulo[15],multpar,multimpar;
float relacion,rpm,velangu,sumapromgen=0;
char tipo_engranaje[15][25],buscatipo[25],nohay[50];
int ped,np,opcionest,dato,conrecto,conheli,condoble,cont,entero,longprom,t,npprom,paso,numserie[20],val,val2;
int indice,numdato,eliminar,ENGLUG,LUG,pos,numser,indicedien;
char titulo[6][100]={"NÚMERO DE SERIE DEL PEDIDO : ","TIPO: [1] Engranaje Recto , [2] Engranaje Helicoidal ó [3]
Engranaje Doble Helicoidal: ","NÚMERO DE DIENTES QUE TIENEN LOS ENGRANAJES : ","CANTIDAD DE ENGRANAJES DEL PEDIDO :
", "MÓDULO CON EL QUE CUENTAN LOS ENGRANAJES : ","PRECIO TOTAL DEL PEDIDO : "};
printf("\n\n\t\a-----PRODUCCIÓN DE ENGRANAJES-----\n\t");
printf("\n\n\tINGRESE LA CANTIDAD DE PEDIDOS : ");
scanf("%i",&np);
for (ped=1;ped<=np;ped++){
printf("\n\n\t...... INGRESA EL PEDIDO %i ...... ",ped);

for (t=1;t<=6;t++){
printf("\n\n\t %s",titulo[t-1]);
if (t==1)
scanf("%i",&numserie[ped-1]);
else if (t==2){
scanf("%f",&eng[ped-1][0]);
if (eng[ped-1][0]==1){
strcpy(tipo_engranaje[ped-1],"Recto");
printf("\n\t Usted seleccionó %s",&tipo_engranaje[ped-1]);
}
if (eng[ped-1][0]==2){
strcpy(tipo_engranaje[ped-1],"Helicoidal");
}
if (eng[ped-1][0]==3){
strcpy(tipo_engranaje[ped-1],"Doble_Helicoidal");
}
if (eng[ped-1][0]!=1&&eng[ped-1][0]!=2&&eng[ped-1][0]!=3){
printf("\n\n.... Opción inválida, este pedido no será ingresado ....");
numserie[ped-1]=0;
eng[ped-1][0]=0;
ped--;
t=7;
}

}
if (t>2&&t<7)
scanf("\t %f",&eng[ped-1][t-2]);
}
}
printf("\n\n\t......DESPLEGANDO DATOS......\n");
if (eng[ped-1][0]==1){
printf ("\n %i| %i %s ",ped,numserie[ped-1],tipo_engranaje[ped-1]);
}
if (eng[ped-1][0]==2){
printf ("\n %i| %i %s ",ped,numserie[ped-1],tipo_engranaje[ped-1]);
}
if (eng[ped-1][0]==3){
printf ("\n %i| %i %s",ped,numserie[ped-1],tipo_engranaje[ped-1]);
}
for (int t=1;t<5;t++){
printf(" %.2f ",eng[ped-1][t]);
}
}
int recur2;
recur2=1;
do{
int opcion;
printf("\n\n\n\t\t------MENÚ DE OPCIONES------");
printf("\n\t[1] CONSULTAR PEDIDO");
printf("\n\t[2] MODIFICAR O ELIMINAR PEDIDO");
printf("\n\t[3] CALCULAR LA RELACIÓN DE TRANSMISIÓN");
printf("\n\t[4] CALCULAR LA VELOCIDAD ANGULAR DEL ÚLTIMO ENGRANAJE");
printf("\n\t[5] CALCULAR ESTADÍSTICA");
printf("\n\t[6] VENTAS");
printf("\n\t[7] AGENDA");
printf("\n\tINGRESE LA OPCIÓN QUE DESEA : ");
scanf("%i",&opcion);
switch(opcion)
{
int datomenu;
case 1:printf("\n\t\t...CONSULTANDO EL PEDIDO...");
printf("\n\t[1] MOSTRAR TODOS LOS DATOS");
printf("\n\t[2] MOSTRAR EL TIPO DESEADO");
printf("\n\tINGRESE LA OPCIÓN DESEADA : ");
scanf("%i",&datomenu);
if(datomenu==1)
{
if (eng[ped-1][1]!=0){
if (eng[ped-1][0]==1){
printf ("\n %i %s ",numserie[ped-1],tipo_engranaje[ped-1]);
}
if (eng[ped-1][0]==2){
}
if (eng[ped-1][0]==3){
printf ("\n %i %s",numserie[ped-1],tipo_engranaje[ped-1]);
}
}
}
}
}
if(datomenu==2){
printf ("\n\n\tINGRESA EL TIPO DE ENGRANAJE QUE DESEAS VER (Recto,Helicoidal o Doble_Helicoidal):

");
indice=0;

scanf("%s",&buscatipo);
cont=0;
for(ped=1;ped<=np;ped++)
{
if(strcmp(buscatipo,tipo_engranaje[ped-1])==0){
indice=ped-1;
printf ("\n %i %s ",numserie[indice],tipo_engranaje[indice]);
printf(" %.2f ",eng[indice][t]);
}
cont++;
}
}
if (cont==0){
strcpy(nohay,"\n\n\tESTE TIPO DE ENGRANAJE NO SE ENCUENTRA ENTRE LOS PEDIDOS INGRESADOS\n");
printf("%s",nohay);
}
}
break;
case 2:printf("\n\t\t......MODIFICAR O ELIMINAR EL PEDIDO......");
printf("\n\n\t[1] MODIFICAR UN ENGRANAJE");

printf("\n\t[2] ELIMINAR UN ENGRANAJE");
printf("\n\tINGRESE LA OPCIÓN DESEADA : ");
scanf("%i",&eliminar);
if(eliminar==1){
indice=0;
paso=1;
if (eng[ped-1][1]!=0){
if (eng[ped-1][0]==1){
}
if (eng[ped-1][0]==2){
}
if (eng[ped-1][0]==3){
}
}
}}
printf ("\n\n\tINGRESA EL NÚMERO DE SERIE DEL PEDIDO QUE DESEAS MODIFICAR : ");
scanf("%i",&indice);
if (numserie[ped-1]==indice){
indice=ped-1;
paso=0;
}
}
dato=0;
if (paso==0){
do{
printf("\n\n\tSUSTITUYA LOS DATOS DEL PEDIDO");
for (t=1;t<=5;t++){
printf("\n\n %s",titulo[t]);
if (t==1){
scanf("%f",&eng[indice][0]);
if (eng[indice][0]==1){
strcpy(tipo_engranaje[indice],"Recto");
printf(" Usted seleccionó %s",&tipo_engranaje[indice]);

}
strcpy(tipo_engranaje[indice],"Helicoidal");
}
strcpy(tipo_engranaje[indice],"Doble_Helicoidal");
}
if (eng[indice][0]!=1&&eng[indice][0]!=2&&eng[indice][0]!=3){
printf("\n\n.... OPCIÓN INVÁLIDA, ESTE PEDIDO NO SERÁ INGRESADO ....");
eng[indice][0]=0;
dato=1;
t=7;
}
}
if (t>=2&&t<6){
scanf("%f",&eng[indice][t-1]);
dato=0;
}
}
}while (dato==1);
printf("\n\n\t......DESPLEGANDO DATOS ACTUALIZADOS......\n");
if (eng[ped-1][1]!=0){
if (eng[ped-1][0]==1){
}
if (eng[ped-1][0]==2){
}
if (eng[ped-1][0]==3){
}
}
}
}
}
else
printf("\n\n\tNÚMERO DE SERIE NO ENCONTRADO");
}
if(eliminar==2){
indice=0;
paso=1;
if (eng[ped-1][1]!=0){
if (eng[ped-1][0]==1){
}
if (eng[ped-1][0]==2){
}
if (eng[ped-1][0]==3){
}
}
}}
printf ("\n\n\tINGRESA EL NÚMERO DE SERIE DEL PEDIDO QUE DESEAS ELIMINAR : ");

if (numserie[ped-1]==indice){
indice=ped-1;
paso=0;
}
}
if (paso==0){
strcpy(tipo_engranaje[indice],"eliminar");
numserie[indice]=0;
for (t=1;t<5;t++){
eng[indice][t-1]=0;
}
printf("\n\n\t......DESPLEGANDO DATOS ACTUALIZADOS\n");
if (eng[ped-1][1]!=0){
if (eng[ped-1][0]==1){
}
if (eng[ped-1][0]==2){
}
if (eng[ped-1][0]==3){
}
}
}}
}
else
printf("NÚMERO DE SERIE NO ENCONTRADO");
}
break;
case 3:
multpar=1;
multimpar=1;
val=0;
val2=0;
printf ("\n\n\t\a¡¡¡Para que la operación pueda realizarse, el Tipo y Módulo de todos los engranajes
debe ser el mismo!!! ");
printf ("\n\n\tINGRESA EL TIPO DE ENGRANAJE QUE DESEAS CALCULAR ( Recto , Helicoidal o Doble_Helicoidal
) : ");
indice=0;
cont=0;
{
indice=ped-1;
printf ("\n\t %i %s ",numserie[indice],tipo_engranaje[indice]);
}
cont++;
}
}
if(cont==0){
printf("%s",nohay);
val=1;
}
if (val==0){
printf("\n\n\tDE CUANTOS ENGRANAJES DESEA CALCULAR LA RELACIÓN DE TRANSMISIÓN : ");
scanf("%d",&ENGLUG);
LUG=1;
while(LUG<=ENGLUG)

{
printf("\n\tINGRESE EL NÚMERO DE SERIE DEL ENGRANAJE %i : ",LUG);
scanf("%i",&numser);
{
if(numserie[ped-1]==numser)
indicedien=ped-1;
}
diente=eng[indicedien][1];
modulo=eng[indicedien][3];
tabdien[LUG-1]=diente;
tabmodulo[LUG-1]=modulo;
if(LUG%2==0)
multpar=multpar*tabdien[LUG-1];
else
multimpar=multimpar*tabdien[LUG-1];
LUG++;
}
for (t=1;t<ENGLUG;t++){
if(tabmodulo[t-1]!=tabmodulo[t])
val2=1;
}
if (val2==0){
relacion=multimpar/multpar;
printf("\n\n\t LA RELACIÓN DE TRANSMISIÓN ES =%.2f",relacion);
}
else
printf ("\nESTOS ENGRANAJES NO CUENTAN CON EL MISMO MÓDULO, IMPOSIBLE HACER LA OPERACIÓN");
}
break;
case 4:
multpar=1;
multimpar=1;
val=0;
val2=0;
printf ("\n\n\t\a¡¡¡Para que la operación pueda realizarse, el Tipo y Módulo de todos los engranajes
debe ser el mismo!!! ");
printf ("\n\n\tINGRESA EL TIPO DE ENGRANAJE QUE DESEAS CALCULAR ( Recto , Helicoidal o Doble_Helicoidal
) : ");
indice=0;
cont=0;
{
indice=ped-1;
}
cont++;
}
}
if (cont==0){
printf("%s",nohay);
val=1;
}
if (val==0){
printf("\n\n\n\tCUANTAS REVOLUCIONES POR MINUTO (RPM) DA SU MOTOR : ");
scanf("%f",&rpm);
printf("\n\n\tDE CUANTOS ENGRANAJES DESEA CALCULAR LA RELACIÓN DE TRANSMISIÓN : ");
scanf("%d",&ENGLUG);
LUG=1;
do
{
printf("\n\tINGRESE EL NÚMERO DE SERIE DEL ENGRANAJE %i : ",LUG);
{
if(numserie[ped-1]==numser)
indicedien=ped-1;
}

if(LUG%2==0)
else
LUG++;
}
while(LUG<=ENGLUG);
if(tabmodulo[t-1]!=tabmodulo[t])
val2=1;
}
if (val2==0){
velangu=relacion*rpm;
printf("\n\n\t LA VELOCIDAD ANGULAR DEL ÚLTIMO ENGRANAJE ES = %.2f RPM ",velangu);
}
else
printf ("\nESTOS ENGRANAJES NO CUENTAN CON EL MISMO MÓDULO, IMPOSIBLE HACER LA OPERACIÓN");
}
break;
case 5:
do{
printf("\nCÁLCULO DE DATOS ESTADÍSTICOS");
printf("\n\n\t[1] CÁLCULO DEL PROMEDIO DE LA CANTIDAD DE ENGRANAJES EN LOS PEDIDOS");
printf("\n\t[2] CÁLCULO DE MEDIDAS DE DISPERSIÓN DE LA CANTIDAD DE ENGRANAJES EN LOS PEDIDOS");
printf("\n\t[3] CÁLCULO DEL PROMEDIO DE LAS VENTAS EN LOS PEDIDOS");
printf("\n\t[4] CÁLCULO DE MEDIDAS DE DISPERSIÓN EN LAS VENTAS DE LOS PEDIDOS");
printf("\n\n\tINGRESE LA OPCIÓN QUE DESEA : ");
scanf("%i",&opcionest);
switch(opcionest)
{
case 1:
promrecto=0;
promheli=0;
promdoble=0;
conrecto=0;
conheli=0;
condoble=0;
longprom=3;
npprom=np;
promgen=0;
for(ped=1;ped<=npprom;ped++){
if (eng[ped-1][0]==1){
promrecto=promrecto+eng[ped-1][2];
conrecto++;
}
if (eng[ped-1][0]==2){
promheli=promheli+eng[ped-1][2];
conheli++;
}
if (eng[ped-1][0]==3){
promdoble=promdoble+eng[ped-1][2];
condoble++;
}
}
if (conrecto==0)
conrecto=1;
promedio[0]=(promrecto/conrecto);
if (conheli==0)
conheli=1;
promedio[1]=(promheli/conheli);
if (condoble==0)
condoble=1;
promedio[2]=(promdoble/condoble);
sumaprom=0;
ped=1;
entero=0;
while (ped<=3){

entero=(int)promedio[ped-1];
if (entero!=0)
sumaprom=sumaprom+promedio[ped-1];
else
longprom=longprom-1;
ped++;
}
promgen=(sumaprom/longprom);
printf("\n\tEL PROMEDIO DE LA CANTIDAD DE LOS ENGRANAJES RECTOS EN LOS PEDIDOS ES : %.0f
engranajes",promedio[0]);
printf("\n\tEl PROMEDIO DE LA CANTIDAD DE LOS ENGRANAJES HELICOIDALES EN LOS PEDIDOS ES : %.0f
printf("\n\tEl PROMEDIO DE LA CANTIDAD DE LOS ENGRANAJES DOBLE HELICOIDALES EN LOS PEDIDOS ES : %.0f
printf("\n\n\tEL PROMEDIO GENERAL DE LA CANTIDAD DE LOS ENGRANAJES ES : %.0f engranajes",promgen);
break;
case 2:
ped=0;
rest=0;
restcua=0;
acumuprom=0;
varianza=0;
sumaprom=0;
npprom=np;
for(ped=0;ped<np;ped++)
sumaprom=sumaprom+eng[ped][2];
promtotal=sumaprom/npprom;
ped=0;
while(ped<np)
{
rest=eng[ped][2]-promtotal;
restcua= pow(rest,2);
acumuprom=acumuprom+restcua;
ped++;
}
if (np==1)
varianza=acumuprom/(np);
else
varianza=acumuprom/(np-1);
desvest=sqrt(varianza);
if (varianza==acumuprom){
varianza=0;
desvest=0;
}
printf("\n\tLA DESVIACIÓN ESTÁNDAR O LA ESTIMACIÓN DEL CAMBIO DE LA CANTIDAD GENERAL DE ENGRANAJES ES: %f ",
desvest);
printf("\n\tLA VARIABILIDAD DE LAS CANTIDADES EN LOS PEDIDOS CON RESPECTO AL PROMEDIO (VARIANZA) ES : %f
",varianza);
break;
default: printf("\n\tELIJA UNA OPCIÓN VÁLIDA");
break;
case 3:
promrecto=0;
promheli=0;
promdoble=0;
conrecto=0;
conheli=0;
condoble=0;
longprom=3;
npprom=np;
promgen=0;
for(ped=1;ped<=npprom;ped++){
if (eng[ped-1][0]==1){
conrecto++;
}
if (eng[ped-1][0]==2){
conheli++;
}

if (eng[ped-1][0]==3){
condoble++;
}
}
if (conrecto==0)
conrecto=1;
promediovent[0]=(promrecto/conrecto);
if (conheli==0)
conheli=1;
promediovent[1]=(promheli/conheli);
if (condoble==0)
condoble=1;
promediovent[2]=(promdoble/condoble);
sumaprom=0;
ped=1;
entero=0;
while (ped<=3){
entero=(int)promediovent[ped-1];
if (entero!=0)
sumaprom=sumaprom+promediovent[ped-1];
else
ped++;
}
printf("\n\tEL PROMEDIO DE LA CANTIDAD DE DINERO DE LOS PEDIDOS DE ENGRANAJES RECTOS ES : $%.2f
",promediovent[0]);
printf("\n\tEL PROMEDIO DE LA CANTIDAD DE DINERO DE LOS PEDIDOS DE ENGRANAJES HELICOIDALES ES : $%.2f
",promediovent[1]);
printf("\n\tEL PROMEDIO DE LA CANTIDAD DE DINERO DE LOS PEDIDOS DE ENGRANAJES DOBLE HELICOIDALES ES : $%.2f
",promediovent[2]);
printf("\n\n\tEL PROMEDIO GENERAL DE LA CANTIDAD DE LOS ENGRANAJES ES $%.2f",promgen);
break;
case 4:
ped=0;
rest=0;
restcua=0;
acumuprom=0;
varianza=0;
sumaprom=0;
npprom=np;
for(ped=0;ped<np;ped++)
sumaprom=sumaprom+eng[ped][4];
promtotal=sumaprom/npprom;
ped=0;
while(ped<np)
{
rest=eng[ped][4]-promtotal;
ped++;
}
if (np==1)
varianza=acumuprom/(np);
else
varianza=acumuprom/(np-1);
desvest=sqrt(varianza);
if (varianza==acumuprom){
varianza=0;
desvest=0;
}
printf("\n\tLA DESVIACIÓN ESTÁNDAR O LA ESTIMACIÓN DE LA DIFERENCIA DEL DINERO GENERAL ENTRE LOS PEDIDOS ES: $%f
", desvest);
printf("\n\tLA VARIABILIDAD DEL DINERO EN LOS PEDIDOS CON RESPECTO AL PROMEDIO (VARIANZA) ES : $%f ",varianza);
break;

}
printf("\n\n\t[1] REGRESAR AL MENÚ DE ESTADÍSTICA o [0] SALIR DEL MENÚ DE ESTADÍSTICA: ");
scanf("%i",&recur5);
}
while(recur5==1);
break;
case 6:
promrecto=0;
promheli=0;
promdoble=0;
sumapromgen=0;
ped=1;
do
{
if (eng[ped-1][0]==1){
promediovent[0]=promrecto;
}
else if (eng[ped-1][0]==2){
promediovent[1]=promheli;
}
else if (eng[ped-1][0]==3){
promediovent[2]=promdoble;
}
ped++;
}
while(ped<=np);
sumapromgen=promediovent[0]+promediovent[1]+promediovent[2];
printf("\n\tLA SUMA TOTAL DE LAS VENTAS DE ENGRANAJES RECTOS ES = $ %.2f ",promediovent[0]);
printf("\n\tLA SUMA TOTAL DE LAS VENTAS DE ENGRANAJES HELICOIDALES ES = $ %.2f ",promediovent[1]);
printf("\n\tLA SUMA TOTAL DE LAS VENTAS DE ENGRANAJES DOBLE HELICOIDALES ES = $ %.2f ",promediovent[2]);
printf("\n\n\t\tLA SUMA GENERAL DE TODOS LOS TIPOS DE ENGRANAJES ES = $%.2f",sumapromgen);
if(promediovent[0]>promediovent[1] && promediovent[0]>promediovent[2])

printf("\n\n\tLOS ENGRANAJES RECTOS FUERON LOS MÁS VENDIDOS CON UN TOTAL DE $ %.2f ",promediovent[0]);
printf("\n\n\tLOS ENGRANAJES HELICOIDALES FUERON LOS MÁS VENDIDOS CON UN TOTAL DE $ %.2f ",promediovent[1]);
printf("\n\n\tLOS ENGRANAJES DOBLE HELICOIDALES FUERON LOS MÁS VENDIDOS CON UN TOTAL DE $ %.2f
",promediovent[2]);
if(promediovent[0]<promediovent[1] && promediovent[0]<promediovent[2])
printf("\n\n\tLOS ENGRANAJES RECTOS FUERON LOS MENOS VENDIDOS CON UN TOTAL DE $ %.2f ",promediovent[0]);
printf("\n\n\tLOS ENGRANAJES HELICOIDALES FUERON LOS MENOS VENDIDOS CON UN TOTAL DE $ %.2f
",promediovent[1]);
printf("\n\n\tLOS ENGRANAJES DOBLE HELICOIDALES FUERON LOS MENOS VENDIDOS CON UN TOTAL DE $ %.2f
",promediovent[2]);
break;
case 7:printf("AGENDA");
break;
}
printf("\n\n\n\t[1] REGRESAR AL MENÚ PRINCIPAL o [0] SALIR DEL MENÚ PRINCIPAL: ");
}
while(recur2==1);
printf("\n\n\n\t[1] AÑADIR OTRO LOTE DE PEDIDOS o [0] SALIR DEL PROGRAMA : ");
scanf("%i",&recur);
for (ped=1;ped<=np;ped++)
strcpy(tipo_engranaje[ped-1],"");
for (t=1;t<=4;t++)
eng[ped-1][t]=0;
for (t=1;t<=3;t++)
promedio[t]=0;
}
while (recur==1);
}

Anexo 8 Vínculo para accesar al Video Tema 4 Diseño de un programa con Arreglos
Video Tema 4 Diseño de un programa con Arreglos.mp4
Anexo 9 Vínculo para accesar al Video Ejemplo de un programa con Arreglos en lenguaje C
Video Ejemplo de un programa con Arreglos en lenguaje C -Temperaturas de regiones.mp4

Anexo 10 Solución de un problema real que incluye funciones, punteros y archivos – Proyecto
Integral
Desarrolla un programa de seguimiento sobre la producción de engranajes tomando en cuenta los diferentes tipos y características de cada engranaje
y en base a esas propiedades realiza los cálculos necesarios para el funcionamiento industrial de un tren de engranajes, así como el cálculo estadístico
para definir el promedio y medidas de dispersión. A su vez, contiene cálculos básicos de las ventas generadas por cada pedido pagado y una agenda de
proveedores.
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<locale.h>
#include<iostream>
#include<stdlib.h>
#include<conio.h>
#include<windows.h>
// Prototipos de funciones
float relacionf(int casorel);
void desplegar();
void ingresar(int numtitulo,int indic);
int buscnumserie(int busnuse);
void buscartp();
int promediar(int posip);
double variacion(int posvar);
// Variables globales
float eng[15][5],promrecto, promheli, promdoble,promediovent[3],sumaprom;
char tipo_engranaje[15][25],nohay[50],buscatipo[25];
int np,numserie[20],t,val,paso,npprom,ped,conrecto,conheli,condoble,indice;
main()
{
int recur,recur5;
recur=0;
do
{
float vendido[3],promedio[3],promtotal, promgen,var,desres,rel,acumulador,datook,sumapromgen=0;
int opcionest,entero,longprom,numdato,eliminar,pos,numtit,opage,dato;
char proveedor[100],limpiar[10],numepro[10];
printf("\n\n\t\a****************************** PRODUCCIÓN DE ENGRANAJES
******************************\n\n\t");
printf("\n\n\tIngrese la cantidad de pedidos : ");
scanf("%i",&np);
{
printf("\n\n\t__________ INGRESA EL PEDIDO %i __________",ped);
printf("\n\n\n\tFavor de ingresar números enteros en el *Número de serie del pedido*");
val=0;
numtit=6;
indice=0;
ingresar(numtit,indice);}
printf("\n\n\t.......... DESPLEGANDO DATOS ..........\n");
desplegar();
int recur2;
recur2=1;
do
{
int opcion;
printf("\n\n\n\t___________________ MENÚ DE OPCIONES ____________________\n");
printf("\n\t[1] CONSULTAR PEDIDO");
printf("\n\t[2] MODIFICAR O ELIMINAR PEDIDO");

printf("\n\t[3] CALCULAR LA RELACIÓN DE TRANSMISIÓN");
printf("\n\t[4] CALCULAR LA VELOCIDAD ANGULAR DEL ÚLTIMO ENGRANAJE");
printf("\n\t[5] CALCULAR ESTADÍSTICA");
printf("\n\t[6] VENTAS");
printf("\n\t[7] AGENDA");
printf("\n\tIngrese la opción deseada : ");
scanf("%i",&opcion);
switch(opcion)
{
int datomenu;
case 1:
printf("\n\n\n\t________ CONSULTANDO EL PEDIDO ________\n");
printf("\n\t[1] MOSTRAR TODOS LOS DATOS");
printf("\n\t[2] MOSTRAR EL TIPO DESEADO");
scanf("%i",&datomenu);
if(datomenu==1)
{
void (*fundesplegar)(void); // Punteros
fundesplegar=&desplegar;
fundesplegar();}
if(dato menú==2){
printf ("\n\n\tIngresa el tipo de engranaje que deseas ver ( Recto , Helicoidal o Doble_Helicoidal ) : ");
buscartp();
}
if(datomenu!=1 && datomenu!=2)
{
printf("\n\n\t..........¡¡¡¡ OPCIÓN NO VÁLIDA !!!!..........");
}
break;
case 2:
printf("\n\n\n\t________ MODIFICAR O ELIMINAR EL PEDIDO ________\n");
printf("\n\t[1] MODIFICAR UN ENGRANAJE");
printf("\n\t[2] ELIMINAR UN ENGRANAJE");
scanf("%i",&eliminar);
if(eliminar==1)
{
indice=0;
paso=1;
desplegar();
printf ("\n\n\tIngresa el número de serie del pedido que deseas modificar : ");
indice!=0;
indice=buscnumserie(indice);
dato=0;
if(paso==0)
{
printf ("\n\n\t------ AÑADA LOS NUEVOS DATOS ------ ");
do
{
val=0;
numtit=5;
ingresar(numtit,indice);}
while (dato==1);
printf("\n\n\t.......... DESPLEGANDO DATOS ACTUALIZADOS ..........\n");
desplegar();}
else
{
printf("\n\n\t¡¡¡¡ NÚMERO DE SERIE NO ENCONTRADO !!!!");}
}
if(eliminar==2)
{
indice=0;
paso=1;
desplegar();
printf ("\n\n\tIngresa el número de serie del pedido que deseas eliminar : ");
indice=buscnumserie(indice);
if (paso==0)
{
strcpy(tipo_engranaje[indice],"eliminar");
numserie[indice]=0;

for (t=1;t<=5;t++)
{
eng[indice][t-1]=0;}
printf("\n\n\t.......... DESPLEGANDO DATOS ACTUALIZADOS ..........\n");
desplegar();
}
else
{
printf("\n\n\t¡¡¡¡ NÚMERO DE SERIE NO ENCONTRADO !!!!");}
}
if(eliminar!=1 && eliminar!=2){
}
break;
case 3:
printf("\n\n\n\t________ RELACIÓN DE TRANSMISIÓN ________\n");
relacionf(3);
break;
case 4:
printf("\n\n\n\t________ VELOCIDAD ANGULAR ________\n");
relacionf(4);
break;
case 5:
do{
printf("\n\n\n\t___________________ CÁLCULO DE DATOS ESTADÍSTICOS ____________________\n");
printf("\n\t[1] CÁLCULO DEL PROMEDIO DE LA CANTIDAD DE ENGRANAJES EN LOS PEDIDOS");
printf("\n\t[2] CÁLCULO DE MEDIDAS DE DISPERSIÓN DE LA CANTIDAD DE ENGRANAJES EN LOS PEDIDOS");
printf("\n\t[3] CÁLCULO DEL PROMEDIO DE LAS VENTAS EN LOS PEDIDOS");
printf("\n\t[4] CÁLCULO DE MEDIDAS DE DISPERSIÓN EN LAS VENTAS DE LOS PEDIDOS");
scanf("%i",&opcionest);
switch(opcionest)
{
case 1:
longprom=3;
npprom=np;
promgen=0;
promediar(2);
if(conrecto==0)
conrecto=1;
promedio[0]=(promrecto/conrecto);
if(conheli==0)
conheli=1;
promedio[1]=(promheli/conheli);
if(condoble==0)
condoble=1;
promedio[2]=(promdoble/condoble);
sumaprom=0;
ped=1;
entero=0;
while (ped<=3){
entero=(int)promedio[ped-1];
if (entero!=0)
sumaprom=sumaprom+promedio[ped-1];
else
ped++;}
printf("\n\tEl promedio de la cantidad de los engranajes rectos en los pedidos es = %.2f
printf("\n\tEl promedio de la cantidad de los engranajes helicoidales en los pedidos es = %.2f
printf("\n\tEl promedio de la cantidad de los engranajes doble helicoidales en los pedidos es =
%.2f engranajes",promedio[2]);
printf("\n\n\tEl promedio general de la cantidad de los engranajes es = %.2f
engranajes",promgen);
break;
case 2:
var=0;
desres=0;
var=variacion(2);
desres=sqrt(var);

printf("\n\tLa desviación estándar o la estimación del cambio de la cantidad general de
engranajes es = %.3f ", desres);
printf("\n\tLa variabilidad de las cantidades en los pedidos con respecto al promedio
(VARIANZA) es = %.3f ",var);
break;
case 3:
longprom=3;
promgen=0;
promediar(4);
if (conrecto==0)
conrecto=1;
promediovent[0]=(promrecto/conrecto);
if (conheli==0)
conheli=1;
promediovent[1]=(promheli/conheli);
if (condoble==0)
condoble=1;
promediovent[2]=(promdoble/condoble);
sumaprom=0;
ped=1;
entero=0;
while (ped<=3){
entero=(int)promediovent[ped-1];
if (entero!=0)
sumaprom=sumaprom+promediovent[ped-1];
else
ped++;}
printf("\n\n\tEl promedio de la cantidad de dinero de los pedidos de engranajes rectos es = $
%.2f ",promediovent[0]);
printf("\n\tEl promedio de la cantidad de dinero de los pedidos de engranajes helicoidales es =
$ %.2f ",promediovent[1]);
printf("\n\tEl promedio de la cantidad de dinero de los pedidos de engranajes doble
helicoidales es = $ %.2f ",promediovent[2]);
printf("\n\n\tEl promedio general de la cantidad de dinero de los engranajes es = $
%.2f",promgen);
break;
case 4:
var=0;
desres=0;
var=variacion(4);
desres=sqrt(var);
printf("\n\n\tLa desviación estándar o la estimación de la diferencia del dinero general entre
los pedidos es = $ %.3f ",desres);
printf("\n\tLa variabilidad del dinero en los pedidos con respecto al promedio (VARIANZA) es =
$ %.3f ",var);
break;
default:
break;
}
printf("\n\n\t[1] REGRESAR AL MENÚ DE ESTADÍSTICA o [0] SALIR DEL MENÚ DE ESTADÍSTICA: ");
}
while(recur5==1);
break;
case 6:
printf("\n\n\n\t________ VENTAS ________\n");
promrecto=0;
promheli=0;
promdoble=0;
promediovent[0]=0;
promediovent[1]=0;
promediovent[2]=0;
sumapromgen=0;
ped=1;
promediar(4);
sumapromgen=promediovent[0]+promediovent[1]+promediovent[2];
printf("\n\tLa suma total de las ventas de engranajes rectos es = $ %.2f ",promediovent[0]);
printf("\n\tLa suma total de las ventas de engranajes helicoidales es = $ %.2f ",promediovent[1]);
printf("\n\tLa suma total de las ventas de engranajes doble helicoidales es = $ %.2f ",promediovent[2]);

printf("\n\n\t\tLa suma general de todos los tipos de engranajes es = $%.2f",sumapromgen);

printf("\n\n\tLos engranajes RECTOS fueron los más vendidos con un total de $ %.2f ",promediovent[0]);
printf("\n\n\tLos engranajes HELICOIDALES fueron los más vendidos con un total de $ %.2f
",promediovent[1]);
printf("\n\n\tLos engranajes DOBLE HELICOIDALES fueron los más vendidos con un total de $ %.2f
",promediovent[2]);

printf("\n\tLos engranajes RECTOS fueron los menos vendidos con un total de $ %.2f ",promediovent[0]);
printf("\n\tLos engranajes HELICOIDALES fueron los menos vendidos con un total de $ %.2f
",promediovent[1]);
printf("\n\tLos engranajes DOBLE HELICOIDALES fueron los menos vendidos con un total de $ %.2f
",promediovent[2]);
break;
case 7:
printf("\n\n\n\t______________ AGENDA ______________\n");
printf("\n\t [1] AGREGAR DATOS DE UN PROVEEDOR ");
printf("\n\t [2] CONSULTAR LOS DATOS DE LA AGENDA");
printf("\n\t Ingresa la opción deseada : ");
scanf("%d",&opage);
FILE *archivo; // Archivo
if(opage==1)
{
gets(limpiar);
printf("\n\n\tNombre del proveedor : ");
gets(proveedor);
printf("\n\tNúmero telefónico del proveedor : ");
scanf("%s",&numepro);
printf("\n\n\t.......... Datos guardados correctamente ..........");
archivo=fopen("AGENDA.txt","a+");
fprintf(archivo,"\t| Proveedor : %s ",proveedor);
fprintf(archivo,"Telefono : %s \n\t--------------------------------------------------\n",numepro);
fclose(archivo);
}
if(opage==2)
{
char visor;
archivo=fopen("AGENDA.txt","r");
if(archivo!=NULL)
{
printf("\n\n\t------ CONSULTANDO AGENDA ------\n\n");
while(1)
{
visor=fgetc(archivo); // archivos
if(feof(archivo))
break;
printf("%c",visor);
}
}
else{
printf("\n\n\t..........¡¡¡¡ EL ARCHIVO NO EXISTE O ESTÁ VACIO !!!!..........\n\n\t*FAVOR DE
INGRESAR PROVEEDORES*");
}
fclose(archivo);
}
if(opage!=1 && opage!=2){
}
break;
default:
break;
}
printf("\n\n\n\t[1] REGRESAR AL MENÚ PRINCIPAL o [0] SALIR DEL MENÚ PRINCIPAL: ");

}
while(recur2==1);
printf("\n\n\n\t[1] AÑADIR OTRO LOTE DE PEDIDOS o [0] SALIR DEL PROGRAMA : ");
scanf("%i",&recur);
strcpy(tipo_engranaje[ped-1],"");
for (t=1;t<=4;t++)
eng[ped-1][t]=0;
for (t=1;t<=3;t++)
promedio[t]=0;
for (t=1;t<=3;t++)
promediovent[t]=0;
}
while (recur==1);
}
void ingresar(int numtitulo, int indic)

{
char título[6][100]={"NÚMERO DE SERIE DEL PEDIDO : ","TIPO: [1] Engranaje Recto , [2] Engranaje Helicoidal ó
[3] Engranaje Doble Helicoidal: ","NÚMERO DE DIENTES QUE TIENEN LOS ENGRANAJES : ","CANTIDAD DE ENGRANAJES DEL
PEDIDO : ", "MÓDULO CON EL QUE CUENTAN LOS ENGRANAJES : ","PRECIO TOTAL DEL PEDIDO : "};
int datoing;
val=0;
for (t=1;t<=6;t++){
int post,retrot;
if (numtitulo==6){
indic=ped-1;
post=t-1;
retrot=t-2;
val=1;}
else if (numtitulo==5){
if(t==1)
t++;
post=t-1;
retrot=t-2;}
printf("\n\n\t%s",titulo[post]);
if (t==1&&val==1)
scanf("%i",&numserie[indic]);
else if (t==2){
scanf("%f",&eng[indic][0]);
if (eng[indic][0]==1){
strcpy(tipo_engranaje[indic],"Recto");
printf("\n\t Usted seleccionó %s",&tipo_engranaje[indic]);}
strcpy(tipo_engranaje[indic],"Helicoidal");
strcpy(tipo_engranaje[indic],"Doble_Helicoidal");
if (eng[indic][0]!=1&&eng[indic][0]!=2&&eng[indic][0]!=3){
printf("\n\n\t.... ¡¡¡ OPCIÓN INVÁLIDA , ESTE PEDIDO NO SERÁ INGRESADO !!! ....");
numserie[indic]=0;
eng[indic][0]=0;
ped--;
t=7;
datoing=1;}
}
if (numtitulo==6){
if (t>2&&t<numtitulo+1){
scanf("%f",&eng[indic][retrot]);
datoing=0;}
}
else if (numtitulo==5){
if (t>2&&t<=numtitulo+1){
scanf("%f",&eng[indic][retrot]);
datoing=0;}
}
}
}

// Funciones
void desplegar(){
int pedes;
if(eng[0][0])
printf("\n\t SERIE TIPO NO.DIENTES CANTIDAD MÓDULO PRECIO");
for (pedes=1;pedes<=np;pedes++){
if (eng[pedes-1][1]!=0){
if (eng[pedes-1][0]==1)
printf ("\n\t %i %s ",numserie[pedes-1],tipo_engranaje[pedes-1]);
for (t=1;t<5;t++)
printf(" %.2f ",eng[pedes-1][t]);}
}
float relacionf (int casorel){

int val2=0,pedrel,ENGLUG,LUG,numser,indicedien;
float multimpar=1,multpar=1,valideng=0,diente,tabdien[15],modulo,tabmodulo[15],rpm,velangu=0,relacion=0;
printf("\n\n\t\a......¡¡¡¡ PARA QUE LA OPERACIÓN PUEDA REALIZARSE , EL *TIPO* Y *MÓDULO* DE TODOS LOS
ENGRANAJES DEBE SER EL MISMO !!!!......");
printf ("\n\n\tIngresa el tipo de engranaje que deseas calcular ( Recto , Helicoidal o Doble_Helicoidal ) : ");
buscartp();
if (val==0){
if (casorel==3){
printf("\n\n\tDe cuantos engranajes desea calcular la relación de transmisión : ");
}else if (casorel==4){
printf("\n\n\tDe cuantos engranajes desea calcular la velocidad angular : ");
}scanf("%d",&ENGLUG);
LUG=1;
while(LUG<=ENGLUG){
indicedien=-1;
printf("\n\tIngrese el número de serie del engranaje %i : ",LUG);
for(pedrel=1;pedrel<=np;pedrel++)
{
if(numserie[pedrel-1]==numser)
indicedien=pedrel-1;}
if (indicedien!=-1){
if(LUG%2==0)
else
LUG++;}
else {
valideng=1;
LUG=ENGLUG+1;}
}
if (valideng==0){
if(tab modulo[t-1]!=tab modulo[t])
val2=1;}
if (val2==0){
if (val==0){
if (casorel==4){
printf("\n\tCuantas revoluciones por minuto (RPM) da su motor : ");
scanf("%f",&rpm);
velangu=relacion*rpm;
printf("\n\n\tLa velocidad angular del último engranaje es = %.2f RPM ",velangu);}
else if (casorel==3){
printf("\n\n\tLa relación de transmisión es = %.2f\n",relacion);
}
}

}
else
{
printf ("\n\n\t¡¡¡¡ ESTOS ENGRANAJES NO CUENTAN CON EL MISMO MÓDULO, IMPOSIBLE HACER LA OPERACIÓN
!!!!");
}
}
else{
printf ("\n\n\t¡¡¡¡ INGRESÓ UN NÚMERO DE SERIE QUE NO EXISTE, INTENTELO DE NUEVO !!!!");
}
}
}
int buscnumserie(int busnuse)

{
int iserie,*puntpaso,pedbns; // Puntero
puntpaso=&paso;
for (pedbns=1;pedbns<=np;pedbns++){
if (numserie[pedbns-1]==busnuse){
iserie=pedbns-1;
*puntpaso=0;
}
}
return iserie;
}
void buscartp(){
int btped,contbuscartp;
val=0;
contbuscartp=0;
indice=0;
printf("\n\t ORDEN: SERIE - TIPO - NO.DIENTES - CANTIDAD - MÓDULO - PRECIO\n");
for(btped=1;btped<=np;btped++)
{
if(strcmp(buscatipo,tipo_engranaje[btped-1])==0){
indice=btped-1;
}
contbuscartp++;
}
}
if(contbuscartp==0){
strcpy(nohay,"\n\n\t¡¡¡¡ ESTE TIPO DE ENGRANAJE NO SE ENCUENTRA ENTRE LOS PEDIDOS INGRESADOS
!!!!\n");
printf("%s",nohay);
val=1;
}
}
promediar(int posip){
int pedprom;
conrecto=0;
conheli=0;
condoble=0;
promrecto=0;
promheli=0;
promdoble=0;
npprom=np;
for(pedprom=1;pedprom<=npprom;pedprom++){
if (eng[pedprom-1][0]==1){
promrecto=promrecto+eng[pedprom-1][posip];
if (posip==4)
promediovent[0]=promrecto;
conrecto++;
}
promheli=promheli+eng[pedprom-1][posip];
if (posip==4)

promediovent[1]=promheli;
conheli++;
}
promdoble=promdoble+eng[pedprom-1][posip];
if (posip==4)
promediovent[2]=promdoble;
condoble++;
}
}
}
double variacion(int posvar){

double rest,restcua,promtotal,varianza,acumuprom;
int pedvar,contcero;
varianza=0;
rest=0;
promtotal=0;
restcua=0;
sumaprom=0;
npprom=np;
contcero=0;
acumuprom=0;
for(pedvar=0;pedvar<npprom;pedvar++){
if (eng[pedvar][0]!=0){
sumaprom=sumaprom+eng[pedvar][posvar];
}
else
contcero++;
}
promtotal=sumaprom/(npprom-contcero);
pedvar=0;
while(pedvar<npprom)
{
if (eng[pedvar][posvar]!=0){
rest=eng[pedvar][posvar]-promtotal;
}
pedvar++;
}
if (npprom==1)
varianza=acumuprom/(npprom);
else{
npprom=(npprom-contcero)-1;
if (npprom==0)
varianza=acumuprom/(1);
else
varianza=acumuprom/(npprom);
}
return varianza;
}

Anexo 11 Vínculo para accesar al Video Tema 5 Diseño de un programa con Módulos
Video Tema 5 Ejemplo de un programa con Funciones.mp4
Anexo 12 Ejemplo de un programa con Módulos en lenguaje C – Control de producción de Motores.
Desarrolla un programa para el registro y control de producción de los diferentes tipos de motores para autos más comunes en la actualidad, considera
el nombre del motor, producción mensual, para así poder calcular la producción anual, mayor y menor producción anual y a que motor corresponde, el
poder consultar la producción total de un motor en específico, así como poder eliminar un motor por baja producción, entre otras opciones, para una
adecuada toma de decisiones.
#include<stdio.h>
#include<string.h>
#include<locale.h>
// Funciones con parámetros y sin parámetros

char buscando(char busnombre[20]);
void desplegando();
void sumando();
char nombre[6][20];
// Variables globales
int produccion[6][12],total[6],motor,mes,indice,suma=0,sumat=0;
main()
{
setlocale(LC_ALL,””);
int recu2;
recu2=1;
do
{
int recu;
int op,mayor=0,menor=99999,nummes,prodok,mayormes;
char mayornombre[20],menornombre[20],buscanombre[20],ELIMINADO;
printf("\n\t\t\tCAPTURA DE DATOS");
printf("\n\n\t\t\tTIPOS DE MOTOR\n1.-GASOLINA 2.-DIESEL 3.-ELECTRICO 4.-GLP 5.-HIBRIDO 6.-ROTATIVO ");
for(motor=1;motor<=6;motor++)
{
printf("\n\nIngresa el nombre del motor %d:",motor);
scanf("%s",&nombre[motor-1]);
printf("Produccion en los meses:\n");
{
printf("Mes %d:",mes);
scanf("%i",&produccion[motor-1][mes-1]);
}
}
{
printf("\n%s \t",nombre[motor-1]);
{
printf("%d\t",produccion[motor-1][mes-1]);
}
}
recu=1;

do
{
printf("\n\n\tCONTROL DE PRODUCCION DE MOTORES\n");
printf("\n1.Calcular la suma total al año, de produccion de cada motor",164);
printf("\n2.Motor con mayor y menor produccion en los 12 meses");
printf("\n3.Total de motores fabricados al a%co",164);
printf("\n4.Corregir algún número de produccion");
printf("\n5.Consultar produccion total de un motor");
printf("\n6.Eliminar un Motor");
printf("\n7.Mes en el que hubo mayor produccion de motores");
printf("\nSeleccione la opción deseada: ");
scanf("%d",&op);
switch(op)
{
case 1: printf("\n\n\tTOTAL DE CADA MOTOR\n");
sumando();
desplegando();
break;
case 2:printf("\n\n\tMOTOR CON MAYOR Y MENOR PRODUCCION\n");

mayor=0;
menor=99999;
{
if(total[motor-1]!=0)
{
if(total[motor-1]>mayor)
{
mayor=total[motor-1];
strcpy(mayornombre,nombre[motor-1]);
}
if(total[motor-1]<menor)
{
menor=total[motor-1];
strcpy(menornombre,nombre[motor-1]);
}
}
}
printf("\nEl motor %s tuvo mayor produccion de %d",mayornombre,mayor);
printf("\nEl motor %s tuvo menor produccion dé %menor nombré, menor);
break;
case 3:printf("\n\n\tTOTAL DE MOTORES FABRICADOS AL A%cO\n",165);

sumat=0;
sumat=sumat+total[motor-1];
printf("\nTotal de motores fabricados: %d",sumat);
break;
case 4: printf("\n\n\tCORREGIR NUMERO DE PRODUCCION\n");

printf("\nNombre del motor que quieres corregir la produccion: ");
scanf("%s",&buscanombre);
indice=buscando(buscanombre);
printf("Numero de mes que quiere corregir: ");
scanf("%d",&nummes);
printf("Produccion correcta: ");
scanf("%d",&prodok);
produccion[indice][nummes-1]=prodok;
sumando();
desplegando();
break;
case 5:printf("\n\n\tCONSULTAR LA PRODUCCION DE UN MOTOR\n");

printf("\nNombre del motor que quieres consultar: ");
printf("\nEl motor %s tiene una produccion total de = %d",nombre[indice],total[indice]);
break;
case 6:printf("\n\n\tELIMINAR UN MOTOR\n");

printf("\nNombre del motor que quieres eliminar: ");

strcpy(nombre[indice],"ELIMINADO");
total[indice]=0;
{
produccion[indice][mes-1]=0;
}
desplegando();
break;
case 7:printf("\n\n\tMES CON MAYOR PRODUCCION DE MOTORES\n");

mayor=0;
{
{
if(produccion[motor-1][mes-1]>mayor)
{
mayor=produccion[motor-1][mes-1];
mayormes=mes;
strcpy(mayornombre,nombre[motor-1]);
}
}
}
printf("\n\nEl motor con mayor produccion mensual es %s con %d en el mes
%d",mayornombre,mayor,mayormes);
break;
default:printf("\n\nOpcion No valida");
break;
}
printf("\n\n[1]Regresar al menu\n[0]Salir del menu\nSeleccionar: ");
scanf("%d",&recu);
}
while(recu==1);
printf("\n\n[1]Calcular otro grupo\n[0]Salir del programa\nSeleccionar: ");

scanf("%d",&recu2);
}
while(recu2==1);
}
char buscando(char busnombre[20])

{
char i;
{
if(strcmp(busnombre,nombre[motor-1])==0)
i=motor-1;
}
return i;
}
void desplegando()
{
int mm;
{
{
printf("\n%s \t",nombre[motor-1]);
for(mm=1;mm<=12;mm++)
{
printf("%d\t ",produccion[motor-1][mm-1]);
}
printf("Total = %d",total[motor-1]);
}
}
}
void sumando()
{
int mm,sum=0;
{
sum=0;

for(mm=1;mm<=12;mm++)
{
sum=sum+produccion[motor-1][mm-1];
total[motor-1]=sum;
}
}
}

Apuntes de La Clase de Programacion Estructurada para Ing. Electrónica

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Apuntes de La Clase de Programacion Estructurada para Ing. Electrónica

Cargado por

Copyright:

Formatos disponibles

Instituto Tecnológico de Toluca

MTE. Andrea O. Nájera Avila ii

MTE. Andrea O. Nájera Avila iii

MTE. Andrea O. Nájera Avila iv

MTE. Andrea O. Nájera Avila 1

tiempo real, la programación de actividades,

MTE. Andrea O. Nájera Avila 2

Los diferentes tipos de software se encargan de

MTE. Andrea O. Nájera Avila 3

problemas 5. Prueba y depuración

MTE. Andrea O. Nájera Avila 4

Estas palabras no importan si se escriben en

Por ejemplo, el tipo de dato determina la

Los tipos de datos predefinidos son: numéricos,

Identificador Datos numéricos:

MTE. Andrea O. Nájera Avila 5

El resultado de una expresión es un dato

MTE. Andrea O. Nájera Avila 6

Es la representación gráfica de un algoritmo, se

Tabla 6 Simbología ANSI para Diagramas de Flujo

MTE. Andrea O. Nájera Avila 7

Ejemplo 5 Calcule y despliegue la cantidad de

Las estructuras condicionales simples permiten

Ejemplo 4 Solicitar tres calificaciones del alumno,

MTE. Andrea O. Nájera Avila 8

Ejemplo 7 Determinar cuál es el número mayor

El flujo de control del ciclo es el siguiente:

Se inicializa la variable de control, se evalúa la

Ejemplo 6 Calcular la suma de los primeros 10

Cuando una instrucción o conjunto de

Estas estructuras se clasifican en ciclos Contador

Es una estructura de control en la que se indica

MTE. Andrea O. Nájera Avila 9

Al contrario de los lenguajes de programación de

la tabla 7 se describe los diferentes tipos de

Tabla 7 Diferentes tipos de sentencias en un

Es la combinación del lenguaje natural (español,

El pseudocódigo se creó para superar las dos

MTE. Andrea O. Nájera Avila 10

Una estructura secuencial en Pseudocódigo se

Ejemplo 8 Diseñar un pseudocódigo que permita

Reglas generales para elaborar un

MTE. Andrea O. Nájera Avila 11

Ejemplo 9 Modificar el pseudocódigo anterior inicio inicio

MTE. Andrea O. Nájera Avila 12

• Ciclos con un número mientras (condición)

MTE. Andrea O. Nájera Avila 13

MTE. Andrea O. Nájera Avila 14

MTE. Andrea O. Nájera Avila 15

MTE. Andrea O. Nájera Avila 16

1.6 Diseño Ejemplo 21 Escribe una función en pseudocódigo

algorítmico de que devuelva el área de un rectángulo dada su

funcion area = area_rectangulo (base real, altura

En la cabecera de la función se debe indicar los

MTE. Andrea O. Nájera Avila 17

Ejercicios de Algoritmos Simples

Ejercicios de Algoritmos con estructuras de

2. Al recibir como dato un número entero,

5. Al recibir como datos tres números reales,

Ejercicios de Algoritmos con estructuras de

MTE. Andrea O. Nájera Avila 18

5. Los organizadores de un acto electoral

Acceso al Video Tema 1 Diseño de Algoritmos en