lunes, 15 de julio de 2013

BUCLE FOR

El bucle for de C# es idéntico al encontrado en los lenguajes C/C++ y Java. El formato general es

        for( inicialización; condición; iteración )
        {
            instrucciones;
        }

Las sentencias de inicialización se ejecutan una vez al principio y sirven principalmente para asignar valores a las variables que servirán de contador. Las sentencias de condición, por su parte, se ejecutan cada vez que el bucle vuelve al principio y sirven para controlar el bucle: éste seguirá realizándose siempre y cuando estas condiciones sean true. Las sentencias de iteración se ejecutan también cada vez que se realiza una nuevo ciclo en el bucle, y sirven para cambiar el estado de las variables que gobiernan las sentencias de condición.

    using System;

    class BucleFor{
        public static void Main()
        {
            int i;  //el contador

            for( i = 0; i < 10; i++)
            {
                Console.WriteLine( i );
            }
        }
    }

Este ejemplo imprime por pantalla los 10 primero enteros positivos. Es un caso muy simple del bucle for. Por cierto, el operador ++ lo que hace es que añade una unidad a la variable a la que acompaña, de forma que, por ejemplo, 9++ es 10. De esta forma, la variable i se incrementa a cada vuelta.

   using System;
   
   class BucleFor2{
       public static void Main()
       {
            int i;
            int j;

            for( i=0, j=10; i<j; i++, j--)
            {
                Console.WriteLine("( {0} , {1} )", i, j);
            }
       }
   }  

En el ejemplo anterior, las sentencias de inicialización y de iteración eran únicas, pero esto no tiene por qué ser así, de hecho se pueden utilizar varias sentencias separadas por comas. Por ejemplo, se pueden usar dos variables para controlar el bucle.

Por su parte, la expresión condicional del bucle for puede ser cualquier expresión que genere un valor booleano. En este caso se ha usado "i<j", pero también hubiera sido válida "i==5", "true" (el bucle se realizará indefinidamente) o "false" (el bucle no se realizará).

INSTRUCCÓN SWITCH

La instrucción switch es muy parecida a la estructura if-else-if, sólo que permite seleccionar entre varias alternativas de una manera más cómoda. Funciona de la siguiente manera: el valor de una expresión se prueba sucesivamente con una lista de constantes. Cuando se encuentra una coincidencia, se ejecuta la secuencia de instrucciones asociada con esa coincidencia. La forma general de la instrucción switch es la siguiente:

        switch( expresión ){
            case constante1:
                instrucciones;
                break;
            case constante2:
                instrucciones;
                break;
            ...
            default:
                instrucciones;
                break;
        } 
 
 
La sentencia default se ejecutará sólo si ninguna constante de las que siguen a case coincide con expresión. Es algo similar al else final de la instrucción if-else-if.
Sin más, vamos a por un ejemplo:


using System;

    class InstruccionSwitch{
        public static void Main()
        {
            string s;

            Console.WriteLine( "Elige hacer algo con los números 2 y 3");
            Console.WriteLine( "    + para sumarlos" );
            Console.WriteLine( "    - para restarlos" );
            Console.WriteLine( "    * para multiplicarlos" );
            Console.WriteLine( "    / para dividirlos (division entera)" );

            s = Console.ReadLine();

            switch(s){
                case "+":
                    Console.WriteLine("El resultado es {0}", 2+3);
                    break;
                case "-":
                    Console.WriteLine("El resultado es {0}", 2-3);
                    break;
                case "*":
                    Console.WriteLine("El resultado es {0}", 2*3);
                    break;
                case "/":
                    Console.WriteLine("El resultado es {0}", 2/3);
                    break;
                default:
                    Console.WriteLine("No te entiendo");
                    break;
            }
        }
    }

El cual solicita al usuario que inserte uno de los símbolos +-*/ , y con un switch compara los resultados para hacer diferentes acciones dependiendo del valor de s, que es la cadena de caracteres que almacena la elección del usuario. El resultado debería ser algo parecido a esto:

Elige hacer algo con los números 2 y 3
    + para sumarlos
    - para restarlos
    * para multiplicarlos
    / para dividirlos (division entera)
*
El resultado es 6

Como habrá notado, al final de todo case siempre hay una sentencia break. Esto no es obligatorio, puede haber en su lugar otra sentencia de salto como un goto inclusive en el caso default.
Siempre se deberá tener un break o un goto en cada caso a menos que la sentencia esté vacía. En esta situación se ejecutará el siguiente caso que viene en la lista. Si no se toma en cuenta ésto se obtiene un error en tiempo de compilación. Otros lenguajes, como C/C++ o Java no tienen esta restricción. La razón de adoptarla en C# es doble: por un lado, elimina muchos errores comunes y en segundo lugar permite al compilador reorganizar las sentencias de los case, y así permitir su optimización.
Ejemplo:
 using System;
  
    class InstruccionSwitch{
        public static void Main()
        {
            int voto;
            Console.WriteLine( "Qué tipo de musica te gusta más");
            Console.WriteLine( "1 - Rock" );
            Console.WriteLine( "2 - Clásica  (clasica cuenta como instrumental)" );
            Console.WriteLine( "3 - Instrumental" );
            Console.WriteLine( "4 - Alternativa (alternativo cuenta como Rock)" );
  
            voto = Int32.Parse(Console.ReadLine());
  
            switch(voto){
                case 1:
                    Console.WriteLine("Has votado por Rock o Alternativo");
                    break;
                case 2: //Debido a que no tiene ni un goto ni break y está vacía va al siguiente caso 
                case 3:
                    Console.WriteLine("Has votado por Clásica o Instrumental");
                    break;
                case 4:
                    goto case 1;
                default:
                    Console.WriteLine("No te entiendo");
                    break;
            }
        }
    }

 

SENTENCIA IF

Esta sentencia sirve para ejecutar unas instrucciones en caso de que se cumpla determinada condición. La forma completa de la instrucción if es donde la cláusula else es opcional. 


 Sintaxis:
if( condición ) { 
   instrucciones;  
   ... 
 } 
 else { 
   instrucciones; 
   ... 
 } 

Si la condición es verdadera, se ejecutarán las instrucciones dentro del bloque if, mientras que si es falsa, se ejecutará el bloque else. El valor que controla la sentencia if debe ser de tipo bool. El siguiente ejemplo te pide que introduzcas un número y dependiendo de si se cumple que dicho número es mayor que cero (condición), se ejecuta un bloque u otro.
La sentencia d = Double.Parse( Console.ReadLine() ); tal vez requiera algo de explicación adicional. En realidad, con Console.ReadLine() estamos leyendo lo que el usuario introduce por pantalla, que es una cadena de caracteres, y con Double.Parse lo que hacemos es interpretar esa cadena de caracteres y convertirla en un tipo numérico double, de forma que tendrá el valor del número que introduzcamos por la consola.
:


//programa que determina si un valor es positivo o negativo
    using System;

    class InstruccionIf{
    
        public static void Main()
        {
            double d;

            Console.WriteLine("Introduce un numero");
            d = Double.Parse( Console.ReadLine() );

            if( d>0 )
            {
                Console.WriteLine("El numero {0} es positivo", d);
            }
            else
            {
                Console.WriteLine("El numero {0} es negativo", d);
            }
        }
    }
 
NOTA: 
Operador Evalúa== Verdadero, si ambos valores son los mismos
!= Verdadero, si los valores son diferentes<, <=, >, >= Verdadero, si el valor cumple con la condición

Las instrucciones if se pueden anidar, y existe también una extensión de la sentencia if, la sentencia if-else-if. Su formato es el siguiente:

if( condicion1 )
        {
            instrucciones;
        }
        else if( condicion2 )
        {
            instrucciones;
         }
         ...
         else
         {
            instrucciones;
         }
 

Las instrucciones condicionales se evalúan de arriba a abajo. Tan pronto como se encuentra una condición true, se ejecuta la instrucción asociada con ella, y el resto de la escalera se omite. Si ninguna de las condiciones es true, se ejecutará la última instrucción else. La última instrucción else actúa como condición predeterminada, es decir, si no funciona ninguna de las otras pruebas condicionales, se realiza esta última instrucción. Si no existe esta instrucción else final y el resto de de las condiciones son falsas, entonces no se realizará ninguna acción.

using System;

    class IfElseIf{
        public static void Main()
        {
            string opcion;

            Console.WriteLine("Elija una opción (si/no)");
            opcion = Console.ReadLine();
            
            if( opcion=="si" )
            {
                Console.WriteLine( "Muy bien, ha elegido si" );
            }
            else if( opcion=="no" )
            {
                Console.WriteLine( "Ha elegido no" );
            }
            else{
                Console.WriteLine("No entiendo lo que ha escrito");
            }
        }
    } 
 
Este ejemplo le pide al usuario que elija una opción si/no y la procesa usando una 
estructura if-else-if. Si la opción no es ni "si" ni "no", entonces se 
ejecuta la sentencia else por defecto, que imprime por pantalla el 
mensaje "No entiendo lo que ha escrito"

CONTADOR

Un contador es aquella variable de tipo numérico entero que cumple la función de contar (como indica su nombre). Es usado para incrementar o decrementar su valor de a 1 (generalmente, porque puede ser cualquier otro valor). A continuación la sintaxis de como usarlo:

entero conta=0; //declaro una variable de tipo numerico entero

conta = conta + 1 //indica la manera de como usar un contador de manera incremental
conta = conta - 1 //indica la manera de como usar un contador de manera decremental

ACUMULADORES

El concepto de acumulador guarda relación estrecha con el de contador. Podríamos decir que el contador es un tipo específico de acumulador. Definiremos acumulador como un elemento cuyo contenido actual se genera a partir de su contenido precedente.
 
En general, los valores del acumulador se van generando a través de sumas (o restas) sucesivas.

A continuación te indico la sintaxis:

entero acumula=0, num=0;

LEER(num) //Ingreso un numero al programa

acumula = acumula + num //guarda el resultado parcial de sumas sucesivas
acumula = acumula - num //guarda el resultado parcial de restas sucesivas
acumula = acumula * num //guarda el resultado parcial de multiplicaciones sucesivas
acumula = acumula / num //guarda el resultado parcial de divisiones sucesivas

Estructura repetitiva while

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.
Representación gráfica de la estructura while:


estructura repetitiva while














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.

algoritmo números del 1 al 100 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.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EstructuraRepetitivaWhile1
{
    class Program
    {
        static void Main(string[] args)
        {
            int x;
            x = 1;
            while (x <= 100)
            {
                Console.Write(x);
                Console.Write(" - ");
                x = x + 1;
            }
            Console.ReadKey();
        }
    }
}
 

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:

estructura repetitiva while
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.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace EstructuraRepetitivaWhile2
{
    class Program
    {
        static void Main(string[] args)
        {
            int n,x;
            string linea;
            Console.Write("Ingrese el valor final:");
            linea=Console.ReadLine();
            n=int.Parse(linea);
            x=1;
            while (x<=n) 
            {
                Console.Write(x);
                Console.Write(" - ");
                x = x + 1;
            }
            Console.ReadKey();
        }
    }
}

jueves, 11 de julio de 2013

Bucles en C# Sharp While y For.

Los bucles
Permiten ejecutar un bloque de código varias veces seguidas.
Un bucle while ejecutará un trozo de código mientras una condición sea true. La condición es comprobada antes de ejecutar el código.
Hay otro tipo de bucle while que comprueba la condición después de ejecutar el código: do/while.
Los bucles while son los más simples y fáciles de entender, pero además, también son los más versátiles.
Cualquier otro tipo de bucle puede ser reescrito como un bucle while.