Arreglos bidimensionales
Los arreglos bidimensionales son
tablas de valores. Cada elemento de un arreglo bidimensional está
simultáneamente en una fila y en una columna.
En matemáticas, a los arreglos bidimensionales se
les llama matrices, y son muy utilizados en problemas de Ingeniería.
En un arreglo bidimensional, cada elemento tiene
una posición que se identifica mediante dos índices: el de su fila y el de su
columna.
Crear arreglos bidimensionales
Los arreglos bidimensionales también son provistos
por NumPy, por lo que debemos comenzar importando las funciones de este módulo:
Al igual que los arreglos de una dimensión, los
arreglos bidimensionales también pueden ser creados usando la función array,
pero pasando como argumentos una lista con las filas de la matriz:
a =
array([[5.1, 7.4,
3.2, 9.9],
[1.9,
6.8, 4.1,
2.3],
[2.9,
6.4, 4.3,
1.4]])
Todas las filas deben ser del mismo largo, o si no
ocurre un error de valor:
>>> array([[1], [2, 3]])
Traceback (most recent call last):
File "<stdin>", line 1, in
<module>
ValueError: setting an array
element with a sequence.
Los arreglos tienen un atributo llamado shape,
que es una tupla con los tamaños de cada dimensión. En el ejemplo, a es
un arreglo de dos dimensiones que tiene tres filas y cuatro columnas:
Los arreglos también tienen otro atributo llamado size que indica cuántos elementos tiene el arreglo:
Por supuesto, el valor de a.size siempre
es el producto de los elementos de a.shape.
Hay que tener cuidado con la función len,
ya que no retorna el tamaño del arreglo, sino su cantidad de filas:
Las funciones zeros y ones también sirven para crear
arreglos bidimensionales. En vez de pasarles como argumento un entero, hay que
entregarles una tupla con las cantidades de filas y columnas que tendrá la
matriz:
>>> zeros((3,
2))
array([[ 0., 0.],
[ 0.,
0.],
[ 0.,
0.]])
>>> ones((2,
5))
array([[ 1., 1.,
1., 1., 1.],
[ 1.,
1., 1., 1.,
1.]])
Lo mismo se cumple para muchas otras funciones que
crean arreglos; por ejemplom la función random:
>>> from numpy.random import random
>>> random((5, 2))
array([[
0.80177393, 0.46951148],
[ 0.37728842, 0.72704627],
[ 0.56237317, 0.3491332 ],
[ 0.35710483, 0.44033758],
[ 0.04107107, 0.47408363]])
Ejemplo
Operaciones con arreglos bidimensionales
Al igual que los arreglos de una dimensión, las
operaciones sobre las matrices se aplican término a término:
>>> a =
array([[5, 1, 4],
... [0, 3, 2]])
>>> b =
array([[2, 3, -1],
... [1, 0, 1]])
>>> a + 2
array([[7, 3, 6],
[2, 5, 4]])
>>> a
** b
array([[25, 1, 0],
[ 0,
1, 2]])
Cuando dos matrices aparecen en una operación,
ambas deben tener exactamente la misma forma:
>>> a =
array([[5, 1, 4],
... [0, 3, 2]])
>>> b =
array([[ 2, 3],
... [-1, 1],
... [ 0, 1]])
>>> a + b
Traceback (most recent call last):
File "<stdin>", line 1, in
<module>
ValueError: shape mismatch:
objects cannot be broadcast to a single shape
Obtener elementos de un arreglo bidimensional
Para obtener un elemento de un arreglo, debe
indicarse los índices de su fila i y su columna j mediante
la sintaxis a[i, j]:
>>> a
= array([[ 3.21, 5.33, 4.67, 6.41],
[ 9.54, 0.30,
2.14, 6.57],
[ 5.62, 0.54,
0.71, 2.56],
[ 8.19, 2.12,
6.28, 8.76],
[ 8.72, 1.47,
0.77, 8.78]])
>>> a[1,
2]
2.14
>>> a[4,
3]
8.78
>>> a[-1,
-1]
8.78
>>> a[0,
-1]
6.41
También se puede obtener secciones rectangulares
del arreglo usando el operador de rebanado con los índices:
>>> a[2:3, 1:4]
array([[ 0.54, 0.71, 2.56]])
>>> a[1:4, 0:4]
array([[ 9.54, 0.3 , 2.14,
6.57],
[ 5.62, 0.54,
0.71, 2.56],
[ 8.19, 2.12,
6.28, 8.76]])
>>> a[1:3, 2]
array([ 2.14, 0.71])
>>> a[0:4:2, 3:0:-1]
array([[ 6.41, 4.67, 5.33],
[ 2.56, 0.71,
0.54]])
>>> a[::4, ::3]
array([[ 3.21, 6.41],
[ 8.72, 8.78]])
Para obtener una fila completa, hay que indicar el
índice de la fila, y poner : en el de las columnas (significa
«desde el principio hasta el final»). Lo mismo para las columnas:
>>> a[2,
:]
array([
5.62, 0.54, 0.71,
2.56])
>>> a[:,
3]
array([
6.41, 6.57, 2.56,
8.76, 8.78])
Note que el número de dimensiones es igual a la
cantidad de rebanados que hay en los índices:
>>> a[2,
3] # valor escalar (arreglo
de cero dimensiones)
2.56
>>> a[2:3,
3] # arreglo de una
dimensión de 1 elemento
array([ 2.56])
>>> a[2:3,
3:4] # arreglo de dos
dimensiones de 1 x 1
array([[ 2.56]])
Otras operaciones
La trasposición consiste en
cambiar las filas por las columnas y viceversa. Para trasponer un arreglo, se
usa el método transpose:
>>> a
array([[
3.21, 5.33, 4.67,
6.41],
[ 9.54,
0.3 , 2.14, 6.57],
[ 5.62,
0.54, 0.71, 2.56]])
>>> a.transpose()
array([[
3.21, 9.54, 5.62],
[ 5.33,
0.3 , 0.54],
[ 4.67,
2.14, 0.71],
[ 6.41,
6.57, 2.56]])
El método reshape entrega un arreglo que tiene los
mismos elementos pero otra forma. El parámetro dereshape es una tupla indicando la nueva
forma del arreglo:
>>> a =
arange(12)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> a.reshape((4, 3))
array([[ 0, 1,
2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
>>> a.reshape((2,
6))
array([[ 0, 1, 2,
3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
La función diag aplicada a un arreglo
bidimensional entrega la diagonal principal de la matriz (es decir, todos los
elementos de la forma a[i, i]):
>>> a
array([[
3.21, 5.33, 4.67,
6.41],
[ 9.54,
0.3 , 2.14, 6.57],
[ 5.62,
0.54, 0.71, 2.56]])
>>> diag(a)
array([
3.21, 0.3 , 0.71])
Además, diag recibe un segundo parámetro
opcional para indicar otra diagonal que se desee obtener. Las diagonales sobre
la principal son positivas, y las que están bajo son negativas:
>>> diag(a,
2)
array([
4.67, 6.57])
>>> diag(a,
-1)
array([
9.54, 0.54])
La misma función diag también cumple el rol inverso: al
recibir un arreglo de una dimensión, retorna un arreglo bidimensional que tiene
los elementos del parámetro en la diagonal:
>>> diag(arange(5))
array([[0, 0, 0,
0, 0],
[0, 1, 0, 0, 0],
[0, 0, 2, 0, 0],
[0, 0, 0, 3, 0],
[0, 0, 0, 0, 4]])
Reducciones por fila y por columna
Algunas operaciones pueden aplicarse tanto al
arreglo completo como a todas las filas o a todas las columnas.
Por ejemplo, a.sum() entrega la suma de todos los
elementos del arreglo. Además, se le puede pasar un parámetro para hacer que la
operación se haga por filas o por columnas:
>>> a =
array([[ 4.3, 2.9, 9.1, 0.1, 2. ],
... [ 8. , 4.5, 6.4, 6. , 4.3],
... [ 7.8, 3.1, 3.4, 7.8, 8.4],
... [ 1.2, 1.5, 9. , 6.3, 6.8],
... [ 7.6, 9.2, 3.3, 0.9, 8.6],
... [ 5.3, 6.7, 4.6, 5.3, 1.2],
... [ 4.6, 9.1, 1.5, 3. , 0.6]])
>>> a.sum()
174.4
>>> a.sum(0)
array([
38.8, 37. , 37.3,
29.4, 31.9])
>>> a.sum(1)
array([
18.4, 29.2, 30.5,
24.8, 29.6, 23.1,
18.8])
El parámetro indica a lo largo de qué dimensión se
hará la suma. El 0 significa «sumar a lo largo de
las filas». Pero hay que tener cuidado, ¡por que lo que se obtiene son las
sumas de las columnas! Del mismo modo, 1 significa «a lo largo de las
columnas, y lo que se obtiene es el arreglo con las sumas de cada fila.
Las operaciones a.min() y a.max() funcionan del mismo modo:
>>> a.min()
0.1
>>> a.min(0)
array([ 1.2, 1.5, 1.5,
0.1, 0.6])
>>> a.min(1)
array([ 0.1, 4.3,
3.1, 1.2, 0.9,
1.2, 0.6])
a.argmin() y a.argmax() también:
>>> a.argmin(0)
array([3, 3, 6, 0, 6])
>>> a.argmin(1)
array([3, 4, 1, 0, 3, 4, 4])
ARREGLOS BIDIMENSIONALES
Hay arreglos de una dimensión, como los que se ha visto y usado hasta
aquí, hay arreglos de dos dimensiones como los que veremos ahora, y puede haber
arreglos de tres o más dimensiones. Esto último depende del lenguaje de
programación que se use y la versión de él se tenga.
Los arreglos bidimensionales son de gran utilidad en el manejo de matrices,
para obtener información de ellas y efectuar operaciones matriciales como suma,
resta, producto e inversión, y aplicaciones donde la solución maneje matrices.
Para definir un arreglo bidimensional se hace de manera análoga a
la definición de arreglos de una dimensión. Se elige un nombre, y se da la
máxima posición para cada dimensión, recordando que cada dimensión varía de uno
hasta ese valor máximo indicado. Cada dimensión tiene su propio rango de
variación que es de 1 hasta el valor máximo, y es independiente de la variación
de las otras dimensiones del arreglo.
En una instrucción se puede definir uno o varios arreglos, unidimensionales,
bidimensionales o de dimensiones mayores.
Ejemplo:
La primera instrucción define 3 arreglos de nombre: N, M y M2. El
primero es unidimensional con 15 variables, el segundo es bidimensional con
10*10 variables que son: M(1,1), M(2,1),..., M(10,1), M(1,2), M(2,2),....,
M(10,9), M(1,10), M(2,10),..., M(10,10). El tercer arreglo es bidimensional con
6*6=36 variables.
La segunda instrucción define dos arreglos bidimensionales cuyos nombres son:
MM y RE. El primero tiene 7*16=132 variables, y el segundo tiene 15*5=75
variables.
El número de variables de un arreglo esta dado por el producto de
la máxima posición de la primera dimensión, por la máxima posición de la
segunda dimensión. Esto, porque en cada dimensión el subíndice varía desde 1
hasta su máxima posición, independientemente de la variación del subíndice de
la otra dimensión.
La instrucción:
Define un arreglo de dimensiones ajustables, de nombre XT con N*M
variables. Esta instrucción estará correcta si las variables N, M están creadas
e inicializadas con anterioridad a ella. Que sea correcta o no depende también
del lenguaje de programación que use y si permite definir dimensiones
ajustables. El lenguaje BASIC permite definirlas.
El tamaño de un arreglo es teóricamente cualquiera, pero estará
limitado por la memoria principal que quede disponible en el computador que
usa.
Por ejemplo, el arreglo M(100,100) tiene 10000 variables, y si cada una ocupa 4
bytes, se concluye que ocupa 40000 bytes que son aproximadamente 40 KB. Esto
indica que este arreglo no podrá estar donde quede menos memoria que esa
cantidad.
Los elementos de un arreglo bidimensional se pueden aludir con el uso de dos
subíndices, uno para cada dimensión. Es decir, el programador para referirse a
una variable dentro de un arreglo bidimensional lo hace usando un subíndice
para cada dimensión.
Las instrucciones:
Están tomadas al azar y sin conexión lógica entre ellas. Para que la
primera instrucción tenga sentido las variables I, J deberán haberse creado e
inicializado con valores dentro del rango de variación de la dimensión del
arreglo M. El arreglo M debe estar creado y la variable en la posición I, J
debe estar inicializada. La variable TR también debe estar creada e
inicializada.
Similares alcances se pueden hacer respecto de las otras tres instrucciones.
Ejemplo:
Estas instrucciones suman 36 variables del arreglo T y dejan la suma en
S.
Observe que hay dos ciclos, uno contenido dentro del otro. Cuando I toma el
valor 1, J toma los valores 1, 2, 3, 4, 5 y 6. Cuando I toma el valor 2, J toma
todos esos valores de nuevo, y así sucesivamente.
En este ejemplo se formal los 21 primeros impares y su cuadrado en el
arreglo IM, luego se calcula al suma, el producto y el promedio de ellos. Al
final se imprimen.
EJEMPLO
En este ejemplo se lee 120 datos correspondientes a DAP y Altura de 120
árboles. Los 120 DAP quedan en la primera dimensión del arreglo DA, las 120
alturas en la segunda, las áreas basales en la tercera y los volúmenes en la
cuarta.
El volumen se calcula como: (Área basal * Altura) / 3 , y, Area basal:
(PI / 4) * DAP * * 2)
EJERCICIOS MATRICIALES
Se muestra ahora dos programas cuya solución requiere usar arreglos
bidimensionales, y que son especialmente útiles en el manejo de matrices.
Ejemplo
Lea dos matrices de 4X4 y calcule e imprima la matriz suma y la matriz
producto. Leer las dos matrices al mismo tiempo, un elemento de cada una.
Ejemplo
OBSERVACIÓN
Hay tres ciclos anidados en el cálculo de la matriz producto y hay dos
ciclos anidados en la lectura y en el cálculo de la suma.
Lea N, y a continuación una matriz de NXN, luego calcules el producto de
ella con su transpuesta. Imprima también la traza de A, de su transpuesta y de
la matriz producto. Asuma que N <= 9.
El registro lógico de lectura tiene la
forma:
EJERCICIOS PROPUESTOS
La lista de ejercicios siguientes es para usar arreglos en su solución,
sea éste unidimensional o bidimensional.
1. Se tiene un archivo con un grupo de 30 alumnos con el nombre y 15 notas de
cada uno. Se pide imprimir cada nombre con sus 15 notas
ordenadas de menor a mayor, y a continuación de las 15 notas, el promedio de
ese alumno.
2. Leer de a un número hasta que lea el número 9999 y no se
considera.
Se pide que imprima cuántas veces apareció el 1, el 2, ..., el 29
entre todos los números que se leyeron. Indique al final cuántos números leyó y
cuál fue el promedio de esos números leídos.
La salida tendrá la forma:
El número 1 apareció ... veces
El número 2 apareció ... veces
:
El número 29 apareció ... veces
Se leyó ... números
El promedio de ellos fue: ....
3. Lea 20 nombres y 8 notas para cada uno, e imprima cada nombre con su
promedio en el orden que los leyó. Luego se debe imprimir cada nombre y su
promedio, pero ordenados de mayor a menor de acuerdo al promedio.
4. Lea 19 números correspondientes a datos tomados en terreno, e
imprímalos ordenados de mayor a menor primero, y luego de menor a mayor. Luego
imprima la mediana y el promedio de esos 19 números leídos. Luego vuelva a leer
otros 19 números correspondientes a otra muestra tomada e imprimir de éstos la
misma información. Debe leer hasta que los 19 números sean iguales y se
consideran.
Por ejemplo.
Si los números leídos son: 15.5, 3.2, 2.5, ...., 18.6,
1.8 se deberá imprimir:
1.8
|
2.5
|
3.2
|
.....
|
15.5
|
18.6
|
18.6
|
15.5
|
......
|
3.2
|
2.5
|
1.8
|
Mediana = ......
|
Promedio = .....
|
5. Considere f(X) = X * SQRT(X) + Ln(1+2X2) - 2 * e-3X y
el intervalo [0,4]. Calcule la imagen de los puntos en el intervalo dado con
aumentos de 0.05, y deje los puntos y las imágenes en arreglos. Observe que son
81 puntos en un arreglo y 81 imágenes en otro arreglo.
Se pide ubicar el punto donde se produce la mayor imagen e
imprimirlo junto a su imagen. Indique también si f(X) es o no estrictamente
creciente o decreciente en el intervalo dado.
6. En un archivo se tiene información de 50 insumos que se ocupan en una
oficina por mes, en formato:
Por ejemplo:
Lápiz pasta 160 25.0Se pide emitir dos informes, el primero debe contener la
descripción, cantidad y valor de los 30 insumos de mayor valor ordenados descendentemente
de acuerdo al valor unitario.El segundo informe debe contener la descripción, cantidad y valor de los 25
insumos de mayor cantidad por mes ordenados descendentemente de acuerdo a la
cantidad.
Así, el primer informe tendrá formato:
cinta de máquina 3 1580.0
papel roneo 100 1005.0
normógrafo 2 860.0
El segundo informe tendrá formato:
stencil 360 50.0
transparencias 200 160.0
papel roneo 100 1005.0
:
7. Considerando el archivo de insumo para una oficina del ejercicio 6,
se pide emitir un listado de todos los insumos ordenados de mayor a menor de
acuerdo al gasto total en dinero al mes de cada uno de ellos. El gasto total
por mes de cada insumo esta dado por el producto: valor unitario *
cantidad
Así, este listado de salida tendrá formato:
papel roneo 100500.0
transparencias 32000.0
stencil 18000.0
: :
8. Por programa forme y luego imprima la siguiente matriz cuadrada
de10X10 agregue a continuación el valor de su traza y el mensaje "es
simétrica de 10 X 10"
2
|
3
|
4
|
. . . . . . .
|
11
|
3
|
4
|
5
|
. . . . . . .
|
12
|
:
|
|
|
|
|
11
|
12
|
13
|
. . . . . . .
|
20
|
9. Forme por programa las siguientes dos matrices: y calcule e imprima la matriz producto
A*B. Luego calcule la matriz producto B*A e imprima A*B y B*A. Finalmente
imprima un mensaje que diga si A*B es igual a B*A
10. Lea un número N que es entero positivo entre dos y diez inclusive,
luego lea dos matrices A y B de NxN debe imprimir un mensaje que diga "A y
B conmutan" o bien, "A y B no conmutan".
11. Se tiene un archivo de cuarenta alumnos con la nota final de quince
asignaturas y se pide leer este archivo para sacar un listado con el orden en
que deben llamarse en la ceremonia de graduación, si se llamará primero al
mayor promedio y luego a los que le siguen en orden. Las dos primeras notas deben
tomarse con coeficiente tres, las cuatro siguientes con coeficiente dos, y las
nueve restantes con coeficiente uno.
El archivo de lectura tiene forma:
°Para determinar el número total de elementos en un arreglo bidimensional usaremos las siguientes fórmulas:
Rango
de renglones (r1) = ls1 - (li1+1)
Rango de columnas (r2) = ls2 - (li2+1)
No. Total de componentes = r1 * r2
Representación en memoria por columnas
[pic]
x : array [1..5,1..7] of integer
Para calcular la dirección de memoria de un elemento se usan la siguiente formula:
A[i,j] = base (A) + [((j - li2) R1 + (i + li1))*w]
Representación en memoria por renglones
[pic]
x : array [1..5,1..7] of integer
Para calcular la dirección de memoria de un elemento se usan la siguiente formula:
A[i,j] = base (A) + [((i - li1) R2 + (j + li2))*w]
Donde:
i = Indice del renglón a calcular
j = Indice de la columna a calcular
li1 = Límite inferior de renglones
li2 = Límite inferior de columnas
w = Número de bytes tipo componente
Operaciones Con Arreglos
Las operaciones en arreglos pueden clasificarse de la siguiente forma:
• Lectura
• Escritura
• Asignación
• Actualización
• Ordenación
• Búsqueda
Lectura
Este proceso consiste en leer un dato de un arreglo y asignar un valor a cada uno de sus componentes.
La lectura se realiza de la siguiente manera:
para i desde 1 hasta N haz
x
Declaración.
La declaración de un arreglo consiste en establecer las características del arreglo y sus elementos, por medio de la siguiente sintaxis:
[ , ] <> ;
Donde:
tipo indica el tipo correspondiente a los elementos del arreglo ,
identificador es el nombre del arreglo, y
el par de corchetes y la coma, [ , ], representan las dimensiones del arreglo y encierra dos números enteros, cuyo producto corresponde al número de elementos del arreglo.
Ejemplos:
double [ , ] matriz ;
int [ , ] ubicación ;
Rama [ , ] árbol; // Rama es una clase.
Observe que, en la declaración, el espacio entre los corchetes está vacío. Esto se debe a que, durante dicha operación, no se reserva espacio en la memoria.
La creación de un arreglo bidimensional consiste en reservar espacio en la memoria para todos sus elementos, utilizando la siguiente sintaxis:
<> = new [ dim1, dim2 ] ;
Donde:
new es el operador para gestionar espacio de memoria, en tiempo de ejecución,
dim1 y dim2 son valores enteros que representan las dimensioes del arreglo.
El tamaño del arreglo es el resultado de multiplicar los valores de las dimensiones y representa el número de elementos del arreglo.
codificación
La codificación es también aquella operación que tiene lugar para enviar datos de un lugar a otro, procesarlos y obtener resultados a partir de ellos. Todas las operaciones informáticas están cifradas en código binario, o bien, combinaciones más o menos complejas de unos y ceros que ocurren constantemente.A su vez, determinadas operaciones con ordenadores requieren un segundo nivel de codificación. Son aquellas que precisan de aspectos de seguridad y confidencialidad y, por ende, implican la creación de mensajes cifrados que sólo pueden ser leídos por cierto tipo de ordenadores o por el usuario que los ha creado, como ocurre con las contraseñas y datos personales en transacciones en línea.Este tipo de codificación tiene un alto valor de confiabilidad y se utiliza en todo tipo de tareas y entornos informáticos, en cuestiones tan simples como crear una cuenta en una red social y tan complejas como realizar operaciones bancarias y financieras por Internet.
Ejemplo:
Arreglos Multidimensionales
Este también es un tipo de dato estructurado, que está compuesto
por n dimensiones. Para hacer referencia a cada componente del arreglo es
necesario utilizar n índices, uno para cada dimensión
Para determinar el número de elementos en este tipo de arreglos
se usan las siguientes fórmulas:
RANGO (Ri) = lsi - (lii + 1)
No. TOTAL DE ELEMENTOS = R1 * R2* R3 * ...* Rn
donde:
i = 1 ... n
n = No. total de dimensiones
Para determinar la dirección de memoria se usa la siguiente
formula:
LOC A[i1,i2,i3,...,in] = base(A) +
[(i1-li1)*R3*R4*Rn + (i2-li2)*R3*R2*... (in -
lin)*Rn]*w
Operaciones Con Arreglos
Las operaciones en arreglos pueden clasificarse de la siguiente
forma:
·
Lectura
·
Escritura
·
Actualización
·
Ordenación
·
Búsqueda
a) LECTURA
Este proceso consiste en leer un dato de un arreglo y asignar un
valor a cada uno de sus componentes.
La lectura se realiza de la siguiente manera:
para i desde 1 hasta N haz
x<--arreglo[i]
b) ESCRITURA
Consiste en asignarle un valor a cada elemento del arreglo.
La escritura se realiza de la siguiente manera:
para i desde 1 hasta N haz
arreglo[i]<--x
c) ASIGNACIÓN
No es posible asignar directamente un valor a todo el arreglo,
por lo que se realiza de la manera siguiente:
para i desde 1 hasta N haz
arreglo[i]<--algún_valor
d) ACTUALIZACION
Dentro de esta operación se encuentran las operaciones de
eliminar, insertar y modificar datos. Para realizar este tipo de operaciones se
debe tomar en cuenta si el arreglo está o no ordenado.
Para arreglos ordenados los algoritmos de inserción, borrado y
modificación son los siguientes:
1.- Insertar.
Si i< mensaje(arreglo contrario caso En arreglo[i]<--valor
i<--i+1 entonces>
2.- Borrar.
Si N>=1 entonces
inicio
i<--1
encontrado<--falso
mientras i<=n y encontrado=falso
inicio
si arreglo[i]=valor_a_borrar entonces
inicio
encontrado<--verdadero
N<--N-1
para k desde i hasta N haz
arreglo[k]<--arreglo[k-1]
fin
en caso contrario
i<--i+1
fin
fin
Si encontrado=falso entonces
mensaje (valor no encontrado)
3.- Modificar.
Si N>=1 entonces
inicio
i<--1
encontrado<--falso
mientras i<=N y encontrado=false haz
inicio
Si arreglo[i]=valor entonces
arreglo[i]<--valor_nuevo
encontrado<--verdadero
En caso contrario
i<--i+1
fin
fin
Tipo_dato nombre_matriz [índice fila] [índice
columna] Nombre_matriz [subíndice1] [subíndice2] Para localizar o almacenar un
valor en el array se deben especificar dos posiciones (dos subíndices), uno
para la fila y otro para la columna. Los elementos se referencian con el
formato: T [3,4] elemento de la fila 3 y columna 4 Declaración de los arrays
bidimensionales: Al igual que en los arrays de una dimensión (vectores), los
arrays bidimensionales (tablas) se crean con declaraciones type y var cuando se
codifican en Pascal. Figura: Array de dos dimensiones T con 5 filas y 8
columnas.
Se deben indicar: Nombre del array Tipo del
array El rango permitido (es decir, el primero y último valores posibles) por
cada subíndice.
Ejemplos
Manipulación de Tablas: El orden mas natural
de procesar los vectores es el orden secuencial: del primero al último
elemento. En el caso de las tablas o arrays bidimensionales, existen diferentes
ordenes para su recorrido. Los más usuales son: recorrido por filas y recorrido
por columnas. Recorrido por filas/columnas: Los elementos de la primera
fila/columna se procesan primero, a continuación los de la segunda
fila/columna, y así sucesivamente. Sea el array A de 3 filas y 4 columnas. Los
recorridos serán:
Los recorridos se realizan mediante bucles
anidados, uno por cada dimensión o índice. Ejemplo: Leer los datos de la
siguiente tabla:
Técnicas de programación: Los tipos de
componentes de un array pueden ser de cualquier tipo predefinido o definido por
el usuario. Los tipos de los subíndices pueden ser de cualquier tipo ordinal,
excepto real. En Pascal, el tamaño del array debe ser declarado en el momento
que se escribe el programa. Por consiguiente, si el tamaño deseado varía de una
ejecución a otra, el array debe ser declarado del mayor tamaño posible. Es
buena idea utilizar constantes definidas para uno o los dos límites de un tipo
de índice del array. Este sistema permite que el tamaño del array pueda ser
modificado cambiando simplemente los valores de las constantes en las
declaraciones. A los elementos del array se puede acceder de modo secuencial,
con un bucle, o de modo aleatorio directamente por su índice. La asignación de
un array a otro requiere que los arrays sean del mismo tipo (A:=B).
Los elementos individuales de un array o el
array completo pueden ser pasados como parámetros a procedimientos. Errores
típicos de programación: Indices de la declaración del array fuera de rango o
de límite ( error en tiempo de ejecución) No inicializar los arrays Los tipos
de dos arrays utilizados en una sentencia de asignación de arrays deben ser los
mismos No deben existir inconsistencias de tipos. El tipo del subíndice y el
tipo del elemento utilizado en todas las referencias de los arrays deben
corresponder a los tipos especificados en la declaración del array.
Vídeos
http://www.youtube.com/watch?v=SMIyVS3k848
http://www.youtube.com/watch?v=dh7KEQKsJy0
http://www.youtube.com/watch?v=nAdjap7i_AU
Algunos gráficos :
