C - ALGORITMOS - C - 2010 v3 PDF

Abraham Sopla Maslucán
Facultad de Ingeniería de Sistemas y Mecánica Eléctrica

Universidad Nacional Toribio Rodríguez de Mendoza
Lima - 2017
La presentación y disposición de:
Introducion a la programación y lenguaje C
Son propiedad del autor, Abraham Sopla Maslucán
Ingeniero de Sistemas por la Universidad Nacional de Cajamarca
Maestro en Ciencias de la computación – Tecnológico de Monterrey, México.
Doctorando en Ingeniería de Sistemas e Informática, Universidad Nacional Mayor de San
Marcos, Perú.
Profesor nombrado en la EAP de Ingeniería de Sistemas, Facultad de Ingeniería de Sistemas y
Mecánica Eléctrica, Universidad Nacional Toribio Rodríguez de Mendoza. Fundador del Instituto
de ingeniería de software y del Instituto de estudios estadísticos y control de calidad.
abrahamsopla@gmail.com
abraham.sopla@untrm.edu.pe
Primera edición, diciembre 2017

Hecho el depósito legal en la Biblioteca Nacional del Perú Nº 2014-15924
Av. Los Rosales, carretera a Taquia - Telf. +51-941 986 484
Chachapoyas – Perú
Este documento ha sido publicado bajo la licencia Creative Commons

Reconocimiento-No comercial-Compartir bajo la misma licencia 2.5 Perú.
Para ver una copia de dicha licencia, visite:
http://creativecommons.org/licenses/by-nc-sa/2.5/pe/
A mi madre
Contenido
INTRODUCCIÓN ............................................................................................................................... 3
CAPÍTULO I............................................................................................................................................. 4
INDICACIONES PARA PRINCIPIANTES ..................................................................................................... 4
1.1 PSEUDOCÓDIGO ....................................................................................................... 4
1.2 ESTRATEGIA PARA RESOLVER PROBLEMAS CON ALGORITMOS ................................................ 4
1.2.1 Pasos para definir problemas ........................................................................................... 5
CAPÍTULO II............................................................................................................................................ 7
APUNTES DE LENGUAJE C ...................................................................................................................... 7
2.1 RECURSOS PARA ESCRIBIR PROGRAMAS EN C ................................................................... 7
2.2 INSTALACIÓN DE COMPILADOR Y EDITOR C/C++ ............................................................. 7
2.3 INSTALACIÓN RÁPIDA DEL PAQUETE COMPLETO ............................................................... 10
2.4 LIBRERÍAS ............................................................................................................ 12
2.5 VARIABLES Y CONSTANTES ........................................................................................ 13
2.5.1 Variable .............................................................................................................................. 13
2.5.2 Clasificación de variables................................................................................................. 13
2.6 ESTRUCTURA MÁS SIMPLE DE UN PROGRAMA EN C ........................................................... 13
2.6.1 La función main() ............................................................................................................. 14
2.7 DECLARACIÓN DE VARIABLES Y TIPOS DE DATOS ............................................................. 14
2.7.1 Declaración de variables.................................................................................................. 14
2.7.2 Tipo de datos .................................................................................................................... 14
2.7.3 Cadena de caracteres ...................................................................................................... 14
2.7.4 Modificadores de los tipos de variables......................................................................... 15
2.7.5 Los modificadores: signed, unsigned, long y short ..................................................... 15
2.7.6 Lectura y escritura de variables ..................................................................................... 15
2.7.7 Las constantes .................................................................................................................. 16
2.8 OPERADORES ........................................................................................................ 16
2.8.1 El paréntesis ...................................................................................................................... 16
2.8.2 El operador de asignación ............................................................................................... 16
2.8.3 Operadores aritméticos ................................................................................................... 16
2.8.4 Operadores relacionales .................................................................................................. 16
2.8.5 Operadores lógicos........................................................................................................... 16
2.8.6 Orden de precedencia de los operadores ..................................................................... 17
CAPÍTULO III......................................................................................................................................... 18
ESTRUCTURAS DE CONTROL ................................................................................................................ 18
3.1 ESTRUCTURAS SECUENCIALES .................................................................................... 18
3.2 EJERCICIOS CON ESTRUCTURAS SECUENCIALES ............................................................... 18
3.2.1 Formatos de lectura o impresión ................................................................................... 20
3.3 EJERCICIOS PROPUESTOS (GRUPO 1) ........................................................................... 22
4.1 EJERCICIOS PROPUESTOS (GRUPO 2) ........................................................................... 23
4.2 ESTRUCTURAS SELECTIVAS ........................................................................................ 24
4.2.1 La sentencia if ................................................................................................................... 24
4.2.2 Ejercicios con selección doble if else ............................................................................. 25
4.2.3 Ejercicios con if anidado .................................................................................................. 28
4.2.4 La sentencia switch .......................................................................................................... 31
4.2.5 Ejercicios con selección múltiple switch ........................................................................ 32
4.3 EJERCICIOS PROPUESTOS ......................................................................................... 36
4.4 ESTRUCTURAS REPETITIVAS ...................................................................................... 36
4.4.1 La sentencia for ................................................................................................................ 37
i
4.4.2 Ejercicios con bucle for .................................................................................................... 38
4.4.3 Ejercicios con for anidado ............................................................................................... 48
4.4.4 La sentencia while ............................................................................................................ 48
4.5 EJERCICIOS CON BUCLE WHILE ................................................................................... 49
4.5.1 La sentencia do-while ...................................................................................................... 62
CAPÍTULO IV ........................................................................................................................................ 65
FUNCIONES Y PROCEDIMIENTOS ......................................................................................................... 65
5.1 FUNCIONES........................................................................................................... 65
5.1.1 Argumentos de las funciones ......................................................................................... 66
5.1.2 Correspondencia entre argumentos .............................................................................. 66
5.1.3 Recursividad ...................................................................................................................... 66
5.1.4 Ejercicios con funciones y procedimientos ................................................................... 67
5.1.5 Ejercicios con funciones recursivas ................................................................................ 75
CAPÍTULO V ......................................................................................................................................... 82
ARREGLOS............................................................................................................................................ 82
6.1 INTRODUCCIÓN A LOS ARREGLOS ................................................................................ 82
6.2 VECTOR O ARREGLO DE UNIDIMENSIONAL ..................................................................... 82
6.3 EJERCICIOS CON VECTORES O ARREGLOS UNIDIMENSIONALES ............................................. 83
6.4 MATRICES A ARREGLO BIDIMENSIONAL ......................................................................... 96
6.5 EJERCICIOS CON MATRICES O ARREGLOS BIDIMENSIONALES ............................................... 98
6.6 EJERCICIOS PROPUESTOS ....................................................................................... 101
6.6.1 Vectores y matrices ........................................................................................................ 101
6.6.2 Cadenas de caracteres .................................................................................................. 101
BIBLIOGRAFÍA.............................................................................................................................. 102
APÉNDICE A ................................................................................................................................... 103
APENDICE B ................................................................................................................................... 104
GLOSARIO DE TÉRMINOS .......................................................................................................... 108
ii
Algoritmos y Lenguaje C
Introducción
Los estudiantes de las materias de lenguajes de programación, técnicas de programación,
algoritmos, estructuras de datos y de la información, sistemas operativos, entre otros, darán fe de
lo complicado que a veces resultan estas materias cuando no entendemos cómo es que la
computadora interpreta internamente las líneas de código escritas en algún lenguaje de
programación para realizar una actividad. ¿Quién tiene una noción de cómo se
an los datos en una hoja de cálculo Excel?, de manera que, luego de seleccionar una lista de datos,
pulsamos en el botón ordenar de la barra de herramientas y ya. ¿Quién sabe cómo la computadora
calcula el término n de una sucesión de números?, así podríamos mencionar muchos casos más.
Muchos operaramos las computadoras para resolver problemas sin antes hacer por lo menos
un pequeño plan acerca de la solución o tantear el camino a seguir para llegar a la solución de una
situación problemática dada. Aspectos que nos obligan a llevar largas horas frente a las
computadoras. Hay quienes creen que para ser buenos programadores hay que tener una
computadora en frente, pues esto no es cierto; más cierto, es que primero sepamos resolver los
problemas usando algoritmos en pseudocódigo o diagramas de flujo para luego llevarlos a la
computadora. En estos casos queda claro que el uso de la computadora pasa a segundo plano. En
consecuencia, para resolver un problema en computadora mediante un programa primero hay que
hacer un plan, en otras palabras un algoritmo y en eso queremos ahondar en este libro.
Los algoritmos que desarrollamos en este libro están representados usando pseudocódigo e
implementados en lenguaje C, evitando complicaciones en el uso del lenguaje. La claridad con que
están escritos hace que estos se puedan implementar fácilmente en otros lenguajes de programación
como java. Es así como se cumple nuestro propósito de ayudar al lector a dar el paso seguro del
algoritmo en pseudocódigo al programa, situación difícil para muchos principiantes. El objetivo es
que tengan un buen comienzo en este largo camino de la programación y que este sea el más corto
posible.
En los primeros capítulos del libro, encontramos conceptos suficientes para desarrollar e
implementar los algoritmos en lenguaje C. Se debe tener en cuenta que este documento no tiene
prioridad en el estudio del lenguaje C sino más bien en el uso del mismo en la resolución de
problemas comunes. Según el avance se trata ejercicios combinados con los diferentes tipos de
sentencias y grado de dificultad. Algunos de los ejercicios solucionados se encuentran propuestas
por otros autores, sin embargo, nuestro aporte está en proponer un método simple y efectivo para
solucionarlos, explicando desde el algoritmo que soluciona un problema hasta la construcción del
programa.
Este trabajo está orientado a estudiantes que se inician en educación superior, en carreras
de ingeniería mecánica, eléctrica, de sistemas, de computación e informática, electrónica, industrial,
etc., a quienes se les sugiere estudiar detenidamente los casos que presentamos. Claro está que nos
es lo ideal que se los copien o que se memoricen las soluciones que aquí proponemos, sino que usen
como guía para poder solucionar otros problemas. No más queda decir que, disfruten de este
material didáctico para fortalecer su formación académica y profesional.
Abraham Sopla Maslucán 3|Página

UNTRM: EAP de Ingeniería de sistemas
Chachapoyas
Capítulo I: Indicaciones para principiantes
Capítulo I
Indicaciones para
principiantes
1.1 Pseudocódigo
El pseudocódigo es un lenguaje general, de especificación de la solución del problema
mediante un algoritmo. Se considera como el paso anterior a la codificación. La ventaja es que, este
lenguaje puede ser traducido indistintamente y sin problemas a cualquier lenguaje de programación
de computadora. Un algoritmo es una secuencia de pasos lógicos que nos conducen hacia la solución
de un determinado problema.
Nosotros implementaremos los algoritmos usando un lenguaje común, el más sencillo para
todos. Adelantamos, si es necesaria la palabrería, será solamente para aclarar situaciones puntuales
orientados a la solución de dificultades. La idea en fin, es solucionar los problemas y así lo haremos,
sabiendo que lo más importante antes de empezar a escribir un programa, es necesario hacer el
algoritmo.
Lógicamente, si ya tiene el programa que soluciona un problema, ya no necesitamos hacer
el algoritmo, esto se da en las personas que tienen mucha experiencia en la programación,
definitivamente todos empezamos haciendo algoritmos; pero si de situaciones académicas se trata,
hacer el algoritmo teniendo el programa no necesita de ningún esfuerzo, solamente adherirse a
algunas reglas y términos de pseudocódigo, como inicio, fin, leer, asignar, imprimir.
1.2 Estrategia para resolver problemas con algoritmos
Cuando usted está resolviendo un examen de algoritmia o programación va donde el profesor a

cada instante y le pregunta y repregunta acerca de un problema que él se lo planteó, hasta es posible
que se olvide de que está rindiendo un examen, después apresuradamente concluye que la pregunta
está mal planteada, y raja, se molesta, tira la silla y se rinde ante el examen y comenta con sus
compañeros e insiste que el problema está mal planteado. Lógicamente, eso puede suceder; si para
usted es siempre así, quizás resulte que en el examen que acaba de desaprobar y después que el
profesor lo resolvió, usted diga, ¡claro la pregunta era esa!, ¡verdad, había una solución! En el
pregrado, nosotros, también lo hacíamos, así es que no se asuste.
La experiencia nos enseña, que hay personas que intentan dar respuestas a los problemas
sin entender de lo que se trata, esto requiere saber escuchar, leer y ver para poder abstraer un
problema y si esto no se hace bien lo que logramos es aumentar la dificultad del problema que se
supone vamos a solucionar. Ante un problema, hay que leer o escuchar cuantas veces sean
necesarias comprender el enunciado.
Cuantas veces hemos fracasado por no escuchar o saber leer bien, lo que implica entender.
Saber escuchar o leer es saber comprender. ¡Si no entiende un problema no se atreva a
resolverlo, mejor siga intentado hasta abstraerlo!
A continuación planteamos tres pasos a seguir, indispensables en el desarrollo de problemas
usando algoritmos y programación.

Chachapoyas
1.2.1 Pasos para definir problemas

1. Comprender el problema
Ante un problema, lea o escuche atentamente. Haga un bosquejo, tantee una posible
solución. Si no entiende el problema no continúe al paso 2.
2. Identificar las entradas, procesos y salidas

Entradas: Identifique los datos de ingreso al algoritmo o programa.
Procesos: Son las operaciones, cálculos matemáticos o procesos que se realizan con los
datos de entrada, a veces dependen del conocimiento de algún tema especifico, puede ser
matemáticas, estadística, química, biología, investigación de operaciones, contabilidad, etc.
Salidas: Son los resultados a imprimirse o mostrarse. Es la solución al problema. Son las
respuestas.
3. Comprobando
Consiste en simular para verificar si el algoritmo resuelve el problema realmente, se hacen
con los datos posibles de entrada, puede realizarse en papel y a mano.
Generalmente, los problemas con estructuras secuénciales y selectivas son más complicados
de comprender y fáciles de identificar las entradas, procesos y salidas, ya que las soluciones tratan
de al menos de operaciones matemáticas u procesos sencillos. Por otro lado los problemas donde se
usan bucles o repeticiones, son sencillos de comprender y difíciles de identificar sus entradas,
procesos y salidas.
Ejemplo 1: Escribir un algoritmo para un programa que calcule el área de un trapecio.

1. Comprendiendo el problema:
Luego de saber que el problema se trata de geometría y es un tema que todo estudiante de
educación superior conoce, el problema ya estaría comprendido de antemano, específicamente se
trata del cálculo del área de un trapecio.
2. Identificando las entradas, procesos y salidas
Entradas: Para calcular el área de un trapecio, se necesita saber el valor numérico de: la base
mayor, base menor y su altura.
Procesos: El proceso general a realizarse sería:
(basemayor basemenor)
area  *h
2
Otra forma sería a través de dos procesos
Proceso 1:
Luego
Proceso 2:
Salidas: La única salida sería el area , en ambos casos
3. Comprobando.
ENTRADAS SALIDAS
Basemayor Basemenor altura área
20 4 5 60
15 10 4 50
24 12 6 108

Chachapoyas
22 15 7 129,5
Algoritmo
Entero area, basemayor, basemenor, altura
Real Area
Inicio
Area ((basemayor+basemenor)/2)* altura
Imprimir area
Fin
NOTA: cuando no se declaran las variables se supone que estas ya están declaradas.
Ejemplo 2: Escriba un programa que calcule la suma de:

1/10+1/11+1/12+1/13+…+1/50
Usemos los pasos para definir el problema.
1. El problema trata de la suma de una serie de fracciones cuyo numerador es 1 y los
denominadores están en sucesión aritmética empezando del 10 y van aumentado de 1
en 1 hasta 50.
2. El proceso consiste en una simple suma, sucesiva.
3. La salida es la suma.
Algoritmo
Entero suma, a
Inicio
Suma0
Desde a=10 hasta a<=50 hacer
Sumasuma+(1/a)
Fin Desde
Imprimir Suma
Fin

Chachapoyas
Capítulo II: Apuntes de lenguaje C
Capítulo II
Apuntes de lenguaje C
2.1 Recursos para escribir programas en C
Para escribir el programa en lenguaje C podemos usar el editor de código llamado Sc1, obteniéndolo
de la dirección http://www.scintilla.org. Asimismo debe instalar el compilador Borland C++ 5.5
después de bajarlo de la dirección http://www.programacionenc.net/modules.php u otra que crea
conveniente1.
2.2 Instalación de compilador y editor C/C++
Paso 1: Instalando el compilador c++

1. Instalar bcc55.exe
2. Y ejecutar SetItUp.exe de C:\Archivos de programa\bcc55
3. Reiniciar la PC
Paso 2: Instalando el editor de c++

4. Sólo se descomprime borland55_ide.zip
Paso 3: Configuración del compilador
1. Una vez terminada la instalación, crea con el bloc de notas un archivo, y pega en el las líneas
siguientes, luego guarda el archivo con el nombre: bcc32.cfg, en la carpeta:
C:\Borland\BCC55\Bin
-I"C:\Borland\BCC55\Include"
-L"C:\Borland\BCC55\Lib;C:\Borland\BCC55\Lib\PSDK"
2. Es importante que cuando guardemos el archivo, en el campo Tipo escojamos la opción

“Todos los archivos” ya que de no hacerlo el archivo se guardará con otra extensión y no
funcionará correctamente:
1
Los pasos se describen en http://www.programacionenc.net

Chachapoyas
Figura 1: Guardando un archivo en Sc1
3. Luego, del mismo modo crea un archivo con el bloc de notas, que incluya las líneas
siguientes, guárdalo con el nombre: ilink32.cfg, en la carpeta: C:\Borland\BCC55\Bin
-L"C:\Borland\BCC55\Lib;C:\Borland\BCC55\Lib\PSDK"
4. Ahora vamos a realizar una configuración adicional, esto se hace para que puedas compilar
tus programas sin importar en donde se encuentre el archivo fuente. La configuración difiere
de acuerdo al sistema operativo que tengas, pues a partir de Windows 2000 se tiene una
diferente forma de manipular el fichero: autoexec.bat. Si usas Windows 95, 98 o Me abre
el archivo: autoexec.bat (que se encuentra en: C:\) con el Bloc de notas y añade la siguiente
línea al final del archivo:
set PATH=C:\Borland\BCC55\Bin;%PATH%
5. Una vez hecho esto reinicia el computador para que se actualice el archivo.
Nota: Si el archivo no es visible, debes ir a opciones de carpeta ó similar y buscar la opción

para mostrar los archivos ocultos y del sistema.
Si usas Windows 2000, XP ó superior. Ve hacia el Panel de Control, haz clic en el icono
Sistema y continuación en la ficha “Opciones avanzadas”.

Chachapoyas
Figura 2: Variable de entorno
6. Haz clic en el botón Variables de entorno y fíjate en el cuadro Variables del sistema.
Figura 3: Ubicando la variable del sistema
7. Selecciona la variable Path y pulsa el botón Modificar, ve al final del cuadro Valor de la
variable y pega lo siguiente ahí:
;C:\Borland\BCC55\Bin
8. Haz clic en Aceptar:
Figura 4: Modificando la variable entorno
Nota que se añade un punto y coma antes de todo, esto es para separar las variables del
sistema que ya están creadas, producto de la instalación del resto de programas de tu PC.

Chachapoyas
9. Listo, tu compilador está instalado y configurado correctamente.
2.3 Instalación rápida del paquete completo

1. Descomprime el archivo: borland55_ide.zip, en el directorio siguiente:
C:\Borland\BCC55\Bin, verás que aparecen los archivos: Sc1.exe y
SciTEGlobal.properties, el primero es el programa ejecutable, el segundo tiene las
opciones de configuración del programa (es importante que no modifiques el contenido de
este archivo)
2. Ahora ejecuta el programa Sc1.exe que está en C:\Borland\BCC55\Bin, verás el entorno

desde el cual programarás y ejecutarás tus programas.
Figura 5: Entorno general de Sc1

Prueba al compilador
Abre el programa: Sc1.exe escribe lo siguiente en él y guárdalo como:
#include<conio.h>
#include <stdio.h>
void main( ) {
printf("Hola mundo");
getch();
}
1. Presiona CTRL+F7, para compilar el programa, luego presiona F5, para ejecutarlo, verás
que tanto la compilación como la ejecución del programa aparecen en la parte inferior de la
pantalla, aunque también puede ejecutar el programa hello.exe, recién generado desde el
Explorador de Windows.
Abraham Sopla Maslucán 10 | P á g i n a

Chachapoyas
Figura 6: Hola mundo en el editor Sc1
Por ejemplo puede copiar el código de la solución del Ejercicio 21 de capítulo V. Los pasos para la
escritura, compilación y ejecución, en el editor Sc1, de éste código sería:
Primero: Escribimos el código tal como se muestra en la imagen.
Figura 7: Factorial de un número en Sc1
Paso 2: Guardamos el código con un nombre, en este caso factorial.cpp

Chachapoyas
Figura 8: Guardar un archivo en Sc1
Paso 3: Compilamos el programa apretando la tecla Ctrl+F7 y lo ejecutamos apretando la tecla F5.
2.4 Librerías
C
es un lenguaje pequeño. La funcionalidad de C se obtiene a través de un rico conjunto de
bibliotecas de funciones, llamados también librerías.
Por ejemplo la función sqrt pertenece a la librería math.
#include<math.h> //declaración de librería

{…
a=sqrt(25); //uso de la función sqrt en el programa principal
…
}
NOTA: Si usted intenta usar la función sqrt sin declarar la librería math, tendrá errores
justamente en la línea donde este escrita esta función. Otras funciones de la librería math
serían sin, cos, tan, etc.
Otras librerías son stdio, stdlib, etc. Las librerías y sus funciones están escritas en la ayuda
del lenguaje C.
¡Cada librería contiene sus propias funciones!
La función sqrt devuelve la raíz cuadrada de un número, ejm sqrt(25) regresa 5. La librería
stdio, es la que mas solemos usar para resolver problemas sencillos como los que veremos mas
adelante.

Chachapoyas
2.5 Variables y constantes

2.5.1 Variable
Es un identificador o nombre que sirve para almacenar valores de un tipo de datos, las variables
pueden ser de un máximo de 256 caracteres, el carácter inicial de las variables será una letra:
Ejemplo de variables: m1, suma2, da2s, etc.

Variables incorrectas: 1num, 25hora, 5p1, etc.
2.5.2 Clasificación de variables

Las variables pueden ser locales o globales.
Variables locales: son las que se declaran dentro de un procedimiento o función.
Variables globales: son aquellas que se definen fuera de las funciones. Pueden ser utilizadas en
cualquier función que se declaren después de ellas, mantienen su valor entre las distintas llamadas.
Tabla 1: Clasificación de las variables

Variables
Declaración Descripción
locales
Pueden ser inicializadas al momento
de ser declaradas. Sus valores
Tipo variable; desaparecen cuando se sale del
Automáticas
Tipo variable = valor_inicial bloque y se asignan al momento de
ingresar al bloque donde son
declaradas.
Pueden ser inicializadas al momento
Static Tipo variable; de ser declaradas. Sus valores no
Estáticas
Static Tipo variable = valor_inicial desaparecen cuando se salen del
boque donde han sido declaradas.
Tipo variable; Pueden ser inicializadas en la misma

Variables
forma que las variables locales
Globales Tipo variable = valor_inicial estáticas.
2.6 Estructura más simple de un programa en C

Lo explicamos a través de un ejemplo que imprime la suma de 4 y 7.
Tabla 2: Partes de un programa

Programa Partes del programa
#include<stdio.h>
#include<stdlib.h> Librerías
int x, n; Declaración de variables y funciones

int suma(int a, int b); que serán definidas por el usuario
Main() Inicio de la función principal.
{char c;
x=suma(4,7)
printf( " %d ",x ); Sentencias
exit (0);
}
int suma(int a, int b) Elaboración de la función

Chachapoyas
{int s;
s=a+b;
return s;
}
Nota importante
Del ejemplo anterior:
x y n son variables globales
c y s son variables locales.
a) C requiere un punto y coma al final de cada sentencia.
b) printf es una función estándar de C, que se usa para escribir o imprimir datos.
c) \n significa salto de línea.
d) % Salida formateada.
2.6.1 La función main() Una función tiene la forma:

Representa a la función principal; la
programación en C es en base a funciones.
Tipo nombre_de_la_funcion(parámetros)
{
Variables locales
Sentencias
}
2.7 Declaración de variables y tipos de datos
2.7.1 Declaración de variables

Las variables se escriben usando caracteres, inclusive los números con un tamaño máximo de 255
letras, siempre empezando con una letra. Ejemplo de variables son numero1, a, b, c, num6,
promedio, suma_números, a12, as12mn, etc. Vea que en todas las variables empezamos con letras.
La declaración de variables se hace de la siguiente manera:
Tipo Variable;
Ejemplo: int a;
En este caso la variable a de tipo entero, aceptará valores enteros, como 2, -20, 15, 0, -658,
etc.
2.7.2 Tipo de datos

Los tipos de datos simples están detallados en la Tabla 3.
Tabla 3: Los tipos de datos simples

Tipo Descripción
Char Carácter (letras)
Int Números enteros (positivos y negativos)
Float Números reales (con punto decimal)
Números de doble precisión, son representados con un
Double
mayor número de dígitos que los Double.
2.7.3 Cadena de caracteres

Se derivan de los de tipo carácter, se declaran así:

Chachapoyas
char mensaje[20];
En este caso la variable mensaje aceptará un texto o cadena cuya longitud será de 20 caracteres
como máximo. La variable mensaje es un vector o arreglo unidimensional de 20 espacios, en cada
espacio se almacena una letra de la cadena. Los arreglos se estudiarán al final de este libro.
2.7.4 Modificadores de los tipos de variables

Luego las variables pueden sufrir algunas modificaciones como las mencionamos a continuación y
los tipos de datos pueden quedar clasificados de la siguiente manera:
Tabla 4: Modificadores de los tipos de variable

Tipo Tamaño(bytes) Limite inferior Limite superior
Char 1 - -
unsigned char 1 0 255
short int 2 -32768 +32767
unsigned short int 2 - 65536
(long) int 4  231  1  231  1
Float 4  32 *1038  32 *1038
Double 8  1.7 * 10 308  1.7 * 10 308
Los tipos de datos básicos tienen varios modificadores que los preceden. Se usa un modificador para
alterar el significado de un tipo base para encajar con las necesidades de diversas situaciones.
2.7.5 Los modificadores: signed, unsigned, long y short

Signed, unsigned, long y short pueden ser usados con los tipos char e int. Aunque permitido, el uso
de signed en enteros es redundante porque la declaración de un entero por defecto asume un
número con signo.
2.7.6 Lectura y escritura de variables

El lenguaje C usa salida formateada. La función printf tiene un carácter especial para formateo %
un carácter enseguida define un cierto tipo de formato para una variable, por ejemplo d indica que
el resultado será entero como se indica en la tabla a continuación. Ejemplo.
Tabla 5: Lectura y escritura de variables

Formato Tipo dato de salida
%c Carácter
%s cadena de caracteres
%d Entero
%f Flotante
Por ejemplo:
printf(" %c %d %f ",ape, i, x);
La sentencia(s) de formato se encierra entre comillas " ", y enseguida las variables. Asegurarse que
el orden de formateo y los tipos de datos de las variables coincidan –debe existir correspondencia
entre las variables y los formatos- en este caso, el valor de ape será de tipo carácter, i entero
decimal, x de coma flotante.
scanf() es la función para entrar valores a variables. Su formato es similar a printf.
Por ejemplo:
scanf("%c %d %f %s",&nombre, &i, &x, cad);

Chachapoyas
Observar que se antepone & a los nombres de las variables, excepto a la variable de tipo cadena de
caracteres que es de tipo string.
2.7.7 Las constantes

Una constante es una variable, a la cual se le asigna un valor y este no puede cambiar. Las constantes
se declaran usando la palabra clave const, por ejemplo:
const a = 6;
Nota: Es usual inicializar una constante con un valor, ya que no puede ser cambiada de alguna otra
forma.
2.8 Operadores
2.8.1 El paréntesis
Los paréntesis se usan para agrupar datos. Es decir, por ejemplo, no es lo mismo, 4+8/2 que
(4+8)/2, si evaluamos en el primer caso tendremos como resultado 8 y en el otro 6, e ahí la
importancia del paréntesis bien usado.
2.8.2 El operador de asignación

El operador de asignación es el “=”,
por ejemplo:
m=4; letra='y';
Se lee:
El número 4 es asignado a la variable entera m,
El carácter y es asignado a la variable alfanumérica letra.
2.8.3 Operadores aritméticos

Operadores aritméticos más usuales: Para: a=5 y b=3.
Tabla 6: Operadores aritméticos

Símbolo Descripción Ejemplo Valor
+ Suma a+b 8
- Resta a-b+2 4
* multiplicación a*b-1 14
/ División a/b+3 4.67
% Módulo a%b 2
2.8.4 Operadores relacionales

Para: a=5 y b=3
Tabla 7: Ejemplos con operadores relacionales

Símbolo Descripción Ejemplo Valor Explicación
< Menor que a<b 0
Cero: si es falso
> Mayor que a>b 1
<= Menor o igual que a<=b 0
Cualquier otro valor
>= Mayor o igual que a>=b 8
distinto de 0, si es
== Igual que a==b 0
verdadero
!= Distinto que a!=b 15
2.8.5 Operadores lógicos

Los operadores lógicos se usan con sentencias condicionales o relacionales, los operadores básicos
lógicos son:

Chachapoyas
Para: a=5 , b=3, c=5 y d=3.
Tabla 8: Ejemplos con operadores lógicos

Símbolo Descripción Ejemplo Valor
&& Y (and) (a<b) &&(c>d) 0 (falso)
|| O (or) (a>b)|| (c<d) 9 (verdadero)
! Negación (not) !(a<b) 7 (verdadero)
2.8.6 Orden de precedencia de los operadores

Hay que ser cuidadosos con el significado de expresiones tales como a + b * c, dependiendo de lo
que se desee hacer por ejemplo:
Para a=5, b=3 y c=5

a+b*c = 20
(a + b) * c = 40
a + (b * c) = 20
Tenga en cuenta los tres resultados anteriores, y vea la importancia del paréntesis, dependiendo
de la operación que desea realizar será utilizado. Sin embargo todos los operadores tienen una
prioridad:
• Los operadores de mayor prioridad son evaluados antes que los que tienen menor prioridad.
• Los operadores que tienen la misma prioridad son evaluados de izquierda a derecha, por lo
que:
En a + b – c es evaluado como (a + b) – c.
En a - b – c es evaluado como (a - b) – c.
Tabla 9: Prioridad de los operadores

Prioridad Operador
Más alta
()
^ * / %
+ -
< <= > >=
== !=
Más baja &&
||
Los () son símbolos de agrupación.
De acuerdo al cuadro anterior

a < 10 && 2 * b < c
Es interpretado como:
(a < 10) && ( (2 * b) < c )

Chachapoyas
Capítulo III: Estructuras de control
Capítulo III
Estructuras de control
3.1 Estructuras secuenciales

Las estructuras secuenciales están basadas en sentencias de asignación simples. A continuación
un ejemplo de algoritmo con estructura secuencial que suma dos números.
Algoritmo
Entero a,b,suma
Inicio
a5;
b12;
suma=a+b;
suma=suma+b;
Imprimir suma;
Fin
Programa
#include<conio.h>
#include<stdio.h>
int x;
main()
{int a,b,suma;
a=5;
b=12;
suma=a+b;
suma=suma+b;
printf("%d",suma);
getch();
}
En este caso, la evaluación se hace línea por línea, siguiendo un orden. En el caso anterior valor
de suma que se imprime es 29.
3.2 Ejercicios con estructuras secuenciales

A veces, los problemas que necesitan de algoritmos que implican estructuras secuenciales
son los más complejos de abstraer, pero los más sencillos de identificar procesos que nos llevarán
a su solución.
En algunos algoritmos se omite la declaración de variables, en el caso de que el algoritmo
no sea complicado. Además para el pseudocódigo consideramos dos tipos de variables:
alfanuméricos en las cuales se almacenaran datos de tipo texto y los numéricos para los datos
de tipo número (real, entero). En cuanto a los valores booleanos se tendrá en cuenta el cero en

Chachapoyas
caso de que el valor de la variable sea FALSO y cualquier otro número cuando el valor es
VERDADERO. Cuando se declaran variables no se tiene en cuenta la ortografía o la gramática.
EJERCICIO 01 Hacer el rastreo manual para:
a = 2
a = a + 1
b = a * 2
b = b - 1
c = a + 2 * b
Presentar “c”
Rastreo: Para el rastreo hay que asignarle a cada línea un número, de la siguiente manera, de
antemano ya nos habremos fijado que el valor de salida es el de la variable c, el problema sería
saber el valor de esta variable c que se mostrará al final o en la línea 6.
1) a = 2
2) a = a + 1
3) b = a * 2
4) b = b - 1
5) c = a + 2 * b
6) Presentar “c”
//Seguimiento línea por línea

Línea 1: a=2
Línea 2: a=2+1=3
Línea 3: b=3*2=6
Línea 4: b=6-1=5
Línea 5: c=3+2*5=13
Línea 6: Se presenta 13
El valor de la variable c será 13.
Hacer el algoritmo para escribir un programa que evalúe la expresión

EJERCICIO 02 xw
2w
Solución: observe que los valores de ingreso serán para las variables x, w.
Variables
Resultado: valor de la expresión luego de ser evaluada.
x : guarda un valor numérico ingresado.
w : guarda un valor numérico ingresado.
Algoritmo
Real Resultado, x, w
Inicio

Chachapoyas
Leer x,w
Resultado(x+w)/(2*w)
Mostrar Resultado
Fin
Programa
#include<stdio.h>
#include<conio.h>
main(void)
{float resultado,x,w;
//se escriben dos valores separados por la barra espaciadora
printf("ingrese el valor de x , también de w \n");
//se leen o capturan dos valores escritos en las variables x y
w.
scanf("%f %f",&x,&w);
//Se evalúa la expresión y el resultado es asignado a la
variable resultado.
resultado=(x+w)/(2*w);
//se imprime el valor de la variable resultado.
printf("%f",resultado);
getch();
}
Cometario:
Printf: Permite escribir en pantalla un mensaje o imprimir un resultado, producto de un proceso.
Scanf: Permite capturar los valores de los datos ingresados, escritos a través de un printf.
//Evita la ejecución de esta línea, se usa para escribir comentarios, como aclaraciones,
recomendaciones, explicaciones, etc.
/* */ Si necesita escribir un comentario extenso, es decir de varias líneas, puede usarlo de la
siguiente manera.
/*...
...Comentario...
... */
\n Permite escribir datos en la línea siguiente (salta una línea). Si se escribe \n\n\n
saltaremos 3 líneas, \n\n\n\n saltaremos hasta la cuarta línea siguiente para imprimir o escribir
el siguiente dato.
3.2.1 Formatos de lectura o impresión
%d Si el dato que se imprimirá o leerá será un número entero

%f Si el dato que se imprimirá o leerá será un número real
%c Si el dato que se imprimirá o leerá será un carácter.
%s Si el dato que se imprimirá o leerá será una cadena
Explicación:
Estas dos líneas de código:
printf("ingrese el valor de x , también de w \n");

scanf("%f %f",&x,&w);
Pueden ser escritas en cuatro líneas de la siguiente manera, con la diferencia de que la forma de
capturar de los datos cambia. Quedando de la siguiente manera.

Chachapoyas
printf("ingrese el valor de x \n");

scanf("%f ",&x);
printf("ingrese el valor de w \n");
scanf("%f ",&w);
Hacer el algoritmo para escribir un programa que evalúe la expresión

EJERCICIO 03 3x 2  4 y 2
Variables
x : guarda un valor numérico ingresado,
y : guarda un valor numérico ingresado,
resultado : guarda el valor resultado de la expresión.
Algoritmo
Real x, y, resultado
Inicio
Leer x, y
resultadoraizcuadrada(3*x*x+4*y*y)
Mostrar resultado
Fin
Programa
#include<stdio.h>
#include<math.h>
#include<conio.h>
main(void)
{int x,y;
float resultado;
printf("ingrese el valor de x, también y \n");
scanf("%d %d",&x,&y);
resultado=sqrt(3*x*x+4*y*y);
getch();
}
Comentario
resultado=sqrt(3*x*x+4*y*y);
Lo anterior puede reemplazarse por una sola línea de código como:
printf("%f", sqrt(3*x*x+4*y*y));
A menor cantidad de líneas en el código, el programa es mejor.
Y el programa quedaría con una línea de menos.
#include<conio.h>
#include<stdio.h>
#include<math.h>
main(void)
{int x,y;
printf("ingrese el valor de x, también y \n");
scanf("%d %d",&x,&y);

Chachapoyas
printf("%f", sqrt(3*x*x+4*y*y));
getch();
}
Hacer el algoritmo para escribir un programa que imprima el subtotal y el

EJERCICIO 04 I.G.V. de una transacción comercial, siendo el I.G.V. el 19% del total. El
dato de ingreso será el total.
Variables
total : guarda el valor del total ingresado
subtotal: guarda el valor del subtotal calculado
igv : guarda el valor del total ingresado
Algoritmo
Real total, subtotal, igv
Inicio
Leer total
Igv  0.19*total
Subtotal total-igv
Mostrar subtotal, igv
Fin
Programa
#include<conio.h>
#include<stdio.h>
main()
{float total,subtotal,igv;
printf("ingrese el total a pagar: ");
scanf("%f",&total);
igv=0.19*total;
subtotal=total-igv;
printf("total: %f, subtotal: %f, igv: %f",total,subtotal,igv);
getch();
}
3.3 Ejercicios propuestos (grupo 1)

1) Evaluar las expresiones que se muestran a continuación:
a) 48/2*6
b) 6*48/2
c) 48/(2*6)
d) 55 / 3 + 20 mod 6
e) 4 * 6 / 2 - 18 / 2
f) 6 * 15 / 2 / (4 - 2)
g) 8 == 16 || 7 != 4 && 4 < 1
h) (4 * 3 < 6 || 3 > 5 - 2) && 3 + 2 < 12
2) Suponiendo que a, b, c son variables enteras que tienen asignados los valores a=8, b=3, c=-
5 determinar el valor de las siguientes expresiones:
a) a+b+c
b) 2 * b + 3 * (a-c)
c) a/b
d) a mod b

Chachapoyas
e) a/c
f) a div b
g) a * b /c
h) a * (b/c)
i) (a*c) mod b
j) a * (c mod b)
3) Suponiendo que previamente se ha realizado la declaración x=7, y=2: enteros, calcular el

valor de la variable y tras evaluar cada una de las siguientes sentencias de asignación:
a) y = -2 + --x
b) y += 2
c) y = (y == x)
d) y = y++ - x
4) Escribir un programa que pida el valor de un número entero y muestre en pantalla el cociente
y el resto de la división entera entre ambos.
5) Escribir un programa que pida cierta cantidad en segundos y la muestre en pantalla en el
formato “hh:mm:ss”, es decir horas, minutos y segundos.
4.1 Ejercicios propuestos (grupo 2)

1) Qué tipo de datos resulta más adecuado para representar cada uno de los datos siguientes:
a. El sueldo de un trabajador,
b. La edad de una persona,
c. El número de hijo,
d. El estado civil,
e. El estado de caducado o no de un producto,
f. El Nº de teléfono,
g. La dirección.
2) Escribir un programa para calcular la distancia recorrida por un objeto en movimiento
rectilíneo uniforme. Donde e=v*t, e=espacio, v=velocidad, t=tiempo.
3) Escribir un programa para calcular la distancia recorrida por un objeto en un movimiento
rectilíneo acelerado. Dado: t=tiempo, Vo=Velocidad Inicial, Vf=Velocidad final,
g=Aceleración. El modelo matemático es el siguiente:
1
𝐸 = 𝑉𝑜𝑡 + 𝑔𝑡 2
2
𝐾𝑘 3 𝑥 5
4) Evalué la expresión , donde: K es una constante equivalente a 0.007, x es una variable
𝐾+𝑥
cuyo valor pertenece a {24.7, 60}
5) Escribir un programa que pida una cantidad en soles y la convierta en euros.
6) A partir del programa anterior escribir uno que pase de soles a libras esterlinas, pidiendo
primero el registro del valor de una libra en soles.
7) Escribir un programa que pida los datos necesarios y calcule el área y el perímetro de la figura
indicada:
a) Un cuadrado b) Un rectángulo c) Un triángulo d) Un círculo.
8) Escribir un programa para calcular el importe de una venta en un supermercado. El usuario
debe indicar el nombre del producto, el precio por unidad y cantidad de unidades. El programa
mostrará por pantalla el nombre del producto, la cantidad de unidades vendidas y el precio
total. Preste especial atención a qué tipo de dato resulta más adecuado para representar
cada dato.
9) Escribir un programa que calcule la nómina de un trabajador de la manera siguiente. El
trabajador cobra un precio fijo por hora y se le retiene un 5% en concepto de seguro social.
El programa debe pedir el nombre del trabajador, las horas trabajadas y el precio que cobra
por hora. Como salida debe mostrar el sueldo bruto, la retención y el sueldo neto.

Chachapoyas
4.2 Estructuras selectivas
4.2.1 La sentencia if
Las tres formas como se puede emplear la sentencia if son:
Tabla 10: Sentencia if en C

Sentencias if Descripción
if (condición) If simple: Si condición es verdadera

{Sentencias1}; entonces se ejecutan las sentencias1.
If (condición)
{Sentencias1}; If doble: Si condición es verdadera se
entonces se ejecutan las sentencias1, en
else caso contrario se ejecutan las sentencias2.
{Sentencias2};
if (condición1)
{Sentencias1};
else if (condición2)
{Sentencias2}; If anidado: La sentencia que está asociada
a la palabra reservada else se ejecuta si
else if (condición3)
todas las condiciones de la estructura if
{Sentencias3}; fueron falsas.
...
else
{SentenciasN};
Tabla 11: Sentencia si en pseudocódigo

Sentencias Si Descripción
Si condición entonces Condicional simple: Si la condición es

Sentencias1; verdadera entonces se ejecutan las
Fin Si sentencias1.
Si condición entonces
Sentencias1; Condicional doble: Si la condición es
Sino verdadera se ejecutan las sentencias1, en
Sentencias2; caso contrario se ejecutan las sentencias2.
Fin Si
Si condición1
Sentencias1;
Sino Si condición2
Condicional anidado: La sentencia que
Sentencias2; está asociada a la palabra reservada sino se
Sino Si condición3 ejecuta si todas las condiciones de la
estructura if fueron falsas.
Sentencias3;
...
Sino

Chachapoyas
SentenciasN;
Fin Si
Hacer el algoritmo para escribir un programa que indique si un número

EJERCICIO 05 ingresado por el teclado es positivo.
Variables
Nu2m: Número que se ingresa por el teclado
Algoritmo
Entero num
Inicio
Leer num
Si num>0 entonces
Imprimir num es positivo
Fin Si
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int num;
printf("ingrese un número.... ");
scanf("%d",&num);
if(num>0)
printf("el número es positivo");
getch();
}
4.2.2 Ejercicios con selección doble if else
EJERCICIO 06 Hacer un algoritmo para un programa que calcule el pago que hacen un
grupo de personas para ver una película teniendo en cuenta que si el
grupo es menor de 8 personas el pago es de 1.5 soles por persona y para grupos de 8 personas
o más el pago es 0.5 soles por persona.
Variables
num: Número que se ingresa por el teclado e indica la cantidad de personas
Pago: El valor del pago que se calculará.
Algoritmo
Real num, pago
Inicio

Chachapoyas
Leer num
Si num>=8 entonces
Pago=0.5*num
Sino
Pago=1.5*num
Fin Si
Imprimir pago
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{float pago;
int num;
printf(" ingrese número de personas ");
scanf("%d",&num);
if(num<8)
pago=1.5*num;
else
pago=0.5*num;
printf("el pago es %f",pago);
getch();
}
Hacer un algoritmo para un programa que convierta un número mayor

PROGRAMA 07 de 10000, dado en segundos a horas minutos y segundos. Ejemplo 12015
segundos es equivalente a 3 horas, 20 minutos, 15 segundos.
Variables
num : valor numérico entero ingresado,
horas : cantidad de horas,
rmin : cantidad de segundos, resto de num,
min : cantidad de minutos,
seg : cantidad de segundos, resto de min.
Algoritmo
Entero num, horas, rmin, min
Inicio
Leer num
Si num>10000 entonces
Horascociente(num,3600)
Rminresto(num,3600)
Mincociente(rmin,60)
Segresto(rmin,60)
Mostrar horas, min, seg
Fin Si
Fin
Programa

Chachapoyas
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
main(void)
{int num, rmin, seg;
div_t horas,min;
printf("ingrese un número mayor de 10000 ........ ");
scanf("%d",&num);
if(num>10000)
{horas=div(num,3600);
rmin= num % 3600;
min=div(rmin,60);
seg=rmin%60;
printf("%d HORAS\n",horas);
printf("%d MINUTOS\n",min);
printf("%d SEGUNDOS\n",seg);
}
getch();
}
En el Instituto Superior Pedagógico Toribio Rodríguez de Mendoza, los

EJERCICIO 08 pagos por curso desaprobado son de 20 soles, con un cargo máximo de
120 soles independiente del número de cursos tomados. Ejemplo si un alumno desaprueba 3
cursos pagaría 60 soles, mientras que uno que desaprueba 8 cursos paga 120 soles. Escriba el
algoritmo de un programa en el que las entradas sean el número de cursos desaprobados y la
salida sea el valor del pago total que el alumno haga por los cursos desaprobados.
Variables
x : Número de cursos
Pago : guarda el pago calculado
Algoritmo
Entero x
Inicio
Leer x
Si x<6 entonces
Imprimir 20*x
Sino
Imprimir el pago es 120 soles
Fin si
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int x;
printf("ingrese el número de cursos desaprobados \n");
scanf("%d",&x);
if(x<=6) printf("el pago será de %d soles ",x*20);
else printf("el pago será de 120 soles");
getch();
}

Chachapoyas
De los estudiantes que se matriculan en la Universidad, los ex soldados

EJERCICIO 09
pagan 30 soles por curso en el que se matriculen, mientras que los demás
(regulares), pagan 50 soles por curso. Diseñe el algoritmo para escribir un programa en el que el
usuario introduce los datos del estudiante (ex soldado o regular) y el número de cursos y las
salidas sean la categoría del estudiante (ex soldado o regular), número de cursos y los costos
totales por los cursos a llevar.
Variables
categoria : Asume los valores exsoldado o regular.
nc : Número de cursos.
pago : Pago por el total de cursos matriculados
Algoritmo
Alfanumerico categoria
Entero nc, pago
Leer categoría
Leer nc
Inicio
Si categoría  “exsoldado” entonces
Pagonc*30
Imprimir “ex soldado”, nc, pago
Sino
Pagonc*50
Imprimir “regular”, nc, pago
Fin Si
Fin
Programa
#include<stdio.h>
#include<conio.h>
main(void)
{int x,pago,nc;
printf("ingrese la categoría: 1) Ex soldado Otro)
Regular\n");
scanf("%d",&x);
printf("ingrese el número de cursos\n");
scanf("%d",&nc);
if(x==1)
printf("categoría: ex soldado, %d cursos, pago: %d soles
",nc,nc*30);
else
printf("categoría: regular, %d cursos, pago: %d soles
",nc,nc*50);
getch();
}
4.2.3 Ejercicios con if anidado
En la ciudad de Chachapoyas, una agencia de seguros para automóviles

EJERCICIO 10
asigna costos basados en el sexo y la edad del conductor. Los varones
menores de 25 años pagan los precios más altos, 1000 soles. Los hombres de 25 años o más
años pagan 700 soles. Las mujeres de menos de 21 años pagan 800 soles, mientras que las

Chachapoyas
mujeres de 21 años o más pagan 500 soles. Escribir el algoritmo del programa que imprima la
edad del conductor, sexo, y el pago correspondiente para los clientes de la aseguradora.
Variables
sexo : Almacena 1 (masculino), 2 (femenino).
edad : Edad del cliente.
pago : valor del pago que hará el cliente
Algoritmo
Entero sexo, edad, pago
Inicio
Leer sexo, edad
Si sexo”masculino” entonces
Si edad<25 entonces
Pago1000
Imprimir edad, sexo, pago
Sino
Pago700
Fin Si
Si no
Si edad<21 entonces
Pago800
Sino
Pago500
Fin si
Fin si
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int x,pago,edad;
printf("ingrese el sexo: 1. Masculino 2.Femenino \n");
scanf("%d",&x);
printf("ingrese la edad \n");
scanf("%d",&edad);
if(x==1)
if(edad<25)
printf("edad: %d años, sexo: masculino, pago: %d soles
",edad,1000);
else
printf("edad: %d años, sexo: masculino, pago: %d soles
",edad,700);
else
if(edad<21)
printf("edad: %d años, sexo: femenino, pago: %d soles
",edad,800);
else

Chachapoyas
printf("edad: %d años, sexo: femenino, pago: %d soles

",edad,500);
getch();
}
En el algoritmo se usan if anidados, en el programa no es necesario, sin embargo también

se puede usar if anidados.
Escribir el algoritmo para un programa que solicita se le ingrese un

EJERCICIO 11 número. Si el número es positivo debe escribirse el número y junto
a él positivo (15 POSITIVO). Si el número es cero (0 CERO); Si es
negativo debe escribirse el número y junto a el negativo (-5 NEGATIVO).
Ejemplo
10 Positivo
0 Cero
-15 Negativo.
Variables
numero : Número ingresado por el teclado
Algoritmo
Entero numero
Inicio
Leer numero
Si número >=0 entonces
Si número>0 entonces
Imprimir número, “POSITIVO”
Sino
Imprimir número, “CERO”
Fin si
Sino
Imprimir número, “NEGATIVO”
Fin Si
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int num;
printf("ingrese un número\n");
scanf("%d",&num);
if(num>=0)
if(num>0)
printf("%d POSITIVO",num);
else
printf("%d CERO",num);
else
printf("%d NEGATIVO",num);
getch();
}

Chachapoyas
En una tienda donde se venden sillas, si se compran más de 8 el costo

EJERCICIO 12
por cada una es de 10 soles; entre 4 y 8 es de 11 soles cada una, si
la compra es menor de 4 el costo es de 15 soles cada una. Escriba el algoritmo para escribir un
programa y saber cuánto pagará un cliente según el número de sillas que compra. Debe
imprimirse el número de sillas que compra y el total a pagar.
Variables
num : cantidad de sillas compradas,
tot : Total a pagar.
Algoritmo
Entero num, tot
Inicio
Leer num, tot
Si num<=8 entonces
Si num<=4 entonces
Tot =num*15
Sino
tot=num*11
Fin si
Sino
tot=num*10
Fin si
Imprimir tot
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int num,tot;
printf("ingrese un número de sillas\n");
scanf("%d",&num);
if(num<=8)
if(num<=4)
tot=num*15;
else
tot=num*11;
else
tot=num*10;
printf("%d soles",tot);
getch();
}
4.2.4 La sentencia switch

Con la estructura if ... else if se pueden realizar comprobaciones múltiples, sin embargo esto
puede tornarse en confusiones muy serias para los que leen los programas, inclusive para uno
mismo que ojee su código después de un buen tiempo de vacaciones. La sentencia de bifurcación
múltiple switch tiene la solución. Sean Constante1, Constante2, Constante3, etc. valores de la
variable opción, los mismos que pueden ser números o caracteres.

Chachapoyas
Tabla 12: La sentencia switch en código C y pseudocódigo

Código C Pseudocódigo
switch (opción) Según opción sea
{ caso constante1
case constante1: Sentencias
Sentencias break;
break; caso constante2
Sentencias break;
break; caso constante3
Sentencias break;
break; ...
... defecto
default: Sentencias
Sentencias Fin Según
}
4.2.5 Ejercicios con selección múltiple switch
Hacer un algoritmo para escribir un programa que devuelva el nombre del

EJERCICIO 13
día de la semana siguiendo un orden de correspondencia (1, 2, 3…7) para
(lunes, martes, miércoles… domingo) respectivamente.
Variable
Número : Número correspondiente al día de la semana.
Algoritmo
Entero numero
Inicio
Leer número
Segun numero sea
Case 1
Imprimir " LUNES"
Case 2
Imprimir "MARTES"
Case 3
Imprimir "MIERCOLES”
Case 4
Imprimir "JUEVES"
Case 5
Imprimir "VIERNES"
Case 6
Imprimir "SABADO"
Case 7
Imprimir "DOMINGO”

Chachapoyas
Sino
Imprimir "SOLO NÚMEROS ENTRE 1 Y 7........ "
Fin Segun
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int dia;
printf("ingrese un número entre 1 y 7........ ");
scanf("%d",&dia);
switch(dia)
{
case 1:
printf(" LUNES \n");
break;
case 2:
printf(" MARTES \n");
break;
case 3:
printf(" MIÉRCOLES\n");
break;
case 4:
printf(" JUEVES\n");
break;
case 5:
printf(" VIERNES\n");
break;
case 6:
printf(" SABADO\n");
break;
case 7:
printf(" DOMINGO\n");
break;
default:
printf(" SOLO NÚMEROS ENTRE 1 Y 7........ ");
}
getch();
}
Hacer el algoritmo para un programa que calcule:

• El valor del área de un triángulo, dada la base y la altura.
EJERCICIO 14 • El valor de la base de un triángulo dada la altura y el área.
• El valor de la altura de un triángulo dada la base y el área.
Variables
opcion : 1 para calcular el área, 2 para calcular la base, 3 para calcular la altura.
Base : Valor de la base del triangulo
Altura : Valor de la altura del triangulo
Area : Valor del área del triangulo
Algoritmo
Entero opcion, base, altura, area
Inicio
Leer opcion
Segun opción sea

Chachapoyas
Caso 1
Leer base, altura
area(base*altura)/2
Imprimir area
Caso 2
Leer area, altura
Base2*area/altura
Imprimir base
Caso 3
Leer area,base
Altura2*area/base
Imprimir altura
Caso contrario
Imprimir " Eso es todo amigo”
Fin Según
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int operacion;
printf("EJERCICIOS DE LOS TRIÁNGULOS ........ \n");
printf("============================ \n\n\n");
printf("1 para calcular el área de un triángulo \n");
printf("2 para calcular la base \n");
printf("3 para calcular la altura \n\n");
printf("ingrese una opción ........ ");
scanf("%d",&operacion);
switch(operacion)
{
float area, altura, base;
case 1:
printf("AREA DEL TRIÁNGULO \n");
printf("ingrese la base ........ ");
scanf("%f",&base);
printf("ingrese la altura ........ ");
scanf("%f",&altura);
printf("el area del triángulo es %f ",base*altura/2);
break;
case 2:
printf("BASE DE UN TRIÁNGULO \n");
printf("ingrese el area ........ ");
scanf("%f",&area);
printf("la base de area del triángulo es %f ",2*area/altura);
break;
case 3:
printf("ALTURA DE UN TRIÁNGULO \n");
scanf("%f",&area);
scanf("%f",&base);

Chachapoyas
printf("la base de area del triángulo es %f ",2*area/base);

break;
default:
printf(" nada mas ........ ");
}
getch();
}
EJERCICIO 15 Hacer el pseudocódigo para escribir un programa que calcule: el área de

un triángulo, un trapecio, un rectángulo y el área de un triángulo en función de sus lados.
Algoritmo
En este caso usted puede guiarse del algoritmo del ejercicio 14 y escribir el proceso matemático
respectivo para obtener el algoritmo buscado.
Programa
#include<conio.h>
#include<stdio.h>
#include<math.h>
main(void)
{int operacion;
printf("CALCULO DE AREAS ........ \n");
printf("============================ \n\n\n");
printf("1 para calcular el área de un triángulo \n");
printf("2 para calcular el área de un trapecio \n");
printf("3 para calcular el área de un rectángulo \n");
printf("4 para calcular el área de un triángulo en función de sus
lados\n\n\n");
printf("ingrese el número que le corresponde al área que desea
calcular ........ ");
switch(operacion)
{
case 1:
int bt,ht;
scanf("%d",&bt);
scanf("%d",&ht);
printf("el area del triángulo es %d ",bt*ht/2);
break;
case 2:
int bmayt,bment,at;
printf("AREA DEL TRAPECIO \n");
printf("ingrese la base mayor ........ ");
scanf("%d",&bmayt);
printf("ingrese la base menor ........ ");
scanf("%d",&bment);
printf("ingrese la altura del trapecio ........ ");
scanf("%d",&at);
printf("el area del trapecio es %d
unidades",((bmayt+bment)/2)*at);
break;
case 3:
int ac,hc;
printf("AREA DE UN RECTANGULO \n");
printf("ingrese la ancho ........ ");

Chachapoyas
scanf("%d",&ac);
printf("ingrese la alttura ........ ");
scanf("%d",&hc);
printf("el area del cuadrado es %d ",ac*hc);
break;
case 4:
int a,b,c;
float s;
printf("ÁREA DEL TRIÁNGULO EN FUNCIÓN DE SUS LADOS \n");
printf("ingrese lado a ........ ");
scanf("%d",&a);
printf("ingrese lado b ........ ");
scanf("%d",&b);
printf("ingrese lado c......... ");
scanf("%d",&c);
s=(a+b+c)/2;
printf("el area del triángulo es %f unidades",sqrt(s*(s-a)*(s-
b)*(s-c)));
break;
default:
}
getch();
}
4.3 Ejercicios propuestos

1) Escribir un programa que pida dos números y muestre por pantalla el mayor. Una versión
mejorada informará de si los dos números son iguales.
2) Escribir un programa que pida un número e indique si se trata de un número par impar.
3) Escribir un programa que pida una nota e imprima por pantalla la calificación en formato
“aprobado” o “desaprobado” según si la nota es mayor o menor que 10.5.
4) Escribir un programa que permita jugar a doble o nada: El jugador apuesta una cantidad y
tira una moneda. Si sale cara obtiene el doble de la cantidad apostada. Si sale cruz la pierde
todo.
5) Escribir un programa que lea tres valores enteros y muestre por pantalla el máximo y el
mínimo de ellos.
6) Escribir un programa que pida un número entero y determine si es múltiplo de 2 y de 5 al
mismo tiempo.
7) Escribir un programa que pida la nota de un examen (un número real entre 0 y 20) e imprima
por pantalla la calificación en formato “Suspenso”, si la nota es menor que 10.5, “Aprobado”
si está entre 10.5 inclusive y 12 sin incluir, “Notable” si está entre 12 inclusive y 15 sin incluir,
“Sobresaliente” si está entre 15 inclusive y 20 sin incluir y “Matrícula de honor” si la nota es
igual a 20.
8) Escribir un programa que, dado el nombre o número del mes, y la información de si el año
es bisiesto muestre por pantalla el número de días del mes
9) Escribir un programa que, pida la fecha de nacimiento de una persona e imprima por pantalla
su signo zodiacal.
4.4 Estructuras repetitivas

La explicación para las estructuras repetitivas los haremos a través de un ejemplo de un programa
que:
2. Imprima la serie 3456789
3. Imprima la serie 3579

Chachapoyas
4.4.1 La sentencia for

La sentencia for tiene el siguiente formato:
V : Variable contador,
valorInicial : Valor inicial de V,
valorFinal : Valor final de V.
Tabla 13: La sentencia for en código C y pseudocódigo

for (expresión1; expresión2; expresión3) Desde V=valorInicial hasta valorFinal hacer
{ Sentencias
Sentencias Fin desde
}
Importante: En expresión3 se indica el valor en que irá cambiando la variable V, en muchos
casos no se indica dado que por defecto este cambio es 1.
Algoritmo para la serie 3456789

Entero a
Inicio
Desde a=3 hasta 9 hacer
Imprimir a
Fin Desde
Fin
Para la serie 3456789

#include<conio.h>
#include<stdio.h>
int a;
main()
{
for(a=3; a<10; a++)
{
printf("%d",a);
}
getch();
}
Mostrará en pantalla: 3456789
Para la serie 3579

#include<ocnio.h>
#include<stdio.h>
int a;
main()
{
for(a=3; a<10; a+=2)
{
printf("%d",a);
}
getch();
}
Mostrará en pantalla: 3579

Chachapoyas
4.4.2 Ejercicios con bucle for
EJERCICIO 16 Hacer el algoritmo para un programa, que calcule la máxima área de un

terreno rectangular de lados 100-2x y x respectivamente, para valores de
x entre 10 y 30.
Variable
X : asume valores desde 10 hasta 30,
Area : asume el valor del área.
Algoritmo
Entero x, area
Inicio
Desde x=10 hasta 30 hacer
Area=100-2*x
Imprimir x, area
Fin Desde
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int x;
for(x=10; x<=30;x++)
printf("%d unidades, para x=%d \n",x*(100-2*x),x);
getch();
}
Nota: El mayor valor de área es 1250 para un valor de x =25
EJERCICIO 17 Hacer el algoritmo para un programa que calcule el mayor y el menor

número de 8 números ingresados por el teclado.
Variables
num : guarda un número ingresado,
mayor : Para asignarle el valor del mayor de los números leídos,
menor : Para asignarle el valor del menor de los números leídos,
x : Permite contar los 8 ingresos (valores desde 1 hasta 8).
Algoritmo
Entero num, mayor, menor, x;
Inicio
mayor0;
menor10000;
leer num
si mayor<num entonces mayornum;
si menor>num entonces menornum;
Fin Desde

Chachapoyas
Imprimir mayor, menor

Fin
Programa
#include<stdio.h>
main(void)
{int num,mayor,menor,x;
mayor=0;
menor=10000;
for(x=1; x<=8;x++)
{ printf("INGRESAR NÚMERO %d : ",x);
scanf("%d",&num);
if(mayor<num) mayor=num;
if(menor>num) menor=num;
}
printf("EL NUMERO MAYOR ES : %d Y EL NUMERO MENOR ES : %d
\n",mayor,menor);
getch();
}
EJERCICIO 18 Hacer el algoritmo para el ejercicio 16, para encontrar solamente el valor
de la mayor área e imprimir el valor de x para el esta área máxima.
Variables
area : Valor del area
x : valor de x.
maxarea : valor de la máxima área.
maxx : valor delmáximo valor de x.
Algoritmo
Entero area, x, maxarea, maxx
Inicio
maxarea0;
areax*(100-2*x);
Si maxarea<area entonces
maxareaarea;
maxxx
Fin Si
Fin Desde
Imprimir maxarea, maxx
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int area, x;
int maxarea,maxx;
maxarea=0;
for(x=10; x<=30;x++)
{
area=x*(100-2*x);
if(maxarea<area)

Chachapoyas
{maxarea=area;
maxx=x;}
}
printf("Area maxima %d unidades, para x=%d \n",maxarea,maxx);
getch();
}
Nota: En este caso la mayor área es 1250, para x=25.
EJERCICIO 19 Escríbase el algoritmo para un programa en el que se pide al usuario

ingresar el nombre, sexo, número de horas de trabajo y el sueldo por hora
para cada uno de seis empleados. La primera parte de la impresión en el papel debe dar el
nombre y el pago para cada empleado. La segunda parte debe dar totales separados y pagos
promedios separados para hombres y para mujeres. El programa puede suponer que hay al
menos un empleado de cada sexo.
Ejemplo:
Pago por
Nombre Sexo *nht Total
hora
A M 50 5 250
E F 60 4 240
I M 70 6 420
O F 50 6 300
U F 50 10 500
E M 70 7 490
*Número de horas trabajadas
Sexo Promedio Total

H 386,6667 1160
F 346,6667 1040
Variables
x : asume valores de 1 hasta 6,
pht : pago por hora trabajada,
nht : número de horas trabajadas,
sexo : sexo,
ptt : pago total,
sumasm : suma de pagos de las hombres,
sumasf : suma de pagos de las mujeres,
sm : número de hombres cuyos datos se ingresaron,
sf : número de mujeres cuyos datos se ingresaron,
nombre : nombre de los trabajadores.
Algoritmo
Entero x, pht, nht, sexo, ptt, sumasm, sumasf, sm, sf
Alfanumerico nombre
Inicio
sumasm0;
sumasf0;
sm0;
sf0;

Chachapoyas
Leer sexo
Si sexo=1 entonces
smsm+1;
Leer nombre,nht, pht
pttnht*pht;
Imprimir nombre, ptt
sumasmsumasm+ptt
Else
sfsf+1;
Leer nombre, nht, pht
pttnht*pht;
sumasfsumasf+ptt
Fin Si
Fin Desde
Imprimir sumasm, sumasm/sm
Imprimir sumasf, sumasf/sf
Fin
Programa
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
int x,pht,nht,sexo,ptt,sumasm,sumasf;
float sm,sf;
main(void)
{char nombre[20];
sumasm=0;
sumasf=0;
sm=0;
sf=0;
for(x=1; x<=6;x++)
{printf("ingrese sexo 1 varon, 2 mujer\n ");
scanf("%d",&sexo);
if(sexo==1)
{sm=sm+1;
printf("ingrese nombre \n ");
scanf("%s",&nombre);
printf("ingrese nro de horas trabajadas \n");
scanf("%d",&nht);
printf("ingrese pago por hora trabajada\n");
scanf("%d",&pht);
ptt=nht*pht;
printf("%s GANA %d SOLES \n\n",nombre,ptt);
sumasm=sumasm+ptt;}
else
{sf=sf+1;
scanf("%d",&nht);
scanf("%d",&pht);

Chachapoyas
ptt=nht*pht;
sumasf=sumasf+ptt;}
}
printf("los HOMBRES GANAN TOTAL: %d SOLES, PROMEDIO: %f
\n",sumasm,sumasm/sm);
printf("las MUJERES GANAN TOTAL: %d SOLES, PROMEDIO:
%f",sumasf,sumasf/sf);
getch();
}
Escriba el algoritmo para un programa que imprima la suma de 15

EJERCICIO 20 elementos de la serie: 1/2 +3/4 +7/8 +15/16...
Variables
a : Asume los valores de los numeradores,
c : Indica las 14 repeticiones,
suma : Acumula el valor de la suma.
Algoritmo
Real a, suma;
Entero c
Inicio
a1
suma0.5
Desde c=1 hasta c<14 hacer
aa*2+1
sumasuma+(a/(a+1))
Fin Desde
Imprimir suma
Fin
Nota: Tenga en cuenta el bucle es de 14 repeticiones por que suma se inicializa en 0.5.
Programa
#include<stdio.h>
main(void)
{float a,c,suma;
a=1;
suma=0.5;
for(c=1;c<15;c++)
{a=a*2+1;
suma=suma+(a/(a+1));}
printf("%lf",suma);
getch();
}
Escriba el algoritmo para un programa que calcule el factorial de un

EJERCICIO 21
número n ingresado por el teclado.
Variables
fac : acumulador del valor del factorial del numero ingresado,
c : cuenta el número de repeticiones,
num : el número cuyo factorial se va a calcular.

Chachapoyas
Algoritmo
Entero c, num, fac
Inicio
Leer num
Fac1
Desde c=1 hasta num hacer
fac=fac*c
Fin Desde
Imprimir num, fac
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int c,num;
float fac;
printf("ingrese el número n para calcular su factorial ");
scanf("%d",&num);
fac=1;
for(c=1;c<=num;c++)
fac=fac*c;
printf("el factorial de %d es %lf",num,fac);
getch();
}
Para “Gaseosas Amazonía” escriba el algoritmo para un programa que

EJERCICIO 22
procese e imprima la información de la nómina de sus diez empleados.
Para cada caso, el programa debe leer el nombre, las horas de trabajo, el pago por hora normal
y la edad.
Ejemplo: Un grupo típico de datos podría ser:
Nombre N.H.T. P.H. Edad

Juan Sopla 50 5 57
El pago por hora después de las 40 horas de trabajo tiene un aumento equivalente al
50% del pago por hora normal. Así, un empleado que trabaja 50 horas a S/. 5.00 por hora tendrá
un pago total de S/. 275.00. Al trabajador se le retiene un impuesto de la siguiente manera:
10 % de los primeros S/. 200.00 y 20 % de la cantidad adicional.
La primera parte de la impresión en papel debe ser la información relevante de cada
empleado.
Ejemplo:
Horas de Sueldo
Nombre Total Impuesto Neto Edad
trabajo por hora
Juan Sopla 275 50 35 5 240 57
La segunda parte debe informar sobre el pago total promedio para los empleados de al
menos 55 años. El nombre y el pago total para el empleado de menos de 55 años con máximo
pago total (se puede suponer que no hay empate).
Ejemplo:
Pago
Nombre Nht Edad Total Des1 Neto
hora
Ana 50 5 40 275 35 240

Chachapoyas
Martha 60 4 15 280 36 244

Darwin 45 6 58 285 37 248
Manuel 50 6 60 330 46 284
Sergio 50 10 40 550 90 460
María 70 7 80 595 99 496
Viviana 45 10 52 475 75 400
La solución sería: Empleado menor de 55 años con máximo sueldo es Sergio con 460 soles.El
promedio del sueldo para los empleados mayor de 55 años es: 342.667 soles
Variables
me : la máxima edad,
mp : máximo promedio,
promedio : promedio que se calcula,
nombre : nombre que se ingresa por el teclado,
nme : nombre del que tiene la máxima edad,
nht : número de horas trabajadas,
ph : pago por hora normal,
total : total sin descuentos,
neto : neto a pagar,
impuesto : impuesto,
i : contador,
edad : edad que se ingresa por el teclado.
Algoritmo
Entero me, mp, nme, nht, ph, total, neto, i, edad
Real promedio, impuesto
Alfanumerico nombre
Inicio
mp0;
promedio0;
Desde i=1 hasta 10 hacer
Leer nombre, nht, ph, edad
Si nht>40 entonces total40*ph+(nht-40)*(ph+0.5*ph)
Sino totalnht*ph
Si total>200 entonces impuesto200*0.1+(total-200)*0.2
Sino impuestototal*0.1
netototal-impuesto
Imprimir nombre, nht, ph, edad
Imprimir total, impuesto, neto
Si edad>=55 entonces promediopromedio+neto/3
Sino
Si mp<neto entonces
mpneto;
meedad;
nmenombre
Fin si
Fin si

Chachapoyas
Fin Desde
Imprimir promedio
Imprimir nme mp me
Fin
Programa
#include<conio.h>
#include<stdio.h>
#include<string.h>
main(void)
{
float me,mp;
float promedio;
char nombre[20];
char nme[20];
float nht,ph;
float total, neto,impuesto;
int i,edad;
mp=0;
promedio=0;
for(i=1;i<=10;i++)
{ printf("\n ingrese nombre: ");
scanf("%s",nombre);
printf("Ingrese número de horas trabajadas: ");
scanf("%f",&nht);
printf("Ingrese el valor del pago por hora: ");
scanf("%f",&ph);
printf("Ingrese la edad: ");
scanf("%d",&edad);
if(nht>40) total=40*ph+(nht-40)*(ph+0.5*ph);
else total=nht*ph;
if(total>200) impuesto=200*0.1+(total-200)*0.2;
else impuesto=total*0.1;
neto=total-impuesto;
printf("%s trabajo %lf horas, Pago por hora %lf, Edad %d años
\n",nombre,nht,ph,edad);
printf("total %lf, impuesto %lf, neto %lf soles
",total,impuesto,neto);
if(edad>=55) promedio=promedio+neto/3;
else
{ if(mp<neto)
{ mp=neto;
me=edad;
strcpy(nme,nombre);
}
}
}
printf("\n\n pago promedio: %lf soles",promedio);
printf("\n %s gana %lf soles edad: %lf años\n",nme,mp,me);
getch();
}
Escriba el algoritmo para un programa interactivo para calificar a un

EJERCICIO 23 grupo de 40 alumnos de la Untrm. El programa debe leer el nombre y
sus 3 calificaciones para cada alumno. Debe calcular el promedio para cada uno y después
determinar si el alumno es aprobado o no; se requiere un promedio de al menos 12 para aprobar.
La primera parte de la salida en el papel debe ser el nombre del alumno, 3 calificaciones, promedio

Chachapoyas
y un mensaje (aprobado ó desaprobado). La segunda parte de salida en el papel debe dar el

número de alumnos que aprobaron y el número de los que obtuvieron al menos 18 de nota.
Variables
i : contador,
n1, n2, n3 : notas,
Promedio : promedio de notas,
naa : número de alumnos desaprobados,
na18 : número de alumnos mayores de 18 años,
nombre : nombre del alumno,
condición : asume valores 1 (aprobados), 2 desaprobados.
Algoritmo
Entero i, n1, n2, n3, naa, na18, condición.
Real promedio
Alfanumerico nombre
Inicio
naa0;
na180;
Leer nombre, n1, n2, n3
promedio(n1+n2+n3)/3
Si promedio>12 entonces
condicion1;
naanaa+1;
sino
condicion2
Fin Si
Si condicion=1 entonces Imprimir nombre, n1, n2, n3, promedio
Sino Imprimir nombre, n1, n2, n3, promedio
Si promedio>=18 entonces na18na18+1
Fin Desde
Imprimir naa, na18
Fin
Programa
#include<conio.h>
#include<stdio.h>
#include<string.h>
main(void)
{
int i,n1,n2,n3;
float promedio;
int naa,na18;
char nombre[20];
int condicion;
naa=0;
na18=0;
for(i=1;i<=40;i++)
{printf("ingrese el nombre ");

Chachapoyas
scanf("%s",nombre);
printf("ingrese el nota1: ");
scanf("%d",&n1);
scanf("%d",&n2);
scanf("%d",&n3);
promedio=(n1+n2+n3)/3;
if(promedio>12)
{condicion=1;
naa=naa+1;
}
else
{ condicion=2; }
if(condicion==1) printf("%s nota1: %d nota2: %d, Nota3: %d,
promedio: %lf condicion :aprobado \n",nombre,n1,n2,n3,promedio);
else printf("%s nota1: %d nota2: %d, Nota3: %d, promedio: %lf
condicion :desaprobado \n",nombre,n1,n2,n3,promedio);
if(promedio>=18) na18=na18+1;
}
printf("hay aprobados: %d y aprobados con mas de 18
%d:\n",naa,na18);
getch();
}
Escriba el algoritmo para un programa que calcule la suma de n de

EJERCICIO 24 términos ingresado por el teclado de la serie 5/6,11/12,23/14,...
Variables
i : Contador
n : Numero de términos de la serie
num : valor del numerador de la serie
suma : Acumulador de la suma
Algoritmo
Entero i, n, Num
Real Suma
Inicio
Leer n
Suma0;
Num2;
Desde i=1 hasta n hacer
Numnum*2+1
Sumasuma+num/(num+1)
Fin Desde
Imprimir suma
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{
int i,n;
float num,den,suma;

Chachapoyas
printf("ingrese la cantidad de términos ");

scanf("%d",&n);
suma=0;
num=2;
for(i=1;i<=n;i++)
{num=num*2+1;
suma=suma+num/(num+1);
}
printf("suma %lf ",suma);
getch();
}
4.4.3 Ejercicios con for anidado
Hacer el algoritmo para un programa que imprima 3 grupos, 5 veces

EJERCICIO 25
"CHACHAPOYAS" en cada grupo. Antes de cada grupo deberá decir
“HOLA”.
Variables
n, m : Variables contadores
Algoritmo
Entero n, m
Inicio
Desde n=1 hasta 3 hacer
Imprimir “HOLA”
Desde m=1 hasta 5 hacer
Imprimir "CHACHAPOYAS“
Fin Desde
Fin Desde
Fin
Programa
#include<conio.h>
#include<stdio.h>
int n,m;
main(void)
{
for(n=1;n<=3;n++)
{ printf(" HOLA \n");
for(m=1;m<=5;m++)
printf("CHACHAPOYAS \n");
}
getch();
}
Comentario: Este es un ejemplo de un for anidado.
4.4.4 La sentencia while

La sentencia while es otro ciclo o bucle cuyo formato es:

Chachapoyas
Tabla 14: La sentencia while en código C y pseudocódigo

while (condicion) Mientras (condicion)
{ sentencias
sentencias; contador
contador Fin Mientras
}
En este caso las sentencias se ejecutan si la condición es verdadera. La comprobación es al inicio

del bucle. Este tipo de estructuras incluyen un contador, el mismo que va cambiando sus valores
en cada repetición y ayuda a romper el bucle en algún momento, en ese sentido este va incluido
de alguna forma en la condición, de esta manera la estructura while es similar a la estructura
for. Sin embargo cuando no sabemos el número de repeticiones podemos usar una variable
boolena que ayudará a romper el bucle en el momento que el usuario lo desee.

#include<stdio.h>
int a;
main()
{
a=3;
while(a<10)
{
printf("%d",a);
a=a+1;
}
}
Para la serie 3579

#include<stdio.h>
int a;
main()
{
a=3;
while(a<10)
{
printf("%d",a);
a=a+2;
}
}
4.5 Ejercicios con bucle while
Usando la instrucción mientras hacer un algoritmo para un programa que

EJERCICIO 26 imprima la serie 1, 3, 5, 7,9.
Variables
i : Contador
Algoritmo
Entero i
Inicio
Leer i
i1

Chachapoyas
Mientras i<=9 hacer

Imprimir i
ii+2
Fin Mientras
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{
int i;
i=1;
while(i<=9)
{
printf(" \n número= %d", i);
i=i+2;
}
getch();
}
Hacer un algoritmo para un programa que encuentre el primer entero
que haga que la suma de la serie 1, 2, 3, 4, 5, 6, 7, 8,9,…; supere 30.
EJERCICIO 27
Variables
i : Contador
suma : acumulador del valor de la suma
Algoritmo
Entero i, suma
Inicio
i0
suma0
Mientras suma<=30 hacer
ii+1
sumasuma+i
Fin Mientras
Imprimir i
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{
int i,suma;
i=0;
suma=0;
while(suma<=30)
{
i=i+1;
suma=suma+i;
}
printf(" \n El primer entero es: %d", i);
getch();

Chachapoyas
Conjetura de Ulam: Empiece con cualquier número entero positivo.

EJERCICIO 28
Si es par divídalo entre 2; y si es impar multiplique por 3 y aumente
en 1. Obténgase enteros positivos repitiendo el proceso hasta llegar a 1. Ejemplo si empezamos
en 5 la serie sería: 5, 16, 8, 4, 2, 1. Haga el algoritmo para un programa que nos permita obtener
secuencias de números como las anteriores.
Variables
i : contador,
num : numero ingresado.
Algoritmo
Entero i, num
Inicio
Leer num
Mientras num>1 hacer
Si num modulo 2 = 0 entonces numnum/2
Sino numnum*3+1
Imprimir num
Fin Mientras
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{
int i,num;
printf("ingrese un número.. ");
scanf("%d",&num);
while(num>1)
{
if(num%2==0)num=num/2;
else num=num*3+1;
printf(" \n número= %d", num);
}
getch();
}
Hacer el algoritmo para un programa que calcule la suma de ciertos

PROGRAMA 29 números ingresados por el teclado. El cálculo de la suma se hará en
cualquier momento.
Variables
suma : acumulador de la suma,
num : numero ingresado.
Algoritmo
Entero suma, num
Inicio
Suma0
Mientras num <> 0 hacer

Chachapoyas
Leer num
Sumasuma+num
Fin Mientras
Imprimir suma
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int suma,num;
suma=0;
printf("CUANDO PULSE 0, TERMINA EL PROGRAMA.. \n");
while(num!=0)
{
printf(" ingrese un número.. ");
scanf("%d",&num);
suma=suma+num;
}
printf(" \n la suma es= %d", suma);
getch();
}
Escribir un algoritmo para un programa que imprima la siguiente tabla de

EJERCICIO 30
temperaturas Fahrenheit y Celsius. Sugerencia C  ( F  32) * 5 / 9 .
°F °C
32 0
34 1,1111
36 2,2222
… …
100 37,778
Variables
fareng: valor numérico de los grados farengheit ingresado,
cel : valor numérico de los grados celcius calculado.
Algoritmo
Real fareng, cel
Inicio
fareng30
Mientras fareng<=100 hacer
Cel(fareng-32)*5/9
farengfare+2
Imprimir fareng, cel
Fin mientras
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)

Chachapoyas
{int fare;
float cel;
fare=30;
while(fare<=100)
{ cel=(fare-32)*5/9;
fare=fare+2;
printf(" %d en grados farengheit = %lf grados en celcius
\n",fare,cel);
}
getch();
}
Escriba el algoritmo para un programa que evalúe la función

EJERCICIO 31
y  4 x 2  16x  15 , donde x toma los valores de 1 a 2 en pasos de
0.1. Para cada valor de x la salida debe dar el valor de y el mensaje POSITIVO o NEGATIVO
según el caso. Ejemplo: si y= 1.0 POSITIVO, Y=-1
NEGATIVO.
Variables
a : Toma los valores de x desde a hasta 2,
y : Toma los valores de la expresión para cada valor de a.
Algoritmo
Real y
Entero a
Inicio
a1
Mientras a<2.1 hacer
y4*a*a-16*a+15
aa+0.1
si y>0 entonces Imprimir y, “POSITIVO"
Sino Imprimir y, “NEGATIVO"
fin si
Fin mientras
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{float a,y;
a=1;
while(a<2.1)
{ y=4*a*a-16*a+15;
a=a+0.1;
if(y>0) printf(" %lf POSITIVO\n",y);
else printf(" %lf NEGATIVO\n",y);
}
getch();
}

Chachapoyas
Uso de centinela
Se usan centinelas para salir de los bucles en cualquier instante que uno desee, un
centinela es una variable que inicialmente adopta un valor, luego dentro de un bucle
este valor cambia, por lo que nos vemos obligados a abandonarlos. Lo anterior se
comprende a través del ejercicio 32
Escriba el algoritmo para un programa de nómina usando un ciclo

EJERCICIO 32 mientras con centinela. Para cada empleado, el programa debe leer el
nombre, sexo, horas de trabajo, sueldo por hora e imprimir el pago. La
segunda parte debe imprimir el pago promedio para las mujeres y el pago promedio para los
hombres.
Variables
pht : valor del pago por hora trabajada,
nht : cantidad de horas trabajadas,
sexo : valor numérico que indica (1 masculino, 2 femenino),
ptt : valor del pago por persona,
sumasm: guarda la suma de pagos a los varones,
sumasf: guarda la suma de pagos a las mujeres,
sm : guarda la cantidad de varones ingresados,
sf : guarda la cantidad de mujeres ingresadas,
nombre: guarda los nombres de las personas,
centinela: valor numérico que permite finalizar el programa.
Algoritmo
Entero pht, nht, sexo, ptt, sumasm, sumasf, centinela
Real sm, sf
Alfanumerico nombre
Inicio
Sumasm0
Sumasf0
Sm0
Sf0
Mientras centinela <> 1 hacer
Leer sexo
Si sexo<>1 y sexo <> 2 entonces
{
Centinela1 //aquí se origina la salida
Sm1
Sf1
}
Sino
{ Si sexo=1 entonces
{
smsm+1
leer nombre, nht, pht
pttnht*pht

Chachapoyas
Imprimir nombre,ptt
sumasmsumasm+ptt
}
Else
{
sfsf+1
Leer nombre, nht, pht
pttnht*pht
sumasfsumasf+ptt
}
}
Fin si
}
Fin Si
Fin mientras
Imprimir sumasm, sumasm/sm
Imprimir sumasf, sumasf/sf
Fin
Comentario: para este caso cualquier número asignado a la variable sexo, diferente de 1 o 2,
hará que la variable centinela se cargue a 1, hecho que obligará la salida del sistema.
Programa
#include<conio.h>
#include<stdio.h>
int x,pht,nht,sexo,ptt,sumasm,sumasf;
float sm,sf;
main(void)
{char nombre[20];
int centinela;
sumasm=0;
sumasf=0;
sm=0;
sf=0;
while(centinela!=1)
{
printf("ingrese sexo 1) varon, 2) mujer 3) Salir \n
");
scanf("%d",&sexo);
if(sexo!=1 || sexo!=2 )
{
centinela=1;
sm=1;
sf=1;
}
else
{
if(sexo==1)
{
sm=sm+1;

Chachapoyas

scanf("%d",&nht);
scanf("%d",&pht);
ptt=nht*pht;
sumasm=sumasm+ptt;
}
else
{
sf=sf+1;
scanf("%d",&nht);
scanf("%d",&pht);
ptt=nht*pht;
sumasf=sumasf+ptt;
}
}
}
printf("Los hombres ganan total: %d soles, Promedio: %f
\n",sumasm,sumasm/sm);
printf("Las mujeres ganan total: %d soles, Promedio:
%f",sumasf,sumasf/sf);
getch();
}
Las potencias de 2 son: 1, 2, 4, 8,16,….. Para obtener la siguiente

EJERCICIO 33
potencia se multiplica la anterior por 2. Escribir el algoritmo para un
programa que imprima la primera potencia de 2 que pasa de 1000.
Variables
potencia: acumula el producto de la variable potencia y el número 2,
e : guarda el valor del exponente.
Algoritmo
Real potencia, e
Inicio
Potencia1
e0
Mientras potencia<=1000 hacer
potenciapotencia*2
ee+1 //e es el exponente
Fin Mientras
Imprimir e
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{

Chachapoyas
int potencia,e;
potencia=1;
e=0;
while(potencia<=1000)
{
potencia=potencia*2;
e=e+1; //e es el exponente
}
printf("%d",e);
getch();
}
Nota: Ciertamente es 10, porque 210 =

1024
Escriba un algoritmo para un programa en el que el usuario debe

EJERCICIO 34
introducir enteros positivos entre 1 y 5. El programa debe informar al
usuario cuando haya escrito un número que hace que la suma pase de 21, imprimiendo la suma
y el último entero introducido y el mensaje “más de 21”.
Variables
suma : el valor de suma acumulada
num : numero ingresado
Algoritmo
Entero suma, num
Inicio
Suma0
Mientras suma<=21 hacer
Leer num
Si num>=1 y num<=5 entonces sumasuma+num
Fin si
Fin Mientras
Imprimir suma, num
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{
int suma,num;
suma=0;
printf("Ingrese números entre 1 y 5 \n");
while(suma<=21)
{
printf("Ingrese un número ");
scanf("%d",&num);
if(num>=1 && num<=5)
{suma=suma+num;}
}
printf("\ n Suma: %d, Número: %d",suma,num);
getch();
}

Chachapoyas
Escriba el algoritmo para un programa que imprima la sucesión completa

de ULAM para un entero de entrada, si la longitud de toda la sucesión es
EJERCICIO 35 no más de 10. En caso contrario sólo se imprimirá los 10 primeros enteros
de la sucesión. Haga las pruebas de mano para sucesiones de menores
de 10, números iguales a 10 y mayores de 10.
Ejemplo
5: 16, 8, 4, 3, 1.
25: 76, 38, 19, 58, 29, 88, 44, 22, 11,34.
Variables
c : contador,
num : número que se imprimirá.
Algoritmo
Entero c, num
Inicio
Leer num
c1;
Mientras num>1 y c<=10 hacer
Si num modulo 2=0 entonces numnum/2
Sino numnum*3+1
Fin Si
Imprimir num
cc+1
Fin Mientras
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{
int c,num;
printf("Ingrese un numero.. ");
scanf("%d",&num);
c=1;
while(num>1 && c<=10)
{
if(num%2==0)num=num/2;
else num=num*3+1;
printf(" \n número= %d", num);
c=c+1;
}
getch();
}
EJERCICIO 36
ex se puede expresar como la siguiente serie infinita.
x1 x 2 x 3
e  1
x
   ...
1! 2! 3!

Chachapoyas
x2
Si se considera 1 como el término 0, x como el primer término, como el segundo término,
2!
x3
como el tercer término, etc.; entonces el término n es igual al término n-1 multiplicado por
3!
x
. Haga el algoritmo para un programa basado en esta serie para encontrar una aproximación
n
a e 2.5 . El programa debe parar cuando el último término sumando sea menor de 0.0001.
Compruebe el programa para e 1 y compare con el valor de la función que devuelve este valor (
e ) en cualquier lenguaje de programación.
Variables
t : valor del término,
n : posición del término,
e : acumulador de t ,
x : valor del exponente ingresado.
Algoritmo
Real t, a, n, e, x
Inicio
Leer x
n2
tx
e1+x
Mientras t>0000.1 hacer
tt*(x/n)
ee+t
nn+1
Fin Mientras
Imprimir x, e
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{float n, t, e;
float x;
printf("ingrese el valor de x.. ");
scanf("%f",&x);
n=2;
t=x;
e=1+x;
while(t>0000.1)
{
t=t*(x/n);
e=e+t;
n=n+1;
}
printf(" \n e a la %f es = %lf", x,e);
getch();
}

Chachapoyas
Escriba el algoritmo para un programa que cuente el número de cifras de

EJERCICIO 37 un entero de entrada hasta 32000. Así para una entrada de 583 la salida
debe ser “3 cifras”, asegúrese que el programa funcione para 1 y 10. Para
cero la salida debe ser "UNA CIFRA”. El programa no debe cerrarse hasta ingresar el número 0.
Variables
x : valor ingresado
Algoritmo
Entero x
Inicio
x1
Mientras x<32000 y x<>0 hacer
Leer x
Si x>=0 y x<10 entonces Imprimir x, “Tiene 1 cifra" Fin si
Si x>9 y x<100 entonces Imprimir x, “Tiene 2 cifras" Fin Si
Si x>99 y x<1000 entonces Imprimir x, “Tiene 3 cifras" Fin Si
Si x>999 y x< 10000 entonces Imprimir x, "Tiene 4 cifras" Fin Si
Si x>9999 y x<=32000 entonces Imprimir "Tiene 5 cifras" Fin si
Fin Mientras
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{
int x=1;
printf("Cuantas cifras tiene un numero. Pulse 0 para terminar");
while(x<32000 && x!=0)
{
printf("\n ingrese un número: ");
scanf("%d",&x);
if(x>=1 && x<=9) printf("%d tiene 1 cifra",x);
else if(x>=10 && x<=99) printf("%d tiene 2 cifras",x);
}
getch();
}
Escriba el algoritmo para un programa en el que se pida al usuario

EJERCICIO 38 ingresar 10 números enteros impares para sumarlos. Elabore el programa
de manera que no se arruine si el usuario escribe algunos enteros pares.
El programa debe salir del ciclo e imprimir la suma sólo cuando se hayan ingresado los 10 enteros
impares.
Variables
x : valor ingresado,
suma : acumulador de los valores de x,
c : contador de números impares.

Chachapoyas
Algoritmo
Entero x, suma, c
Inicio
Mientras (c<10)
Leer x
Si x modulo 2 <>0 entonces
sumasuma+x
cc+1
Fin Si
Fin Mientras
Imprimir suma
Fin
Programa
#include<conio.h>
#include<stdio.h>
int x,suma,c;
main(void)
{
printf("INGRESE 10 NÚMEROS IMPARES \n");
while(c<10)
{printf("ingrese un número ");
scanf("%d",&x);
if(x%2!=0)
{suma=suma+x;
c=c+1;}
}
printf("la suma es %d ",suma);
getch();
}
Hacer un algoritmo para un programa que imprima todos los números

EJERCICIO 39 primos entre 2 números ingresados por el teclado.
Ejemplo: primer número = 5
Último número =15
Resultado =5, 7, 11, 13
Variables
i : contador, número primo,
j : contador,
n1 : primer número del rango,
n2 : segundo número del rango.
Algoritmo
Entero i, n1, n2, j
Inicio
Leer n1, n2
Desde i=n1 hasta n2 hacer
j2
Mientras i modulo j <>0 hacer
j=j+1
Si i=j entonces Imprimir i

Chachapoyas
Fin Si
Fin mientras
Fin Desde
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{
int i,n1,n2,j;
printf("ingrese el primer número ");
scanf("%d",&n1);
printf("ingrese el segundo número ");
scanf("%d",&n2);
for(i=n1;i<=n2;i++)
{j=2;
while(i%j!=0)
{
j=j+1;
if(i==j) printf(" %d ",i);
}
}
getch();
}
Comentario: Los i son los números primos, entre n1 y n2.
4.5.1 La sentencia do-while

A diferencia de del bucle for y while, el bucle do-while, verifica la condición al finalizar. El
comportamiento de esta estructura es similar al del bucle while.
Tabla 15: La sentencia do-while en código C y pseudocódigo

do{ Hacer
Sentencias; Sentencias
} Mientras condición
while(condición);
NOTA: Las llaves no son necesarias si solamente se escribe una sentencia dentro de
los bucles.
En el siguiente programa se usa un ciclo do... while para leer números desde el teclado hasta
que uno de ellos es menor que o igual a 100:
#include<conio.h>
#include<stdio.h>
main()
{
int num;

Chachapoyas
do
{
scanf("%d", &num);
} while ( num>100 );
getch();
}
Do-While es útil en el desarrollo de programas con menús.
En el siguiente ejemplo al correr el programa imprime la serie 345678910, fíjese se supone la

impresión debió ser hasta 9 como máximo. Esto explica que luego se haberse impreso el número
10, recién se hace la comparación.
Algoritmo para la serie 345678910

Entero a;
Inicio
a3;
Hacer
aa+1
Imprimir a
Mientras a<10
Fin

#include<conio.h>
#include<stdio.h>
int a;
main()
{
a=3;
do
{
a=a+1;
printf("%d",a);
}while(a<10);
getch();
}

#include<conio.h>
#include<stdio.h>
int a;
main()
{
a=3;
do
{
a=a+2;
printf("%d",a);
}while(a<10);
getch();
}

Chachapoyas

1) Modificar el programa del juego de doble o nada para que permita ir jugando hasta que el
jugador decida abandonar el juego. El programa debe sacar por pantalla el número de
jugadas y el total ganado y perdido por el jugador.
2) Escribir un programa para jugar a adivinar un número entre 1 y 10, el número es generado
al azar.
3) Escribir un programa que pida una contraseña y permita tres intentos. Si el usuario da la
contraseña correcta responde "Enhorabuena!" y queda inactivo, con este mensaje. En caso
contrario el programa escribe "Lo siento, contraseña equivocada" y se cierra de inmediato.
4) Escribir un programa que pida un número y muestre por pantalla su tabla de multiplicar.
5) Escribir un programa para calcular el promedio de una lista de números positivos, el programa
termina cuando se escribe un número negativo.
6) Escribir un programa para sumar los números enteros de 1 a 100 utilizando
a. estructura hacer mientras,
b. estructura mientras,
c. estructura desde.
7) Escribir un programa que lea una lista de números y determine cuantos son positivos y
cuántos son negativos.
8) Escribir un programa que dados dos números, uno real (base) y un entero positivo n, saque
por pantalla todas las potencias con base el número dado y exponentes entre uno y n
9) Escribir un programa que imprima por pantalla los codigos ASCII correspondientes a los
números 32 al 127.

Chachapoyas
Capítulo IV: Funciones y procedimientos
Capítulo IV
Funciones y
procedimientos
5.1 Funciones
Sea la función f ( x)  x 2  2
Tabla 16: Valores de una función con una variable

x f(x)
-3 11
-2 6
0 11
1 3
2 6
3 11
La función f(x) devuelve un solo valor para cada valor de x respectivamente.

Sea la función g ( x, y )  x 3  y  1
Tabla 17: Valores de una función con dos variables

x y g(x)
-3 1 -24
-2 3 -3
0 -1 -24
1 2 5
2 -2 8
3 0 29
Nuevamente la función g(x, y) devuelve un solo valor para dos valores de 2 variables de entrada,
x e y respectivamente. Las funciones en los lenguajes de programación se tratan teniendo en
cuenta el criterio anterior.
Función: Una función es un grupo de instrucciones cuya ejecución se lleva a cabo cada
vez que se invoca el nombre de la función con valores de entrada y luego de realizar
un cálculo regresa un valor hasta la línea donde se hizo la llamada a la función.
Toda función regresa un único valor

Chachapoyas
Procedimiento: Cuando una función no regresa valor alguno se llama procedimiento, en

todo caso el valor que regresa es nulo. Un procedimiento es un grupo de instrucciones,
que como su nombre lo dice realiza un procedimiento y nada mas, cuya ejecución se
lleva a cabo cada vez que se invoca el nombre del procedimiento, posiblemente con
algunos valores como argumentos.
Todo procedimiento no regresa valores, sino que hace algo como por
ejemplo ordenar, imprimir, intercambiar valores, etc.
Argumentos de las funciones

Son los valores de las variables de la función f(x, y, z), en este caso los argumentos son x, y, z.
• En un procedimiento no interesa el número de argumentos de ingreso, lo que
mas interesa es el proceso que va ha realizar y sobre ello el valor que devuelve.
• En algunos casos los problemas pueden ser solucionados a través de funciones
o procedimientos indistintamente.
En Lenguaje C, main es una función; es decir es la función principal de un programa.
5.1.2 Correspondencia entre argumentos

Se refiere a que los valores de una misma función pueden ser diferentes, pero siguen n un orden
de correspondencia.
Ejemplo: Sea f(a, b, c) = f(m, n, p)=f(4, 5, -7), en este caso;
a corresponde a m y éste a 4 (podría decirse a  m  4 )
b corresponde a n y éste a 5 (podría decirse b  n  5 )
c corresponde a p y éste a -7 (podría decirse c  p  7 )
Como se ve la función f tiene 3 variables o argumentos.
5.1.3 Recursividad
Normalmente una función f puede llamar a una función g y esta a una función h y así
sucesivamente. Cuando una función se llama a si misma se dice que sigue un proceso recursivo.
En este caso una función f se llama así misma, o la función f llama a la función f; estos conceptos
pueden ser utilizados para calcular el factorial de un número o calcular un elemento de la serie
del Italiano Fibonacii.
Importante:
En un proceso recursivo, identifique primero la semilla, si no logra identificarlo, siga
intentando hasta lograrlo.
Semilla: Son los valores iniciales de las series que siguen procesos recursivos.
En el factorial: La semilla es 1, para factorial de 0 o 1.
Serie fibonacii: La semilla es 1,1, para fibonacii de 0 o 1.
Llamada a una función:

Variablefunción(argumentos);
Llamada a un procedimiento:
Procedimiento(argumentos);

Chachapoyas
5.1.4 Ejercicios con funciones y procedimientos
Hacer un algoritmo para un programa que calcule el cubo de un número

EJERCICIO 40 ingresado.
Algoritmo
Los dos algoritmos que se muestran a continuación hacen lo mismo, el algoritmo1 es en base a
una función y el algoritmo2 en base a un procedimiento.
Tabla 18: Cubo de un número

Algoritmo1 Algoritmo 2
Variables Variables
Cubo: función, Cubo: función,
Num: número ingresado, Num: número ingresado,
Res: resultado, Res: resultado,
X: toma el valor de num. X: toma el valor de num.
Entero num, res Entero num
Real cubo(x) Nada cubo(x)
Inicio Inicio
Leer num Leer num
rescubo(num) cubo(num)
Imprimir num, res Fin
Fin //Función cubo
//Función cubo Nada cubo(x)
Real cubo(x) Inicio
Inicio Entero res
Cubox*x*x resx*x*x
Regresa Cubo Imprimir res
Fin Fin
Cuando una función no regresa valores se le puede llamar procedimiento como es el caso de
la función cubo de algoritmo2.
Programa
#include<conio.h>
#include<stdio.h>
float num;
float res, cubo(int x);
main()
{
printf("ingrese un número ");
scanf("%f",&num);
res=cubo(num);
printf("%f al cubo es: %f",num,res);
getch();
}
//Funcion cubo
float cubo(int x)
{
return x*x*x;
}

Chachapoyas
Hacer un algoritmo para un programa que evalúe la expresión x y .

EJERCICIO 41
Variables
potencia: es una función,
b : valor ingresado,
e : valor ingresado,
m : toma valores de b,
n : toma valores de e,
i : contador,
y : guarda el valor buscado.
Algoritmo
Entero b, e
Nada potencia(m, n)
Inicio
Leer b, e
Imprimir potencia(b, e)
Fin
//Función potencia
Nada potencia(m, n)
Inicio
Entero i, y
y1
Desde i=1 hasta i<=abs(n) hacer
yy*m
Si n<0 entonces y1/y
Fin Si
Fin Desde
potenciay
Fin
Programa
#include<conio.h>
#include<stdio.h>
#include <math.h>
int b,e;
float potencia(int m, int n);
main(void)
{
printf("Ingrese dos números menores de 10.. ");
scanf("%d %d",&b,&e);
printf("%f",potencia(b,e));
getch();
}
float potencia(int m, int n)

{int i;
float y;
y=1;
for(i=1;i<=abs(n);i++)
y=y*m;
if(n<0) y=1/y;

Chachapoyas
return y;
}
Hacer un algoritmo para un programa que calcule el área de círculo y

EJERCICIO 42
longitud de circunferencia. Utilizar procedimientos.
Variables
r : valor ingresado,
Circulo : función,
m : toma el valor de r,
pi : guarda el valor 3,1416.
Algoritmo
Entero r;
Nada circulo(m)
Inicio
Leer r
circulo(r)
Fin
//Función círculo
Nada circulo(m)
Inicio
Real pi
pi3.1416
Imprimir pi*m*m
Imprimir 2*pi*m
Fin
Programa
#include<conio.h>
#include<stdio.h>
int r;
void circulo(int m);
main(void)
{
printf(" Ingrese el valor del radio: ");
scanf("%d",&r);
circulo(r); // llamada a un procedimiento
}
void circulo(int m) // procedimiento

{float pi;
pi=3.1416;
printf("Area: %f \n",pi*m*m);
printf("Longitud: %f",2*pi*m);
getch();
}
Hacer un algoritmo para un programa que intercambie los valores de

EJERCICIO 43 dos variables.

Chachapoyas
Variables
Temp : temporal,
a : valor ingresado,
b : valor ingresado,
x : toma el valor de a,
y : toma el valor de b,
intercambio: procedimiento.
Algoritmo
Nada intercambio(x, y)
Entero temp, a, b
Inicio
Leer a, b
Intercambio(a, b);
Fin
//Funcion intercambio
Nada intercambio(x, y)
Inicio
tempx
Xy
Ytemp
Imprimir x, y
Fin
Programa
#include<conio.h>
#include<stdio.h>
void intercambio(int x,int y);
int temp,a,b;
main(void)
{
printf("Ingrese valor de a: ");
scanf("%d",&a);
printf("Ingrese valor de b: ");
scanf("%d",&b);
intercambio(a,b);
getch();
}
void intercambio(int x, int y)

{
temp=x;
x=y;
y=temp;
printf("nuevos valores de a:=%d y b:=%d",x,y);
}
Comentario: En este caso vea usted la variable temp no está declarada dentro del procedimiento
intercambio. Esto significa que la variable temp es una variable global.
El ejercicio 43 no puede ser solucionado usando funciones, la única manera es a través

de procedimientos, es decir una función que no devuelve ningún valor.

Chachapoyas
Hacer un algoritmo para un programa que calcule el factorial de un número

EJERCICIO 44 n
Variables
n : valor que se ingresa para calcular su factorial,
a : toma el valor de n,
factorial: función.
Algoritmo
Entero n
Entero factorial(a)
Inicio
Leer n
Imprimir factorial(n) //llamada a la función.
Fin
//Función factorial
Entero factorial(a)
Inicio
Si a=0 o a=1 entonces factorial1 //semilla 1
Sino factoriala*factorial(a-1) //aquí el llamado es nuevamente a la función
factorial(a), hasta que a=0 o a=1
Fin si
Regresa factorial
Fin
Programa
#include<conio.h>
#include<stdio.h>
int n,factorial(int a);
main(void)
{
printf("Ingrese el numero: ");
scanf("%d",&n);
printf("%d",factorial(n)); // llamada a la función
getch();
}
int factorial(int a)
{
if(a==0 ||a==1) return 1; //semilla 1
else return a*factorial(a-1); //el llamado es nuevamente a la función
factorial(a), hasta que a=0 o a=1.
}
Explicación: Mediante un ejemplo
F(5)=5*f(4)
4*f(3)
3*f(2)
2*f(1)
1*f(0)
La semilla es f(0)=1

Chachapoyas
Hacer un algoritmo para un programa que calcule el enésimo elemento

EJERCICIO 45 de la serie FIBONACII. 1, 1, 2, 3, 5, 8,13,…
Variables
n : enésimo elemento de la serie fibonacii,
x : toma valores de n,
fibonacii : función.
Algoritmo
Entero n
Entero fibonacii(x)
Inicio
Leer n
Imprimir n, fibonacii(n)
}
//Función Fibonacii
Funcion fibonacii(x)
Inicio
Si x=0 ó x=1 entonces fibonacii 1 //semilla
Sino fibonacii fibonacii(x-2)+fibonacii(x-1); //está llamando nuevamente a la
función fibonacii(x) hasta que
x=0 o x=1.
Fin Si
Fin
Programa
#include<conio.h>
#include<stdio.h>
int n;
int fibonacii(int x);
main(void)
{
printf(" INGRESE LA POSICION DEL ELEMENTO .. ");
scanf("%d",&n);
printf("FIBONACII DE %d es %d",n,fibonacii(n));
getch();
}
int fibonacii(int x)
{
if(x==0 || x==1)return 1; //semilla
else return fibonacii(x-2)+fibonacii(x-1); //está llamando nuevamente
a la función fibonacii(x) hasta que x=0 o x=1.
}
Explicación: Sea la función fibonacii f(4)

Chachapoyas
F(4)=5
F(3) + F(2)
F(2)+F(1) F(1)+F(0)
F(1)+F(0) 1 1 1
1 1
Hacer un algoritmo que calcule el enésimo elemento de la serie: 4, 6,

EJERCICIO 46 10, 16, 26, 42,…
Variables
n : enésimo elemento de la serie,
elemento : función.
Algoritmo
Entero n
Entero elemento(x)
Inicio
Leer n
Imprimir n, elemento(n)
Fin
//Función elemento
Entero elemento(x)
Inicio
Si x=0 entonces elemento 4 Fin Si //semilla
Si x=1 entonces elemento 6 //semilla
Sino elementoelemento(x-2)+elemento(x-1) //recursividad
Fin si
Fin
Programa
#include<conio.h>
#include<stdio.h>
int n;
int elemento(int x);
main(void)
{
printf(" Ingrese la posición del elemento .. ");
scanf("%d",&n);
printf("Elemento DE %d es %d",n,elemento(n));
getch();
}
int elemento(int x)
{
if(x==0)return 4; //semilla

Chachapoyas
else return elemento(x-2)+elemento(x-1); //recursividad
}
Hacer un algoritmo para un programa que calcule el enésimo elemento

EJERCICIO 47 de la serie: 1, 1, 2, 4, 7, 13, 24, 44,…
Variables
n : enésimo elemento de la serie fibonacii,
elemento : función.
Algoritmo
Entero n
Entero elemento(x)
Inicio
Leer n
Imprimir n, elemento(n)
Fin
//Función elemento
Entero elemento(x)
Inicio
Si x=0 entonces elemento1 Fin si //semilla
Si x=1 entonces elemento1 Fin si //semilla
Si x=2 entonces elemento2 //semilla
Sino elementoelemento(x-3)+elemento(x-2)+elemento(x-1);
//recursividad
Fin
Programa
#include<conio.h>
#include<stdio.h>
int n;
int elemento(int x);
main(void)
{
scanf("%d",&n);
printf("Elemento de %d es %d",n,elemento(n));
getch();
}
int elemento(int x)
{
else return elemento(x-3)+elemento(x-2)+elemento(x-1); //recursividad
}

Chachapoyas
5.1.5 Ejercicios con funciones recursivas
Hacer un algoritmo para un programa que halle el elemento n de la

EJERCICIO 48 serie, 2n: 1 2 4 8 16 32 64 128 ... para n = 0,1,2,3,4,5,6,7,8, .... ;
También diseñe una función que regrese el exponente correspondiente a la potencia 2n.
Variables
n : valor ingresado,
X : toma valor de n,
valor : toma el valor de la variable potencia,
potencia : valor de la potencia del término n,
potenciadedos : función,
exponente : función.
Algoritmo
Entero n, potencia
Entero potenciadedos(x), exponente(valor)
Inicio
Leer n
Potenciapotenciadedos(n)
Imprimir n, potencia
Imprimir potencia, exponente(potencia)
Fin
//Función potenciadedos
Entero potenciadedos(x)
Inicio
Si x=0 entonces potenciadedos1
Sino potenciadedos 2*potenciadedos(x-1)
Fin si
Fin
//Función exponente
Entero exponente(valor)
Inicio
Si valor=1 entonces exponente0
Sino exponenteexponente(valor/2)+1
Fin Si
Fin
Programa
#include<conio.h>
#include<stdio.h>
int n;
int potenciadedos(int x), exponente(int valor);
int potencia;
main(void)
{
scanf("%d",&n);
potencia=potenciadedos(n);
printf("2 a la %d es %d",n,potencia);

Chachapoyas
printf("%d es 2 a la %d",potencia, exponente(potencia));

getch();
}
int potenciadedos(int x)
{
if(x==0)return 1;
else return 2*potenciadedos(x-1);
}
int exponente(int valor)

{
if(valor==1)return 0;
else return 1+exponente(valor/2);
}
Comentario: Observe que los procesos potenciadedos y exponente son recursivos. En el ejercicio
anterior tal vez no se note como opera la función exponente, ya que la posición que se ingresa
representa el exponente, para comprenderlo mejor vea la solución del ejercicio 49.
Compruebe el siguiente algoritmo ingresando valores resultados de la

EJERCICIO 49 potencia de 2, ejemplo: 256, 32, 1024, etc. y verá la importancia de la
función exponente.
Variables
n : valor ingresado,
exponente : función,
valor : toma el valor de n.
Algoritmo
Entero n
Inicio
Leer n
Imprimir n, exponente(n)
Fin
Inicio
Si valor=1 entonces exponente0
Sino exponenteexponente(valor/2)+1
Fin Si
Fin
Programa
#include<conio.h>
#include<stdio.h>
int exponente(int valor);
int potencia;
main(void)
{
printf(" Ingrese valor potencia de 2 .. ");
scanf("%d",&potencia);
printf("%d es 2 a la %d",potencia, exponente(potencia));
getch();

Chachapoyas
int exponente(int valor)

{
if(valor==1)return 0;
else return 1+exponente(valor/2);
}
Desarrollar el ejercicio 14, usando funciones y procedimientos.

EJERCICIO 50
Variables
opcion : para saber cual es calculo a realizar,
base : valor de la base, también es función,
altura : valor de la altura, también es función,
area : valor del área, también es función.
Algoritmo usando funciones

Entero opcion, base, altura, area
Inicio
Leer opcion
Segun opcion sea
Caso 1
Leer base, altura
Imprimir area(base, altura)
Caso 2
Leer area, altura
Imprimir base(area,altura)
Caso 3
Leer area, base
Imprimir altura(area,base)
Fin Según
Fin
Real area(base,altura)
Inicio
Areabase*altura/2
Fin
Real base(area, altura)

Inicio
base2*area/altura
Fin
Real altura(area,base)
Inicio
altura2*area/base
Fin

Chachapoyas
Comentario: algunas variables pueden funcionar como tal o como funciones, en este problema,
fíjese por que.
Programa usando funciones

#include<conio.h>
#include<stdio.h>
int operacion;
float area(int b,int h);
float base(int a, int h);
float altura(int a,int b);
main(void)
{
printf("Ejercicios de los triangulos ........ \n");
printf("============================ \n\n\n");
printf("1) para calcular el area de un triangulo \n");
printf("2) para calcular la base \n");
printf("3) para calcular la altura \n\n");
printf("Ingrese una opcion ........ ");
switch(operacion)
{
float a,b,h;
case 1:
printf("Area del triangulo \n");
scanf("%f",&b);
scanf("%f",&h);
printf("%f",area(b,h));
break;
case 2:
scanf("%f",&a);
scanf("%f",&h);
printf("%f",base(a,h));
break;
case 3:
scanf("%f",&a);
scanf("%f",&b);
printf("%f",altura(a,b));
break;
default:
}
getch();
}
float area(int b,int h)

{return b*h/2;
}
float base(int a, int h)

{return 2*a/h;}
float altura(int a,int b)

Chachapoyas
{return 2*a/b;
}
Variables
opcion : para saber cual es la operación a realizar,
base : valor de la base, también es procedimiento,
altura : valor de la altura, también es procedimiento,
area : valor del área, también es procedimiento.
Algoritmo usando procedimiento

Entero area, base, altura
Inicio
Según opción sea
Caso 1
Area()
Caso 2
Base()
Caso 3
Altura()
Fin Según
Fin
Nada area()
Inicio
Real area, base, altura
Leer base, altura
Areabase*altura/2
Mostrar area
Fin
Nada base()
Inicio
Entero area, base, altura
Leer area, altura
base2*area/altura
Mostrar base
Fin
Nada altura()
Inicio
Real area, base, altura
Leer area,base
altura2*area/base
mostrar altura
Fin

Chachapoyas
Programa usando procedimiento

#include<conio.h>
#include<stdio.h>
int operacion;
void area();
void base();
void altura();
main(void)
{
printf("Ejercicios de los triangulos ........ \n");
printf("============================ \n\n\n");
printf("1) para calcular el area de un triangulo \n");
printf("2) para calcular la base \n");
printf("3) para calcular la altura \n\n");
printf("Ingrese una opcion ........ ");
switch(operacion)
{
case 1:
area();
break;
case 2:
base();
break;
case 3:
altura();
break;
default:
}
getch();
}
void area()
{
float altura, base;
scanf("%f",&base);
printf("el area del triángulo es %f ",base*altura/2);
}
void base()
{
float area,altura;
printf("BASE DE UN TRIÁNGULO \n");
scanf("%f",&area);
printf("la base de area del triángulo es %f ",2*area/altura);
}
void altura()
{
float area,base;

Chachapoyas
printf("ALTURA DE UN TRIÁNGULO \n");

scanf("%f",&area);
scanf("%f",&base);
printf("la base de área del triángulo es %f ",2*area/base);
}

1) Diseñar una función que calcule el promedio de varios números introducidos por el teclado.
Hacer dos versiones, una para un número fijo de valores y otra para un número cualquiera
de valores.
2) Diseñar una función que calcule la potencia enésima de un número, es decir que calcule X n
para X, real y n entero.
3) Diseñar una función "aMayusculas()" que convierta una cadena de texto en mayúsculas.
4) Diseñar dos funciones "EurosASoles()" y "SolesAEuros()" que realicen las conversiones de
monedas.
5) Diseñar una función "EsBisiesto()" que decida si un año es bisiesto o no.
6) Escribir una función "EsMultiplo" que sirva para determinar si un número es múltiplo de otro.
Utilizarlo en un programa que pida la antigüedad de un trabajador y calcule cuantas décadas
de antigüedad tiene como trabajador.

Chachapoyas
Capítulo VII: Ejercicios propuestos
Capítulo V
Arreglos
6.1 Introducción a los arreglos

Una variable nos ayuda a guardar un solo valor. Qué pasaría si se requiere guardar
muchos valores en una variable, por ejemplo si se requiere guardar las notas de 1000 estudiantes,
tendríamos que usar 1000 variables, una para cada calificación. Un arreglo es una estructura de
datos que nos permite guardar muchos valores en una sola variable y referirnos a cada uno de
esos valores con un número denominado índice. Los arreglos son "estructuras estáticas de
almacenamiento interno" dado que su tamaño se declara al principio del programa y ya no se
puede modificar en el transcurso. Y se dice que son de almacenamiento interno porque están en
la memoria RAM de la computadora.
Los arreglos de una dimensión se llaman vectores, los de 2 dimensiones se llaman
matrices y los de 3 o más se llaman poliedros o arreglos multidimensionales. En informática
muchas veces se llama vector a cualquier arreglo.
6.2 Vector o arreglo de unidimensional

Pensemos en una escuela primaria de cuatro secciones: A, B, C y D que corresponden al primer
grado, una sección por profesor. Se puede escribir un programa usando una estructura
secuencial, guardando el nombre del profesor de cada sección, una vez que ha recopilado toda
esa información, nos permita preguntarle quien es el maestro que enseña en una sección.
profesor María Julia Manuel Lucía
sección A B C D
Para guardar los nombres de cada profesor tendríamos que usar las variables: profeso1,
profesor2, profesor3 y profesor4 de tipo alfanumérico o cadena. Sin embargo si serían 60
secciones necesitaríamos 60 variables diferentes de tipo cadena cada una. También sería
complicado usar una estructura repetitiva para asignar el nombre de cada profesor a cada
variable.
Usando un vector es fácil, se requiere una sola variable cuya estructura se muestra a
continuacion.
profesor María Julia Manuel Lucía
índice 0 1 2 3
La variable para referirnos al vector sería profesor. En este sentido para asignar el nombre del
profesor de la sección C a la variable se haría así:
profesor[2]”Manuel”

Chachapoyas
El índice dos de la variable profesor apunta a la sección C. Por el contrario, si el nombre de la

profesora de la sección D la queremos asignar a una variable maestra se haría así:
maestraprofesor[3]
Como se ve, el primer índice del vector es 0 e indica la primera posición, asimismo el índice 3
apunta a la sección D. Algo muy importante a tener en cuenta es que cuando se declara un vector
de tamaño 50 esto implica que lo óptimo es usar los 50 espacios, si no es así el espacio que no
se usa se desperdicia y ocupa espacio inútil en la memoria RAM de la computadora.
En lenguaje C la declaración de un arreglo unidimensional o vector numérico se hace así:
Entero vectorNumero[5],
En el vector vectorNumero se pueden guardar hasta cinco números enteros. Sin embargo para
el tratamiento de cadenas o variables alfanuméricas esto difiere un poco:
char profe[20], nos permite guardar un nombre de un profesor a lo más de 20 caracteres.

char matrizProfesor[5][20], nos permite guardar cinco nombres de a lo más 20
caracteres cada uno.
6.3 Ejercicios con vectores o arreglos unidimensionales
Hacer un programa para registrar los nombres de los profesores de cuatro

EJERCICIO 51
secciones. Mostrar el nombre del profesor dada la sección
correspondiente.
Variables
profe1, profe2, profe3, profe4 : nombre de los profesores,
n : sección.
Algoritmo
Alfanumerico profe1, profe2, profe3, profe4;
Entero n;
Inicio
Leer profe1
Leer profe2
Leer profe3
Leer profe4
//Imprimiendo
Imprimir profe1
Imprimir profe2
Imprimir profe3
Imprimir profe4
Leer n
Según n sea
caso 1
Imprimir profe1
caso 2
Imprimir profe2

Chachapoyas
caso 3
Imprimir profe3
caso 4
Imprimir profe4
Fin Según
Fin
Programa
#include<conio.h>
#include<stdio.h>
char profe1[20], profe2[20], profe3[20], profe4[20];
int n;
main(void)
{
printf("Profesor de 1 seccion: ");
scanf("%s",&profe1);
printf("Profesor de la 2 seccion: ");
//Imprimiendo
printf("\nEn la 1 seccion ensena %s", profe1);
printf("\nIngrese una seccion : ");
scanf("%d",&n);
switch(n)
{
case 1:
printf("En el piso %d ensena %s", n,profe1);
break;
case 2:
break;
case 3:
break;
case 4:
break;
default:
printf("Las secciones va de 1 a 4");
}
getch();
}
El programa anterior se puede reducir usando una estructura de datos de tipo vector y una
estructura repetiva for.
Variables
profesor[4] : estructura de datos para cuatro valores,
profe : nombre del profesor,
n : sección,
i : contador.

Chachapoyas
Algoritmo
Alfanumerico profesor[4], profe;
Entero n, i;
Inicio
Leer profe;
profesor[i]profe
Fin Desde
//Ver el profesor de una seccion en particular
Leer n;
Imprimir profesor[n-1]
Programa
#include<conio.h>
#include<stdio.h>
#include<string.h>
char profesor[4][20], profe[20]; //20 representa la cantidad de letras
int n, i;
main(void)
{
for(i=0; i<4; i++)
{
printf("Nombre del profesor de la seccíon %d: ", i+1);
scanf("%s",&profe);
strcpy(profesor[i],profe);
}
//Ver el profesor de una seccion en particular
printf("Quien es el profesor de la seccion: ");
scanf("%d",&n);
printf("Profesor de la seccion %d es %s",n,profesor[n-1]);
getch();
}
Programa que permite ingresar 8 números y realizar la búsqueda de un

EJERCICIO 52
número, imprimiendo también su posición.
Variables
Numero[8] : variable para guardar números,
i : contador,
num : para leer números,
busca : numero a buscar.
Algoritmo
Entero Numero[8]
Entero i, num, busca
Inicio
Leer num;
Numero[i]num;
Fin Desde
//Imprimir

Chachapoyas

Imprimir Numero[i]
Fin Desde
//Búsqueda
Leer busca
Si busca == Numero[i] Entonces
Imprimir i, Numero[i]
i8;
Fin Si
Fin
Programa
#include<conio.h>
#include<stdio.h>
int Numero[8];
int i, num, busca;
main(void)
{
for(i=0;i<8;i++)
{
printf("Escriba el numero: ");
scanf("%d",&num);
Numero[i]=num;
}
for(i=0;i<8;i++)
{
printf("\nNumero%d: %d", i, Numero[i]);
}
//Busqueda
printf("\nDame un valor a buscar: ");
scanf("%d",&busca);
for(i=0;i<8;i++)
{
if(busca == Numero[i])
{
printf("Posicion %d, Numero: %d", i, Numero[i]);
i=8;
}
}
getch();
}
Programa que permite ingresar e imprimir cierta cantidad de números

EJERCICIO 53 mayores que 100 y menores de 500, luego realizar la búsqueda un
número ingresado. Imprime el número y la posición en donde se
encuentra el número buscado.
Variables
Numero[100] : variable para guardar números,
n : cantidad de números,
i : contador,
busca : numero a buscar.

Chachapoyas
Algoritmo
Entero Numero[100]
Entero n, i, num, busca
Inicio
Leer n
Mientras i<n
Leer num;
Si num>100 y num<500 entonces
Numero[i]num
ii+1
Fin Si
Fin Desde
//Imprimir
Imprimir Numero[i]
Fin Desde
//Búsqueda
Leer busca
Si busca == Numero[i] Entonces
Imprimir i, Numero[i]
in;
Fin Si
Fin
Programa
#include<conio.h>
#include<stdio.h>
int Numero[100];
int n, i, num, busca;
main(void)
{
printf("Cuantos numeros desea ingresar: ");
scanf("%d",&n);
i=0;
while(i<n)
{
scanf("%d",&num);
if(num>100 && num<500)
{
Numero[i]=num;
i++;
}
}
for(i=0;i<n;i++)
{
}
//Busqueda

Chachapoyas
printf("\nDame un valor a buscar: ");

scanf("%d",&busca);
for(i=0;i<n;i++)
{
if(busca == Numero[i])
{
printf("Posicion %d, Numero: %d", i, Numero[i]);
i=n;
}
}
getch();
}
EJERCICIO 54 Elaborar un algoritmo que permita ingresar 20 números y muestre

solamente los números ingresados menores e iguales a 25.
Variables
Numero[20] : variable para guardar 20 números,
i : contador,
num : para leer números.
Algoritmo
Entero Numero[20];
Entero i, num, busca;
Inicio
Leer num
Numero[i]num
Fin Desde

If Numero[i]>25 entonces
Imprimir Numero[i]
Fin Desde
Programa
#include<conio.h>
#include<stdio.h>
int Numero[20];
int n, i, num, busca;
main(void)
{
for(i=0;i<20;i++)
{
scanf("%d",&num);
Numero[i]=num;
}
for(i=0;i<20;i++)
{
if(Numero[i]>25)

Chachapoyas
}
getch();
}
EJERCICIO 55 Elaborar un algoritmo, que permita el ingreso de 10 números enteros. El

programa debe sumar todos los números que sean múltiplos de 3 e
imprimirlo.
Variables
Numero[10] : variable para guardar 10 números,
i : contador,
Suma : acumulador para sumar números múltiplos de 3.
Algoritmo
Entero Numero[10];
Entero i, num, Suma;
Inicio
Leer num
Numero[i]num
Fin Desde
Si Numero[i] % 3==0 entonces
Suma = Suma + Numero[i];
Fin Si
Fin Desde
Imprimir Suma
Fin
Programa
#include<conio.h>
#include<stdio.h>
int Numero[10];
int n, i, num, Suma;
main(void)
{
for(i=0;i<10;i++)
{
scanf("%d",&num);
Numero[i]=num;
}
for(i=0;i<10;i++)
{
if(Numero[i] % 3==0)
Suma = Suma + Numero[i];
}
printf("\n La suma es %d",Suma);
getch();
}

Chachapoyas
Buscar un número en una lista

EJERCICIO 56
Variables
Numero[10] : Vector de números,
i : contador,
num : número a leer,
posición : posición del elemento,
buscar : Elemento a buscar.
Algoritmo
//Buscar un número en una lista
Entero Numero[10]
Entero i, num
Entero posicion=-1, buscar
Inicio
Leer num
Numero[i]num
Fin desde
Leer buscar
Si Numero[i]=buscar entonces
Posicióni
Fin Si
Fin desde
Imprimir posición
Fin
Programa
#include<conio.h>
#include<stdio.h>
int Numero[10];
int i, num, busca;
int posicion=-1, buscar;
main(void)
{
for(i=0;i<10;i++)
{
scanf("%d",&num);
Numero[i]=num;
}
printf("Deme el numero a buscar: ");
scanf("%d",&buscar);
for(i=0;i<10;i++)
{
if(Numero[i]==buscar)

Chachapoyas
posicion=i;
}
printf("El numero esta en la posicion %d: ", posicion);
getch();
}
//Otra forma de buscar

Algoritmo
Entero Numero[10]
Entero i, num
Entero posicion=-1, buscar
Inicio
Leer num
Numero[i]num
Fin desde
Leer buscar
i0;
Mientras i<10
Si Numero[i]=buscar Entonces
Posicióni
i9
Fin Si
ii+1
Fin Mientras
Imprimir posicion
Fin
Programa
#include<conio.h>
#include<stdio.h>
int Numero[10];
int i, num, busca;
int posicion=-1, buscar;
main(void)
{
for(i=0;i<10;i++)
{
scanf("%d",&num);
Numero[i]=num;
}
printf("Deme el numero a buscar: ");
i=0;
while(i<10)
{
if(Numero[i]==buscar)
{

Chachapoyas
posicion=i;
i=9;
}
i++;
}
printf("El numero esta en la posicion %d: ", posicion);
getch();
}
Ordenar datos en una lista

EJERCICIO 57
Algoritmo
//Ordenar datos en una lista poniendo el dato más pequeño al comienzo
Entero Numero[10]
Entero i, j, num, temp
Inicio
Leer num
Numero[i]num
Fin Desde
//Ordenar
Desde j=0 hasta 9 hacer
Si Numero[i] > Numero[j] Entonces
temp = Numero[j]
Numero[j] = Numero[i]
Numero[i] = temp
Fin Si
Fin Desde
Fin Desde
//Imprimir lista ordenada
Imprimir Numero[i]
Fin Desde
Fin
Programa
//Ordenar datos en una lista
#include<conio.h>
#include<stdio.h>
int Numero[10];
int i, j, num, temp;
main(void)
{
for(i=0;i<10;i++)
{
scanf("%d",&num);
Numero[i]=num;

Chachapoyas
}
//Ordenar
for(i=0;i<10;i++)
{
for(j=0;j<10;j++)
{if(Numero[i] > Numero[j])
{
temp = Numero[j];
Numero[j] = Numero[i];
Numero[i] = temp;
}
}
}
for(i=0;i<10;i++)
{
printf("\n Numero: %d", Numero[i]);
}
getch();
}
//Otra forma de ordenación
Algoritmo
//Ordenar datos en una lista poniendo el dato más grande al final
Entero Numero[10]
Entero i, j, num, temp
Inicio
Leer num
Numero[i]num
Fin Desde
//Ordenar
Desde j=0 hasta 8-i hacer
Si Numero[j] > Numero[j+1] Entonces
tempNumero[j]
Numero[j]Numero[j+1]
Numero[j+1]temp
Fin Si
Fin Desde
Fin Desde
Imprimir Numero[i]
Fin Desde
Fin
Programa
//Ordenar datos en una lista
#include<conio.h>

Chachapoyas
#include<stdio.h>
int Numero[10];
int i, j, num, temp;
main(void)
{
for(i=0;i<10;i++)
{
scanf("%d",&num);
Numero[i]=num;
}
//Ordenar por el método de la burbuja
for(i=0;i<10;i++)
{
for(j=0;j<9-i;j++)
{if(Numero[j] > Numero[j+1])
{
temp = Numero[j];
Numero[j] = Numero[j+1];
Numero[j+1] = temp;
}
}
}
for(i=0;i<10;i++)
{
printf("\n Numero: %d", Numero[i]);
}
getch();
}
Búsqueda binaria
EJERCICIO 58
Algoritmo
//Búsqueda binaria
Entero Numero[10]{10,15,18,18,19,19,20,21,24,38}
Entero i, j, posicion, buscar
Entero medio=0, inicio=0, fin=9
Inicio
//buscar
Leer buscar
Mientras inicio <= fin
Medio(inicio + fin) / 2
Si Numero[medio] = buscar Entonces
posicion  medio
inicio inicio+1
Sino
Si buscar<Numero[medio] Entonces
fin  medio-1
Sino
iniciomedio+1

Chachapoyas
Fin Si
posición -1
Fin Si
Fin Mientras
Imprimir posicion
Fin
Programa
//Búsqueda binaria
#include<conio.h>
#include<stdio.h>
int Numero[10]={10,15,18,18,19,19,20,21,24,38};
int i, j, posicion, buscar;
int medio=0, inicio=0, fin=9;
main(void)
{
//buscar
printf("Dame el dato a buscar: ");
while (inicio <= fin)
{
medio=(inicio + fin) / 2 ;
if (Numero[medio] == buscar)
{ posicion = medio;
inicio=inicio+1;
}
else
{
if(buscar<Numero[medio]) fin = medio-1;
else inicio = medio + 1;
posicion=-1;
}
}
//Imprimir posición
printf("\n Posicion: %d", posicion);
getch();
}
Busca la cantidad de veces que se repite un número en una lista

EJERCICIO 59
Algoritmo
Vector[10] : vector de 10 posiciones,
A : Variable para leer números.
Algoritmo
//Busca la cantidad de veces que se repite un número en una lista
Entero Vector[10]{10,20,10,18,19,19,20,20,10,20}
Entero i, j, c, A
Inicio
//buscar

Chachapoyas
AVector[i]
c0
Si Vector[j]=A Entonces
cc+1
Vector[j]0 //Poniendo a 0 los vectores contados
Fin Si
Fin Desde
//Imprimir repetidos
Si A!=0 entonces
Imprimir A
Imprimir c
Fin Si
Fin Desde
Fin
Programa
//Busca la cantidad de veces que se repite un número en una lista
#include<conio.h>
#include<stdio.h>
int Vector[10]={10,20,10,18,19,19,20,20,10,20};
int i, j, c, A;
main(void)
{
//buscar
printf("Contando las repeticiones");
for(i=0;i<10;i++)
{
A=Vector[i];
c=0;
for(j=0;j<10;j++)
{
if(Vector[j]==A)
{
c=c+1;
Vector[j]=0;
}
}
//Imprimir repetidos
if(A!=0)
{
printf("\n Numero: %d Repeticiones: %d", A, c);
}
}
getch();
}
6.4 Matrices a arreglo bidimensional

Pensemos en un colegio de cinco grados: 1º, 2º, 3º, 4º y 5º con cuatro secciones por grado: A,
B, C y D. En este caso tendríamos una estructura como la que se muestra en la tabla.

Chachapoyas
Tabla 19: Representación en una matriz de las secciones de un colegio

profesor
1º María José Ernesto Merlin
2º Luis Iker Sergio Jorge
grado
3º Juan Enmanuel Aurelio Nina
4º Alejandro Julio Orlando Leoncio
5º Pedro Luis Kevin Esther
A B C D
sección
Para guardar los nombres de cada profesor tendríamos que usar las variables: profeso1,
profesor2, profesor3, profesor4,… profesor20 de tipo alfanumérico o cadena. Sin embargo si
serían 10 secciones necesitaríamos 50 variables diferentes de tipo cadena cada una. También
sería complicado usar estructuras repetitivas para asignar el nombre de cada profesor a cada
variable.
Usando un arreglo bidimensional o matriz se requiere una sola variable cuya estructura se
muestra a continuacion.
Tabla 20: Matriz de secciones de un colegio

profesor
0 María José Ernesto Merlin
1 Luis Iker Sergio Jorge

Grado
2 Juan Enmanuel Aurelio Nina
3 Alejandro Julio Orlando Leoncio
4 Pedro Luis Kevin Esther
0 1 2 3
sección
La variable para referirnos al arreglo bidimensional, nuevamente puede ser profesor. En este
sentido para asignar el nombre del profesor del segundo grado y la sección tres a la variable
profesor se haría así:
profesor[1][2]”Sergio”
Los índices [1][2] de la variable profesor apunta al segundo grado y a la sección tres. Por el
contrario, si el nombre de la profesora de la sección D de quinto grado la queremos asignar a
una variable maestra se haría así:
maestraprofesor[4][3]
Como se ve, los índices [0][0] apuntan a la primera posición. Un aspecto importante para no
complicarse al momento de programar es entender que en la variable profesor[f][c], f refiere
a las filas y c a las columnas, aspecto importante para saber como acceder a los valores de la
matriz o asignar valores a los campos de la matriz. Luego podríamos crear un programa para
registrar los nombres de los profesores de cada sección y cada grado usando una estructura
secuencial con muchas líneas de código o escribir pocas líneas de código usando una estructura

Chachapoyas
de datos de tipo matriz y dos estructuras repetitivas para o mientras para dar solución a este
problema.
En lenguaje C la declaración de un arreglo bidimensional o matriz numérica se hace así:
Entero matrizNumero[5][4]
En la matriz matrizNumero se pueden guardar hasta 20 números enteros en cinco filas y cuatro
columnas. Sin embargo para el tratamiento de cadenas o variables alfanuméricas difiere un poco:
char profe[20], nos permite guardar un nombre de un profesor a lo más de 20 caracteres.
char matrizProfesor[5][4][25], nos permite guardar 20 nombres de a lo más 25
caracteres cada uno.
6.5 Ejercicios con matrices o arreglos bidimensionales
Hacer un programa para registrar los números de la matriz adjunta.

EJERCICIO 60
0 1 2
0 23 2 12
1 45 5 13
2 67 67 14
3 78 9 16
4 34 4 23
5 34 6 12
Variables
matrizNumero[5][3]: variable para guardar números,
Entero i, j : contador,
Num : número,
Suma : para sumar la columna del centro.
Algoritmo
Entero matrizNumero[5][3]
Entero i, j, num, Suma
Inicio
Leer num
matrizNumero[i][j]num
Fin Desde
Fin Desde
//Imprimir
Imprimir matrizNumero[i][j]
Fin Desde
Fin Desde
//Sumar la columna del centro
Suma=Suma+matrizNumero[i][1]

Chachapoyas
Fin Desde
Imprimir Suma
Fin
Programa
#include<conio.h>
#include<stdio.h>
int matrizNumero[5][3];
int i, j, num, Suma;
main(void)
{
for(i=0;i<5; i++)
{
for(j=0;j<3; j++)
{
printf("Escriba un numero: ");
scanf("%d",&num);
matrizNumero[i][j]=num;
}
}
//Imprimir
for(i=0;i<5; i++)
{ printf("\n");
for(j=0;j<3; j++)
{
printf("[%d][%d]=%d ",i,j,matrizNumero[i][j]);
}
}
//Sumar la columna del centro
for(i=0;i<5; i++)
{
Suma=Suma+matrizNumero[i][1];
}
printf("\nSuma de la columna central: %d",Suma);
getch();
}
Hacer un programa para registrar los nombres de los profesores de cinco

EJERCICIO 61 grados, cada grado tiene cuatro secciones. Mostrar el nombre del
profesor dado el grado y la sección correspondiente.
profesor
0 María José Ernesto Merlin
1 Luis Iker Sergio Jorge

Grado
2 Juan Enmanuel Aurelio Nina
3 Alejandro Julio Orlando Leoncio
4 Pedro Luis Kevin Esther
0 1 2 3
sección

Chachapoyas
Variables
matrizProfesor[5][4] : variable 5 filas y 4 columnas para guardar los nombres de los
profesores,
profe : nombre del profesor de seccion,
i, j : contador.
Algoritmo
Alfanumerico matrizProfesor[5][4], profe
Entero i, j, num
Inicio
Leer profe
matrizProfesor[i][j]profe
Fin Desde
Fin Desde
//Imprimir
Imprimir matrizProfesor[i][j]
Fin Desde
Fin Desde
//Buscar
Leer i
Leer j
Imprimir matrizProfesor[i-1][j-1]
Fin
Programa
#include<conio.h>
#include<stdio.h>
#include<string.h>
char matrizProfesor[5][4][20], profe[20];
int i, j;
main(void)
{
for(i=0;i<5; i++)
{
for(j=0;j<4; j++)
{
printf("Profesor del grado: %d seccion: %d: ", i+1, j+1);
scanf("%s",&profe);
strcpy(matrizProfesor[i][j],profe);
}
}
//Imprimir
for(i=0;i<5; i++)
{ printf("\n");
for(j=0;j<4; j++)
{
printf("[%d][%d]=%s ",i+1,j+1,matrizProfesor[i][j]);
}

Chachapoyas
}
//Buscar
printf("\nBuscar profesor de");
printf("\nGrado: ");
scanf("%d",&i);
printf("\nSeccion: ");
scanf("%d",&j);
printf("\n Grado: %d Seccion: %d = %s",i,j,matrizProfesor[i-1][j-
1]);
getch();
}

6.6.1 Vectores y matrices
1) Escribir un programa que lea diez números, los guarde en un vector y a continuación los
imprima en orden inverso al de su entrada.
2) Escribir un programa que lea 10 números y los guarde en un vector. A continuación los
ordenará y guardará los valores ordenados en otro vector. Finalmente mostrará ambas listas
de números por la pantalla.
3) Repetir el ejercicio anterior con un número cualquiera de valores.
4) Escribir un programa que llene una matriz de cinco por cuatro con valores aleatorios. A
continuación el programa debe imprimir por pantalla. El programa también debe imprimir las
sumas de cada fila y columna.
5) Escribir un programa que pida un número e imprima por pantalla su tabla de sumar. Por
ejemplo si el número fuera el 3 la tabla debería ser:
+ 0 1 2 3
0 0 1 2 3
1 1 2 3 4
2 2 3 4 5
3 3 4 5 6
6.6.2 Cadenas de caracteres

1) Escribir un programa que pida una frase acabada en un punto y cuente las palabras que
contiene.
2) Escribir un programa que pida una palabra y cuente el número de vocales y consonantes que
contiene.
3) Escribir un programa que lea una frase y la escriba en mayúsculas.
4) Escribir un programa que sirva para generar códigos de usuario por el procedimiento
siguiente: tiene que leer los dos apellidos y el número de DNI del usuario y devolver un
código de usuario formado por las tres primeras letras del primer apellido más el número de
DNI. Por ejemplo, si la cadena de entrada es: “José Vargas Rojas” y DNI 26012545 debe
devolver “VAR26012545”.
“Es mejor encontrar una estrategia que solucione mil problemas,

antes que buscarle a cada problema una estrategia de solución” ASM.

Chachapoyas
BIBLIOGRAFÍA
• Cairó Battistutti, O. (2010). Metodología de la programación: Algoritmos,

diagramas de flujo y programas (3ª. ed.). México: Alfaomega.
• Hennefeld, J. (1989). Turbo Pascal con Aplicaciones 3.0, 4.0, y 5,0. USA: PWS
Publishers.
• Joyanes Aguilar, J. (1998). Fundamentos de programación: Algoritmos y
Estructura de Datos (1ª ed). España: McGraw Hill/Interamericana de España.
• Lopez Roman, L. (2003). Programación estructurada: un enfoque algorítmico (2a
ed.) México: Alfaomega.
• Maynard Kong. (1987). Lenguaje de Programación C. Fondo editorial de la
Pontificia Universidad Católica del Perú. Lima.
• Schildt, H. (1998). Programación en Turbo C (1ª. ed. en español). España:
McGraw Hill/Interamericana de España.

Chachapoyas
APÉNDICE A
EJERCICIO PROPUESTO
Desarrollar un algoritmo para un programa que imprima 40 números generados aleatoriamente distintos
entre 1 y 40. Sugerencia use un arreglo.
Ejemplo de resultados:
• 29, 26, 17, 33, 25, 18, 37, 23, 13, 3, 24, 1, 11, 22, 7, 21, 10, 31, 6, 2, 4, 15, 27, 19, 38, 40,
14, 34, 32, 36, 8, 30, 35, 28, 5, 9, 20, 39, 16, 12.
• 16, 13, 4, 20, 12, 5, 24, 11, 10, 40, 30, 28, 38, 9, 34, 8, 37, 18, 29, 31, 2, 14, 39, 6, 25, 27,
21, 19, 23, 35, 17, 22, 7, 1, 15, 32, 36, 3, 33, 26
Con el mismo procedimiento usted puede generar una cantidad mayor de números para tener una idea
de la capacidad de microprocesamiento de su computadora.

Chachapoyas
Introducción a la programación
Ingeniería de sistemas 2014-II
MsC. Abraham Sopla Maslucán
Apendice B
Primer examen 2014-1
1. Desarrolle un algoritmo que permita calcular la nota de unidad del curso de introducción a la
programación.
2. Hacer un algoritmo para calcular el total a pagar por tres chompas si la tienda ofrece un
descuento de 15%.
3. A un trabajador le pagan según sus horas trabajadas y una tarifa de pago por hora. si la
cantidad de horas trabajadas es mayor a 40 horas. La tarifa se incrementa en un 50% para
las horas extras. calcular el salario del trabajador dadas las horas trabajadas y la tarifa.
4. La empresa Milagrito S.A. tiene la siguiente tabla de valores para pagar las comisiones de sus
ejecutivos de ventas:
Parámetro de venta
% de comisión
Desde hasta
2000 10000 7%
10000.01 20000 10%
20000.01 En adelante 15%
Escriba un programa que al introducir la cantidad vendida por el ejecutivo de ventas,

calcule cuánto será su comisión.
5. Calcular mediante un algoritmo repetitivo la suma de los N primeros números naturales a
partir de un número E.
Segundo examen 2014-2 (V1)
1. Programa que lea un número expresado en segundos y lo visualice en el equivalente de

minutos y segundos. (Utilizar los operadores / y % que sólo se utilizan con enteros).
2. De los estudiantes que se matriculan en la Universidad, los ex soldados pagan 30 soles por
curso en el que se matriculen, mientras que los demás (regulares), pagan 50 soles por curso.
Diseñe el algoritmo para escribir un programa en el que el usuario introduce los datos del
estudiante (ex soldado o regular) y el número de cursos y las salidas sean la categoría del
estudiante (ex soldado o regular), número de cursos y los costos totales por los cursos a
llevar.
3. El Depto. de Seguridad Publica y Transito del D.F. desea saber, de los n autos que entran a
la ciudad de México, cuantos entran con calcomanía de cada color. Conociendo el último
dígito de la placa de cada automóvil se puede determinar el color de la calcomanía utilizando
la siguiente relación:
DÍGITO COLOR
1o2 amarilla
3o4 rosa
5o6 roja
7o8 verde
9o0 azul

Chachapoyas
4. Sumar los números enteros de 50 al 100 mediante: estructura repetir y estructura mientras.
5. Mostrar tabla de multiplicar de dos números por sumas sucesivas.
1. Escribir un programa que permita jugar a doble o nada: El jugador apuesta una cantidad y
tira una moneda. Si sale cara obtiene el doble de la cantidad apostada. Si sale cruz la pierde
todo.
2. El Depto. de Seguridad Publica y Transito del D.F. desea saber, de los n autos que entran a
la ciudad de México, cuantos entran con calcomanía de cada color. Conociendo el último
dígito de la placa de cada automóvil se puede determinar el color de la calcomanía utilizando
la siguiente relación:
DÍGITO COLOR
1o2 amarilla
3o4 rosa
5o6 roja
7o8 verde
9o0 azul
3. Escribir un programa que pida la nota de un examen (un número real entre 0 y 20) e imprima
por pantalla la calificación en formato “Suspenso”, si la nota es menor que 10.5, “Aprobado”
si está entre 10.5 inclusive y 12 sin incluir, “Notable” si está entre 12 inclusive y 15 sin incluir,
“Sobresaliente” si está entre 15 inclusive y 20 sin incluir y “Matrícula de honor” si la nota es
igual a 20. Use funciones.
4. Mostrar tabla de multiplicar de dos números por sumas sucesivas.
5. Escribir una función que convierta un número entero en otro número entero que será el
primero pero con las cifras que lo forman escritas al revés. Ejemplo: convertirá el número
entero 1842 en el 2481.
1. Escribir un programa que calcule la nómina de un trabajador de la manera siguiente. El

trabajador cobra un precio fijo por hora y se le retiene un 5% en concepto de seguro social.
El programa debe pedir el nombre del trabajador, las horas trabajadas y el precio que cobra
por hora. Como salida debe mostrar el sueldo bruto, la retención y el sueldo neto.
2. Diseñar una función que calcule el cociente y resto de la división entera de dos números
mediante restas y sumas.
3. Realizar un programa para obtener la suma de la serie 1 + 1/2 + 1/3 +... + 1/N hasta que
la suma sea mayor de 3. Visualiza el valor de N.
4. Escribir una funcion que calcule la suma de los cuadrados de los n primeros números
naturales: 1 + 22 + 32 +… + n2.

Chachapoyas
5. Escribir una función que calcule el cuadrado de un número haciendo sólo sumas. Ayuda: el
cuadrado de un número n es la suma de los n primeros números impares. Ejemplo:
32=1+3+5=9.

Chachapoyas

Chachapoyas
Glosario de términos
B L
BUCLE for, 55 LA FUNCIÓN main(), 21
C O
Centinela, 74 OPERADORES, 23, 24
D P
do-while, 31 Procedimientos, 33
PSEUDOCÓDIGO, 7
F
S
Fibonacii, 36
for ANIDADO, 67 SENTENCIA switch, 28
Funciones, 33
V
I VARIABLES Y CONSTANTES, 19
if else, 43

Chachapoyas
Estamos convencidos que éste sea uno de los textos más sencillos y prácticos porque en
eso hemos pensado desde muy antes de iniciar este proyecto, es decir en los principiantes y el
bello mundo de la programación y la algoritmia, un tema muy complicado para muchos
estudiantes de las carreras de informática, sistemas y ramas de la ingeniería.
Con el presente trabajo aportaremos con un grano de arena al proceso de aprendizaje

del curso de algoritmia y programación en lenguaje C, en ese sentido queremos que ese proceso
se haga más fácil, sin antes recordar la importancia que tienen el buen conocimiento de las
matemáticas y el buen uso de la comprensión lectora en este campo. Muchas veces los problemas
en la vida se presentan complicados y dependen de la buena lectura, capacidad de escucha e
interpretación de los mismos, para después pensar en los posibles cálculos o procesos
matemáticos para solucionar los problemas en computadora.
La característica principal del libro es la sencillez con la que explicamos la solución de los
problemas que planteamos; usando estructuras secuenciales, selectivas, bucles, funciones,
procedimientos y arreglos, que corresponde a los temas de los cursos de algoritmos, técnicas de
programación, sistemas operativos para principiantes; escribiendo los programas en el Lenguaje
C de la forma mas sucinta, e indicando las variables, el pseudocódigo y el programa respectivo;
situaciones que no se contemplan en otras obras. Me atrevo a decir que si se logra entender los
ejercicios desarrollados en este libro, entonces se puede esperar el éxito como futuro
programador en cualquier otro lenguaje de programación similar a lenguaje C.

C - ALGORITMOS - C - 2010 v3 PDF

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

C - ALGORITMOS - C - 2010 v3 PDF

Cargado por

Copyright:

Formatos disponibles

Abraham Sopla Maslucán

Facultad de Ingeniería de Sistemas y Mecánica Eléctrica

Primera edición, diciembre 2017

Este documento ha sido publicado bajo la licencia Creative Commons

Abraham Sopla Maslucán 3|Página

1.2 Estrategia para resolver problemas con algoritmos

Cuando usted está resolviendo un examen de algoritmia o programación va donde el profesor a

Abraham Sopla Maslucán 4|Página

1.2.1 Pasos para definir problemas

2. Identificar las entradas, procesos y salidas

Ejemplo 1: Escribir un algoritmo para un programa que calcule el área de un trapecio.

Otra forma sería a través de dos procesos

Salidas: La única salida sería el area , en ambos casos

Abraham Sopla Maslucán 5|Página

Ejemplo 2: Escriba un programa que calcule la suma de:

Abraham Sopla Maslucán 6|Página

2.1 Recursos para escribir programas en C

2.2 Instalación de compilador y editor C/C++

Paso 1: Instalando el compilador c++

Paso 2: Instalando el editor de c++

Paso 3: Configuración del compilador

2. Es importante que cuando guardemos el archivo, en el campo Tipo escojamos la opción

Abraham Sopla Maslucán 7|Página

Figura 1: Guardando un archivo en Sc1

Nota: Si el archivo no es visible, debes ir a opciones de carpeta ó similar y buscar la opción

Abraham Sopla Maslucán 8|Página

Figura 2: Variable de entorno

Figura 3: Ubicando la variable del sistema

8. Haz clic en Aceptar:

Figura 4: Modificando la variable entorno

Abraham Sopla Maslucán 9|Página

9. Listo, tu compilador está instalado y configurado correctamente.

2.3 Instalación rápida del paquete completo

2. Ahora ejecuta el programa Sc1.exe que está en C:\Borland\BCC55\Bin, verás el entorno

Figura 5: Entorno general de Sc1

Abre el programa: Sc1.exe escribe lo siguiente en él y guárdalo como:

Abraham Sopla Maslucán 10 | P á g i n a

Figura 6: Hola mundo en el editor Sc1

Primero: Escribimos el código tal como se muestra en la imagen.

Figura 7: Factorial de un número en Sc1

Paso 2: Guardamos el código con un nombre, en este caso factorial.cpp

Abraham Sopla Maslucán 11 | P á g i n a

Figura 8: Guardar un archivo en Sc1

#include<math.h> //declaración de librería

Abraham Sopla Maslucán 12 | P á g i n a

2.5 Variables y constantes

Ejemplo de variables: m1, suma2, da2s, etc.

2.5.2 Clasificación de variables

Variables locales: son las que se declaran dentro de un procedimiento o función.

Tabla 1: Clasificación de las variables

Tipo variable; Pueden ser inicializadas en la misma

2.6 Estructura más simple de un programa en C

Tabla 2: Partes de un programa

int x, n; Declaración de variables y funciones

Abraham Sopla Maslucán 13 | P á g i n a

2.6.1 La función main() Una función tiene la forma:

2.7 Declaración de variables y tipos de datos

2.7.1 Declaración de variables

2.7.2 Tipo de datos

Tabla 3: Los tipos de datos simples

2.7.3 Cadena de caracteres

Abraham Sopla Maslucán 14 | P á g i n a

2.7.4 Modificadores de los tipos de variables