Programación en C Sharp

Que es un algoritmo? Los algoritmos son el conjunto de pasos que se hacen para cumplir cierto objetivo, por ejemplo: Si tienes que hacer un jugo de papaya, lo primero que tienes que hacer es:

jueves, 23 de octubre de 2014

Resumen de Ordenes de C#

Bucle Mientras

Es un bucle que puede ser aplicado en todos los ejercicios del bucle Para, incluso tiene mayores ventajas respecto a este dependiendo el uso y las necesidades que tengamos, debemos considerar que primero se evalúa la condición y luego se hacen las operaciones,  su sintaxis es la siguiente:

Sintaxis:

Algoritmo C# 
Mientras (condición)
          Operación1
          Operación2
          ...
FinMientras 
while (condición)
{
          Operación1;
          Operación2;
          ...

Características:
  • Primero se evalúa la condición.
  • Luego si la condición es verdadera, se ejecutan las operaciones.
  • El bucle termina si la condición se vuelve falsa.



Bucle Hacer Mientras

Es un bucle que puede ser aplicado en todos los ejercicios de los dos bucles anteriores, tiene la ventaja de primero realizar operaciones y luego evaluar la condición para determinar si se siguen repitiendo las operaciones, su sintaxis es la siguiente:

Sintaxis:

Algoritmo C# 
Hacer
          Operación1
          Operación2
          ...
Mientras(condición)
do
{
          Operación1;
          Operación2;
          ...
}
while (condición)

Características:

  • Primero se hacen las operaciones.
  • Luego se evalúa la condición y si esta es verdadera se vuelven a realizar las operaciones.
  • Si la condición se evalúa como falsa se termina el bucle.

Bucle Hacer Mientras

El Bucle Hacer Mientras (do ... while)

Esta estructura es muy similar a la estructura mientras, su diferencia radica en que la condición de repetición se realiza después de ejecutadas las operaciones, es decir, las operaciones que están en este bucle siempre se ejecutan por lo menos una vez, luego se evalúa la condición para ver si la repetición se continua.

Sintaxis: 
hacer
          operación 1
          operación 2
          ....
          operación n
mietras (condición)


--En Construcción afuera 

Ejercicio 1. Los Número Naturales

Hacer un programa que permita mostrar los 20 primeros números positivos.
Análisis: 

  • El programa debe mostrar 1, 2, 3, 4, 5, 6, ..., 20
  • Variable de Salida: k, es un contador


Diseño: 
Algoritmo Numeros20
Inicio
          Entero k
          k = 1
          Hacer
                    Escribir(k)
                    k = k + 1
          Mientras (k<=20)
Fin

Código: 
         public static void Main(string[] args)
        {
            int k;
            k=1;
            do
            {
                Console.WriteLine(" ♥ " + k);
                k++;
            }while(k<=20);
            Console.WriteLine("Presiona enter para salir");
            Console.ReadLine();
        }
Notas: 

  • Ten en cuenta que siempre se mostrará el uno sin importar la condición que se le ponga.
  • Este bucle es ideal cuando necesitamos primero ejecutar un conjunto de ordenes y luego evaluar la condición.
--En construcción afuera 

--En Construcción afuera 

Ejercicio 2. Lectura de Positivos

Hacer un programa que haga la lectura de números positivos únicamente, la lectura debe terminar si alguien pone un numero cero o inferior.

Análisis: 

  • El objetivo del programa es ingresar números, de forma que solo se puedan ingresar numeros positivos, para el ejemplo usaremos solo números enteros.
  • Variable de Entrada: dato 
  • Condición de repetición: dato > 0


Diseño:
Algoritmo LecturaPositivos
Inicio
          Entero dato
          Hacer
                    Leer(dato)
          Mientras(dato>0)
Fin

Código:
--En Construcción Notas:
--En construcción afuera 

Ejercicios con Mientras y Para

Cuando se hacen programas normalmente necesitamos diferentes bucles, dependiendo de las necesidades que se tienen, en este caso es necesario hacer un análisis que nos permita identificar la estructura a utilizar.



Ejercicio 1. El Número Primo

Desarrolle un programa que indique si un número es primo o no lo es, un numero primo es todo aquel numero que es divisible por si mismo y por la unidad, por ejemplo:
  • 7 es primo porque solo se puede dividir entre 7 y entre 1.
  • 9 no es primo porque se puede dividir entre 9, 3 y 1, por lo tanto no es primo.
  • 13 es primo porque solo se puede dividir entre 13 y 1.
  • 27 no es primo porque se puede dividir entre 27, 9, 3, 1.
Análisis:
En los ejemplos podemos ver que los que los números primos tienen dos divisores exactos, si por ejemplo tenemos el 6, podemos hacer lo siguiente:

  • 1, 2, 3, 4, 5, 6, aquí tenemos todos los números si nos preguntamos  cuales son los divisores podemos analizar uno a uno verificando cuales tienen un residuo de cero en su división.
  • Al tener un numero divisor, entonces lo contamos, de esta forma en el caso del 6, tendremos los números 1, 2, 3, 6, por tanto no es primo.
  • Para este caso tenemos la necesidad de usar un bucle que genere los números por ejemplo del 1 al 6, luego dentro una condición para verificar si el numero es divisible entre estos y contarlos.
  • Al terminar el conteo deveremos verificar cuantos numeros son divisores y si teneos dos entonces si es primo, sino no lo es.
Variables de Entrada: numero
Variables de Salida: No se tienen, solo se mostrara un mensaje que indique si el numero es primo o no.

Diseño:
Algoritmo ElNumeroPrimo
Inicio
         Entero numero, contador, k
         Leer(numero)
         contador = 0
         k = 1
         Mienstras k<= numero
                  Si numero MOD k == 0 Entonces
                           contador = contador + 1
                  FinSi
                  k = k +1
         FinMientras
         Si contador == 2 Entonces
                  Escribir("Es un numero Primo")
         Sino
                  Escribir("El numero no es primo")
         FinSi
Fin

Código:
Notas:
...



Ejercicio 2. El Número Perfecto

Un número es perfecto si la suma de sus divisores menores a el es el mismo número, por ejemplo:
  • 28 = 1+2+4+7+14
  • 496 = 1+2+4+8+16+31+62+124+248
  • 8128 = 1+2+4+8+16+32+64+127+254+508+1016+2032+4064
Análisis:

  • Como podemos observar en los ejemplos tenemos al 28, y sus divisores, si observas bien el número, llegamos hasta 14 por que es la mitad de 28 y no existen divisores mayores a 14.
  • Al observar esto podemos ver que necesitamos un bucle que recorra desde 1 hasta la mitad del numero analizado, también necesitamos un condicional que indique si el numero es divisible.
  • Cuando al verificar que un numero es divisor procedemos a acumular este numero.
  • Cuando el bucle finaliza debemos comparar el acumulado con el numero original, si resultan ser iguales mostramos el mensaje que es numero perfecto, caso contrario no lo es.


Diseño:
Algoritmo ElNumeroPerfecto
Inicio
          Entero dato, k, suma
          Leer(dato)
          k = 1
          suma = 0
          Mientras (k <= dato DIV 2)
                    Si dato MOD k == 0 Entonces
                              suma = suma + k
                    FinSi
                    k = k + 1
          FinMientras
          Si suma == dato Entonces
                    Escribir("Es numero perfecto..")
          Sino
                    Escribir("No es perfecto..")
          FinSi
Fin

--En construcción Código:
--En Construcción Notas: 

--En construcción afuera 

--En Construcción afuera 
--En construcción Ejercicio
--En construcción Análisis:

--En construcción Diseño:

--En construcción Código:
--En Construcción Notas:
--En construcción afuera 

Ejercicios Con Mientras (while)


Ejercicios Con Mientras o while en C#

Con la estructura repetitiva While puedes hacer cualquier ejercicio que se pueda resolver usando el bucle PARA, además permite realizar otros ejercicios, ahora vamos ha desarrollar programas con opciones.

Ejercicio 1. El Promedio

Hacer un programa para calcular el promedio de varios números, el programa debe terminar cuando se ingresa un numero negativo.
Análisis:
Como puedes ver debemos ingresar números de 0 a 20, si ingresas un numero diferente el programa terminara y nos debe mostrar el promedio de los números ingresado, es decir, si ingresamos 4, 15, 7, 17, 19 y finalmente -1, el programa debe mostrar solo el promedio de los números 4, 15, 7, 17, 19.

  • Condición del bucle Mientras: dato >= 0.
  • Contador dentro del bucle: c = c + 1.
  • Acumulador dentro del bucle: suma = suma + dato.

Diseño:
Algoritmo LosPromedios
Inicio
        Real suma, c, dato, promedio
        suma = 0
        c = -1
        dato = 0
        Mientras ( dato >= 0 )
                suma = suma + dato
                c = c + 1
                Leer(dato)
        FinMientras
        promedio = suma / c
        Escribir(promedio)
Fin

Código:
         public static void Main(string[] args)
        {
            double suma,c,dato,promedio;
            suma = 0;
            c = -1;
            dato = 0;
            while (dato>=0)
            {
                suma = suma + dato;
                c = c + 1;
                Console.Write("Ingresa el Numero: ");
                dato = int.Parse(Console.ReadLine());
            }
            promedio = suma / c;
            Console.WriteLine("El promedio es: "+promedio);
            Console.ReadLine();
        }
Notas:
Iniciamos el contador en -1 ya que al principio siempre contamos el primer ingreso sin importar el numero ingresado.


--En Construcción afuera

Ejercicio 2. El menú de opciones.

Desarrolla un programa para hacer las 4 operaciones matemáticas, este debe tener un menú de la siguiente forma:

*********** CALCULADORA BÁSICA ***********
1. Sumar
 2. Restar
       3. Multiplicar
 4. Dividir

0. Salir
Elija una Opción -----> _

Al ingresar la opción 1 por ejemplo deberá pedir dos números y sumarlos, al ingresar la opción de 0 el programa deberá terminar.
Análisis:

  • En este ejercicio tenemos las formulas para las operaciones de suma, resta, multiplicación y división.
  • También sabemos que debemos tener un menú de opciones.
  • Deberemos usar 4 estructuras si para el control de las 4 operaciones.
  • El bucle mientras tendrá la condición siguiente: opción != 0

Diseño:
Algoritmo CalculadoraOpciones
Inicio
        Entero a, b, respuesta, opcion
        opcion = 10
        Mientras (opcion != 0)
                Escribir("*********** CALCULADORA BÁSICA ***********")
                Escribir("1. Sumar")
                Escribir("2. Restar")
                Escribir("3. Multiplicar")
                Escribir("4. Dividir")
                Escribir("****************")
                Escribir("0. Salir")
                Escribir("Ingresa la Opción: ")
                Leer(opcion)
                Si opcion = 1 Entonces
                        Leer(a, b)
                        respuesta = a + b
                        Escribir(respuesta)
                FinSi
                Si opcion = 2 Entonces
                        Leer(a, b)
                        respuesta = a - b
                        Escribir(respuesta)
                FinSi
                Si opcion = 3 Entonces
                        Leer(a, b)
                        respuesta = a * b
                        Escribir(respuesta)
                FinSi
                Si opcion = 4 Entonces
                        Leer(a, b)
                        respuesta = a / b
                        Escribir(respuesta)
                FinSi              
        FinMientras
Fin

Código:
         public static void Main(string[] args)
        {
        
            double a,b,respuesta,opcion;
            opcion = 10;
            while(opcion != 0)
            {
                Console.Clear();
                Console.WriteLine("*************** CALCULADORA ***************");
                Console.WriteLine("1. Suma");
                Console.WriteLine("2. Resta");
                Console.WriteLine("3. Multiplicacion");
                Console.WriteLine("4. Division");
                Console.WriteLine("********************************************");
                Console.WriteLine("0. Salir");
                Console.Write("Ingresa la opción: ");
                opcion = int.Parse(Console.ReadLine());

                if (opcion == 1)
                {
                    Console.WriteLine("Ingresa A: ");
                    a = double.Parse(Console.ReadLine());
                    Console.WriteLine("Ingresa B: ");
                    b = double.Parse(Console.ReadLine());
                    respuesta = a +b;
                    Console.WriteLine("La suma es: " + respuesta);
                    Console.ReadLine();
                }
                if (opcion == 2)
                {
                    Console.WriteLine("Ingresa A: ");
                    a = double.Parse(Console.ReadLine());
                    Console.WriteLine("Ingresa B: ");
                    b = double.Parse(Console.ReadLine());
                    respuesta = a - b;
                    Console.WriteLine("La resta es: " + respuesta);
                    Console.ReadLine();
                }
                if (opcion == 3)
                {
                    Console.WriteLine("Ingresa A: ");
                    a = double.Parse(Console.ReadLine());
                    Console.WriteLine("Ingresa B: ");
                    b = double.Parse(Console.ReadLine());
                    respuesta = a  * b;
                    Console.WriteLine("La Multiplicacion es: " + respuesta);
                    Console.ReadLine();
                }
                if(opcion == 4)
                {
                    Console.WriteLine("Ingresa A: ");
                    a = double.Parse(Console.ReadLine());
                    Console.WriteLine("Ingresa B: ");
                    b = double.Parse(Console.ReadLine());
                    respuesta = a / b;
                    Console.WriteLine("La division es: " + respuesta);
                    Console.ReadLine();
                }
    
            }        
Notas:





Actividad 1. Desarrolla un programa para mostrar los primeros n numeros, los primeros n numeros pares, los primeros n numeros impares, la opción S debe ser para salir:

*********** LOS NUMEROS ***********
N: Numeros
 P: Numeros Pares
I: Numeros Impares
S: Salir
♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣♣
Elija una Opción -----> _


  • Las opciones son letras, aquí al poner S, debemos poder salir o terminar el programa.

Bucle Mientras

Nuevos Bucles

En programación usaras constantemente bucles, es por ello que necesitamos conocer que otras herramientas a utilizar, ahora ya conoces la estructura PARA, esta no sera suficiente para muchos problemas que se te van ha presentar en tu vida como programador, en esta lección aprenderemos una nueva estructura, se trata de la estructura Mientras.

El bucle Mientras (While)

Este bucle repite un conjunto de ordenes, siempre y cuando una condición se cumpla, lo mas relevante del bucle es que primero evalúa la condición y luego realiza las operaciones, esta estructura tiene la siguiente sintaxis:

Mientras (Condición)
        Operación 1
        Operación 2
        ...
FinMientras

Importante

La totalidad de los ejercicios resueltos con en bucle PARA (for), se resuelven con MIENTRAS (while), deberás practicar y resolver todos los ejercicios resueltos aplicando el nuevo bucle.

Series para Practicar


Figura de Series.


Ejercicio 1.

Hacer un programa para mostrar la serie 1 hasta su termino n.

Análisis:

En la figura puedes observar la solución de la serie, de esta podemos extraer el siguiente modelo y detalles para su inicialización.

  • aumento = 4, al principio.
  • termino = 2, al principio.
  • k = 1, es la inicialización del contador.
  • mostrar el termino dentro del bucle
  • termino = termino + aumento, dentro del bucle
  • aumento = aumento / 2, dentro del bucle
  • La condición del bucle es que tenemos un contador k que comienza en 1 fuera del bucle.
  • La variable n la cantidad de términos de la serie, es decir, el limite.
  • La condición de mientras es que k<=n.

Variable de Entrada: n
Variables de Salida: termino

Diseño:

Algoritmo Serie1
Inicio
        Real termino, aumento, k, n, suma
        aumento = 4
        termino = 2
        k = 1
        Leer(n)
        Mientras ( k<=n )
                Escribir(termino)
                termino = termino + aumento
                aumento = aumento / 2
                k = k + 1
        FinMientras
Fin

Código:

         public static void Main(string[] args)
        {
            double termino, aumento, k, n, suma;
            aumento = 4;
            termino = 2;
            k = 1;
            Console.Write("Ingresa N: ");
            n = int.Parse(Console.ReadLine());
            Console.WriteLine("****** Valores de la Serie ******");
            while( k<=n )
            {
                Console.WriteLine("El termino: " + termino);
                termino = termino + aumento;
                aumento = aumento / 2;
                k = k + 1;
            }
            Console.ReadLine();
        }

Notas Importantes:


  • El bucle Mietras no cuenta con un contador automático, es por ello que necesitamos usar un contador k, que comienza en 1 y se actualiza con +1.
  • En este ejercicio usamos en realidad dos acumuladores, uno de ellos suma y el otro termino.





Ejercicio 2.

Hacer un programa para mostrar la serie 8 que tienes en la figura, también debe mostrar la suma de los términos de esta serie.

Análisis:

Viendo la serie, podemos notar que en realidad esta compuesta por son dos series, una que se incrementa de 111 y otra que se reducen en -111, esto nos da la idea de usar una condicional para controlar el incremento y decremento.

  • Necesitamos una variable terminoA y otra terminoB, para la serie.
  • signo = 1, inicializamos signo.
  • suma = 0, inicializamos suma.
  • terminoA = 1, inicializamos terminoA.
  • terminoB = 100, inicializamos terminoB.
  • terminoA = terminoA + signo*111, si signo mayor a cero.
  • terminoB = terminoB + signo*111, si signo es menor a cero.
  • suma = suma + terminoA, si signo es mayor a cero.
  • suma = suma + terminoB, si signo es menor a cero.
  • signo = -1 * signo, esto permitirá que la serie incremente y decremento.

Diseño:

Algoritmo Serie8
Inicio
        Real signo, suma, terminoA, terminoB, n, k
        signo = 1
        suma = 0
        terminoA = 1
        terminoB = 1000
        k = 1
        Leer (n)
        Mientras ( k <= n )
                Si signo > 0 Entonces
                        Escribir(terminoA)
                        terminoA = terminoA + signo*111
                        suma = suma + terminoA
                Sino
                        Escribir(terminoB)
                        terminoB = terminoB + signo*111                      
                        suma = suma + terminoB
                FinSi
                signo = -1 * signo
                k = k + 1
        FinMientras
        Escribir(suma)
Fin

Código:

         public static void Main(string[] args)
        {
            double signo, suma, terminoA, terminoB, n, k;
            signo = 1;
            suma = 0;
            terminoA = 1;
            terminoB = 1000;
            k = 1;
            Console.Write("Ingresa el valor de N: ");
            n = int.Parse(Console.ReadLine());
            Console.WriteLine("******** LOS TERMINOS DE LA SERIE *******");
            while ( k <= n )
            {
                if (signo > 0)
                {
                    Console.WriteLine("♥ " + terminoA);
                    terminoA = terminoA + signo*111;
                    suma = suma + terminoA;
                }
                else
                {
                    Console.WriteLine("♣ " + terminoB);
                    terminoB = terminoB + signo*111;       
                    suma = suma + terminoB;
                }
                signo = -1* signo;
                k = k + 1;
            }
            Console.WriteLine("-----------> La suma es: " + suma);
            Console.ReadLine();
        }

Los Acumuladores

Los Acumuladores


Estas variables tienen un trabajo especifico, como su nombre lo indica su misión es acumular ciertas cantidades, por ejemplo si quisiéramos sumar los números del 1 al 5, nosotros haríamos los siguiente: 1+2+3+4+5, esto es fácil en una lista de numero pequeña pero si hablamos de 1000 números las cosas cambian. La forma de usar un acumulador tiene la siguiente sintaxis:

Sintaxis:

acumulador = 0
Bucle
        acumulador = acumulador + x
FinBucle

acumulador = 0; esto significa que el acumulador se esta inicializando, normalmente en CERO.
acumulador = acumulador + x; aquí actualizamos el acumulador e ingrementamos el valor de x.

Los acumuladores son muy usados para calcular sumatorias, sumas de series, para hallar totales.

Ejercicio 1. Desarrollar un programa para hallar la suma de los números del 1 al 10.

Análisis

Esto significa que nos piden hacer el siguiente calculo, 1+2+3+4+5+6+7+8+9+10, como podemos ver los números del 1 al 10 los podemos generar con el bucle PARA, en este caso k es el contador del bucle, por tanto.
Modelo: suma = suma + k, donde suma inicia en cero y k varia su valor desde 1 hasta 10 de uno en uno.

Diseño

Algoritmo SumaDeNumeros
Inicio
        Real suma, k
        suma = 0
        Para k = 1 Hasta 10
                suma = suma + k
        FinPara
        Escribir(suma)
Fin

Código Fuente en C#

         public static void Main(string[] args)
        {
            double suma, k;
            suma = 0;
            for(k = 1; k <= 10; k++)
            {
                suma = suma + k;
            }
            Console.WriteLine("La suma de los números del 1 al 10 es: " + suma);
            Console.ReadLine();
        }

Notas

Puedes cambiar el valor de 10 por cualquier numero, e incluso modificar el programa para que pueda calcular la suma de los números de 1 hasta el valor que quieras (n), haciendo esta modificación tenemos:
         public static void Main(string[] args)
        {
            double suma, k, n;
            Console.WriteLine("♣♣♣♣ SUMA DE LOS NUMEROS DESDE 1 HASTA N ♣♣♣♣");
            Console.WriteLine("Ingresa el valor de N: ");
            n = double.Parse( Console.ReadLine());
            suma = 0;
            for(k = 1; k <= n; k++)
            {
                suma = suma + k;
            }
            Console.WriteLine("La suma de los numeros es:" + suma);
            Console.ReadLine();
        }

Ejercicio 2. Hacer un programa para sumar n numeros.

Análisis

Podemos ponernos en el ejemplo que tengamos 4 números, entonces lo que debemos hacer es: 45 + 98 + 33 + 14, entonces aquí usamos un acumulador y como los números cambian y pueden ser cualquier numero necesitamos leerlos, también debemos tener en cuenta la cantidad de números, en este caso 4 que podemos llamar n.
Modelo: total = total + numero, donde total es el acumulador y numero un dato ingresado.

Diseño

Algoritmo CalculoDelTotal
Inicio
        Entero n, k
        Real numero, total
        total = 0
        Leer(n)
        Para k = 1 Hasta n
                Leer(numero)
                total = total + numero
        FinPara
        Escribir(total)
Fin

Codigo Fuente en C#

         public static void Main(string[] args)
        {
            int n, k;
            double numero, total;
            total = 0;
            Console.WriteLine("♣♣♣ PROGRAMA PARA SUMAR N NUMEROS ♣♣♣");
            Console.Write("Ingresa N: ");
            n = int.Parse(Console.ReadLine());
            Console.WriteLine("******** INGRESO DE DATOS *********");
            for(k = 1; k <= n; k++)
            {
                Console.Write("=====> Ingresa el numero: ");
                numero = double.Parse(Console.ReadLine());
                total = total + numero;
            }
            Console.WriteLine("******** RESULTADO FINAL *********");
            Console.WriteLine("La suma de los numeros es: " + total);
            Console.ReadLine();
        }

Notas

En el programa se han añadido mensajes que facilitan el manejo del programa y el mostrar los resultados, esto en un programa es muy importante.



Figura de Sumatorias Numéricas

Ejercicio 3. Resolver la sumatoria Nº 2 de la figura. 

Análisis

Ya tenemos el modelo, este es: g = g + (i/(i+1)), donde g es el acumulador, i es el contador del bucle que va desde 1 hasta n.

Diseño

Algoritmo SegundoEjercicioDeFigura
Inicio
        Entero n, i
        Real g
        g = 0
        Leer(n)
        Para i = 1 Hasta n
                g = g + (i/(i+1))
        FinPara
        Escribir(g)
Fin

Código Fuente en C#

         public static void Main(string[] args)
        {
            int n, i;
            double g;
            g = 0;
            Console.WriteLine("*********** SUMATORIA EJERCICIO 2********** ");
            Console.Write("Ingresa el valor de n: ");
            n = int.Parse(Console.ReadLine());
            for(i = 1; i <= n; i++)
            {
                g = g + (i/(i+1.0));
            }
            Console.WriteLine("*********** RESULTADO ***********");
            Console.WriteLine("La sumatoria es: " + g);
            Console.ReadLine();
        }

Notas

Las sumatorias también se usan para el calculo de algunas series.

  • Codifique un programa para calcular el promedio de n notas.
  • Una tienda desea calcular el precio total de ventas, para ello ingresa las cantidades y los precios unitarios, el programa debe calcular el total, por ejemplo: 5 x 1.22 + 3 x 5.1, el 5 y el 3 son las cantidades y el 1.22 y el 5.1 son los precios unitarios, esto debe sumarse, este ejemplo solo es con dos ventas, el programa debe resolverlo para n ventas.
  • Haga un programa para la serie 4 de la figura.
  • Desarrolle un programa para la serie 6 de la figura.