Archivo de la etiqueta: Lógica

Dando vueltas.. (Repitiendo :))


Sigamos con esto de la lógica. Imaginemos que tenemos que repetir una tarea determinada cantidad de veces (como las tablas de multiplicar).

Tomemos ese ejemplo. Digamos, la tabla del 15 (de las otras imagino, te sabrás varias de memoriaSonrisa ).

Si dibujamos el proceso (imaginando la tabla de los primeros 20 valores), sería algo así:

Diagrama Tabla de Multiplicar

En principio, esto podría codificarse “literalmente”:

 VB

    Private Sub Tabla()
        Dim Contador As Integer = 1
        Dim Resultado As Integer
Seguir:
        If Contador > 20 Then
            Exit Sub
        End If
        Resultado = Contador * 15
        Print(Resultado)
        Contador = Contador + 1
        GoTo Seguir
    End Sub

 

CS

        private void Tabla()
        {
            int Contador = 1;
            int Resultado = 0;
        Seguir:
            if (Contador > 20)
            {
                return;
            }
            Resultado = Contador * 15;
            Print(Resultado);
            Contador = Contador + 1;
            goto Seguir;
        }

Nota: la sentencia Print en C# no existe. ahora vemos como se hace esto en realidad para probar.

Mejor un bucle.

Los lenguajes de programación implementan formas sintácticas optimizadas para estas cosas; los bucles For.

 

 VB

    Private Sub Tabla()
        Dim Resultado As Integer
        For Contador As Integer = 1 To 20
            Resultado = Contador * 15
            Debug.WriteLine(Resultado)
        Next
    End Sub

CS

        private void Tabla()
        {
            int Resultado = 0;
            for (int Contador = 1; Contador <= 20; Contador++)
            {
                Resultado = Contador * 15;
                Debug.WriteLine(Resultado);
            }
        }

La sintaxis de for admite indicar además los “pasos” en los que se ejecutan las  repeticiones, pudiendo hacerse en pasos de más de una unidad (de a dos, de a tres, etc.), o inclusive, en reversa (Indicando el paso como un valor negativo y el valor de inicio mayor que el final)

        For Contador As Integer = 20 To 1 Step -1

            for (int Contador = 20; Contador >= 1; Contador -= 1)

Repitiendo sin contar.

A veces es necesario hacer tareas por  cada uno de los elementos de un conjunto. Por supuesto se podrían contar cuantos son y meterlos dentro de un for.  Pero existe una sintaxis específica para esto, que podríamos parafrasear como “por cada uno de estos cosos…”

VB

        For Each elemento In estalista

        Next

CS

            foreach (elemento in estalista)
            {
                
            }

Repitiendo (mientras haga falta).

Esta sería la otra forma posible de repetición. Mientras se cumpla una condición se debe realizar la tarea.

Esto se realiza con dos palabras reservadas (Do y Loop), donde una (y solo una) de ellas lleva adosada la condición con la expresión While  o la expresión  Until que determinan el “mientras” o el “hasta que”.

VB

       Do While condición

        Loop
        '
        Do Until condición

        Loop
        Do

        Loop While condición
        '
        Do

        Loop Until condición

CS

            while (condición)
            {
            }
            //
            while (!(condición))
            {
            }
            //
            do
            {
            } while (condición);
            //
            do
            {
            } while (!(condición));

Poner la condición en el inicio condiciona si la tarea se realiza o no, ANTES de comenzar.

En cambio,  si la condición está en la instrucción final, significará que al menos una vez se hará, antes de evaluar la condición.

Anuncios

Pero… ¿Que es un programa?


Acostumbrados estamos a usar programas de todo tipo.

Pero la pregunta del título no es tan fácil de responder.

Los programas, como es obvio, evolucionaron, pero si podemos decir que hay algo básico que sigue siendo cierto:

Un programa es una sucesión de acciones.

Antaño, cuando programar no era tan sencillo (ni barato Sonrisa ), era necesario tener bien claro cada paso. Un programa podían ser de cientos de líneas… o sea cientos de tarjetas perforadas… que si había un error, habría que re codificar. Tiempo, costo, etc.

Por eso, se diseñó una metodología para esquematizar el programa y hacer pruebas de su funcionalidad previas a cualquier codificación.

La diagramación lógica.

Se basa en esquematizar un proceso paso a paso. Hay diseños estándar para representar los distintos tipos de actividades.

image 

Los “terminadores” (Inicio y fin), establecen precisamente eso, los extremos del proceso.

Las acciones, como se ve en el diagrama, se representa por rectángulos.

Por supuesto, a estas alturas, nadie usa diagramación lógica para programar. 

Sin embargo, en este blog haré uso de ellos; de cuando en vez,  echaré mano a ellos, para contarte mejor de que va algo.

Ejemplo simple (y, de paso, sentencias de control de flujo).

Si bien ahora el .Net Framework es capaz de hacer matemática de fechas (en realidad, desde bastante antes, lenguajes como Visual Basic, o los dBase, ya lo tenían), hubo épocas en que las fechas se debían ingresar en campos separados (día, mes y año), y luego validarla adecuadamente. Insisto, no es una problemática actual pero sirve para equiparar diagramas y códigos.

Aunque parezca simple, se lleva varios pasos.

  • El mes no puede ser menor de uno.
  • El mes no puede ser mayor que doce.
  • El día no puede ser menor de uno
  • El día no puede ser mayor que 31
  • Si el mes es abril, junio, setiembre o noviembre, el día no debiera ser mayor que 30.
  • Si el mes es febrero, no debiera ser mayor que 28, excepto si el año es bisiesto, que no podrá ser mayor que 29.

image

Bueno, como se ve, los rombos simbolizan preguntas (en realidad, toma de decisión lógica). No existe un “estándar” para indicar las salidas, aunque suelen marcarse con “si y no”. En el diagrama, usé colores, que también sirve.

La sentencia de decisión lógica.

En definitiva, es una pregunta:

SI sucede esto ENTONCES hacemos esto.

VB

        If condición Then
            acción()
        End If

CS

            if (condición)
            {
                acción;
            }

En ocasiones, es cuestión de tomar acciones alternativas, dependiendo del valor lógico, como la decisión del año bisiesto:

image

VB

        If Bisiesto Then
            If Día > 29 Then
                acción()
            End If
        Else
            If Día > 28 Then
                acción()
            End If
        End If

CS

            if (Bisiesto)
            {
                if (Día>29)
                {
                 acción;           
                }
            }
            else
            {
                if (Día > 28)
                {
                    acción;
                }
            }

En conclusión, el diagrama completo (exceptuando que en realidad las variables no existen), sería

VB

        EsVálida = True
        If Mes < 1 Then
            EsVálida = False
            Return EsVálida
        End If
        If Mes > 12 Then
            EsVálida = False
            Return EsVálida
        End If
        If Día < 1 Then
            EsVálida = False
            Return EsVálida
        End If
        If Día < 1 Then
            EsVálida = False
            Return EsVálida
        End If
        If Día > 31 Then
            EsVálida = False
            Return EsVálida
        End If
        If Mes = 4 Then
            If Día > 30 Then
                EsVálida = False
                Return EsVálida
            End If
        End If
        If Mes = 6 Then
            If Día > 30 Then
                EsVálida = False
                Return EsVálida
            End If
        End If
        If Mes = 9 Then
            If Día > 30 Then
                EsVálida = False
                Return EsVálida
            End If
        End If
        If Mes = 11 Then
            If Día > 30 Then
                EsVálida = False
                Return EsVálida
            End If
        End If
        If Mes = 2 Then
            Bisiesto = (Año Mod 4 = 0)
            If Bisiesto Then
                If Día > 29 Then
                    EsVálida = False
                End If
            Else
                If Día > 28 Then
                    EsVálida = False
                End If
            End If
        End If
        Return EsVálida

CS

            EsVálida = true;
            if (Mes < 1)
            {
                EsVálida = false;
                return EsVálida;
            }
            if (Mes > 12)
            {
                EsVálida = false;
                return EsVálida;
            }
            if (Día < 1)
            {
                EsVálida = false;
                return EsVálida;
            }
            if (Día < 1)
            {
                EsVálida = false;
                return EsVálida;
            }
            if (Día > 31)
            {
                EsVálida = false;
                return EsVálida;
            }
            if (Mes == 4)
            {
                if (Día > 30)
                {
                    EsVálida = false;
                    return EsVálida;
                }
            }
            if (Mes == 6)
            {
                if (Día > 30)
                {
                    EsVálida = false;
                    return EsVálida;
                }
            }
            if (Mes == 9)
            {
                if (Día > 30)
                {
                    EsVálida = false;
                    return EsVálida;
                }
            }
            if (Mes == 11)
            {
                if (Día > 30)
                {
                    EsVálida = false;
                    return EsVálida;
                }
            }
            if (Mes == 2)
            {
                Bisiesto = (Año % 4 == 0);
                if (Bisiesto)
                {
                    if (Día > 29)
                    {
                        EsVálida = false;
                    }
                }
                else
                {
                    if (Día > 28)
                    {
                        EsVálida = false;
                    }
                }
            }
            return EsVálida;

NOTA: Este código dista de ser óptimo y NO debe usarse como ejemplo…. solo es útil para entender la lógica. Ya veremos otras versiones.

Hasta la próxima.