Algoritmos en Lenguaje C

Abraham Sopla Maslucn
Facultad de Ingeniera de Sistemas y Mecnica Elctrica

Universidad Nacional Toribio Rodrguez de Mendoza
Lima - 2017
La presentacin y disposicin de:
Introducion a la programacin y lenguaje C
Son propiedad del autor, Abraham Sopla Maslucn
Ingeniero de Sistemas por la Universidad Nacional de Cajamarca
Maestro en Ciencias de la computacin Tecnolgico de Monterrey, Mxico.
Doctorando en Ingeniera de Sistemas e Informtica, Universidad Nacional Mayor de San
Marcos, Per.
Profesor nombrado en la EAP de Ingeniera de Sistemas, Facultad de Ingeniera de Sistemas y
Mecnica Elctrica, Universidad Nacional Toribio Rodrguez de Mendoza. Fundador del Instituto
de ingeniera de software y del Instituto de estudios estadsticos y control de calidad.
abrahamsopla@gmail.com
abraham.sopla@untrm.edu.pe
Primera edicin, diciembre 2017

Hecho el depsito 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
INTRODUCCIN ............................................................................................................................... 3
CAPTULO I............................................................................................................................................. 4
INDICACIONES PARA PRINCIPIANTES ..................................................................................................... 4
1.1 PSEUDOCDIGO ....................................................................................................... 4
1.2 ESTRATEGIA PARA RESOLVER PROBLEMAS CON ALGORITMOS ................................................ 4
1.2.1 Pasos para definir problemas ........................................................................................... 5
CAPTULO II............................................................................................................................................ 7
APUNTES DE LENGUAJE C ...................................................................................................................... 7
2.1 RECURSOS PARA ESCRIBIR PROGRAMAS EN C ................................................................... 7
2.2 INSTALACIN DE COMPILADOR Y EDITOR C/C++ ............................................................. 7
2.3 INSTALACIN RPIDA DEL PAQUETE COMPLETO ............................................................... 10
2.4 LIBRERAS ............................................................................................................ 12
2.5 VARIABLES Y CONSTANTES ........................................................................................ 13
2.5.1 Variable .............................................................................................................................. 13
2.5.2 Clasificacin de variables................................................................................................. 13
2.6 ESTRUCTURA MS SIMPLE DE UN PROGRAMA EN C ........................................................... 13
2.6.1 La funcin main() ............................................................................................................. 14
2.7 DECLARACIN DE VARIABLES Y TIPOS DE DATOS ............................................................. 14
2.7.1 Declaracin 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 parntesis ...................................................................................................................... 16
2.8.2 El operador de asignacin ............................................................................................... 16
2.8.3 Operadores aritmticos ................................................................................................... 16
2.8.4 Operadores relacionales .................................................................................................. 16
2.8.5 Operadores lgicos........................................................................................................... 16
2.8.6 Orden de precedencia de los operadores ..................................................................... 17
CAPTULO 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 impresin ................................................................................... 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 seleccin doble if else ............................................................................. 25
4.2.3 Ejercicios con if anidado .................................................................................................. 28
4.2.4 La sentencia switch .......................................................................................................... 31
4.2.5 Ejercicios con seleccin mltiple 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
CAPTULO 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
CAPTULO V ......................................................................................................................................... 82
ARREGLOS............................................................................................................................................ 82
6.1 INTRODUCCIN 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
BIBLIOGRAFA.............................................................................................................................. 102
APNDICE A ................................................................................................................................... 103
APENDICE B ................................................................................................................................... 104
GLOSARIO DE TRMINOS .......................................................................................................... 108
ii
Algoritmos y Lenguaje C
Introduccin
Los estudiantes de las materias de lenguajes de programacin, tcnicas de programacin,
algoritmos, estructuras de datos y de la informacin, sistemas operativos, entre otros, darn fe de
lo complicado que a veces resultan estas materias cuando no entendemos cmo es que la
computadora interpreta internamente las lneas de cdigo escritas en algn lenguaje de
programacin para realizar una actividad. Quin tiene una nocin de cmo se
an los datos en una hoja de clculo Excel?, de manera que, luego de seleccionar una lista de datos,
pulsamos en el botn ordenar de la barra de herramientas y ya. Quin sabe cmo la computadora
calcula el trmino n de una sucesin de nmeros?, as podramos mencionar muchos casos ms.
Muchos operaramos las computadoras para resolver problemas sin antes hacer por lo menos
un pequeo plan acerca de la solucin o tantear el camino a seguir para llegar a la solucin de una
situacin problemtica 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; ms cierto, es que primero sepamos resolver los
problemas usando algoritmos en pseudocdigo 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 estn representados usando pseudocdigo e
implementados en lenguaje C, evitando complicaciones en el uso del lenguaje. La claridad con que
estn escritos hace que estos se puedan implementar fcilmente en otros lenguajes de programacin
como java. Es as como se cumple nuestro propsito de ayudar al lector a dar el paso seguro del
algoritmo en pseudocdigo al programa, situacin difcil para muchos principiantes. El objetivo es
que tengan un buen comienzo en este largo camino de la programacin y que este sea el ms corto
posible.
En los primeros captulos 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 ms bien en el uso del mismo en la resolucin de
problemas comunes. Segn 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 mtodo simple y efectivo para
solucionarlos, explicando desde el algoritmo que soluciona un problema hasta la construccin del
programa.
Este trabajo est orientado a estudiantes que se inician en educacin superior, en carreras
de ingeniera mecnica, elctrica, de sistemas, de computacin e informtica, electrnica, 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 gua para poder solucionar otros problemas. No ms queda decir que, disfruten de este
material didctico para fortalecer su formacin acadmica y profesional.
Abraham Sopla Maslucn 3|Pgina

UNTRM: EAP de Ingeniera de sistemas
Chachapoyas
Captulo I: Indicaciones para principiantes
Captulo I
Indicaciones para
principiantes
1.1 Pseudocdigo
El pseudocdigo es un lenguaje general, de especificacin de la solucin del problema
mediante un algoritmo. Se considera como el paso anterior a la codificacin. La ventaja es que, este
lenguaje puede ser traducido indistintamente y sin problemas a cualquier lenguaje de programacin
de computadora. Un algoritmo es una secuencia de pasos lgicos que nos conducen hacia la solucin
de un determinado problema.
Nosotros implementaremos los algoritmos usando un lenguaje comn, el ms sencillo para
todos. Adelantamos, si es necesaria la palabrera, ser solamente para aclarar situaciones puntuales
orientados a la solucin de dificultades. La idea en fin, es solucionar los problemas y as lo haremos,
sabiendo que lo ms importante antes de empezar a escribir un programa, es necesario hacer el
algoritmo.
Lgicamente, 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 programacin,
definitivamente todos empezamos haciendo algoritmos; pero si de situaciones acadmicas se trata,
hacer el algoritmo teniendo el programa no necesita de ningn esfuerzo, solamente adherirse a
algunas reglas y trminos de pseudocdigo, como inicio, fin, leer, asignar, imprimir.
1.2 Estrategia para resolver problemas con algoritmos
Cuando usted est resolviendo un examen de algoritmia o programacin 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, despus 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
compaeros e insiste que el problema est mal planteado. Lgicamente, eso puede suceder; si para
usted es siempre as, quizs resulte que en el examen que acaba de desaprobar y despus que el
profesor lo resolvi, usted diga, claro la pregunta era esa!, verdad, haba una solucin! En el
pregrado, nosotros, tambin lo hacamos, as es que no se asuste.
La experiencia nos ensea, 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 continuacin planteamos tres pasos a seguir, indispensables en el desarrollo de problemas
usando algoritmos y programacin.

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
solucin. Si no entiende el problema no contine al paso 2.
2. Identificar las entradas, procesos y salidas

Entradas: Identifique los datos de ingreso al algoritmo o programa.
Procesos: Son las operaciones, clculos matemticos o procesos que se realizan con los
datos de entrada, a veces dependen del conocimiento de algn tema especifico, puede ser
matemticas, estadstica, qumica, biologa, investigacin de operaciones, contabilidad, etc.
Salidas: Son los resultados a imprimirse o mostrarse. Es la solucin 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 secunciales y selectivas son ms complicados

de comprender y fciles de identificar las entradas, procesos y salidas, ya que las soluciones tratan
de al menos de operaciones matemticas u procesos sencillos. Por otro lado los problemas donde se
usan bucles o repeticiones, son sencillos de comprender y difciles 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 geometra y es un tema que todo estudiante de
educacin superior conoce, el problema ya estara comprendido de antemano, especficamente se
trata del clculo 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 numrico de: la base
mayor, base menor y su altura.
Procesos: El proceso general a realizarse sera:
(basemayor basemenor)
area *h
2
Otra forma sera a travs de dos procesos
Proceso 1:
Luego
Proceso 2:
Salidas: La nica salida sera 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 estn 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 estn en sucesin aritmtica 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
Suma0
Desde a=10 hasta a<=50 hacer
Sumasuma+(1/a)
Fin Desde
Imprimir Suma
Fin

Chachapoyas
Captulo II: Apuntes de lenguaje C
Captulo 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 cdigo llamado Sc1, obtenindolo
de la direccin http://www.scintilla.org. Asimismo debe instalar el compilador Borland C++ 5.5
despus de bajarlo de la direccin http://www.programacionenc.net/modules.php u otra que crea
conveniente1.
2.2 Instalacin 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. Slo se descomprime borland55_ide.zip
Paso 3: Configuracin del compilador
1. Una vez terminada la instalacin, crea con el bloc de notas un archivo, y pega en el las lneas
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 opcin

Todos los archivos ya que de no hacerlo el archivo se guardar con otra extensin 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 lneas
siguientes, gurdalo 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 configuracin adicional, esto se hace para que puedas compilar
tus programas sin importar en donde se encuentre el archivo fuente. La configuracin 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 aade la siguiente
lnea 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 opcin

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 continuacin en la ficha Opciones avanzadas.

Chachapoyas
Figura 2: Variable de entorno
6. Haz clic en el botn Variables de entorno y fjate en el cuadro Variables del sistema.
Figura 3: Ubicando la variable del sistema
7. Selecciona la variable Path y pulsa el botn 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 aade un punto y coma antes de todo, esto es para separar las variables del
sistema que ya estn creadas, producto de la instalacin del resto de programas de tu PC.

Chachapoyas
9. Listo, tu compilador est instalado y configurado correctamente.
2.3 Instalacin rpida del paquete completo

1. Descomprime el archivo: borland55_ide.zip, en el directorio siguiente:
C:\Borland\BCC55\Bin, vers que aparecen los archivos: Sc1.exe y
SciTEGlobal.properties, el primero es el programa ejecutable, el segundo tiene las
opciones de configuracin 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, vers el entorno

desde el cual programars y ejecutars tus programas.
Figura 5: Entorno general de Sc1

Prueba al compilador
Abre el programa: Sc1.exe escribe lo siguiente en l y gurdalo 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, vers
que tanto la compilacin como la ejecucin del programa aparecen en la parte inferior de la
pantalla, aunque tambin puede ejecutar el programa hello.exe, recin generado desde el
Explorador de Windows.
Abraham Sopla Maslucn 10 | P g i n a

Chachapoyas
Figura 6: Hola mundo en el editor Sc1
Por ejemplo puede copiar el cdigo de la solucin del Ejercicio 21 de captulo V. Los pasos para la
escritura, compilacin y ejecucin, en el editor Sc1, de ste cdigo sera:
Primero: Escribimos el cdigo tal como se muestra en la imagen.
Figura 7: Factorial de un nmero en Sc1
Paso 2: Guardamos el cdigo 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 Libreras
C
es un lenguaje pequeo. La funcionalidad de C se obtiene a travs de un rico conjunto de
bibliotecas de funciones, llamados tambin libreras.
Por ejemplo la funcin sqrt pertenece a la librera math.
#include<math.h> //declaracin de librera

{
a=sqrt(25); //uso de la funcin sqrt en el programa principal
NOTA: Si usted intenta usar la funcin sqrt sin declarar la librera math, tendr errores
justamente en la lnea donde este escrita esta funcin. Otras funciones de la librera math
seran sin, cos, tan, etc.
Otras libreras son stdio, stdlib, etc. Las libreras y sus funciones estn escritas en la ayuda
del lenguaje C.
Cada librera contiene sus propias funciones!
La funcin sqrt devuelve la raz cuadrada de un nmero, ejm sqrt(25) regresa 5. La librera
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 mximo de 256 caracteres, el carcter inicial de las variables ser una letra:
Ejemplo de variables: m1, suma2, da2s, etc.

Variables incorrectas: 1num, 25hora, 5p1, etc.
2.5.2 Clasificacin de variables

Las variables pueden ser locales o globales.
Variables locales: son las que se declaran dentro de un procedimiento o funcin.
Variables globales: son aquellas que se definen fuera de las funciones. Pueden ser utilizadas en
cualquier funcin que se declaren despus de ellas, mantienen su valor entre las distintas llamadas.
Tabla 1: Clasificacin de las variables

Variables
Declaracin Descripcin
locales
Pueden ser inicializadas al momento
de ser declaradas. Sus valores
Tipo variable; desaparecen cuando se sale del
Automticas
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
Estticas
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 estticas.
2.6 Estructura ms simple de un programa en C

Lo explicamos a travs 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> Libreras
int x, n; Declaracin de variables y funciones

int suma(int a, int b); que sern definidas por el usuario
Main() Inicio de la funcin principal.
{char c;
x=suma(4,7)
printf( " %d ",x ); Sentencias
exit (0);
}
int suma(int a, int b) Elaboracin de la funcin

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 funcin estndar de C, que se usa para escribir o imprimir datos.
c) \n significa salto de lnea.
d) % Salida formateada.
2.6.1 La funcin main() Una funcin tiene la forma:

Representa a la funcin principal; la
programacin en C es en base a funciones.
Tipo nombre_de_la_funcion(parmetros)
{
Variables locales
Sentencias
}
2.7 Declaracin de variables y tipos de datos
2.7.1 Declaracin de variables

Las variables se escriben usando caracteres, inclusive los nmeros con un tamao mximo de 255
letras, siempre empezando con una letra. Ejemplo de variables son numero1, a, b, c, num6,
promedio, suma_nmeros, a12, as12mn, etc. Vea que en todas las variables empezamos con letras.
La declaracin 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 estn detallados en la Tabla 3.
Tabla 3: Los tipos de datos simples

Tipo Descripcin
Char Carcter (letras)
Int Nmeros enteros (positivos y negativos)
Float Nmeros reales (con punto decimal)
Nmeros de doble precisin, son representados con un
Double
mayor nmero de dgitos que los Double.
2.7.3 Cadena de caracteres

Se derivan de los de tipo carcter, 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 mximo. 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 estudiarn 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 continuacin y
los tipos de datos pueden quedar clasificados de la siguiente manera:
Tabla 4: Modificadores de los tipos de variable

Tipo Tamao(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 *1038 32 *1038
Double 8 1.7 * 10 308 1.7 * 10 308
Los tipos de datos bsicos 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 declaracin de un entero por defecto asume un
nmero con signo.
2.7.6 Lectura y escritura de variables

El lenguaje C usa salida formateada. La funcin printf tiene un carcter especial para formateo %
un carcter 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 continuacin. Ejemplo.
Tabla 5: Lectura y escritura de variables

Formato Tipo dato de salida
%c Carcter
%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 carcter, i entero
decimal, x de coma flotante.
scanf() es la funcin 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 parntesis
Los parntesis 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 parntesis bien usado.
2.8.2 El operador de asignacin

El operador de asignacin es el =,
por ejemplo:
m=4; letra='y';
Se lee:
El nmero 4 es asignado a la variable entera m,
El carcter y es asignado a la variable alfanumrica letra.
2.8.3 Operadores aritmticos

Operadores aritmticos ms usuales: Para: a=5 y b=3.
Tabla 6: Operadores aritmticos

Smbolo Descripcin Ejemplo Valor
+ Suma a+b 8
- Resta a-b+2 4
* multiplicacin a*b-1 14
/ Divisin a/b+3 4.67
% Mdulo a%b 2
2.8.4 Operadores relacionales

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

Smbolo Descripcin Ejemplo Valor Explicacin
< 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 lgicos

Los operadores lgicos se usan con sentencias condicionales o relacionales, los operadores bsicos
lgicos son:

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

Smbolo Descripcin Ejemplo Valor
&& Y (and) (a<b) &&(c>d) 0 (falso)
|| O (or) (a>b)|| (c<d) 9 (verdadero)
! Negacin (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 parntesis, dependiendo
de la operacin 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
Ms alta
()
^ * / %
+ -
< <= > >=
== !=
Ms baja &&
||
Los () son smbolos de agrupacin.
De acuerdo al cuadro anterior

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

Chachapoyas
Captulo III: Estructuras de control
Captulo III
Estructuras de control
3.1 Estructuras secuenciales

Las estructuras secuenciales estn basadas en sentencias de asignacin simples. A continuacin
un ejemplo de algoritmo con estructura secuencial que suma dos nmeros.
Algoritmo
Entero a,b,suma
Inicio
a5;
b12;
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 evaluacin se hace lnea por lnea, 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 ms complejos de abstraer, pero los ms sencillos de identificar procesos que nos llevarn
a su solucin.
En algunos algoritmos se omite la declaracin de variables, en el caso de que el algoritmo
no sea complicado. Adems para el pseudocdigo consideramos dos tipos de variables:
alfanumricos en las cuales se almacenaran datos de tipo texto y los numricos para los datos
de tipo nmero (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 nmero cuando el valor es
VERDADERO. Cuando se declaran variables no se tiene en cuenta la ortografa o la gramtica.
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 lnea un nmero, de la siguiente manera, de
antemano ya nos habremos fijado que el valor de salida es el de la variable c, el problema sera
saber el valor de esta variable c que se mostrar al final o en la lnea 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 lnea por lnea

Lnea 1: a=2
Lnea 2: a=2+1=3
Lnea 3: b=3*2=6
Lnea 4: b=6-1=5
Lnea 5: c=3+2*5=13
Lnea 6: Se presenta 13
El valor de la variable c ser 13.
Hacer el algoritmo para escribir un programa que evale la expresin

EJERCICIO 02 xw
2w
Solucin: observe que los valores de ingreso sern para las variables x, w.
Variables
Resultado: valor de la expresin luego de ser evaluada.
x : guarda un valor numrico ingresado.
w : guarda un valor numrico 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 , tambin de w \n");
//se leen o capturan dos valores escritos en las variables x y
w.
scanf("%f %f",&x,&w);
//Se evala la expresin 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 travs de un printf.
//Evita la ejecucin de esta lnea, se usa para escribir comentarios, como aclaraciones,
recomendaciones, explicaciones, etc.
/* */ Si necesita escribir un comentario extenso, es decir de varias lneas, puede usarlo de la
siguiente manera.
/*...
...Comentario...
... */
\n Permite escribir datos en la lnea siguiente (salta una lnea). Si se escribe \n\n\n
saltaremos 3 lneas, \n\n\n\n saltaremos hasta la cuarta lnea siguiente para imprimir o escribir
el siguiente dato.
3.2.1 Formatos de lectura o impresin
%d Si el dato que se imprimir o leer ser un nmero entero

%f Si el dato que se imprimir o leer ser un nmero real
%c Si el dato que se imprimir o leer ser un carcter.
%s Si el dato que se imprimir o leer ser una cadena
Explicacin:
Estas dos lneas de cdigo:
printf("ingrese el valor de x , tambin de w \n");

scanf("%f %f",&x,&w);
Pueden ser escritas en cuatro lneas 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 evale la expresin

EJERCICIO 03 3x 2 4 y 2
Variables
x : guarda un valor numrico ingresado,
y : guarda un valor numrico ingresado,
resultado : guarda el valor resultado de la expresin.
Algoritmo
Real x, y, resultado
Inicio
Leer x, y
resultadoraizcuadrada(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, tambin 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 lnea de cdigo como:
printf("%f", sqrt(3*x*x+4*y*y));
A menor cantidad de lneas en el cdigo, el programa es mejor.
Y el programa quedara con una lnea de menos.
#include<conio.h>
#include<stdio.h>
#include<math.h>
main(void)
{int x,y;
printf("ingrese el valor de x, tambin 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 transaccin 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 continuacin:
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 declaracin x=7, y=2: enteros, calcular el

valor de la variable y tras evaluar cada una de las siguientes sentencias de asignacin:
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 nmero entero y muestre en pantalla el cociente
y el resto de la divisin 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 ms adecuado para representar cada uno de los datos siguientes:
a. El sueldo de un trabajador,
b. La edad de una persona,
c. El nmero de hijo,
d. El estado civil,
e. El estado de caducado o no de un producto,
f. El N de telfono,
g. La direccin.
2) Escribir un programa para calcular la distancia recorrida por un objeto en movimiento
rectilneo 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
rectilneo acelerado. Dado: t=tiempo, Vo=Velocidad Inicial, Vf=Velocidad final,
g=Aceleracin. El modelo matemtico es el siguiente:
1
= + 2
2
3 5
4) Evalu la expresin , 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 permetro de la figura
indicada:
a) Un cuadrado b) Un rectngulo c) Un tringulo d) Un crculo.
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 atencin a qu tipo de dato resulta ms adecuado para representar
cada dato.
9) Escribir un programa que calcule la nmina 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 retencin 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 Descripcin
if (condicin) If simple: Si condicin es verdadera

{Sentencias1}; entonces se ejecutan las sentencias1.
If (condicin)
{Sentencias1}; If doble: Si condicin es verdadera se
entonces se ejecutan las sentencias1, en
else caso contrario se ejecutan las sentencias2.
{Sentencias2};
if (condicin1)
{Sentencias1};
else if (condicin2)
{Sentencias2}; If anidado: La sentencia que est asociada
a la palabra reservada else se ejecuta si
else if (condicin3)
todas las condiciones de la estructura if
{Sentencias3}; fueron falsas.
...
else
{SentenciasN};
Tabla 11: Sentencia si en pseudocdigo

Sentencias Si Descripcin
Si condicin entonces Condicional simple: Si la condicin es

Sentencias1; verdadera entonces se ejecutan las
Fin Si sentencias1.
Si condicin entonces
Sentencias1; Condicional doble: Si la condicin es
Sino verdadera se ejecutan las sentencias1, en
Sentencias2; caso contrario se ejecutan las sentencias2.
Fin Si
Si condicin1
Sentencias1;
Sino Si condicin2
Condicional anidado: La sentencia que
Sentencias2; est asociada a la palabra reservada sino se
Sino Si condicin3 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 nmero

EJERCICIO 05 ingresado por el teclado es positivo.
Variables
Nu2m: Nmero 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 nmero.... ");
scanf("%d",&num);
if(num>0)
printf("el nmero es positivo");
getch();
}
4.2.2 Ejercicios con seleccin doble if else
EJERCICIO 06 Hacer un algoritmo para un programa que calcule el pago que hacen un
grupo de personas para ver una pelcula 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 ms el pago es 0.5 soles por persona.
Variables
num: Nmero 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 nmero 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 nmero 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 numrico 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
Horascociente(num,3600)
Rminresto(num,3600)
Mincociente(rmin,60)
Segresto(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 nmero 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 Pedaggico Toribio Rodrguez de Mendoza, los

EJERCICIO 08 pagos por curso desaprobado son de 20 soles, con un cargo mximo de
120 soles independiente del nmero de cursos tomados. Ejemplo si un alumno desaprueba 3
cursos pagara 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 nmero de cursos desaprobados y la
salida sea el valor del pago total que el alumno haga por los cursos desaprobados.
Variables
x : Nmero 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 nmero 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 dems
(regulares), pagan 50 soles por curso. Disee el algoritmo para escribir un programa en el que el
usuario introduce los datos del estudiante (ex soldado o regular) y el nmero de cursos y las
salidas sean la categora del estudiante (ex soldado o regular), nmero de cursos y los costos
totales por los cursos a llevar.
Variables
categoria : Asume los valores exsoldado o regular.
nc : Nmero de cursos.
pago : Pago por el total de cursos matriculados
Algoritmo
Alfanumerico categoria
Entero nc, pago
Leer categora
Leer nc
Inicio
Si categora exsoldado entonces
Pagonc*30
Imprimir ex soldado, nc, pago
Sino
Pagonc*50
Imprimir regular, nc, pago
Fin Si
Fin
Programa
#include<stdio.h>
#include<conio.h>
main(void)
{int x,pago,nc;
printf("ingrese la categora: 1) Ex soldado Otro)
Regular\n");
scanf("%d",&x);
printf("ingrese el nmero de cursos\n");
scanf("%d",&nc);
if(x==1)
printf("categora: ex soldado, %d cursos, pago: %d soles
",nc,nc*30);
else
printf("categora: 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 automviles

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

Chachapoyas
mujeres de 21 aos o ms 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 sexomasculino entonces
Si edad<25 entonces
Pago1000
Imprimir edad, sexo, pago
Sino
Pago700
Fin Si
Si no
Si edad<21 entonces
Pago800
Sino
Pago500
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 aos, sexo: masculino, pago: %d soles
",edad,1000);
else
printf("edad: %d aos, sexo: masculino, pago: %d soles
",edad,700);
else
if(edad<21)
printf("edad: %d aos, sexo: femenino, pago: %d soles
",edad,800);
else

Chachapoyas
printf("edad: %d aos, sexo: femenino, pago: %d soles

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

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

EJERCICIO 11 nmero. Si el nmero es positivo debe escribirse el nmero y junto
a l positivo (15 POSITIVO). Si el nmero es cero (0 CERO); Si es
negativo debe escribirse el nmero y junto a el negativo (-5 NEGATIVO).
Ejemplo
10 Positivo
0 Cero
-15 Negativo.
Variables
numero : Nmero ingresado por el teclado
Algoritmo
Entero numero
Inicio
Leer numero
Si nmero >=0 entonces
Si nmero>0 entonces
Imprimir nmero, POSITIVO
Sino
Imprimir nmero, CERO
Fin si
Sino
Imprimir nmero, NEGATIVO
Fin Si
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int num;
printf("ingrese un nmero\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 ms 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 cunto pagar un cliente segn el nmero de sillas que compra. Debe
imprimirse el nmero 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 nmero 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 mltiples, sin embargo esto
puede tornarse en confusiones muy serias para los que leen los programas, inclusive para uno
mismo que ojee su cdigo despus de un buen tiempo de vacaciones. La sentencia de bifurcacin
mltiple switch tiene la solucin. Sean Constante1, Constante2, Constante3, etc. valores de la
variable opcin, los mismos que pueden ser nmeros o caracteres.

Chachapoyas
Tabla 12: La sentencia switch en cdigo C y pseudocdigo

Cdigo C Pseudocdigo
switch (opcin) Segn opcin sea
{ caso constante1
case constante1: Sentencias
Sentencias break;
break; caso constante2
Sentencias break;
break; caso constante3
Sentencias break;
break; ...
... defecto
default: Sentencias
Sentencias Fin Segn
}
4.2.5 Ejercicios con seleccin mltiple switch
Hacer un algoritmo para escribir un programa que devuelva el nombre del

EJERCICIO 13
da de la semana siguiendo un orden de correspondencia (1, 2, 37) para
(lunes, martes, mircoles domingo) respectivamente.
Variable
Nmero : Nmero correspondiente al da de la semana.
Algoritmo
Entero numero
Inicio
Leer nmero
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 NMEROS ENTRE 1 Y 7........ "
Fin Segun
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int dia;
printf("ingrese un nmero entre 1 y 7........ ");
scanf("%d",&dia);
switch(dia)
{
case 1:
printf(" LUNES \n");
break;
case 2:
printf(" MARTES \n");
break;
case 3:
printf(" MIRCOLES\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 NMEROS ENTRE 1 Y 7........ ");
}
getch();
}
Hacer el algoritmo para un programa que calcule:

El valor del rea de un tringulo, dada la base y la altura.
EJERCICIO 14 El valor de la base de un tringulo dada la altura y el rea.
El valor de la altura de un tringulo 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 opcin sea

Chachapoyas
Caso 1
Leer base, altura
area(base*altura)/2
Imprimir area
Caso 2
Leer area, altura
Base2*area/altura
Imprimir base
Caso 3
Leer area,base
Altura2*area/base
Imprimir altura
Caso contrario
Imprimir " Eso es todo amigo
Fin Segn
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{int operacion;
printf("EJERCICIOS DE LOS TRINGULOS ........ \n");
printf("============================ \n\n\n");
printf("1 para calcular el rea de un tringulo \n");
printf("2 para calcular la base \n");
printf("3 para calcular la altura \n\n");
printf("ingrese una opcin ........ ");
scanf("%d",&operacion);
switch(operacion)
{
float area, altura, base;
case 1:
printf("AREA DEL TRINGULO \n");
printf("ingrese la base ........ ");
scanf("%f",&base);
printf("ingrese la altura ........ ");
scanf("%f",&altura);
printf("el area del tringulo es %f ",base*altura/2);
break;
case 2:
printf("BASE DE UN TRINGULO \n");
printf("ingrese el area ........ ");
scanf("%f",&area);
printf("la base de area del tringulo es %f ",2*area/altura);
break;
case 3:
printf("ALTURA DE UN TRINGULO \n");
scanf("%f",&area);
scanf("%f",&base);

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

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

un tringulo, un trapecio, un rectngulo y el rea de un tringulo en funcin de sus lados.
Algoritmo
En este caso usted puede guiarse del algoritmo del ejercicio 14 y escribir el proceso matemtico
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 tringulo \n");
printf("2 para calcular el rea de un trapecio \n");
printf("3 para calcular el rea de un rectngulo \n");
printf("4 para calcular el rea de un tringulo en funcin de sus
lados\n\n\n");
printf("ingrese el nmero 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 tringulo 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 TRINGULO EN FUNCIN 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 tringulo 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 nmeros y muestre por pantalla el mayor. Una versin
mejorada informar de si los dos nmeros son iguales.
2) Escribir un programa que pida un nmero e indique si se trata de un nmero par impar.
3) Escribir un programa que pida una nota e imprima por pantalla la calificacin en formato
aprobado o desaprobado segn 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 mximo y el
mnimo de ellos.
6) Escribir un programa que pida un nmero entero y determine si es mltiplo de 2 y de 5 al
mismo tiempo.
7) Escribir un programa que pida la nota de un examen (un nmero real entre 0 y 20) e imprima
por pantalla la calificacin 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 Matrcula de honor si la nota es
igual a 20.
8) Escribir un programa que, dado el nombre o nmero del mes, y la informacin de si el ao
es bisiesto muestre por pantalla el nmero de das 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 explicacin para las estructuras repetitivas los haremos a travs 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 cdigo C y pseudocdigo

Cdigo C Pseudocdigo
for (expresin1; expresin2; expresin3) Desde V=valorInicial hasta valorFinal hacer
{ Sentencias
Sentencias Fin desde
}
Importante: En expresin3 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 mxima 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

nmero de 8 nmeros ingresados por el teclado.
Variables
num : guarda un nmero ingresado,
mayor : Para asignarle el valor del mayor de los nmeros ledos,
menor : Para asignarle el valor del menor de los nmeros ledos,
x : Permite contar los 8 ingresos (valores desde 1 hasta 8).
Algoritmo
Entero num, mayor, menor, x;
Inicio
mayor0;
menor10000;
leer num
si mayor<num entonces mayornum;
si menor>num entonces menornum;
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 NMERO %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 mxima.
Variables
area : Valor del area
x : valor de x.
maxarea : valor de la mxima rea.
maxx : valor delmximo valor de x.
Algoritmo
Entero area, x, maxarea, maxx
Inicio
maxarea0;
areax*(100-2*x);
Si maxarea<area entonces
maxareaarea;
maxxx
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 Escrbase el algoritmo para un programa en el que se pide al usuario

ingresar el nombre, sexo, nmero de horas de trabajo y el sueldo por hora
para cada uno de seis empleados. La primera parte de la impresin 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
*Nmero 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 : nmero de horas trabajadas,
sexo : sexo,
ptt : pago total,
sumasm : suma de pagos de las hombres,
sumasf : suma de pagos de las mujeres,
sm : nmero de hombres cuyos datos se ingresaron,
sf : nmero 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
sumasm0;
sumasf0;
sm0;
sf0;

Chachapoyas
Leer sexo
Si sexo=1 entonces
smsm+1;
Leer nombre,nht, pht
pttnht*pht;
Imprimir nombre, ptt
sumasmsumasm+ptt
Else
sfsf+1;
Leer nombre, nht, pht
pttnht*pht;
sumasfsumasf+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
a1
suma0.5
Desde c=1 hasta c<14 hacer
aa*2+1
sumasuma+(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
nmero n ingresado por el teclado.
Variables
fac : acumulador del valor del factorial del numero ingresado,
c : cuenta el nmero de repeticiones,
num : el nmero cuyo factorial se va a calcular.

Chachapoyas
Algoritmo
Entero c, num, fac
Inicio
Leer num
Fac1
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 nmero 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 Amazona escriba el algoritmo para un programa que

EJERCICIO 22
procese e imprima la informacin de la nmina 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 tpico de datos podra ser:
Nombre N.H.T. P.H. Edad

Juan Sopla 50 5 57
El pago por hora despus 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 impresin en papel debe ser la informacin 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 aos. El nombre y el pago total para el empleado de menos de 55 aos con mximo
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
Mara 70 7 80 595 99 496
Viviana 45 10 52 475 75 400
La solucin sera: Empleado menor de 55 aos con mximo sueldo es Sergio con 460 soles.El
promedio del sueldo para los empleados mayor de 55 aos es: 342.667 soles
Variables
me : la mxima edad,
mp : mximo promedio,
promedio : promedio que se calcula,
nombre : nombre que se ingresa por el teclado,
nme : nombre del que tiene la mxima edad,
nht : nmero 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
mp0;
promedio0;
Desde i=1 hasta 10 hacer
Leer nombre, nht, ph, edad
Si nht>40 entonces total40*ph+(nht-40)*(ph+0.5*ph)
Sino totalnht*ph
Si total>200 entonces impuesto200*0.1+(total-200)*0.2
Sino impuestototal*0.1
netototal-impuesto
Imprimir nombre, nht, ph, edad
Imprimir total, impuesto, neto
Si edad>=55 entonces promediopromedio+neto/3
Sino
Si mp<neto entonces
mpneto;
meedad;
nmenombre
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 nmero 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 aos
\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 aos\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 despus
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

nmero de alumnos que aprobaron y el nmero de los que obtuvieron al menos 18 de nota.
Variables
i : contador,
n1, n2, n3 : notas,
Promedio : promedio de notas,
naa : nmero de alumnos desaprobados,
na18 : nmero de alumnos mayores de 18 aos,
nombre : nombre del alumno,
condicin : asume valores 1 (aprobados), 2 desaprobados.
Algoritmo
Entero i, n1, n2, n3, naa, na18, condicin.
Real promedio
Alfanumerico nombre
Inicio
naa0;
na180;
Leer nombre, n1, n2, n3
promedio(n1+n2+n3)/3
Si promedio>12 entonces
condicion1;
naanaa+1;
sino
condicion2
Fin Si
Si condicion=1 entonces Imprimir nombre, n1, n2, n3, promedio
Sino Imprimir nombre, n1, n2, n3, promedio
Si promedio>=18 entonces na18na18+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 trminos ingresado por el teclado de la serie 5/6,11/12,23/14,...
Variables
i : Contador
n : Numero de trminos 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
Suma0;
Num2;
Desde i=1 hasta n hacer
Numnum*2+1
Sumasuma+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 trminos ");

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 cdigo C y pseudocdigo

Cdigo C Pseudocdigo
while (condicion) Mientras (condicion)
{ sentencias
sentencias; contador
contador Fin Mientras
}
En este caso las sentencias se ejecutan si la condicin es verdadera. La comprobacin es al inicio

del bucle. Este tipo de estructuras incluyen un contador, el mismo que va cambiando sus valores
en cada repeticin y ayuda a romper el bucle en algn momento, en ese sentido este va incluido
de alguna forma en la condicin, de esta manera la estructura while es similar a la estructura
for. Sin embargo cuando no sabemos el nmero 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 instruccin 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
i1

Chachapoyas
Mientras i<=9 hacer

Imprimir i
ii+2
Fin Mientras
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{
int i;
i=1;
while(i<=9)
{
printf(" \n nmero= %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
i0
suma0
Mientras suma<=30 hacer
ii+1
sumasuma+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 nmero entero positivo.

EJERCICIO 28
Si es par divdalo entre 2; y si es impar multiplique por 3 y aumente
en 1. Obtngase enteros positivos repitiendo el proceso hasta llegar a 1. Ejemplo si empezamos
en 5 la serie sera: 5, 16, 8, 4, 2, 1. Haga el algoritmo para un programa que nos permita obtener
secuencias de nmeros 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 numnum/2
Sino numnum*3+1
Imprimir num
Fin Mientras
Fin
Programa
#include<conio.h>
#include<stdio.h>
main(void)
{
int i,num;
printf("ingrese un nmero.. ");
scanf("%d",&num);
while(num>1)
{
if(num%2==0)num=num/2;
else num=num*3+1;
printf(" \n nmero= %d", num);
}
getch();
}
Hacer el algoritmo para un programa que calcule la suma de ciertos

PROGRAMA 29 nmeros ingresados por el teclado. El clculo de la suma se har en
cualquier momento.
Variables
suma : acumulador de la suma,
num : numero ingresado.
Algoritmo
Entero suma, num
Inicio
Suma0
Mientras num <> 0 hacer

Chachapoyas
Leer num
Sumasuma+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 nmero.. ");
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 numrico de los grados farengheit ingresado,
cel : valor numrico de los grados celcius calculado.
Algoritmo
Real fareng, cel
Inicio
fareng30
Mientras fareng<=100 hacer
Cel(fareng-32)*5/9
farengfare+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 evale la funcin

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
segn 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 expresin para cada valor de a.
Algoritmo
Real y
Entero a
Inicio
a1
Mientras a<2.1 hacer
y4*a*a-16*a+15
aa+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 travs del ejercicio 32
Escriba el algoritmo para un programa de nmina 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 numrico 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 numrico que permite finalizar el programa.
Algoritmo
Entero pht, nht, sexo, ptt, sumasm, sumasf, centinela
Real sm, sf
Alfanumerico nombre
Inicio
Sumasm0
Sumasf0
Sm0
Sf0
Mientras centinela <> 1 hacer
Leer sexo
Si sexo<>1 y sexo <> 2 entonces
{
Centinela1 //aqu se origina la salida
Sm1
Sf1
}
Sino
{ Si sexo=1 entonces
{
smsm+1
leer nombre, nht, pht
pttnht*pht

Chachapoyas
Imprimir nombre,ptt
sumasmsumasm+ptt
}
Else
{
sfsf+1
Leer nombre, nht, pht
pttnht*pht
sumasfsumasf+ptt
}
}
Fin si
}
Fin Si
Fin mientras
Imprimir sumasm, sumasm/sm
Imprimir sumasf, sumasf/sf
Fin
Comentario: para este caso cualquier nmero 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 nmero 2,
e : guarda el valor del exponente.
Algoritmo
Real potencia, e
Inicio
Potencia1
e0
Mientras potencia<=1000 hacer
potenciapotencia*2
ee+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 nmero que hace que la suma pase de 21, imprimiendo la suma
y el ltimo entero introducido y el mensaje ms de 21.
Variables
suma : el valor de suma acumulada
num : numero ingresado
Algoritmo
Entero suma, num
Inicio
Suma0
Mientras suma<=21 hacer
Leer num
Si num>=1 y num<=5 entonces sumasuma+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 nmeros entre 1 y 5 \n");
while(suma<=21)
{
printf("Ingrese un nmero ");
scanf("%d",&num);
if(num>=1 && num<=5)
{suma=suma+num;}
}
printf("\ n Suma: %d, Nmero: %d",suma,num);
getch();
}

Chachapoyas
Escriba el algoritmo para un programa que imprima la sucesin completa

de ULAM para un entero de entrada, si la longitud de toda la sucesin es
EJERCICIO 35 no ms de 10. En caso contrario slo se imprimir los 10 primeros enteros
de la sucesin. Haga las pruebas de mano para sucesiones de menores
de 10, nmeros 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 : nmero que se imprimir.
Algoritmo
Entero c, num
Inicio
Leer num
c1;
Mientras num>1 y c<=10 hacer
Si num modulo 2=0 entonces numnum/2
Sino numnum*3+1
Fin Si
Imprimir num
cc+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 nmero= %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 trmino 0, x como el primer trmino, como el segundo trmino,
2!
x3
como el tercer trmino, etc.; entonces el trmino n es igual al trmino n-1 multiplicado por
3!
x
. Haga el algoritmo para un programa basado en esta serie para encontrar una aproximacin
n
a e 2.5 . El programa debe parar cuando el ltimo trmino sumando sea menor de 0.0001.
Compruebe el programa para e 1 y compare con el valor de la funcin que devuelve este valor (
e ) en cualquier lenguaje de programacin.
Variables
t : valor del trmino,
n : posicin del trmino,
e : acumulador de t ,
x : valor del exponente ingresado.
Algoritmo
Real t, a, n, e, x
Inicio
Leer x
n2
tx
e1+x
Mientras t>0000.1 hacer
tt*(x/n)
ee+t
nn+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 nmero de cifras de

EJERCICIO 37 un entero de entrada hasta 32000. As para una entrada de 583 la salida
debe ser 3 cifras, asegrese que el programa funcione para 1 y 10. Para
cero la salida debe ser "UNA CIFRA. El programa no debe cerrarse hasta ingresar el nmero 0.
Variables
x : valor ingresado
Algoritmo
Entero x
Inicio
x1
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 nmero: ");
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 nmeros 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 slo cuando se hayan ingresado los 10 enteros
impares.
Variables
x : valor ingresado,
suma : acumulador de los valores de x,
c : contador de nmeros impares.

Chachapoyas
Algoritmo
Entero x, suma, c
Inicio
Mientras (c<10)
Leer x
Si x modulo 2 <>0 entonces
sumasuma+x
cc+1
Fin Si
Fin Mientras
Imprimir suma
Fin
Programa
#include<conio.h>
#include<stdio.h>
int x,suma,c;
main(void)
{
printf("INGRESE 10 NMEROS IMPARES \n");
while(c<10)
{printf("ingrese un nmero ");
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 nmeros

EJERCICIO 39 primos entre 2 nmeros ingresados por el teclado.
Ejemplo: primer nmero = 5
ltimo nmero =15
Resultado =5, 7, 11, 13
Variables
i : contador, nmero primo,
j : contador,
n1 : primer nmero del rango,
n2 : segundo nmero del rango.
Algoritmo
Entero i, n1, n2, j
Inicio
Leer n1, n2
Desde i=n1 hasta n2 hacer
j2
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 nmero ");
scanf("%d",&n1);
printf("ingrese el segundo nmero ");
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 nmeros 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 condicin al finalizar. El
comportamiento de esta estructura es similar al del bucle while.
Tabla 15: La sentencia do-while en cdigo C y pseudocdigo

Cdigo C Pseudocdigo
do{ Hacer
Sentencias; Sentencias
} Mientras condicin
while(condicin);
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 nmeros 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 mens.
En el siguiente ejemplo al correr el programa imprime la serie 345678910, fjese se supone la

impresin debi ser hasta 9 como mximo. Esto explica que luego se haberse impreso el nmero
10, recin se hace la comparacin.
Algoritmo para la serie 345678910

Entero a;
Inicio
a3;
Hacer
aa+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 nmero de
jugadas y el total ganado y perdido por el jugador.
2) Escribir un programa para jugar a adivinar un nmero entre 1 y 10, el nmero es generado
al azar.
3) Escribir un programa que pida una contrasea y permita tres intentos. Si el usuario da la
contrasea correcta responde "Enhorabuena!" y queda inactivo, con este mensaje. En caso
contrario el programa escribe "Lo siento, contrasea equivocada" y se cierra de inmediato.
4) Escribir un programa que pida un nmero y muestre por pantalla su tabla de multiplicar.
5) Escribir un programa para calcular el promedio de una lista de nmeros positivos, el programa
termina cuando se escribe un nmero negativo.
6) Escribir un programa para sumar los nmeros 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 nmeros y determine cuantos son positivos y
cuntos son negativos.
8) Escribir un programa que dados dos nmeros, uno real (base) y un entero positivo n, saque
por pantalla todas las potencias con base el nmero dado y exponentes entre uno y n
9) Escribir un programa que imprima por pantalla los codigos ASCII correspondientes a los
nmeros 32 al 127.

Chachapoyas
Captulo IV: Funciones y procedimientos
Captulo IV
Funciones y
procedimientos
5.1 Funciones
Sea la funcin f ( x) x 2 2
Tabla 16: Valores de una funcin con una variable

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

Sea la funcin g ( x, y ) x 3 y 1
Tabla 17: Valores de una funcin 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 funcin 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 programacin se tratan teniendo en
cuenta el criterio anterior.
Funcin: Una funcin es un grupo de instrucciones cuya ejecucin se lleva a cabo cada
vez que se invoca el nombre de la funcin con valores de entrada y luego de realizar
un clculo regresa un valor hasta la lnea donde se hizo la llamada a la funcin.
Toda funcin regresa un nico valor

Chachapoyas
Procedimiento: Cuando una funcin 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 ejecucin 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 funcin f(x, y, z), en este caso los argumentos son x, y, z.
En un procedimiento no interesa el nmero 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 travs de funciones
o procedimientos indistintamente.
En Lenguaje C, main es una funcin; es decir es la funcin principal de un programa.
5.1.2 Correspondencia entre argumentos

Se refiere a que los valores de una misma funcin 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 (podra decirse a m 4 )
b corresponde a n y ste a 5 (podra decirse b n 5 )
c corresponde a p y ste a -7 (podra decirse c p 7 )
Como se ve la funcin f tiene 3 variables o argumentos.
5.1.3 Recursividad
Normalmente una funcin f puede llamar a una funcin g y esta a una funcin h y as
sucesivamente. Cuando una funcin se llama a si misma se dice que sigue un proceso recursivo.
En este caso una funcin f se llama as misma, o la funcin f llama a la funcin f; estos conceptos
pueden ser utilizados para calcular el factorial de un nmero 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 funcin:

Variablefuncin(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 nmero

EJERCICIO 40 ingresado.
Algoritmo
Los dos algoritmos que se muestran a continuacin hacen lo mismo, el algoritmo1 es en base a
una funcin y el algoritmo2 en base a un procedimiento.
Tabla 18: Cubo de un nmero

Algoritmo1 Algoritmo 2
Variables Variables
Cubo: funcin, Cubo: funcin,
Num: nmero ingresado, Num: nmero 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
rescubo(num) cubo(num)
Imprimir num, res Fin
Fin //Funcin cubo
//Funcin cubo Nada cubo(x)
Real cubo(x) Inicio
Inicio Entero res
Cubox*x*x resx*x*x
Regresa Cubo Imprimir res
Fin Fin
Cuando una funcin no regresa valores se le puede llamar procedimiento como es el caso de
la funcin cubo de algoritmo2.
Programa
#include<conio.h>
#include<stdio.h>
float num;
float res, cubo(int x);
main()
{
printf("ingrese un nmero ");
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 evale la expresin x y .

EJERCICIO 41
Variables
potencia: es una funcin,
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
//Funcin potencia
Nada potencia(m, n)
Inicio
Entero i, y
y1
Desde i=1 hasta i<=abs(n) hacer
yy*m
Si n<0 entonces y1/y
Fin Si
Fin Desde
potenciay
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 nmeros 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 crculo y

EJERCICIO 42
longitud de circunferencia. Utilizar procedimientos.
Variables
r : valor ingresado,
Circulo : funcin,
m : toma el valor de r,
pi : guarda el valor 3,1416.
Algoritmo
Entero r;
Nada circulo(m)
Inicio
Leer r
circulo(r)
Fin
//Funcin crculo
Nada circulo(m)
Inicio
Real pi
pi3.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
tempx
Xy
Ytemp
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 travs

de procedimientos, es decir una funcin que no devuelve ningn valor.

Chachapoyas
Hacer un algoritmo para un programa que calcule el factorial de un nmero

EJERCICIO 44 n
Variables
n : valor que se ingresa para calcular su factorial,
a : toma el valor de n,
factorial: funcin.
Algoritmo
Entero n
Entero factorial(a)
Inicio
Leer n
Imprimir factorial(n) //llamada a la funcin.
Fin
//Funcin factorial
Entero factorial(a)
Inicio
Si a=0 o a=1 entonces factorial1 //semilla 1
Sino factoriala*factorial(a-1) //aqu el llamado es nuevamente a la funcin
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 funcin
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 funcin
factorial(a), hasta que a=0 o a=1.
}
Explicacin: 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 ensimo elemento

EJERCICIO 45 de la serie FIBONACII. 1, 1, 2, 3, 5, 8,13,
Variables
n : ensimo elemento de la serie fibonacii,
x : toma valores de n,
fibonacii : funcin.
Algoritmo
Entero n
Entero fibonacii(x)
Inicio
Leer n
Imprimir n, fibonacii(n)
}
//Funcin 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
funcin 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 funcin fibonacii(x) hasta que x=0 o x=1.
}
Explicacin: Sea la funcin 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 ensimo elemento de la serie: 4, 6,

EJERCICIO 46 10, 16, 26, 42,
Variables
n : ensimo elemento de la serie,
elemento : funcin.
Algoritmo
Entero n
Entero elemento(x)
Inicio
Leer n
Imprimir n, elemento(n)
Fin
//Funcin elemento
Entero elemento(x)
Inicio
Si x=0 entonces elemento 4 Fin Si //semilla
Si x=1 entonces elemento 6 //semilla
Sino elementoelemento(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 posicin 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 ensimo elemento

EJERCICIO 47 de la serie: 1, 1, 2, 4, 7, 13, 24, 44,
Variables
n : ensimo elemento de la serie fibonacii,
elemento : funcin.
Algoritmo
Entero n
Entero elemento(x)
Inicio
Leer n
Imprimir n, elemento(n)
Fin
//Funcin elemento
Entero elemento(x)
Inicio
Si x=0 entonces elemento1 Fin si //semilla
Si x=1 entonces elemento1 Fin si //semilla
Si x=2 entonces elemento2 //semilla
Sino elementoelemento(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, .... ;
Tambin disee una funcin 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 trmino n,
potenciadedos : funcin,
exponente : funcin.
Algoritmo
Entero n, potencia
Entero potenciadedos(x), exponente(valor)
Inicio
Leer n
Potenciapotenciadedos(n)
Imprimir n, potencia
Imprimir potencia, exponente(potencia)
Fin
//Funcin potenciadedos
Entero potenciadedos(x)
Inicio
Si x=0 entonces potenciadedos1
Sino potenciadedos 2*potenciadedos(x-1)
Fin si
Fin
//Funcin exponente
Entero exponente(valor)
Inicio
Si valor=1 entonces exponente0
Sino exponenteexponente(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 funcin exponente, ya que la posicin que se ingresa
representa el exponente, para comprenderlo mejor vea la solucin 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
funcin exponente.
Variables
n : valor ingresado,
exponente : funcin,
valor : toma el valor de n.
Algoritmo
Entero n
Inicio
Leer n
Imprimir n, exponente(n)
Fin
Inicio
Si valor=1 entonces exponente0
Sino exponenteexponente(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, tambin es funcin,
altura : valor de la altura, tambin es funcin,
area : valor del rea, tambin es funcin.
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 Segn
Fin
Real area(base,altura)
Inicio
Areabase*altura/2
Fin
Real base(area, altura)

Inicio
base2*area/altura
Fin
Real altura(area,base)
Inicio
altura2*area/base
Fin

Chachapoyas
Comentario: algunas variables pueden funcionar como tal o como funciones, en este problema,
fjese 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 operacin a realizar,
base : valor de la base, tambin es procedimiento,
altura : valor de la altura, tambin es procedimiento,
area : valor del rea, tambin es procedimiento.
Algoritmo usando procedimiento

Entero area, base, altura
Inicio
Segn opcin sea
Caso 1
Area()
Caso 2
Base()
Caso 3
Altura()
Fin Segn
Fin
Nada area()
Inicio
Real area, base, altura
Leer base, altura
Areabase*altura/2
Mostrar area
Fin
Nada base()
Inicio
Entero area, base, altura
Leer area, altura
base2*area/altura
Mostrar base
Fin
Nada altura()
Inicio
Real area, base, altura
Leer area,base
altura2*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 tringulo es %f ",base*altura/2);
}
void base()
{
float area,altura;
printf("BASE DE UN TRINGULO \n");
scanf("%f",&area);
printf("la base de area del tringulo es %f ",2*area/altura);
}
void altura()
{
float area,base;

Chachapoyas
printf("ALTURA DE UN TRINGULO \n");

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

1) Disear una funcin que calcule el promedio de varios nmeros introducidos por el teclado.
Hacer dos versiones, una para un nmero fijo de valores y otra para un nmero cualquiera
de valores.
2) Disear una funcin que calcule la potencia ensima de un nmero, es decir que calcule X n
para X, real y n entero.
3) Disear una funcin "aMayusculas()" que convierta una cadena de texto en maysculas.
4) Disear dos funciones "EurosASoles()" y "SolesAEuros()" que realicen las conversiones de
monedas.
5) Disear una funcin "EsBisiesto()" que decida si un ao es bisiesto o no.
6) Escribir una funcin "EsMultiplo" que sirva para determinar si un nmero es mltiplo de otro.
Utilizarlo en un programa que pida la antigedad de un trabajador y calcule cuantas dcadas
de antigedad tiene como trabajador.

Chachapoyas
Captulo VII: Ejercicios propuestos
Captulo V
Arreglos
6.1 Introduccin a los arreglos

Una variable nos ayuda a guardar un solo valor. Qu pasara si se requiere guardar
muchos valores en una variable, por ejemplo si se requiere guardar las notas de 1000 estudiantes,
tendramos que usar 1000 variables, una para cada calificacin. 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 nmero denominado ndice. Los arreglos son "estructuras estticas de
almacenamiento interno" dado que su tamao se declara al principio del programa y ya no se
puede modificar en el transcurso. Y se dice que son de almacenamiento interno porque estn en
la memoria RAM de la computadora.
Los arreglos de una dimensin se llaman vectores, los de 2 dimensiones se llaman
matrices y los de 3 o ms se llaman poliedros o arreglos multidimensionales. En informtica
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 seccin por profesor. Se puede escribir un programa usando una estructura
secuencial, guardando el nombre del profesor de cada seccin, una vez que ha recopilado toda
esa informacin, nos permita preguntarle quien es el maestro que ensea en una seccin.
profesor Mara Julia Manuel Luca
seccin A B C D
Para guardar los nombres de cada profesor tendramos que usar las variables: profeso1,
profesor2, profesor3 y profesor4 de tipo alfanumrico o cadena. Sin embargo si seran 60
secciones necesitaramos 60 variables diferentes de tipo cadena cada una. Tambin sera
complicado usar una estructura repetitiva para asignar el nombre de cada profesor a cada
variable.
Usando un vector es fcil, se requiere una sola variable cuya estructura se muestra a
continuacion.
profesor Mara Julia Manuel Luca
ndice 0 1 2 3
La variable para referirnos al vector sera profesor. En este sentido para asignar el nombre del
profesor de la seccin C a la variable se hara as:
profesor[2]Manuel

Chachapoyas
El ndice dos de la variable profesor apunta a la seccin C. Por el contrario, si el nombre de la

profesora de la seccin D la queremos asignar a una variable maestra se hara as:
maestraprofesor[3]
Como se ve, el primer ndice del vector es 0 e indica la primera posicin, asimismo el ndice 3
apunta a la seccin D. Algo muy importante a tener en cuenta es que cuando se declara un vector
de tamao 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 intil en la memoria RAM de la computadora.
En lenguaje C la declaracin de un arreglo unidimensional o vector numrico se hace as:
Entero vectorNumero[5],
En el vector vectorNumero se pueden guardar hasta cinco nmeros enteros. Sin embargo para
el tratamiento de cadenas o variables alfanumricas esto difiere un poco:
char profe[20], nos permite guardar un nombre de un profesor a lo ms de 20 caracteres.

char matrizProfesor[5][20], nos permite guardar cinco nombres de a lo ms 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 seccin
correspondiente.
Variables
profe1, profe2, profe3, profe4 : nombre de los profesores,
n : seccin.
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
Segn n sea
caso 1
Imprimir profe1
caso 2
Imprimir profe2

Chachapoyas
caso 3
Imprimir profe3
caso 4
Imprimir profe4
Fin Segn
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 : seccin,
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 seccon %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 nmeros y realizar la bsqueda de un

EJERCICIO 52
nmero, imprimiendo tambin su posicin.
Variables
Numero[8] : variable para guardar nmeros,
i : contador,
num : para leer nmeros,
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
//Bsqueda
Leer busca
Si busca == Numero[i] Entonces
Imprimir i, Numero[i]
i8;
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 nmeros

EJERCICIO 53 mayores que 100 y menores de 500, luego realizar la bsqueda un
nmero ingresado. Imprime el nmero y la posicin en donde se
encuentra el nmero buscado.
Variables
Numero[100] : variable para guardar nmeros,
n : cantidad de nmeros,
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
ii+1
Fin Si
Fin Desde
//Imprimir
Imprimir Numero[i]
Fin Desde
//Bsqueda
Leer busca
Si busca == Numero[i] Entonces
Imprimir i, Numero[i]
in;
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 nmeros y muestre

solamente los nmeros ingresados menores e iguales a 25.
Variables
Numero[20] : variable para guardar 20 nmeros,
i : contador,
num : para leer nmeros.
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 nmeros enteros. El

programa debe sumar todos los nmeros que sean mltiplos de 3 e
imprimirlo.
Variables
Numero[10] : variable para guardar 10 nmeros,
i : contador,
Suma : acumulador para sumar nmeros mltiplos 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 nmero en una lista

EJERCICIO 56
Variables
Numero[10] : Vector de nmeros,
i : contador,
num : nmero a leer,
posicin : posicin del elemento,
buscar : Elemento a buscar.
Algoritmo
//Buscar un nmero 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
Posicini
Fin Si
Fin desde
Imprimir posicin
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
i0;
Mientras i<10
Si Numero[i]=buscar Entonces
Posicini
i9
Fin Si
ii+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 ms pequeo 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 ordenacin
Algoritmo
//Ordenar datos en una lista poniendo el dato ms 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
tempNumero[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 mtodo 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();
}
Bsqueda binaria
EJERCICIO 58
Algoritmo
//Bsqueda 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
iniciomedio+1

Chachapoyas
Fin Si
posicin -1
Fin Si
Fin Mientras
Imprimir posicion
Fin
Programa
//Bsqueda 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 posicin
printf("\n Posicion: %d", posicion);
getch();
}
Busca la cantidad de veces que se repite un nmero en una lista

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

Chachapoyas
AVector[i]
c0
Si Vector[j]=A Entonces
cc+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 nmero 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 tendramos una estructura como la que se muestra en la tabla.

Chachapoyas
Tabla 19: Representacin en una matriz de las secciones de un colegio

profesor
1 Mara 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
seccin
Para guardar los nombres de cada profesor tendramos que usar las variables: profeso1,
profesor2, profesor3, profesor4, profesor20 de tipo alfanumrico o cadena. Sin embargo si
seran 10 secciones necesitaramos 50 variables diferentes de tipo cadena cada una. Tambin
sera 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

Grado
0 1 2 3
seccin
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 seccin tres a la variable
profesor se hara as:
profesor[1][2]Sergio
Los ndices [1][2] de la variable profesor apunta al segundo grado y a la seccin tres. Por el
contrario, si el nombre de la profesora de la seccin D de quinto grado la queremos asignar a
una variable maestra se hara as:
maestraprofesor[4][3]
Como se ve, los ndices [0][0] apuntan a la primera posicin. 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 podramos crear un programa para
registrar los nombres de los profesores de cada seccin y cada grado usando una estructura
secuencial con muchas lneas de cdigo o escribir pocas lneas de cdigo usando una estructura

Chachapoyas
de datos de tipo matriz y dos estructuras repetitivas para o mientras para dar solucin a este
problema.
En lenguaje C la declaracin de un arreglo bidimensional o matriz numrica se hace as:
Entero matrizNumero[5][4]
En la matriz matrizNumero se pueden guardar hasta 20 nmeros enteros en cinco filas y cuatro
columnas. Sin embargo para el tratamiento de cadenas o variables alfanumricas difiere un poco:
char profe[20], nos permite guardar un nombre de un profesor a lo ms de 20 caracteres.
char matrizProfesor[5][4][25], nos permite guardar 20 nombres de a lo ms 25
caracteres cada uno.
6.5 Ejercicios con matrices o arreglos bidimensionales
Hacer un programa para registrar los nmeros 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 nmeros,
Entero i, j : contador,
Num : nmero,
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 seccin correspondiente.
profesor

Grado
0 1 2 3
seccin

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 nmeros, los guarde en un vector y a continuacin los
imprima en orden inverso al de su entrada.
2) Escribir un programa que lea 10 nmeros y los guarde en un vector. A continuacin los
ordenar y guardar los valores ordenados en otro vector. Finalmente mostrar ambas listas
de nmeros por la pantalla.
3) Repetir el ejercicio anterior con un nmero cualquiera de valores.
4) Escribir un programa que llene una matriz de cinco por cuatro con valores aleatorios. A
continuacin el programa debe imprimir por pantalla. El programa tambin debe imprimir las
sumas de cada fila y columna.
5) Escribir un programa que pida un nmero e imprima por pantalla su tabla de sumar. Por
ejemplo si el nmero fuera el 3 la tabla debera 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 nmero de vocales y consonantes que
contiene.
3) Escribir un programa que lea una frase y la escriba en maysculas.
4) Escribir un programa que sirva para generar cdigos de usuario por el procedimiento
siguiente: tiene que leer los dos apellidos y el nmero de DNI del usuario y devolver un
cdigo de usuario formado por las tres primeras letras del primer apellido ms el nmero 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 solucin ASM.

Chachapoyas
BIBLIOGRAFA
Cair Battistutti, O. (2010). Metodologa de la programacin: Algoritmos,

diagramas de flujo y programas (3. ed.). Mxico: Alfaomega.
Hennefeld, J. (1989). Turbo Pascal con Aplicaciones 3.0, 4.0, y 5,0. USA: PWS
Publishers.
Joyanes Aguilar, J. (1998). Fundamentos de programacin: Algoritmos y
Estructura de Datos (1 ed). Espaa: McGraw Hill/Interamericana de Espaa.
Lopez Roman, L. (2003). Programacin estructurada: un enfoque algortmico (2a
ed.) Mxico: Alfaomega.
Maynard Kong. (1987). Lenguaje de Programacin C. Fondo editorial de la
Pontificia Universidad Catlica del Per. Lima.
Schildt, H. (1998). Programacin en Turbo C (1. ed. en espaol). Espaa:
McGraw Hill/Interamericana de Espaa.

Chachapoyas
APNDICE A
EJERCICIO PROPUESTO
Desarrollar un algoritmo para un programa que imprima 40 nmeros 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 nmeros para tener una idea
de la capacidad de microprocesamiento de su computadora.

Chachapoyas
Introduccin a la programacin
Ingeniera de sistemas 2014-II
MsC. Abraham Sopla Maslucn
Apendice B
Primer examen 2014-1
1. Desarrolle un algoritmo que permita calcular la nota de unidad del curso de introduccin a la
programacin.
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 segn 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:
Parmetro de venta
% de comisin
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 cunto ser su comisin.
5. Calcular mediante un algoritmo repetitivo la suma de los N primeros nmeros naturales a
partir de un nmero E.
Segundo examen 2014-2 (V1)
1. Programa que lea un nmero expresado en segundos y lo visualice en el equivalente de

minutos y segundos. (Utilizar los operadores / y % que slo 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 dems (regulares), pagan 50 soles por curso.
Disee el algoritmo para escribir un programa en el que el usuario introduce los datos del
estudiante (ex soldado o regular) y el nmero de cursos y las salidas sean la categora del
estudiante (ex soldado o regular), nmero 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 Mxico, cuantos entran con calcomana de cada color. Conociendo el ltimo
dgito de la placa de cada automvil se puede determinar el color de la calcomana utilizando
la siguiente relacin:
DGITO COLOR
1o2 amarilla
3o4 rosa
5o6 roja
7o8 verde
9o0 azul

Chachapoyas
4. Sumar los nmeros enteros de 50 al 100 mediante: estructura repetir y estructura mientras.
5. Mostrar tabla de multiplicar de dos nmeros 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 Mxico, cuantos entran con calcomana de cada color. Conociendo el ltimo
dgito de la placa de cada automvil se puede determinar el color de la calcomana utilizando
la siguiente relacin:
DGITO COLOR
1o2 amarilla
3o4 rosa
5o6 roja
7o8 verde
9o0 azul
3. Escribir un programa que pida la nota de un examen (un nmero real entre 0 y 20) e imprima
por pantalla la calificacin 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 Matrcula de honor si la nota es
igual a 20. Use funciones.
4. Mostrar tabla de multiplicar de dos nmeros por sumas sucesivas.
5. Escribir una funcin que convierta un nmero entero en otro nmero entero que ser el
primero pero con las cifras que lo forman escritas al revs. Ejemplo: convertir el nmero
entero 1842 en el 2481.
1. Escribir un programa que calcule la nmina 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 retencin y el sueldo neto.
2. Disear una funcin que calcule el cociente y resto de la divisin entera de dos nmeros
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 nmeros
naturales: 1 + 22 + 32 + + n2.

Chachapoyas
5. Escribir una funcin que calcule el cuadrado de un nmero haciendo slo sumas. Ayuda: el
cuadrado de un nmero n es la suma de los n primeros nmeros impares. Ejemplo:
32=1+3+5=9.

Chachapoyas

Chachapoyas
Glosario de trminos
B L
BUCLE for, 55 LA FUNCIN main(), 21
C O
Centinela, 74 OPERADORES, 23, 24
D P
do-while, 31 Procedimientos, 33
PSEUDOCDIGO, 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 ms sencillos y prcticos porque en
eso hemos pensado desde muy antes de iniciar este proyecto, es decir en los principiantes y el
bello mundo de la programacin y la algoritmia, un tema muy complicado para muchos
estudiantes de las carreras de informtica, sistemas y ramas de la ingeniera.
Con el presente trabajo aportaremos con un grano de arena al proceso de aprendizaje

del curso de algoritmia y programacin en lenguaje C, en ese sentido queremos que ese proceso
se haga ms fcil, sin antes recordar la importancia que tienen el buen conocimiento de las
matemticas y el buen uso de la comprensin lectora en este campo. Muchas veces los problemas
en la vida se presentan complicados y dependen de la buena lectura, capacidad de escucha e
interpretacin de los mismos, para despus pensar en los posibles clculos o procesos
matemticos para solucionar los problemas en computadora.
La caracterstica principal del libro es la sencillez con la que explicamos la solucin de los
problemas que planteamos; usando estructuras secuenciales, selectivas, bucles, funciones,
procedimientos y arreglos, que corresponde a los temas de los cursos de algoritmos, tcnicas de
programacin, sistemas operativos para principiantes; escribiendo los programas en el Lenguaje
C de la forma mas sucinta, e indicando las variables, el pseudocdigo 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 programacin similar a lenguaje C.

Algoritmos en Lenguaje C

Caricato da

Informazioni sul documento

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Algoritmos en Lenguaje C

Caricato da

Copyright:

Formati disponibili

Abraham Sopla Maslucn

Facultad de Ingeniera de Sistemas y Mecnica Elctrica

Primera edicin, diciembre 2017

Este documento ha sido publicado bajo la licencia Creative Commons

Abraham Sopla Maslucn 3|Pgina

1.2 Estrategia para resolver problemas con algoritmos

Cuando usted est resolviendo un examen de algoritmia o programacin va donde el profesor a

Abraham Sopla Maslucn 4|Pgina

1.2.1 Pasos para definir problemas

2. Identificar las entradas, procesos y salidas

Generalmente, los problemas con estructuras secunciales y selectivas son ms complicados

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

Otra forma sera a travs de dos procesos

Salidas: La nica salida sera el area , en ambos casos

Abraham Sopla Maslucn 5|Pgina

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

Abraham Sopla Maslucn 6|Pgina

2.1 Recursos para escribir programas en C

2.2 Instalacin de compilador y editor C/C++

Paso 1: Instalando el compilador c++

Paso 2: Instalando el editor de c++

Paso 3: Configuracin del compilador

2. Es importante que cuando guardemos el archivo, en el campo Tipo escojamos la opcin

Abraham Sopla Maslucn 7|Pgina

Figura 1: Guardando un archivo en Sc1

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

Abraham Sopla Maslucn 8|Pgina

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 Maslucn 9|Pgina

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

2.3 Instalacin rpida del paquete completo

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

Figura 5: Entorno general de Sc1

Abre el programa: Sc1.exe escribe lo siguiente en l y gurdalo como:

Abraham Sopla Maslucn 10 | P g i n a

Figura 6: Hola mundo en el editor Sc1

Primero: Escribimos el cdigo tal como se muestra en la imagen.

Figura 7: Factorial de un nmero en Sc1

Paso 2: Guardamos el cdigo con un nombre, en este caso factorial.cpp

Abraham Sopla Maslucn 11 | P g i n a

Figura 8: Guardar un archivo en Sc1

#include<math.h> //declaracin de librera

Abraham Sopla Maslucn 12 | P g i n a

2.5 Variables y constantes

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

2.5.2 Clasificacin de variables

Variables locales: son las que se declaran dentro de un procedimiento o funcin.

Tabla 1: Clasificacin de las variables

Tipo variable; Pueden ser inicializadas en la misma

2.6 Estructura ms simple de un programa en C

Tabla 2: Partes de un programa

int x, n; Declaracin de variables y funciones

Abraham Sopla Maslucn 13 | P g i n a

2.6.1 La funcin main() Una funcin tiene la forma:

2.7 Declaracin de variables y tipos de datos

2.7.1 Declaracin de variables

2.7.2 Tipo de datos

Tabla 3: Los tipos de datos simples

2.7.3 Cadena de caracteres

Abraham Sopla Maslucn 14 | P g i n a

2.7.4 Modificadores de los tipos de variables