Las estructuras selectivas
Hasta ahora, se han desarrollado programas con una estructura lineal, es decir que una instrucción sigue a la otra en secuencia. Sin embargo, esta es muy rígida para crear programas más complejos, donde se involucren la toma de decisión en función del resultado obtenido. Para ello se pueden emplear las estructuras selectivas, las cuales evalúan una condición y en función del resultado de la misma se ejecuta una instrucción u otra. El ejemplo de una estructura selectiva es la definida simplemente como si, entonces. La forma más fácil de representarla es:
Si se cumple la condición { secuencia de instrucciones }
Que en la sintaxis del lenguaje Perl, es:
if (condición) { secuencia de procesos }

Ejercicio 1:
Instrucciones:
a) Teclear el código que se muestra a continuación

#!/usr/local/bin/perl
#programa: estruc1.pl
$var1 = <STDIN>;
chop($var1);
if ($var1)
{ print ("El valor es distinto de cero"); }

b) grabar el código con el nombre estruc1.pl
c) salirse del editor de texto
d) cambiarle los derechos al programa, para hacerlo ejecutable.
e) ejecutar el programa.

¿Qué hace el programa estruc1.pl ?
1 El programa espera un valor de entrada que se almacena en la variable  $var1
2 Con la función chop se quita el último caracter tecleado.
3 Si el valor de la variable $var1 es diferente de cero ejecuta lo que esta encerrado entre “{}”; en este caso, presenta un mensaje en pantalla.
4 Si el contenido de la variable $var1 es igual a cero, no ejecuta lo que se encuentra encerrado entre “{}” y concluye el programa.
Para una mejor implementación de las estructuras selectivas, es muy importante usar los operadores de comparación, facilitando la toma de decisiones en función de una condición. En el lenguaje Perl, se tiene dos tipos de operadores de comparación, el primero para números y el segundo para cadenas de caracteres.

Tabla A Operadores de comparación de valores numéricos

Operador  Descripción
<               menor que
>               mayor que
==             igual que
<=             menor o igual que
>=             mayor o igual que
!=              no igual a

Tabla B operadores de comparación de cadena de caracteres

Operador Descripción
lt               menor que
gt              mayor que
eq             igual a
le              menor o igual que
ge             Mayor o igual que
ne             No igual a

Veamos con los siguientes ejemplos su aplicación dentro de las estructuras selectivas.

Ejercicio 2
Instrucciones
a) Teclear el código que se muestra a continuación:

Programa 2.2

#!/usr/local/bin/perl
#programa: estruc2.pl
print "Tecla un valor entero ";
$var1 = <STDIN>;
chop($var1);
print "Teclea un segundo valor";
$var2=<STDIN>;
chop($var2);
if ($var1==$var2)
{ print ("Los valores son iguales\n"); }

b) grabar el código con el nombre estruc2.pl
c) salirse del editor de texto
d) cambiarle los derechos al programa, para hacerlo ejecutable
e) ejecutar el programa Operador Descripción

Variante de estructura selectiva

Se capturan dos valores numéricos y se comparan entre sí, utilizando el operador “==“ Si son iguales se ejecuta el contenido entre “{}”. De lo contrario no entra y concluye.

Cuestionario
¿Qué pasaría si en vez de utilizar el operador “==“, se emplea el “=“?

Existe una variante en esta estructura selectiva que se muestra a continuación
Si se cumple la condición { secuencia de procesos }
de lo contrario { secuencia de procesos }
Que se representa con la sintaxis del lenguaje Perl, de la siguiente manera:
If (condición) { secuencia de procesos }
else { secuencia de procesos }

Ejercicio 3
Instrucciones:
a) Teclear el código que se muestra a continuación:

#!/usr/local/bin/perl
#programa: estruc3.pl
print "Tecla un valor entero ";
$var1 = <STDIN>;
chop($var1);
print "Teclea un segundo valor ";
$var2=<STDIN>;
chop($var2);
if ($var1==$var2)
{ print ("Los valores son iguales\n"); }
else
{ print "Son diferentes\n"; }

b) grabar el código con el nombre estruc3.pl
c) salirse del editor de texto
d) cambiarle los derechos al programa, para hacerlo ejecutable
e) ejecutar el programa

Actividad
Describe con tus propias palabras el funcionamiento del programa estruc3.pl
 

Ejercicio 4
Instrucciones:

a) Crear un programa que calcule la media aritmética de 5 números enteros y positivos.
b) grabarlo con el nombre estruc4.pl

Ejercicio 5
Instrucciones:

a)Crear un programa para sumar 5 números positivos introducidos por teclado.
b) grabarlo con el nombre estruc5.pl
 

Existe otra variante a la estructura de selección, donde es posible crear diferentes opciones de ejecución, en función de la condición. Veamos

Si se cumple la condición { secuencia de procesos }
Si se cumple la condición { secuencia de procesos }
. . de lo contrario { secuencia de procesos }

De acuerdo a la sintaxis en Perl, tenemos:
if (condicion) { secuencia de procesos }
elsif { secuencia de procesos }
elsif { secuencia de procesos }
. . . else { secuencia procesos }
 

Ejercicio 6
Instrucciones:
a) Teclear el código que se muestra a continuación:

#!/usr/local/bin/perl
#programa: estruc6.pl
print "Tecla un valor entero ";
$var1 = <STDIN>;
chop($var1);
print "Teclea un segundo valor ";
$var2=<STDIN>;
chop($var2);
if ($var1==$var2)
{ print ("Los valores son iguales\n"); }
elsif ($var1==$var2+1)
{ print ("El primer numero es mayor\n"); }
elsif ($var1+1==$var2)
{ print ("El segundo es mayor\n"); }
else { print ("los dos numeros no son iguales\n"); }

b)  grabar el código con el nombre estruc6.pl
c) salirse del editor de texto
d) cambiarle los derechos al programa, para hacerlo ejecutable
e) ejecutar el programa

Ejercicio 7
Instrucciones:

a) teclear el código del siguiente programa:

#!/usr/local/bin//perl
#programa: estruc7.pl
$uno=lunes;
$dos=martes;
$tres=miercoles;
$cuatro=jueves;
$cinco=viernes;
$seis=sabado;
$siete=domingo;
print " Teclea el dia ";
$dia=<STDIN>;
chop($dia);
if ($dia eq $uno)
{ print "$uno\n"; }
elsif ($dia eq $dos)
{ print "$dos\n"; }
elsif ($dia eq $tres)
{ print "$tres\n"; }
elsif ($dia eq $cuatro)
{ print "$cuatro\n"; }
elsif ($dia eq $cinco)
{ print "$cinco\n"; }
elsif ($dia eq $seis)
{ print "$seis\n"; }
elsif ($dia eq $siete)
{ print "$siete\n"; }
else { print "fin del programa\n"; }

b) grabar el código con el nombre estruc7.pl
c) salirse del editor de texto
d) cambiarle los derechos al programa, para hacerlo ejecutable
e) ejecutar el programa
¿Qué hace el programa estruc7.pl ?

Ejercicio 8
Instrucciones:
a) Crear un programa que convierta las calificaciones alfabéticas A, B, C, D y E a calificaciones numéricas 10, 9, 8, 7 y 6, respectivamente.
b) Grabarlo como estruc8.pl

Las estructuras repetitivas

Las computadoras están especialmente diseñadas para todas aquellas aplicaciones en las cuales una operación o conjunto de ellas deben repetirse muchas veces. Por ejemplo la lectura de las calificaciones de varias materias de un alumno para obtener su promedio.
Para implementar actividades como la anterior, los lenguajes de programación, incluyen estructuras repetitivas, donde la repetición de una secuencia de instrucciones se le denomina ciclo y se denomina iteración al hecho de repetir la ejecución de una secuencia de acciones.
En le lenguaje de programación Perl se tienen varias estructuras repetitivas, como son:
While, Unless, For, Do y el Foreach. Para este capítulo, se desarrollarán los cuatro primeros, dejando para el apartado de las listas y los arreglos asociativos la estructura repetitiva foreach.

la estructura WHILE
La sintaxis en lenguaje Perl es:
while (expresión) {
instrucciones
}

El formato de la estructura while es muy similar a la del if, pero trabaja de manera distinta.
Veamos un ejemplo:

Ejercicio 9
Instrucciones:
a) teclear el código del siguiente programa:

#!/usr/local/bin/perl
#programa:estruc9.pl
$valor=0;
$contar=1;
print (“Esta linea se imprime antes de iniciar el ciclo while.\n”);
while ($valor==0) {
print (“El valor de contar es “, $contar, “\n”);
if ($contar ==3)
{ $valor=1; }
$contar=contar+1;
}
print (“Fin del ciclo while.\n”);

b)  grabar el código con el nombre estruc9.pl
c) salirse del editor de texto
d) cambiarle los derechos al programa, para hacerlo ejecutable
e) ejecutar el programa

¿Qué hace el programa estruc9.pl?

a) Inicializa las variables $contar y $valor con valores que serán utilizados a lo largo del programa.
b) Manda un mensaje a la pantalla.
c) en la línea While, el programa evalúa y “dice” mientras que el contenido de la variable $valor sea igual a cero, ejecutar la secuencia de instrucciones que se encuentra dentro de los “{}”.
d) Manda un mensaje a pantalla
e) Compara el contenido de la variable $contar con el número 3. Si es verdadera la condición, ejecuta la secuencia de instrucciones que se encuentra dentro de los “{}”.
f) Incrementa el contenido de la variable $contar en 1.
g) Va a la línea donde está el While y repite la operación, hasta que el contenido de la variable $valor sea distinto de 0.

Ejercicio 10
Instrucciones:

a) teclear el código del siguiente programa:

#!/usr/local/bin/perl
#programa:estruc10.pl
$suma=0;
$numero=2;
$valor=10;
while ($numero<=$valor) {
$suma=$suma+$numero;
$numero=$numero+2;
}
print ("la suma de los numeros pares es:$suma\n");

b) grabar el código con el nombre estruc10.pl c) salirse del editor de texto d) cambiarle los derechos al programa, para hacerlo ejecutable e) ejecutar el programa
 

Cuestionario

Describa con sus propias palabras ¿qué hace el programa estruc10.pl?

Ejercicio 11
Instrucciones:

Crear un programa que lea las calificaciones del grupo A, de la materia de computadoras 1 y contar el número de aprobados y la media aritmética del mismo.

La estructura repetitiva Until

La estructura repetiva until, permite llevar un control parecido al de while pero, trabaja hasta que la condición sea verdadera.
La representación del until en Perl es:
until (expresión) { secuencia de instrucciones }

Veamos un ejemplo

Ejercicio 12
Instrucciones:

a) Teclear el código que se muestra a continuación:
#!/usr/local/bin/perl
#programa:estruc12.pl
print (“Cual es la suma de 17 + 26\n”);
$resp_correcta=43;
$resp_entrada=<STDIN>;
until ($resp_entrada == $resp_correcta) {
print (“no es correcta. Intenta de nuevo\n”);
$resp_entrada=<STDIN>;
chop ($resp_entrada);
}
print (“Lo has logrado\n”);

b) grabar el código con el nombre estruc12.pl
c) salirse del editor de texto
d) cambiarle los derechos al programa, para hacerlo ejecutable
e) ejecutar el programa

¿Cómo funciona el programa estruc12.pl?

a) Muestra un mensaje en pantalla, preguntando por la suma de 17 + 26.
b) El usuario teclea el valor de la suma
c) La estrcutura repetitiva until compara y “dice” al menos que no sea verdadera , ejecuta la secuencia de instrucciones que estan dentro de “{}”. Espera un nuevo valor de la suma, si sigue siendo diferente, repite el ciclo.
d) Si es verdadero el valor de la suma, en este caso debe ser 43. Envía un mensaje a la pantalla, diciendo: lo has logrado.

Aqui podría surgir la duda, con respecto a la forma de estructurar el programa con el until. Sin embargo, funciona.

Cuestionario
¿Qué pasaría si se modifica el operador de comparación por el de ne ?

Ejercicio 13
Instrucciones:

a) Teclear el código que se muestra a continuación:

#!/usr/local/bin/perl
#programa:estruc13.pl
print ("Cual es el valor de N?\n");
$num=<STDIN>;
chop($num);
$fac=$num;
$valor=$fac-1;
until ($valor <= 0)
{ $fac=$fac*$valor; $valor=$valor-1; }
print ("el factorial del numero $num es $fac\n");

Ejercicio 14
Instrucciones:

a) Crear un programa que muestre en pantalla los números del 1 hasta el 100 b) Grabarlo con el nombre: estruc14.pl

La estructura repetitiva For

En muchas ocasiones se conoce de antemamo el número de veces que se desea ejecutar un proceso dentro de un ciclo repetitivo. Para ello se utiliza la estructura desde o para (for en inglés).
Dentro del lenguaje de programación Perl, la representación del for es:
For (expr1;expr2;expr3) {
instrucciones;
}

expr1 es el inicializador del ciclo. Es evaluado solo una vez, antes de iniciar el ciclo. expr2 es la expresión de condición que termina el ciclo. instrucciones son el conjunto de actividades que se ejecuta-ran cuando se cumpla la condición. expr3 se ejecuta una vez por iteracción del ciclo y se ejecuta después de la última instrucción de las mismas.

Ejercicio 15
Instrucciones
a) Teclear fielmente el código que se muestra continuación:

#!/usr/local/bin/perl
#programa: estruc17.pl
for ($count=1;$count<=5;$count++)
{ print ("$count\n"); }

Ejercicio 16
Instrucciones:
a) Teclear el código que se muestra a continuación

#!/usr/local/bin/perl
#programa:estruc16.pl
print ("Cual es el valor de N?\n");
$num=<STDIN>;
chop($num);
$fac=$num;
for ($valor=1; $valor < $num; $valor++) {
$fac=$fac*$valor; }
print ("el factorial del numero $num es $fac\n");

Ejercicio 17
Instrucciones:
a) Crear un programa que obtenga la suma de los números pares comprendidos entre el 1 y el 100
b) Grabarlo con el nombre: estruc17.pl

Ejercicio 18
Instrucciones:
a) Crear un programa que muestre el valor máximo de una serie de 10 números
b) Grabarlo con el nombre: estruc18.pl
 

La estructura repetitiva Do

Esta estructura repetitiva evalúa la condición después de haber ejecutado por primera vez un ciclo. Mientras que el ciclo while, for lo hacen antes.
La estructura del do en el lenguaje de Programación Perl, es:
do {
secuencia de instrucciones } while o Until (condición)
Veamos un ejemplo

Ejercicio 19
Instrucciones:
a) Teclear el código que se muestra a continuación valores sucesivos de la variable contar.

#!/usr/local/bin/perl
#programa:estruc12.pl
$resp_correcta=43;
do{
print (“Cual es la suma de 17 + 26\n”);
$resp_entrada=<STDIN>; }
chop ($resp_entrada);
if($resp_entrada != $resp_correcta)
print (“no es correcta. Intenta de nuevo\n”);
}
until ($resp_entrada == $resp_correcta)
print (“Lo has logrado\n”);

b) grabar el código con el nombre estruc12.pl
c) salirse del editor de texto
d) cambiarle los derechos al programa, para hacerlo ejecutable
e) ejecutar el programa
 
Ejercicio 20
Actividad:
a)Utilizar la estructura do, en vez de while del ejercicio 11 b)Grabarlo como: estruc20.pl

Apéndice Programas del curso del capitulo dos

Ejercicio 4
Crear un programa que calcule la media aritmética de 5 números enteros y positivos.

#!/usr/local/bin/perl
#programa: estruc4.pl
$valor=0;
print "Teclea el primer valor numerico a promediar :";
$num1=<STDIN>;
if($valor ne 5)
{ $suma=$suma+$num1;
$valor=$valor+1; }
print"Teclea el segundo valor numerico a promediar : ";
$num1=<STDIN>;
if($valor ne 5)
{ $suma=$suma+$num1;
$valor=$valor+1; }
print "Teclea el tercer valor numerico a promediar :";
$num1=<STDIN>;
if($valor ne 5)
{ $suma=$suma+$num1;
$valor=$valor+1; }
print "Teclea el cuarto valor numerico a promediar : ";
$num1=<STDIN>;
if($valor ne 5)
{ $suma=$suma+$num1;
$valor=$valor+1; }
print "Teclea el quinto valor numerico a promediar :";
$num1=<STDIN>; if($valor ne 5)
{ $suma=$suma+$num1;
$valor=$valor+1; }
$media=$suma/$valor;
print "el contenido de suma es: $suma\n";
print "el contenido de valor es: $valor\n";
print "La media aritmetica es: $media\n";

Ejercicio 5
Crear un programa que sume 5 números positivos introducidos por teclado

#!/usr/local/bin/perl
#programa: estruc5.pl
$valor=0;
print "Teclea el primer valor numerico a sumar : ";
$num1=<STDIN>;
if($valor ne 5)
{ $suma=$suma+$num1;
$valor=$valor+1;}
print "Teclea el segundo valor numerico a sumar : ";
$num1=<STDIN>;
if($valor ne 5)
{ $suma=$suma+$num1;
$valor=$valor+1; }
print "Teclea el tercer valor numerico a sumar :";
$num1=<STDIN>;
if($valor ne 5)
{ $suma=$suma+$num1;
$valor=$valor+1; }
print "Teclea el cuarto valor numerico a sumar : ";
$num1=<STDIN>;
print "Teclea el cuarto valor numerico a sumar : ";
$num1=<STDIN>;
if($valor ne 5)
{ $suma=$suma+$num1;
$valor=$valor+1; }
print "Teclea el quinto valor numerico a sumar :";
$num1=<STDIN>;
if($valor ne 5)
{ $suma=$suma+$num1;
$valor=$valor+1; }
print "el contenido de suma es: $suma\n";
print "el contenido de valor es: $valor\n";

Ejercicio 8
Crear un programa que convierta las calificaciones alfabéticas A, B, C, D y E a calificaciones numéricas 10, 9, 8, 7 y 6, respectivamente.

#!/usr/local/bin/perl
#programa: estruc8.pl
$letra1=A;
$letra2=B;
$letra3=C;
$letra4=D;
$letra5=E;
print "Teclea la letra de calificacion :";
$valor=<STDIN>;
chop($valor);
if($valor eq $letra1)
{ print "su calificacion es:10\n"; }
elsif($valor eq $letra2)
{ print "su calificacion es: 9\n"; }
elsif($valor eq $letra3)
{ print "su calificacion es: 8\n"; }
elsif($valor eq $letra4)
{ print "su calificacion es: 7\n"; }
elsif($valor eq $letra5)
{ print "su calificacion es: 6\n"; }
else { print "No es letra para calificacion\n";

Ejercicio 11

#!/usr/local/bin/perl
#programa:estruc11.pl
print ("Cuantos alumnos son?\n");
$alumno=<STDIN>;
chop($alumno);
while ($valor ne $alumno)
{ print ("La calificacion del alumno: ");
$calif=<STDIN>;
chop($calif);
$suma=$suma+$calif;
$valor=$valor+1;
if ($calif>=6)
{ $aprob=$aprob+1; }
}
$media=$suma/$alumno;
print ("La cantidad de aprobados son: $aprob\n");
print ("la media es:$media\n");

Ejercicio 14
#!/usr/local/bin/perl
#programa:estruc14.pl
$num=1;
$valor=99;
until ($valor <= 0)
{ $num=$num+1;
$valor=$valor-1;
print ("el numero es: $num\n"); }

Ejercicio 17
Instrucciones:
Crear un programa que obtenga la suma de los números pares comprendidos entre el 1 y el 100

#!/usr/local/bin/perl
#programa:estruc17.pl
$suma=2;
$numero=4;
 for ($valor=1; $valor < 49; $valor++)
{ $suma=$suma+$numero;
$numero=$numero+2; }
print ("la suma de los numeros pares es:$suma\n");

Ejercicio 18
Instrucciones:
Crear un programa que muestre el valor máximo de una serie de 10 números

#!/usr/local/bin/perl
#programa:estruc18.pl
print ("Valor: ");
$num=<STDIN>;
chop($num);
$maximo=$valor;
$n=1;
for ($valor=1; $valor < 10; $valor++)
{ print ("Valor: ");
$num=<STDIN>;
chop($num);
if ($num > $maximo)
{ $maximo=$num; }
}
print ("El numero mayor de la serie es:$maximo\n");

Ejercicio 20
#!/usr/local/bin/perl
#programa:estruc20.pl
print ("Cuantos alumnos son?\n");
$alumno=<STDIN>;
chop($alumno);
do
{ print ("La calificacion del alumno: ");
$calif=<STDIN>;
chop($calif);
$suma=$suma+$calif;
$valor=$valor+1;
if ($calif>=6)
{ $aprob=$aprob+1; }
}while ($valor ne $alumno);
$media=$suma/$alumno;
print ("La cantidad de aprobados son: $aprob\n");
print ("la media es:$media\n");