Un arreglo es un conjunto de celdas de
memoria relacionadas entre si ya que todos tienen el mismo nombre y almacenan
el mismo tipo de datos para referirse a una celda en particular algún elemento
dentro del arreglo y entre corchetes [ ] el número de posición del elemento
dentro del arreglo.
El primer elemento se almacena en la
posición 0 del arreglo, es decir el primer elemento del arreglo se conoce como
a[0], el segundo como a[1], el séptimo como a[6] y en general el elemento de
orden i del arreglo a se conoce como a[i-1].
El número de posición que aparece
dentro de los corchetes se conoce como índice y debe ser un
número entero o una expresión entera, por ejemplo:
printf ("%i", a[0]+a[5]+a[10]);
x=a[7]/2;
x=a[4]=12;
Para declarar un arreglo se emplea la siguiente
sintaxis:
tipo_de_dato nombre_del_arreglo
[número de elementos];
int a[12];
float
f[10];
char
nom_emp [30];
Ejemplo:
#include
<stdio.h>
#include
<conio.h>
#define
MAX 12
void
main(){
int
a[MAX], b[MAX], c[MAX], i, j=0, k=0;
clrscr();
printf ("Programa que almacena
12 numeros en un arreglo ");
printf ("y luego los separa en
dos de acuerdo a su valor.\n");
for (i=0; i < MAX; i++){
printf
("Introduce el valor %i: ", i+1);
scanf
("%i", &a[i]);
}
for (i=0; i < MAX; i++)
if
(a[i] < MAX){
b[j]
= a[i];
j++;
}
else
{
c[k]
= a[i];
k++;
}
printf ("\nLos numeros quedan
asi:\n\n");
for (i=0; i < j; i++)
printf
("%i\n", b[i]);
for
(i=0; i < k; i++)
printf
("\t%i\n", c[i]);
getch();
}
Arreglos
unidimensionales
Un arreglo unidimensional es un tipo de datos
estructurado que está formado por una colección finita y ordenada de datos del
mismo tipo. Es la estructura natural para modelar listas de elementos iguales.
Los datos que se guarden en los arreglos todos deben ser del mismo tipo.
El tipo de acceso a los arreglos unidimensionales es el acceso directo, es
decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar
a elementos anteriores o posteriores, esto mediante el uso de un índice para
cada elemento del arreglo que nos da su posición relativa.
Para implementar arreglos unidimensionales se debe reservar espacio en memoria.
Los arreglos nos permiten hacer un conjunto de
operaciones para manipular los datos guardados en ellos, estas operaciones son:
ordenar, buscar, insertar, eliminar, modificar entre otras.
REPRESENTACION EN MEMORIA: Los arreglos guardan en memoria la
cantidad de espacios que se le indican en la declaración.
Ejemplo: sea el siguente arreglo unidimensional
donde se va a guardar 5 datos de tipo entero (integer)
x : array[1..5] of integer
En memoria el computador guarda 5 espacios: esto
quiere decir en el arreglo X en la posición 1 guarda 34, en el arreglo X en la
posición 2 guarda 22, asi hasta la última posición del arreglo X posicion 5
guarda 72.
X [1]
34
X [2]
22
X [3]
39
X [4]
63
X [5]
72
Declaracion de los arreglos unidimensionales: Se declara el tipo del
arreglo, con la palabra reservada TYPE, luego se declara la variable de tipo
arreglo, esto se hace en el bloque de declaracion de variables palabra
reservada VAR.
Type
nombre_arreglo= array[x..y]of tipo_dato;
Ejemplos:
salarios= array [1…x] of real;
nombre_trabajador=array[1..x] of string;
Nota: El tipo de dato del arreglo puede ser:
integer,real, boolean, string etc.
Variables tipo array
Var
sueldo:salarios;
nombre:nombre_trabajador;
Una vez declarados los arreglos procedemos a cargar
información en ellos, para esto usamos estructuras repetitivas la mas
recomendable por su facilidad es el for, una vez cargada la información se
puede hacer cualquier operación de calculo y por último mostramos la
información de los arreglos usando de igual manera la estructura repetitiva
for.
carga de un arreglo, la letra i es el indice o
subindice del arreglo e indica la posición del arreglo:
for i:=1 to num do
begin
readln(notas[i]);
end;
Mostrar la información de un arreglo, la letra i es
el indice o subindice del arreglo e indica la posición del arreglo::
for i:=1 to num do
begin
writeln(notas[i]:3:1);
end;
Se han hechos programas que suman una cantidad de
números usando dos variables, una para leer cada número y otra para acumular la
suma. Este enfoque tiene la desventaja de que se pierden los valores de los
sumandos. El uso de arreglos permite calcular la suma de los números con una
cantidad mínima de código y a la vez conservar cada valor, como muestra el
siguiente programa completo:
Program SumaN;
Uses
Crt;
Const
n = 5;
Var
nums: Array[1..n] Of
Integer;
s, i: Integer;
Begin
For i:=1 To n Do
Begin
Write('Escriba el número: ');
ReadLn(nums[i]);
s := s + nums[i];
End;
WriteLn('La suma es: ', s);
End.
Nótese el uso de una constante para marcar el tamaño del arreglo; dicha
constante, también sirve para controlar el For. De este modo, sólo se hace
necesario cambiar un número para adecuar el programa a la escala apropiada
Ejercicios de arreglos unidimensionales:
* Dadas n cantidad de notas, calcular e imprimir el
promedio de las notas y todas las notas que fueron mayor a la media calculada.
PROGRAM calificaciones;
USES CRT;
type
listacalificaciones=array[1..n]of real;
VAR
notas:listacalificaciones;
media,suma:real;
num,i:integer;
BEGIN
WRITELN('INTRODUZCA la cantidad de notas a procesar');
READLN(NUM);
suma:=0;
for i:=1 to num do
begin
readln(notas[i]);
suma:=suma+notas[i];
end;
media:=suma/num;
writeln('la media es:' , media:2:2);
writeln('la lista de calificaciones mayores a la media es:');
for i:=1 to num do
begin
if notas[i]>media then
writeln(notas[i]:3:1);
readln;
end;
END.
(*Escribir un programa en pascal que rellene un array con 11
numeros, luego dividirlos entre 3 y mostralos por pantalla *)
PROGRAM numeros;
USES CRT;
type
arreglonumeros=array[1..11]of real;
VAR
num:arreglonumeros;
i:integer;
numero:real;
BEGIN
for i:=1 to 11 do
begin
WRITELN('Introduzca el numero ' , i, ' a dividir');
readln(num[i]);
numero:=num[i]/3;
write('los numero resultantes de la division son:' ,numero:2:2);
readln;
end;
end.
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:
from numpy import *
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:
>>>
a.shape
(3, 4)
Los
arreglos también tienen otro atributo llamado size que
indica cuántos elementos tiene el arreglo:
>>>
a.size
12
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:
>>>
len(a)
3
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]])
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
