Unidad V - Ciclos - V3

UNIVERSIDAD DE EL SALVADOR
FACULTAD DE INGENIERÍA Y ARQUITECTURA

ESCUELA DE INGENIERÍA DE SISTEMAS INFORMÁTICOS
INTRODUCCIÓN A LA INFORMÁTICA
GUION DE CLASE Nº 5
UNIDAD V LB
ESTRUCTURAS REPETITIVAS
Contenido
1. GENERALIDADES - ESTRUCTURAS REPETITIVAS ................................................................................................................................................... 2
2. TERMINOLOGÍA BÁSICA .......................................................................................................................................................................................... 2
3. ESTRUCTURA DE ENTRADA CONDICIONADA - ESTRUCTURA MIENTRAS .............................................................................................................. 4
4. VALIDACIÓN DE DATOS CON CICLO MIENTRAS ................................................................................................................................................... 10
5. OPERADORES ADICIONALES DEL LENGUAJE C# ................................................................................................................................................. 12
6. ESTRUCTURA CONTROLADA POR UN CONTADOR – ESTRUCTURA DESDE_HASTA ............................................................................................ 30
7. ESTRUCTURA DE ENTRADA ASEGURADA – ESTRUCTURA HASTA_QUE ............................................................................................................. 38
8. ESTRUCTURA PARA CADA ELEMENTO - ESTRUCTURA DERIVADA ...................................................................................................................... 42
9. CICLOS ANIDADOS ................................................................................................................................................................................................ 43
10. TECNICA DE CICLO CONTROLADO POR BANDERA .............................................................................................................................................. 43
11. TECNICA DE CICLO CONTROLADO POR CENTINELA ............................................................................................................................................ 51
12. TECNICA PARA DETERMINAR EL VALOR MENOR/MAYOR Y DATOS ASOCIADOS ................................................................................................ 57
13. ANEXOS ................................................................................................................................................................................................................ 58
Objetivo: Aprender a utilizar las estructuras repetitivas fundamental y derivadas en el diseño y codificación de soluciones.
INTRODUCCIÓN
En nuestra vida cotidiana nosotros podemos realizar tareas o acciones más de una vez, por ejemplo para ustedes es casi
obligatorio venir a clase todos los días, para nosotros los docentes es obligatorio venir a trabajar todos los días; así también
todos los días nos bañamos, comemos, dormimos, etc. Hay otras tareas que no son tan frecuentes pero que también se repiten:
estudiar (solo estudiamos unos 2 o 3 días antes de la evaluación), ir al cine (solo cuando tenemos plata, tiempo y exhiben la
película que nos interesa).
Realizar algunas actividades muchas veces depende de alguna condición que se nos imponga: por ejemplo: compilamos un
programa las veces que sea necesario hasta que no tenga errores; es decir, mientras tenga errores no dejamos de compilarlo.
Recordemos que para cualquier diseño de solución y su respectiva codificación disponemos únicamente de tres estructuras de
control que son: las secuenciales, las selectivas y las repetitivas; y que no importa que tan compleja sea la solución que se
necesita, dichas estructuras son suficientes para diseñarla y codificarla. Ya hemos estudiado las estructuras secuenciales y las
estructuras selectivas por lo que en esta unidad se debe hacer uso de las estructuras secuenciales y selectivas según
corresponda en combinación con las estructuras repetitivas, a fin de obtener una solución adecuada al problema planteado.
Las estructuras repetitivas son aplicables a problemas para los cuales el diseño de la solución requiere la repetición de una o
más acciones, para llevar a cabo el objetivo de la misma, dicho sea de paso las computadoras están especialmente diseñadas
para ejecutar tareas que se repiten y hacerlo con la mayor eficiencia.
En esta unidad iniciaremos estudiaremos las generalidades sobre el tema; comenzando con la terminología (conceptos básicos
que nos ayudarán a comprender mejor el uso de los ciclos), luego operadores en lenguaje C# (especialmente para uso en
ciclos) y la clasificación de las estructuras repetitivas. Otro punto importante que estudiaremos es la estructura o ciclo mientras y
sus aplicaciones en la solución de problemas como es el caso de validaciones, conteos, cálculo de sumas y promedios, entre
otros así como las distintas aplicaciones de variables de control de ciclo. Por ultimo aprenderemos ciclos derivados como el
desde hasta y hasta que con las formas en que podemos aplicarlos principalmente en cálculos de sumas y promedios, junto con
técnicas de variables de control y técnica para determinar el valor menor/mayor y datos asociados.
Página 1 de 73
1. GENERALIDADES - ESTRUCTURAS REPETITIVAS
Para repetir varias veces un proceso determinado haremos uso de los ciclos repetitivos, a los cuales se les conoce también
con el nombre de Estructuras Repetitivas, Estructuras Iterativas, Lazos, Bucles, Loops o simplemente ciclos al conjunto
de bloques y flechas que nos permite, representar en un flujograma que, una acción (o varias) se puede realizar una o
varias veces (en algunos casos especiales ninguna vez) de acuerdo a una condición. Al igual que las estructuras
secuenciales y las selectivas, estas estructuras tienen únicamente una flecha de entrada y una sola flecha de salida
dentro de un flujograma.
2. TERMINOLOGÍA BÁSICA
Para trabajar con estructuras repetitivas se hace necesario conocer ciertos conceptos, previo al estudio de cada estructura,
ya que nos servirán para comprender mejor el funcionamiento de cada una de ellas.
Estructuras de Control Repetitivas: En un programa son aquellas estructuras en las que una sentencia o grupo de
sentencias se pueden repetir una o varias veces (en algunos casos especiales ninguna vez) mientras o hasta que una
condición especifica se cumpla.
Las estructuras repetitivas las clasificamos en fundamental y derivadas como se describe a continuación:
a) Estructura Fundamental
 Entrada Condicionada o estructura Mientras, se repite mientras la condición se cumpla.
b) Estructuras Derivadas
 Ciclo controlado por contador o estructura Desde_hasta, se repite desde un valor inicial hasta un valor final.
 Ciclo Para_cada_uno es una variante del Desde_hasta pensada especialmente para compactar la escritura de códigos
donde se realice algún tratamiento a todos los elementos de una colección, muy habitual en los lenguajes C#. Lo veremos en
detalle cuando estemos trabajando con Colecciones de datos en la siguiente Unidad.
 Entrada asegurada o estructura Hasta_que, se repite al menos una vez antes que se evalúa la condición y se repite mientras
la condición se cumpla.
Para representar gráficamente una estructura repetitiva, haremos uso de los siguientes símbolos o bloques.
Cuerpo del Ciclo: Está formado por la acción o conjunto de acciones que se repite en un bucle y puede estar formado por una o
más estructuras lógicas de control:
 Secuenciales (entrada de datos, asignación/proceso, salida de datos)
 Selectivas (simple, doble, anidada, múltiple)
 Repetitivas (entrada condicionada, entrada asegurada, controlada por contador)
 Combinación de las anteriores.
Iteración: A la ejecución del cuerpo del ciclo se le conoce como iteración; dicho de otra forma, una iteración es cada una de las
ejecuciones, es decir, cada una de las veces que se repite el cuerpo del ciclo. Si el cuerpo del ciclo o acción a repetir, se realiza 5
veces, se dice que se ejecutan 5 iteraciones.
Página 2 de 73
Representación General de Estructuras Iterativas
Variable de control del ciclo: es una variable que permite controlar las veces que se ejecuta un ciclo. La variable de control puede
ser: bandera, centinela o contador. Cabe aclarar que un ciclo podría estar controlado por más de una variable. A continuación se
define cada una de las variables de control:
a. Bandera: es una variable de entrada y una variable de control de ciclo (con una sola función: continuar o detener un ciclo), y
solamente puede almacenar uno de dos valores, normalmente cero (0) o uno (1), debemos recordar que cero es el valor
numérico para falso y uno se considera el valor numérico para cierto.
Se puede hacer uso de números o letras; pero en todo caso solo existirán dos valores posibles. En el caso de usar letras se
escoge dos letras una de ellas indica cierto y la otra falso, por ejemplo 's' y 'n', una es sí (cierto) y la otra es no (falso). Se usa
con el ciclo mientras o con el ciclo hasta que.
b. Centinela: es una variable de entrada y una variable de control de ciclo (con doble función la primera recibir los datos a
procesar y la segunda función de: continuar o detener un ciclo). Una variable centinela se escoge de entre las variables de
entrada de la solución (variables tipo entero, tipo real o tipo alfanumérico de un carácter)
La variable centinela al igual que la variable de control bandera se usará cuando la cantidad de veces que debe repetirse el
ciclo es desconocida. Se usa con el ciclo mientras o con el ciclo hasta que.
c. Contador: Es una variable que controla el número de veces que se repite un ciclo y/o el número de ocurrencias de un
evento, situación o valor determinado (tiene una doble función controlar el ciclo repetitivo y contar; pero puede ser usada
únicamente para contar).Para definir correctamente una variable contador, se debe de indicar lo siguiente:
Valor inicial: representa el número a partir del cual se empieza a contar.
Valor final: representa el número hasta el que se va a contar.
Valor de cambio: Indica de cuanto en cuanto se realiza la cuenta (siempre es el mismo valor, es decir, es constante).
La forma más común de contar es de uno en uno, sobre todo si lo que se desea es saber cuántas veces se repite una acción
determinada, pero no es la única forma de contar, se puede hacer también contar de dos en dos ó de cinco en cinco ó de 100
en 100, es más también podemos contar con fracciones de 0.5 en 0.5 o de 0.01 en 0.01. Estas formas de contar se conocen
como progresivas, y el valor de cambio de la variable que controla estas cuentas siempre es positivo y se le llama
incremento, el valor inicial siempre debe de ser menor que el valor final para que la acción se pueda ejecutar.
Existen también conteos regresivos, en estas formas de contar el valor de cambio es negativo y el valor inicial es siempre
mayor que el valor final de la variable contador; así podemos contar desde 5 hasta 1 por ejemplo, el valor de cambio es -1. Es
importante recordar que independientemente del valor de cambio (positivo o negativo) de un contador, éste siempre es
constante. Como ejemplo podemos mencionar que para leer un grupo de 5 edades, se puede definir una variable contador
numEd. Dicha variable numEd, tendrá un valor inicial de 1, un valor final de 5 y un valor de cambio 1.
La variable contador se usará cuando la cantidad de veces que debe repetirse el ciclo es conocida o se puede preguntar las
veces que debe repetirse, en cuyo caso la cantidad de repeticiones es una variable de entrada más a considerar. La
variable contador se puede usar con ciclos mientras, hacer hasta que y hacer desde hasta.
Acumulador: Es una variable que “almacena” el resultado final de sumar todos los distintos valores que toma una variable, para
definirla, también es necesario indicar:
Página 3 de 73
 Valor inicial: Representa el valor original o inicial del acumulador, por lo general cero
 Valor final: El último valor que toma el acumulador, desconocido por lo general.
 Valor de cambio: Representa cada valor de la variable que se va sumando o acumulando.
Por ejemplo para calcular el monto total a desembolsar para pagar la planilla de 20 empleados, tendríamos que sumar todos los
salarios de los empleados. Podemos hacer uso de una variable suma; para la cual definimos un valor inicial de 0.0 y un valor de
cambio que es el valor de la variable salario (contiene el salario del enésimo trabajador); el valor final es lo que pretendemos
encontrar, no está definido de antemano.
El acumulador no lo utilizaremos para controlar ciclos pero es aplicable su uso en cualquiera tipo de ciclos, con cualquier variable de
control de ciclo.
3. ESTRUCTURA DE ENTRADA CONDICIONADA - ESTRUCTURA MIENTRAS
A la Estructura MIENTRAS también se le llama estructura de entrada condicionada, debemos mencionar que ésta es la
primera estructura usada para repetir porciones de un algoritmo a conveniencia, por lo tanto se le distingue como
Estructura Fundamental; de esta estructura, se diseñaron otras 3 estructuras, que se conocen como Derivadas. (Hacer
desde hasta, hacer hasta que, y una última conocida como para cada elemento)
Funcionamiento de la Estructura Mientras

Esta estructura, nos permite realizar el cuerpo del ciclo las veces que sea necesario, siempre y cuando (o Mientras) se cumpla la
condición. Al entrar a la estructura se evalúa la condición, si el resultado es falso, el cuerpo del ciclo no se ejecuta, si al contrario la
condición resulta cierta, se realiza el cuerpo del ciclo. Una vez finalizada la ejecución del cuerpo del ciclo se regresa a evaluar la
condición de nuevo. De tal forma que el cuerpo del ciclo puede ser que se ejecute: ninguna vez, una vez o varias veces, dependiendo
del resultado de la condición, por esta razón, a estos ciclos
se les denomina ciclos con entrada condicionada, se
entra al cuerpo del ciclo si la condición se cumple.
Dentro del cuerpo del ciclo debe existir alguna

estructura que modifique el resultado lógico (de
verdadero a falso) de la condición; si esto no sucediera,
la estructura repetitiva se quedaría ejecutando el cuerpo del
ciclo indefinidamente, ya que para salir de la estructura la
condición debe dar como resultado falso, en este caso el
ciclo se denomina bucle infinito (ciclo o lazo infinito) o sin
fin (situación que DEBE evitarse).
Representación Gráfica – Diseño de la Solución

Para representar gráficamente una estructura MIENTRAS, vamos a utilizar el símbolo especial que se mostró en la figura anterior,
aunque también se puede utilizar el rombo, como se muestra a continuación:
Página 4 de 73
EJEMPLO
n=0
n != 5
Nótese que lo que está dentro de las líneas punteadas es la Estructura
Repetitiva (gráfico de la derecha), los caminos o rutas que salen del
"Adivine el rombo nunca se unen, como sucede en la Estructura Selectiva.
número:"
En este ejercicio se repite el cuerpo del ciclo cuando el usuario ingresa
el valor de 5, y como resultado se imprime "Felicidades Adivino"
n
"Felicidades Adivinó!!!"
La estructura algorítmica mientras es la estructura adecuada para utilizar en un ciclo cuando no sabemos el número de veces que éste
se ha de repetir. Dicho número depende de las proposiciones dentro del ciclo. Ejemplos en la vida cotidiana encontramos muchos. Por
ejemplo, supongamos que tenemos que obtener el total de una serie de gastos, pero no sabemos exactamente cuántos son; o cuando
tenemos que sacar el promedio de calificaciones de un examen, pero no sabemos precisamente cuántos alumnos lo aplicaron.
Tenemos que sumar las calificaciones e ir contando el número de alumnos, esto con el fin de poder obtener posteriormente el
promedio. El ciclo se repite mientras tengamos calificaciones de alumnos.
Representación en Pseudo-Código – Diseño de la Solución

Para expresar una estructura MIENTRAS en pseudo-código vamos a utilizar la siguiente simbología. Debe tenerse muy claro que el
uso de ciclos implica la posible realización de acciones previas y acciones posteriores al ciclo, según corresponda al diseño de la
solución. … Ejemplo
//Acciones Previas …
Hacer cont = Proposición Inicial n=0
Mientras cont es verdadero repetir Mientras (n!=5) repetir
{ Repetir el Cuerpo del Ciclo} Escribir "Adivine el número:"
Hacer cont = Modificación de cont Leer n
{ Fin del Ciclo } { Fin del Ciclo }
//Acciones Posteriores Escribir "Felicidades Adivinó!!!"
… …
Reglas de Funcionamiento
Las siguientes normas o reglas deben de cumplirse, cuando utilicemos una estructura MIENTRAS:
1. La condición (expresión lógica) es lo primero que se evalúa al llegar a la estructura; cuando el resultado el resultado es
“Verdadero”, se ejecuta el cuerpo del ciclo (y se regresa a evaluarla la condición), cuando el resultado es “Falso” se sigue la
flecha de salida de la estructura.
2. Cuando la condición se evalúa a “Falso”, al entrar a la estructura por primera vez, el cuerpo del bucle no se ejecutará nunca. En
este caso se dice que el bucle se ha ejecutado cero veces.
3. Mientras la condición dé como resultado “Verdadera” el cuerpo del ciclo se va a continuar ejecutando.
4. La única forma de salir del ciclo MIENTRAS, es obteniendo un resultado de falso en la expresión lógica.
Página 5 de 73
Codificación de la Estructura Mientras en C#
La estructura iterativa de entrada condicionada necesita solamente la palabra reservada while, que justamente en español significa
mientras, los paréntesis ( ) para encerrar la condición y las { } para delimitar el cuerpo del ciclo:
Sintaxis
. . . Ejemplo
//Acciones previas . . .
cont = Proposición Inicial // cont=Vi; //Acciones previas
while(condición) // cont<=Vf;
x = 100;
{
//Cuerpo del Ciclo while ( x <= 500)
//Acción1 {
//AcciónN Console.Write("\n {0}", x);
//cont = Modificación de cont cont++ x = x + 50;
} }
//Acciones Posteriores //Acciones Posteriores
. . . . . .
…
Otro Ejemplo
. . .
//Acciones previas
n=0;
while(n !=5)
{
Console.Write("Adivine el numero:");
n = Console.ReadLine();
}
Console.Write("Felicidades Adivinó!!!");
//Acciones posteriores
. . .
Es de aclarar que si el cuerpo del ciclo está formado por solo una acción no se coloca las llaves; solo en el caso que sean dos o más
acciones, se colocarán las llaves. Observe también que la línea donde va el while no lleva. Además Un bucle while se puede terminar
cuando una instrucción break, goto, return o throw transfiere el control fuera del bucle. Para pasar el control a la siguiente iteración sin
salir del bucle, use la instrucción continue. Para uso académico de la asignatura no se aplicará ninguno de estos últimos.
Para el siguiente ejercicio se considera solamente los conceptos adquiridos hasta el momento con las estructuras selectivas y las
nociones de las estructuras repetitivas mientras. Se hará uso de la estructura selectiva para validar el dato de entrada, dado que
hasta el momento no hemos implementado la estructura mientras con este fin, lo solucionaremos de esta forma en el primer ejercicio.
En este caso la estructura repetitiva mientas la utilizaremos para dejar de repetir el cuerpo del ciclo.
Ejemplo No. 1: En la primera parte aplique la metodología para resolver problema sin módulos, con el fin de conocer la estructura
mientras. Luego aplique la metodología modular para el siguiente:
Enunciado: Diseñe un flujograma que Imprima los n primeros números enteros positivos.
I. Planteamiento del problema.
Página 6 de 73
II. Análisis del Problema.
a. Variables de Salida:
Nombre Tipo Descripción
num Entero Representa cada uno de los números a imprimir
b. Datos de Entrada
Variables:
cantNum entero Almacena la cantidad de números a imprimir
Constantes: No son necesarias.
c. Restricciones: cantNum >0

d. Procesos: Lo que haremos es leer la cantidad de números que vamos a imprimir y verificar que cumpla la restricción; luego
iniciar con num=1; imprimirlo y aumentarle 1, mientras num sea menor o igual que cantNum.
Leer cantNum
¿ cantNum >0?
Si: Inicialmente num=1
Mientras num <= cantNum
Imprimir num
num= num + 1
NO: Imprimir “Error en datos”
e. Variables de Proceso: No se ha utilizado.
III. Diseño de la solución.

Pseudocódigo (Flujograma ver ANEXO 1-A)
{El programa, imprime los n primeros números enteros positivos}
{num y cantNum son variables de tipo entero, y deben ser positivo, num representa cada uno de los números a imprimir,
cantNum almacena la cantidad de números a imprimir}
1. Escribir “Cuantos números quiere imprimir”
2. Leer cantNum.
3. Si cantNum > 0
Entonces
num = 1
3.1. Mientras num <= cantNum repetir
Escribir num
num = num + 1;
3.2. {Fin del ciclo paso 3.1}
Sino
Escribir “Error en dato”
4. {fin del condicional del paso 3}
Página 7 de 73
IV. Codificación.
/* *Programa que genera cantNum numeros enteros positivos, iniciando de 1 * */
using System;
namespace ImprimeNumerosPositivos
{
class Program
{
public static void Main(string[] args)
{
//declaracion de variables
int cantNum, num=1;
//Entrada de Datos
Console.WriteLine("Cuantos números quiere imprimir (positivo)?");
cantNum = int.Parse( Console.ReadLine() );
if (cantNum > 0)//validacion del numero ingresado

{
Console.WriteLine("NUMEROS ENTEROS POSITIVOS. {0}", cantNum);
// estructura mientras, num sea menor que numero ingresado
while (num <= cantNum)
{
Console.WriteLine("{0}", num);
num = num + 1;
}
}
else
Console.WriteLine("Error en datos");
Console.Write("Press any key to continue . . . ");

Console.ReadKey(true);
return;
}
}
}
Otra forma de solucionar el ejemplo de los números enteros positivos utilizando modularidad es el siguiente:
Enunciado: Diseñe un flujograma que Imprima los n primeros números enteros positivos.
I. Planteamiento General del problema
ENTRADA DE DATOS SALIDA DE DATOS
 Cantidad de números a imprimir  Cada uno de los números
II. Análisis / Diseño Jerárquico Modular

 Main, Lee cuantos números desea imprimir (cantNum) e invoca el método ImprimirEnteros.
 ImprimirEnteros, mostrará un mensaje y luego leerá la cantidad de mujeres como un valor entero por teclado, lo convertirá
a entero y retornará el valor entero.
Página 8 de 73
ImprimeNumerosPositivos
Program
Main
ImprimirEnteros
III. Análisis / Diseño Jerárquico Modular Diseño de la Solución

Pseudocódigo (Flujograma ver ANEXO 1-B)
Método: ImprimirEnteros Acceso: Público Estático: Sí
{ imprime enteros hasta que num < cantNum }

{ num, cantNum de tipo entero, positivos}
1. Recibir cantNum, num.

2. Si cantNum > 0
Entonces
Escribir “Numeros Enteros Positivos", cantNum
2.1. Mientras num <= cantNum Repetir
Escribir num
num = num + 1;
2.2. {Fin del ciclo paso 2.1}
Sino
Escribir “Error en dato”
3. { fin del condicional del paso 2}
Método: Main Acceso: Público Estático: Sí
{ imprime enteros hasta que num < cantNum }

{ num, cantNum de tipo entero, positivos}
1. Hacer num = 1
2. Escribir “Cuantos números quiere imprimir (positivo)”
3. Leer cantNum.
4. imprimirEnteros(cantNum,num)
Página 9 de 73
IV. Codificación.
using System;
{
class Program
{
{
int cantNum, num=1;
//Entrada de Datos
imprimirEnteros(cantNum, num);

}
public static void imprimirEnteros(int cantNum, int num)

{
if (cantNum > 0)//validacion del numero ingresado

{
Console.WriteLine("NUMEROS ENTEROS POSITIVOS. {0}", cantNum);
{
num = num + 1;
}
}
else
Console.WriteLine("Error en datos");
return;
}
}
}
4. VALIDACIÓN DE DATOS CON CICLO MIENTRAS

Hasta el momento lo que hemos hecho con las restricciones de los datos de entrada es verificar si se cumplen, utilizando
una estructura selectiva: si se cumplen realizamos el proceso; pero si no lo hacen, terminamos el algoritmo sin hacer nada
o imprimimos un mensaje de "Error en los datos", y por lo tanto no se lleva a cabo el objetivo de la solución. El concepto
de validación de datos consiste en obtener valores correctos, con el fin de llevar a cabo el objetivo de la solución; es decir,
obtener datos que cumplan la o las restricciones, esto lo logramos con una estructura Mientras.
Por ejemplo, supongamos que tenemos un dato de entrada (que se llama puntos) cuya restricción es que debe ser mayor
que 5 pero menor o igual a 20, para validar este dato o sea cerciorarnos que el dato es correcto y que el algoritmo funciona
lo podemos hacer así: Expresión de estructura Selectiva o Restricción: puntos >=5 && puntos <= 20
Validar este dato, significa que Mientras la restricción no se cumpla, el dato es incorrecto y debemos volver a leer el dato;
por el funcionamiento de la estructura MIENTRAS (ejecuta la acción cuando la condición es cierta), es necesario escribir lo
contrario de la restricción o simplemente negar la expresión de la restricción, y esto nos servirá para volver a leer otro otra
vez leer puntos, y evaluar la condición nuevamente:
 Condición del ciclo Mientras: puntos<5 || puntos > 20
 Puede también escribirse: !(puntos >=5 && puntos <= 20)
Página 10 de 73
Observe que la flecha
regresa
Siempre a evaluar la condición,
NO ANTES NI DESPUÉS.
En esta parte de algoritmo no

hará más que pedir datos si
no se cumple la restricción.
Note también que en la

condición se ha escrito lo
contrario de la restricción, para
que la estructura MIENTRAS
funcione correctamente.
Muy importante: debemos distinguir entre la Restricción y la Condición de validación ó expresión lógica de validación así:
 Restricción: es la condición que deben cumplir la o las variables de entrada para que la solución funcione
correctamente, es decir, la restricción indica que valores son correctos para la o las variables de entrada.
 Condición de validación ó expresión lógica de validación:
 En el caso del ciclo mientras: es la condición o expresión lógica que se debe de cumplir para seguir ejecutando el
bucle de lectura de la o las variables de entrada en busca de un valor o valores correctos. En otras palabras es lo
contrario de la Restricción, como podemos observar en el ejemplo anterior.
 En el caso del ciclo hasta que: es la condición o expresión lógica que se debe de cumplir para dejar de ejecutar el
bucle de lectura de la o las variables de entrada en busca de un valor o valores correctos. En otras palabras es la
Restricción.
A continuación se muestra el mismo ejemplo anterior con el propósito de ilustrar el uso de la estructura mientras para
obtener un dato valido e implementando modularidad: Este ejercicio imprime n enteros positivos
IV. Codificación.
using System;
{
class Program
{
{
int cantNum, num=1;
//Entrada de Datos

}
Página 11 de 73
{
//Lazo para validar datos, notese que se sustituye estructura selectiva Doble
while (cantNum<=0)
{
Console.WriteLine("ERROR EN DATOS, NUMERO DEBE SER ENTERO POSITIVO");
}

{
num = num + 1;
}
return;
}
}
}
5. OPERADORES ADICIONALES DEL LENGUAJE C#

C# proporciona muchos operadores, que son símbolos que especifican las operaciones (matemáticas, indización, llamada
de función, etc.) que se realizan en una expresión. Puede sobrecargar muchos operadores para cambiar su significado al
aplicarlos a un tipo definido por el usuario.
Los operadores que hemos visto los resumimos en aritméticos (+, -, *, /, %), relacionales (<, <=, >,>=, !=, ==), lógicos (&&,
||, !) , el de asignación (=) y el operador condicional (?:).
Los datos sobre los que actúan los operadores se denominan operandos. Así en la expresión: 2 + a tenemos:
 un operador: ‘+’
 Y dos operandos: ‘2’ y ‘a’
Si escribimos completa la expresión tenemos que agregar una variable y otro operador más: x = 2 + a; para que dicho valor
adquiera el resultado de la expresión.
En esta sección clasificaremos a los operadores de acuerdo al número de operandos que necesiten en:
 Unuarios o monoarios, necesitan sólo un operando, como el signo menos de un número negativo: -a.
o Ejemplo: -15 y otros que veremos más adelante.
 Binarios que necesitan 2 operandos como 2+a.
o Ejemplo: a%2 x=5 etc.
 Terciarios que necesitan 3 operandos, como el condicional que considera cada expresión como operando, por
ejemplo, el operador condicional ?.
o Ejemplo: (a+3>7)? b=a: b=2; Donde (a+3>7) es el primer operando, b=a segundo operando y b=2 tercer
operando.
C# es un lenguaje rico en operadores, además de los que ya estudiamos, conoceremos también otros operadores:
 Asignación (binarios)
 Incremento-decremento (monarios)
5.1 Operadores de asignación:

Ya sabemos que, el operador = asigna el valor resultado de evaluar la expresión de la derecha a la variable situada a su
izquierda. Y es un operador binario, necesita 2 operandos, el de la izquierda que siempre es una variable y el de la
derecha que puede ser una constante, una variable o una expresión:
a = 300; b = a; x = 2 +a; total = sqrt(2*x+3/x-(5%2+b));
Página 12 de 73
Además del operador de Asignación =, lenguaje C# proporciona cinco operadores de asignación adicionales que actúan
como una nota abreviada para expresiones utilizadas con frecuencia, y que también son operadores binarios:
Símbolo Sentencia Abreviada Sentencia No Abreviada Descripción

= a=b a=b Asigna el valor de b a a.
*= a *= b a=a*b Multiplica a por b y asigna el resultado a la variable a
/= a /= b a=a/b Divide a entre b y asigna el resultado a la variable a
%= a %= b a=a%b Asigna el residuo de a/b
+= a += b a=a+b Suma a y b y lo asigna a la variable a
-= a -= b a=a-b Resta b de a y asigna el resultado a la variable a
Con estos nuevos operadores la adición de 3 a una variable num la podemos escribir de las siguientes formas:
num = num + 3; Equivale a num+= 3;
5.2 Operadores de Incremento – Decremento.

El lenguaje C# ofrece los operadores de incremento (++) y decremento (- -) que tiene una sintaxis abreviada para sumar
(incrementar) o restar (decrementar) 1 al valor de una variable, utilizado comúnmente en el uso de contadores. Estos
operandos son unuarios, ya que solo necesitan un operando, y éste debe ser siempre una variable:
Líneas que suman 1 a la variable n Sentencias que restan 1 al valor que tiene la variable n
++n; --n;
n += 1; n -= 1;
n = n +1; n = n – 1;
Estos operadores tienen la propiedad de que pueden utilizarse como prefijo (antes del operando) o como sufijo (después
del operando), el resultado de la expresión puede ser distinto, dependiendo del contexto.
Si los operadores ++ y - - se usan como prefijo, la operación de incremento o decremento se efectúa antes que la
operación de asignación; si los operadores ++ y - - están como sufijos, la asignación se efectúa en primer lugar y el
incremento o decremento después.
Ejemplos: Si i es una variable entera cuyo valor es 3, las variables y e i toman los valores sucesivos que se indican en las
sentencias siguientes:
Sentencia Descripción
++i; // incrementa i a 4
--i; // decrementa i en 1, i = 3
i++; // incrementa i a 4
i--; // decrementa i en 1, i =3
y = i++; // asigna el valor de i que es 3 a y , e incrementa 1 a i (i = 4)
y = ++i; // incrementa 1 a i (i = 5) y asigna el valor de i que es 5 a y
y = i--; // asigna el valor de i que es 5 a y , y decrementa 1 a i (i=4)
y = --i; // decrementa i en 1 (i =3), y asigna el valor de i que es 3 a y
A continuación se muestra el mismo ejemplo anterior con el propósito de ilustrar el uso de operadores de Incremento: Este
ejercicio imprime n enteros positivos
Página 13 de 73
using System;
{
class Program
{
{
int cantNum, num=1;
//Entrada de Datos

}

{
//Lazo para validar datos, notese que se sustituye estructura selectiva Doble
while (cantNum<=0)
{
Console.WriteLine("ERROR EN DATOS, NUMERO DEBE SER ENTERO POSITIVO");
}

{
num += 1; // ++num o también num = num + 1;
}
return;
}
}
}
5.3 Jerarquía de Todos los Operadores de C#

Ahora agregaremos a la jerarquía de operadores que ya conocemos, los operadores adicionales de asignación, incremento
y decremento. Esto para saber cuál operador evaluar primero y cual después. Se debe recordar que con el uso de
paréntesis se puede romper este orden de prioridades establecido por el lenguaje C#.
Operador Prioridad Asociatividad

Metodos Mayor Izq.– der.
++, --, ! Der – izq.
- (cambio de signo) Der – izq
*, /, % Izq – der
+, - Izq – der.
>, <, <=, >= Izq – der.
==, != Izq – der.
&& Izq – der.
|| Izq – der.
?: Der – Izq.
=, +=, -=, *=, /=, %= Der – Izq.
Página 14 de 73
Ejemplo No. 2
En la empresa “XXX” se requiere clasificar los diferentes productos que ofrecen. Para ello mantienen tres diferentes
clases de calidad: OPTIMA, NORMAL, y DEFICIENTE. Diseñe un programa, utilizando la metodología completa, que dé a
conocer el número de productos de cada clase, si se conoce la calidad de cada uno de los 100 existentes en bodega.

2.1 Análisis del Problema
a. Definición de Variables de Salida.

opt Entero Representa el número de productos con calidad Optima
nor Entero Contiene el número de productos con calidad Normal
def Entero Representa el número de productos con calidad Deficiente
Estas tres variables son de tipo contador, ya que irán guardando el número de productos de cada tipo de calidad, su valor
inicial es cero (0), su valor de cambio es uno (1) y su valor final es lo que necesitamos saber.
b. Definición de datos de Entrada.

Variables:
Representa un código numérico que indica la clase de calidad que tiene
clase Entero
un producto: 1: Optima, 2: Normal, 3: Deficiente
Constantes: El número de productos almacenados en bodega se consideran constantes: 100
c. Restricciones: clase >=1 && clase <= 3 // clase==1|| clase==2|| clase==3
d. Proceso:
Lo que se hará es, leer la calidad (o clase) de cada producto y contabilizarlo según su clase; es decir le sumaremos uno (1) a
opt, nor o def según corresponda y esto lo realizaremos 100 veces, ya que 100 son los productos existentes; por lo que
necesitamos un contador de productos (prod) como variable de control del ciclo. Como son tres tipos distintas, y esta son de
tipo contador, utilizaremos para la clasificación un Estructura de Selección Múltiple:
prod=1; opt=0; nor=0; def=0;
// Aquí se lee y valida clase
Repetir 1 opt++ / / opt=opt+1)

Mientras clase = 2 nor++ / / nor+=1)
prod 3 def++
<=100
e. Definición de Variables de Proceso:

Cuenta el número de productos analizados.
prod Entero
Valor inicial = 1; valor de cambio = 1 y valor final = 100
Página 15 de 73
2.2 Diseño Jerárquico Modular
 Main, Realiza la clasificación de los productos guardando cada tipo de producto respectivos dependiendo del
tipo recibido al invocar el método ValidarClase() y realiza la impresión enviándole los tipos e invocando al
método ImprimirClase().
 ValidarClase, recibe el número de producto a analizados para ser impreso (prod), además debe pedir el tipo
de producto (clase) y validar el valor ingresada se encuentre entre 1 y 3, y retorna el valor de tipo de producto.
 ImprimirClase, Muestra en pantalla del total de cada clasificación de productos como optima, normal,
deficiente (opt, nor, def) son variables de tipo entero, y deben ir incrementando según corresponda.
ClasificarProductos
Program
Main
ValidarClase ImprimirClase

Pseudocódigo (Flujograma ver ANEXO 2)
Método: Main Acceso: Público Estático: Sí
{ opt representa el número de productos con calidad óptima, nor contiene el número de productos con calidad normal,
def representa el número de productos con calidad deficiente, clase representa el valor ingresado código numérico
que indica la clase que tiene un producto, prod cuenta el número de productos analizados }
{opt, nor, def son acumuladores de cada clase son variables de tipo entero, y prod es variable de proceso que
representa el contador de clase, de tipo entero }
1. Hacer prod = 1, opt = 0, nor = 0, def = 0

2. Mientras prod <= 100 Repetir
Hacer clase = ValidarClase( )
2.1. Si clase igual
1: Hacer opt++
2: Hacer nor++
3: Hacer def++
2.2 { Fin del condicional paso 2.1 }
3. { Fin de ciclo paso 2 }
4. Hacer prod ++
5. ImprimirClase ( opt, nor, prod )
Página 16 de 73
Método: ValidarClase Acceso: Público Estático: Sí
{ Debe pedir la clase y validar que la clase ingresada se encuentre entre el rango 1, 2, 3 }
{ clase es una variable selector de tipo entero, y deben ser positivo }
1. Escribir "Digite la clase del producto (debe ser 1.Optimo ,2.Normal ,3.Deficiente): "
2. Leer clase
3. Mientras (clase < 1 || clase > 3) Repetir
Escribir "clase no existe intente de nuevo 1.Optimo, 2.Normal, 3.Deficiente: "
Leer clase
4. {Fin del ciclo paso 3}
5. Retornar clase
Método: ImprimirClase Acceso: Público Estático: Sí
{ Imprime total de las clasificaciones de productos como optima, normal, deficiente }

{ opt, nor, def son variables de tipo entero y deben ser positivo }
1. Recibe opt , nor, def
2. Escribir “Calidad optima”,opt
3. Escribir “Calidad Normal”, nor
4. Escribir “Calidad Deficiente”, def
IV. Codificación
/** Programa para clasificar los productos **/
using System;
namespace ClasificarProductos
{
class Program
{
{
//declaracion de variables e inicializadas
int prod=1;
int opt=0, nor=0, def=0;
int clase;
//Entrada de Datos
Console.WriteLine("CLASIFICACION DE PRODUCTOS SEGUN SU CALIDAD");
Console.WriteLine("1. Clase de Calidad Óptima"); // No están en el flujograma pero,
Console.WriteLine("2. Clase de Calidad Normal"); //ayudan a la entrada de datos
Console.WriteLine("3. Clase de Calidad Deficiente");
Console.WriteLine();// líneas en blanco
//Lazo para validar datos, nótese que se sustituye la estructura selectiva Doble
while (prod <=10)
{
clase = ValidarClase( ); //llamada a método lectura
switch (clase)
{
case 1: opt++;
break;
case 2: nor++;
break;
case 3: def++;
break;
}
prod ++;
}
//Definición del metodo impresion

Imprimir(opt, nor, def);
}
Página 17 de 73
public static int ValidarClase()
{
int clase;
Console.WriteLine("Digite la clase del producto(debe ser 1.Optimo ,2.Normal ,3.Deficiente): ");

clase = int.Parse(Console.ReadLine());
while (clase < 1 || clase > 3)

{ // Validacion de la clase de producto
Console.WriteLine("clase no existe intente de nuevo 1.Optimo, 2.Normal, 3.Deficiente):");
clase = int.Parse(Console.ReadLine());
}
return clase;
}
public static void Imprimir(int opt, int nor, int def)

{
Console.WriteLine("Calidad Optima. {0}", opt);
Console.WriteLine("Calidad Normal. {0}", nor);
Console.WriteLine("Calidad Deficiente. {0}", def);
return;
}
}
}
Los anidamientos de estructuras no solo se dan entre las selectivas, en este ejemplo tenemos dos estructuras mientras anidadas y
dentro de la primera (while (prod<=100)), una de selección múltiple. El único cuidado que se debe de tener es cerrar cada estructura
como tiene que ser y nunca cruzar dos o más de ellas.
Ejemplo No. 3
Diseñe un programa C# que, dados como datos 25 números enteros, obtenga la suma de los números impares y el promedio de los
números pares.

a. Definición de Variables de Salida

to_imp Entero Suma, totaliza o Acumula todos los números impares
p_pares Entero Promedio de todos los números pares
b. Definición de Datos de Entrada.

Variables:
num entero Cada uno de los 25 datos enteros
Constantes: Se utiliza el valor fijo 25.

c. Restricciones: No existen, los datos pueden ser negativos, positivos o cero.
d. Proceso:
Lo primero que haremos es clasificar los datos, cada uno de ellos, en par o impar, con la división residual %. Luego se van
sumando en 2 variables que acumulen cada tipo de dato; esto lo vamos a repetir 25 veces. Y al final se calcula el promedio
de pares, dividiendo la suma de todos los pares entre el número de datos pares, por lo tanto necesitamos contarlos:
Página 18 de 73
i=1 //cuenta número de datos, valor inicial 1
to_imp=0 //acumulada impares, valor inicial=0
to_par=0 //acumula pares, vi:=0
n_par=0 //cuenta pares, vi=0
e. Definición de Variables de Proceso

to_par entero Acumula todos los datos pares. Vi=0; Vc=num; Vf es lo que necesitamos conocer
n_par entero Cuenta el número de datos pares, Vi=0; Vc=1; Vf es lo que necesitamos
i entero Cuenta el número de datos leídos y procesados. Vi=1; Vc=1 y Vf =25 (contamos
desde el primer dato hasta el último).

 Main, inicializara el valor de números de datos leídos y procesados ( i ), además aumentar las variables que llevan
control de números pares y números impares (toImp, toPar) realizar la invocación ValidarNumEntero y ImpParesImpares.
 ValidarNumEntero, Leerá umEntero y validara que este número sea positivo y será devuelvo al main.
 ImpParesImpares, realizara el promedio de pPares, y realizara las impresiones de suma de impares (toImp) y promedio
de pares (pPares).
SumarImparesPromediar
Pares
Program
Main
ValidarNumEntero ImpParesImpares
Página 19 de 73
Método: Main Acceso: Público Estático: Si
{ inicializara el valor de números de datos leídos y procesados ( i ), además aumentar las variables que
llevan control de números pares y números impares (toImp, toPar) realizar la invocación ValidarNumEntero
y ImpParesImpares }
{toImp, numEntero, i=1 son variables de tipo entero, y deben ser positivo, topar, nPar, i=1 es variable de
proceso de tipo entero }
1. Hacer nPar=0, toPar=0, toImp=0, i=1.
2. Mientras i <= 25 Repetir
Hacer numEntero = ValidarNumEntero( i )
2.1 Si numEntero %2 == 0
Entonces
Hacer nPar++
Hacer toPar += numEntero
Sino
Hacer toImp += numEntero
2.2 {Fin del condicional del paso 2.1}
Hacer i++
3. {Fin del condicional del paso 2}
4. Hacer ImpParesImpares(toPar, nPar, toImp)
Método: ValidarNumEntero Acceso: Público Estático: Sí
{ Encargado de recibir el contador i y leer cada uno de los números enteros ( numEntero ) y validar su valor
sea entero positivo y retorna este valor }
{ numEntero, i , son variables de tipo entera y deben ser positivos }
1. Recibir i
2. Escribir "Digite el dato", i
3. Leer numEntero
4. Mientras numEntero < 0
Entonces
Escribir "Digite el dato nuevamente", i
Leer numEntero
5. {Fin del ciclol del paso 3}
6. Retornar numEntero.
Método: ImpParesImpares Acceso: Público Estático: Si
{recibe suma de numeros pares (toPar), el número de datos pares (nPar), el número de números impares
(toImp) y será el encargado de realizar el promedio de pares (pPares ) y realiza las impresiones de suma
de impares (toImp) y promedio de pares (pPares) }
{toImp, son variables de tipo entera y deben ser positivos, pPares , variable de tipo real, toPar, nPar son
variable de procesos }
1. Recibe toPar, nPar, toImp

2. Hacer pPares= toPar/nPar
3. Escribir "Suma de impares", toImp
4. Escribir "Promedio de pares", pPares
Página 20 de 73
IV. Codificación.
using System;
namespace SumarImparesPromediarPares
{
class Program
{
static void Main(string[] args)
{
int toImp, numEntero, toPar, nPar, i;
toImp = 0;
toPar = 0;
nPar = 0;
i = 1;
//Entrada de Datos
Console.WriteLine("SUMA DE NUMEROS ENTEROS PARES Y PROMEDIO DE IMPARES");
while (i <= 25) //inicia el ciclo de 25 numeros enteros

{
// se realiza el llamado al metodo validar numero entero
numEntero = ValidarNumEntero( i );
if (numEntero % 2 == 0) //Verifica si el dato es par

{
nPar++;
toPar += numEntero;
}
else
toImp += numEntero;
i++;
}
// invocar al metodo para imprimir
ImpParesImpares( toPar, nPar, toImp);
private static int ValidarNumEntero(int i) {

int numEntero;
Console.WriteLine("Digite el dato {0}", i);

numEntero = int.Parse(Console.ReadLine());
while (numEntero < 0) {

Console.WriteLine("Digite el dato nuevamente {0}", i);
}
return numEntero;
}
private static void ImpParesImpares(int toPar, int nPar, int toImp) {
float pPares;
pPares = toPar / nPar;
Console.WriteLine("Suma de impares = {0}", toImp);
Console.WriteLine("Promedio de pares = {0}", pPares);
return;
}
}
}
Página 21 de 73
Ejemplo No. 4
Diseñe un programa en C# que, lea un número entero y positivo N para que calcule el resultado de la siguiente serie:
1+1/2+1/3+1/4+1/5+……+1/N


serie Real La suma de todos los términos de la suma, acumulador Vi=0; Vc=cada
término y Vf es lo que se necesita conocer
b. Definición de Datos de Entrada:

Variables:
n Entero Número de términos de la serie, denominador mas grande
Constantes: No se utilizan.
c. Restricciones: n>0
d. Proceso:
Para sumar todos los términos en serie, esta variable debe tener un valor inicial de cero, generar cada término y acumularlo
en serie. Al observar la serie, cada término tiene el mismo numerador (1), y el denominador va incrementando de uno en
uno, siendo el primero 1. La generación del término y la acumulación en serie se realizará n veces:
k=1 //contador de términos
serie=0 //acumulador de términos

k Entero Contador de términos generados, sumas realizadas o de veces que se
repite el proceso. Vi=0, Vc=ter; Vf=n
ter Entero Representa cada uno de los términos a sumar

 Main, inicializara el valor de k, inicializa la serie, y hace los llamados a los métodos ValidarN y GenerarSerie e imprime el
resultado.
 ValidarN, leer numEntero y valida el valor, numEntero indica el número de términos de la serie y retorna numEntero.
 generarSerie, rrecibe numEntero como punto de fin para generar la serie, será retornada la serie y k que es un número para
división de la serie.
Página 22 de 73
ProgramaParaCalcularSerie
Program
Main
ValidarN GenerarSerie

{leer valor y valida el valor n que representa el fin de la serie }
{numEntero variables de tipo, entero deben ser positivo, k es un valor real para que el resultado de la
división sea real}
1. Hacer serie = 0,
2. Hacer k = 1.0
3. Hacer numEntero = ValidarN()
4. Hacer serie= GenerarSerie ( numEntero,k );
5. Escribe “El resultado de la serie es” serie
Método: ValidarN Acceso: Público Estático: Si
{ leer numEntero y valida el valor, numEntero indica el número de términos de la serie y retorna
numEntero }
{ numEntero variables de tipo, entero deben ser positivo }
1. Escribir "¿Cuantos términos (debe ser positivo)? "

2. Leer numEntero
3. Mientras numEntero <= 0 Repetir
Escribir "Debe ser un número positivo"
Leer numEntero
4. {Fin del ciclo del paso 3}
5. Retornar numEntero
Método: GenerarSerie Acceso: Público Estático: Si
{Recibe numEntero como punto de fin para generar la serie, será retornada la serie y k que es un numero
para división de la serie}
{ numEntero variables de tipo, entero deben ser positivo y serie ,k son variable de proceso de tipo real }
1. Recibe numEntero, k
2. Mientras k <= numEntero Repetir
Hacer ter = 1/k
Hacer serie += ter
Hacer k++
3. { Fin del ciclo del paso 2 }
4. Retornar serie
Página 23 de 73
IV. Codificación
using System;
namespace ProgramaParaCalcularSerie
{
class Program
{
{
int numEntero;
double serie;
serie = 0.0;
double k = 1.0; //k debe ser real para que el resultado de la division sea real
Console.WriteLine(" CALCULAR LA SERIE");

Console.WriteLine(" 1 + 1/2 + 1/3 + ... + 1/N");
Console.WriteLine("Donde N: numero de terminos de la serie");
//llamado a metodo pedir y validar n
numEntero = ValidarN();
//llamado a metodo para generar serie
serie = GenerarSerie(numEntero,k);
Console.Write("El resultado de la serie es = {0} ",serie);

}
public static int ValidarN()

{
int numEntero;
Console.WriteLine("Cuantos terminos? ");
while (numEntero <= 0) //inicia el ciclo de validacion de n, un entero positivo

{
Console.WriteLine("Debe ser un numero positivo: ");
}
return numEntero;
}
public static double GenerarSerie(int numEntero, double k) {

double serie=0, ter;
while (k <= numEntero) //inicia el ciclo para calcular cada termino y acumularlo
{
ter = 1 / k;
serie += ter;
k++;
}
return serie;
}
}
}
Página 24 de 73
Ejemplo No. 5
Un profesor de IAI115 tiene en su grupo 80 alumnos inscritos, los cuales realizaron 5 evaluaciones en todo el ciclo. El docente
necesita entregar a la coordinación un informe que contenga la siguiente información: Nombre y la nota final de cada estudiante, Nota
promedio de todos, Número de hombres aprobados y Número de mujeres reprobadas.


nFin Real Nota final de cada estudiante,
prom Real Nota promedio del grupo.
hApro Entero Representa el número de hombres que aprobaron la asignatura.
Variable tipo contador
mRep Entero La cantidad de mujeres que reprobaron la asignatura. Variable tipo
contador
 Además, se desplegara el nombre de cada estudiante

Variables:
nom Alfanum. Nombre de cada estudiante,
nota Real Cada una de las notas de cada estudiante.
sexo Entero Representa el sexo de cada estudiante: 1: Hombre y 2: Mujer
Constantes: Se utilizaran los valores fijos de 80 alumnos y 5 evaluaciones.
c. Restricciones:
nota>=0 && nota<=10
sexo==1 || sexo==2
d. Proceso:
 Los contadores y acumuladores deben iniciarse con valor cero.
 Para la nota final de cada estudiante uno se suman (o acumulan las 5 notas) y luego se divide entre 5.
Por lo tanto, se debe leer cada nota, validarla y después acumularla; proceso que se realiza 5 veces por alumno y, al
final de las cinco veces se divide entre 5. El acumulador debe iniciarse con cero para cada alumno. (Esto se realiza 80
veces).
 Para el promedio de todos se suman o acumulan las notas finales de cada alumno (se hace 80 veces) y se divide entre
80.
 Para calcular la cantidad de hombres aprobados y mujeres reprobadas se va a comparar la nota final de cada estudiante
con 6.0 y se incrementa en 1 el contador que corresponda, según el sexo del alumno, el sexo se debe leer y validar para
cada alumno. Se repite 80 veces también:
Página 25 de 73
a=1 // Contador de alumnos.
hApro=0 // Contador de hombres aprobados.
mRep=0 // Contador de mujeres reprobadas.
suma=0 // Acumulador de notas finales.

a Entero Contador de estudiantes, Vi=1; Vc=1 y Vf=80.
e Entero Contador de cada una de las 5 notas de cada estudiante, Vi=1; Vc=1; Vf=5
su1 Real Acumulador de las 5 notas de cada estudiante, Vi=0; Vc=nota y Vf es lo que
necesitamos.
suma Real Acumulador de las 80 notas finales, Vi=0; Vc=n Fin y Vf es lo que estamos
buscando.

 Main, inicializa las variables a, suma , hApro, mRep además de realizar los llamados a los métodos como ValidarNota(),
ValidarSexo(), ImprimirResultados() y llevar el control de la variable su1 que es el acumulador de notas del estudiante,
además hApro, mRep que son la variables que representan el número de hombres aprobados y mujeres reprobadas
respectivamente.
 ValidarSexo encargado leer el sexo de los alumnos y además validar que este ingresado correctamente.
 ValidarNota encargado de leer las notas de los alumnos y validar que las notas estén el rango correcto.
 Imprimir resultado encargado de imprimir los resultados esperados por el programa como hombre aprobados hApro y
mujeres reprobadas mRep así como el promedio de las notas del grupo
Nota_Promedio
Program
Main
ValidarSexo ValidarNota ImprimirResultados
Página 26 de 73
{ Crear un programa para la asignatura IAI115 que tiene en un grupo 100 alumnos inscritos, los cuales
realizaran 5 evaluaciones en todo el ciclo. Se necesita entregar a la coordinación un informe que contenga
la siguiente información: nombre y la nota final de cada estudiante, nota promedio de todos, número de
hombres aprobados, número de mujeres reprobadas }
{ nFin, prom, son variables de tipo real, deben ser positivo. hApro, mRep son variables de tipo, entero
deben ser positivo, a, e son variables de proceso de tipo entero y representan contadores que deberán ser
de tipo entera, su! Y suma son variable de proceso de tipo real y son acumuladores }
1. Hacer a=1
2. Hacer suma = 0
3. Hacer e=0
4. Hacer hApro=0, mRep=0
5. Mientras a <= 100 Repetir
Hacer su1 = 0
Hacer e =1
Escribir “Digite el nombre del estudiante”
Leer nom
5.1 Mientras e <= 5 Repetir
Hacer nota = ValidarNota();
Hacer su1 = su1 + nota
Hacer e++
5.2 {Fin de ciclo del paso 5.1}
Hacer nFin= su1/5
Hacer suma += nFin
Hacer sexo = ValidarSexo();
5.3 Si sexo == 1 entonces
5.3.1 Si nFin entonces
Hacer hApro++
5.3.2 {Fin del ciclo paso 5.3.1 }
Sino
5.3.3 Si nFin < 6.0 entonces
Hacer mRep++
5.4 {Fin del ciclo paso 5.3}
Escribir A, nom, nFin
Hacer A++
7. ImprimirResultado()
Método: ValidarNota Acceso: Público Estático: Si
{ obtiene las diferentes notas de los alumnos y valida que se encuentre en el rango 1 y 10 }
{ nota, es variable de tipo real, deben ser positivo }
1. Escribir “Digite la nota del estudiante”

2. Leer nota
3. Mientras (nota < 0 || nota > 10) Repetir
Escribir “Debe ser >=0 y <=10”
Escribir “Nota del estudiante:”
Leer nota
5. Retornar nota
Página 27 de 73
Método: ValidarSexo Acceso: Público Estático: Si
{ obtiene los tipos de sexo de los alumnos y valida que se encuentre en el rango 1 y 2 }
{ sexo, e, es variable de tipo entera, deben ser positivo }
1. Recibe e
2. Escribir “Sexo 1 masc. y 2 feme.”
3. Leer sexo
4. Mientras sexo !=1 && sexo!=2 Repetir
Escribir “Sexo 1 masc. y 2 feme.”
Leer sexo
6. Retornar sexo
Método: ImprimirResultado Acceso: Público Estático: Si
{ realiza el promedio del total de estudiantes y además imprime los resultados como promedio, hombres
aprobados, mujeres reprobados }
{ prom,suma son variables de tipo real, deben ser positivo, hApro, mRep son variables de tipo entera y
deben ser positivas }
1. Recibir suma, hApro, mRep

2. Hacer prom = suma / 80
3. Escribir “Promedio ,prom”
4. Escribir “Hombres aprobados", hApro
5. Escribir “Mujeres reprobadas", mRep
IV. Codificación.
using System;
namespace Nota_Promedio
{
class Program
{
{
int a;
float suma;
int e;
int hApro, mRep, sexo;
String nom;
float nota, su1, nFin;
a= 1;
suma = 0;
hApro = 0;
mRep = 0;
while (a <= 80)

{
su1 = 0;
e = 1;
Console.WriteLine("Digite el nombre de estudiante:");
nom = Console.ReadLine();
Página 28 de 73
while (e <= 5)
{
//llamada al metodo para ingresar nota
nota = ValidarNota(e);
su1 = su1 + nota;
e++;
}
nFin = su1 / 5;
suma += nFin;
//llamada al metodo para ingresar sexo
sexo = ValidarSexo();
if (sexo == 1)
{
if (nFin >= 6.0)
hApro++;
} else
if (nFin < 6.0)

mRep++;
Console.WriteLine("<------------>{0} {1} {2:0.00}",a,nom,nFin);
a++;
}
ImprimirResultados(suma, hApro, mRep);

}
public static float ValidarNota(int e) {

float nota;
Console.WriteLine("Digite la nota {0} del estudiante:", e);

nota = float.Parse(Console.ReadLine());
while (nota < 0 || nota > 10)

{
Console.WriteLine("DEBE SER MAYOR O IGUAL QUE CERO Y MENOR O IGUAL QUE DIEZ");
Console.WriteLine("Digite la nota {0} del estudiante: ", e);
}
return nota;
}
public static int ValidarSexo() {

int sexo;
Console.WriteLine("Digite el sexo del estudiante (1:masculino, 2:femenino):");
sexo = int.Parse(Console.ReadLine());
while (sexo != 1 && sexo != 2)

{
Console.WriteLine("EL SEXO PUEDE SER 1: MASCULINO o 2: FEMENINO");
Console.WriteLine("Digite el sexo del estudiante así 1: masculino, 2: femenino:");
sexo = int.Parse(Console.ReadLine());
}
return sexo;
}
public static void ImprimirResultados(float suma, int hApro, int mRep) {

float prom;
prom = suma / 3;
Console.WriteLine("PROMEDIO: {0:0.00} CANTIDAD HOMBRES APROBADOS: {1}", prom, hApro);
Console.WriteLine("CANTIDAD MUJERES REPROBADAS: {0}", mRep);
}
}
}
Página 29 de 73
6. ESTRUCTURA CONTROLADA POR UN CONTADOR – ESTRUCTURA DESDE_HASTA
Esta estructura se conoce como Desde - Hasta o ciclo FOR, se utiliza cuando conocemos por anticipado el número exacto de veces
que se va a ejecutar una determinada operación, acción o tarea. Al igual que el ciclo MIENTRAS, la realización del cuerpo del ciclo
depende de una condición, que siempre está relacionada con el valor final del contador.
Funcionamiento de la Estructura Desde_Hasta

Esta estructura, nos permite realizar el cuerpo del ciclo las veces que sea necesario, siempre y cuando se cumpla la condición. Al
entrar a la estructura se evalúa la condición, si el resultado es falso, el cuerpo del ciclo no se ejecuta, si al contrario la condición
resulta cierta, se realiza el cuerpo del ciclo.
Al ejecutarse el ciclo por primera vez, el valor inicial se le asigna a una variable de control (o contador), se verifica si el valor de la
variable de control es menor o igual (o mayor, en el caso de decremento) que el valor final, y a continuación se ejecuta el proceso del
interior del ciclo; cuando se termina el cuerpo del ciclo se cambia el valor de la variable contador (según su valor de cambio); si la
variable de control, es mayor (o menor en caso de cuentas regresivas) que el valor final, entonces se sale del bucle y continua con la
siguiente estructura del algoritmo.

Para la representación gráfica de esta estructura se utiliza solamente el símbolo de repetición, como se muestra adyacentemente, en
donde:
Cont : Variable de control (Contador)
Vi : Valor inicial del contador (desde cuanto contamos)
Vf : Valor final del contador (hasta cuanto contamos)
Vc : Valor de cambio del contador (incremento o decremento)
En otras palabras la estructura desde-hasta funciona como una estructura mientras
(cuando su variable de control es un contador), asignando el valor inicial al contador y
repitiendo el cuerpo del ciclo mientras éste se encuentre entre el rango de valores
permitidos por el valor final del contador, dentro del cuerpo del ciclo se le cambia el valor al
contador con el incremento o decremento del valor de cambio, sin necesidad de dibujar un
bloque que lo indique, ya que la estructura automáticamente lo realiza.

Para expresar una estructura Desde - Hasta en pseudo-código vamos a utilizar la siguiente simbología. Debe tenerse muy claro que
el uso de ciclos implica la posible realización de acciones previas y acciones posteriores al ciclo, según corresponda al diseño de la
solución.… Ejemplo
Hacer cont = Proposición Inicial //Acciones Previas
Repetir con cont desde Vi hasta Vf Hacer cont = 1
{ Repetir el Cuerpo del Ciclo} Repetir con cont desde 1 hasta 5
Hacer cont = Modificación de cont (Vc) { Repetir el Cuerpo del Ciclo}
{ Fin del Ciclo } Hacer cont = cont + 1
//Acciones Posteriores { Fin del Ciclo }
… //Acciones Posteriores
…
Las siguientes normas o reglas deben de cumplirse, cuando utilicemos una estructura Desde_Hasta
1. Las variable de control, valor inicial y valor final deben ser todas del mismo tipo : entera (int).
2. Los valores iniciales y finales pueden ser tanto expresiones, constantes o variables.
3. La última ejecución del bucle normalmente ocurre cuando la variable de control es igual al valor final.
4. El valor de cambio puede ser positivo (incremento) o negativo (decremento).
5. Cuando no se especifica el valor de cambio, el incremento de la variable de control es 1.
Página 30 de 73
6. La variable de control o contador solo se le debe cambiar su valor, después de realizado el cuerpo del ciclo y por el valor de
cambio indicado, nunca por una asignación extra.
En esta estructura el valor de cambio siempre es un valor entero (al igual que el valor inicial y el final y; por lo tanto la variable
contador debe ser también tipo entero). No podemos tener un valor de cambio de 0.5. Entonces, si nuestra variable contador debe ser
de tipo real, se debe de diseñar la solución con una estructura mientras y no con una desde – hasta.
Codificación de la Estructura Desde_Hasta en C#

La estructura iterativa Desde_Hasta necesita solamente la palabra reservada for ( ; ; ), que en español significa desde_hasta, los
paréntesis ( ) para encerrar la condición, los ; para separar los argumentos y las { } para delimitar el cuerpo del ciclo. Cada instrucción
for define el inicializador, la condición, y secciones de iterador. Estas secciones determinan normalmente cuántas veces recorre el
bucle.
Sintaxis
. . .
//Acciones previas
for (Inicializar; condición; iterador) //for (cont=Vi; cont<=Vf; cont++)
{
//Cuerpo del Ciclo
//Acción1
//AcciónN
}
//Acciones posteriores
. . .
Otra forma de representarlo
. . .
for (Expresion1; Expresion2; Expresion3)
{
Cuerpo del ciclo;
}
En donde: . . .
Expresion1: Es la expresión que asigna el valor inicial a la variable contador.
Expresion2: Es una expresión lógica (condición) que verifica que el valor actual del contador se encuentre entre
los permitidos (vi –vf).
Expresion3: Es una expresión de asignación que cambia el valor del contador.
Ejemplo
. . .
for ( x = 100; x <= 500; x = x + 50 )
{
Console.Write("\n {0}", x);
}
. . .
Página 31 de 73
Ejemplo No. 6
Diseñe un programa que imprima la suma de los números enteros comprendidos entre 15 y 25.

a. Definición de variables de salida.

suma entero Representa la sumatoria de cada uno de los números enteros
comprendidos entre los límites.
Acumulador vi=0; vc=cada número, vf=?

Variables:
li entero Representa el límite inferior del rango de números a sumar, o número inicial
ls entero Representa el límite superior del rango de números.
En este caso se han considerado los límites del rango de números a sumar (15 y 25) como variables, para tener la flexibilidad de
cambiarlos a necesidad del usuario, perfectamente se puede también diseñar una solución solamente para esos 2 valores.
Constantes: No se utilizan
c. Restricciones: li < ls, los límites pueden ser positivos o negativos
d. Proceso:
Leer li y ls // Validar
sum = 0 // Inicialización del acumulador
sum = sum + j //se repite desde j = li hasta j <= ls

j entero Representa cada uno de los números a sumar. Contador vi = li vc = 1 vf = ls

 Main, leer los limites inferior y superior los valida y los envía para ser procesador en ImprimirSuma.
 ImprmirSuma, realiza la suma de los números, entre los límites recibidos y es impreso.
SumatoriaNumerosEntre2límites
Program
Main
ImprimirSuma
Página 32 de 73
Método: Main Acceso: Público Estático:Si
{ El programa debe imprimir la suma de los números enteros comprendidos entre 15 y 25 }

{ li y ls son variables de tipo entera y representan el límite inferior y límite superior del rango de números pueden ser
positivos o negativos }
1. Escribir “Digite primero el límite inferior y luego el límite superior "

2. Leer li, ls
3. Mientras li > ls Repetir
Escribir "El primer limite a ingresar debe ser menor "
Leer li , ls
5. ImprimirSuma( li , ls)
Método: ImprmirSuma Acceso: Público Estático:Si
{ realiza la suma de los números entre los limites recibidos y es impreso }

{ suma es variable del tipo entero, debe ser positiva, j es variable de proceso que representan el contador }
1. Recibir li, ls
2. Hacer suma = 0
3. Repetir con 1 desde i=li hasta 1 ls
Hacer suma = suma + j
5. Escribir "La suma de los entero es ", suma
IV. Codificación
/* Programa que calcula la sumatoria de los números que se encuentra entre 2 límites*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace SumatoriaNumerosEntre2límites
{
class Program
{
{
int li, ls;
String[] tokens;
// lectura de los limites del rango de números(uno seguido del otro)
Console.WriteLine("Digite primero el limite inferior y luego el limite superior ");
tokens = Console.ReadLine().Split();
// Parse element 0
li = int.Parse(tokens[0]);
// Parse element 1
ls = int.Parse(tokens[1]);
Página 33 de 73
while (li > ls) /* validacion de datos */
{
Console.WriteLine("El primer limite a ingresar debe ser menor");
// Parse element 0
li = int.Parse(tokens[0]);
// Parse element 1
ls = int.Parse(tokens[1]);
}
//llamada a metodo para realizar el ciclo FOR
ImprimirSuma(li, ls);
/* Impresión del resultado */

public static void ImprimirSuma(int li, int ls)

{
int suma = 0;
for (int j = li; j <= ls; j++) // proceso, sumatoria de los numeros
suma += j;
Console.WriteLine("La suma de los enteros es: {0}", suma);
return;
}
}
}
Ejemplo No. 7
Un profesor calificó 25 exámenes de sus alumnos y requiere calcular la nota promedio de todos ellos, la nota más alta y cuántos
aprobaron y reprobaron el examen. Además se deberá imprimir el nombre y la nota de cada estudiante.


prom Real Representa la nota promedio del grupo de alumnos
mayor Real Representa la nota mayor de todos los exámenes
apr Entero Representa el número de estudiantes que aprobaron el examen. Contador vi=
0 vc = 1 vf =?
rep Entero Representa el número de reprobados. Contador vi=0 vc=1 vf=?
 Se desplegara el nombre de cada estudiante.
Variables:
nom Alfanúm Representa el nombre de cada estudiante
nota real Representa la nota de cada estudiante.
Constantes: Se utiliza el valor de 25 alumnos.
Página 34 de 73
c. Restricciones: nota >= 0 && nota <= 10
d. Proceso:

suma real Representa la suma de las 25 notas. Acumulador vi=0 vc=nota vf =?
i entero Representa el contador de los alumnos, vi =1 vc =1 vf =25.

calculaAprobadosRepro
bados
Program
Main
ValidarNota Imprimir

Página 35 de 73
{Un profesor calificó 25 exámenes de sus alumnos y requiere calcular la nota promedio de todos ellos, la nota más alta y
cuántos aprobaron y reprobaron el examen. Además se deberá imprimir el nombre y la nota de cada estudiante}
{ apr, rep son variables de tipo entero, deben ser positivos y representan el numero aprobados y reprobados
respectivamente, nom es del tipo alfanuméricos y representa el nombre del estudiante, nota del tipo real, suma es del tipo
real es variable de proceso y representa la suma de las 25 notas, i es un entero que representa un contador y es variable de
proceso}
1. Hacer mayor = 0, rep = 0, apr = 0, suma = 0

2. Repetir con i desde 1 hasta 25
Escribir “Digite el nombre del alumno”
Leer nom
Hacer nota = ValidarNota()
Hacer suma = suma + nota
Escribir nom, nota
2.1 Si nota >= 6 entonces
Hacer apr=apr+1
Sino
Hacer rep=rep+1
2.3 Si nota > mayor entonces
Hacer mayor = nota
3. {Fin del ciclo paso 2 }
4. Imprimir(suma, mayor, apr, rep)
{Realiza la validación de nota, se encuentre entre el rango 0 y 10 de cada alumno}

{nota es variable de tipo real }
1. Escribir “Introduzca la nota”

2. Leer nota
3. Mientras nota < 0 || nota > 10 Repetir
Escribir “La nota debe estar entre 0 y 10”
Leer nota
5. Retornar nota
Método: Imprimir Acceso: Público Estático: Si
{recibe los valores de suma, mayor, apr, rep los cuales utiliza para realiza el cálculo del promedio y además imprime los
demás valores}
{prom, mayor son variables de tipo real, deben ser positivos, apr, rep son variables de tipo entero, deben ser positivos y
representan el numero aprobados y reprobados respectivamente}
1. Recibir suma, mayor, apr, rep

2. prom = suma /25
3. Escribir “La nota promedio del grupo es”, prom
4. Escribir “Nota mayor del grupo es”, mayor
5. Escribir “Numero de aprobados”, apr
6. Escribir “Numero de reprobados”, rep
Página 36 de 73
V. Codificación.
/* Programa que calcula el numero de aprobados y reprobados*/
using System;
namespace calculaAprobadosReprobados
{
class Program
{
{
int apr = 0, rep = 0, i;
float nota, suma = 0, mayor = -1;
string nom;
for (i = 1; i <= 25; i++) // Inicio del lazo

{
Console.WriteLine("Digite el nombre del alumno:");
//realiza llamado al metodo y retorna nota
nota = ValidarNota();
suma += nota;
Console.WriteLine(" {0} {1:0.00}",nom,nota);// Cuenta aprobados y reprobados
if (nota>=6)
apr++;
else
rep++;
if (nota > mayor) // Almacena la nota mayor
mayor = nota;
} //Fin del lazo
//llamado a metodo para realizar prom e imprimir
Imprimir(suma, mayor, apr, rep);
}
private static float ValidarNota() {

float nota;
Console.WriteLine("Introduzca la nota:");
//fflush(stdin); // Se utiliza para limpieza del buffer de memoria
while (nota < 0 || nota > 10) //Validacion de datos

{
Console.WriteLine("La nota debe estar entre 0 y 10: ");
}
return nota;
}
private static void Imprimir(float suma,float mayor,int apr, int rep) {

float prom=0;
prom = suma / 25;
Console.WriteLine("La Nota Promedio del grupo es: {0:0.00} ", prom);

Console.WriteLine("Nota mayor del grupo: {0:0.00} ", mayor);
Console.WriteLine("Numero de Aprobados: {0:} ", apr);
Console.WriteLine("Numero de Reprobados: {0:} ", rep);
return;
}
}
}
Página 37 de 73
7. ESTRUCTURA DE ENTRADA ASEGURADA – ESTRUCTURA HASTA_QUE
Esta estructura se conoce como Hasta_Que o ciclo do-while, se utiliza cuando desconocemos el número exacto de veces que se va
a ejecutar el ciclo. Al igual que el ciclo MIENTRAS, la realización del cuerpo del ciclo depende de una condición, con la única
diferencia que esta estructura ejecuta (al menos una vez) el cuerpo del ciclo antes de que evalúe la condición.
Funcionamiento de la Estructura Hasta_Que

En esta estructura el cuerpo del ciclo se ejecuta la primera vez el cuerpo del ciclo, sin tomar en cuenta la condición, de aquí su
nombre: ENTRADA ASEGURADA; al finalizar el cuerpo del ciclo, se evalúa la condición, si el resultado es cierto se continúa
repitiendo el cuerpo del ciclo, caso contrario continúa con la estructura del algoritmo o flujograma.
Esta estructura, permite repetir el cuerpo del ciclo (proceso, acciones o tareas) al menos una vez, es decir que el número de
iteraciones puede ser 1, 2 o varias veces. Antes de ejecutar por primera vez el cuerpo del ciclo se asigna el valor inicial de la variable
de control, una vez completado el cuerpo del ciclo se verifica si el valor de la variable de control se cumple y al terminar la estructura,
cambia la variable de control y regresa a evaluar la condición de nuevo, si el resultado es falso, el cuerpo del ciclo no se ejecuta más
y continua con la estructura del algoritmo. Dentro del cuerpo del ciclo debe existir alguna estructura que modifique el resultado
lógico (de verdadero a falso) de la condición.
inicializa
Para la representación gráfica de esta estructura se utiliza solamente el símbolo de repetición,
como se muestra adyacentemente, en donde:
En otras palabras la estructura Hasta_Que funciona como una estructura mientras con la única
diferencia que primero realiza el cuerpo de ciclo y luego evalúa la condición.

Para expresar una estructura Hasta - Que en pseudo-código vamos a utilizar la siguiente simbología. Debe tenerse muy claro que el
uso de ciclos implica la posible realización de acciones previas y acciones posteriores al ciclo, según corresponda al diseño de la
solución.
… Ejemplo
Hacer cont = Proposición Inicial //Acciones Previas
Repetir Hacer cont = 1
{ Repetir el Cuerpo del Ciclo} Repetir
Hacer cont = Modificación de cont (Vc) { Repetir el Cuerpo del Ciclo}
Hasta que ( condición ) Hacer cont = cont + 1
{ Fin del Ciclo } Hasta que ( cont < 5 )
//Acciones Posteriores { Fin del Ciclo }
… //Acciones Posteriores
…
Las siguientes normas o reglas deben de cumplirse, cuando utilicemos una estructura HASTA_QUE:
1. La estructura se asigna el valor inicial de la variable de control.
2. Se ejecuta el cuerpo del ciclo una vez, la primera
3. Dentro del cuerpo del ciclo debe existir alguna expresión que posibilite la modificación del resultado lógico (de verdadero a falso)
de la condición.
4. La estructura termina con una expresión lógica.
5. Se evalúa la condición: resultado falso se repite una vez más el cuerpo del ciclo y se evalúa de nuevo la condición.
Página 38 de 73
Codificación de la Estructura Hasta_Que en C#
La estructura iterativa de entrada asegurada necesita solamente la palabra reservada do while, que justamente en español significa
Hasta que, los paréntesis ( ) para encerrar la condición y las { } para delimitar el cuerpo del ciclo.
La instrucción do ejecuta una instrucción o un bloque de instrucciones repetidamente hasta que una determinada expresión se evalúa
como false. El cuerpo del bucle se debe incluir entre llaves, {}, a menos que esté compuesto por una sola instrucción. En ese caso,
las llaves son opcionales.
Sintaxis
. . . Ejemplo
//Acciones previas . . .
cont = Proposición Inicial // cont=Vi; //Acciones previas
do
x = 100;
{ do
//Cuerpo del Ciclo
{
//Acción1
//AcciónN Console.Write("\n {0}", x);
//cont = Modificación de cont cont++ x = x + 50;
} while(condición) // cont<=Vf; } while ( x < 500);
//Acciones Posteriores //Acciones Posteriores
. . . . . .
En C# la estructura do-while puede salir del bucle utilizando la instrucción break en cualquier punto del bloque. Puede pasar
directamente a la instrucción de evaluación de expresión while utilizando la instrucción continue. Si la expresión while se evalúa
como true, la ejecución continúa en la primera instrucción tras el bucle. Si la expresión se evalúa como false, la ejecución continúa en
la primera instrucción detrás del bucle do-while. En nuestro caso y con fines académicos no aplicaremos estas últimas técnicas para
salir de la estructura sino como se indicó al principio de esta unidad se utilizaran llaves para delimitar el fin de la estructura.
Ejemplo No. 8: Mismo ejercicio anterior solamente pero ahora con la estructura asegurada
Un profesor calificó 25 exámenes de sus alumnos y requiere calcular la nota promedio de todos ellos, la nota más alta y cuántos
aprobaron y reprobaron el examen. Además se deberá imprimir el nombre y la nota de cada estudiante.
Para este ejercicio omitiremos la fase I y II y desarrollaremos la parte III y IV

Página 39 de 73
{ Un profesor calificó 25 exámenes de sus alumnos y requiere calcular la nota promedio de todos ellos, la nota más
alta y cuántos aprobaron y reprobaron el examen. Además se deberá imprimir el nombre y la nota de cada
estudiante }
{ apr, rep son variables de tipo entero, deben ser positivos y representan el numero aprobados y reprobados
respectivamente, nom es del tipo alfanuméricos y representa el nombre del estudiante, nota del tipo real, suma es
del tipo real es variable de proceso y representa la suma de las 25 notas, i es un entero que representa un
contador y es variable de proceso }
1. Hacer mayor = 0, rep = 0, apr = 0, suma = 0, i =1

2. Repetir
Escribir “Digite el nombre del alumno”
Leer nom
Hacer nota = ValidarNota()
Hacer suma = suma + nota
Escribir nom, nota
2.1 Si nota >= 6 entonces
Hacer apr=apr+1
Sino
Hacer rep=rep+1
2.3 Si nota > mayor entonces
Hacer mayor = nota
Hacer i++
Hasta i < 25
3 {Fin del ciclo paso 2 }
4 Imprimir(suma, mayor, apr, rep)
{Realiza la validación de nota, se encuentre entre el rango 0 y 10 de cada alumno}

{nota es variable de tipo real }
1. Escribir “Introduzca la nota”

2. Leer nota
3. Mientras nota < 0 || nota > 10 Repetir
Escribir “La nota debe estar entre 0 y 10”
Leer nota
5. Retornar nota
Método: Imprimir Acceso: Público Estático: Si
{recibe los valores de suma, mayor, apr, rep los cuales utiliza para realiza el cálculo del promedio y además
imprime los demás valores}
{prom, mayor son variables de tipo real, deben ser positivos, apr, rep son variables de tipo entero, deben ser
positivos y representan el numero aprobados y reprobados respectivamente}
1. Recibir suma, mayor, apr, rep

2. prom = suma /25
3. Escribir “La nota promedio del grupo es”, prom
4. Escribir “Nota mayor del grupo es”, mayor
5. Escribir “Numero de aprobados”, apr
6. Escribir “Numero de reprobados”, rep
Página 40 de 73
VI. Codificación.
using System;
namespace calculaAprobadosReprobados
{
class Program
{
{
int apr = 0, rep = 0, i;
float nota, suma = 0, mayor = -1;
string nom;
i = 1;
do // inicia el ciclo DO WHILE entrada asegurada
{
Console.WriteLine("Digite el nombre del alumno:");
//realiza llamado al metodo y retorna nota
nota = ValidarNota();
suma += nota;
Console.WriteLine(" {0} {1:0.00}", nom, nota);// Cuenta aprobados y reprobados

if (nota >= 6)
apr++;
else
rep++;
if (nota > mayor) // Almacena la nota mayor
mayor = nota;
i++;
} while (j < 25);
//llamado a metodo para realizar prom e imprimir

Imprimir(suma, mayor, apr, rep);
}
private static float ValidarNota() {

float nota;
Console.WriteLine("Introduzca la nota:");
while (nota < 0 || nota > 10) //Validacion de datos

{
Console.WriteLine("La nota debe estar entre 0 y 10: ");
}
return nota;
}
private static void Imprimir(float suma,float mayor,int apr, int rep) {
float prom=0;
prom = suma / 25;
Console.WriteLine("La Nota Promedio del grupo es: {0:0.00} ", prom);

Console.WriteLine("Nota mayor del grupo: {0:0.00} ", mayor);
Console.WriteLine("Numero de Aprobados: {0:} ", apr);
Console.WriteLine("Numero de Reprobados: {0:} ", rep);
return;
}
}
}
Página 41 de 73
8. ESTRUCTURA PARA CADA ELEMENTO - ESTRUCTURA DERIVADA
La estructura para cada elemento es una variante del ciclo Desde_Hasta. Se conoce por la instrucción foreach derivada de la
estructura for pensada especialmente para compactar la escritura de códigos donde se realice algún tratamiento a todos los
elementos de una colección, que suele tener un uso muy habitual de for en los lenguajes de programación que lo incluyen con C#. La
sintaxis que se sigue a la hora de escribir esta instrucción foreach es:
foreach (<tipoElemento> <elemento> in <colección>)
<Instrucciones>
El significado de esta instrucción es muy sencillo:

1. se ejecutan <instrucciones> para cada uno de los elementos de la <colección> indicada.
2. <elemento> : es una variable de sólo lectura de tipo
3. <tipoElemento> : que almacenará en cada momento el elemento de la colección que se esté procesando y que podrá ser
accedida desde <instrucciones>
.
Es importante señalar que <colección> no puede valer null porque entonces saltaría una excepción de tipo
System.NullReferenceException, y que <tipoElemento> ha de ser un tipo cuyos objetos puedan almacenar los valores de los
elementos de <colección>
En tanto que una tabla se considera que es una colección, el siguiente código muestra cómo usar for para compactar aún más el
código de la clase HolaMundoFor anterior:
using System;
namespace ParaCadaElemento
{
class HolaMundoFoeach
{
{
if(args.Length>0)
foreach(String arg in args)
Console.WriteLine("¡Hola {0}!", arg);
else
Console.WriteLine("¡Hola mundo!");
}
}
}
En general, se considera que una colección es todo aquel objeto que implemente la interfaz
System.Collections.IEnumerable. Esta interfaz está definida en la BCL. Por el momento solo conoceremos el
funcionamiento básico de la estructura, los detalles lo veremos en detalle en la unidad 6.
Página 42 de 73
9. CICLOS ANIDADOS
El cuerpo de un ciclo puede contener cualquier tipo de sentencias: secuenciales, selectivas y repetitivas. Cuando un ciclo
está contenido en el cuerpo de otro ciclo, se denominan ciclos anidados. Se pueden anidar cualquier tipo de estructura
estudiada anteriormente, ya sea con un mismo tipo de estructuras o con una combinación de varias de ellas.
Por ejemplo, los ciclos Hacer mientras y desde hasta pueden estar anidados, entre sí, o bien ciclos Hacer mientras con
hasta que o viceversa; como se muestra a continuación:
. . .
//Dos ciclos mientras anidados:
Mientras (Condición 1) repetir
. . .
Mientras (Condición 2) repetir
Bloque de instrucciones
Fin del ciclo mientras
. . .
. . .
. . .
//Ciclo mientras dentro de un desde - hasta
Repetir con var=vi desde Vi hasta Vf
. . .
Mientras (Condición 2) Repetir
Bloque de instrucciones
. . .
Fin del ciclo desde - hasta
. . .
10. TECNICA DE CICLO CONTROLADO POR BANDERA
Bandera: es una técnica que utiliza una variable de control que puede almacenar uno de dos posibles valores resultado de evaluar
una condición) y puede representar el continuar o finalizar de repetir el ciclo. Ejemplo “cierto” o “falso”, 1 o 0, continuar o finalizar, yes
o no, si o no, etc.
Una bandera sirve entre otras cosas para controlar las repeticiones de un ciclo, tomando en cuenta que para esta técnica solamente
se puede implementar cuando se desconoce las veces que se repite el ciclo y con la estructura mientras y hasta_que. El
Programador es quien decide que estructura será la más idónea y los valores a usar como valor cierto y valor falso; la variable
bandera puede ser de tipo alfanumérico, entero o real (aunque el lenguaje lo permite no utilizaremos las variables de tipo string); pero
en todo caso habrá un valor para “cierto” y un valor para “falso”. Véase ejemplos de valores usando diferentes tipos, en la tabla
siguiente:
Valor Cierto Valor Falso

‘c’ ‘f’ Si la variable bandera es alfanumérica
‘y’ ‘n’ usaremos un carácter para cierto y
Si la variable bandera es numérica usaremos ‘s’ ‘n’ otro para falso, según sea el caso.
un valor para cierto y otro para falso, según ‘+’ ‘*’
sea el caso. El programador decide que 1 0
valores asignarle durante el análisis. 1 2
10 20
1.0 0.0
1.0 2.0
Página 43 de 73
Anteriormente, hemos practicado el uso de ciclo controlado por contador, el cual se emplea cuando se sabe o se puede preguntar la
cantidad de repeticiones. En el presente contenido estudiaremos el uso de bandera para controlar ciclos. Como ya hemos aclarado las
variables bandera se utilizan cuando no se sabe la cantidad de repeticiones que se deben realizar.
Cabe señalar que en un programa se puede combinar diferentes técnicas de control de ciclos. Por ejemplo se puede usar bandera en
el primer ciclo cuando no se sabe la cantidad de repeticiones, combinando con un contador para determinar la cantidad de
repeticiones. Al finalizar el ciclo controlado por la bandera el contador contiene la cantidad de repeticiones, por lo que si fuera
necesario ejecutar alguna operación con los mismos datos se puede usar contador, lo anterior es útil principalmente cuando se
emplea arreglos o matrices.
La bandera es una variable que posee restricción y que se lee por teclado, por lo que igual que las variables de entrada tendrán que
ser validada. Para la cual se empleará el ciclo mientras, también llamado ciclo con entrada condicionada para validar.
Representación en Pseudo-Código – Bandera

La representación en pseudocódigo se expresa generalmente en una estructura MIENTRAS en pseudo-código y utilizaremos la
siguiente simbología. En esta situación hay que aclarar que se declarará una variable extra, variable bandera como una variable de
proceso. Ejemplo supóngase una variable de nombre bandera, de tipo entero y restricción bandera ==1 || bandera==0

…
//acciones previas al ciclo principal, como inicializar acumuladores, contadores y otros
bandera = 1 // a la variable bandera se le asigna el valor inicial que corresponde al valor cierto
Mientras (bandera ==1) repetir // la condición será que la variable bandera sea igual al valor cierto
{ Repetir el Cuerpo del Ciclo} //Cuerpo del Ciclo, validar entrada, Acciones, procesos y salidas iterativos
Escribir "otro dato? 1. Si o 0. No" //Mensaje de entrada
Leer bandera //solicitud de continuar o parar
Mientras (bandera ==1|| bandera ==0) repetir //validación de bandera
Escribir "Error, Digite 1. Si o 0. No"
Escribir "otro dato? 1. Si o 0. No"
IMPORTANTE: justo antes de finalizar el ciclo, se debe de validar la
Leer bandera variable bandera, esta acción funciona como acción de control de
{ Fin del Ciclo validación Bandera} ciclo, en otras palabras esta acción es la que permite que el ciclo
{ Fin del Ciclo Principal} continúe ejecutándose o finalice.
//Acciones Posteriores al ciclo principal
…
Observe que el ciclo se ejecutará mientras el valor de bandera sea igual a 1, es decir, igual al valor “cierto”
Ejemplo No. 9
Dada la estatura de un grupo (la cantidad es totalmente desconocida) de personas adultas y su género, la estatura debe estar entre 1
mts y 2.5 mts ambos inclusive. Se pide, determinar la cantidad de personas del género femenino por arriba de 1.50 mts y la cantidad
de personas del género masculino por arriba de 1.65 mts. También se necesita conocer la estatura promedio de todo el grupo sin
importar el género de las personas de las personas. Además debe determinar la estatura y el género ‘f’ o ‘m’ de la persona más alta y
de la persona más baja respectivamente.
Página 44 de 73
Entrada de datos Salida de datos
 II. Estatura de cada persona  Cantidad de personas femenino arriba de 1.5 mts
 Genero de cada persona  Cantidad de personas masculino arriba de 1.65
 Variable de control bandera mts
 Promedio general de estaturas
 Estatura y género de la persona más alta
 Estatura y género de la persona más baja


cantF_150 Entero Cantidad de personas femenino de estatura mayor a 1.5 mts vi=0 vf=? vc=1
cantM_165 Entero Cantidad de personas masculino de estatura mayor a 1.65 mts vi=0 vf=? vc=1
promEst Real Promedio de estaturas general de todo el grupo
mayorEst Real Estatura mayor del grupo
mayorGen Alfanumérico Género de la estatura mayor
menorEst Real Estatura menor del grupo
menorGen Alfanumérico Género de la estatura menor
Variables:
estatura Real Estatura de las persona
genero alfanumérico Género de la persona ‘f’. femenino o ‘m’ masculino
Constantes: No se utilizará
c. Restricciones: estatura >= 1 && estatura <=2.5
genero==’f’ || genero == ‘m’
d. Proceso:
contPer=0 //Contador de personas se inicia a cero

cantF_150=0//Contadores de genero de inicializa a cero
cantM_165=0
sumaEst=0 // el acumulador se inicia en cero
mayorEst=0
mayorGen=’ ’
menorEst=0
menorGen=’ ’
Previo al ciclo se debe inicializar la bandera así: variable
bandera=1 =valorSeguir, en este caso la variable se llama bandera y
el valor seguir es 1.
La condición del ciclo será
Mientras(bandera==1)
Validar estatura La variable ==valor seguir
Validar genero Estructura selectiva múltiple con variable alfanumérica
¿Si genero es:? de carácter género, se usan dos casos que son ‘f’ y ‘m’
‘f’ : ¿Es (estatura > 1.50)?
Si: cantF_150++ Para el caso ‘f’ se tiene una estructura selectiva simple,
‘m’: ¿Es (estatura > 1.65)? que cuando la estatura es mayor a 1.50 la cuenta
Si: cantM_165++
¿Es estatura > mayorEst? Para el caso ‘m’ se tiene una estructura selectiva simple,
que cuando la estatura es mayor a 1.65 la cuenta
Página 45 de 73
Si: mayorEst=estatura
mayorGen=genero Estructura selectiva simple que permite determinar cuál es la estatura
mayor y su genero sino determina la menor estatura y su genero
No: menorEst=estatura
menorGen=genero
contPer++
Cada vez que se repite el ciclo principal se incrimenta contPer y se acumula est
sumaEst += estatura
validar bandera //continuar es 1 para finalizar 0

Justo antes de finalizar el ciclo principal, se debe
promEst=sumEst/contPer validar la variable bandera
Imprimir cantF_150 , cantM_165, promEst, mayores, mayorGen, menorEst, menorGen

contPer entero Contador de personas vi=0 vf=? vc=1
sumaEst Real Suma de las estaturas de las personas vi=0 vf=? vc=estatura
bandera entero Indicador de continuar o finalizar. 1 continuar 0. parar
 LeerBandera Lee y valida la variable bandera

 LeerEstatura Lee y valida la estatura ingresa
 LeerGenero Lee y valida el género digitado
 Imprimir Devuelve en pantalla el mensaje recibido más la variable a mostrar
Ejemplo9
Program
Main
LeerBandera LeerEstatura Imprimir LeerGenero

Pseudocódigo
Página 46 de 73
Método: main Acceso: Público Estático: Sí
{Invoca el modulo LeerGenero y LeerEstatura , donde Lee edad y estatura de personas adultas junto con su género,
la estatura debe estar entre 1 mts y 2.5 mts género femenino por arriba de 1.50 mts y la cantidad de personas del
género masculino por arriba de 1.65 mts.}
{ contPer , cantF_150 , cantM_165 , sumaEst , mayorEst , menorEst

son acumuladores de cada clase son variables de tipo entero, y prod es variable de proceso que representa el
contador de clase, de tipo entero }
1. Hacer contPer = 0, cantF_150 = 0, cantM_165 = 0, sumaEst = 0, mayorEst = 1.0, menorEst = 2.5

2. Hacer menorGen = ' ', mayorGen = ' '
3. Hacer bandera = 1
4. Mientras bandera == 1 Repetir
Hacer estatura = LeerEstatura()
Hacer genero = LeerGenero()
4.1. Si (genero) igual
'f': Si (estatura > 1.5) entonces
Hacer cantF_150++
'm': (estatura > 1.65) entonces
Hacer cantM_165++
{ Fin del condicional paso 4.1 }
4.2 Si (estatura > mayorEst) entonces
Hacer mayorEst=estatura
Hacer mayorGen=genero
Sino
Hacer menorEst=estatura
Hacer menorGen=genero
{ Fin del condicional paso 4.2 }
Hacer contPer++
Hacer sumaEst += estatura
Hacer bandera = LeerBandera()
5. { Fin de ciclo paso 4 }
6. Hacer promEst = sumaEst / contPer
7. Imprimir("Cantidad de femenino > 1.50 mts: ", cantF_150)
8. Imprimir("Cantidad de masculino > 1.65 mts: ", cantM_165)
9. Imprimir("Promedio de estatura en mts:", promEst)
10. Imprimir("Estatura mayor mts:", mayorEst)
11. Imprimir("Genero de estatura mayor : ", mayorGen)
12. Imprimir("Estatura menor mts: ", menorEst)
13. Imprimir("Genero de estura menor: ", menorGen)
Método: LeerEstatura Acceso: Público Estático: Sí
{ Debe pedir la estatura y validar que la ingresada sea correcta }

{ est es una variable de tipo real, y deben ser positivo entre 1 y 2.5 }
1. Escribir " Ingrese la estatura de la persona "

2. Leer est
3. Mientras (est < 1 || est > 2.5) Repetir
Escribir " Error estatura debe ser mayor a 1 y menor que 2.5"
Escribir " Ingrese la estatura de la persona "
Leer est
5. Retornar est
Página 47 de 73
Método: LeerGenero Acceso: Público Estático: Sí
{ Debe pedir el genero y validar que la ingresada sea f o m }

{ gen es una variable de tipo caracter, y deben ser f o m }
1. Escribir " Ingrese genero de la persona f. femenino o m. masculino "

2. Leer gen
3. Mientras (gen == 'f' || gen == 'm') Repetir
Escribir " Error genero debe ser f o m "
Escribir " Ingrese genero de la persona f. femenino o m. masculino "
Leer gen
5. Retornar gen
Método: LeerBandera Acceso: Público Estático: Sí
{ Debe pedir el si continuar o parar de repetir }

{ ban es una variable de tipo entero y deben ser 1 Si o 0. No }
1. Escribir " Desea continuar(1 es Si o 0 es no):");"

2. Leer ban
3. Mientras (!(ban == 1 || ban == 0)) Repetir
Escribir " Error en la respuesta valido 1 o 0"
Escribir " Desea continuar(1 es Si o 0 es no): "
Leer ban
5. Retornar ban
Método: Imprimir Acceso: Público Estático: Sí
{ Debe recibir los parámetros enviados desde el modulo principal, para imprimir resultados y mensaje }
1. Recibir msg, var

2. Escribir msg, var
IV. Codificación.
using System;
namespace Ejemplo9
{
class Program
{
{
//Definicion de variables de entrada
double estatura;
char genero;
//Definicion de variables de salida
int cantF_150, cantM_165;
char mayorGen, menorGen;
double mayorEst, menorEst, promEst;
//Variables de proceso
int contPer, bandera;
double sumaEst;
//Inicializacion de variables
contPer = 0; cantF_150 = 0; cantM_165 = 0; sumaEst = 0;
Página 48 de 73
mayorEst = 1.0; //para determinar el mayor se inicia la variable con el valor menor posible
menorEst = 2.5; //para determinar el menor se inicia la variable con el valor mayor posible
menorGen = ' '; mayorGen = ' ';
bandera = 1;
while (bandera == 1)
{
estatura = LeerEstatura();
genero = LeerGenero();
//posibles casos de estaturas superiores

switch (genero)
{
case 'f': if (estatura > 1.5)
cantF_150++;
break;
case 'm': if (estatura > 1.65)
cantM_165++;
break;
}
//la estatura y genero mayor

if (estatura > mayorEst)
{
mayorEst = estatura;
mayorGen = genero;
}
else
{
// la estatura y genero menor
menorEst = estatura;
menorGen = genero;
}
contPer++; //contador de personas

sumaEst += estatura; //suma de las estaturasa
Console.Clear();
bandera = LeerBandera();
Console.Clear();
}//finalizacion del ciclo principal
//calculo de promedio
promEst = sumaEst / contPer;
Console.Clear();
//Impresiones de variable de salida
Imprimir("\nCantidad de femenino > 1.50 mts: {0} ", cantF_150);
Imprimir("\nCantidad de masculino > 1.65 mts: {0} ", cantM_165);
Imprimir("\nPromedio de estatura en mts: {0} ", promEst);
Imprimir("\nEstatura mayor mts: {0} ", mayorEst);
Imprimir("\n Genero de estatura mayor : {0} ", mayorGen);
Imprimir("\n Estatura menor mts: {0} ", menorEst);
Imprimir("\n Genero de estura menor: {0} ", menorGen);
Console.ReadLine();
}
Página 49 de 73
private static double LeerEstatura()
{
double est;
//lectura de la estatura de la persona
Console.WriteLine("Ingrese la estatura de la persona \n");
est = double.Parse(Console.ReadLine());
//validacion de la estatura
while (!(est >= 1 && est <= 2.5))
{
Console.WriteLine("\n Error estatura debe ser mayor a 1 y menor que 2.5");
Console.WriteLine("\n Ingrese la estatura de la persona \n");
}
return est;
}
private static char LeerGenero()

{
char gen;
//lectura del genero de la persona
Console.WriteLine("Ingrese genero de la persona f. femenino o m. masculino");
gen = char.Parse(Console.ReadLine());
//validacion del genero
while (!(gen == 'f' || gen == 'm'))
{
Console.WriteLine("\n Error genero debe ser f o m");
Console.WriteLine("\n Ingrese genero de la persona f. femenino o m. masculino \n");
}
return gen;
}
private static int LeerBandera()

{
int ban;
//lectura de la bandera
Console.WriteLine("\n Desea continuar(1 es Si o 0 es no):");
ban = int.Parse(Console.ReadLine());
//validacion de bandera
while (!(ban == 1 || ban == 0))
{
Console.WriteLine("\n Error en la respuesta valido 1 o 0");
Console.WriteLine("\n Desea continuar(1 es Si o 0 es no):");
ban = int.Parse(Console.ReadLine());
}
return ban;
}
private static void Imprimir(string msg, object var)

{
Console.WriteLine(msg,var);
}
}
}
Página 50 de 73
11. TECNICA DE CICLO CONTROLADO POR CENTINELA
Centinela: es una técnica que utiliza una variable de control que es además de una variable de entrada (con datos validos) una
variable de control de ciclo. Es decir que la variable tiene una doble función la primera recibir los datos a procesar y la segunda
función de: continuar o detener un ciclo).
Una variable centinela se escoge de entre las variables de entrada de la solución (variables tipo entero, tipo real o tipo alfanumérico de
un carácter) que al igual que la bandera no utilizaremos variable tipo cadena de carácter por fines prácticos.
La variable centinela al igual que la variable de control bandera se usará cuando la cantidad de veces que debe repetirse el ciclo es
desconocida, generalmente con la estructura mientras, pero algunas programadores gustan de la estructura de control hasta que.
La variable centinela es una variable que posee restricción y que se lee por teclado, por lo que igual que las variables de entrada
tendrán que ser validada. Al igual que como lo hace la bandera empleando el ciclo mientras.
Representación en Pseudo-Código – Centinela

siguiente simbología. En esta situación hay que aclarar que no se declarará una variable extra, sino que selecciono un valor preciso
de mis datos incorrectos para detener la repetición del ciclo. Ejemplo supóngase una variable de nombre edad, de tipo entero y
restricción edad > 0. De los datos incorrectos (edad <= 0) elijo cualquier, para nuestro caso -1 que es el valor que detiene el ingreso
de datos y por consiguiente presentará los resultados esperados del problema.
Pseudocódigo
…
Hacer edad = 1 // cualquier valor diferente del centinela y que sea valido
Mientras (edad != -1) repetir //la condición debe ser la variable centinela diferente del valor centinela
Hacer edad = 0 //asignar variable centinela cualquier valor del centinela que no sea valido
Mientras (!((edad >0) || (edad == -1)) repetir //validación del centinela (que sea dato valido o centinela)
Escribir "Digite la edad o -1. para detener " //mensaje de datos validos o valor para detener
Leer edad //lectura del dato centinela
{ Fin del Ciclo validación variable centinela}
Si edad != -1 //entrará todo aquel valor que sea válido y diferente del valor centinela
entonces
{ Repetir el Cuerpo del Ciclo} // validar entradas, Acciones, procesos y salidas iterativas
{ Fin de la Condicional de Evaluación datos validos }
{ Fin del Ciclo Principal}
//Acciones Posteriores al ciclo principal como impresiones sumarizadas
…
Ejemplo No. 10. El mismo ejemplo 9 solo que aplicando centinela
Entrada de datos Salida de datos
 II. Estatura de cada persona  Cantidad de personas femenino arriba de 1.5 mts
 Genero de cada persona y Variable de  Cantidad de personas masculino arriba de 1.65
control centinela con valor z. detener mts
 Promedio general de estaturas
 Estatura y género de la persona más alta
 Estatura y género de la persona más baja
Página 51 de 73

cantF_150 Entero Cantidad de personas femenino de estatura mayor a 1.5 mts vi=0 vf=? vc=1
cantM_165 Entero Cantidad de personas masculino de estatura mayor a 1.65 mts vi=0 vf=? vc=1
promEst Real Promedio de estaturas general de todo el grupo
mayorEst Real Estatura mayor del grupo
mayorGen Alfanumérico Género de la estatura mayor
menorEst Real Estatura menor del grupo
menorGen Alfanumérico Género de la estatura menor
Variables:
estatura Real Estatura de las persona
genero alfanumérico Género de la persona ‘f’. femenino o ‘m’. masculino. Además variable de control de ciclo z.
detiene el ingreso de datos
Constantes: No se utilizará
c. Restricciones: estatura >= 1 && estatura <=2.5
genero==’f’ || genero == ‘m’
d. Proceso:
contPer=0 //Contador de personas se inicia a cero
cantF_150=0//Contadores de genero de inicializa a cero
cantM_165=0
sumaEst=0 // el acumulador se inicia en cero
mayorEst=0
mayorGen=’ ’
menorEst=0
menorGen=’ ’
genero = 'f'
Mientras (genero != 'z') repetir
genero = 'w'
Mientras (!(genero == 'f'|| genero == 'm'|| genero == 'z')) repetir
Validar genero
¿Si genero != 'z'?
Si: Validar edad
¿Si genero es:?
‘f’ : ¿Es (estatura > 1.50)?
Si: cantF_150++
‘m’: ¿Es (estatura > 1.65)?
Si: cantM_165++
¿Es estatura > mayorEst?
Si: mayorEst=estatura
mayorGen=genero
No: menorEst=estatura
menorGen=genero
contPer++
sumaEst += est
promEst=sumEst/contPer
Imprimir cantF_150 , cantM_165, promEst, mayores, mayorGen, menorEst, menorGen
Página 52 de 73
contPer entero Contador de personas vi=0 vf=? vc=1
sumaEst Real Suma de las estaturas de las personas vi=0 vf=? vc=estatura
 LeerEstatura Lee y valida la estatura ingresa

 Imprimir Devuelve en pantalla el mensaje recibido más la variable a mostrar
Ejemplo10
Program
Main
LeerEstatura Imprimir

Pseudocódigo
Método: main Acceso: Público Estático: Sí
{Invoca el modulo LeerGenero y LeerEstatura , donde Lee edad y estatura de personas adultas junto con su género,
la estatura debe estar entre 1 mts y 2.5 mts género femenino por arriba de 1.50 mts y la cantidad de personas del
género masculino por arriba de 1.65 mts.}
{ contPer , cantF_150 , cantM_165 , sumaEst , mayorEst , menorEst

son acumuladores de cada clase son variables de tipo entero, y prod es variable de proceso que representa el
contador de clase, de tipo entero }
1. Hacer contPer = 0, cantF_150 = 0, cantM_165 = 0, sumaEst = 0, mayorEst = 1.0, menorEst = 2.5

2. Hacer menorGen = ' ', mayorGen = ' '
3. Hacer genero = 'f'
4. Mientras (genero != 'z') Repetir
Hacer genero = 'w'
4.1 Mientras (!(genero == 'f'|| genero == 'm'|| genero == 'z')) Repetir
Escribir "Digite el género f. femenino, m. masculino o z. para detener "
Leer genero
{ Fin del Ciclo paso 4.1 }
Página 53 de 73
4.2 Si genero != 'z'
entonces
' Hacer estatura = LeerEstatura()
4.2.1. Si (genero) igual
'f': Si (estatura > 1.5) entonces
Hacer cantF_150++
'm': (estatura > 1.65) entonces
Hacer cantM_165++
{ Fin del condicional paso 4.2.1 }
4.2.2 Si (estatura > mayorEst) entonces
Hacer mayorEst=estatura
Hacer mayorGen=genero
Sino
Hacer menorEst=estatura
Hacer menorGen=genero
{ Fin del condicional paso 4.2.2 }
Hacer contPer++
Hacer sumaEst += estatura
{ Fin de Condicional paso 4.2 }
5. { Fin del Ciclo paso 4 }
6. Hacer promEst = sumaEst / contPer
7. Imprimir("Cantidad de femenino > 1.50 mts: ", cantF_150)
8. Imprimir("Cantidad de masculino > 1.65 mts: ", cantM_165);
9. Imprimir("Promedio de estatura en mts:", promEst);
10. Imprimir("Estatura mayor mts:", mayorEst);
11. Imprimir("Genero de estatura mayor : ", mayorGen);
12. Imprimir("\Estatura menor mts: ", menorEst);
13. Imprimir("\Genero de estura menor: ", menorGen);
Método: LeerEstatura Acceso: Público Estático: Sí
{ Debe pedir la estatura y validar que la ingresada sea correcta }

{ est es una variable de tipo real, y deben ser positivo entre 1 y 2.5 }
1. Escribir " Ingrese la estatura de la persona "

2. Leer est
3. Mientras (est < 1 || est > 2.5) Repetir
Escribir " Error estatura debe ser mayor a 1 y menor que 2.5"
Escribir " Ingrese la estatura de la persona "
Leer est
5. Retornar est
Método: Imprimir Acceso: Público Estático: Sí
{ Debe recibir los parámetros enviados desde el modulo principal, para imprimir resultados y mensaje }
1. Recibir msg, var

2. Escribir msg, var
IV. Codificación.
Página 54 de 73
using System;
namespace Ejemplo10
{
class Program
{
{
//Definicion de variables de entrada
double estatura;
char genero;
//Definicion de variables de salida
int cantF_150, cantM_165;
char mayorGen, menorGen;
double mayorEst, menorEst, promEst;
//Variables de proceso
int contPer;
double sumaEst;
//Inicializacion de variables
contPer = 0; cantF_150 = 0; cantM_165 = 0; sumaEst = 0;
mayorEst = 1.0; //para determinar el mayor se inicia la variable con el valor menor posible
menorEst = 2.5; //para determinar el menor se inicia la variable con el valor mayor posible
menorGen = ' '; mayorGen = ' ';
genero = 'f';
while (genero != 'z')
{
genero = 'w';
while (!(genero == 'f'|| genero == 'm'|| genero == 'z'))//validación de centinela
{
Console.WriteLine("Digite genero f. femenino, m. masculino o z. para detener \n");
}
if (genero != 'z')
{
estatura = LeerEstatura();
switch (genero) //posibles casos de estaturas superiores

{
case 'f': if (estatura > 1.5)
cantF_150++;
break;
case 'm': if (estatura > 1.65)
cantM_165++;
break;
}
//la estatura y genero mayor

if (estatura > mayorEst)
{
mayorEst = estatura;
mayorGen = genero;
}
else
{
// la estatura y genero menor
menorEst = estatura;
menorGen = genero;
}
}
contPer++; //contador de personas
sumaEst += estatura; //suma de las estaturasa
Console.Clear();
}//finalizacion del ciclo principal
Página 55 de 73
//calculo de promedio
promEst = sumaEst / contPer;
Console.Clear();
//Impresiones de variable de salida
Imprimir("\nCantidad de femenino > 1.50 mts: {0} ", cantF_150);
Imprimir("\nCantidad de masculino > 1.65 mts: {0} ", cantM_165);
Imprimir("\nPromedio de estatura en mts: {0} ", promEst);
Imprimir("\nEstatura mayor mts: {0} ", mayorEst);
Imprimir("\n Genero de estatura mayor : {0} ", mayorGen);
Imprimir("\n Estatura menor mts: {0} ", menorEst);
Imprimir("\n Genero de estura menor: {0} ", menorGen);
Console.ReadLine();
}
private static double LeerEstatura() {
double est;
//lectura de la estatura de la persona
Console.WriteLine("Ingrese la estatura de la persona \n");
//validacion de la estatura
while (!(est >= 1 && est <= 2.5))
{
Console.WriteLine("\n Error estatura debe ser mayor a 1 y menor que 2.5");
Console.WriteLine("\n Ingrese la estatura de la persona \n");
}
return est;
}
private static void Imprimir(string msg, object var)

{
Console.WriteLine(msg,var);
}
}
}
Página 56 de 73
12. TECNICA PARA DETERMINAR EL VALOR MENOR/MAYOR Y DATOS ASOCIADOS
Mayor: es una variable que durante la ejecución de un ciclo almacena el valor mayor que se haya ingresado; el nombre de
la variable debe reflejar su contenido. El valor inicial para menor será el menor valor posible.
Menor: es una variable que durante la ejecución de un ciclo almacena el valor menor que se haya ingresado; el nombre de
la variable debe reflejar su contenido. El valor inicial para menor será el mayor valor posible.
Datos asociados: son datos que están relacionados a los valores ,mayor y/o menor de la serie de datos de entrada, en
otras palabras en una lectura iterativa, se leen en conjunto una serie de datos, como por ejemplo salario y categoría, como
variables de entrada y restricciones salaria >0 y categoría >=1 && categoría <=4,podría requerirse la categoría con mayor
salario, en dicho caso se busca el mayor salario y cuando se encuentra se almacena no solo el salario sino que también la
categoría a la cual pertenece dicho salario. Por todo lo anterior además de las variables para guardar menor y mayor se
necesitan de una o más variables para guardar datos asociados, para el caso del ejemplo se requieren usar
mayor_categoria para guardar dicho valor. IMPORTANTE: Cabe mencionar que en los ejercicios 8, 9 y 10, se aplica una
técnica para conocer cada uno de estos, pero que no es la única para determinar el mayor y menor y datos relacionados,
ya que existen otras variantes, las cuales no se cubren en esta guía.
Representación en Pseudo-Código - Pseudocódigo (Flujograma ver ANEXO 10)

siguiente simbología. En esta situación hay que aclarar que se declarará una variable extra, variable bandera como una variable de
proceso. Ejemplo en este apartado veremos el uso de la variable bandera en el proceso. Supóngase las variables de entrada
sal y cat, con restricciones sal > 0.00 && sal <3000.00 y cat >=1 && cat <=4, también una variable de un nombre bandera,
de tipo entero y restricción bandera ==1 || bandera=0
…
mayor_sal=0.0 //se asigna el valor más bajo al mayor valor
meyor_cat=0 //se asigna cualquier valor
menor_sal=3000.0 // se asigna el valor inicial más alto al menor
menor_cat=0 //se asigna cualquier valor
bandera=1//a la variable bandera se le asigna el valor inicial que corresponde al valor cierto
Mientras (bandera ==1) repetir // la condición será que la variable bandera sea igual al valor cierto
Validar sal
Validar cat
{ Repetir el Cuerpo del Ciclo} //Cuerpo del Ciclo, validar entrada, Acciones, procesos y salidas iterativos
Si sal > mayor_sal? entonces IMPORTANTE: para determinar cuál es el valor mayor se usa
mayor_sal =sal una estructura selectiva simple y se pregunta si la variable de
mayor_cat=cat entrada sal es mayor que la variable el mayor_sal si eso da
Si sal < menor_sal entonces cierto se hace el cambio, de lo contrario se mantiene el valor
menor_sal =sal almacenado. Para determinar el menor el proceso es similar con
menor_cat=cat la diferencia que se usa el signo contrario, o sea menor que.
Escribir "otro dato? 1. Si o 0. No" //Mensaje de entrada
Leer bandera //solicitud de continuar o parar
Mientras (bandera ==1|| bandera ==0) repetir //validación de bandera
Escribir "Error, Digite 1. Si o 0. No"
Escribir "otro dato? 1. Si o 0. No" Observe: que una vez que se encuentra un valor mayor o un
Leer bandera valor menor, además de hacer el cambio o reemplazo de dicho
{ Fin del Ciclo validación Bandera} valor en la variable correspondiente, se realiza el cambio del valor
{ Fin del Ciclo Principal} asociado en las variables asociadas, en este caso el valor de la
//Acciones Posteriores al ciclo principal categoría que poseen el salario mayor y/o menor.
...
Página 57 de 73
13. ANEXOS
Anexos 1 – A Anexos 1 - B
Flujograma Ejemplo 1 (sin modularidad) Flujograma Ejemplo 1 (con modularidad)
Inicio Inicio
num = 1
Cua tos ú e os
uie e i p i i
Cua tos ú e os
uie e i p i i
n
cantNum
No n>0 Si
num = 1
imprimirEnteros(cantNum , num)
E o e
dato Nu e o E te o
Positivo. ,n
Fin
Inicio imprimirEnteros(cantNum ,
num)
num <= n
No cantNum > 0 Si
Si
Nu e o E te o
num E o e Positivo. ,cnrNum
dato
num = num + 1
no num <= n
Fin
Si
num
num = num + 1
Fin imprimirEnteros(cantNum ,
Retornar num
num)
Página 58 de 73
Anexo 2
Flujograma Ejemplo 2 (con modularidad)
Inicio validarClase(prod) Inicio imprimir(opt, nor, def)
Digite la lase Calidad

del p odu to Opti a opt
Calidad No al
nor
clase
Caldiad
defi ie te def
clase <1 || clase > 3 NO
SI
Retornarnor, def)
Fin imprimir(opt,
Esa lase o
existe, intente de
uevo
clase
Retornar
Fin Retornarclase
clase
Página 59 de 73
Anexo 3
Inicio Inicio validarEntero ( i ) Iniciar

impPareImpares(nPar,
toPar, toImp)
nPar = 0
Digite el dato
toPar = 0 pPares = toPar/nPar
toImp = 0
“u a de i pa es
numEntero
= ,toImp
i=1
numEntero < 0 P o edio de pa es

= ,pPares
i <= 25
SI
Iniciar
Retornar
numEntero = Digite el dato toPar, toImp)
validarEntero( i ) ueva e te
NO num%2 == 0 SI
numEntero
toImp+=num nPar++
No
toPar+=num
FinRetornar
RetornarnumEntero
numEntero
i ++
toPar, toImp)
Fin
Página 60 de 73
Anexo 4
Inicio Inicia
Inicia validarEntero()
generarSerie(numEntero, k)
serio = 0
¿Cuá tos
Mientras
terminos?
(k<=n)
k=1
ter = 1/k
numEntero
numEntero = validarN()
serie += ter
Mientras
(n<=0)
k ++
serie = generarSerie(numeroEntero , k)
De e se u u e o
positivo
Retornar serie
El esultado de la Fin retorna serie
serie es: ,serie
numEntero
Fin
Retornar
Fin retorn numEntero
numEntero
Página 61 de 73
Anexo 5
Inicio
Inicio
validarSexo()
a =1
suma=0
Sexo 1 masc. y
hApro=0 2 feme
mRep=0
sexo
a <= 8
Mientras
sexo !=1 && sexo != 2
su1 = 0
Sexo 1 masc. y
e =1
2 feme
nom
sexo
Mientras
(e<=5)
nota = validarNota()
Retornar sexo
su1 = su1 + nota
e++
Inicio
validarNota()
nFin=su1/5
Digite la ota
Suma += nfin del estudia te
sexo = validarSexo()
nom
NO sexo == 1
SI
Mientras
nota < 0 || nota > 10
nFin < 6.0 nFin>6.0

SI
NO
SI
NO De e se >=0
y <=10
mRep++ hApro++
Nota del
estudia te
A, nom, nFin
nota
a++
Retornar nota
sexo = validarSexo()
Página 62 de 73
Anexo 6
Inicio Iniciar
ImprimirSuma(li,ls)
Digite los li ites i fe io

y supe io
sum = 0
li, ls j=li, ls, 1
NO sum = sum +j
li > ls
SI
La su a de e te os
El p i e li ite de e se
es: su
e o
Retornar
Fin
ImprimirSuma(li,ls)
li, ls
ImprimirSuma(li,ls)
Fin
Página 63 de 73
Anexo 7
Inicio
Iniciar ValidarNota()
mayor = 0
reo =0 I t oduz a la ota
apr = 0
nota
suma = 0
Mientras
Nota < 0 || nota > 10
La ota de e esta
entre 0 y 10
i = 1, 25, 1
nota
Digite el o e
del alu o
Imprimir(suma,mayor,apr,rep)
Retornar nota
nom
Fin
Iniciar
Imprimir(suma,mayor,a
nota=ValidarNota() pr,rep)
suma = suma + nota prom = suma/25
nom, nota La ota p o edio

del grupo es: , prom
Nota >= 6 Nota ayo del

g upo , mayor
rep = rep +1 apr = apr +1

Nu e o de
ap o ados , apr
nota > mayor Nu e o de

ep o ados ,rep
Mayor = nota
Fin
Retornar
pr,rep)
Página 64 de 73
Anexo 8
Flujograma Ejemplo 8 (con modularidad) - Do WHILE
Inicio
Iniciar ValidarNota()
mayor = 0
reo =0
I t oduz a la ota
apr = 0
suma = 0 nota
i=1 Mientras
Nota < 0 || nota > 10
La ota de e esta
Digite el o e entre 0 y 10
del alu o
nota
nom
nota=ValidarNota()
Retornar nota
suma = suma + nota
nom, nota Iniciar

pr,rep)
Nota >= 6
prom = suma/25
rep = rep +1 apr = apr +1

La ota p o edio
del grupo es: , prom
nota > mayor

Nota ayo del
g upo , mayor
Mayor = nota
Nu e o de
ap o ados , apr
i++
Nu e o de
ep o ados ,rep
Verdadero i <= 25
Falso
Fin
Imprimir(suma,mayor,apr,rep) Imprimir(suma,mayor,a
pr,rep)
Fin
Página 65 de 73
Anexo 9
Estas acciones pueden ser asignación
Flujograma Bandera - Mientras de valores iníciales para contadores,
acumuladores, mayores y menores
El ciclo controlado por bandera debe

repetirse mientras el valor de la variable Asignamos el valor inicial de
sea igual a 1, ósea valor “cierto” cierto a la variable bandera, en
este caso es 1.
Cuerpo del ciclo incluye las

lecturas, validaciones, cálculos,
procesos, decisiones y salidas
Al igual que las iterativas
variables de entrada
propias de la solución,
las variables bandera
deben ser validadas. Mensaje de entrada
Leer la variable
Si la restricción de la variable
bandera no se cumple, se repite
el proceso de mensaje de error,
entrada y la lectura
Página 66 de 73
Anexo 10
Flujograma Bandera - valor mayor y menor
Inicialización de variables para

mayor/menor y datos asociados
Asignamos el valor inicial de cierto

a la variable bandera, en este caso
es 1
Observe: como se
hace uso de la Cuerpo del ciclo, incluye las
estructura selectiva lecturas, validaciones, cálculos,
simple para procesos, decisiones y salidas
iterativas
determinar el valor
menor/mayor y
Determina el mayor y asociado
asociados
Determina el menor y
asociado
Solo si el salario actual es menor se

hace el intercambio de lo contrario se
mantienen los valores anteriores en
las variables. Similar ocurre con el
mayor.
Página 67 de 73
Anexo 11
Ejemplo No.11(sin modularidad)
Se tiene un grupo de números enteros positivos, pero se desconoce cuántos son, diseñe un algoritmo que imprima:
a) Cuántos números forman el grupo de datos.
b) El promedio de los números pares.
c) Cuántos son los impares.
d) Cuántas veces se repite el número cinco.
El primer dato debe ser 10.
I. Planteamiento del Problema.

datos Entero Representa el número total de datos. Contador vi =0; vc= 1 vf =?
prom_p Real Representa el promedio de los números pares
cinco Entero Almacena el número de veces que se repite el número cinco. Contador vi=0
vc=1 vf=?
imp Entero Almacena número de datos impares. Contador vi=0 vc=1 vf=?

Variables:
num Entero Almacena cada uno de los números del grupo de datos, solo que
inicialmente se le asigna el valor de 10, luego se lee
Constantes: No se utilizan.
c. Restricciones: num > 0 y se utilizará como centinela o condición de fin de datos
d. Proceso:
 Vamos a leer los datos uno a uno y los vamos a ir contando, para saber cuántos leímos en total; vamos a parar
de leer cuando tengamos un dato negativo
 Con cada dato leído se verificará si es par, y en tal caso se acumulará (sum_p) con todos los pares que aparezcan,
para después calcular el promedio de pares (prom_p),
 En caso de que el dato leído es impar y se lleva un conteo de ellos (imp). Además, si el dato verificaremos que sea
igual a 5 para contarlos.
 Para calcular el número de pares, se debe restar el número de impares del total de datos leídos.
Página 68 de 73
sum_p Entero Acumula los datos pares: vi=0 vc=num vf=?
pares Entero Cuenta la cantidad de datos pares vi=0 vc=1 vf=?
III. Diseño de la solución:

Pseudocódigo
{Se tiene un grupo de números enteros positivos, pero se desconoce cuántos son, diseñe un algoritmo que imprima:
a. Cuántos números forman el grupo de datos.
b. El promedio de los números pares.
c. Cuántos son los impares.
d. Cuántas veces se repite el número cinco.
El primer dato debe ser 10.}
{datos, cinco, imp son variables tipo entera, deben ser positivas, imp es variable del tipo real, debe ser positiva , sumP y
pares son variables enterar y de proceso}
1. Hacer datos = 0, sumpP = 0, cinco = 0, imp= 0,
2. Hacer num = 10
3. Hacer
4. Hacer datos = datos +1
4.1 Si num % 2 == 0 entonces
Hacer sumP = sumP + num
sino
Hacer imp++
4.2 si num == 5 entonces
Hacer cinco = cinco +1
4.3 {Fin de ciclo de paso 3.2}
4.4 {Fin de ciclo del paso 3.1}
Escribir “Digite el número del grupo”
Leer num
5. Repetir mientras num <= 0
7. Hacer pares = datos – imp
8. Hacer promP = sumP/pares
9. Escribir datos, promP, cinco, imp
Página 69 de 73
Página 70 de 73
Anexo 12
Ejemplo No. 12 (sin modularidad)
Diseñe un programa en C que imprima los valores de la función f(x)= x3, a partir de un valor real inicial de x, hasta un límite final, con
incrementos de 0.25. El programa debe de imprimir tanto el valor de x como el de f(x).

x Real Cada uno de los valores que toma x. Variable tipo
contador.
y Real El valor de la función para cada valor de x

Variables:
vi Real El valor inicial de x
vf Real El valor final de x
Constantes: El incremento de x en 0.25
c. Restricciones:
El valor final debe ser mayor que el valor inicial
vi < vf
d. Proceso:
Lo que vamos a hacer es calcular y=pow(x,3); x tomará distintos valores siendo el primero vi, el último vf y el valor de cambio o
incremento es de 0.25, de donde se observa que x es
una variable tipo contador. Por lo tanto el cálculo se repite mientras x<=vf:
Los variables vi y vf se deben leer y validar.

No se Utilizan.
Página 71 de 73
III. Diseño de la solución
Pseudocódigo
{ El programa debe imprir los valores de la función f(x)= x3, a partir de un valor real inicial de x, hasta un límite final, con
incrementos de 0.25. El programa debe de imprimir tanto el valor de x como el de f(x).}
{x, y son variables del tipo real, deben ser positivo }
1. Escribir “Digite el valor inicial y final de X”

2. Leer vi, vf
3. Mientras vi >= vf Repetir
Escribir “El valor inicial debe ser menor que el final”
Leer vi , vf
5. Hacer x=vi
6. Mientras x <= vf Repetir
Hacer y=pow(x,3)
Escribir x,y
Hacer x += 0.25
7. {Fin del cilco del paso 6}
Flujograma
Página 72 de 73
IV. Codificación de la Solución.
/*Programa que calcula f(x) */
using System;
namespace CalculaF_x_
{
class Program
{
{
float vi, vf;
double x,y;
String[] tokens;
Console.WriteLine("Digite el valor inicial y final de x");

tokens= Console.ReadLine().Split();
//Parse elemento 0
vi = int.Parse(tokens[0]);
//parse elemento 1
vf = int.Parse(tokens[1]);
while (vi >= vf) //validacion de datos

{
Console.WriteLine("El valor inicial debe ser menor que el final");
//Parse elemento 0
vi = int.Parse(tokens[0]);
//parse elemento 1
vf = int.Parse(tokens[1]);
}
x = vi;
Console.WriteLine(" x f(x)");//Encabezado de la impresion
while (x <= vf)
{
y = Math.Pow(x, 3);
Console.WriteLine(" {0:0.00} {1:0.00}",x,y);
// printf \n \t % .2f \t \t % 0.2f \n , x, y ;
x += 0.25;
}
}
}
}
Página 73 de 73

Unidad V - Ciclos - V3

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Unidad V - Ciclos - V3

Cargado por

Copyright:

Formatos disponibles

UNIVERSIDAD DE EL SALVADOR

FACULTAD DE INGENIERÍA Y ARQUITECTURA

3. ESTRUCTURA DE ENTRADA CONDICIONADA - ESTRUCTURA MIENTRAS

Funcionamiento de la Estructura Mientras

Dentro del cuerpo del ciclo debe existir alguna

Representación Gráfica – Diseño de la Solución

Representación en Pseudo-Código – Diseño de la Solución

I. Planteamiento del problema.

c. Restricciones: cantNum >0

e. Variables de Proceso: No se ha utilizado.

III. Diseño de la solución.

if (cantNum > 0)//validacion del numero ingresado

Console.Write("Press any key to continue . . . ");

I. Planteamiento General del problema

ENTRADA DE DATOS SALIDA DE DATOS

 Cantidad de números a imprimir  Cada uno de los números

II. Análisis / Diseño Jerárquico Modular

III. Análisis / Diseño Jerárquico Modular Diseño de la Solución

{ imprime enteros hasta que num < cantNum }

1. Recibir cantNum, num.

Método: Main Acceso: Público Estático: Sí

{ imprime enteros hasta que num < cantNum }

Console.Write("Press any key to continue . . . ");

public static void imprimirEnteros(int cantNum, int num)

if (cantNum > 0)//validacion del numero ingresado

4. VALIDACIÓN DE DATOS CON CICLO MIENTRAS

En esta parte de algoritmo no

Note también que en la

Console.Write("Press any key to continue . . . ");

// estructura mientras, num sea menor que numero ingresado

5. OPERADORES ADICIONALES DEL LENGUAJE C#

5.1 Operadores de asignación:

a = 300; b = a; x = 2 +a; total = sqrt(2*x+3/x-(5%2+b));

Símbolo Sentencia Abreviada Sentencia No Abreviada Descripción

5.2 Operadores de Incremento – Decremento.

Console.Write("Press any key to continue . . . ");

public static void imprimirEnteros(int cantNum, int num)

// estructura mientras, num sea menor que numero ingresado

5.3 Jerarquía de Todos los Operadores de C#

Operador Prioridad Asociatividad

I. Planteamiento General del problema

II. Análisis / Diseño Jerárquico Modular

a. Definición de Variables de Salida.

b. Definición de datos de Entrada.

// Aquí se lee y valida clase

Repetir 1 opt++ / / opt=opt+1)

e. Definición de Variables de Proceso:

III. Análisis / Diseño Jerárquico Modular Diseño de la Solución

Método: Main Acceso: Público Estático: Sí

1. Hacer prod = 1, opt = 0, nor = 0, def = 0

Método: ImprimirClase Acceso: Público Estático: Sí

{ Imprime total de las clasificaciones de productos como optima, normal, deficiente }

//Definición del metodo impresion

Console.WriteLine("Digite la clase del producto(debe ser 1.Optimo ,2.Normal ,3.Deficiente): ");

while (clase < 1 || clase > 3)

public static void Imprimir(int opt, int nor, int def)

I. Planteamiento General del problema

II. Análisis / Diseño Jerárquico Modular

a. Definición de Variables de Salida

b. Definición de Datos de Entrada.

Constantes: Se utiliza el valor fijo 25.

e. Definición de Variables de Proceso

2.2 Diseño Jerárquico Modular