3. Microsoft Visual .

Net 2012 – C#
III) Estructuras Condicionales Anidada Solución: Inicio
Decimos que una estructura condicional
nota1
es anidada cuando por la rama del
verdadero o el falso de una estructura
nota2
condicional hay otra estructura
condicional.
nota3
Problema: Confeccionar un programa
que pida por teclado tres notas de un prom = (nota1+ nota2+ nota1+ nota1)/3
alumno, calcule el promedio e imprima
alguno de estos mensajes:
(prom>=7)
Si el promedio es >=7 mostrar
"Promocionado". ”Promocionado”
(prom>=4)
Si el promedio es >=4 y <7 mostrar
"Regular". ”Reprobado” ”Regular”
Si el promedio es <4 mostrar
"Reprobado"

Fin
 3. Microsoft Visual .Net 2012 – C#
Código: using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace EstructuraCondicionalAnidada1
Al correr el programa deberá solicitar por {
class Program
teclado la carga de tres notas y {
static void Main(string[] args)
mostrarnos un mensaje según el {
promedio de las mismas. int nota1,nota2,nota3; string linea;
Console.Write("Ingrese primer nota:");
linea = Console.ReadLine(); nota1=int.Parse(linea);
Console.Write("Ingrese segunda nota:");
linea = Console.ReadLine(); nota2 = int.Parse(linea);
A la codificación del if anidado podemos Console.Write("Ingrese tercer nota:");
observarla por el else del primer if. linea = Console.ReadLine(); nota3 = int.Parse(linea);
int promedio=(nota1 + nota2 + nota3) / 3;
if (promedio>=7)
{
Para no tener problemas (olvidarnos) con Console.Write("Promocionado");
}
las llaves de apertura y cerrado podemos else
{
ver la siguiente regla: if (promedio>=4)
Cada vértice representa una llave de {
Console.Write("Regular");
apertura y una de cierre: }
else
{
Console.Write("Reprobado");
}
}
Console.ReadKey();
}
}
}
 3. Microsoft Visual .Net 2012 – C#
IV) Estructuras Condicionales Compuestas con Operadores Lógicos
Los operadores lógicos se emplean Inicio
fundamentalmente en las estructuras
condicionales para agrupar varias condiciones num1
simples.
“Y” (&&) num2
“O” (||)
Problema: Confeccionar un programa que lea num3
por teclado tres números distintos y nos
muestre el mayor.
Solución: Si la Condición 1 es verdadera Y la (num1 > num2
condición 2 es verdadera luego ejecutar la &&
num1 > num3)
rama del verdadero.

Cuando vinculamos dos o más condiciones con (num2 > num3)

num1
el operador “&&”, las dos condiciones deben
ser verdaderas para que el resultado de la
condición compuesta de Verdadero y continúe
num2 num2
por la rama del verdadero de la estructura
condicional.

Fin
 3. Microsoft Visual .Net 2012 – C#
Código: using System;
using System.Collections.Generic;
Si el contenido de la variable num1 es mayor al using System.Linq;
contenido de la variable num2 Y si el contenido de la using System.Text;
namespace EstructuraCondicionalAnidada1
variable num1 es mayor al contenido de la variable {
num3 entonces la CONDICION COMPUESTA resulta class Program
{
Verdadera. static void Main(string[] args)
{
int num1,num2,num3; string linea;
Si una de las condiciones simples da falso la Console.Write("Ingrese primer valor:");
linea = Console.ReadLine(); num1=int.Parse(linea);
CONDICION COMPUESTA da Falso y continua por la Console.Write("Ingrese segundo valor:");
rama del falso. linea = Console.ReadLine(); num2 = int.Parse(linea);
Console.Write("Ingrese tercer valor:");
linea = Console.ReadLine(); num3 = int.Parse(linea);
Es decir que se mostrará el contenido de num1 si y if (num1>num2 && num1>num3)
{
sólo si num1>num2 y num1>num3. Console.Write(" num1 ");
}
else
En caso de ser Falsa la condición, analizamos el {
if (num2>num3)
contenido de num2 y num3 para ver cual tiene un {
valor mayor. Console.Write("num2");
}
else
En esta segunda estructura condicional no se {
Console.Write("num3");
requieren operadores lógicos al haber una condición }
simple. }
Console.ReadKey();
}
}
}
 3. Microsoft Visual .Net 2012 – C#
V) Estructuras Repetitiva While

Una estructura repetitiva permite Inicio

ejecutar una instrucción o un conjunto de
instrucciones varias veces. x=1

El bloque se repite MIENTRAS la

(x<=100)
condición sea Verdadera.

Problema 1: Realizar un programa que

imprima en pantalla los números del 1 al x
100.

Solución: La primera operación inicializa x = x +1

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.
Fin
 3. Microsoft Visual .Net 2012 – C#
Código:
Al ejecutarse la condición retorna VERDADERO using System;
porque el contenido de x (1) es menor o igual using System.Collections.Generic;
a 100. Al ser la condición verdadera se ejecuta using System.Linq;
using System.Text;
el bloque de instrucciones que contiene la namespace EstructuraRepetitivaWhile1
estructura while. {
class Program
{
El bloque de instrucciones contiene una salida static void Main(string[] args)
y una operación. {
int x; x = 1;
while (x <= 100)
Se imprime el contenido de x, y seguidamente {
se incrementa la variable x en uno. Console.Write(x);
Console.Write(" - ");
x = x + 1;
Mientras la condición retorne verdadero se }
ejecuta el bloque de instrucciones; al retornar Console.ReadKey();
falso la verificación de la condición se sale de }
}
la estructura repetitiva y continua el }
algoritmo, en este caso finaliza el programa.
 3. Microsoft Visual .Net 2012 – C#

Inicio
Problema 2: Escribir un programa que
solicite la carga de un valor positivo y nos n
muestre desde 1 hasta el valor ingresado
de uno en uno. Si ingresamos 30 se debe x=1
mostrar en pantalla los números del 1 al 30.
(x<=n)
Solución: Podemos observar que se ingresa
por teclado la variable n. El operador puede
cargar cualquier valor.
x
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 x = x +1
sea menor o igual a 10”; pues x comienza
en uno y se incrementa en uno cada vez
que se ejecuta el bloque repetitivo.

Fin
 3. Microsoft Visual .Net 2012 – C#

Código: using System;

using System.Collections.Generic;
using System.Linq;
Los nombres de las variables n y x pueden ser using System.Text;
palabras o letras (como en este caso). namespace EstructuraRepetitivaWhile2
{
class Program
La variable x recibe el nombre de CONTADOR. {
static void Main(string[] args)
Un contador es un tipo especial de variable {
int n,x; string linea;
que se incrementa o decrementa con valores Console.Write("Ingrese el valor final:");
constantes durante la ejecución del programa. linea=Console.ReadLine(); n=int.Parse(linea);
x=1;
while (x<=n)
El contador x nos indica en cada momento la {
cantidad de valores impresos en pantalla. Console.Write(x);
Console.Write(" - ");
x = x + 1;
}
Console.ReadKey();
}
}
}
 3. Microsoft Visual .Net 2012 – C#
VI) Estructuras Repetitiva For
la estructura for se usa en aquellas
situaciones en las cuales CONOCEMOS la Inicio
cantidad de veces que queremos que se
ejecute el bloque de instrucciones.
Ejemplo: cargar 10 números, ingresar 5
f = 1; f <= 100; f++
notas de alumnos, etc.

Problema 1: Realizar un programa que

imprima en pantalla los números del 1 al
100. f

Solución: 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.
Fin
 3. Microsoft Visual .Net 2012 – C#

Código:
Inicialmente f vale 1 y como no es superior a using System;
using System.Collections.Generic;
100 se ejecuta el bloque, imprimimos el using System.Linq;
contenido de f, al finalizar el bloque repetitivo using System.Text;
se incrementa la variable f en 1, como 2 no es namespace EstructuraRepetitivaFor1
{
superior a 100 se repite el bloque de class Program
instrucciones. {
static void Main(string[] args)
{
Cuando la variable del for llega a 101 sale de la int f;
estructura repetitiva y continúa la ejecución for(f=1;f<=100;f++)
del algoritmo que se indica después del {
Console.Write(f);
círculo. Console.Write("-");
}
Console.ReadKey();
}
}
}
 3. Microsoft Visual .Net 2012 – C#

Inicio

Problema 2: Desarrollar un programa

x=1
que permita la carga de 10 valores por
teclado y nos muestre posteriormente la
suma de los valores ingresados y su f = 1; f <= 10; f++
promedio.
valor
Solución: Podemos observar y comparar
con el problema realizado con el while. suma = suma + valor
Con la estructura while el CONTADOR x
sirve para contar las vueltas. Con el for el
CONTADOR f cumple dicha función.
promedio = suma/10

suma

promedio

Fin
 3. Microsoft Visual .Net 2012 – C#

using System;
Código: using System.Collections.Generic;
using System.Linq;
En este caso, a la variable del for (f) sólo using System.Text;
namespace EstructuraRepetitivaFor2
se la requiere para que se repita el {
bloque de instrucciones 10 veces. class Program
{
static void Main(string[] args)
El problema requiere que se carguen 10 {
valores y se sumen los mismos. int suma,f,valor,promedio; string linea;
suma=0;
for(f=1;f<=10;f++)
Tener en cuenta encerrar entre llaves {
bloque de instrucciones a repetir dentro Console.Write("Ingrese valor:");
del for. linea=Console.ReadLine();
valor=int.Parse(linea);
suma=suma+valor;
El promedio se calcula fuera del for luego }
de haber cargado los 10 valores. Console.Write("La suma es:"); Console.WriteLine(suma);
promedio=suma/10;
Console.Write("El promedio es:"); Console.Write(promedio);
Console.ReadKey();
}
}
}
 3. Microsoft Visual .Net 2012 – C#

Inicio

Problema 3: Escribir un programa

aprobados = 0
que lea 10 notas de alumnos y
nos informe cuántos tienen notas
reprobados = 0
mayores o iguales a 7 y cuántos
menores. f = 1; f <= 10; f++

Solución: Para resolver este nota

problema se requieren tres
contadores: aprobados (Cuenta la (Nota
>=7)
cantidad de alumnos aprobados),
reprobados (Cuenta la cantidad de reprobados = reprobados + 1 aprobados = aprobados + 1
reprobados), f (es el contador del
for).

aprobados

aprobados

Fin
 3. Microsoft Visual .Net 2012 – C#

Código:
using System;
using System.Collections.Generic;
Dentro de la estructura repetitiva using System.Linq;
using System.Text;
debemos hacer la carga de la variable namespace EstructuraRepetitivaFor2
nota y verificar con una estructura {
class Program
condicional si el contenido de la variable {
static void Main(string[] args)
nota es mayor o igual a 7 para {
int aprobados,reprobados,f,nota; string linea;
incrementar el contador aprobados, en aprobados=0; reprobados=0;
for(f=1;f<=10;f++)
caso de que la condición retorne falso {
debemos incrementar la variable Console.Write("Ingrese la nota:");
linea = Console.ReadLine(); nota=int.Parse(linea);
reprobados. if (nota>=7)
{
aprobados=aprobados+1;
}
Los contadores aprobados y reprobados else
deben imprimirse FUERA de la estructura {
reprobados=reprobados+1;
repetitiva. }
}
Console.Write("Cantidad de aprobados:");
Console.WriteLine(aprobados);
Es fundamental inicializar los contadores Console.Write("Cantidad de reprobados:");
Console.Write(reprobados);
aprobados y reprobados en cero antes Console.ReadKey();
de entrar a la estructura for. }
}

}
 3. Microsoft Visual .Net 2012 – C#

VII) Estructuras Repetitiva do While Solución: Inicio

La estructura do while es otra
estructura repetitiva, la cual ejecuta al
valor
menos una vez su bloque repetitivo, a
diferencia del while o del for que (valor
podían no ejecutar el bloque. >=100)

(valor “Tiene 3 dígitos”

Esta estructura repetitiva se utiliza >=10)
cuando conocemos de antemano que
“Tiene un dígito” “Tiene 2 dígitos”
por lo menos una vez se ejecutará el
bloque repetitivo.
Problema 1: Escribir un programa que
solicite la carga de un número entre 0
y 999, y nos muestre un mensaje de
(valor
cuántos dígitos tiene el mismo. != 0)
Finalizar el programa cuando se
cargue el valor 0.
Fin
 3. Microsoft Visual .Net 2012 – C#

Código:
using System;
using System.Collections.Generic;
using System.Linq;
En este problema por lo menos se carga using System.Text;
namespace EstructuraRepetitivaFor2
un valor. {
class Program
{
Si se carga un valor mayor o igual a 100 static void Main(string[] args)
{
se trata de un número de tres dígitos, si int valor; string linea;
do
es mayor o igual a 10 se trata de un valor {
de dos dígitos, en caso contrario se trata Console.Write("Ingrese un valor entre 0 y 999 (0 finaliza):");
linea = Console.ReadLine(); valor=int.Parse(linea);
de un valor de un dígito. if (valor>=100)
{
Console.WriteLine("Tiene 3 dígitos.");
}
Este bloque se repite hasta que se else
{
ingresa en la variable valor el número 0 if (valor>=10)
con lo que la condición de la estructura {
Console.WriteLine("Tiene 2 dígitos.");
do while retorna falso y sale del bloque }
else
repetitivo finalizando el programa. {
Console.WriteLine("Tiene 1 dígito.");
}
}
} while (valor!=0);
}
}
}
 3. Microsoft Visual .Net 2012 – C#
Inicio

suma = 0

Problema 2: Escribir un programa

cant= 0
que solicite la carga de números
por teclado, obtener su promedio. valor
Finalizar la carga de valores
cuando se cargue el valor 0. (valor
!= 0)

Solución: Cuando la finalización suma = suma + valor

depende de algún valor ingresado

cant= cant + 1
por el operador conviene el
empleo de la estructura do while,
(valor
por lo menos se cargará un valor != 0)
(en el caso más extremo se carga
0, que indica la finalización de la (cant
carga de valores) != 0)

promedio=suma/cant
“No se ingresaron valores”
promedio

Fin
 3. Microsoft Visual .Net 2012 – C#
using System;
Código: using System.Collections.Generic;
using System.Linq;
using System.Text;
Definimos un contador cant que cuenta namespace EstructuraRepetitivaFor2
{
la cantidad de valores ingresados por el class Program
{
operador (no lo incrementa si static void Main(string[] args)
ingresamos 0). {
int suma,cant,valor,promedio; string linea;
suma=0; cant=0;
do
El valor 0 no es parte de la serie de {
Console.Write("Ingrese un valor (0 para finalizar):");
valores que se deben sumar. linea = Console.ReadLine();
Definimos el acumulador suma que valor=int.Parse(linea);
if (valor!=0)
almacena todos los valores ingresados {
suma=suma+valor; cant++;
por teclado. }
} while (valor!=0);
if (cant!=0)
La estructura repetitiva do while se {
promedio=suma/cant;
repite hasta que ingresamos el valor 0. Console.Write("El promedio de los valores ingresados es:");
Console.Write(promedio);
Con dicho valor la condición del ciclo }
else
retorna falso y continúa con el flujo del {
Console.Write("No se ingresaron valores.");
diagrama. }
Console.ReadLine();
}
}
}
 3. Microsoft Visual .Net 2012 – C#
Código:
VIII) Cadenas de Caracteres using System;
using System.Collections.Generic;
En C# hemos visto que cuando using System.Linq;
using System.Text;
queremos almacenar un valor entero namespace CadenaDeCaracteres1
definimos una variable de tipo int, si {
class Program
queremos almacenar un valor con {
static void Main(string[] args)
decimales definimos una variable de {
tipo float. String nombre1,nombre2; int edad1,edad2;
String linea;
Console.Write("Ingrese el nombre:"); nombre1=Console.ReadLine();
Ahora si queremos almacenar una Console.Write("Ingrese edad:");
linea=Console.ReadLine();
cadena de caracteres (por ejemplo un edad1=int.Parse(linea);
Console.Write("Ingrese el nombre:"); nombre2=Console.ReadLine();
nombre de una persona) debemos Console.Write("Ingrese edad:");
definir una variable de tipo string. linea=Console.ReadLine();
edad2=int.Parse(linea);
Console.Write("La persona de mayor edad es:");
if (edad1>edad2)
Problema 1: Solicitar el ingreso del {
nombre y edad de dos personas. Console.Write(nombre1);
} else
Mostrar el nombre de la persona con {
mayor edad. Console.Write(nombre2);
}
Console.ReadKey();
}
}
}
 Cadenas de Caracteres
Problema 2: Solicitar el ingreso
del apellido, nombre y edad de
dos personas.
Mostrar el nombre de la
persona con mayor edad.
Realizar la carga del apellido y
nombre en una variable de tipo
string.
Código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace CadenaDeCaracteres2
{
class Program
{
static void Main(string[] args)
{
string apenom1,apenom2; int edad1,edad2;
string linea;
Console.Write("Ingrese el apellido y el nombre:"); apenom1=Console.ReadLine();
Console.Write("Ingrese edad:");
linea = Console.ReadLine();
edad1=int.Parse(linea);
Console.Write("Ingrese el apellido y el nombre:"); apenom2=Console.ReadLine();
Console.Write("Ingrese edad:");
linea = Console.ReadLine();
edad2=int.Parse(linea);
Console.Write("La persona de mayor edad es:");
if (edad1>edad2)
{
Console.Write(apenom1);
} else
{
Console.Write(apenom2);
}
Console.ReadKey();
}
}
}
 3. Conclusiones

La programación es el proceso de
diseñar, codificar, depurar y mantener
el código fuente de programas
computacionales. El código fuente es
escrito en un lenguaje de programación.

Visual Studio. Net permite a los

desarrolladores crear aplicaciones, sitios
y aplicaciones web, así como servicios
web en cualquier entorno que soporte la
plataforma .NET