Comenzando a programar: 11c- Subrangos y Arreglos lineales.

[Kyshuo]

Recorriendo arreglos:

Muchas veces resulta necesario recorrer un arreglo, ya sea para buscar un elemento de él o para trabajar de algún modo con los valores de sus celdas, de otro modo ¿para qué lo habríamos creado entonces?
Aunque les dejé esto como ejercicio, espero lo hayan hecho antes de llegar aquí, veremos un ejemplo donde el usuario ingresa 10 valores enteros para un arreglo y luego nosotros desplegaremos éstos para mostrárselos y además le mostraremos la suma de ellos:

Código Pascal:

PROGRAM sumaCeldas;
 
Const
     N= 10; //Dimensión del arreglo.
 
Type
     arr= array[1..N] of integer;
 
Var
    arreglo1: arr;
    i, suma: integer;
 
BEGIN
 //Mensaje para el usuario.
 write('Ingresa ‘,N,’ enteros: ');
 
 //Leemos un valor para cada celda.
 For i:=1 to N do
    read(arreglo1[i]);
 
 //Dejamos una línea en blanco.
 writeln;
 
 //Mensaje al usuario. Mostramos su ingreso.
 write('Usted ha ingresado: ');
 For i:=1 to N do
    write(arreglo1[i],' ');
 
 //Iniciamos suma en 0 ya que aún no hemos sumado nada.
 suma:=0;
 
 //Recorremos todo el arreglo sumando los valores a suma.
 For i:=1 to N do
    suma:= suma + arreglo1[i];
 
 //Mostramos el resultado al usuario.
 writeln;
 writeln('La suma de los valores es: ',suma);
END.
 

Lo primero a destacar en este ejemplo es el uso de la constante N cuyo valor es 10. Es simplemente la que usaremos para declarar el Subrango que declara la dimensión del arreglo. De este modo la usaremos también en las iteraciones FOR para recorrer todas las celdas del arreglo. Si luego debiéramos modificar nuestro programa para que el usuario ingrese 20 valores en vez de 10 solo debemos cambiar el valor de N en su declaración de la línea 4 y todo funcionará perfectamente. De lo contrario deberíamos cambiar un 10 por un 20 cada vez que iteráramos con el arreglo, al declararlo, etc.

En la línea 17 tenemos un FOR que leerá un valor para cada celda del arreglo. Dada esa declaración el usuario puede ingresar de a un valor he ir presionando enter, o ingresar los 10 valores separados por espacio en una misma línea y presionar enter al final. Esto es posible ya que hemos usado el procedimiento read que lee un valor y deja el cursor en la misma línea. De haber usado readln deberíamos ingresar un valor por línea.
Les dejo el resto del programa a ustedes.

Ahora veremos un ejemplo donde el usuario ingresa 10 valores enteros en un arreglo y el programa le mostrará el mayor de todos ellos:

Código Pascal:

PROGRAM arreglos;
 
Const
     N= 10; //Dimensión del arreglo.
 
Type
     arr= array[1..N] of integer;
 
Var
    arreglo1: arr;
    i, mayor: integer;
 
BEGIN
 //Mensaje para el usuario.
 write('Ingresa ',N,' enteros: ');
 
 //Leemos un valor para cada celda.
 For i:=1 to N do
    read(arreglo1[i]);
 
 //Dejamos una línea en blanco.
 writeln;
 
 //En un principio el mayor valor es el primero.
 mayor:= arreglo1[1];
 
 //Ahora recorremos el resto del arreglo buscando el mayor valor.
 For i:=2 to N do
 begin
    30    If arreglo1[i]>mayor then
       mayor:= arreglo1[i];
 end;
 
 //Informamos al usuario.
 writeln('El mayor valor ingresado es: ',mayor);
END.
 

Lean ustedes mismos este código. Seguro son capaces de entenderlo muy bien.


Búsqueda de un elemento:

En este ejemplo veremos un programa en el que el usuario ingresa 10 enteros que guardaremos en el arreglo y luego le pediremos que ingrese otro valor. Buscaremos ese valor en el arreglo. Si está ahí lo notificaremos y en caso contrario notificaremos que no está:

Código Pascal:

PROGRAM BusquedaArreglo;
 
Const
     N= 10; //Dimensión del arreglo.
 
Type
     arr= array[1..N] of integer;
 
Var
    arreglo1: arr;
    i, valorBuscado: integer;
    exito: boolean;
 
BEGIN
 //Mensaje para el usuario.
 write('Ingresa ',N,' enteros: ');
 
 //Leemos un valor para cada celda.
 For i:=1 to N do
    read(arreglo1[i]);
 
 //Dejamos una línea en blanco.
 writeln;
 
 //Leemos el valor a buscar en el arreglo.
 write('Ingresa el valor que deseas buscar: ');
 readln(valorBuscado);
 
 //Inicializamos nuestra variable índice en 0.
 i:=0;
 {Iteramos hasta encontrar el valor o hasta
 recorrer todo el arreglo sin hallarlo}
 Repeat
    //Aumentamos un índice.
    i:= i + 1;
    exito:= arreglo1[i]=valorBuscado;
 Until (exito) or (i=N);
 
 writeln;
 
 //Mostramos el mensaje correspondiente.
 If exito then
    writeln('El valor está en el arreglo.')
 else
    writeln('El valor no está en el arreglo.');
END.
 

Lo importante aquí está a partir de la línea 30 donde inicializamos i en 0 ya que será nuestro índice. En la línea 33 declaramos un REPEAT que aumentará nuestro índice de búsqueda y luego se fijará si el valor buscado es igual al de la celda en que estamos posicionados. En ese caso exito será true y la iteración terminará. En caso contrario volveremos a aumentar i en 1 y nos fijaremos en la nueva posición. La iteración terminará al encontrar el elemento o al recorrer todo el arreglo sin hallarlo.

Es importante destacar el uso del REPEAT aquí. Como primera cosa sabemos que iteraremos al menos una vez ya que debemos fijarnos al menos en la primera celda del arreglo, por eso usé un REPEAT y no un WHILE.
Alguno podrá preguntarse ¿y por qué no usaste un FOR para recorrer el arreglo como has hecho hasta ahora? Bien, veamos como quedaría ese trozo de código sin es vez de REPEAT fuera FOR

Código:

For i:=1 to N do
   exito:= arreglo1[i]=valorBuscado;

If exito then
   Writeln(‘El valor está en el arreglo.’)
Else
   Writeln(‘El valor no está en el arreglo.’);

Con el FOR recorreremos todo el arreglo siempre. La bandera booleana se volverá true al hallar el elemento.
Funciona perfectamente al igual que el REPEAT, ahora piensen esto. Imaginen que tenemos un arreglo de 500 celdas y el valor que buscábamos estaba en la celda número 86. Con el REPEAT recorreremos solo las primeras 86 celdas del arreglo y nos detendremos ya que al encontrar el elemento no nos interesa lo demás. Con el FOR, al encontrar el elemento la bandera será true pero aún así recorreremos las 500 celdas. Esto hace al programa trabajar de más cuando no es necesario y le resta mucha eficiencia. Piensen en un arreglo de miles y miles de celdas, por ejemplo, una base de datos de Google en donde están guardadas casi todas las webs del mundo. ¿Sería mejor recorrer la base de datos hasta encontrar el elemento o recorrerla toda siempre?
Es importante que comprendan esto. Aunque ya les dije que no les haría mucho hincapié con esto de la eficiencia, también dije que en ciertas ocasiones mencionaría el modo de realizar ciertas tareas de la forma más eficiente posible.

Deben notar que el programa anterior se detendrá ante el primer encuentro con el valor buscado sin interesarse en si se repite luego.
Ahora les dejo una serie de ejercicios. No continúen con el tutorial hasta que sean capaces de realizarlos todos, o de lo contrario, no podrán con las lecciones que vendrán a continuación.


Ejercicios:

Ejercicio1: Escriban un programa que lea diez enteros de la entrada estándar y guarde estos en un arreglo. El programa debe indicar el mayor de ellos y el índice de la posición en la que aparece, así como también, el menor de ellos y su posición. En caso de que se repita un valor mostrarán el índice de la primera celda en que aparezca.
Asumimos que siempre se ingresan enteros en la entrada estándar.
Ejemplo1:

Código:

Ingrese 10 enteros: 2 3 1 4 5 10 6 7 8 9
El mayor entero es 10 en la posición 6
El menor entero es 1 en la posición 3

Ejemplo2:

Código:

Ingrese 10 enteros: 2 3 2 20 5 20 6 7 8 9
El mayor entero es 20 en la posición 4
El menor entero es 2 en la posición 1

Ejercicio2: Este ejercicio conlleva cierta dificultad, sobretodo porque trabajarán con dos arreglos a la vez, cada uno de distinto tamaño. Dada la definición de tipo para representar cadenas de caracteres de largo M y N :

Código:

CONST N = . . .;
  M = . . .; { M < N }
. . .
TYPE
   CadenaM = ARRAY[1..M] Of Char;
   CadenaN = ARRAY[1..N] Of Char;

Implementen un programa que lea dos cadenas de la entrada estándar de largo M y N respectivamente, y determine si la primer cadena ocurre como parte de la segunda cadena. El programa debe funcionar para cualquier valor positivo que puedan tomar M y N, considerando la restricción M < N. Ustedes mismos definan los valores de las constantes.

Ejemplo de entrada para N=6, M=3:
tor
totora

Ejemplo de salida:
El texto 'tor' se encuentra dentro del texto 'totora'.

Ejemplo de entrada:
tos
totora

Ejemplo de salida:
El texto 'tos' no se encuentra dentro del texto 'totora'.


Ejercicio3: Tiene una dificultad similar al anterior. Dada la definición de tipo para representar cadenas de caracteres de largo N y M:

Código:

CONST N = . . .;
M = . . .;
. . .
TYPE
   CadenaM = ARRAY[1..M] Of Char;
   CadenaN = ARRAY[1..N] Of Char;

1. Escriban un programa que lea dos cadenas de largo M y N respectivamente, e imprima un mensaje en la salida estándar indicando si alguna letra en la primera palabra ocurre en la segunda.
2. Escriban un programa que lea dos cadenas de largo M y N respectivamente, y determine si todas las letras en la primera palabra ocurren en la segunda.


Como ya saben, siempre que un ejercicio les de verdaderos problemas no tienen más que preguntar. Siempre intenten todo lo que puedan y prueben bien sus programas antes de dar por terminado un ejercicio.

Suerte, espero que comenten lo que les va pareciendo hasta ahora.