1. No category

Programación I, Guía 5
1
Facultad: Ingeniería
Escuela: Ingeniería en Computación
Asignatura: Programación I
Tema: “Estructuras de Repetición en C#”.
Objetivos


Utilizar las estructuras de repetición para ejecutar instrucciones repetidas en una aplicación.
Solucionar problemas con programas que integren la estructura de selección y estructuras repetitivas for.
Introducción
Los bucles o ciclos repiten una sentencia o una secuencia de sentencias un número de veces. A dichas sentencias se
les conoce como cuerpo del bucle. A cada repetición del bucle se le llama iteración.
El bucle for
Ejecuta una sentencia o conjunto de sentencias un número finito de veces.
En inicialización se escribe una variable de control de bucle (la cual actúa como un contador), con su valor inicial. La
condición iteración contiene una expresión lógica que hace que el bucle realice las iteraciones de las sentencias
mientras sea verdadera. Finalmente, en incremento se modifica la variable de control.
for(inicialización; condición_iteración; incremento_o_decremento)
{
Sentencia 1...;
Sentencia 2…;
….
Sentencia n;
}
El bucle while
Repite la ejecución de una sentencia o de un grupo de sentencias mientras la condición que se evalúa (al principio del
bucle) sea verdadera.
while(condición_de_bucle)
{
Sentencias;
}
Programación I, Guía 5
2
El bucle do while
Repite le ejecución de una sentencia o de un grupo de sentencias mientras se cumpla la condición especificada (al
menos una vez). La condición del do while evalúa al final del bucle.
 Contadores: un contador es una variable casi siempre de tipo entero cuyo valor se incrementa o decrementa en
cada repetición del bucle. Es habitual llamar a esta variable “cont” (contador) o “i” (índice);
El contador suele utilizarse de este modo:
1. Se inicializa antes de que comience el bucle. Es decir, se le da un valor inicialPor ejemplo: cont = 1
2. Se modifica dentro del cuerpo del bucle. Lo más habitual es que se incremente su valor en una unidad:
Por ejemplo: cont = cont + 1;
Esto quiere decir que el valor de la variable cont se incrementa en una unidad y es asignado de nuevo a la
variable contador. Es decir, si cont valía 1 antes de esta instrucción, cont valdrá 2 después. Otra forma típica
del contador es: cont = cont – 1.
Formas de incrementar los contadores:
Primera Forma
cont = cont + 1
Segunda Forma
cont++
Tercera Forma
cont += 1
 Acumuladores: Las variables acumuladores tienen la misión de almacenar los resultados sucesivos, es decir, de
acumular resultados.
Las variables acumuladores también deben ser inicializadas. Si llamamos “acum” a un acumulador, escribiremos
antes de iniciar el bucle algo como esto: acum = 0.
Por supuesto, el valor inicial puede cambiar, dependiendo de la naturaleza del problema. Más tarde, en el cuerpo
del bucle, la forma en la que solemos encontrarla es:
acum = acum + N; otra manera de escribir esta sentencia sería: acum += N.
Material y Equipo



Guía de laboratorio No. 5.
Computadora con Visual Studio 2013 o superior.
Dispositivo de almacenamiento (USB).
Procedimiento
Realice los siguientes programas:
G5_Ejemplo_1:
Realizar un programa que sea capaz de leer 5 números y mostrar el cubo de cada uno de ellos.
Hacer uso de una estructura for.
Programación I. Guía 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace G5_Ejemplo_1
{
class Program
{
static void Main(string[] args)
{
Console.Title = "Utilizando la estructura FOR";
Double cubo;
int cantidad;
int i;
Console.WriteLine("Calculo de Cubos");
for (i = 0; i < 5; i++)
{
Console.WriteLine("Escriba un numero entero: ");
cantidad = int.Parse(Console.ReadLine());
cubo = Math.Pow(cantidad,3);
Console.WriteLine("El cubo de la cantidad es: " + cubo);
}
Console.WriteLine("Saliendo del programa...");
Console.ReadKey();
}
}
}
Corrida del ejercicio:
3
4
Programación I, Guía 5
G5_Ejemplo_2
Escriba un programa que lea 5 números desde teclado y presente la sumatoria de los mismos. Hacer uso de la
estructura repetitiva while.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace G5_Ejemplo_2
{
class Program
{
static void Main(string[] args)
{
Console.Title = "Utilizando la estructura WHILE";
int contador = 1;
Double suma = 0;
int N;
Double prom;
while (contador <= 5)
{
Console.WriteLine("Ingrese un numero entero:[{0}] " , contador);
N = int.Parse(Console.ReadLine());
suma = suma + N;
contador = contador + 1;
}
Console.WriteLine("La suma de los 5 numeros ingresados es: " + suma);
prom = suma / 5;
Console.WriteLine("El promedio de los numeros ingresados es: " + Math.Round(prom,3));
Console.ReadKey();
}
}
}
Corrida del ejercicio:
Programación I. Guía 4
5
G5_Ejemplo_3: Programa que combina uso de for y do while.
Esta aplicación captura desde teclado los datos de uno o varios empleados y calcula el total invertido en sueldos.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace G5_Ejemplo_3
{
class Program
{
static void Main(string[] args)
{
Console.Title = "Utilizando la estructura DO WHILE";
int op, i, cantidad;
String nombre, ocupacion;
Double sueldo;
Double total = 0;
do
{
Console.Clear();
Console.WriteLine("Cuantos empleados va a registrar?");
cantidad = int.Parse(Console.ReadLine());
for (i=1; i<=cantidad; i=i+1)
{
Console.WriteLine("Ingrese el nombre del empleado[{0}]: ", i);
nombre = Console.ReadLine();
Console.WriteLine("Ingrese la ocupacion del empleado: ");
ocupacion = Console.ReadLine();
Console.WriteLine("Ingrese el sueldo: ");
sueldo = Double.Parse(Console.ReadLine());
total = total + sueldo;
}
Console.WriteLine("\tEl total de dinero invertido en sueldos es:$ " + total);
Console.WriteLine("\tSi desea continuar, presione 1 sino presione 0");
op = int.Parse(Console.ReadLine());
} while (op == 1);
Console.ReadKey();
}
}
}
Anotaciones
6
Programación I, Guía 5
Corrida del ejercicio:
G5_Ejemplo_4: Ejecute el siguiente código de programa en su cuaderno y escriba la salida en el cuadro que está
debajo del código.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace G5_Ejemplo_4
{
class Program
{
static void Main(string[] args)
{
Console.Title = "Programa extra del ciclo FOR";
int x, y;
Console.WriteLine("Programa que imprime una secuencia de numeros");
Console.WriteLine("\n");
for (x=1; x<10; x=x+2)
{
y=x+5;
Console.Write(x + "," + y +",");
}
Console.ReadKey();
}
}
}
Programación I. Guía 4
7
G5_Ejemplo_extra: El Estadio el Manguito es uno de los estadios más importantes de Soyapango. Este estadio tiene
diversos sectores. El costo de la entrada a los partidos del estadio se asigna en virtud de los sectores del estadio
mediante la siguiente tabla:
Sector
Costo de la entrada
Sol Candente
$3
Sol Luminoso
$5
Sombrita
$8
Tribunita
$ 15
Silla Plástica
$ 20
Se pide desarrollar un programa que permita seleccionar un sector del estadio, ingresar la cantidad de entradas
solicitadas y calcular el total a pagar por las entradas,
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace G5_Ejemplo_extra
{
class Program
{
static void Main(string[] args)
{
Console.Title = "Programa de entradas del Manguito";
int cantidad = 0;
String op;
Double precio = 0, total = 0;
Console.WriteLine("Hey que ondas aqui estas en el estadio El Manguito");
Console.WriteLine("Ingresa la cantidad de entradas requeridas: ");
cantidad = int.Parse(Console.ReadLine());
Console.Clear();
if (cantidad < 1)
{
Console.WriteLine("\t ERROR: La cantidad de entradas debe ser mayor que 1");
Console.ReadKey();
Environment.Exit(0);
}
Console.Clear();
Console.WriteLine("\t**********************************************************");
Console.WriteLine("\t*
BIENVENIDO AL ESTADIO EL MANGUITO
*");
Console.WriteLine("\t**********************************************************");
Console.WriteLine("\t*
*");
Console.WriteLine("\t*
SECTORES DEL ESTADIO
*");
Console.WriteLine("\t*
A- SOL CANDENTE
*");
Console.WriteLine("\t*
B- SOL LUMINOSO
*");
Console.WriteLine("\t*
C- SOMBRITA
*");
Console.WriteLine("\t*
D- TRIBUNITA
*");
Console.WriteLine("\t*
E- SILLA PLASTICA
*");
Console.WriteLine("\t*
*");
Console.WriteLine("\t**********************************************************");
Programación I, Guía 5
8
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
Console.WriteLine("");
Console.WriteLine("SELECCIONA LA LETRA CORREPONDIENTE AL SECTOR DEL ESTADIO: ");
op = Console.ReadLine();
switch(op)
{
case "A": case "a":
Console.WriteLine("\t Sector seleccionado: Sol Candente");
precio = 3;
break;
case "B": case "b":
Console.WriteLine("\t Sector seleccionado: Sol Luminoso");
precio = 5;
break;
case "C": case "c":
Console.WriteLine("\t Sector seleccionado: Sombrita");
precio = 8;
break;
case "D": case "d":
Console.WriteLine("\t Sector seleccionado: Tribunita");
precio = 15;
break;
case "E": case "e":
Console.WriteLine("\t Sector seleccionado: Silla Plastica");
precio = 20;
break;
default:
Console.WriteLine("\t ERROR: El sector seleccionado no existe");
Console.ReadKey();
Environment.Exit(0);
break;
}
total = precio * cantidad;
Console.WriteLine("\t Precio Unitario: $" + precio);
Console.WriteLine("\t Cantidad de entradas: " + cantidad);
Console.WriteLine("\t Total a pagar: $" + total);
Console.WriteLine("\t Gracias por visitar el Manguito!");
Console.ReadKey();
}
}
}
Programación I. Guía 4
9
NOTA: Después de haber utilizado este sistema de entradas, se le contrata a su persona para que posea una opción
de SALIR, sin olvidar que, utilizando alguna estructura repetitiva se pueda obtener que el menú de opciones siempre
se encuentre activo hasta que el usuario decida salir del programa.
Análisis de Resultados
1. Desarrolle un programa que presente el siguiente menú:
a) Elevar a potencia.
b) Extraer Raíz cuadrada.
c) Verificar si un número es par o impar.
d) Salir del programa.
Consideraciones:
 El menú tiene que estar activo hasta que el usuario decida salir del programa.
 Cada vez que se seleccione una opción deberá realizar una limpieza de pantalla para más orden en la
aplicación.
 Se recomienda la utilización del switch case y la estructura repetitiva do while.
2. Desarrollar un programa que capture un número desde teclado e imprima su tabla de multiplicar.
3. Desarrollar un programa que permita imprimir en pantalla los números del 1 al 50, excepto el 25.
Investigación Complementaria
1. Desarrollar un programa, que dados como datos 25 números enteros, obtenga la suma de los números impares y
el promedio de los números pares.
2. En una empresa de computadoras, los salarios de los empleados se van a aumentar según el contrato actual:
Contrato
Aumento %
$ 0.0 - $9,000.00
20
$9,001 – $15,000
10
$15,001 – $20,000
5
Más de $20,000
0
Bibliografía

Deitel, Harvey M. y Paul J. Deitel, Cómo Programar en C#, Segunda Edición, México, 2007.