Apunte de introduccion a la programacion

Vista previa del material en texto

INTRODUCCIÓN A LA 
PROGRAMACIÓN 
 
 
 
Claudio Gutiérrez-Soto 
Manuel Crisosto Muñoz 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
2
Agradecimientos 
 
 
 
 
 
 
Quiero agradecer de manera anticipada a los alumnos de introducción a la programación, 
de quienes esperamos recibir feedback para mejorar este apunte con el objeto de que en 
algún momento sea un texto de apoyo a la programación. Segundo, quiero agradecer a mi 
colega y amigo Manuel Crisosto quien ha hecho importantes contribuciones con ejemplos 
y ejercicios, así como también para que este apunte llegue a mano nuestros alumnos. 
Además quiero agradecer a mis colegas Pedro Campos y Christian Vidal por sus aportes 
en la preparación de los certamenes así como de las clases. 
 
 
 
Claudio Gutiérrez-Soto 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
3
 
 
Prólogo 
 
Estimados alumnos, el material que se presenta a continuación está diseñado para 
apoyar la asignatura de introducción a la programación que tienen como objetivo el lograr 
resolver problemas simples mediante un programa escrito en algún lenguaje de 
programación. 
 
Como ustedes pondrán ver el conjunto de símbolos, instrucciones y estructuras presentes 
en un algoritmo o programa son fáciles de identificar y aprender en relación a su 
significado. La dificultad se presenta al intentar combinar lógicamente estas 
instrucciones y estructuras para que resuelvan un problema planteado. 
 
El objetivo general es resolver problemas básicos a través de la construcción de 
programas basados en algoritmos. Un algoritmo lo podemos definir como un conjunto de 
pasos lógicamente ordenados, escritos a través de símbolos o en lenguaje natural. Lo 
podemos comparar con una receta de cocina, o con las instrucciones para armar un 
mueble, las instrucciones que vienen en un manual de un grabador de CD, por mencionar 
algunos ejemplos. La diferencia está en la precisión que deben tener cada una de las 
instrucciones de un algoritmo. Por ejemplo, no podemos indicar en un algoritmo, agregue 
sal a gusto, o apreté esta tuerca pues son indicaciones poco precisas, que no pueden ser 
traducidas a una instrucción escrita en un lenguaje de programación. En el diseño e 
implementación de los algoritmos debemos indicar agregue 10 grs. de sal, o apreté esta 
tuerca dando diez giros a la derecha. Es decir las instrucciones dadas en un algoritmo 
deben de ser precisas y no ambiguas. 
 
En este material desde el primer capítulo se presentarán una serie de ejercicios resueltos. 
Le recomendamos que antes de ver el desarrollo de estos ejercicios, intenten resolver 
dichos ejercicios. Es una tarea progresiva, que se puede apoyar si siguen los siguientes 
pasos: 
1. Entender lo que se esta solicitando que el algoritmo o programa resuelva. 
ENTENDER EL ENUNCIADO. 
2. La mayoría de los algoritmos o programas requiere que se le ingresen datos que 
serán transformados, convenientemente por el conjunto de instrucciones, en la 
salida que se esta solicitando. Es imprescindible poder identificar estos datos 
de entrada y la información de salida que se está solicitando. 
3. Identificar las posibles restricciones o condiciones que se deben consideran para 
los datos de entrada. 
4. Construcción del algoritmo o programa. 
 
Sin embargo, lo más importante que podemos recalcar en la utilización de este libro, es 
que la adquisición de la destreza para poder resolver un problema a través de un 
algoritmo es paulatina y progresiva. Es decir, hay que ejercitar con el objeto de adquirir la 
lógica para resolver problemas. Esto es equivalente a las metas de un deportista, ellos se 
colocan metas y trabajan constantemente para alcanzarlas. Aquí ocurre de manera 
similar, debemos de adquirir la destreza a través de ejercicios. En dicho caso, nuestra 
herramienta es el computador, compilador y simuladores asociados. 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
4
 
 
Parte 0: Introducción.............................................................................................................5 
Programa ..........................................................................................................................5 
Algoritmo...........................................................................................................................6 
Variables ...........................................................................................................................6 
Concepto de Ciclo ..............................................................................................................13 
Ciclo Mientras (expresión) ..............................................................................................13 
Ciclo Repetir (instrucciones) Mientras ............................................................................13 
Ciclo Para (variables de control): ....................................................................................14 
Ejercicios parte 0: Construcción de algoritmos ...............................................................19 
Parte 1: Estructura e instrucciones básicas en el lenguaje C.............................................20 
Función printf() ................................................................................................................20 
Comentarios....................................................................................................................21 
Define..............................................................................................................................24 
Incremento y Decremento.............................................................................................24 
Operadores .....................................................................................................................25 
Ejercicios.........................................................................................................................26 
Parte 2: Estructura de Control. ...........................................................................................28 
La estructura de control if................................................................................................28 
Proposición switch ..........................................................................................................34 
Proposición while ............................................................................................................38 
Ejercicios parte 2: Ciclo while .........................................................................................41 
Proposición for ................................................................................................................42 
Ejercicios parte 2 ciclos for .............................................................................................45 
Proposición do while ......................................................................................................46 
PREGUNTAS DE CERTAMENES DE AÑOS ANTERIORES al 2008, REFERENTES AL 
MANEJO DE CICLOS Y EVALUACIONES LÓGICAS ...................................................47 
Parte 3: Definición de una función......................................................................................51 
Pasaje de parámetros o argumentos ..............................................................................59 
PREGUNTAS DE CERTAMENES DE AÑOS ANTERIORES al 2008, REFERENTES AL 
MANEJO DE FUNCIONES.............................................................................................61 
Parte 4: ArreglosUnidimensionales ...................................................................................65 
Inicialización de arreglos.................................................................................................65 
Cadenas o Strings...........................................................................................................67 
Arreglos bidimensionales ................................................................................................69 
Ejercicios Parte 4: Arreglos.............................................................................................72 
PREGUNTAS DE CERTAMENES DE AÑOS ANTERIORES al 2008, REFERENTES AL 
MANEJO DE ARREGLOS, CADENAS Y MATRICES....................................................74 
Parte 5: Estructuras ............................................................................................................82 
Declaración de Variables de tipo estructura ...................................................................83 
Referencia a los elementos de una estructura................................................................83 
Arreglos de estructuras ...................................................................................................84 
Estructuras en las funciones ...........................................................................................85 
Estructuras como parámetros de una función ................................................................85 
Ejercicios parte 5: Estructuras ........................................................................................86 
Parte 6: Punteros................................................................................................................89 
Uso de typedef....................................................................................................................94 
Soluciones a ejercicios planteados.....................................................................................95 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
5
 
PARTE 0: INTRODUCCIÓN 
 
Conceptos básicos 
 
PROGRAMA 
Un programa computacional, en términos simples, consiste en una serie de pasos lógicamente 
escritos que permiten resolver un problema determinado, que a partir de datos de entrada obtiene 
información útil para la toma de decisiones. Aprender a programar consiste, por un lado, en 
conocer las distintas instrucciones que un determinado lenguaje de programación tiene, y más 
importante aún, escribir un conjunto de instrucciones en forma lógica para que la ejecución de 
estas instrucciones permita dar respuesta al problema planteado. No basta con conocer las 
instrucciones existentes, se debe adquirir la lógica que permite utilizarlas con un fin específico. 
 
La mayoría de los problemas que se resuelven en el transcurso de un curso de programación viene 
especificada mediante un enunciado. Los pasos necesarios para poder construir un programa que 
de respuesta al enunciado lo podemos resumir de la siguiente manera: 
• Entender el problema 
• Buscar soluciones 
• Elegir solución 
• Diseñar solución 
• Implementar solución 
• Validar solución 
 
La siguiente figura simplifica los pasos anteriores, para esto supongamos que queremos construir 
un programa que permita resolver la ecuación de primer grado. 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
6
 
 
El primer paso es entender que se está pidiendo, esto requiere de la máxima atención, pues de lo 
contrario difícilmente el programa escrito responderá al enunciado planteado. Una vez que se 
entiende el enunciado se debe poder definir cuales son los datos de entrada del programa y cual 
es la información de salida. Además, se debe poder definir algunas restricciones, para este 
ejemplo que a debe ser distinto de cero. A continuación se recomienda escribir un algoritmo que 
represente una aproximación a la solución final. Posterior a estos pasos se traduce el algoritmo a 
un lenguaje de programación determinado. 
 
ALGORITMO 
Un algoritmo consiste en un procedimiento detallado, escrito en forma simbólica o con lenguaje 
natural, para resolver un problema en pasos y en un tiempo finito. Algunas características de los 
algoritmos son: 
• el algoritmo lleva desde un estado inicial a un estado final 
• se especifican en base a operaciones básicas que controlan las variables y el flujo del 
algoritmo 
• el algoritmo recibe entradas y entrega salidas 
 
VARIABLES 
En todo programa computacional se requiere almacenar temporalmente datos en posiciones 
específicas de la memoria del computador. Estos datos pueden ser ingresados por ejemplo desde 
teclado (datos de entrada), o ser datos intermedios producto de alguna transformación 
(procesamiento) para producir la salida requerida (información). Los lenguajes de programación 
utilizan diversos tipos de datos los cuales determinan la cantidad de memoria a ocupar en el 
computador. Entre estos datos tenemos: 
 
 Programa que 
permite 
resolver la 
ecuación de 
primer grado 
a x + b = 0 
? a 
 
b 
x= -b / a 
#include <stdio.h> 
int a,b,x; 
main() 
{ 
 printf(“Ingrese valores de EC”); 
 scanf(“%d %d”,&a,&b); 
 if a ==0 printf (“error”); 
 else 
 { 
 x = -b / a; 
 printf(“La solución es %d:”,x); 
 } 
 printf(“Fin programa”); 
} 
Algoritmo EC 1er Grado 
Variables 
 a,b,x de tipo entero 
Inicio 
 Escribir(“Ingrese valores de EC”) 
 Leer (a,b) 
 Si a = 0 entonces 
 escribir (“Error”) 
 sino 
 Inicio 
 x=-b/a 
 Escribir (“La solución es:”,x) 
 Fin 
 Escribir(“Fin programa”) 
Fin 
a ≠ 0
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
7
Tipo de dato Propósito 
Entero Permite almacenar valores de tipo entero. 
Real o flotante Permite almacenar números fraccionarios. 
Lógico Permite almacenar los valores lógicos de verdad, Verdadero o Falso. 
Carácter Permite almacenar cualquier carácter conocido. 
 
Para hacer uso de las posiciones de memoria donde se almacenan los datos se utilizan “etiquetas” 
o nombres. La etiqueta o nombre es un nemotécnico que se recomienda que sea significativo para 
el dato que se esta almacenando. Por ejemplo: 
• si se requiere almacenar la suma de varios valores, conviene bautizar la posición de 
memoria con el nombre “suma”, 
• si se quiere calcular la ecuación de primer grado, los datos de entrada conviene 
almacenarlos en las posiciones con nombre a, b; y el resultado de la evaluación en x. 
 
Recordemos que para resolver un problema, se debe tener claro cuales son los datos de entrada y 
salida; además de estos se pueden utilizar datos intermedios necesarios para el procesamiento. 
Todos estos datos se deben declarar, al inicio del programa o, como veremos más adelante, al 
inicio de cada sección del programa. 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
8
 
La forma en que se ejecutan las operaciones básicas en un computador, es similar a lo que ocurre 
en nuestro cerebro. Por ejemplo, para sumar dos valores, los pasos básicos son: 
• Primero debemos pedirle a alguien que nos diga el primer valor. 
• Luego de que conocemos este valor, debemos almacenarlo (para recordarlo después) en 
una neurona (Suponemos que un valor se puede almacenar en una neurona). 
Ya conocemos el primer valor y está almacenado en nuestro cerebro. 
• Ahora debemos pedir el segundo valor. 
• Una vez conocido, lo almacenamos en otra neurona distinta de la anterior. 
¿Por qué se debe hacer esto?: Si almacenamos el valoren la misma neurona “no 
recordaremos” el primer valor a sumar. 
• Ahora que conocemos los dos valores procedemos a sumarlos, y dicho resultado lo 
almacenamos en otra neurona distinta de las anteriores. 
• Por último, le decimos el resultado a la persona que nos entrego los números. 
 
De lo anterior podemos decir que: 
• al menos necesitamos 3 neuronas para sumar dos números. 
• pedimos explícitamente que nos dijeran dichos valores. 
• asignamos dichos valores a las neuronas 
• la suma la realizó nuestro cerebro de forma mecánica. 
• Finalmente se da el resultado 
 
Por lo tanto el algoritmo básico para sumar dos números podría ser el siguiente: 
• Algoritmo para sumar dos números: 
o Definimos tres neuronas 
o Pedimos el primer valor 
o Almacenamos ese valor en la neurona 1. 
o Pedimos el segundo valor 
o Almacenamos ese valor en la neurona 2. 
o Almacenamos la suma de las neuronas 1 y 2 en la neurona 3 
o Entregamos el resultado que se encuentra en la neurona 3. 
 
En los algoritmos y lenguajes de programación no se usan neuronas, pero podemos definir 
variables (recuerde que las variables pueden tomar cualquier valor según el tipo de dato definido), 
es decir, en lugar de usar neurona 1 y neurona 2, se utilizan espacios de memoria que llamaremos 
“var 1” y “var 2”, y así sucesivamente. También las podemos llamar “x1” y “x2” ó “x” e “y”. 
Recuerde que es conveniente usar nombre de variables que de alguna forma reflejen el contenido 
de dicha posición de memoria. 
 
Ejercicio 0.1: Cree un algoritmo que multiplique tres números. 
 
Datos de Entrada: tres 
números (x1,x2,x3) 
 
Información de Salida: 
Suma de x1,x2 y x3 
 
Restricciones: Ninguna 
Algoritmo para multiplicar tres números: 
• Definimos cuatro variables var1, var2, var3 y var4 
de tipo entero 
• Pedimos el primer valor 
• Almacenamos ese valor en var1. 
• Pedimos el segundo valor 
• Almacenamos ese valor en var2. 
• Pedimos el tercer valor 
• Almacenamos ese valor en var3. 
• Almacenamos la multiplicación de las variables en 
var4 
• Entregamos e l resultado que se encuentra en var4. 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
9
 
La manera en que se han detallado los dos algoritmos se llama pseudo-código, el cual fue escrito 
en lenguaje natural (nuestro lenguaje, entendible por el ser humano). Otra manera de poder 
detallar lo algoritmos, es a través de los diagrama de flujo. Un diagrama de flujo es una 
representación simbólica de la lógica del algoritmo. 
 
Existen un conjunto de símbolos básicos utilizados en la constricción de diagramas de flujo, los 
cuales tienen su equivalente en pseudo-código, y lo más importante su correspondiente traducción 
en un lenguaje de programación. 
 
 
 
Como hemos mencionado anteriormente, no basta con saber el significado de cada símbolo, 
debemos saber como combinar estos símbolos para producir un algoritmo que resuelva el 
problema planteado. 
Inicio 
Escribir 
“Mensaje 1” 
Fin 
Leer 
var1,x, y 
a = 3 * x + y 
b = a / var1 
Entero var1, x , y 
Real a, b 
Si a > b V F 
Inicio de Algoritmo
Definición de variables 
Impresión de mensajes 
Lectura de mensajes
Transformación de datos 
Operaciones sobre los datos 
Bifurcación en la ejecución 
de instrucciones 
Conector 
Fin de algoritmo 
DIAGRAMA DE FLUJO NOMENCLATURA PSEUDO-CÓDIGO 
Inicio 
Variables 
 Entero var1, x, y 
 Real a, b 
Escribir (“Mensaje 1”)
Leer (var1, x, y) 
a = 3 * x + y 
b = a / var1 
Si a > b Entonces 
 Inicio 
 Instrucciones… 
 Fin 
Sino 
 Inicio 
 Instrucciones… 
 Fin 
Fin
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
10
 
Ejemplo 0.2: El siguiente algoritmo, escrito utilizando diagrama de flujo permite sumar dos números y 
muestra el resultado por pantalla (o monitor) 
 
Entrada: Dos números (x1 y x2) 
Salida: x1+x2 
Restricciones: Ninguna 
 
 
 
 
 
Observación: En los ejemplos de este apartado, incluiremos el código en lenguaje C con el objetivo 
de que lo prueben, modifiquen, adapten, corrijan, etc. 
Inicio 
Termino 
int var1,var2 ,var3 
 Ingrese el primer valor 
var 1 
Ingrese el segundo valor 
var 2 
var3=var1+var2 
El resultado es : var3 
En pseudos-código: 
Algoritmo Suma 
Variables 
 Entero var1, var2, var3 
Inicio 
 Escribir(“Ingrese el primer valor”) 
 Leer (var1) 
 Escribir(“Ingrese el segundo valor”) 
 Leer (var2) 
 var3=var1+var2 
 Escribir(“El resultado es:”,var3) 
Fin 
El lenguaje C: 
#include<stdio.h> 
int var1,var2,var3; 
main() 
{ 
 printf(“Ingrese el primer valor:”); 
 scanf(“%d”,&var1); 
 printf(“Ingrese el segundo valor:”); 
 scanf(“%d”,&var2); 
 var3=var1+var2; 
 printf(“El resultado es:%d”,var3); 
} 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
11
 
 
Ejemplo 0.3: Cree un algoritmos donde una persona ingrese su edad y muestre por pantalla 
si es mayor de edad. 
 
Entrada: Edad 
Salida: Mensaje 1: Usted es mayor de edad 
 Mensaje 2: Usted es menor de edad (sólo uno de estos mensajes) 
Restricciones: Edad no puede ser negativa, ni mayor a 200 (esto no es validado en este 
algoritmo). 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Del ejemplo anterior podemos observar que la bifurcación permite seguir el flujo adecuado dada 
una condición. La condición que se evalúan en una bifurcación puede ser verdadera o falsa y 
determina el conjunto de instrucciones que se ejecutaran. No siempre es necesario colocar 
instrucciones en el caso de que la condición sea falsa, esto dependerá del problema que se este 
resolviendo. También es posible que existan bifurcaciones contiguas. 
 
v 
f 
En pseudos-código:
Algoritmo Edad 
Variables 
 Entero edad 
Inicio 
 Escribir(“Ingrese su edad:”) 
 Leer (edad) 
 Si (edad >= 18) Entonces 
 Inicio 
 Escribir(“Usted es mayor de edad”) 
 Fin 
 Sino 
 Inicio 
 Escribir(“Usted es menor de edad”) 
 Fin 
Fin
El lenguaje C:
#include<stdio.h> 
int edad; 
main() 
{ 
 printf(“Ingresesu edad:”); 
 scanf(“%d”,&edad); 
 if (edad >= 18) 
 { 
 printf(“Usted es mayor de edad”); 
 } 
 else 
 { 
 printf(“Usted es menor de edad”); 
 } 
} 
Inicio 
Entero Edad 
 Ingrese su edad 
Edad 
Edad >= 18 
Termino 
Usted es 
menor 
de edad 
Usted es mayor 
de edad 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
12
En las bifurcaciones o estructura de control, se evalúan proposiciones utilizando: 
• Operadores lógicos: And, or y not 
• Operadores aritméticos: *, / , +, - , %1 
• Operadores Relacionales: == (igual), != (distinto), > (mayor que), < (menor que), 
 >= (mayor igual), <= (menor igual) 
 
Recordemos que los operadores lógicos están definidos según el algebra booleana y arrojan un 
valor de verdadero o falso según las proposiciones que forman la expresión. La siguiente tabla de 
verdad nos muestra las posibles combinaciones que se puede presentar (supongamos que las 
proposiciones son P1 y P2). 
 
(P1) (P2) (P1) and (P2) (P1) or (P2) Not (P1) 
V V V V F 
V F F V F 
F V F V V 
F F F F V 
 
Además, cada expresión puede estar formada por una o más proposiciones unidas por operadores 
lógicos, a estas expresiones les llamaremos expresiones compuestas. 
 
Ejemplo 0.4: Evaluación de una expresión compuesta 
 
Asumamos la siguiente expresión: 
 ((P1 and P2) or P3) and (not P3)) 
 
Para determinar la veracidad o falsedad de esta expresión debemos saber el valor de verdad de 
cada proposición, la cual puede cambiar en el transcurso del tiempo. La tabla de verdad asociadaa esta expresión se forma a partir de todas las posibles combinaciones: 
 
P1 P2 P3 P1 and P2 (P1 and P2) or P3 Not P3 ((P1 and P2) or P3) and (not P3)) 
V V V V V F F 
V V F V V V V 
V F V F V F F 
V F F F F V F 
F V V F V F F 
F V F F F V F 
F F V F V F F 
F F F F F V F 
 
 
Hasta ahora los algoritmos descritos son secuenciales, es decir se ejecuta una instrucción, y al 
término de ésta se ejecuta la siguiente, excepto cuando existe una bifurcación, en cuyo caso se 
podría saltar un grupo de instrucciones dependiendo de la evaluación de la condición. El control de 
ejecución es siempre “hacia delante”. 
 
Existen aplicaciones en las cuales se requiere repetir un número determinado de instrucciones, en 
cuyo caso, una o más instrucciones se ejecutarán de acuerdo a determinadas condiciones, a estas 
estructuras presentes en los algoritmos se les denomina ciclos. 
 
 
1 Corresponde a la función modulo que entrega el resto de la división entre dos enteros. 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
13
CONCEPTO DE CICLO 
 
Un ciclo es la repetición de un conjunto de instrucciones. Dicho ciclo culmina cuando se cumple 
una condición de término. El grupo de instrucciones se pueden ejecutar un número conocido o 
desconocido de veces. 
 
CICLO MIENTRAS (EXPRESIÓN): Esta estructura se utiliza cuando se quiere repetir un 
conjunto de instrucciones mientras se cumpla una determinada condición la cual es evaluada al 
comienzo del ciclo. El grupo de instrucciones se ejecutará como mínimo cero veces (la expresión 
evaluada es falsa), o una o más veces (la expresión evaluada es verdadera, y se espera que esta 
cambie en el transcurso de la ejecución del grupo de instrucciones)2. En el diagrama de flujo se 
utiliza la estructura de bifurcación, y cuando termina de ejecutarse el grupo de instrucciones, el 
control del algoritmo retorna a la bifurcación, produciéndose una nueva evaluación de la expresión. 
El esquema siguiente ilustra la forma que toma este ciclo utilizando diagrama de flujo y pseudos-
código. 
 
 
 
Ciclo Mientras 
 
 
CICLO REPETIR (INSTRUCCIONES) MIENTRAS 
 
La diferencia con el ciclo anterior es que la expresión se evalúa al término de la ejecución del grupo 
de instrucciones que se necesitan repetir, tal como lo muestra el esquema siguiente. 
 
 
2 Si esto no se cumple, es decir la expresión inicialmente es verdadera y no cambia se producira un 
ciclo infinito o loop infinito. 
Instrucción a 
Instrucción 1
Instrucción N
expresión
Instrucción 2
V 
Instrucción b 
F 
Instrucción a
 
 
mientras (expresión) 
Inicio 
 Instrucción 1 
 Instrucción 2 
 
 
 
 
 
 
 Instrucción n 
Fin 
 
 
Instrucción b 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
14
 
 
 
 
 
 
Ciclo Repetir …. Mientras 
 
En las estructuras anteriores el número de veces que se repetirán las instrucciones no 
necesariamente es conocido (esto depende la lógica del algoritmo). Existen muchas ocasiones en 
que se conoce el número de veces que se desea repetir el grupo de instrucciones, por ejemplo leer 
100 números. En estos casos es aconsejable utilizar el ciclo “Para”. 
 
CICLO PARA (VARIABLES DE CONTROL): En este ciclo el número de veces que se 
repite el conjunto de instrucciones es conocido, y el control de la repetición es asumido por un 
conjunto de variables de control. El esquema siguiente representa esta estructura en diagrama de 
flujo y pseudos-código. Las variables de control se inicializan en un determinado valor, el cual 
aumenta o disminuye de acuerdo un salto definido, hasta llegar a un valor final. 
Instrucción a 
Instrucción 1
Instrucción N 
expresión
Instrucción 2 
V 
Instrucción b 
F 
Instrucción a
 
do 
Inicio 
 Instrucción 1 
 Instrucción 2 
 
 
 
 
 
 Instrucción n 
Fin 
mientras (expresión) 
 
 
Instrucción b
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
15
 
Ciclo Para (variables de control) 
 
A continuación de verán algunos ejemplos para clarificar estas estructuras. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Instrucción a 
Instrucción 1 
Instrucción N 
Instrucción 2 
Instrucción b 
Vc = Vi , Vf / 
Condición, Salto 
Instrucción a
 
 
Para ( Vc=Vi; Vf / Condición; Salto) 
Inicio 
 Instrucción 1 
 Instrucción 2 
 
 
 
 
 
 
 
 Instrucción n 
Fin 
 
 
Instrucción b 
 
Algoritmo Tabla de Multiplicar 
Variables 
 Entero a,b 
Inicio 
 Escribir (“Ingrese un número entero:”) 
 Leer (a) 
 b=0 
 Para (b=0; b<a; salto 1) 
 Inicio 
 Escribir (a,b,a*b) 
 Fin 
Fin
Inicio 
Entero a,b 
Escribir 
“Ingrese un numero entero:” 
Leer (a) 
b ← 0 
b=0,b<a, inc 1 
Escribir 
a, b, a*b 
Fin 
#include <stdio.h> 
Int a, b; 
main() 
{ 
 printf(“Ingrese un número entero:”); 
 scanf(“%d”,&a); 
 for(b=0;b<a;b=b+1) 
 { 
 printf(“%d * %d = %d,a,b,a*b); 
 } 
} 
Ejemplo: Construir la tabla de multiplicar de un numero ingresado por teclado, 
partiendo desde cero. 
Entrada: x 
Salida: x*0, x*1, x*2, x*3………..x*x 
Restricciones: No tiene 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
16
 
Observación: Revisar este algoritmo y realizar un seguimiento. Qué sucede cuando se ingresa un 
número negativo. El algoritmo: ¿es una respuesta al enunciado planteado?. Realice las 
modificaciones que estime necesarias. 
 
En el ejemplo anterior, la variable de control b se inicializa en 0 (b=0) y el grupo de instrucciones 
(en este caso una instrucción) se ejecuta mientras se cumpla la condición que b sea menor que a 
(b<a). Cada vez que se ejecuta el grupo de instrucciones el valor de b se incremente en 1 (inc 1). 
 
Algunas características del ciclo Para: 
• El incremento puede ser un valor negativo o positivo, entero o decimal, unitario o no 
unitario. 
• La expresión además de la variable de control puede contener más proposiciones, esto 
dependerá de la lógica del programa. 
• Es aconsejable no modificar el valor de estas variables en el grupo de instrucciones que se 
repiten. 
 
Para un problema pueden existir varias posibles soluciones. Analicemos el siguiente ejemplo: 
Construir un programa que permita evaluar la siguiente función para un rango de valores enteros 
de x comprendido en el intervalo [a,b]. 
f(x)= (3x2+5x-2)/125 
Se debe mostrar en pantalla el valor de x y f(x). 
 
Entrada: a, b 
Salida: f(a), f(a+1), f(a+2)………f(b-2), f(b-1), f(b) 
Restricciones: a < b 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
17
 
 
 
La primera solución muestra un mensaje al usuario indicando que al ingresar un intervalo [a,b], 
siempre a debe ser menor que b y se termina el programa, en este caso el usuario deberá ejecutar 
nuevamente el algoritmo. La segunda solución valida que el valor de a sea menor que b, 
permitiendo ingresar varias veces el valor de a y b, hasta que a sea menor que b. A continuación 
se escribe los pseudo-código de ambos diagramas de flujo y sus correspondientes programas en 
C. 
Inicio 
Entero a,b,x 
Real fx 
Escribir
“Ingrese los valores de ay b” 
fx = (3*x*x+5*x-2) / 125 
Escribir 
 x, fx 
Leer (a,b)
Fin 
x=a,x<=b, inc 1 
Si a > b V
F 
Si a < b VF 
Inicio 
Entero a,b,x
Real fx 
Escribir 
“Ingrese los valores de a y b” 
fx = (3*x*x+5*x-2) / 125 
Escribir
 x, fx 
Leer (a,b)
x=a,x<=b, inc 1 
Escribir 
 “a debe ser menor que b” 
Fin 
 
Introducción a la Programación 
Departamentode Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
18
 
Uso de bifurcación y ciclo para Uso de repetir… mientras y ciclo para 
Algoritmo F(x) 
Variables 
 Entero a,b,x 
 Real fx 
Inicio 
 Escribir(“Ingrese los valores de a y b”) 
 Leer (a,b) 
 Si (a<b) entonces 
 Inicio 
 Para (x=a, x<=b, inc 1) 
 Inicio 
 fx = (3*x*x+5*x-2) / 125 
 Escribir ( x, fx) 
 Fin 
 Fin 
 Si no 
 Inicio 
 Escibir(“a debe ser menor que b”) 
 Fin 
Fin 
 Algoritmo F(x) 
Variables 
 Entero a,b,x 
 Real fx 
Inicio 
 Escribir(“Ingrese los valores de a y b”) 
 Repetir 
 Inicio 
 Leer (a,b) 
 Fin 
 Mientras (a > b) 
 Para (x=a, x<=b, inc 1) 
 Inicio 
 fx = (3*x*x+5*x-2) / 125 
 Escribir ( x, fx) 
 Fin 
Fin 
 
Equivalente en lenguaje C 
#include<stdio.h> 
int a,b,x; 
flota fx; 
main() 
{ 
 printf(“Ingrese los valores de a y b”); 
 scanf(“%d”,&a); 
 scanf(“%d”,&b); 
 if (a<b) 
 { 
 for (x=a;x<=b;x=x+1) 
 { 
 fx= (3*x*x+5*x-2) / 125; 
 printf(“%d %f”, x,fx); 
 } 
 } 
 else 
 { 
 printf(“a debe ser menor que b”) 
 } 
} 
 #include<stdio.h> 
int a,b,x; 
flota fx; 
main() 
{ 
 printf(“Ingrese los valores de a y b”); 
 do 
 { 
 scanf(“%d”,&a); 
 scanf(“%d”,&b); 
 } 
 while (a>b) 
 for (x=a;x<=b;x=x+1) 
 { 
 fx= (3*x*x+5*x-2) / 125; 
 printf(“%d %f”, x,fx); 
 } 
} 
 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
19
EJERCICIOS PARTE 0: CONSTRUCCIÓN DE ALGORITMOS3 
 
Construya los siguientes algoritmos 
 
1. Que multiplique tres números ingresados desde teclado y muestre el resultado 
 
2. Que divida dos números y muestre el resultado 
 
3. Que muestre en forma ordenada tres número enteros ingresados desde teclado. 
 
4. Que resuelva la ecuación de primer grado y muestre el resultado 
 
5. Que resuelva la ecuación de segundo grado, para valores reales e imaginarios, y muestre el 
resultado. 
 
6. Que permita sumar “n” números y muestre el resultado. El valor de “n” debe ser ingresado por 
teclado al igual que los números que se sumarán. 
 
7. Que permita el ingreso de 15 números y que cuente cuántos de los números ingresados son 
pares. 
 
8. Que permita el ingreso de 15 números y que muestre el mayor, el menor y el promedio. 
 
9. Crear un algoritmo donde el usuario ingrese Crear un algoritmo que reciba a>=0 y b>=0 y que 
calcule: a!/((a-b)!b!) 
 
Construya los algoritmos que permitan calcular las siguientes series con un valor de n ingresado 
desde teclado 
 
10. 12+22+32+… +N2 
 
11. 1!+2!+3!+…+N! 
 
12. 11+22+33+… +NN 
 
13. -11+22-33+…..+Nn, tal que N es par 
 
14. (1+1)+(2+(1+2))+(3+(1+2+3))+…(N+(1+2+…N)) 
 
15. (1!+2!+3!+…+N!)/(1+2+3+…+N) 
 
16. 11+(21+22)+(31+32+33)+…+(N1+N2+…+NN) 
 
17. 11!+(21!+22!)+(31!+32!+33!)+…+(N1!+N2!+…+NN!) 
 
18. 1N+2N-1+3N-2+….+N1 
 
3 No se incluirán las respuestas de este apartado. 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
20
PARTE 1: ESTRUCTURA E INSTRUCCIONES BÁSICAS EN EL LENGUAJE C 
 
La siguiente es la estructura general de un programa en C 
 
#include<stdio.h> 
main() 
{ 
 printf (“Este es mi primer programa en C”); 
 getchar(); 
 
} 
 
En este sencillo ejemplo, podemos visualizar lo siguiente: 
 
#include<stdio.h> Esto hace referencia a la librería stdio.h, la cual posee 
las funciones de entrada y salida de datos. Existen 
múltiples librerías para propósitos específicos. 
 main() main(), es la función principal de C, ella siempre debe 
estar presente. 
{ Comienza el cuerpo del programa 
 printf(“Este es mi primer programa en C.”); La función printf( ), se encarga de mostrar o desplegar 
el contenido que se encuentra entre las comillas en el 
monitor. 
 getchar(); Función que espera a que se presione una tecla 
} Fin del programa. 
 
Este programa debe ser compilado para su ejecución. El proceso de compilación, en términos 
simples, corresponde a la traducción del programa “fuente” a su equivalente en lenguaje “objeto” o 
lenguaje de “máquina”. El compilador realiza un análisis sintáctico del programa. 
 
Una vez compilado, arrojará en pantalla: 
 
Este es mi primer programa en C. 
 
Ejemplo 1.1 
 
#include<stdio.h> 
main() 
{ 
 printf(“hola mundo.”); 
} 
 
En pantalla : 
Hola mundo. 
 
 
FUNCIÓN PRINTF() 
La función printf( ), consta de dos partes : cadena de control y una lista de argumentos. En el 
siguiente ejemplo veremos como se utiliza los caracteres de control. 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
21
 
Ejemplo 1.2 : En este ejemplo se muestran las diferentes cadenas de control para la 
función printf 
#include<stdio.h> 
 main() 
{ 
 printf(“Ahora utilizaremos los caracteres de control\n”); 
 printf(“El siguiente carácter salta a una nueva línea. \n”); 
 printf(“ \t El carácter utilizado es un tabulador. \n”); 
 printf(“ \“ Esta frase esta entre comillas. \” \n”); 
 printf(“ El siguiente carácter representa retorno de carro : \r \n”); 
 printf(“ \‘ Esta frase esta entre apóstrofes. \’ \n”); 
 printf(“ \\ Esta frase esta entre barras invertidas \\ \n”); 
 printf(“Los siguientes caracteres representan retrocesos :\b\b\b\b\b\b \n”); 
} 
 
A continuación se imprimirá lo siguiente en pantalla: 
 
Ahora utilizaremos los caracteres de control 
El siguiente carácter salta a una nueva línea 
El carácter utilizado es un tabulador. 
\“ Esta frase esta entre comillas. \” 
 El siguiente carácter representa retorno de carro 
‘ Esta frase esta entre apóstrofes. \ 
\\ Esta frase esta entre barras invertidas \\ 
 Los siguientes caracteres representan retrocesos : 
 
COMENTARIOS 
 
Los comentarios son una lista de caracteres desconocidos por el compilador, que tienen como 
objetivo fundamental el hacer referencias, documentación o acotaciones a líneas de códigos o al 
programa general, la forma de utilizarlos es: 
/* Este es un comentario, el cual generalmente involucra 2 o más lineas de código */ 
// Este es otro comentario que involucra 1 sola línea de comentario 
 
Ahora veremos como se utilizan la lista de argumentos del printf( ). 
Ejemplo 1.3: Aquí se muestran los diferentes caracteres 
(argumentos) asociados a los tipos de datos para su 
correspondiente impresión. 
#include<stdio.h> 
main() 
{ 
 int entero=1; // declaración de una variable entera 
 // llamada entero, con valor 1. 
 float comaflotante =1.56356789; 
 char caracter=’a’; 
 char cadena[]=” Esta es una cadena”; 
 printf(“El valor del entero es : %d \n”, entero); 
 printf(“El valor del flotante es : %f \n”, comaflotante); 
 printf(“El valor del carácter es : %c \n”, caracter); 
 printf(“ %s \n”, cadena); 
 
 
 
 
Se imprimirá lo siguiente en pantalla: 
 
 El valor del entero es : 1 
 El valor del flotante es : 1.56356789; 
 El valor del carácter es : a 
 Esta es una cadena 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
22
 getchar(); 
} 
En el ejemplo anterior podemos ver los caracteres de control %d, %f, %c y %s, los cuales 
aparecen dentro de los printf. Estos son utilizados para imprimir variables de acuerdo al tipo de 
dato que dichas variables almacenan. 
 
CARÁCTER TIPO DE DATO 
c Carácter 
d Entero 
s String (conjunto de caracteres) 
e Flotante en notación científica 
f Flotante 
g e ó f más corto. 
 
Otro ejemplo, donde podemos utilizar las opciones de visualización de las variables, es el siguiente 
 
Ejemplo 1.4 
#include<stdio.h> 
 main() 
{float i=56.111111111; 
 printf(“El valor de i es : %f \n”,i); 
 printf(“El valor de i es : %5f \n”,i); 
 printf(“El valor de i es : %15f \n”,i); 
 printf(“El valor de i es : %.1f \n”,i); 
 printf(“El valor de i es : %.5f \n”,i); 
 printf(“El valor de i es : %.0f \n”,i); 
 printf(“El valor de i es : %e \n”,i); 
 getchar(); 
} 
 
Se imprimirá lo siguiente en pantalla : 
 
El valor de i es : 56.111111 
El valor de i es : 56.111111 
El valor de i es : 56.111111 
El valor de i es : 56.1 
El valor de i es : 56.11111 
El valor de i es : 56 
El valor de i es : 5.61111e+01 
 
 
Ejemplo 1.5: En este ejemplo se muestran los caracteres de 
control, salto de línea, retoceso y tabulación. 
 
#include<stdio.h> 
main() 
{ 
 printf(“Estos han sido unos \”EXCELENTES EJEMPLOS\” \n”); 
 printf(“ \t \b\b\b\b\b *** \n”); 
 printf(“ *** “); 
 printf(“ *** “); 
 printf(“ *** “); 
 printf(“ \t \b\b\b\b\b *** \n”); 
} 
 
 
Esto imprimirá lo siguiente : 
 
Estos han sido unos ”EXCELENTES EJEMPLOS” 
 
 *** 
*** *** *** 
 *** 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
23
 
Entre otras características del printf( ), podemos encontrar. 
 
Ejemplo 1.6: Aquí se muestra que es posible realizar las 
operaciones matemáticas básicas dentro del printf. 
#include<stdio.h> 
 main() 
{ 
 int a, b; 
 a=3; b=4; 
 printf(“La suma de la variable a+b es : %d. \n”, a+b); 
} 
Esto imprimirá : 
 
 La suma de la variable a+b es : 7. 
 
 
Función scanf() 
 
El scanf( ) es la función que permite recibir datos ingresados a través de teclado. 
 
Ejemplo 1.7: La función scanf también utiliza caracteres para los distintos tipos de datos. Obsere 
que son los mismos caracteres que utiliza la función printf. 
#include<stdio.h> 
#include<conio.h> //librería que contiene la función clrscr( ). 
main() 
{ 
 int a,b; 
 printf(“Ingrese el primer valor a sumar\n”); 
 scanf(“ %d”, &a); 
 printf(“Ingrese el segundo valor a suma \n”); 
 scanf(“ %d”, &b); 
 printf(“El resultado de a+b es : %d \n”, a+b); 
 getchar(); 
} 
 
En este ejemplo es posible notar que a las variables a y b en la función scanf se le antepone el 
signo &. El signo & es utilizado por el compilador para guardar los valores que se le asignan a las 
variables en las correspondientes direcciones de memoria de dichas variables. Por lo tanto, cada 
vez que utilizamos scanf, las variables deberán llevar el & en el argumento de la función (osea 
después de la coma). Como en el ejemplo, scanf(“ %d”, &a); 
 
Ejemplo 1.8 Aquí se muestra que también es posible ingresar varios datos a la vez con la función 
scanf. 
#include<stdio.h> 
#include<conio.h> 
main() 
{ 
 int a; 
 float b; 
 char c; 
 printf(“Ingrese un entero, luego un flotante y por último un carácter \n”); 
 printf(“ todos separados por un espacio \n”); 
 scanf(“%d %f %c”, &a,&b,&c); 
 printf(Los valores ingresados fueron : %d, %f, %c \n”, a,b,c); 
} 
 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
24
DEFINE 
 
El uso de define, se utiliza para declarar variables con un valor fijo (también denominada 
constante), el cual puede ser utilizado en el resto del programa. Las líneas de control con #define 
se pueden presentar de varias formas. Por ejemplo: 
 
 #define STRING "Este es un ejemplo" 
 #define SEGUNDOS_AL_DIA (60 * 60 * 24) 
 
En este ejemplo, el valor (60 * 60 * 24) reemplazará a SEGUNDOS_AL_DIA por ese string todas 
las veces que aparezca en el resto del archivo. Un error frecuente es terminar una línea #define 
con un punto y coma, lo cual la convierte en parte de la cadena de reemplazo, cuando esto no es lo 
que se desea. Los #define sencillos tienen varios usos importantes que mejoran la claridad y la 
transportabilidad de los programas. Por ejemplo, para constantes especiales : 
 
 #define PI 3.14159 
 #define E 2.71828 /* exponencial */ 
 #define C 299792.4562 /*velocidad de la luz en km/seg*/ 
 
En términos generales, las constantes simbólicas ayudan en la documentación al reemplazar lo 
que de otra forma sería una constante enigmática con un identificador nemotecnico, hacen más 
portátil el programa al permitir que se alteren en un solo lugar las constantes que pueden ser 
dependientes del sistema, y mejoran la confiabilidad al restringir a un solo lugar la verificación de la 
representación real de la constante. 
 
Ejemplo 1.9: Ingresar el valor del radio para calcular el área de una circunferencia. 
 
#include<stdio.h> 
#include<conio.h> 
#define PI 3.1415 // se define una constante simbólica. 
 
 main() 
{ 
 float radio; 
 printf(“Ingrese el radio \n”); 
 scanf(“%f”,&radio); 
 printf(“El área del círculo es : %f \n”, PI * radio * radio); 
 getchar(); 
} 
 
El programa del ejemplo calculará el área del círculo, reemplazando PI, por el valor flotante 3.1415 
 
INCREMENTO Y DECREMENTO 
 
En C, existen los operadores matemáticos de incremento y decremento, los cuales aumentan y 
disminuyen el valor actual de una variable en 1. 
 
El operador de incremento es : ++ 
El operador de decremento es: -- 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
25
 
Ejemplo 1.10 Aquí se muestra la aplicación del 
incremento y decremento de variables 
#include<stdio.h> 
main() 
{ 
 int i=0, j=1; 
 i++; 
 j--; 
 printf(“El valor de i es : %d. \n”,i); 
 printf(“El valor de j es : %d. \n”,j); 
 getchar(); 
} 
 
 
 
 
Esto imprimirá : 
 
El valor de i es : 1 
El valor de j es : 0 
 
 
Ejemplo 1.11 En este ejemplo se muestra la diferencia de 
aplicar los operadores de incremento antes y después de la 
variable. 
#include<stdio.h> 
main() 
{ 
 int i=2,j=2,a,b; 
 a=-2*i++; 
 b=-2*++j; 
 printf(“El valor de a es: %d y el de i es: %d \n”,a,i); 
 printf(“El valor de b es: %d y el de j es: %d \n”,b,j); 
 getchar(); 
} 
 
 
 
 
Imprimirá en pantalla lo siguiente: 
 
El valor de a es : -4 y el de i es: 3 
El valor de b es : -6 y el de j es: 3 
 
 
De lo anterior nos podemos dar cuenta que existe un orden de precedencia de los operadores de 
incremento y decremento, es decir, no entregan el mismo resultado al colocarlos antes o después 
de las variables que se incrementan o decrementan. 
 
OPERADORES 
 
++ (incremento) -- (decremento) - (unario) 
* (multiplicación) / (división) %(módulo) 
+(suma) — (resta) 
= (asignación) 
 
 
Como mencionamos previamente, existe una diferencia entre : ++i; y i++; al momento de utilizar 
otros operadores de incremento y decremento. 
 
La operación de modulo (a % b) entrega el resto de la división entre los enteros a y b. 
 
 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
26
EJERCICIOS 
 
Crear los siguientes programas: 
 
1. Ingresar dos números y multiplicarlos. 
2. Ingresar el radio de una circunferencia y calcular su perímetro. 
3. Ingresar el largo y ancho de un rectángulo y calcular el área y perímetro. 
4. Ingresar el radio y el alto para obtener el volumen de un cilindro. 
5. Ingresar cuatro números, obtener la suma, multiplicación y promedio. 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
27
Dado los siguientes códigos: 
6. ¿Qué errores presenta el siguiente programa? 
#include<stdio.h> 
 main() 
{ 
 int a, b; 
 printf(“Ingrese el primer número \n”); 
 scanf(“%c”,&a); 
 printf(“Ingrese el segundo número \n”); 
 scanf(“%c”,&d); 
 } 
 
7. ¿Qué sucede en elsiguiente programa? 
#include<stdio.h> 
main() 
{ 
 float a,b; 
 printf(“Ingrese el primer valor \n”); 
 scanf(%f”,&a); 
 printf(“Ingrese el segundo valor \n”); 
 scanf(“%f”,&b); 
 suma= a+b; 
 printf(“El resultado es %d \n”, suma); 
 return(); 
 } 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
28
PARTE 2: ESTRUCTURA DE CONTROL. 
 
Las estructuras de control permiten “romper” el orden lineal de ejecución de las instrucciones (una 
a continuación de la otra), permitiendo bifurcar en dos o más caminos la ejecución de las 
instrucciones, o repetir un número conocido o desconocido de veces un conjunto de instrucciones. 
En estas estructuras se utilizan (expresiones) formadas por operadores relacionales y operadores 
lógicos. 
 
Operadores Relacionales Operadores Lógicos 
< Menor ! Negación 
> Mayor && Y lógico 
<= Menor o igual || O lógico 
>= Mayor o igual 
== Igual 
!= Distinto 
LA ESTRUCTURA DE CONTROL IF 
 
La estructura de control if permite bifurcar la ejecución de instrucciones en dos caminos 
 
Sintaxis : 
 if (expresión) 
 sentencia V // se ejecutan estas sentencias si evaluación de la expresión es verdadera
 else 
 sentencia F // se ejecutan estas instrucciones si la evaluación de la expresión es falsa 
 
donde: 
 
expresion Proposicion1 TipoOperador Proposicion2 TipoOperador ....ProposicionN 
TipoOperador Operador lógico ó OperadorMatemático ó OperadorRelacional. 
 
Ejemplo 2.1: Ingrese 2 números y muestre la división : 
 
Entrada: a y b 
Salida : a/b 
Restricciones: b ≠ 0 
#include<stdio.h> 
void main() 
{ 
 float a,b; 
 printf(“Ingrese el primer valor \n”); 
 scanf(“%f”,&a); 
 printf(“Ingrese el segundo valor \n”); 
 scanf(“%f”,&b); 
 if(b!=0) 
 printf(“El resultado es %f \n”,a/b); 
 else 
 print(“El resultado no existe \n”); 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
29
} 
 
En este ejemplo comenzamos a utilizar la proposición if. Dentro de esta proposición nos 
encontramos con el operador lógico distinto !=, ya que como sabemos cualquier número dividido 
por cero es indeterminado. Resumiendo, si el divisor es distinto de cero, se hará la división, en 
caso contrario desplegará el mensaje “El resultado no existe”. 
 
Algunas veces no es necesario la sentencia else, como se ve en el siguiente ejemplo. 
 
Ejemplo 2.2 Aquí se muestra un ejemplo donde se calcula el sueldo líquido de una persona. 
Sin embargo, si la persona es de la I o XII región, esta recibe el 35% de su sueldo por zona. Es 
posible apreciar que no es necesario la sentencia else, es decir con la sentencia if se modifica 
lo necesario y se sigue el curso normal del programa. 
Entrada: Sueldo Bruto 
Salida : Sueldo Liquido 
Restricciones: no tiene 
#include<stdio.h> 
main() 
{ 
 float sueldoB,AFP,ISAPRE; 
 int region; 
 printf(“Ingrese su sueldo Bruto \n”); 
 scanf(“%f”,&sueldoB); 
 printf(“Ingrese la region donde trabaja \n”); 
 scanf(“%d”,&region); 
 if (region==1 || region==12) // si la persona pertenece a la primera ó duodécima 
 sueldoB=sueldoB*1.35; // región se le aumenta un 35% de su sueldo bruto 
 AFP= sueldoB*0.07; // se calcula el 7% de la AFP 
 ISAPRE=sueldoB*0.11; // se calcula el 11% de la Isapre 
 printf(“ El sueldo líquido es de: %f \n”, sueldoB-AFP-ISAPRE); 
 } 
 
Algunas veces se necesitará tener varios if anidados. La sintaxis de estos es la siguiente : 
If(expresion1) 
else if(expresion2) 
 else if(expresion3) 
 else if(expresion4) 
 else expresion 5 
Ejemplo 2.3 En este ejemplo se muestra si un número es par o imparr, para ello se utiliza el 
operador módulo %. 
Entrada: X 
Salida : Mensaje 1: El número es par 
 Mensaje 2: El número es impar 
Restricciones: no tiene 
#include<stdio.h> 
main() 
{ 
 int numero; 
 printf(“Ingrese un número \n”); 
 scanf(“%d”,&numero); 
 if(!(numero%2)) 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
30
 printf(“El número es par \n”); 
 else printf(“El número es impar \n”); 
 } 
Cualquier número par, al dividirlo por 2 su residuo es 0., es decir el módulo es 0. 
 
Ejemplo 2.4 En este ejemplo se ingresan tres números y se muestra el mayor, para ello se utiliza 
la sentencia if-else anidadas. 
Entrada: a,b,c 
Salida : se imprime el mayor 
Restricciones: no tiene 
#include<stdio.h> 
main() 
{ 
 int a,b,c; 
 printf(“Ingrese el primer número \n”); 
 scanf(“%d”, &a); 
 printf(“Ingrese el segundo número \n”); 
 scanf(“%d”, &b); 
 printf(“Ingrese el tercer número \n”); 
 scanf(“%d”, &c); 
 if(a>b) 
 if(a>c) 
 printf(“El número mayor es %d \n”,a); 
 else 
 printf(“El número mayor es %d \n”,c); 
 else if(b>c) 
 printf(“El número mayor es %d \n”,b); 
 else 
 printf(“El número mayor es %d \n”,c); 
 } 
 
 
Ejemplo 2.5 En este ejemplo se ingresan tres números y se muestra el mayor, para ello se utiliza 
la sentencia if –else anidados, en conjunto con el operador lógico y ( &&). 
Entrada: a,b,c 
Salida : se imprime el mayor 
Restricciones: no tiene 
#include<stdio.h> 
main() 
{ 
 int a,b,c; 
 printf(“Ingrese el primer número \n”); 
 scanf(“%d”, &a); 
 printf(“Ingrese el segundo número \n”); 
 scanf(“%d”, &b); 
 printf(“Ingrese el tercer número \n”); 
 scanf(“%d”, &c); 
 if(a>b && a>c) 
 printf(“El numero mayor es %d \n”,a); 
 else if(b>c) 
 printf(“El número mayor es %d \n”,b); 
 else 
 printf(“El número mayor es %d \n”,c); 
 getchar(); 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
31
 } 
 
 
Ejemplo 2.6 En este ejemplo se ingresa un número entero y se muestra el valor absoluto de dicho 
número. 
Entrada: x 
Salida : Valor absoluto de x 
Restricciones:no tiene 
 #include<stdio.h> 
main() 
{ 
 int x; 
 printf(“Ingrese un número \n”); 
 scanf(“%d”, &x); 
 if(x>0) 
 printf(“El valor absoluto de %d es %d \n”,x,x); 
 else 
 printf(“El valor absoluto de %d es %d \n”,x,(-1*x)); 
 getchar(); 
} 
 
 
Ejemplo 2.7 En este ejemplo se ingresan tres números y de ellos se muestran el mayor y menor 
de los tres. 
Entrada: a,b,c 
Salida : se imprime el mayor y el menor 
Restricciones: no tiene 
 #include<stdio.h> 
main() 
{ 
 int a,b,c,min,max; 
 printf(“Ingrese el primer número \n”); 
 scanf(“%d”, &a); 
 printf(“Ingrese el segundo número \n”); 
 scanf(“%d”, &b); 
 printf(“Ingrese el tercer número \n”); 
 scanf(“%d”, &c); 
 if(a>b && a>c) 
 max=a; 
 else if(b>c) 
 max=b; 
 else 
 max=c; 
if(a<b && a<c) 
 min=a; 
else if(b<c) 
 min=b; 
else 
 min=c; 
printf(“El número mayor es %d y el menor es %d ºn”, max,min); 
} 
 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
32
 
 
Ejemplo 2.8 Este ejemplo al igual que el anterior, se ingresan tres números y se muestran el 
mayor y el menor. 
Entrada: a,b,c 
Salida : se imprime el mayor y el menor 
Restricciones: no tiene 
#include<stdio.h> 
main() 
{ 
 int a,b,c,min,max; 
 printf(“Ingrese el primer número \n”); 
 scanf(“%d”, &a); 
 printf(“Ingrese el segundo número \n”); 
 scanf(“%d”, &b); 
 printf(“Ingrese el tercer número \n”); 
 scanf(“%d”, &c); 
 if(a>b && a>c) 
 { 
 max=a;if(b>c) 
 min=c; 
 else 
 min=b; 
 } 
 else if(b>c) 
 { 
 max=b; 
 if(c>a) 
 min=a; 
 else 
 min=c; 
 } 
 else 
 { 
 max=c; 
 if(b>a) 
 min=a; 
 else 
 min=b; 
} 
printf(“El número mayor es %d y el menor es %d ºn”, max,min); 
} 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
33
 
Ejemplo 2.9 Este ejemplo muestra la solución para la ecuación cuadrática. Aquí se utiliza la librería 
math.h, la cual contiene la función sqrt. La función sqrt calcula la raíz cuadrada de un valor. 
Entrada: a,b,c 
Salida : x1 y x2 (las soluciones de la ecuación) 
Restricciones: a ≠ 0 
 b2-4ac ≥ 0 
 
 #include<stdio.h> 
#include<math.h> 
void main() 
{ 
 float a,b,c,dis; 
 float x1,x2; 
 printf(“Ingrese a \n”); 
 scanf(“%f”, &a); 
 printf(“Ingrese b \n”); 
 scanf(“%f”, &b); 
 printf(“Ingrese c \n”); 
 scanf(“%f”, &c); 
 dis=b*b-4*a*c; // aquí se calcula el discriminante 
 if(dis<0 || a ==0) // si el discriminante es menor que cero, entonces se trata de complejos 
 printf(“No se puede calcular \n”); 
 else { 
 x1= (-b+sqrt(dis))/(2*a); 
 x2= (-b-sqrt(dis))/(2*a); 
 printf(“El valor x1 y x2 son : %d, %d \n”,x1,x2); 
 } 
 } 
 
 
Ejemplo 2.10 En este ejemplo se ingresan valores númericos del 0 al 9. Y dicho valor es 
desplegado de manera textual. Aquí se utilizan varios if-else anidados. 
Entrada : x 
Salida : x escrito en palabra 
Restricciones: 0 ≤ x ≤ 9 
 
#include<stdio.h> 
void main() 
{ 
 int valor; 
 printf(“Ingrese un número del 0-9 \n”); 
 scanf(“%d”,&valor); 
 if(valor >=0 && valor <=9) 
 if(valor==1) 
 printf(“El número ingresado es el uno \n”); 
 else if(valor==2) 
 printf(“El número ingresado es el dos \n”); 
 else if(valor==3) 
 printf(“El número ingresado es el tres \n”); 
 else if(valor==4) 
 printf(“El número ingresado es el cuatro \n”); 
 else if(valor==5) 
 printf(“El número ingresado es el cinco \n”); 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
34
 
 else if(valor==6) 
 printf(“El número ingresado es el seis \n”); 
 else if(valor==7) 
 printf(“El número ingresado es el siete \n”); 
 else if(valor==8) 
 printf(“El número ingresado es el ocho \n”); 
 else 
 printf(“El número ingresado es el nueve \n”); 
 else 
 printf(“El valor ingresado esta fuera del rango \n”); 
} 
PROPOSICIÓN SWITCH 
 
switch es una proposición condicional múltiple que generaliza a la proposición if-else. 
 
Lo siguiente es la estructura del switch 
switch (expresión) 
{ 
 case 'caso_1': 
 sentencias; 
 break; 
 case 'caso_2': 
 sentencias; 
 break; 
 case 'caso_3': 
 sentencias; 
 break; 
 case 'caso_N': 
 sentencias; 
 break; 
 default: 
 sentencias; 
 } 
 
Obsérvese que la proposición switch está encerrada entre llaves. Después de evaluar la 
expresión, el control salta a la etiqueta apropiada (al correspondiente case). Todos los case 
son exclusivos, es decir reflejan un caso particular. Por lo común, la última proposición antes 
de la siguiente case es break. Con este break nos aseguramos que la ejecución del caso 
termine allí. Si no hay una proposición break, la ejecución hasta el siguiente case que sigue. La 
ausencia de proposiciones break es una causa frecuente de error en el uso de switch. Por 
último, puede haber una proposición etiquetada default. Esto indica que si la evaluación de 
switch no coincide con ninguna etiqueta, entonces toma en cuenta el default. 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
35
 
Ejemplo 2.11: Crear un programa donde el usuario pueda ingresar dos valores y opta por 
sumar, restar, dividir ó multiplicar dichos valores, utilizando switch. 
 
Entrada : x1,x2, opción 
Salida : x1 opción x2 
Restricciones: no tiene 
 
#include<stidio.h> 
void main() 
{ 
 float a,b,c; 
 int opcion,div0=0; 
 printf("Ingrese a \n"); 
 scanf("%f",&a); 
 printf(" Ingrese b \n"; 
 scanf("%f",&b); 
 printf("Ingrese 1 suma, 2 resta, 3 división ó 4 multiplicación \n"); 
 scanf("%d",&opcion); 
 if(b==0.0 && opcion==3) 
 opcion=5; 
 switch(opcion) 
 { 
 case 1 : c=a+b; 
 break; 
 case 2: c=a-b; 
 break; 
 case 3: c=a/b; 
 break; 
 case 4: c=a*b; 
 break; 
 case 5 : div0=1; 
 break; 
 default: div0=-1; 
 } 
 if(div0 == 1) 
 printf("Division por cero no se puede calcular \n"); 
 else if(div0==-1) 
 printf("Ingreso una opcion no valida \n"); 
 else 
 printf(" El resultado es : %f \n",c); 
 getchar(); 
 } 
 
Notar que los valores adjuntos al lado derecho de los case de este ejemplo, van sin ‘ ‘. Esto 
porque los valores que se están evaluando corresponde a enteros y no a caracteres. 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
36
 
Ejemplo 2.12 Crear un programa donde el usuario pueda ingresar dos valores y opta por sumar, 
restar, dividir ó multiplicar dichos valores, utilizando switch. Pero a diferencia del ejemplo anterior, 
aquí se utiliza una variable denominada bandera, la cual nos indica si es posible mostrar el 
resultado (en el caso de una división por cero, esto no es posible). 
 
Entrada : x1,x2, opción 
Salida : Mensaje 1: x1 opción x2 
 Mensaje 2: No se puede dividir por cero (en caso que se quiera dividir dos números) 
Restricciones: Si se divide, x2 no puede ser cero 
 No se puede ingresar una opción distinta a las ofrecidas 
 
#include<stidio.h> 
main() 
{ 
 float a,b,c, 
 int opcion,bandera=1; 
 printf("Ingrese a \n"); 
 scanf("%d",&a); 
 printf(" Ingrese b \n"; 
 scanf("%d",&b); 
 printf("Ingrese 1 suma, 2 resta, 3 división ó 4 multiplicación \n"); 
 scanf("%d",&opcion); 
 switch(opcion) 
 { 
 case 1 : c=a+b; 
 break; 
 case 2: c=a-b; 
 break; 
 case 3: if(b!=0.0) 
 c=a/b; 
 else bandera=-1; 
 break; 
 case 4: c=a*b; 
 break; 
 default: bandera=0; 
 } 
 if(bandera==1) 
 printf(" El resultado es : %d \n",c); 
 else if(bandera==0) 
 printf("Ingreso una opción no valida \n"); 
 else 
 printf("No se puede dividir por 0 \n"); 
 } 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
37
 
Ejemplo 2.13: Crear un programa donde el usuario ingrese un número del 1 al 9, y se muestre en 
pantalla el texto asociado al número, pero utilizando la proposición switch. 
 
Entrada : x 
Salida : x escrito en palabra 
Restricciones: 0 ≤ x ≤ 9 
 
 #include<stdio.h> 
main() 
{ 
 int valor; 
 printf(“Ingrese un número del 0-9 \n”); 
 scanf(“%d”,&valor); 
 switch(valor) 
 { 
 case 1 : printf(“El número ingresado es el uno \n”); 
 break; 
 case 2: printf(“El número ingresado es el dos \n”); 
 break; 
 case 3: printf(“El número ingresado es el tres \n”); 
 break; 
 case 4: printf(“El número ingresado es el cuatro \n”); 
 break;case 5: printf(“El número ingresado es el cinco\n”); 
 break; 
 case 6: printf(“El número ingresado es el seis\n”); 
 break; 
 case 7: printf(“El número ingresado es el siete \n”); 
 break; 
 case 8: printf(“El número ingresado es el ocho \n”); 
 break; 
 case 9: printf(“El número ingresado es el nueve \n”); 
 break; 
 default: printf("Ha ingresado un valor no válido \n"); 
 } 
 getchar(); 
 } 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
38
 
Ejemplo 2.13: Crear un programa donde el usuario pueda ingresar dos valores y optar por sumar, 
restar, dividir ó multiplicar dichos valores utilizando switch. A diferencia de los ejemplos anteriores, 
aquí seleccionamos la operación con caracteres. 
Entrada : x1,x2, opción 
Salida : Mensaje 1: x1 opción x2 
 Mensaje 2: No se puede dividir por cero (en caso que se quiera dividir dos números) 
Restricciones: Si se divide, x2 no puede ser cero 
 No se puede ingresar una opción distinta a las ofrecidas 
 
#include<stidio.h> 
main() 
{ 
 float a,b,c, 
 char opcion; 
 int bandera=1; 
 printf("Ingrese a \n"); 
 scanf("%f",&a); 
 printf(" Ingrese b \n") 
 scanf("%f",&b); 
 printf("Ingrese S suma, R resta, D división ó M multiplicación \n"); 
 scanf("%c",&opcion); 
 switch(opcion) 
 { 
 case 'S' : c=a+b; 
 break; 
 case 'R': c=a-b; 
 break; 
 case 'D': if(b!=0.0) 
 c=a/b; 
 else bandera=-1; 
break; 
 case 'M': c=a*b; 
 break; 
 default: bandera=0; 
 } 
 if(bandera==1) 
 printf(" El resultado es : %d \n",c); 
 else if(bandera==-1) 
 printf("No se puede calcular la division \n"); 
 else 
 printf("Ingreso una opción no váida \n"); 
} 
PROPOSICIÓN WHILE 
 
Es una construcción de la forma: 
 
while (expresión) 
 proposición(es) a repetir 
 proposición que no se repite 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
39
 
Primero se evalúa expresión; si es falso (o es el valor cero), el control pasa directamente a 
proposición siguiente (proposición que no se repite), pero si es verdadero (o el valor es distinto de 
cero), entonces se ejecuta (proposición a repetir), y el control se devuelve al principio del ciclo 
while. De este modo, proposición se ejecuta cero (ña expresión es falsa en la primera evaluación) o 
varias veces hasta que expresión sea falsa, en ese momento, el control pasará a la proposición 
que no se repite. El efecto de esto es que la proposición puede ejecutarse cero, una o más veces. 
Es posible que, sin advertirlo, se especifique una expresión que nunca se convierta en falsa (o 
cero), y con esto el programa quedará en un ciclo infinito a menos que se introduzcan medios para 
escapar del ciclo while; para evitar tal situación debe tenerse cuidado. 
 
Ejemplo 2.14: Crear un programa que calcule el factorial de un número que sea un entero mayor 
o igual que cero. 
Entrada : x 
Salida : 1*2*3*4*5…..*x (si x>0) 
 1 (si x=0) 
Restricciones: x ≥ 0 
#include<stdio.h> 
main() 
{ 
 int contador,numero,fact=1; 
 printf(“Ingrese el número para calcular el factorial \”); 
 scanf(“%d”,&numero); 
 if(numero >0) 
 { contador=numero ; 
 while(contador) 
 { fact=fact*contador; 
contador--; 
 } 
 printf(“El factorial de %d es %d \n”,numero,contador); 
 } 
 else if(numero==0) 
 printf(“El factorial de 0 es 1 \n”); 
 else 
 printf(“los factoriales de números negativos no existen \n”); 
} 
 
Ejemplo 2.14:Una alternativa al problema anterior 
#include<stdio.h> 
main() 
{ int contador,numero,fact=1; 
 printf(“Ingrese el número para calcular el factorial \”); 
 scanf(“%d”,&numero); 
 if(numero >0) 
 { contador=1 ; 
while(contador<=numero) 
{ fact=fact*contador; 
 contador=contador+1; 
} 
 printf(“El factorial de %d es %d \n”,numero,contador); 
 } 
 else if(numero==0) printf(“El factorial de 0 es 1 \n”); 
 else printf(“los factoriales de números negativos no existen \n”); 
 getchar(); 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
40
} 
Ejemplo 2.15: Crear un programa que resuelva lo siguiente: 
1+2+3+4+5+6+7+8+...+n 
Entrada : n 
Salida : 1+2+3+4+5+…..+(n-1)+n 
Restricciones: n > 0 
#include<stdio.h> 
main() 
{ 
 int contador,n,suma; 
 printf(“Ingrese el número para calcular la sumatoria \n”); 
 scanf(“%d”,&n); 
 if(n>0) 
 { 
 for(contador=1,suma=0;contador<=n ; contador++) 
 suma=suma+contador; 
 printf(“El resultado de la sumatoria es %d \n”,suma); 
 } 
 else 
 printf(“El número que ingreso es incorrecto\n”); 
 getchar(); 
} 
 
 
Ejemplo 2.15: Cree un programa que calcule ab, donde a >0 y b>0 
Entrada : a,b 
Salida : ab 
Restricciones: a>0 y b>0 
#include<stdio.h> 
main() 
{ 
 int contador,a,b,pot; 
 printf(“Ingrese la base\n”); 
 scanf(“%d”,&a); 
 printf(“Ingrese el exponente \n”); 
 scanf(“%d”,&b); 
 if(a>0 && b>0) 
 { 
 contador=1: 
 pot=1; 
 while(contador<=b) 
 { 
pot=pot*a; 
contador=contador+1; 
 } 
 printf(“El resultado de %d elevado a %d es %d \n”,a,b,pot); 
 } 
 else 
 printf(“Hay un número que no es mayor que 0 \n”); 
 getchar(); 
} 
Nota: modificar este programa para que a y b acepte cualquier valor entero (positivo, negativo o 
cero). 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
41
EJERCICIOS PARTE 2: CICLO WHILE 
 
1.- Crear un programa que calcule: 12+22+32+42+...+n2 
 
2.- Crear un programa que calcule : (n)= 11+22+33+44+...+nn 
 
3.- Crear un programa que calcule: 1!+2!+3!+4!+...+n! 
 
4.- Crear un programa que calcule. 10+21+32+43+54 +...+Nn-1 
 
5.- Crear un programa donde se ingresen 15 números y muestre el mayor de todos. 
 
6.- Crear un programa donde se ingresen 20 números y muestre el mayor y el menor. 
 
7.- Crear un programa que calcule: (a ϖ b)= a!/(b!-a!). 
 
8.- Crear un programa donde se ingresen 15 números y contar cuantos son pares. 
 
9.- Analizar el siguiente programa. 
 
#include<stdio.h> 
main() 
{ 
 int valor,contpares=0,i; 
 i=50000; 
 while(i); 
 i--; 
 printf(“ Fin del programa \n”); 
} 
 
 
 
10.- Analizar el siguiente programa. 
 
#include<stdio.h> 
main() 
{ 
 int i; 
 i=1; 
 while(i) 
printf(“ El valor de i es : %d\n",i); 
i++; 
} 
 
 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
42
PROPOSICIÓN FOR 
Sintaxis: 
 
 for (expresión1 ; expresión2 ; expresión3) 
 proposición verdadera; 
 proposición siguiente; 
 
o 
 
 for (expresión1 ; expresión2 ; expresión3) 
 { 
 proposición verdadera1; 
 proposición verdadera2; 
 …. 
 proposición verdaderaN; 
 } 
 proposición siguiente; 
 
 
Primero se evalúa expresión1 (lo usual es que expresión1 inicie el ciclo); después, se evalúa 
expresión2, si la expresión 2 es verdadera (o posee un valor distinto de 0) entonces se ejecuta la 
proposición verdadera o el conjunto de expresiones verdaderas. Note que el conjunto de 
expresiones verdaderas está compuesto por más de una expresión verdadera y por lo tanto debe 
de llevar las llaves { }. Posterior al ejecutar la proposición o proposiciones verdades, entonces se 
ejecuta la expresión 3, la cual generalmente aumenta o disminuye lavariable, o variables que 
condicionan el ciclo. Posteriormente se vuelve a evaluar la expresión2, si esto es verdadero se 
vuelve a ejecutar la proposición o conjunto de proposiciones verdaderas, donde posteriormente se 
evalua la expresión3. Note que la expresión1, sólo se ejecuta la primera vez, luego la expresión2 y 
expresión3 se peueden ejecutar muchas veces mientras la expresión 2 sea verdadera. 
Finalmente, si la expresión2 es falsa (o posee un valor 0), entonces se ejecuta la 
proposición siguiente. 
 
Ejemplo 2.16 Este ejemplo imprime valores desde 1 al 15, utilizando el ciclo for 
 
#include<stdio.h> 
#define STOP 15 
main() 
{ 
 int i; 
 for(i=1;i<=STOP;i++) 
 printf(“El valor de i es:%d\n”,i); 
 getchar(); 
 } 
 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
43
 
Ejemplo 2.17: Crear un programa que calcule el factorial de un número que sea un entero 
mayor que cero. 
Entrada : x 
Salida : 1*2*3*4*5…..*x (si x>0) 
 1 (si x=0) 
Restricciones: x ≥ 0 
#include<stdio.h> 
main() 
{ 
 int contador,numero,fact=1; 
 printf(“Ingrese el número para calcular el factorial \n”); 
 scanf(“%d”,&numero); 
 if (numero >0) 
 { 
 for( contador=numero ; contador ; contador--) 
 fact=fact*contador; 
 printf(“El factorial de %d es %d \n”,numero,fact); 
 } 
 else if (numero==0) 
 printf(“El factorial de 0 es 1 \n”); 
 else 
 printf(“los factoriales de números negativos no existen \n”); 
} 
 
 
Ejemplo 2.18: Crear un programa que resuelva lo siguiente: 
 1+2+3+4+5+6+7+8+...+n , utilizando ciclos for 
Entrada : n 
Salida : 1+2+3+4+5+…..+(n-1)+n 
Restricciones: n > 0 
#include<stdio.h> 
main() 
{ 
 int i,n,suma=0; 
 
 printf(“Ingrese el número para calcular la sumatoria \n”); 
 scanf(“%d”,&n); 
 if(n>0) 
 { 
 for(i=1,suma=0;i<=n ; i++) 
 suma=suma+i; 
 printf(“El resultado de la sumatoria es %d \n”,suma); 
 } 
 else 
 printf(“El número que ingreso es incorrecto\n”); 
} 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
44
 
 
Ejemplo 2.19: Cree un programa que calcule ab, donde a >0 y b>0 
 
Entrada : a,b 
Salida : ab 
Restricciones: a>0 y b>0 
#include<stdio.h> 
main() 
{ 
 int i,a,b,pot; 
 
printf(“Ingrese la base\n”); 
scanf(“%d”,&a); 
printf(“Ingrese el exponente \n”); 
scanf(“%d”,&b); 
if(a>0 && b>0) 
 { 
 for(i=pot=1; i<=b; i++) 
 pot=pot*a; 
 printf(“El resultado de %d elevado a %d es %d \n”,a,b,pot); 
 } 
else 
 printf(“Hay un número que no es mayor que 0 \n”); 
} 
 
 
Ejemplo 2.20: Crear un programa que calcule: 11+22+33+44+...+nn 
Entrada : n 
Salida : 11+22+33+44+...+nn 
Restricciones: n > 0 
 
#include<stdio.h> 
void main() 
{ 
 int contador,N,b,pot; 
 printf(“Ingrese N\n”); 
 scanf(“%d”,&N); 
 if(N>0 ) 
 { 
 for(i=1;i<=N;i++) 
{ for(j=pot=1; j<=i ; j++) 
 pot=pot*a; 
 suma=suma+pot; 
 } 
 printf(“El resultado es. %d \N”,suma); 
 } 
 else 
 printf(“el número ingresado no es mayor que 0 \n”); 
} 
 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
45
EJERCICIOS PARTE 2 CICLOS FOR 
 
Utilizando el ciclo for construya los siguientes programas 
 
11. Calcular lo siguiente : 1+2+3+4+5+...+N 
 
12. Calcular 12+22+32+42+...+N2 
 
13. Crear un programa que calcule: 10+21+32+43+...+NN-1 
 
14. Crear un programa que calcule: 11+22+33+44+..+Nn 
 
15. Crear un programa que calcule lo siguiente: 1!+2!+3!+4!+...+N! 
 
16. Crear un programa que calcule: a ω b= a!/b!(b-a)! 
 
17. Crear un programa que calcule lo siguiente: 
(a k)=s(s-1)(s-2)(s-3)(s-4)...(s-k+1)/k! 
(a 0)=1 
s ∈ R+, k ∈ N U{0} 
 
 
18. Crear un programa que calcule: 1(x1+1)/1!+2(x2+1)/2!+3(x3+1)/3!+...+N(xN+1)/N! 
 
19. Crear un programa que calcule lo siguiente: 
 n 
 3*∑ i 2*i-1/(n-i)! 
 i=1 
 
 
 
 
20. Crear un programa que calcule lo siguiente: 
 
 n i 
 ∑ ∑ ( (2*i)/j ) 
 i=1 j=1 
 
21. Crear un programa que calcule: 
 n i 
 ∑ ∑ (2*j)i 
 i=1 j=1 
 
 
22. Crear un programa donde se ingresen 50 números, muestre el mayor, menor, y cuantos de 
ellos son múltiplos de 5. 
 
 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
46
PROPOSICIÓN DO WHILE 
 Este es un ciclo como los anteriores, pero la principal diferencia es que este se ejecuta al 
menos una vez. 
Sintaxis: 
do 
{ 
 sentencia_1; 
 sentencia_2; 
 : 
 sentencia_N; 
 } 
 while(proposicion); 
 
Ejemplo 2.21: Crear un programa donde el usuario ingrese 2 números y pueda ejecutar 
cualquiera de las operaciones basicas. Si se desea salir se debe ingresar 0. 
Entrada : x1,x2, opción 
Salida : Mensaje 1: x1 opción x2 
 Mensaje 2: No se puede dividir por cero (en caso que se quiera dividir dos números) 
Restricciones: Si se divide, x2 no puede ser cero 
 No se puede ingresar una opción distinta a las ofrecidas 
#include<stdio.h> 
main() 
{ 
 float a,b,c; 
 int opcion; 
 do 
 { 
 printf("Ingrese el Primer Valor \n"); 
 scanf("%f",&a); 
 printf("Ingrese el segundo Valor \n"); 
 scanf("%f",&b); 
 printf("Ingrese 1:sumar, 2:restar ,3:dividir,4:mutiplicar \n") ; 
 scanf("%d",&opcion); 
 if (b!=0.0 && opcion==3) opcion=5; 
switch(opcion) 
 { 
 case 1: printf("El resultado es : %f \n",a+b); 
 break; 
 case 2: printf("El resultado es : %f \n",a-b); 
 break; 
 case 3: printf("El resultado es : %f \n",a/b); 
 break; 
 case 4: printf("El resultado es : %f \n",a*b); 
 break; 
 case 5: printf("No se puede dividir por cero \n"); 
 break; 
 default: printf(" Ha ingresado un valor no válido \n"); 
 } 
 printf("Ingrese 0 para terminar y cualquier número para continuar \n"); 
 scanf("%d",&opcion); 
 } 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
47
 while(opcion); 
} 
 
 
PREGUNTAS DE CERTAMENES DE AÑOS ANTERIORES AL 
2008, REFERENTES AL MANEJO DE CICLOS Y 
EVALUACIONES LÓGICAS 
 
A continuación se lista algunas preguntas que se encuentran en certamenes 
anteriores, estás preguntas están con sus respuestas al final del apunte. 
 
PCR23.- Pregunta 1. Primer Certamen, Segundo Semestre 2007, 10 ptos. 
 
Dada la siguiente expresión: 
 
!( k>=j || k<=5) && (!(j=j-1 > k ) && ((i+1)==j/2)) 
 
Evalúe los valores de verdad (es decir, si el resultado es verdadero o falso) tanto al interior 
de cada paréntesis, como en la expresión completa, con los valores de variable indicados en 
los casos a) y b) abajo expuestos. Las variables son de tipo entero (5 puntos cada caso). 
 
Casos: 
a) k=3, j=4, i=4 
b) k=3 , j=7, i=3 
 
 
 
 
PCR24. Pregunta 2. Primer Certamen, Segundo Semestre 2007, 25 ptos. 
 
 
Dado los siguientes algoritmos, obtenga los valores de las variables que aparecen en la tabla en 
cada iteración, para un valor inicial de N=6 (25 puntos el ejercicio completo). 
 
 
ALGORITMO uno 
{ 
int i,stop=1,cont,N 
printf “Ingrese N” 
scanf N 
 
for(i=1, cont=0;i<=N && stop !=0 ;i=i+1) 
{ if (!(i/2)) 
printf “1” 
cont=cont+1 
if(cont==3) 
stop=0 
else 
printf “0” 
 
} 
} 
 
Introducción a la Programación 
Departamento de Sistemas de Información 
Universidad del Bío-Bío 
 
Página : 
Claudio Gutiérrez-Soto, Manuel Crisosto, 
48
PCR25. Pregunta 2. Primer