Escolar Documentos
Profissional Documentos
Cultura Documentos
ESCUELA DE INGENIERÍA
DEPARTAMENTO DE CIENCIA DE LA COMPUTACIÓN
IIC 1102 INTRODUCCIÓN A LA PROGRAMACIÓN
Profesor: Rodrigo Sandoval U.
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
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
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 {
...
Bloque de instrucciones 2
...
}
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.
• 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;
using System;
class MainApp {
if (respuesta=="s") {
Console.Write ("Le gusta ver TV? (s/n): ");
respuesta = Console.ReadLine();
if (respuesta=="s") {
Console.Write("Hay algún programa bueno esta noche? (s/n): ");
respuesta = Console.ReadLine();
if (respuesta=="s")
Console.WriteLine("Sugerencia: Coma cabritas y vea el programa de hoy");
else
Console.WriteLine("Sugerencia: Arriende una pelicula");
}
else {
Console.Write("Le gusta leer? (s/n): ");
respuesta = Console.ReadLine();
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): ");
respuesta = Console.ReadLine();
if (respuesta=="s") {
Console.Write("Le gusta la música tropical? (s/n): ");
respuesta = Console.ReadLine();
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): ");
respuesta = Console.ReadLine();
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
• 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”);
}
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
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;}
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();
}
}
Ejemplo de ejecución:
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 ) {
...
Bloque de instrucciones
...
}
Los bloques de instrucciones consisten en una secuencia de instrucciones terminadas en punto y coma.
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++;
}
using System;
class Temperatura {
class MainApp {
Ejemplo de ejecución:
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
que completó). En esta simulación se toman las medidas pertinentes para detectar y tratar en forma
especial los años bisiestos.
Ejemplo de ejecución:
using System;
class Agno {
//////////////////////////////////////////////////////////////////////////////
// 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 {
if (hh==24) {
hh = 0; d++;
do {
...
Bloque de instrucciones
...
} while ( expresión-lógica );
Los bloques de instrucciones consisten en una secuencia de instrucciones terminadas en punto y coma.
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
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. do {
// Esto se ejecuta en cada iteración del ciclo
...
Console.Write ("Desea continuar? (s/n): ");
respuesta = Console.ReadLine();
} while (respuesta != “n”);
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
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.
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:
2. Ciclo infinito:
for (;;) {
...
instrucciones
...
}
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);
}
}
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)
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();
Ejemplo de ejecución:
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
/////////////////////////////////////////////////////////////////////////
//
// 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 {
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("");
}
if(DiezMil!=0)
resultado = resultado + " " + Decenas (DiezMil,Mil);
return (resultado);
}
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;
class MainApp {
Console.WriteLine("{0}", num.toString2());
Ejemplo de ejecución:
Ingrese un Numero: 3686041
tres millones seiscientos ochenta y seis mil cuarenta y uno
using System;
class MainClass
{
public static void Main()
{
int impares = 0, pares = 0;
int[] arr = new int [] {0,1,2,5,7,8,11};
Más ejemplos de esta instrucción se ven en una siguiente sección, dedicada a los “Arreglos” o Arrays.
Empleando while:
bloque1
while (condición) {
bloque3
bloque2
}
Empleando do-while:
bloque1
if (condición)
do {
bloque3
bloque2
} while (condición);
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);
using System;
class Cuadrado {
if (longitud>=1) {
do { // ciclo externo
b=1;
if (longitud>=1) {
do { // ciclo interno
Console.Write ("*");
b++;
} while (b<=longitud);
Console.WriteLine(); // salto de línea
a++;
}
} while (a<=longitud);
}
}
}
class MainApp {
cuad.cuadrado(5); Console.ReadLine();
cuad.cuadrado1(5); Console.ReadLine();
cuad.cuadrado2(5); Console.ReadLine();
}
}
Ejemplo de ejecución:
*****
*****
*****
*****
*****
class Letras {
while (letra1<='C') {
letra2 = 'D';
while (letra2<=69) {
Console.WriteLine("{0} {1} ",(char) letra1,(char) letra2);
letra2++;
}
letra1++;
}
}
}
class MainApp {
let.serie_letras1('A','C','D','E'); Console.ReadLine();
let.serie_letras2('A','C','D','E'); Console.ReadLine();
let.serie_letras3('A','C','D','E'); Console.ReadLine();
let.serie_letras4('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
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.