9 - Estructura repetitiva while

Hasta ahora hemos empleado estructuras SECUENCIALES y

CONDICIONALES. Existe otro tipo de estructuras tan importantes como las
anteriores que son las estructuras REPETITIVAS.
Una estructura repetitiva permite ejecutar una instrucción o un conjunto de
instrucciones varias veces.
Una ejecución repetitiva de sentencias se caracteriza por:
- La o las sentencias que se repiten.
- El test o prueba de condición antes de cada repetición, que motivará que se
repitan o no las sentencias.
Estructura repetitiva while.
Representación gráfica de la estructura while:

No debemos confundir la representación gráfica de la estructura repetitiva while

(Mientras) con la estructura condicional if (Si)
Funcionamiento: En primer lugar se verifica la condición, si la misma resulta
verdadera se ejecutan las operaciones que indicamos por la rama del
Verdadero.
A la rama del verdadero la graficamos en la parte inferior de la condición. Una
línea al final del bloque de repetición la conecta con la parte superior de la
estructura repetitiva.
En caso que la condición sea Falsa continúa por la rama del Falso y sale de la
estructura repetitiva para continuar con la ejecución del algoritmo.
El bloque se repite MIENTRAS la condición sea Verdadera.
Importante: Si la condición siempre retorna verdadero estamos en presencia
de un ciclo repetitivo infinito. Dicha situación es un error de programación,
nunca finalizará el programa.

Problema 1:

Realizar un programa que imprima en pantalla los números del 1 al 100.

Sin conocer las estructuras repetitivas podemos resolver el problema
empleando una estructura secuencial. Inicializamos una variable con el valor 1,
luego imprimimos la variable, incrementamos nuevamente la variable y así
sucesivamente.

Diagrama de flujo:

Si continuamos con el diagrama no nos alcanzarían las próximas 5 páginas

para finalizarlo. Emplear una estructura secuencial para resolver este problema
produce un diagrama de flujo y un programa en C# muy largo.
Ahora veamos la solución empleando una estructura repetitiva while:
Es muy importante analizar este diagrama:
La primera operación inicializa la variable x en 1, seguidamente comienza la
estructura repetitiva while y disponemos la siguiente condición ( x <= 100), se
lee MIENTRAS la variable x sea menor o igual a 100.
Al ejecutarse la condición retorna VERDADERO porque el contenido de x (1)
es menor o igual a 100. Al ser la condición verdadera se ejecuta el bloque de
instrucciones que contiene la estructura while. El bloque de instrucciones
contiene una salida y una operación.
Se imprime el contenido de x, y seguidamente se incrementa la variable x en
uno.
La operación x=x + 1 se lee como "en la variable x se guarda el contenido de x
más 1". Es decir, si x contiene 1 luego de ejecutarse esta operación se
almacenará en x un 2.
Al finalizar el bloque de instrucciones que contiene la estructura repetitiva se
verifica nuevamente la condición de la estructura repetitiva y se repite el
proceso explicado anteriormente.
Mientras la condición retorne verdadero se ejecuta el bloque de instrucciones;
al retornar falso la verificación de la condición se sale de la estructura repetitiva
y continua el algoritmo, en este caso finaliza el programa.
Lo más difícil es la definición de la condición de la estructura while y qué bloque
de instrucciones se van a repetir. Observar que si, por ejemplo, disponemos la
condición x >=100 ( si x es mayor o igual a 100) no provoca ningún error
sintáctico pero estamos en presencia de un error lógico porque al evaluarse por
primera vez la condición retorna falso y no se ejecuta el bloque de
instrucciones que queríamos repetir 100 veces.
No existe una RECETA para definir una condición de una estructura repetitiva,
sino que se logra con una práctica continua solucionando problemas.
Una vez planteado el diagrama debemos verificar si el mismo es una solución
válida al problema (en este caso se debe imprimir los números del 1 al 100 en
pantalla), para ello podemos hacer un seguimiento del flujo del diagrama y los
valores que toman las variables a lo largo de la ejecución:
x
1
2
3
4
.
.
100
101 Cuando x vale 101 la condición de la estructura
repetitiva retorna falso,
en este caso finaliza el diagrama.
Importante: Podemos observar que el bloque repetitivo puede no ejecutarse
ninguna vez si la condición retorna falso la primera vez.
La variable x debe estar inicializada con algún valor antes que se ejecute la
operación x=x + 1 en caso de no estar inicializada aparece un error de
compilación.

Programa:

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaWhile1
{
class Program
{
static void Main(string[] args)
{
int x;
x = 1;
while (x <= 100)
{
[Link](x);
[Link](" - ");
x = x + 1;
}
[Link]();
}
}
}
Recordemos que un problema no estará 100% solucionado si no hacemos el
programa en C# que muestre los resultados buscados.
Probemos algunas modificaciones de este programa y veamos que cambios se
deberían hacer para:
1 - Imprimir los números del 1 al 500.
2 - Imprimir los números del 50 al 100.
3 - Imprimir los números del -50 al 0.
4 - Imprimir los números del 2 al 100 pero de 2 en 2
(2,4,6,8 ....100).
Respuestas:
1 - Debemos cambiar la condición del while con x<=500.
2 - Debemos inicializar x con el valor 50.
3 - Inicializar x con el valor -50 y fijar la condición x<=0.
4 - Inicializar a x con el valor 2 y dentro del bloque repetitivo
incrementar a x en 2
( x = x + 2 )

Problema 2:

Escribir un programa que solicite la carga de un valor positivo y nos muestre

desde 1 hasta el valor ingresado de uno en uno.
Ejemplo: Si ingresamos 30 se debe mostrar en pantalla los números del 1 al
30.
Es de FUNDAMENTAL importancia analizar los diagramas de flujo y la
posterior codificación en C# de los siguientes problemas, en varios problemas
se presentan otras situaciones no vistas en el ejercicio anterior.

Diagrama de flujo:
Podemos observar que se ingresa por teclado la variable n. El operador puede
cargar cualquier valor.
Si el operador carga 10 el bloque repetitivo se ejecutará 10 veces, ya que la
condición es ?Mientras x<=n ?, es decir ?mientras x sea menor o igual a 10?;
pues x comienza en uno y se incrementa en uno cada vez que se ejecuta el
bloque repetitivo.
A la prueba del diagrama la podemos realizar dándole valores a las variables;
por ejemplo, si ingresamos 5 el seguimiento es el siguiente:
n x
5 1 (Se imprime el contenido de x)
2 " "
3 " "
4 " "
5 " "
6 (Sale del while porque 6 no es menor o igual a 5)

Programa:

using System;
using [Link];
using [Link];
using [Link];
namespace EstructuraRepetitivaWhile2
{
class Program
{
static void Main(string[] args)
{
int n,x;
string linea;
[Link]("Ingrese el valor
final:");
linea=[Link]();
n=[Link](linea);
x=1;
while (x<=n)
{
[Link](x);
[Link](" - ");
x = x + 1;
}
[Link]();
}
}
}
Los nombres de las variables n y x pueden ser palabras o letras (como en este
caso)
La variable x recibe el nombre de CONTADOR. Un contador es un tipo especial
de variable que se incrementa o decrementa con valores constantes durante la
ejecución del programa.
El contador x nos indica en cada momento la cantidad de valores impresos en
pantalla.

Problema 3:

Desarrollar un programa que permita la carga de 10 valores por teclado y nos

muestre posteriormente la suma de los valores ingresados y su promedio.

Diagrama de flujo:
En este problema, a semejanza de los anteriores, llevamos un CONTADOR
llamado x que nos sirve para contar las vueltas que debe repetir el while.
También aparece el concepto de ACUMULADOR (un acumulador es un tipo
especial de variable que se incrementa o decrementa con valores variables
durante la ejecución del programa)
Hemos dado el nombre de suma a nuestro acumulador. Cada ciclo que se
repita la estructura repetitiva, la variable suma se incrementa con el contenido
ingresado en la variable valor.
La prueba del diagrama se realiza dándole valores a las variables:
valor suma x promedio
0 0
(Antes de entrar a la estructura repetitiva estos son los valores).
5 5 1
16 21 2
7 28 3
10 38 4
2 40 5
20 60 6
5 65 7
5 70 8
10 80 9
2 82 10
8 90 11
9

Este es un seguimiento del diagrama planteado. Los números que toma la

variable valor dependerá de qué cifras cargue el operador durante la ejecución
del programa.
El promedio se calcula al salir de la estructura repetitiva (es decir primero
sumamos los 10 valores ingresados y luego los dividimos por 10)
Hay que tener en cuenta que cuando en la variable valor se carga el primer
valor (en este ejemplo 5) al cargarse el segundo valor (16) el valor anterior 5 se
pierde, por ello la necesidad de ir almacenando en la variable suma los valores
ingresados.

Programa:

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaWhile3
{
class Program
{
static void Main(string[] args)
{
int x,suma,valor,promedio;
string linea;
x=1;
suma=0;
while (x<=10)
{
[Link]("Ingrese un
valor:");
linea = [Link]();
 valor=[Link](linea);
suma=suma+valor;
x=x+1;
}
promedio=suma/10;
[Link]("La suma de los 10
valores es:");
[Link](suma);
[Link]("El promedio es:");
[Link](promedio);
[Link]();
}
}
}

Problema 4:

Una planta que fabrica perfiles de hierro posee un lote de n piezas.

Confeccionar un programa que pida ingresar por teclado la cantidad de piezas
a procesar y luego ingrese la longitud de cada perfil; sabiendo que la pieza
cuya longitud esté comprendida en el rango de 1,20 y 1,30 son aptas. Imprimir
por pantalla la cantidad de piezas aptas que hay en el lote.

Diagrama de flujo:
Podemos observar que dentro de una estructura repetitiva puede haber
estructuras condicionales (inclusive puede haber otras estructuras repetitivas
que veremos más adelante)
En este problema hay que cargar inicialmente la cantidad de piezas a ingresar (
n ), seguidamente se cargan n valores de largos de piezas.
Cada vez que ingresamos un largo de pieza (largo) verificamos si es una
medida correcta (debe estar entre 1.20 y 1.30 el largo para que sea correcta),
en caso de ser correcta la CONTAMOS (incrementamos la variable cantidad en
1)
Al contador cantidad lo inicializamos en cero porque inicialmente no se ha
cargado ningún largo de medida.
Cuando salimos de la estructura repetitiva porque se han cargado n largos de
piezas mostramos por pantalla el contador cantidad (que representa la cantidad
de piezas aptas)
En este problema tenemos dos CONTADORES:
x (Cuenta la cantidad de piezas cargadas hasta el
momento)
cantidad (Cuenta los perfiles de hierro aptos)

Programa:

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaWhile4
{
class Program
{
static void Main(string[] args)
{
int x,cantidad,n;
float largo;
string linea;
x=1;
cantidad=0;
[Link]("Cuantas piezar
procesará:");
linea = [Link]();
n=[Link](linea);
while (x<=n)
{
[Link]("Ingrese la medida
de la pieza:");
linea = [Link]();
largo=[Link](linea);
if (largo>=1.20 && largo<=1.30)
{
cantidad = cantidad +1;
}
x=x + 1;
}
[Link]("La cantidad de piezas
aptas son:");
 [Link](cantidad);
[Link]();
}
}
}
Problemas propuestos
Ha llegado la parte fundamental, que es el momento donde uno desarrolla
individualmente un algoritmo para la resolución de problemas.
El tiempo a dedicar a esta sección EJERCICIOS PROPUESTOS debe ser
mucho mayor que el empleado a la sección de EJERCICIOS RESUELTOS.
La experiencia dice que debemos dedicar el 80% del tiempo a la resolución
individual de problemas y el otro 20% al análisis y codificación de problemas ya
resueltos por otras personas.
Es de vital importancia para llegar a ser un buen PROGRAMADOR poder
resolver problemas en forma individual.

1. Escribir un programa que solicite ingresar 10 notas de alumnos y nos

informe cuántos tienen notas mayores o iguales a 7 y cuántos menores.
2. Se ingresan un conjunto de n alturas de personas por teclado. Mostrar la
altura promedio de las personas.
3. En una empresa trabajan n empleados cuyos sueldos oscilan entre $100
y $500, realizar un programa que lea los sueldos que cobra cada
empleado e informe cuántos empleados cobran entre $100 y $300 y
cuántos cobran más de $300. Además el programa deberá informar el
importe que gasta la empresa en sueldos al personal.
4. Realizar un programa que imprima 25 términos de la serie 11 - 22 - 33 -
44, etc. (No se ingresan valores por teclado)
5. Mostrar los múltiplos de 8 hasta el valor 500. Debe aparecer en pantalla
8 - 16 - 24, etc.
6. Realizar un programa que permita cargar dos listas de 15 valores cada
una. Informar con un mensaje cual de las dos listas tiene un valor
acumulado mayor (mensajes "Lista 1 mayor", "Lista 2 mayor", "Listas
iguales")
Tener en cuenta que puede haber dos o más estructuras repetitivas en
un algoritmo.
7. Desarrollar un programa que permita cargar n números enteros y luego
nos informe cuántos valores fueron pares y cuántos impares.
Emplear el operador ?%? en la condición de la estructura condicional:
8. if (valor%2==0) //Si el if da verdadero luego es par.
using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaWhile5
{
class Program
{
static void Main(string[] args)
 {
int x,nota,conta1,conta2;
string linea;
x=1;
conta1=0;
conta2=0;
while (x<=10)
{
[Link]("Ingrese nota:");
linea = [Link]();
nota=[Link](linea);
if (nota>=7)
{
conta1=conta1 + 1;
}
else
{
conta2=conta2 + 1;
}
x=x + 1;
}
[Link]("Cantidad de alumnos con notas mayores o
iguales a 7:");
[Link](conta1);
[Link]("Cantidad de alumons con notas menores a
7:");
[Link](conta2);
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaWhile6
{
class Program
{
static void Main(string[] args)
{
int n,x;
float altura,suma,promedio;
string linea;
[Link]("Cuantas personas hay:");
linea = [Link]();
n=[Link](linea);
x=1;
suma=0;
while (x<=n)
{
[Link]("Ingrese la altura:");
linea = [Link]();
altura=[Link](linea);
suma=suma + altura;
 x=x + 1;
}
promedio=suma/n;
[Link]("Altura promedio:");
[Link](promedio);
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaWhile7
{
class Program
{
static void Main(string[] args)
{
int n,x,conta1,conta2;
float sueldo,gastos;
string linea;
[Link]("Cuantos empleados tiene la empresa:");
linea = [Link]();
n=[Link](linea);
x=1;
conta1=0;
conta2=0;
gastos=0;
while (x<=n) {
[Link]("Ingrese el sueldo del empleado:");
linea = [Link]();
sueldo=[Link](linea);
if (sueldo<=300) {
conta1=conta1 + 1;
} else {
conta2=conta2 + 1;
}
gastos=gastos+sueldo;
x=x + 1;
}
[Link]("Cantidad de empleados con sueldos entre 100
y 300:");
[Link](conta1);
[Link]("Cantidad de empleados con sueldos mayor a
300:");
[Link](conta2);
[Link]("Gastos total de la empresa en sueldos:");
[Link](gastos);
[Link]();
}
}
}
using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaWhile8
{
class Program
{
static void Main(string[] args)
{
int x,termino;
x=1;
termino=11;
while (x<=25)
{
[Link](termino);
[Link](" - ");
x=x + 1;
termino=termino + 11;
}
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaWhile9
{
class Program
{
static void Main(string[] args)
{
int mult8;
mult8=8;
while (mult8<=500)
{
[Link](mult8);
[Link](" - ");
mult8=mult8 + 8;
}
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaWhile10
{
class Program
{
static void Main(string[] args)
{
int valor,x,suma1,suma2;
string linea;
x=1;
suma1=0;
suma2=0;
[Link]("Primer lista");
while (x<=15)
{
[Link]("Ingrese valor:");
linea = [Link]();
valor=[Link](linea);
suma1=suma1 + valor;
x=x + 1;
}
[Link]("Segunda lista");
x=1;
while (x<=15)
{
[Link]("Ingrese valor:");
linea = [Link]();
valor=[Link](linea);
suma2=suma2 + valor;
x=x + 1;
}
if (suma1>suma2)
{
[Link]("Lista 1 mayor.");
}
else
{
if (suma2>suma1)
{
[Link]("Lista2 mayor.");
}
else
{
[Link]("Listas iguales.");
}
}
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];
namespace EstructuraRepetitivaWhile11
{
class Program
{
static void Main(string[] args)
{
int n,x,valor,pares,impares;
string linea;
x=1;
pares=0;
impares=0;
[Link]("Cuantos números ingresará:");
linea = [Link]();
n=[Link](linea);
while (x<=n) {
[Link]("Ingrese el valor:");
linea = [Link]();
valor = [Link](linea); ;
if (valor%2==0)
{
pares=pares + 1;
}
else
{
impares=impares + 1;
}
x=x + 1;
}
[Link]("Cantadad de pares:");
[Link](pares);
[Link]("Cantidad de impares:");
[Link](impares);
[Link]();
}
}
}

10 - Estructura repetitiva for

Cualquier problema que requiera una estructura repetitiva se puede resolver
empleando la estructura while. Pero hay otra estructura repetitiva cuyo planteo
es más sencillo en ciertas situaciones.
En general, la estructura for se usa en aquellas situaciones en las cuales
CONOCEMOS la cantidad de veces que queremos que se ejecute el bloque de
instrucciones. Ejemplo: cargar 10 números, ingresar 5 notas de alumnos, etc.
Conocemos de antemano la cantidad de veces que queremos que el bloque se
repita. Veremos, sin embargo, que en el lenguaje C# la estructura for puede
usarse en cualquier situación repetitiva, porque en última instancia no es otra
cosa que una estructura while generalizada.
Representación gráfica:
En su forma más típica y básica, esta estructura requiere una variable entera
que cumple la función de un CONTADOR de vueltas. En la sección indicada
como "inicialización contador", se suele colocar el nombre de la variable que
hará de contador, asignándole a dicha variable un valor inicial. En la sección de
"condición" se coloca la condición que deberá ser verdadera para que el ciclo
continúe (en caso de un falso, el ciclo se detendrá). Y finalmente, en la sección
de "incremento contador" se coloca una instrucción que permite modificar el
valor de la variable que hace de contador (para permitir que alguna vez la
condición sea falsa)
Cuando el ciclo comienza, antes de dar la primera vuelta, la variable del for
toma el valor indicado en la sección de de "inicialización contador".
Inmediatamente se verifica, en forma automática, si la condición es verdadera.
En caso de serlo se ejecuta el bloque de operaciones del ciclo, y al finalizar el
mismo se ejecuta la instrucción que se haya colocado en la tercer sección.
Seguidamente, se vuelve a controlar el valor de la condición, y así prosigue
hasta que dicha condición entregue un falso.
Si conocemos la cantidad de veces que se repite el bloque es muy sencillo
emplear un for, por ejemplo si queremo que se repita 50 veces el bloque de
instrucciones puede hacerse así:

La variable del for puede tener cualquier nombre. En este ejemplo se la ha

definido con el nombre f.
Analicemos el ejemplo:
- La variable f toma inicialmente el valor 1.
- Se controla automáticamente el valor de la condición: como f vale 1
y esto es menor
que 50, la condición da verdadero.
- Como la condición fue verdadera, se ejecutan la/s operación/es.
- Al finalizar de ejecutarlas, se retorna a la instrucción f++, por lo
que la
variable f se incrementa en uno.
- Se vuelve a controlar (automáticamente) si f es menor o igual a 50.
Como ahora su valor es 2, se ejecuta nuevamente el bloque de
instrucciones e
incrementa nuevamente la variable del for al terminar el mismo.
- El proceso se repetirá hasta que la variable f sea incrementada al
valor 51.
En este momento la condición será falsa, y el ciclo se detendrá.
La variable f PUEDE ser modificada dentro del bloque de operaciones del for,
aunque esto podría causar problemas de lógica si el programador es inexperto.
La variable f puede ser inicializada en cualquier valor y finalizar en cualquier
valor. Además, no es obligatorio que la instrucción de modificación sea un
incremento del tipo contador (f++).
Cualquier instrucción que modifique el valor de la variable es válida. Si por
ejemplo se escribe f=f+2 en lugar de f++, el valor de f será incrementado de a 2
en cada vuelta, y no de a 1. En este caso, esto significará que el ciclo no
efectuará las 50 vueltas sino sólo 25.

Problema 1:

Realizar un programa que imprima en pantalla los números del 1 al 100.

Diagrama de flujo:

Podemos observar y comparar con el problema realizado con el while. Con la

estructura while el CONTADOR x sirve para contar las vueltas. Con el for el
CONTADOR f cumple dicha función. 
Inicialmente f vale 1 y como no es superior a 100 se ejecuta el bloque,
imprimimos el contenido de f, al finalizar el bloque repetitivo se incrementa la
variable f en 1, como 2 no es superior a 100 se repite el bloque de
instrucciones.
Cuando la variable del for llega a 101 sale de la estructura repetitiva y continúa
la ejecución del algoritmo que se indica después del círculo.
La variable f (o como sea que se decida llamarla) debe estar definida como una
variable más.

Programa:
using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor1
{
class Program
{
static void Main(string[] args)
{
int f;
for(f=1;f<=100;f++)
{
[Link](f);
[Link]("-");
}
[Link]();
}
}
}

Problema 2:

: Desarrollar un programa que permita la carga de 10 valores por teclado y nos

muestre posteriormente la suma de los valores ingresados y su promedio. Este
problema ya lo desarrollamos, lo resolveremos empleando la estructura for.

Diagrama de flujo:
En este caso, a la variable del for (f) sólo se la requiere para que se repita el
bloque de instrucciones 10 veces.

Programa:

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor2
{
class Program
{
static void Main(string[] args)
 {
int suma,f,valor,promedio;
string linea;
suma=0;
for(f=1;f<=10;f++)
{
[Link]("Ingrese valor:");
linea=[Link]();
valor=[Link](linea);
suma=suma+valor;
}
[Link]("La suma es:");
[Link](suma);
promedio=suma/10;
[Link]("El promedio es:");
[Link](promedio);
[Link]();
}
}
}
El problema requiere que se carguen 10 valores y se sumen los mismos.
Tener en cuenta encerrar entre llaves bloque de instrucciones a repetir dentro
del for.
El promedio se calcula fuera del for luego de haber cargado los 10 valores.

Problema 3:

Escribir un programa que lea 10 notas de alumnos y nos informe cuántos

tienen notas mayores o iguales a 7 y cuántos menores.
Para resolver este problema se requieren tres contadores:
aprobados (Cuenta la cantidad de alumnos aprobados)
reprobados (Cuenta la cantidad de reprobados)
f (es el contador del for)
Dentro de la estructura repetitiva debemos hacer la carga de la variable nota y
verificar con una estructura condicional si el contenido de la variable nota es
mayor o igual a 7 para incrementar el contador aprobados, en caso de que la
condición retorne falso debemos incrementar la variable reprobados.

Diagrama de flujo:
Los contadores aprobados y reprobados deben imprimirse FUERA de la
estructura repetitiva.
Es fundamental inicializar los contadores aprobados y reprobados en cero
antes de entrar a la estructura for.
Importante: Un error común es inicializar los contadores dentro de la
estructura repetitiva. En caso de hacer esto los contadores se fijan en cero en
cada ciclo del for, por lo que al finalizar el for como máximo el contador puede
tener el valor 1.

Programa:

using System;
using [Link];
using [Link];
using [Link];
namespace EstructuraRepetitivaFor3
{
class Program
{
static void Main(string[] args)
{
int aprobados,reprobados,f,nota;
string linea;
aprobados=0;
reprobados=0;
for(f=1;f<=10;f++)
{
[Link]("Ingrese la
nota:");
linea = [Link]();
nota=[Link](linea);
if (nota>=7)
{
aprobados=aprobados+1;
}
else
{
reprobados=reprobados+1;
}
}
[Link]("Cantidad de
aprobados:");
[Link](aprobados);
[Link]("Cantidad de
reprobados:");
[Link](reprobados);
[Link]();
}
}
}

Problema 4:

Escribir un programa que lea 10 números enteros y luego muestre cuántos

valores ingresados fueron múltiplos de 3 y cuántos de 5. Debemos tener en
cuenta que hay números que son múltiplos de 3 y de 5 a la vez.
Diagrama de flujo:

Tengamos en cuenta que el operador matemático % retorna el resto de dividir

un valor por otro, en este caso: valor%3 retorna el resto de dividir el valor que
ingresamos por teclado, por tres.
Veamos: si ingresamos 6 el resto de dividirlo por 3 es 0, si ingresamos 12 el
resto de dividirlo por 3 es 0. Generalizando: cuando el resto de dividir por 3 al
valor que ingresamos por teclado es cero, se trata de un múltiplo de dicho
valor.
Ahora bien ¿por qué no hemos dispuesto una estructura if anidada? Porque
hay valores que son múltiplos de 3 y de 5 a la vez. Por lo tanto con if anidados
no podríamos analizar los dos casos.
Es importante darse cuenta cuando conviene emplear if anidados y cuando no
debe emplearse.

Programa:

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor4
{
class Program
{
static void Main(string[] args)
{
int mul3,mul5,valor,f;
string linea;
mul3=0;
mul5=0;
for(f=1;f<=10;f++)
{
[Link]("Ingrese un
valor:");
linea = [Link]();
valor=[Link](linea);
if (valor%3==0)
{
mul3=mul3+1;
}
if (valor%5==0)
{
mul5=mul5+1;
}
}
[Link]("Cantidad de valores
ingresados múltiplos de 3:");
[Link](mul3);
 [Link]("Cantidad de valores
ingresados múltiplos de 5:");
[Link](mul5);
[Link]();
}
}
}

Problema 5:

Escribir un programa que lea n números enteros y calcule la cantidad de

valores mayores o iguales a 1000.
Este tipo de problemas también se puede resolver empleando la estructura
repetitiva for. Lo primero que se hace es cargar una variable que indique la
cantidad de valores a ingresar. Dicha variable se carga antes de entrar a la
estructura repetitiva for.
La estructura for permite que el valor inicial o final dependa de una variable
cargada previamente por teclado.

Diagrama de flujo:
Tenemos un contador llamado cantidad y f que es el contador del for.
La variable entera n se carga previo al inicio del for, por lo que podemos fijar el
valor final del for con la variable n.
Por ejemplo si el operador carga 5 en n la estructura repetitiva for se ejecutará
5 veces.
La variable valor se ingresa dentro de la estructura repetitiva, y se verifica si el
valor de la misma es mayor o igual a 1000, en dicho caso se incrementa en uno
el contador cantidad.
Fuera de la estructura repetitiva imprimimos el contador cantidad que tiene
almacenado la cantidad de valores ingresados mayores o iguales a 1000.

Programa:

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor5
{
class Program
{
static void Main(string[] args)
{
int cantidad,n,f,valor;
string linea;
cantidad=0;
[Link]("Cuantos valores
ingresará:");
linea = [Link]();
n=[Link](linea);
for(f=1;f<=n;f++)
{
[Link]("Ingrese el
valor:");
linea = [Link]();
valor = [Link](linea);
if (valor>=1000)
{
cantidad=cantidad+1;
}
}
[Link]("La cantidad de
valores ingresados mayores o iguales a 1000
son:");
[Link](cantidad);
[Link]();
}
}
}
Problemas propuestos
Ha llegado nuevamente la parte fundamental, que es el momento donde uno
desarrolla individualmente un algoritmo para la resolución de un problema.

1. Confeccionar un programa que lea n pares de datos, cada par de datos

corresponde a la medida de la base y la altura de un triángulo. El
 programa deberá informar:
a) De cada triángulo la medida de su base, su altura y su superficie. 
b) La cantidad de triángulos cuya superficie es mayor a 12.
2. Desarrollar un programa que solicite la carga de 10 números e imprima
la suma de los últimos 5 valores ingresados.
3. Desarrollar un programa que muestre la tabla de multiplicar del 5 (del 5
al 50)
4. Confeccionar un programa que permita ingresar un valor del 1 al 10 y
nos muestre la tabla de multiplicar del mismo (los primeros 12 términos)
Ejemplo: Si ingreso 3 deberá aparecer en pantalla los valores 3, 6, 9,
hasta el 36.
5. Realizar un programa que lea los lados de n triángulos, e informar:
a) De cada uno de ellos, qué tipo de triángulo es: equilátero (tres lados
iguales), isósceles (dos lados iguales), o escaleno (ningún lado igual)
b) Cantidad de triángulos de cada tipo.
c) Tipo de triángulo que posee menor cantidad.
6. Escribir un programa que pida ingresar coordenadas (x,y) que
representan puntos en el plano.
Informar cuántos puntos se han ingresado en el primer, segundo, tercer
y cuarto cuadrante. Al comenzar el programa se pide que se ingrese la
cantidad de puntos a procesar.
7. Se realiza la carga de 10 valores enteros por teclado. Se desea conocer:
a) La cantidad de valores ingresados negativos.
b) La cantidad de valores ingresados positivos.
c) La cantidad de múltiplos de 15.
d) El valor acumulado de los números ingresados que son pares.
8. Se cuenta con la siguiente información:
Las edades de 50 estudiantes del turno mañana.
Las edades de 60 estudiantes del turno tarde.
Las edades de 110 estudiantes del turno noche.
Las edades de cada estudiante deben ingresarse por teclado.
a) Obtener el promedio de las edades de cada turno (tres promedios)
b) Imprimir dichos promedios (promedio de cada turno)
c) Mostrar por pantalla un mensaje que indique cual de los tres turnos
tiene un promedio de edades mayor.

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor6
{
class Program
{
static void Main(string[] args)
{
int basetri,altura,superficie,cantidad,f,n;
string linea;
cantidad=0;
[Link]("Cuantos triángulos procesará:");
linea = [Link]();
n=[Link](linea);
 for(f=1;f<=n;f++)
{
[Link]("Ingrese el valor de la base:");
linea = [Link]();

basetri=[Link](linea);
[Link]("Ingrese el valor de la altura:");
linea = [Link]();
altura=[Link](linea);
superficie=basetri*altura/2;
[Link]("La superficie es:");
[Link](superficie);
if (superficie>12)
{
cantidad=cantidad+1;
}
}
[Link]("La cantidad de triángulos con superficie
superior a 12 son:");
[Link](cantidad);
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor7
{
class Program
{
static void Main(string[] args)
{
int f,valor,suma;
string linea;
suma=0;
for(f=1;f<=10;f++)
{
[Link]("Ingrese un valor:");
linea = [Link]();
valor=[Link](linea);
if (f>5)
{
suma=suma+valor;
}
}
[Link]("La suma de los últimos 5 valores es:");
[Link](suma);
[Link]();
}
}
}
using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor8
{
class Program
{
static void Main(string[] args)
{
int f;
for(f=5;f<=50;f=f+5)
{
[Link](f);
[Link]("-");
}
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor9
{
class Program
{
static void Main(string[] args)
{
int f,valor;
string linea;
[Link]("Ingrese un valor entre 1 y 10:");
linea = [Link]();
valor=[Link](linea);
for(f=valor;f<=valor*12;f=f+valor)
{
[Link](f);
[Link]("-");
}
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor10
{
class Program
{
static void Main(string[] args)
{
int f,lado1,lado2,lado3,cant1,cant2,cant3,n;
string linea;
cant1=0;
cant2=0;
cant3=0;
[Link]("Ingrese la cantidad de triángulos:");
linea = [Link]();
n=[Link](linea);
for(f=1;f<=n;f++)
{
[Link]("Ingrese lado 1:");
linea = [Link]();
lado1=[Link](linea);
[Link]("Ingrese lado 2:");
linea = [Link]();
lado2 = [Link](linea);
[Link]("Ingrese lado 3:");
linea = [Link]();
lado3 = [Link](linea);
if (lado1==lado2 && lado1==lado3)
{
[Link]("Es un triángulo equilatero.");
cant1++;
}
else
{
if (lado1==lado2 || lado1==lado3 || lado2==lado3)
{
[Link]("Es un triángulo
isósceles.");
cant2++;
}
else
{
cant3++;
[Link]("Es un triángulo escaleno.");
}
}
}
[Link]("Cantidad de triángulos equilateros:");
[Link](cant1);
[Link]("Cantidad de triángulos isósceles:");
[Link](cant2);
[Link]("Cantidad de triángulos escalenos:");
[Link](cant3);
if (cant1<cant2 && cant1<cant3)
{
[Link]("Hay menor cantidad de triángulos
equilateros.");
}
else
{
 if (cant2<cant3)
{
[Link]("Han menor cantidad de triángulos
isósceles");
}
else
{
[Link]("Han menor cantidad de triángulos
escalenos");
}
}
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor11
{
class Program
{
static void Main(string[] args)
{
int n,f,x,y,cant1,cant2,cant3,cant4;
string linea;
cant1=0;
cant2=0;
cant3=0;
cant4=0;
[Link]("Cantidad de puntos:");
linea = [Link]();
n=[Link](linea);
for(f=1;f<=n;f++)
{
[Link]("Ingrese coordenada x:");
linea = [Link]();
x=[Link](linea);
[Link]("Ingrese coordenada y:");
linea = [Link]();
y=[Link](linea);
if (x>0 && y>0)
{
cant1++;
}
else
{
if (x<0 && y>0)
{
cant2++;
}
else
{
if (x<0 && y<0)
 {
cant3++;
}
else
{
if (x>0 && y<0)
{
cant4++;
}
}
}
}
}
[Link]("Cantidad de puntos en el primer
cuadrante:");
[Link](cant1);
[Link]("Cantidad de puntos en el segundo
cuadrante:");
[Link](cant2);
[Link]("Cantidad de puntos en el tercer
cuadrante:");
[Link](cant3);
[Link]("Cantidad de puntos en el cuarto
cuadrante:");
[Link](cant4);
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor12
{
class Program
{
static void Main(string[] args)
{
int f,valor,negativos,positivos,mult15,sumapares;
string linea;
negativos=0;
positivos=0;
mult15=0;
sumapares=0;
for(f=1;f<=10;f++)
{
[Link]("Ingrese valor:");
linea = [Link]();
valor=[Link](linea);
if (valor<0)
{
negativos++;
}
else
 {
if (valor>0)
{
positivos++;
}
}
if (valor%15==0)
{
mult15++;
}
if (valor%2==0)
{
sumapares=sumapares+valor;
}
}
[Link]("Cantidad de valores negativos:");
[Link](negativos);
[Link]("Cantidad de valores positivos:");
[Link](positivos);
[Link]("Cantidad de valores múltiplos de 15:");
[Link](mult15);
[Link]("Suma de los valores pares:");
[Link](sumapares);
[Link]();
}
}
}

using System;
using [Link];
using [Link];
using [Link];

namespace EstructuraRepetitivaFor13
{
class Program
{
static void Main(string[] args)
{
int f,edad,suma1,suma2,suma3,pro1,pro2,pro3;
string linea;
suma1=0;
suma2=0;
suma3=0;
for(f=1;f<=50;f++)
{
[Link]("Ingrese edad:");
linea = [Link]();
edad=[Link](linea);
suma1=suma1+edad;
}
pro1=suma1/50;
[Link]("Promedio de edades del turno mañana:");
[Link](pro1);
for(f=1;f<=60;f++)
{
 [Link]("Ingrese edad:");
linea = [Link]();
edad = [Link](linea) ;
suma2=suma2+edad;
}
pro2=suma2/60;
[Link]("Promedio de edades del turno tarde:");
[Link](pro2);
for(f=1;f<=110;f++)
{
[Link]("Ingrese edad:");
linea = [Link]();
edad=[Link](linea);
suma3=suma3+edad;
}
pro3=suma3/110;
[Link]("Promedio de edades del turno noche:");
[Link](pro3);
if (pro1<pro2 && pro1<pro3)
{
[Link]("El turno mañana tiene un promedio menor
de edades.");
}
else
{
if (pro2<pro3)
{
[Link]("El turno tarde tiene un promedio
menor de edades.");
}
else
{
[Link]("El turno noche tiene un promedio
menor de edades.");
}
}
[Link]();
}
}
}