ALG Guia5

PONTIFICIA UNIVERSIDAD CATÓLICA DE CHILE
ESCUELA DE INGENIERÍA
DEPARTAMENTO DE CIENCIA DE LA COMPUTACIÓN
IIC 1102 INTRODUCCIÓN A LA PROGRAMACIÓN
Profesor: Rodrigo Sandoval U.
Capítulo V – Control de Flujo
1 CONTROL DE FLUJO....................................................................................................................................... 1
2 DECISIÓN O SELECCIÓN ............................................................................................................................... 2
2.1 INSTRUCCIÓN IF .............................................................................................................................................. 2
2.1.1 Ejemplo: ¿Qué hago el sábado por la noche? (Implementación) .......................................................... 3
2.2 INSTRUCCIÓN SWITCH ..................................................................................................................................... 6
2.2.1 Ejemplo: Conversión a letras de una cantidad de dos dígitos ............................................................... 7
3 ITERACIÓN......................................................................................................................................................... 9
3.1 INSTRUCCIÓN WHILE ....................................................................................................................................... 9
3.1.1 Ejemplo: Tabla de conversión de temperaturas (Fahrenheit-Celsius) .................................................. 9
3.1.2 Ejemplo: Esperando el Año Nuevo ...................................................................................................... 10
3.2 INSTRUCCIÓN DO-WHILE ............................................................................................................................... 12
3.3 INSTRUCCIÓN FOR ......................................................................................................................................... 13
3.3.1 Ejemplo: Cálculo de x a la n (uso restringido del for)......................................................................... 15
3.3.2 Ejemplo: Conversión a letras de cantidades numéricas (uso general del for)..................................... 16
3.4 INSTRUCCIÓN FOREACH ................................................................................................................................ 19
3.5 EQUIVALENCIA LÓGICA ENTRE INSTRUCCIONES DE ITERACIÓN.................................................................... 19
3.5.1 Ejemplos: Programa con funciones equivalentes y Ciclos anidados ................................................... 21
3.6 ITERACIONES CON ANIDAMIENTO ................................................................................................................. 24
Material preparado por Rodrigo Sandoval U en Marzo 2004,

basado en los apuntes de clase del curso IIC1102, año 2003, de M. Nussbaum, Marcos Sepúlveda, et.al
Intro Prog. Orientada a Objeto – Control de Flujo Rodrigo Sandoval U.
1 Control de Flujo
Los algoritmos normalmente requieren modificar el flujo de ejecución de las instrucciones que lo
componen. Esto se lleva a cabo mediante decisión e iteración.
La decisión permite especificar la ejecución condicional de ciertas instrucciones. La condición que se
considera para tomar la decisión está basada en el estado actual de la ejecución, es decir, en las
entradas del programa, las instrucciones ejecutadas hasta ahora y, en general, en el contenido de las
variables.
Los lugares dentro del programa en que se toman las decisiones se conocen como puntos de control de
flujo, o simplemente, puntos de decisión.
Como referencia puede consultarse la sección que trata los árboles de decisión y, en particular, el
ejemplo ¿Qué hago el sábado por la noche?, donde se ilustra una situación en la que es necesario tomar
decisiones durante la ejecución de un algoritmo.
El lenguaje de programación C# cuenta con dos instrucciones que permiten especificar decisión dentro
de un programa:
• if-else
• switch
Por otra parte, la iteración permite controlar mediante expresiones lógicas la repetición de una o varias
instrucciones dentro del programa. Los bloques con las instrucciones que se repiten se conocen como
ciclos o loops. La expresión que controla la ejecución del ciclo se conoce como condición de control.
El lenguaje de programación C# cuenta con cuatro instrucciones para especificar iteraciones, y aunque
éstas son lógicamente equivalentes (ver ejemplos más adelante), sus diferencias radican principalmente
en la forma en que se controla la continuación o terminación del ciclo (especificación y verificación). Las
instrucciones son:
• while
• do-while
• for
• foreach
IIC 1102 Página: 1

2 Decisión o Selección
2.1 Instrucción if
La instrucción if permite decidir si una porción de código (una o más instrucciones) se debe ejecutar,
tomando como criterio para la decisión el valor de una expresión lógica. Alternativamente, permite elegir
entre dos porciones de código, de acuerdo a la evaluación de la expresión de control.
Sintaxis:
if ( expresion-evaluación )
instrucción ;
if ( expresion-evaluación ) {
...
Bloque de instrucciones
...
}
if ( expresion-evaluación )
instrucción1 ;
else
instrucción2 ;
if ( expresion-evaluación ) {
...
Bloque de instrucciones 1
...
}
else {
...
...
}
Los bloques de instrucciones consisten en una secuencia de instrucciones terminadas en punto y coma.
Al ejecutarse una instrucción if, se evaluará la expresión de evaluación o expresión booleana (que
resulta en Verdadero o Falso) suministrada en los paréntesis, y dependiendo de su valor (verdadero o
falso, es decir, true o false), se tomará una de las siguientes acciones:
• Si la expresión es verdadera, se ejecutará la instrucción o bloque de instrucciones que viene
después de la condición, pero antes de la sección else (si es que existe). Una vez hecho esto,
se continuará la ejecución en la siguiente instrucción después del if.
• Si la expresión es falsa, y no se incluyó la partícula else dentro de la instrucción, el if pasará
desapercibido, es decir, no se ejecutará las instrucciones contenidas en él, sino que la ejecución
continuará en la siguiente instrucción después del if.
IIC 1102 Página: 2

• Si la expresión es falsa, y existe una partícula else dentro del if, se ejecutará la instrucción o
bloque de instrucciones que viene después del else. Una vez hecho esto, se continuará la
ejecución en la siguiente instrucción después del if.
Es posible escribir if anidados, es decir, incluir otras instrucciones if dentro de las instrucciones a
ejecutar al evaluar una primera instrucción if.
Ejemplos:
1. int edad;
int viejitos = 0;
if (edad > 80) {

// Esto se ejecuta si la variable edad tiene un valor mayor a 80
viejitos++;
Console.WriteLine("Ud. no califica para descuento de adolescente”);
}
else {
// Esto se ejecuta si la variable edad tiene un valor <= 80
Console.WriteLine("Bienvenido, Ud. cuenta con un descuento de $15”);
}
2. int salario, credito;
if (salario > 1000000)

credito = 5000000;
else if (salario > 500000)
credito = 2000000;
else if (salario > 100000)
credito = 1000000;
else
credito = 0;
2.1.1 Ejemplo: ¿Qué hago el sábado por la noche? (Implementación)

Se presenta una implementación (empleando la instrucción if) del árbol de decisión para saber qué
hacer el sábado por la noche.
Para ilustrar el uso de los árboles de decisión, se presenta un árbol que guía a un usuario a tomar una
decisión sobre qué hacer el sábado por la noche. La profundización en el árbol se lleva a cabo de
acuerdo a las respuestas que va dando el usuario a las interrogantes que se le plantean. Cuando se llega
a un nodo terminal en el árbol (hoja), el usuario recibe una recomendación sustentada en el desarrollo de
la interacción.
IIC 1102 Página: 3

using System;
class MainApp {
public static void Main() {

string respuesta;
Console.WriteLine("Veamos qué hacer el sábado por la noche... ");
Console.Write("Desea quedarse en casa? (s/n): ");

respuesta = Console.ReadLine();
if (respuesta=="s") {
Console.Write ("Le gusta ver TV? (s/n): ");
Console.Write("Hay algún programa bueno esta noche? (s/n): ");
if (respuesta=="s")
Console.WriteLine("Sugerencia: Coma cabritas y vea el programa de hoy");
else
Console.WriteLine("Sugerencia: Arriende una pelicula");
}
IIC 1102 Página: 4

else {
Console.Write("Le gusta leer? (s/n): ");
if (respuesta=="s")
Console.WriteLine("Sugerencia: Tómese un vinito y lea un buen libro");
else
Console.WriteLine("Sugerencia: Vaya a dormir! ...Buenas noches");
}
}
else {
Console.Write ("Le gusta bailar? (s/n): ");
Console.Write("Le gusta la música tropical? (s/n): ");
if (respuesta=="s")
Console.WriteLine("Sugerencia: Vaya a la discotheque El Merengazo");
else
Console.WriteLine("Sugerencia: Vaya a la discotheque Los Tarros");
}
else {
Console.Write("Le gusta ir al cine? (s/n): ");
if (respuesta=="s")
Console.WriteLine("Sugerencia: Vaya a ver una película");
else
Console.WriteLine("Sugerencia: Vaya a un pub y tómese un Pisco Sour");
}
}
Console.Write("Presione ENTER para terminar."); Console.ReadLine();
}
}
Ejemplo de ejecución:
Veamos que hacer el sábado por la noche...
Desea quedarse en casa? (s/n): s
Le gusta ver TV? (s/n): n
Le gusta leer? (s/n): s
Sugerencia: Tómese un vinito y lea un buen libro
Veamos que hacer el sábado por la noche...

Desea quedarse en casa? (s/n): n
Le gusta bailar? (s/n): s
Le gusta la música tropical? (s/n): n
Sugerencia: Vaya a la discotheque Los Tarros
IIC 1102 Página: 5

2.2 Instrucción switch

La instrucción switch permite decidir cuál bloque de instrucciones se debe ejecutar, de una serie de
bloques disponibles, tomando como criterio para la decisión el valor de una expresión. La expresión
suministrada se compara con una serie de valores constantes que etiquetan los bloques de instrucciones,
y cuando se logra un valor igual se inicia la ejecución en ese punto.
Sintaxis:
switch ( expresión ) {
case constante1 : {
...
...
break;
}
case constante2 : {
...
...
break;
}
...
case constanteN : {
...
Bloque de instrucciones N
...
break;
}
default : { // Opcional
...
Bloque de instrucciones N+1
...
}
}
Al ejecutarse una instrucción switch, se evaluará la expresión suministrada en los paréntesis, y se
comparará su valor con cada una de las constantes dadas, empezando por la primera y descendiendo.
Dependiendo de estos valores puede ocurrir lo siguiente:
• Si se encuentra una constante igual al valor de la expresión, la ejecución continuará en el bloque
de instrucciones asociado con la constante, y seguirá de ahí en adelante hasta terminar el caso
particular del switch, el cual debe terminar en instrucción break u otra de salto de flujo
(como continue o return). Una vez hecho esto, la ejecución continuará en la siguiente instrucción
después del switch.
• Si no se encuentra ninguna constante que sea igual al valor de la expresión, y no se incluyó la
sección default, la instrucción pasará inadvertida (no se ejecutará ninguna de las
instrucciones contenidas en ella), y la ejecución continuará en la siguiente instrucción después
del switch.
IIC 1102 Página: 6

• Si no se encuentra ninguna constante que sea igual al valor de la expresión, pero existe un
bloque de instrucciones asociado con la partícula default, la ejecución continuará en ese
bloque. Una vez hecho esto, la ejecución seguirá en la siguiente instrucción después del
switch.
• Es posible escribir switch anidados, es decir, incluir otras instrucciones switch dentro de
las instrucciones a ejecutar al evaluar una primera instrucción switch.
Ejemplos: Clásico uso en un menú de opciones
Console.WriteLine(“Con qué desea pagar?”);
Console.WriteLine(“1) Efectivo”);
Console.WriteLine(“2) Cheque”);
Console.WriteLine(“3) Tarjeta Crédito”);
Console.WriteLine(“4) MasterCard”);
opcion = int.Parse(Console.ReadLine());
switch( opcion ) {
case 1: Console.WriteLine(“Sólo con billetes nuevos”); break;
case 2: Console.WriteLine(“Adjunte su cédula al cheque”); break;
case 3: Console.WriteLine(“Entréguenos su tarjeta, por favor”); break;
default: Console.WriteLine(“Lo siento, pero no manejamos ese medio”);
}
2.2.1 Ejemplo: Conversión a letras de una cantidad de dos dígitos

Programa que convierte una cantidad de dos dígitos a letras, en la forma en que sería útil, por ejemplo,
para escribir un cheque. El programa es una versión muy simple que soporta sólo cantidades entre 30 y
99 (no se consideran excepciones). El programa pide al usuario que ingrese una cantidad entre 30 y 99, y
le devuelve por pantalla el equivalente en letras. No se tratan los números entre 1 y 29 por simplicidad,
dado que entre estos valores se presentan múltiples reglas de excepción. Si no se respeta esta
restricción se obtendrán resultados sin sentido
using System;
class MainApp {
public static void Main() {
int cantidad; // cantidad a convertir
int decenas; // numero de decenas en la cantidad a convertir
int unidades; // numero de unidades en la cantidad a convertir
Console.Write("Ingrese un numero entero entre 0 y 99: ");

cantidad = (int) Console.Read();
decenas = cantidad / 10;

unidades = cantidad % 10;
if(decenas == 1)
{
switch(unidades)
{
case 0: {Console.Write("Diez “); break;}
case 1: {Console.Write("Once “); break;}
case 2: {Console.Write("Doce “); break;}
case 3: {Console.Write("Trece “); break;}
IIC 1102 Página: 7

case 4: {Console.Write("Catorce “); break;}

case 5: {Console.Write("Quince “); break;}
case 6: {Console.Write("Dieciseis “); break;}
case 7: {Console.Write("Diecisiete”); break;}
case 8: {Console.Write("Dieciocho “); break;}
case 9: {Console.Write("Diecinueve”); break;}
}
}
else{
switch(decenas) {
case 2:
{
if (unidades == 0) Console.Write("Veinte");
else Console.Write("Veinti");
break;
}
case 3: { Console.Write("Treinta"); break; }
case 4: { Console.Write("Cuarenta"); break; }
case 5: { Console.Write("Cincuenta"); break; }
case 6: { Console.Write("Sesenta"); break; }
case 7: { Console.Write("Setenta"); break; }
case 8: { Console.Write("Ochenta"); break; }
case 9: { Console.Write("Noventa"); break; }
}
if(unidades>0 && decenas>2) Console.Write(" y ");
switch(unidades) {
case 0: { Console.Write("“); break; }
case 1: { Console.Write("uno “); break; }
case 2: { Console.Write("dos “); break; }
case 3: { Console.Write("tres “); break; }
case 4: { Console.Write("cuatro”); break; }
case 5: { Console.Write("cinco “); break; }
case 6: { Console.Write("seis “); break; }
case 7: { Console.Write("siete “); break; }
case 8: { Console.Write("ocho “); break; }
case 9: { Console.Write("nueve “); break; }
}
}
Console.Write("\nPresione ENTER para terminar."); Console.ReadLine();
}
}
Ingrese un numero entero entre 0 y 99: 32

Treinta y dos
IIC 1102 Página: 8

3 Iteración
3.1 Instrucción while
La instrucción while permite repetir una instrucción o un bloque de instrucciones, tantas veces como
sea necesario, mientras una determinada expresión lógica sea verdadera. Si la expresión es falsa
inicialmente, la instrucción while no tiene efecto alguno, es decir, no ejecuta ninguna de las
instrucciones subordinadas.
Más adelante se presenta una equivalencia lógica de las tres instrucciones para especificar iteración con
que cuenta el lenguaje de programación C.
Sintaxis:
while ( expresión-lógica )
instrucción ;
while ( expresión-lógica ) {
...
...
}
Al ejecutarse la instrucción while, se evaluará la expresión booleana suministrada en los paréntesis, y
si su valor es verdadero, se ejecutarán la o las instrucciones subordinadas. Una vez hecho esto, la
condición es reevaluada y se procede de la misma manera. Cuando la condición se vuelve falsa, en la
siguiente evaluación se dará la instrucción while por terminada.
Las instrucciones subordinadas al while pueden ser compuestas, es decir, otras instrucciones while,
if, etc.
Si la condición nunca se vuelve falsa, la instrucción nunca terminará y, dependiendo de las instrucciones
incluidas en el ciclo, se generaría un error de ejecución que detendría el programa, o podría ser que el
programa itere indefinidamente hasta ser detenido en forma manual.
Ejemplos:
1. num = 0;
while (num < 50) {
// Esto se ejecuta en cada iteración, hasta que num = 50
if ( (num % 2) == 0 )
Console.WriteLine("El número {0} es par", num);
else
Console.WriteLine("El número {0} es impar", num);
num++;
}
3.1.1 Ejemplo: Tabla de conversión de temperaturas (Fahrenheit-Celsius)

Programa que genera una tabla de equivalencias Celsius-Fahrenheit, desde -15 hasta 50 grados Celsius.
Se emplea una función de conversión para llevar a cabo los cálculos.
IIC 1102 Página: 9

using System;
class Temperatura {
// Función que recibe una temperatura expresada en grados Celsius y retorna

// su equivalente en grados Faherenheit. El argumento de entrada es celsius
// de tipo float. El valor de retorno también es de tipo float.
// La fórmula de conversión es F=32+(C*9/5)
***************************************************************************/
public float fahrenheit(float celsius) {
return((celsius*9/5)+32);
}
}
class MainApp {
static void Main () {

Temperatura temp = new Temperatura();
float centigrados = (float) -15.0; // Temperatura en grados Celsius, inicialmente -15
// Imprime el encabezado de la tabla con un formato que le da buena apariencia

// Refiérase a la descripción de Console.WriteLine para mayor detalle
Console.WriteLine("{0,15} {1,15}", "Celsius", "Fahrenheit");
// Ciclo que genera la tabla. La variable centígrados vale inicialmente -15, y

// dentro del ciclo se va a ir incrementando en paso de 5 grados, hasta llegar
// hasta 50: Ver la condición de control del while. En cada iteración del
// ciclo se imprime el valor en centígrados y su equivalente fahrenheit.
// Observe que la conversión se lleva a cabo directamente al imprimir.
while (centigrados <= 50.0) {
// Imprime la fila de la tabla: Centígrados - Fahrenheit
Console.WriteLine("{0,15:F2} {1,15:F2}", centigrados, temp.fahrenheit(centigrados));
// Incrementa centigrados para la siguiente iteración

centigrados = centigrados + 5;
}
Console.WriteLine("Presione ENTER para terminar."); Console.ReadLine();
}
}
Celsius Fahrenheit
-15.00 5.00
-10.00 14.00
-5.00 23.00
0.00 32.00
5.00 41.00
10.00 50.00
15.00 59.00
20.00 68.00
25.00 77.00
30.00 86.00
35.00 95.00
40.00 104.00
45.00 113.00
50.00 122.00
3.1.2 Ejemplo: Esperando el Año Nuevo

Este programa es una simulación de un cronómetro para la espera del año nuevo. El programa pide al
usuario la fecha y hora actuales, y cuenta los segundos hasta la llegada del primero de enero del
siguiente año. Los segundos se simulan como iteraciones en un ciclo. Una vez llegada la fecha esperada
imprime un mensaje que incluye la cantidad de segundos que esperó (es decir, la cantidad de iteraciones
IIC 1102 Página: 10

que completó). En esta simulación se toman las medidas pertinentes para detectar y tratar en forma
especial los años bisiestos.
using System;
class Agno {
private int agno;
// Constructor de la clase. Inicializa el valor del año

public Agno(int a) { agno = a; }
//////////////////////////////////////////////////////////////////////////////
// Función que recibe como argumento un año y devuelve un número entero que
// indica si es bisiesto o no. Si el año pasado es bisiesto la función
// retorna true, y en caso contrario false. Para saber si un año es bisiesto
// basta con analizar si es divisible por 4 y no por 100 (empleando módulo).
//////////////////////////////////////////////////////////////////////////////
public bool bisiesto()
{
if ((agno % 4 == 0) && (agno % 100 != 0)) return(true);
else return(false);
}
}
class MainApp {
static void Main()

{
int d, m, a, hh, mm, ss; // Hora y fecha actuales
long contador = 0; // Contador de segundos
Console.WriteLine("Ingrese la fecha actual.");

Console.Write("Ingrese el día: "); d = int.Parse(Console.ReadLine());
Console.Write("Ingrese el mes: "); m = int.Parse(Console.ReadLine());
Console.Write("Ingrese el año: "); a = int.Parse(Console.ReadLine());
Console.Write("Ingrese la hora: "); hh = int.Parse(Console.ReadLine());
Console.Write("Ingrese minutos: "); mm = int.Parse(Console.ReadLine());
Console.Write("Ingrese segundos: "); ss = int.Parse(Console.ReadLine());
Agno year = new Agno(a); // Se inicializa la instancia de año
// Este ciclo simula la ocurrencia de un segundo en cada iteración. La variable

// contador (inicialmente en 0) se incrementa en cada vuelta, para lograr tal
// efecto. Cada vez que pasa un segundo se verifica si es necesario actualizar
// el estado de las variables que mantienen la hora, minutos, día, mes y año.
// La condición para salir del ciclo es llegar (o estar) al primero de enero.
while (d!=1 || m!=1) { // Día=1 y Mes=1 -> ¡1º enero!

ss++; // Se aumenta el contador de segundos
if (ss==60) {
ss = 0; mm++;
if (mm==60) {
mm=0; hh++;

if (hh==24) {
hh = 0; d++;
// Verifica si hay cambio de mes, considerando las excepciones:

// Abril, Junio, Septiembre y Noviembre tienen solo 30 días
// Febrero tiene 28 días excepto en los años bisiestos
// El resto de los meses tienen 31 días
if ( (d==29 && m==2 && !year.bisiesto()) ||
(d==30 && m==2 && year.bisiesto()) ||
(d==31 && (m==4 || m==6 || m==9 || m==11)) ||
(d==32) ) {
d=1; m++;
if (m==13) {
m=1; a++;
}
}
}
}
}
contador++;
}
Console.WriteLine("Feliz año {0,4} !!!", a);

Console.WriteLine("Transcurrieron {0} segundos", contador);
Console.WriteLine("Presione ENTER para terminar.");
Console.ReadLine();
}
}
3.2 Instrucción do-while

La instrucción do-while permite repetir una instrucción o un bloque de instrucciones, tantas veces
como sea necesario, mientras una determinada expresión lógica sea verdadera. A diferencia de la
instrucción while, la condición se verifica una vez ejecutadas las instrucciones subordinadas, por lo
que si la expresión es falsa inicialmente, y permanece así, el cuerpo del ciclo se ejecutará una vez (con
while no se ejecutaría).
Sintaxis:
do
instrucción ;
while ( expresión-lógica );
do {
...
...
} while ( expresión-lógica );
Al ejecutarse la instrucción do-while, se ejecutarán la o las instrucciones subordinadas. Una vez
hecho esto, se evalúa la expresión booleana suministrada en los paréntesis, y si su valor es verdadero,
se volverán a ejecutar las instrucciones subordinadas y se procederá de la misma manera. Cuando la
condición se vuelve falsa, en la siguiente evaluación se dará la instrucción do-while por terminada.

Las instrucciones subordinadas al do-while pueden ser compuestas, es decir, otras instrucciones
do-while, while, if, etc.
Si la condición nunca se vuelve cero, la instrucción nunca terminará y, dependiendo de las instrucciones
Ejemplos:
1. do {
// Esto se ejecuta en cada iteración del ciclo
...
Console.Write ("Desea continuar? (s/n): ");
} while (respuesta != “n”);
Programas de ejemplo: Ver ejemplos en capítulo de Algoritmos Numéricos
3.3 Instrucción for

La instrucción for permite repetir una instrucción o un bloque de instrucciones, tantas veces como sea
necesario, mientras una determinada expresión lógica sea verdadera. Permite además especificar
instrucciones de inicialización (que se ejecutarán una única vez antes de empezar las iteraciones), así
como instrucciones que deben ejecutarse al finalizar cada iteración, pero antes de empezar la siguiente.
Al igual que la instrucción while la condición se verifica antes de ejecutar las instrucciones
subordinadas, por lo que si la expresión es falsa inicialmente, la instrucción no tendrá efecto alguno, es
decir, no se ejecuta ninguna de las instrucciones subordinadas.
Más adelante se presenta una equivalencia lógica de las tres instrucciones para especificar iteración con
que cuenta el lenguaje de programación C.
Sintaxis:
for ( inicialización ; expresión-booleana ; actualización
)
instrucción ;
for ( inicialización ; expresión-booleana ; actualización

) {
...
...
}
Tanto el componente de inicialización como el de actualización corresponde a una instrucción, o a varias
separadas por comas. Cualquiera de los componenentes en los paréntesis se puede omitir, incluso los
tres, pero los separadores (punto y coma) deben aparecer siempre.
Al ejecutarse la instrucción for, en primera instancia se ejecutará la sección de inicialización.
Posteriormente se evaluará la condición y, en caso de ser verdadera (no cero), se ejecutarán la o las
instrucciones subordinadas. Una vez cumplido esto, se ejecutará la sección de actualización y se volverá
a verificar la condición. Cuando la condición se vuelve falsa (es decir, cero), en la siguiente evaluación se
dará la instrucción for por terminada.

Las instrucciones subordinadas al for pueden ser compuestas, es decir, otras instrucciones for, do-
while, while, if, etc.
Si la condición nunca se vuelve cero, la instrucción nunca terminará y, dependiendo de las instrucciones
El uso normal que se le da a la instrucción for es para implementar ciclos en los cuales se conoce de
antemano, o al menos se puede determinar antes del ciclo, la cantidad de iteraciones que son
necesarias. En este caso, se emplea una variable de control (contador de iteraciones) que se inicializa en
la sección de inicialización y se modifica (por ejemplo, incrementándola) en la sección de actualización.
Ejemplos:
1. Se conoce de antemano la cantidad de iteraciones:
for (i = 0 ; i < 100 ; i++)

Console.WriteLine("{0}", i);
2. Ciclo infinito:
for (;;) {
...
instrucciones
...
}
3. Programa de uso del For

using System;
class MainApp {
static void main() {
int rep;
for (rep=1;rep<=20;rep=rep+5)
// repite de 5 en 5 ascendente
Console.WriteLine("rep ascendente: {0}",rep);
for (rep=20;rep>=1;rep=rep-5)
// repite de 5 en 5 descendente
Console.WriteLine("rep descendente: {0}”,rep);
}
}
Salida del programa:

rep ascendente: 1
rep ascendente: 6
rep ascendente: 11
rep ascendente: 16
rep descendente: 20
rep descendente: 15
rep descendente: 10
rep descendente: 5

3.3.1 Ejemplo: Cálculo de x a la n (uso restringido del for)

Programa que calcula x**n (n-ésima potencia de x), empleando un ciclo for. Se implementa una función
que recibe dos argumentos, la base y el exponente, y devuelve el valor indicado. Para probar la función,
el programa solicita al usuario los valores de la base y el exponente, lleva a cabo el cálculo utilizando la
función, y finalmente devuelve el resultado por pantalla.
using System;
class Calculo {
//////////////////////////////////////////////////////////////////////////
// Función que calcula la n-ésima potencia de un número x, ambos valores
// recibidos como argumentos de entrada de tipo float. El valor de retorno
// también es float. No se controla la validez de los argumentos.
// Cálculo: x**n = x * x * ... * x (n veces)
//////////////////////////////////////////////////////////////////////////
public double potencia(double x, double n)
{
int i; // Contador del número de multiplicaciones realizadas
double pot; // Acumulador para el resultado
pot = x; // Se inicia la acumulación del resultado con x (la base)
// Ciclo que lleva a cabo el calculo: i variará de 2 a n

for (i=2; i<=n; i++)
// Se multiplica el acumulado actual una vez más por la base (x)
pot = pot * x;
// Devuelve como valor de retorno el resultado acumulado
return(pot);
}
class MainApp {
//////////////////////////////////////////////////////////////////////////
// Pide al usuario una base x y un exponente n, y calcula el valor de x**n
// (n-ésima potencia de x), devolviendo el resultado por pantalla.
//////////////////////////////////////////////////////////////////////////
static void Main() {
float xbase; // Base empleada para el cálculo, dado por el usuario
int exponente; // Exponente empleado para el cálculo, dado por el usuario
Calculo cal = new Calculo();
// Solicita y lee del usuario los valores de base y exponente

Console.Write("Ingrese el valor de x: ");
xbase = float.Parse(Console.ReadLine());
Console.Write("Ingrese el valor de n: ");
exponente = int.Parse(Console.ReadLine());
// Devuelve el resultado de x**n, llevando a cabo en forma directa el

// llamado a la función que realiza el cálculo en si. Emplea 2 decimales.
Console.WriteLine("Resultado de x**n: {0}", cal.potencia(xbase, exponente));
Console.WriteLine("Presione ENTER para terminar"); Console.ReadLine();

}
}
Ingrese el valor de x: 2
Ingrese el valor de n: 8
Resultado de x**n: 256

Ingrese el valor de x: 8
Ingrese el valor de n: 15
Resultado de x**n: 4747562057728
3.3.2 Ejemplo: Conversión a letras de cantidades numéricas (uso general del for)
Programa que convierte una cantidad numérica en su equivalente en letras, en la forma en que sería útil,
por ejemplo, para escribir un cheque. Es una versión mejorada del ejemplo de uso de switch, presentado
anteriormente, pero con menos restricciones y, en general, un mejor funcionamiento. Se permiten
cantidades de hasta 9 dígitos, aunque la ampliación a más dígitos es bastante simple.
El programa solicita al usuario la cantidad en cuestión y le devuelve el equivalente. Existen algunas
excepciones que no fueron consideradas para no complicar demasiado el ejemplo.
Se permiten cantidades de hasta 9 dígitos, aunque la ampliación a más dígitos es bastante simple. El
programa solicita al usuario la cantidad en cuestión y le devuelve el equivalente. Existen algunas
excepciones que no fueron consideradas para no complicar demasiado el ejemplo. No se mostrará el
desarrollo completo de la metodología estudiada, sino tan solo la descomposición en funciones del
problema general, el algoritmo resultante y el código equivalente en el lenguaje de programación C#.
El problema de la conversión a letras puede simplificarse si se descompone en funcionalidades más
independientes, las cuales se implementarán posteriormente como funciones en C#:
• Unidades
• Decenas
• Centenas
• Milenios (que agrupa desde los cien mil a los mil)
• Millones
Finalmente, el método que transforma el número a texto, se define como

• toString2()
/////////////////////////////////////////////////////////////////////////
//
// Curso: IIC1102 - Introducción a la Programación Orientada a Objetos
// Profesor: Rodrigo Sandoval U.
//
// Ejemplo de transformación de números a texto.
//
//////////////////////////////////////////////////////////////////////////
using System;
class Numero {
private long num;
public Numero(string numero) { this.num = int.Parse(numero); }
string Unidad(long Unidades) {

switch(Unidades) {
case 1: { return("uno" ); }
case 2: { return("dos" ); }
case 3: { return("tres" ); }

case 4: { return("cuatro" ); }
case 5: { return("cinco" ); }
case 6: { return("seis" ); }
case 7: { return("siete" ); }
case 8: { return("ocho" ); }
case 9: { return("nueve" ); }
}
return("");
}
string Decenas(long Diez, long Uni) {

switch(Diez) {
case 0: { return(""); }
case 1: { if(Uni >= 6) { return("dieci"); }
else {
switch(Uni) {
case 0: { return("diez"); }
case 1: { return("once"); }
case 2: { return("doce"); }
case 3: { return("trece"); }
case 4: { return("catorce"); }
case 5: { return("quince"); }
default: return ("");
}
}
}
case 2: { if(Uni==0) return("veinte"); else return("veinti"); }
case 3: { if(Uni==0) return("treinta"); else return("treinta y "); }
case 4: { if(Uni==0) return("cuarenta"); else return("cuarenta y "); }
case 5: { if(Uni==0) return("cincuenta");else return("cincuenta y "); }
case 6: { if(Uni==0) return("sesenta"); else return("sesenta y "); }
case 7: { if(Uni==0) return("setenta"); else return("setenta y "); }
case 8: { if(Uni==0) return("ochenta"); else return("ochenta y "); }
case 9: { if(Uni==0) return("noventa"); else return("noventa y "); }
}
return("");
}
string Centenas(long Cien, long Diez, long Uni) {

if (Cien==1 && Diez==0 && Uni==0) return("cien");
else {
switch(Cien) {
case 1: { return ("ciento" ); }
case 2: { return ("doscientos" ); }
case 3: { return ("trescientos" ); }
case 4: { return ("cuatrocientos"); }
case 5: { return ("quinientos" ); }
case 6: { return ("seiscientos" ); }
case 7: { return ("setecientos" ); }
case 8: { return ("ochocientos" ); }
case 9: { return ("novecientos" ); }
}
}
return("");
}
string Milenios(long CienMil, long DiezMil, long Mil) {

string resultado = "";
if(CienMil!=0)
resultado = resultado + Centenas (CienMil,DiezMil,Mil);
if(DiezMil!=0)
resultado = resultado + " " + Decenas (DiezMil,Mil);

if(Mil>0 && Mil!=1)

resultado = resultado + Unidad(Mil);
else if(DiezMil>1 && Mil>0) resultado = resultado + " un";
if(CienMil!=0 || DiezMil!=0 || Mil!=0)

resultado = resultado + " mil";
return (resultado);
}
string Millones(long Millon) {

switch(Millon) {
case 1: { return ("un millon" ); }
case 2: { return ("dos millones" ); }
case 3: { return ("tres millones" ); }
case 4: { return ("cuatro millones"); }
case 5: { return ("cinco millones" ); }
case 6: { return ("seis millones" ); }
case 7: { return ("siete millones" ); }
case 8: { return ("ocho millones" ); }
case 9: { return ("nueve millones" ); }
}
return ("");
}
public string toString2() {

long nUni, nDec, nCen, nMil, n10Mil, n100Mil, nMill;
nMill = num/1000000;
n100Mil = num/100000 - nMill*10;
n10Mil = num/10000 - n100Mil*10 - nMill*100;
nMil = num/1000 - n10Mil*10 - n100Mil*100 - nMill*1000;
nCen = num/100 - nMil*10 - n10Mil*100 - n100Mil*1000 - nMill*10000;
nDec = num/10 - nCen*10 - nMil*100 - n10Mil*1000 - n100Mil*10000 - nMill*100000;
nUni = num - nDec*10 - nCen*100 - nMil*1000 - n10Mil*10000
- n100Mil*100000 - nMill*1000000;
return(Millones(nMill) + " " + Milenios(n100Mil,n10Mil,nMil) + " " +

Centenas(nCen,nDec,nUni) + " " + Decenas(nDec,nUni) +
Unidad(nUni));
}
}
class MainApp {
static void Main() {

Console.Write("Ingrese un número (hasta 9.999.999): ");
Numero num = new Numero(Console.ReadLine());
Console.WriteLine("{0}", num.toString2());
Console.WriteLine("Presione ENTER para terminar ... "); Console.ReadLine();

}
}
Ingrese un Numero: 3686041
tres millones seiscientos ochenta y seis mil cuarenta y uno

Ingrese un Numero: 2568

dos mil quinientos sesenta y ocho
3.4 Instrucción foreach

La instrucción foreach repite un grupo de instrucciones definidas, para cada elemento dentro de un
arreglo o dentro de una colección de objetos. Esta instrucción se usa para iterar a través de la colección
para obtener la información requerida, pero no debe ser utilizada para cambiar los contenidos de la
colección del arreglo, ya que puede producir efectos laterales no deseados. La declaración tiene la
siguiente forma:
foreach (tipo identificador in expresión)
instrucciones
using System;
class MainClass
{
public static void Main()
{
int impares = 0, pares = 0;
int[] arr = new int [] {0,1,2,5,7,8,11};
foreach (int i in arr) {

if (i%2 == 0)
pares++;
else
impares++;
}
Console.WriteLine("Hay {0} impares y {1} pares.", impares, pares);

}
}
Más ejemplos de esta instrucción se ven en una siguiente sección, dedicada a los “Arreglos” o Arrays.
3.5 Equivalencia Lógica entre Instrucciones de Iteración

Las tres instrucciones con que cuenta el lenguaje de programación C para la especificación de iteración
son lógicamente equivalentes. Esto quiere decir que un ciclo escrito empleando una de las
instrucciones puede reescribirse empleando otra sin que hayan cambios en la ejecución del programa (su
semántica).
Para ilustrar este hecho, se muestra a continuación un ciclo escrito con la instrucción for, y la forma en
que se reescribiría empleando las otras dos instrucciones de iteración. Los bloques son secuencias de
instrucciones.
Empleando for:
for (bloque1; condición; bloque2) {
bloque3
}
// Instrucciones de bloque1 y bloque2 separadas por coma

// Instrucciones de bloque3 separadas por punto y coma

Empleando while:
bloque1
while (condición) {
bloque3
bloque2
}
// Instrucciones de los bloques separadas por punto y

coma
Empleando do-while:
bloque1
if (condición)
do {
bloque3
bloque2
} while (condición);
// Instrucciones de los bloques separadas por punto y

coma
// ¿Por qué es necesario el if?
Finalmente, se muestra otro ejemplo de la equivalencia lógica entre las instrucciones de iteración. A
continuación se presenta un ciclo escrito mediante do-while, y la forma como se reescribiría empleando
while.
Empleando do-while:
do {
bloque
} while (condición);
// Instrucciones del bloque separadas por punto y coma

Empleando while:
bloque
while (condición) {
bloque
}
// Instrucciones del bloque separadas por punto y coma

// ¿Por qué se debe repetir el bloque (afuera y adentro)?

3.5.1 Ejemplos: Programa con funciones equivalentes y Ciclos anidados

Ejemplo 1: Equivalencia de Ciclos en Función Cuadrado()
Este programa muestra la equivalencia lógica entre las funciones cuadrado, cuadrado1 y cuadrado2, para
imprimir (dibujar) en pantalla un cuadrado.
using System;
class Cuadrado {
public void cuadrado(int longitud)

{
int a,b;
for (a=1;a<=longitud;a++) { // ciclo externo
for (b=1;b<=longitud;b++) // ciclo interno
Console.Write("*");
Console.WriteLine(); // salto de línea
}
}
public void cuadrado1(int longitud)

{
int a=1,b;
while (a<=longitud) { // ciclo externo

b=1;
while (b<=longitud) { // ciclo interno
Console.Write ("*");
b++;
}
a++;
}
}
public void cuadrado2(int longitud)

{
int a,b;
a=1;
if (longitud>=1) {
do { // ciclo externo
b=1;
if (longitud>=1) {
do { // ciclo interno
Console.Write ("*");
b++;
} while (b<=longitud);
a++;
}
} while (a<=longitud);
}
}
}

class MainApp {
static void Main()

{
Cuadrado cuad = new Cuadrado();
cuad.cuadrado(5); Console.ReadLine();
cuad.cuadrado1(5); Console.ReadLine();
cuad.cuadrado2(5); Console.ReadLine();
}
}
*****
*****
*****
*****
*****
Ejemplo 2: Equivalencia de Ciclos en Series de Letras

Las funciones serie_letras1, hasta serie_letras6 son equivalentes e imprimen una serie de letras
using System;
class Letras {
public void serie_letras1(char a, char b, char c, char d)

{
int letra1,letra2;
for (letra1=a; letra1<=b; letra1++)

for (letra2=c; letra2<=d; letra2++)
Console.WriteLine("{0} {1} ",(char) letra1,(char) letra2);
}
public void serie_letras2(char a,char b, char c, char d)

{
int letra1,letra2;

}
public void serie_letras3(int a,int b, int c, int d)

{
int letra1,letra2;

Console.WriteLine("{0} {1} ", (char) letra1, (char) letra2);
}

public void serie_letras4(int a,int b, int c, int d)

{
int letra1,letra2;

}
public void serie_letras5()

{
int letra1,letra2;
for (letra1='A'; letra1<='C'; letra1++)

for (letra2=68;letra2<=69;letra2++)
}
public void serie_letras6()

{
int letra1,letra2;
letra1 = 65; // 65 ==> 'A'
while (letra1<='C') {
letra2 = 'D';
while (letra2<=69) {
letra2++;
}
letra1++;
}
}
}
class MainApp {
static void Main()

{
Letras let = new Letras();
let.serie_letras1('A','C','D','E'); Console.ReadLine();
let.serie_letras5(); Console.ReadLine();
let.serie_letras6(); Console.ReadLine();
}
}
Ejemplo de ejecución
A D
A E
B D
B E
C D

C E
3.6 Iteraciones con Anidamiento

Dentro de las instrucciones que se pueden incluir en un ciclo se encuentran a su vez, otros ciclos, es
decir, instrucciones while, do-while, y for. Este tipo de construcciones, en las que se incluye
una instrucción de repetición dentro del cuerpo de otra se conoce como iteración anidada.
En una iteración anidada, en cada iteración del ciclo exterior, se completa un grupo de iteraciones del
ciclo interior. Considere, por ejemplo, el siguiente fragmento de código:
for (i=1; i<=3; i++)

for (j=1; j<=5; j++)
Console.WriteLine("{0} {1}”, i, j);
El ciclo exterior se ejecutará 3 veces, haciendo variar la variable i por los valores 1,2,3. En cada una de
estas iteraciones se ejecutará un ciclo de 5 iteraciones (el for interior), en el que se variará la variable j
por los valores 1,2,3,4,5. De esta forma, por cada valor que toma la variable i, la variable j tomará todos
sus valores. Así, la instrucción Console.WriteLine se ejecutará 15 veces (3x5), y la salida de este
programa sería algo como:
1 1
1 2
1 3
1 4
1 5
2 1
2 2
2 3
2 4
2 5
3 1
3 2
3 3
3 4
3 5
Es posible anidar cualquier cantidad de instrucciones de iteración, prácticamente hasta que la
implementación del compilador lo soporte. Sin embargo, demasiados niveles de anidamiento pueden
volver el programa difícil de leer, por lo que se recomienda seguir reglas claras de indentación, que hagan
el código más legible.
Más adelante en la materia se muestran ejemplos en los que se emplean instrucciones de iteración
anidadas.

ALG Guia5

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ALG Guia5

Uploaded by

Copyright:

Available Formats

PONTIFICIA UNIVERSIDAD CATÓLICA DE CHILE

Capítulo V – Control de Flujo

Material preparado por Rodrigo Sandoval U en Marzo 2004,

IIC 1102 Página: 1

IIC 1102 Página: 2

if (edad > 80) {

2. int salario, credito;

if (salario > 1000000)

2.1.1 Ejemplo: ¿Qué hago el sábado por la noche? (Implementación)

IIC 1102 Página: 3

public static void Main() {

Console.WriteLine("Veamos qué hacer el sábado por la noche... ");

Console.Write("Desea quedarse en casa? (s/n): ");

IIC 1102 Página: 4

Veamos que hacer el sábado por la noche...

IIC 1102 Página: 5

2.2 Instrucción switch

IIC 1102 Página: 6

2.2.1 Ejemplo: Conversión a letras de una cantidad de dos dígitos

Console.Write("Ingrese un numero entero entre 0 y 99: ");

decenas = cantidad / 10;

IIC 1102 Página: 7

case 4: {Console.Write("Catorce “); break;}

if(unidades>0 && decenas>2) Console.Write(" y ");

Ingrese un numero entero entre 0 y 99: 32

IIC 1102 Página: 8

3.1.1 Ejemplo: Tabla de conversión de temperaturas (Fahrenheit-Celsius)

IIC 1102 Página: 9

// Función que recibe una temperatura expresada en grados Celsius y retorna

static void Main () {

// Imprime el encabezado de la tabla con un formato que le da buena apariencia

// Ciclo que genera la tabla. La variable centígrados vale inicialmente -15, y

// Incrementa centigrados para la siguiente iteración

3.1.2 Ejemplo: Esperando el Año Nuevo

IIC 1102 Página: 10

private int agno;

// Constructor de la clase. Inicializa el valor del año

static void Main()

Console.WriteLine("Ingrese la fecha actual.");

Agno year = new Agno(a); // Se inicializa la instancia de año

// Este ciclo simula la ocurrencia de un segundo en cada iteración. La variable

while (d!=1 || m!=1) { // Día=1 y Mes=1 -> ¡1º enero!

IIC 1102 Página: 11

// Verifica si hay cambio de mes, considerando las excepciones:

Console.WriteLine("Feliz año {0,4} !!!", a);

3.2 Instrucción do-while

IIC 1102 Página: 12

Programas de ejemplo: Ver ejemplos en capítulo de Algoritmos Numéricos

3.3 Instrucción for

for ( inicialización ; expresión-booleana ; actualización

IIC 1102 Página: 13

for (i = 0 ; i < 100 ; i++)

3. Programa de uso del For

Salida del programa:

IIC 1102 Página: 14

3.3.1 Ejemplo: Cálculo de x a la n (uso restringido del for)

// Ciclo que lleva a cabo el calculo: i variará de 2 a n

// Solicita y lee del usuario los valores de base y exponente

// Devuelve el resultado de x**n, llevando a cabo en forma directa el

Console.WriteLine("Presione ENTER para terminar"); Console.ReadLine();

IIC 1102 Página: 15

Finalmente, el método que transforma el número a texto, se define como

private long num;