Lógica de Programación (17) - Estructura hacer-mientras

En la lección anterior conocimos la estructura mientras-hacer, la cual evalúa una condición inmediatamente al inicio de la estructura, lo cual puede resultar en que el bloque de instrucciones que forman el cuerpo del ciclo no se repitan ni una sola vez.

La estructura que vamos a conocer hoy es muy parecida pero con una diferencia crucial: la condición se evalúa hasta el final de la estructura. Esta es la sintaxis de la estructura hacer-mientras:

hacer

   sentencias

mientras (condición)

Esta particularidad permite que el cuerpo del ciclo se repita al menos una vez, mientras que la segunda repetición dependerá del resultado de la evaluación de la condición. Esta puede ser una elección correcta cuando necesitamos que unas determinadas instrucciones se ejecuten por lo menos una vez (como presentar un menú de opciones al usuario), pero puede conducir a errores si no se usa con cuidado. Por ejemplo, supongamos que necesitamos evaluar una lista de números; si la lista está vacía y tratamos de ejecutar instrucciones sobre ella sin verificar su contenido primero, generaremos muchos errores de programación. Por eso es importante conocer las diferencias entre los distintos tipos de estructuras de repetición, pues así sabremos cual nos conviene usar según sea la lógica necesaria para el algoritmo.

Veamos un ejemplo: en este algoritmo solicitamos al usuario las calificaciones de un grupo de alumnos (se desconoce la cantidad) y calculamos el promedio de las mismas.

algoritmo Promedio
var
   entero: cal, suma, cont
   real: promedio
   caracter: respuesta
inicio
   suma <- 0
   cont <- 0
   hacer
      escribir("Escribe la calificación:")
      leer(cal)
      suma <- suma + cal
      cont++;
      escribir("¿Deseas capturar otra calificación?" S/N")
      leer (resp)   
   mientras (resp = 'S') o (resp = 's')
   promedio <- suma/cont
   escribir("El promedio de las calificaciones capturadas es: " + promedio)
fin

En el ejemplo podemos ver que el cuerpo del ciclo se va a repetir al menos una vez, dado que la condición (mientras) se ejecuta hasta el final. Dentro del cuerpo del ciclo leemos la calificacion, la acumulamos en la suma y entonces preguntamos al usuario si desea capturar otra calificación, es decir, si desea dar otra vuelta al ciclo. Dependiendo de su respuesta, el cuerpo del ciclo se repetirá (o no). También usamos la variable cont para hacer un conteo de las calificaciones capturadas, de modo que podamos calcular el promedio una vez que se terminaron de capturar todas.

Esta es la prueba de escritorio del altoritmo para cuatro calificaciones:

Y este es el programa corriendo en C#:



Mira otro ejemplo de un algoritmo que recibe un número y nos regresa el número con los dígitos invertidos (por ejemplo, si se introduce un 198, nos regresa un 891):

algoritmo Invertir_numero
var
   entero: num, digitoSig
inicio
   escribir("Escribe un número: ")
   leer(num)
   escribir("El número en orden inverso es ")
   hacer
      digitoSig <- num mod 10
      escribir(digitoSig)
      num = num div 10
   mientras (num > 0)
fin

Mira la prueba de escritorio:

Y el programa funcionando en C# :



Como vemos, el ciclo hacer-mientras tiene sus usos y ventajas sobre la estructura mientras-hacer. Perp dependerá de las necesidades de nuestro programa la elección que hagamos de la estructura de repetición más adecuada. En la próxima lección conoceremos una estructura de repetición más, pero por ahora toca practicar. ¡Hasta la próxima!

ACTIVIDADES DE APRENDIZAJE

• Repite los cuatro ejercicios de la lección anterior, pero ahora usa la estructura hacer-mientras.

Enlace: Índice del curso

Sigue leyendo...

.NET Fiddle, edita y ejecuta código C# sin salir del navegador

Una de las herramientas más útiles que me he encontrado recientemente en la web es .NET Fiddle, un sitio que nos permite editar código C# y ejecutarlo para ver su funcionamiento en tiempo real.

Esta es una herramienta bastante útil para cuando queremos probar rápido algún código, dado que nos evita tener que abrir en nuestro PC alguna herramienta más compleja como Visual Studio.NET. Según los propios creadores del sitio, ese es precisamente su objetivo.

En .NET Fiddle podemos crear proyectos de consola o incluso MVC usando lenguajes como C#, Visual Basic o F# para probarlos en tiempo real dentro de nuestro navegador, sin importar si estás bajo ambiente Windows, Linux, Mac o ChromeOS. También nos permite guardar nuestros "fiddles" o bloques de código que vamos creando y probando. Tiene también una impresionante herramienta que traduce de C# a Visual Basic y viceversa, entre muchas otras funciones.

Una de las características que más me gustó es la posibilidad de incluir tus fiddles en otros sitios web, función que empecé a usar en las más recientes lecciones del curso de Lógica de Programación para demostrar el funcionamiento de algunos de los ejemplos propuestos en las lecciones. El fiddle no solo incluye el código sino que además puede ejecutarse al instante.

Lo mejor de todo es que .NET Fiddle es totalmente gratuita y pueden crear una cuenta de usuario para acceder a todas las funciones del sitio. ¡Vale la pena probarlo!

Sigue leyendo...

Lógica de Programación (16) - Estructura mientras-hacer

La primera estructura de repetición que vamos a conocer es la estructura mientras-hacer. En esta estructura, un conjunto de instrucciones se va a repetir mientras que se cumpla una determinada condición. Esta estructura sigue esta sintaxis:

mientras (condición) hacer

   sentencias

fin_mientras

En esta estructura, lo primero que sucede es que se evalúa la condición (que es una expresión booleana). Si el resultado es falso, entonces no se toma ninguna acción y el algoritmo sigue su camino hacia las sentencias que estén después del ciclo. Es decir, el ciclo es ignorado. Pero si la expresión resulta verdadera, entonces se ejecutan las sentencias que forman el cuerpo del ciclo, después de lo cual se vuelve a evaluar la condición. Este proceso se repite vez tras vez mientras la condición sea verdadera.

¿Recuerdan el ejemplo que citamos en la lección anterior? en dicho ejemplo, necesitabamos leer el valor de 10 números para calcular su suma. Usando la estructura mientras-hacer, el ejemplo quedaría de este modo:

algoritmo Suma

var

   entero: contador, numero, suma

inicio

   suma <- 0

   contador <- 1

   mientras (contador <= 10) hacer

      escribir("Escribe un número:")

      leer(numero)

      suma <- suma + numero

      contador ++

   fin_mientras

   escribir("La suma de los números dados es: " + suma)

fin

En este algoritmo, lo primero que hacemos es inicializar las variables suma y contador. Dado que suma será la variable donde vamos a almacenar el resultado de la suma de todos los números, la inicializamos en cero. Por otro lado, la variable contador será la que nos ayude a determinar cuando nuestro ciclo mientras va a detenerse. Como la condición indica que el contador debe llegar a 10, lo inicializamos en 1 para permitir la primera vuelta del ciclo. Una vez que inicializamos las variables, evaluamos la condición (contador <= 10). Como la primera vez esta condición resulta verdadera, ejecutamos el cuerpo del ciclo. Dicho cuerpo está formado por cuatro sentencias: en las primeras dos nos ocupamos de leer el número que vamos a sumar; en la tercera, nos ocupamos de acumular el valor dado en la variable suma (es decir, a suma le asignamos el valor que ya tenía la variable mas el valor del número dado); finalmente, la sentencia contador++ se encarga de incrementar en 1 el valor de la variable contador, de modo que, ahora, su valor es 2 y entonces volvemos a evaluar la condición. Este proceso se repetirá hasta que la variable contador tenga un valor de 11, en cuyo caso la condición resultará falsa y el cuerpo del ciclo ya no se ejecutará de nuevo.

Esta es la prueba de escritorio para este ejemplo:

Y este es el programa escrito en C#, de modo que puedas ver su funcionamiento real:

Esta estructura podemos usarla para, por ejemplo, pedir una contraseña a un usuario tantas veces como sea necesario hasta que introduzca una contraseña válida. Mira:

algoritmo Password

var

   cadena: pass

inicio

   escribir("Introduce tu contraseña para continuar: ")

   leer(pass)

   mientras (pass <> "123456") hacer

      escribir("Contraseña equivocada. Inténtalo de nuevo.")

      leer(pass)

   fin_mientras
   escribir("Finalizado")

fin

En este ejemplo, repetiremos la lectura del valor de la variable pass mientras que el usuario proporcione un valor diferente a "123456", que es la contraseña esperada. A diferencia del ejemplo anterior, aquí no sabemos realmente cuántas veces se va a repetir el ciclo, dado que depende del valor que introduzca el usuario. Puede ser cero, una o mil veces. Precisamente esta es una de las características del ciclo mientras: si la condición se evalúa como falsa desde el principio, el ciclo se ejecuta un total de cero veces. Puede que suene como algo inútil, pero en este caso, esa es la acción deseada (si el usuario introduce su contraseña correctamente desde el principio, no tiene caso indicarle que hubo un error).

Aquí está la prueba de escritorio para este algoritmo:

Y su implementación en C# para que pruebes su funcionamiento:



Observemos que en ambos ejemplos contamos con una variable que es la que controla la repetición del ciclo (contador y pass, respectivamente). Estas variables son inicializadas ya sea por asignación (contador <- 1) o por lectura (leer(pass)). También, son usadas en la condición que controla el ciclo comparando su valor con un valor esperado. Finalmente, los valores de ambas variables son modificados dentro del cuerpo del ciclo para poder regresar a evaluar la condición una vez más. En el primer ejemplo la modificación es un incremento de valor (contador++) mientras que en el segundo se trata de una lectura (leer(pass)). Este último paso es importante porque, si no se hiciera, nos llevaría a un ciclo infinito pues el valor de la variable siempre es aquél con el que se le inicializó.

En la siguiente lección conoceremos una variación de este ciclo: la estructura hacer-mientras que, aunque en esencia hace lo mismo, veremos que tiene una importantísima diferencia con la estructura que acabamos de conocer. ¡Hasta la próxima!

ACTIVIDADES DE APRENDIZAJE

1. Escribe un algoritmo que muestre en pantalla 100 veces la frase: "Programar ciclos es fácil".
2. Escribe un programa que reciba 50 calificaciones de alumnos y calcule y muestre el promedio de todas ellas.
3. Modifica el programa anterior suponiendo que no se sabe cuántas calificaciones se van a capturar. Pregunta al usuario cada vez si desea capturar otra calificación.
4. Escribe un programa que lea una lista de 200 números y al finalizar nos muestre: (a) la suma de todos los números, (b) la cantidad de números que fueron positivos, (c) la cantidad de números que fueron negativos, (d) la suma de los números pares y (e) la suma de los números impares.

Enlace: Índice del curso

Sigue leyendo...

Lógica de Programación (15) - Estructuras repetitivas

Los programas que hemos creado hasta ahora incluyen conceptos de programación esenciales tales como entradas, salidas, asignaciones, expresiones y operaciones, sentencias secuenciales y estructuras de selección.  Sin embargo, muchos de los problemas con los que nos topamos en la práctica del desarrollo de software requieren de características de repetición de instrucciones el las que algunos cálculos o sentencias se repiten una y otra vez, utilizando diferentes conjuntos de datos. Algunos ejemplos de tareas de repetición son las verificaciones de entradas de datos de usuario hasta que se introduce una entrada aceptable (por ejemplo una contraseña válida), acumulación de valores, aceptación constante de valores de entrada, dibujar muchos renglones de una tabla de datos, etc.

Las estructuras que repiten una secuencia de instrucciones un número determinado de veces se llaman ciclos y se le llama iteración al hecho de repetir la ejecución de una secuencia de acciones. Tratemos de entender la necesidad de estas estructuras con un ejemplo. Supongamos que necesitamos leer una lista de 10 números para calcular la suma de todos ellos. El algoritmo que resuelve este problema se vería algo así:

algoritmo Suma

var

   entero: suma, numero

inicio

   suma <- 0

   leer(numero)

   suma <- suma + numero

   leer(numero)

   suma <- suma + numero

   leer(numero)

   suma <- suma + numero

   leer(numero)

   suma <- suma + numero

   leer(numero)

   suma <- suma + numero

   leer(numero)

   suma <- suma + numero

   leer(numero)

   suma <- suma + numero

   leer(numero)

   suma <- suma + numero

   leer(numero)

   suma <- suma + numero

       leer(numero)

   suma <- suma + numero

   escribir(suma)

fin

Como vemos, este algoritmo está repitiendo diez veces las mismas dos instrucciones. Puede que no sea tan complicado crear este algoritmo pero, ¿y si tuviéramos que calcular la suma de 1000 números en vez de sólo 10? Peor aún, ¿qué tal si no conozco la cantidad exacta de números que se van a sumar y en su lugar debo preguntar al usuario si desea introducir un número más y, en caso afirmativo, leerlo y sumarlo? En ese caso la situación se complica todavía más. Les estructuras repetitivas nos ayudarían a resolver cualquiera de los dos problemas planteados y, en programación, contamos con las siguientes:

• Estructura mientras (while)
• Estructura hacer-mientras (do-while)
• Estructura repetir (repeat)
• Estructura desde/para (for)

Cada una de ellas, aunque en esencia hace lo mismo (repetir instrucciones), tiene sus propias características, ventajas, desventajas y usos, todos los cuales iremos conociendo a partir de la siguiente lección.

¡Hasta la próxima!


Enlace: Índice del curso

Sigue leyendo...

Lógica de Programación (14) - Estructuras de selección anidadas

En la lección anterior conocimos la alternativa múltiple, la cual nos permite dividir el flujo de nuestros programas en n caminos distintos. Sin embargo, esta estructura tiene una limitante muy importante: los valores que determinan el flujo que se debe seguir debe ser un valor cierto y conocido, además de pertenecer a alguno de los tipos entero, caracter o cadena únicamente. Pero, ¿qué hacemos si, para determinar el camino a seguir en nuestro algoritmo, necesitamos considerar un rango de valores en lugar de un valor en particular? Por ejemplo, tal vez necesitemos un programa que determine qué dia debe inscribirse a la escuela una persona en base a su fecha de nacimiento; si la fecha está entre el 1 y el 15 de enero se inscribirá en un día particular; si la fecha está entre el 16 y el 31 de enero, la fecha será otra y así sucesivamente. En dicho caso, necesitamos trabajar con rangos en vez de con valores fijos, y ahi es donde la alternativa múltiple falla. 

Para resolver este problema, podemos usar las alternativas simple o doble (que ya conocemos) contenidas una dentro de otra. Es decir, una estructura si-entonces puede contener otra, y esta a su vez contener otra y así sucesivamente cualquier cantidad de veces. A estas estructuras las llamamos anidadas o en cascada, y la podemos construir siguiendo este formato:

si (condición1) entonces

   <acciones>

si_no

   si (condición2) entonces

      <acciones>

   si_no

      si (condición3) entonces

         <acciones>

      si_no

         ...

         ...

      fin_si

   fin_si

fin_si

Una estructura de selección múltiple puede constar de una serie de alternativas simples o dobles, unas interiores a otras. Como esto puede volverse bastante complejo para que el algoritmo resulte claro de leer, se recomienda usar indentación (sangrías), de modo que exista una correspondencia entre las palabras reservadas si y fin_si.

En este ejemplo, leemos tres números para determinar cuál de ellos es el mayor usando estructuras de selección anidadas:

algoritmo Mayor

var

   real: A, B, C, Mayor

inicio

   leer(A,B,C)

   si (A > B) entonces

      si (A > C) entonces

         Mayor <- A

      si_no

         Mayor <- C

      fin_si

   si_no

      si (B > C) entonces

         Mayor <- B

      si_no

         Mayor <- C

      fin_si

   fin_si

   escribir("El número mayor es: " + Mayor)

fin

Estas son algunas pruebas de escritorio para demostrar el funcionamiento del algoritmo en distintos escenarios:

Y este es el programa escrito en el lenguaje de programación C# (¡incluso pueden probar cómo funciona!)

Este otro ejemplo recibe tres números y los muestra ordenados de mayor a menor:

algoritmo Ordenar

var

   real: a, b, c

inicio

   escribir("Dame 3 números: ")

   leer (a, b, c)

   si (a > b) entonces

      si (b > c) entonces

         escribir(a, b, c)

      si_no

         si (c > a) entonces

            escribir(c, a, b)

         si_no

            escribir(a, c, b)

         fin_si

      fin_si

   si_no

      si (a > c) entonces

         escribir (b, a, c)

      si_no

         si (c > b)

            escribir(c, b, a)

         si_no

            escribir(b, c, a)

         fin_si

      fin_si

   fin_si

fin

Mira las pruebas de escritorio de este algoritmo para distintos casos:

Un ejemplo más, para terminar de clarificar este asunto. Ahora tenemos un programa en el cual asignamos a un cliente un estatus y un porcentaje de descuento aplicable de acuerdo a los años de antigüedad que tiene comprando con una tienda. Si tiene hasta 1 año, su estatus será "Nuevo" y no tiene descuento; si tiene hasta 2 años, su estatus será "Regular" y accede a un 3% de descuento; si tiene hasta 4 años, su estatus será "Constante" y su descuento será del 7% y si tiene más de 4 años su estatus será "VIP" y su descuento será del 15%. Mira el algoritmo:

algoritmo Estatus_cliente

var

   real: años

   entero: descuento

   cadena: estatus

inicio

   escribir("¿Cuantos años tiene comprando el cliente?")

   leer(años)

   si (años <= 1) entonces

      estatus <- "Nuevo"

      descuento <- 0

   si_no

      si (años <= 2) entonces

         estatus <- "Regular"

         descuento <- 3

      si_no

         si (años <= 4) entonces

            estatus <- "Constante"

            descuento <- 7

         si_no

            estatus <- "VIP"

            descuento <- 15

         fin_si

      fin_si

   fin_si

   escribir("Estatus del cliente: " + estatus)

   escribir("Descuento aplicado: " + descuento)

fin

Estas son algunas pruebas para este algoritmo:

En cada uno de estos tres ejemplos usamos decisiones sucesivas para poder seleccionar las instrucciones que hemos de ejecutar. Como vemos, las estructuras anidadas nos permiten llegar donde la alternativa múltiple no, aunque el precio puede llegar a ser la legibilidad de nuestros algoritmos.

Esta es la última de las estructuras de selección que conoceremos. En la siguiente lección comenzaremos a analizar otro tipo de estructuras muy útiles: las estructuras de repetición. Pero primero, hay que practicar lo que ya hemos aprendido hasta ahora. ¡Hasta la próxima!

ACTIVIDADES DE APRENDIZAJE

1. Reescribe el algoritmo Dia_Semana (primer ejemplo de la lección 13) para usar estructuras de decisión anidadas en lugar de la alternativa múltiple.
2. Escribe un algoritmo que tome como datos tres números enteros y nos indique cuál de ellos es el valor central.
3. Un ángulo se considera agudo si es menor a 90°, obtuso si es mayor a 90° y menor a 180°, recto si es igual a 90° y llano si es igual a 180°. Utilizando esta información, escribe un algoritmo que acepte la medida de un ángulo en grados y nos muestre el tipo de ángulo correspondiente.
4. Los empleados de una fábrica trabajan en dos turnos: diurno y nocturno. Se desea calcular el salario diario de acuerdo con las siguientes condiciones:
• el pago por cada hora diurna es de 5 dólares
• el pago de cada hora nocturna es de 8 dólares
• en caso de que sea domingo, el pago por hora se incrementa en 2 dólares para el turno diurno y en 3 dólares para el turno nocturno
5. Una agencia de viajes necesita un programa que le ayude a determinar el costo de un boleto de avión de ida y vuelta para sus clientes, de acuerdo a las siguientes condiciones:
• el precio se calcula de acuerdo a la distancia en kilómetros del destino
• si la distancia es superior a 800 km y el viajero piensa quedarse en el destino por más de 7 días, se le aplica un descuento del 30% sobre el precio final
• el precio por kilómetro es de 8.5 dólares

Enlace: Índice del curso

Sigue leyendo...

Los desarrolladores: felices con su trabajo, bien pagados y con seguridad laboral - Un estudio de StackOverflow

Cada año, el sitio StackOverflow, una comunidad dedicada a desarrolladores, lleva a cabo una encuesta para determinar el perfil del desarrollador moderno. Este año, ha arrojado resultados muy interesantes:

1) Luxemburgo es el país con más desarrolladores per capita

2) La edad de los desarrolladores promedia los 28.9 años

3) El campo sigue siendo dominado por hombres...

4) ...pero son más las mujeres que se integran a la profesión que los hombres

5) La mayoría de los desarrolladores son autodidactas...

6) ...y están bastante satisfechos con su trabajo.

7) Javascript es el lenguaje de desarrollo más popular

8) En Noruega toman más café

9) C# es de los lenguajes mejor pagados

10) Y la gran mayoría goza de un empleo seguro de tiempo completo

No cabe duda que la labor del desarrollador domina el campo laboral y lo seguirá haciendo por mucho tiempo. Si andan en busca de alguna opción laboral alternativa o definitiva, ¿por qué no involucrarse en el desarrollo de software? Y si no saben programar, ¿por qué no empezar con el curso de Lógica de Programación que comparto en este mismo espacio? Segurito no se arrepentirán.

Enlaces: 
StackOverflow developer survey 2015
Quartz.com - Ten charts that paint a fascinating portrait of the modern-day programmer

Sigue leyendo...

Pruebas de escritorio, aliadas del programador

En el curso de Lógica de Programación hemos estado aprendiendo a escribir algoritmos, que no son más que un conjunto de instrucciones con las que pretendemos resolver un problema, las cuales posteriormente serán implementadas en algún lenguaje de programación.

Escribir un algoritmo para nuestros programas es importante porque representa la lógica entera en la que nos vamos a basar al momento de escribir el programa en un lenguaje específico. Sin embargo, ¿cómo podemos saber si la lógica de nuestro algoritmo es la correcta? ¿cómo saber si va a arrojar los resultados deseados? Después de todo, cuando escribimos un programa directamente en la computadora podemos ejecutarlo para ver si arroja los resultados esperados. Pero el algoritmo está en papel, asi que  ¿cómo podemos probarlo?

Ahi es donde entran en juego las pruebas de escritorio. Una prueba de escritorio es una herramienta muy útil que nos permite "ejecutar", en papel, un algoritmo determinado para ver si se comporta como esperamos y para verificar si los resultados son los deseados. Esta ejecución "a mano" se puede realizar mediante una tabla en la que registremos tanto las instrucciones como las variables, constantes y salidas que forman a nuestro algoritmo. Por cada instrucción que vayamos "ejecutando" manualmente, veremos cómo se van comportando las diferentes variables de nuestro programa y podremos ir registrando las salidas esperadas.

Veamos cómo funcionan con un ejemplo muy sencillo. El siguiente es un algoritmo para calcular el salario a pagar a un empleado y forma parte de la novena lección del curso de Lógica de Programación que encuentran en este mismo espacio. El listado de pseudocódigo es el siguiente:

algoritmo Calcular_Pago

var

   entero : num_empleado, horas_trabajadas

   real : pago_hora, pago_bruto, impuestos, pago_neto

   cadena : nombre_empleado

const

   tasa_impuesto = 2.3

inicio

   leer (num_empleado, nombre_empleado, horas_trabajadas, pago_hora)

   pago_bruto <- horas_trabajadas * pago_hora

   impuestos <- pago_bruto * tasa_impuesto / 100

   pago_neto <- pago_bruto - impuestos

   escribir("Desglose de nómina para el empleado " + nombre_empleado + " con número " +   num_empleado)

   escribir("Pago Bruto : " + pago_bruto)

   escribir("Deducciones : " + impuestos)

   escribir("Pago Neto : " + pago_neto)

fin

Una prueba de escritorio para este algoritmo, podría registrarse en una tabla como la siguiente:

(Clic para agrandar)

En esta tabla iremos registrando tanto las instrucciones como las constantes, variables y salidas de nuestro algoritmo, conforme lo vayamos "ejecutando". Creamos una columna para las instrucciones (la cual es opcional y se usa sólo si el algoritmo no es demaisado complejo), una columna para cada una de las constantes y variables y una columna para las salidas esperadas. Comenzamos con la primera instrucción:

(Clic para agrandar)

Esta primera instrucción consiste en leer los valores para nuestras variables de entrada, por lo que nos toca a nosotros proporcionar datos de prueba para procesarlos en el algoritmo. Incluimos también el valor de la constante porque ya está definido desde el principio. Una vez cargada la primera instrucción, continuamos con la segunda:

(Clic para agrandar)

Como vemos, en esta segunda instrucción nos ocupamos de hacer los cálculos para la variable pago_bruto, asi que registramos el resultado en la columna correspondiente. De este modo continuamos "ejecutando todas las instrucciones de nuestro algoritmo hasta lograr una tabla de la ejecución completa que debería verse algo así:

(Clic para agtrandar)

Podemos observar que hemos registrado también las salidas esperadas, las cuales ocurren sólo hasta que hemos terminado de procesar los datos de entrada.

Las pruebas de escritorio son una de las herramientas más útiles que tiene el programador en su arsenal, porque le permiten asegurarse de que su lógica de programación funciona como es esperado. Desde luego, esto no implica que el programa final vaya a estar libre de errores, pero sí nos ayuda a darnos una mejor idea de dónde podrían surgir.

Sigue leyendo...

Lógica de Programación (13) - Alternativa múltiple (segun_sea, caso)

Hemos conocido ya las alternativas simple y doble, las cuales nos proporcionan uno o dos caminos alternativos para nuestros programas, respectivamente. Sin embargo, ¿qué pasaría si necesitamos más de dos opciones? Por ejemplo, en el caso de la resolución de una ecuación de segundo grado (cuyo algoritmo ya resolvimos en la lección anterior), nos hace falta considerar una opción: que el discriminante (b**2-4*a*c) sea igual a cero. Este problema puede resolverse de dos maneras: usando estructuras dobles anidadas o en cascada (como veremos más delante) o mediante el uso de la alternativa múltiple.

La alternativa múltiple evalúa una expresión que puede tomar n valores distintos. Según sea el valor que tome la expresión, el flujo del programa seguirá un camino determinado entre los n posibles.

Al escribir algoritmos, la alternativa múltiple se representa de este modo:

segun_sea (expresion) hacer

   caso valor_1:

         instrucciones_1

   caso valor_2:

         instrucciones_2

   caso valor_3:

         instrucciones_3

   ...

   caso valor_n:

         instrucciones_n

   [otros:

         instrucciones_otros]

fin_segun

Sobre esta estructura, podemos comentar lo siguiente:

• la expresión que define el camino que habrá de seguirse puede ser desde una simple variable hasta una expresión más compleja, aunque cabe señalar que el resultado de esta expresión siempre debe ser un valor conocido, ya sea entero, caracter o cadena de caracteres
• puede haber tantos elementos caso como caminos diferentes necesitemos en nuestro algoritmo
• el elemento otros contiene instrucciones que se ejecutarán sólo en caso de que la variable o expresión no resulte en ninguno de los valores propuestos para los distintos caminos y es un elemento opcional (aunque es recomendable que siempre esté presente)

Pero para entender mejor esta estructura, vayamos directamente a un ejemplo. El siguiente algoritmo sirve para mostrarle al usuario qué dia de la semana es en función del valor de una variable numérica llamada dia, que será proporcionada por el mismo usuario:

algoritmo Dia_Semana

var

   entero: dia

inicio

   escribir("Escribe un número entre 1 y 7: ")

   leer(dia)

   segun_sea (dia) hacer

      caso 1:

         escribir("LUNES")

      caso 2:

         escribir("MARTES")

      caso 3:

         escribir("MIÉRCOLES")

      caso 4:

         escribir("JUEVES")

      caso 5:

         escribir("VIERNES")

      caso 6:

         escribir("SÁBADO")

      caso 7:

         escribir("DOMINGO")

      otros:

         escribir("Error. El número debe estar entre 1 y 7.")

   fin_segun

fin

Como vemos en este ejemplo, el valor que el usuario proporcione determina lo que se escribe en pantalla. Por otro lado, si el usuario nos proporciona un número que no esté entre 1 y 7 (a pesar de que se le instruye a hacerlo), entonces se ejecuta la sentencia del elemento otros y se muestra al usuario un mensaje de error.

Veamos otro ejemplo. Ahora vamos a escribir un programa que arroje una calificación en letra según el promedio de tres calificaciones numéricas dadas por el usuario.

algoritmo Calificacion

var

   entero: cal1, cal2, cal3, promedio

inicio

   escribir("Proporciona las tres calificaciones del alumno: ")

   leer(cal1, cal2, cal3)

   promedio <- redondeo((cal1 + cal2 + cal3) / 3)

   segun_sea (promedio) hacer

      caso 10:

         escribir("A")

      caso 9:

         escribir("B")

      caso 8:

         escribir("C")

      caso 7:

         escribir("D")

      otros:

         escribir("F")

   fin_segun

fin

En este caso optamos por redondear el promedio para convertirlo en un número entero y poder hacer uso de la alternativa múltiple.

Veamos un último caso más completo, combinando varias de las estructuras que ya conocemos. El siguiente algoritmo se usa para determinar el descuento a aplicar a un cliente en una tienda de computadoras. La tienda reconoce 4 niveles de clientes y dos niveles de descuento para cada uno. Los tipos de clientes son "A", "B", "C" y "D", mientras que los montos de descuento se resumen en la siguiente tabla:

algoritmo Descuentos

var

   caracter: tipo_cliente

   entero: descuento

   real: monto_compra

inicio

   escribir("Proporciona el tipo de cliente: ")

   leer(tipo_cliente)

   escribir("Proporciona el monto de la compra: ")

   leer(monto_compra)

   segun_sea (tipo_cliente) hacer

      caso "A":

         si (monto_compra < 5000) entonces

            descuento = 0

         si_no

            descuento = 5

         fin_si

      caso "B":

         si (monto_compra < 5000) entonces

            descuento = 5

         si_no

            descuento = 7

         fin_si

      caso "C":

         si (monto_compra < 5000) entonces

            descuento = 7

         si_no

            descuento = 10

         fin_si

      caso "D":

         si (monto_compra < 5000) entonces

            descuento = 10

         si_no

            descuento = 15

         fin_si

   fin_segun

   escribir("El descuento aplicable al cliente es del " + descuento + "%")

fin

En este ejemplo hemos combinado dos estructuras de selección: la alternativa múltiple y la alternativa doble, haciendo a nuestro algoritmo muy potente y versátil. Este es un buen ejemplo de las estructuras de decisión anidadas o en cascada que estudiaremos en la próxima lección. 

Por ahora, ¡te toca practicar! ¡hasta la próxima!

ACTIVIDADES DE APRENDIZAJE

1. Escribe un programa que acepte dos números reales de un usuario y también un código de selección que representa la operación aritmética a ejecutar. Si el código es 1, se debe ejecutar y mostrar el resultado de la suma de ambos números. Si el código es 2, se debe restar el segundo número del primero y mostrar el resultado. Si el código es 3, se deben multiplicar los números y mostrar el resultado. Si el código es 4, el primer número debe dividirse entre el segundo y mostrar el resultado. Si el código es un número distinto a cualquiera de los especificados, se debe mostrar un mensaje de error.

2. Escribe un programa que permita calcular el área de distintas figuras geométricas, a elección del usuario. Primero, el usuario debe ver un menú de opciones para elegir la figura geométrica cuya área desea calcular. Las opciones son:

   A - Triángulo

   B - Rectánulo

   C - Cuadrado

   D - Círculo

   E - Polígono de n lados

Una vez que el usuario elige su figura, el algoritmo debe solicitar los datos necesarios para calcular el área de la figura elegida y mostrar el resultado correspondiente.

Enlace: Índice del curso

Sigue leyendo...