ARREGLOS

Que es un arreglo en programacin?

Un arreglo es una coleccin de datos del mismo tipo, que se almacenan en
posiciones consecutivas de memoria y reciben un nombre comn. Un arreglo
puede tener una coleccin finita, homognea y ordenada de elementos.
Finita: Todo arreglo tiene un lmite; es decir, debe determinarse cul ser el
nmero mximo de elementos que podrn formar parte del arreglo.
Homognea: Todos los elementos del arreglo deben ser del mismo tipo.
Ordenada: Se puede determinar cul es el primer elemento, el segundo, el
tercero y el siguiente el elemento.
TIPOS DE ARREGLOS
Arreglos Unidimensionales (vectores):
Un arreglo unidimensional es un tipo de datos estructurado que est formado
por una coleccin 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 posicin 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.
REPRESENTACIN EN MEMORIA: Los arreglos guardan en memoria la cantidad
de espacios que se le indican en la declaracin.
Ejemplo: sea el siguiente 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 posicin 1 guarda 34, en el arreglo X en la posicin 2 guarda 22, asi hasta
la ltima posicin del arreglo X posicin 5 guarda 72.
X [1]

22

34

X [3]

X [2]

39

X [4]

X [5]

63

72

Declaracin 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 declaracin de variables palabra reservada VAR.
Type
nombre_arreglo= array[x..y]of tipo_dato;
Ejemplos:
salarios= array [1x] 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 informacin en ellos,
para esto usamos estructuras repetitivas la mas recomendable por su facilidad
es el for, una vez cargada la informacin se puede hacer cualquier operacin
de calculo y por ltimo mostramos la informacin de los arreglos usando de
igual manera la estructura repetitiva for.
Carga de un arreglo, la letra i es el ndice o subndice del arreglo e indica la
posicin del arreglo:
for i:=1 to num do
begin
readln(notas[i]);
end;
Mostrar la informacin de un arreglo, la letra i es el indice o subindice del
arreglo e indica la posicin del arreglo::
for i:=1 to num do
begin
writeln(notas[i]:3:1);
end;

Se han hechos programas que suman una cantidad de nmeros usando dos
variables, una para leer cada nmero 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 nmeros con una cantidad
mnima de cdigo 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 nmero: ');
ReadLn(nums[i]);
s := s + nums[i];
End;
WriteLn('La suma es: ', s);
End.
Ntese el uso de una constante para marcar el tamao del arreglo; dicha
constante, tambin sirve para controlar el For. De este modo, slo se hace
necesario cambiar un nmero para adecuar el programa a la escala apropiada

Arreglos Bidimensionales (matrices, tablas):

Es un tipo de dato estructurado, finito ordenado y homogneo. El acceso a ellos
tambin es en forma directa por medio de un par de ndices.
Los arreglos bidimensionales se usan para representar datos que pueden verse
como una tabla con filas y columnas.

Crear arreglos bidimensionales

Los arreglos bidimensionales tambin son provistos por NumPy, por lo que
debemos comenzar importando las funciones de este mdulo:
from numpy import *

Al igual que los arreglos de una dimensin, los arreglos bidimensionales tambin
pueden ser creados usando la funcin 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 tamaos
de cada dimensin. En el ejemplo, a es un arreglo de dos dimensiones que tiene
tres filas y cuatro columnas:
>>> a.shape
(3, 4)

Los arreglos tambin tienen otro atributo llamado size que indica cuntos
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 funcin len, ya que no retorna el tamao del arreglo,
sino su cantidad de filas:

>>> len(a)
3

Las funciones zeros y ones tambin 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 funcin 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 dimensin, las operaciones sobre las matrices se
aplican trmino a trmino:
>>> 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 operacin, 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,
[ 9.54, 0.30,
[ 5.62, 0.54,
[ 8.19, 2.12,
[ 8.72, 1.47,
>>> a[1, 2]
2.14

5.33,
2.14,
0.71,
6.28,
0.77,

4.67, 6.41],
6.57],
2.56],
8.76],
8.78]])

>>> a[4, 3]
8.78
>>> a[-1, -1]
8.78
>>> a[0, -1]
6.41

Tambin 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 nmero de dimensiones es igual a la cantidad de rebanados que hay en

los ndices:
>>> a[2, 3]
2.56
>>> a[2:3, 3]
array([ 2.56])

# valor escalar (arreglo de cero dimensiones)

# arreglo de una dimensin de 1 elemento

>>> a[2:3, 3:4] # arreglo de dos dimensiones de 1 x 1

array([[ 2.56]])

Otras operaciones
La trasposicin consiste en cambiar las filas por las columnas y viceversa. Para
trasponer un arreglo, se usa el mtodo 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 mtodo reshape entrega un arreglo que tiene los mismos elementos pero otra
forma. El parmetro 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 funcin 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])

Adems, diag recibe un segundo parmetro opcional para indicar otra diagonal
que se desee obtener. Las diagonales sobre la principal son positivas, y las que
estn bajo son negativas:
>>> diag(a, 2)

array([ 4.67, 6.57])

>>> diag(a, -1)
array([ 9.54, 0.54])

La misma funcin diag tambin cumple el rol inverso: al recibir un arreglo de una
dimensin, retorna un arreglo bidimensional que tiene los elementos del
parmetro 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. Adems,
se le puede pasar un parmetro para hacer que la operacin 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 parmetro indica a lo largo de qu dimensin 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() tambin:
>>> a.argmin(0)
array([3, 3, 6, 0, 6])
>>> a.argmin(1)
array([3, 4, 1, 0, 3, 4, 4])

Arreglos multidimensionales
Un arreglo multidimensional es un arreglo cuyos elementos tienen ms de un
ndice.
El caso ms simple son los arreglos bidimensionales, que tienen dos ndices, y son
tiles para representar datos con formato tabular, como tablas y matrices.
Los arreglos multidimensionales son declarados indicando los tamaos a lo largo
de cada una de las dimensiones, separados por comas. Por ejemplo, un arreglo de
enteros de 5 3 es declarado as:
integer, dimension(5, 3) :: a

Este arreglo tiene quince elementos: desde a(1, 1) hasta a(5, 3).
La manera tpica de recorrer los elementos de un arreglo multidimensional es usar
varios ciclos do anidados, uno por cada dimension. Por ejemplo, el siguiente
programa suma todos los elementos del arreglo a declarado en el ejemplo anterior:
suma = 0
do i = 1, 5
do j = 1, 3

suma = suma + a(i, j)

end do
end do

Cada ndice no tiene un significado por s mismo. El programador puede

interpretar cada uno como quiera, siempre que sea consistente a lo largo del
programa. Por ejemplo, para los elementos a(i, j) de un arreglo bidimensional, uno
puede interpretar i como las filas de una tabla y j como las columnas, pero hacerlo
al revs tambin es correcto.

PARTES DE UN ARREGLO.
Los componentes: Hacen referencia a los elementos que forman el arreglo, es
decir, a los valores que se almacenan en cada una de las casillas del mismo.
Los ndices: Permiten hacer referencia a los componentes del arreglo en forma
individual, especifican cuntos elementos tendr el arreglo y adems, de qu
modo podrn acezarse esos componentes. Existen tres formas de indexar los
elementos de una matriz:
Indexacin base-cero (0): En este modo el primer elemento del vector ser la
componente cero (0) del mismo, es decir, tendr el ndice '0'. En consecuencia,
si el vector tiene 'n' componentes la ltima tendr como ndice el valor n-1.
* Indexacin base-uno (1): En esta forma de indexacin, el primer elemento de
la matriz tiene el ndice '1' y el ltimo tiene el ndice 'n' (para una matriz de 'n'
componentes).
* Indexacin base-n (n): Este es un modo verstil de indexacin en la que el
ndice del primer elemento puede ser elegido libremente, en algunos lenguajes
de programacin se permite que los ndices puedan ser negativos e incluso de
cualquier tipo escalar (tambin cadenas de caracteres).
Las operaciones que se pueden llegar a realizar con vectores o arreglos
durante el proceso de resolucin de un problema son las siguientes:
* Lectura (llenar el vector): El proceso de lectura de un arreglo consiste en leer
y asignar un valor a cada uno de sus elementos. Normalmente se realizan con
estructuras repetitivas, aunque pueden usarse estructuras selectivas.
* Escritura (mostrar el vector): Es similar al caso de lectura, slo que en vez de
leer el componente del arreglo, lo escribimos.
* Asignacin (dar valor a una posicin especfica): No es posible asignar
directamente un valor a todo el arreglo; sino que se debe asignar el valor

deseado en cada componente. Con una estructura repetitiva se puede asignar

un valor a todos los elementos del vector.
* Actualizacin (dar valor a una posicin especfica): Incluye aadir (insertar),
borrar o modificar algunos de los ya existentes. Se debe tener en cuenta si el
arreglo est o no ordenado. Aadir datos a un vector consiste en agregar un
nuevo elemento al final del vector, siempre que haya espacio en memoria.
Recorrido (acceso secuencial): El acceso a los elementos de un vector puede ser para
leer en l o para escribir (visualizar su contenido). Recorrido del vector es la accin de
efectuar una accin general sobre todos los elementos de ese vector.
* Ordenacin.
* Bsqueda.
INICIALIZACIN DE LOS ARREGLOS.
Al igual que otras variables, los arreglos se pueden inicializar al momento de declararse.
Para hacer eso, es necesario enlistar los valores de cada uno de los elementos del
arreglo entre llaves y separados por comas. Ejemplo:
Int b [3] = {2, 12, 1};
En casos como ste, cuando se escriben cada uno de los valores de los elementos del
arreglo, algunos compiladores permiten omitir el tamao del arreglo en la Declaracin. Por
ello, la declaracin:
Int b [ ] = {2, 12, 1};
Sera equivalente a la anterior.
DECLARACIN DE ARREGLOS.
Un arreglo es prcticamente una lista de variables. Cada una de las variables de la lista
tiene un nombre que est constituido por dos partes. Una de las partes es el nombre del
arreglo, nombre que van a compartir cada una de las variables de la lista. La otra parte es
diferente para cada variable y es lo que permite identificar a una variable de la lista de
otra.
Los tipos arreglo se declaran en la seccin type del programa:
Nombre = array [tipo ndice] of tipo base;
Tipo ndice debe ser un tipo ordinal, generalmente es un sub rango de enteros.
Tipo base es cualquier tipo de Pascal
ERRORES COMUNES EN LOS ARREGLOS
El error ms comn en el manejo de arreglos es el tratar de usar un elemento del arreglo
que no existe. Este error slo es detectado por algunos de los compiladores de C++ y se
muestra con un mensaje similar a:
array ndex out of range

Cadena de caracteres

En programacin, una cadena de caracteres, palabra, ristra de caracteres o frase (string

en ingls) es una secuencia ordenada de longitud arbitraria (aunque finita) de elementos
que pertenecen a un cierto lenguaje formal o alfabeto anlogas a una frmula o a una
oracin. En general, una cadena de caracteres es una sucesin de caracteres (letras,
nmeros u otros signos o smbolos).
Desde un punto de vista de la programacin, si no se ponen restricciones al alfabeto, una
cadena podr estar formada por cualquier combinacin finita de todo el juego de
caracteres disponibles (las letras de la 'a' a la 'z' y de la 'A' a la 'Z', los nmeros del '0' al
'9', el espacio en blanco ' ', smbolos diversos '!', '@', '%', etc). En este mismo mbito (el
de la programacin), se utilizan normalmente como un tipo de dato predefinido, para
palabras, frases o cualquier otra sucesin de caracteres. En este caso, se almacenan en
un vector de datos, o matriz de datos de una sola fila (array en ingls). Las cadenas se
pueden almacenar fsicamente:
Seguidas.
Enlazada letra a letra.
Generalmente son guardados un carcter a continuacin de otro por una cuestin de
eficiencia de acceso.
Un caso especial de cadena es la que contiene cero caracteres, a esta cadena se la llama
cadena vaca; en teora de autmatas es comn denotar a la misma por medio de la letra
griega \psilon.

Operacin con cadena de caracteres

Siguiendo en el mbito de la informtica, al considerar las cadenas como un tipo de datos,
hay que definir (o conocer) cuales son las operaciones que podemos hacer con ellas, en
principio stas podran ser muchas y llegar a ser muy sofisticadas, aqu se exponen
algunas de ellas:
Asignacin: Consiste en asignarle una cadena a otra.
Concatenacin: Consiste en unir dos cadenas o ms (o una cadena con un carcter) para
formar una cadena de mayor tamao.
Bsqueda: Consiste en localizar dentro de una cadena una subcadena ms pequea o un
carcter.
Extraccin: Se trata de sacar fuera de una cadena una porcin de la misma segn su
posicin dentro de ella.

Comparacin: Se utiliza para comparar dos cadenas.

Representacin
Una cadena suele ser representada entre comillas dobles superiores ("palabra"), mientras que un
carcter de esa cadena (unchar en ingls) suele ser representado entre comillas simples ('p'). Por
ejemplo, en C:

charAt c = 'a';
char str[5] = "hola";

Generalmente para acceder a un carcter en una posicin determinada se suele usar la

forma variable[posicin] como cuando se accede a un vector.
Para poder mostrar una comilla (") dentro de la cadena y no tener problemas con las comillas que la
delimitan, se usan secuencias de escape. Esto se aplica a otros caracteres reservados o no imprimibles
como el retorno de carro. No obstante, las expresiones para producir estas secuencias de escape
dependen del lenguaje de programacin que se est usando. Una forma comn, en muchos lenguajes,
de escapar un carcter es anteponindole un \ (sin comillas), p. e.: \" (sin comillas).

Cadenas dinmicas y estticas

Las cadenas pueden ser de naturaleza dinmica (pueden alterar su longitud durante el tiempo de
ejecucin), o de naturaleza esttica (su longitud es fija a lo largo del tiempo de ejecucin). En este
segundo caso el programador debe prever que al recorrer la cadena los indces no se vayan de los
lmites previstos (C no permite que las cadenas crezcan automticamente de forma explcita, mientras
que C# s).
El final de la cadena se delimita de diferente manera en uno u otro caso:

Mediante un carcter de fin de cadena ("\0" en C) para las cadenas de tipo dinmico.

Mediante una propiedad de la cadena que delimite su longitud ( Length en C#) para las de tipo
esttico.

Ejemplos de algunas operaciones comunes

Asignacin: asignarle una cadena a otra

char *strcpy(char [], const char[]); # en C

cadena1=cadena2;

# en C++

cadena1 := cadena2

# en Smalltalk

Concatenacin: unir dos cadenas de caracteres.

$pareja = "Joshua"." y "."Lidia"

# en Perl y PHP;

pareja = "Luisa" & " y " & "Carmen"

# en Visual Basic;

pareja = "Luisa" + " y " + "Carmen"; # en C++ y Java con la clase String.
pareja := 'Luisa' , ' y ' , 'Carmen'.

# en Smalltalk

strcat(cadena1,cadena2); strcat(cadena1, cadena3); # en C (Debe haber

suficiente espacio en la primera)

N de caracteres de una cadena

int strlen(const char[]); # en C Devuelve el n de caracteres sin contar el

'\0'
cadena.length();

# en C++

cadena size.

# en Smalltalk

Comparacin: Compara dos cadenas en orden lexicogrfico

int strcmp(const char[], const char[]); # en C Devuelvee <0 si la 1 es

menor, >0 si es mayor y 0 si son iguales
cadena1==cadena2; cadena1>cadena2; etc. # en C++ Devuelve un valor de verdad
cadena1 = cadena2

# en Smalltalk Devuelve true o false.

Multiplicar una cadena: repetir una cadena un nmero de veces

$puntos ="." x 5 # pone 5 puntos en Perl

puntos := Generator generateJoin: '.' repeat: 5.

# Genera una cadena de 5

puntos en Smalltalk

Manipulacin de bits (bitwise)

Formato de nmeros enteros
Almacenamiento:
Endiannes: Describe como es almacenado un entero en la memoria sobre todo cuando
ocupan ms de un byte para su almacenamiento, y puede dividirse en dos tipos: bigendian y little-endian.
big-endian: Primero se almacena el byte mas significativo (caso Java, protocolo IP,
motorota, PowerPC)
little-endian: Primero se almacena el byte menos significativo (caso Pentium Intel)
Estas palabras se usan para referirse a las dos formas en que se pueden guardar los
nmeros que ocupan ms de un byte.
Por ejemplo el nmero 5. Si se expresa en binario con 4 bits, su equivalencia es 0101. Si
se hace con 8 bits, sera 00000101. Pero si se usa ms de un byte para representarlo, por
ejemplo porque se tratara de un nmero "entero corto", usando la nomenclatura del
lenguaje Java o C, se tiene que el nmero 5 equivaldra a 16 dgitos binarios: 00000000
00000101.
Por tanto, ahora este nmero 5 queda representado como 2 bytes. El de la izquierda es el
byte ms significativo (MSB) y el de la derecha es el bit menos significativo (LSB). Estos
nombres vienen de que un cambio en el byte de la derecha hace que el nmero cambie
poco (por ejemplo, 00000000 00000100 = 4 en decimal), mientras que un cambio en el
byte de la izquierda provoca cambios mucho ms grandes (00000001 00000101 = 261 en
decimal).
De acuerdo a la arquitectura de una computadora, puede ocurrir que esos dos bytes se
guarden en el orden que hemos visto: 00000000 00000101 (primero el MSB y luego el
LSB) o al contrario (00000101 00000000).
El primer formato (MSB LSB) es lo que se conoce como Big Endian, porque eso de que el
extremo ms grande aparece en primer lugar. El segundo formato (LSB MSB) es lo que
se conoce como Little Endian, porque se almacena primero el dato ms pequeo.

Esto es importante dentro de la programacin, ya que muchas veces deberemos saber

con qu plataforma se ha creado un archivo de datos, o en que plataforma estamos
trabajando, para poderlo interpretar correctamente.
En general, en caso de que un archivo contenga datos numricos de ms de un byte,
deberamos saber si estn almacenados en formato Little Endian o Big Endian, e
intercambiar el orden de los bytes despus de leer, si fuera necesario, de la misma
manera debemos tener en cuenta esta informacin, si se van a enviar datos numricos
por la red (Internet).
Sistemas numricos:
Los sistemas numricos mas utilizados en computacin son:
Binario que es tipo base de almacenamiento de cualquier tipo de dato, programa
ejecutable. Los valores que estn comprendidos son el 0 y el 1. Para el caso de los
enteros que es lo que nos interesa en este tema, la conversin de decimal a binario se
hace siguiendo en mtodo natural que es basado en una sucesin de divisiones y para su
almacenamiento interno se considera todo el tamao de la palabra (o registro) de acuerdo
al tipo de entero que se trate, la cantidad de bits que haran falta para completar dicha
cantidad se llenara de la siguiente manera:
Si el nmero es positivo se agrega la cantidad de ceros necesarios para completar la
palabra por la izquierda, por ejemplo: el nmero 15 en binario es 1111, si es un valor de
tipo:
byte, se completaria: 00001111
short, se completaria: 00000000 00001111
int, se completaria: 00000000 00000000 00000000 00001111
long, se completaria: 00000000 00000000 00000000 00000000 00000000 00000000
00000000 00001111
Otros ejemplos:
|Decimal |Binario
|Tipo |
|2 |00000010 |byte |
|63 |00000000 00111111 |short |
|4863 |00000000 00000000 00010010 11111111 |int |
|500 |00000000 00000000 00000000 00000000 00000000 00000000 00000001 11110100
|long |

CONCLUSIN.
Uno de los problemas ms comunes en los diversos sistemas de informacin es
el tratamiento o procesamiento de un gran volumen de datos o de informacin.
Pero para resolver dichos problemas se emplea el mtodo del arreglo, que nos
sirve para Ordenar y estructurar datos que responden a una misma realidad o
entidad, pero donde cada uno hace referencia a una instancia y De este modo
nos evitamos tener n variables de un mismo tipo.
En la programacin tradicional siempre se manejan dos tipos de arreglos los
arreglos tipo listas, vectores o unidimensionales y los arreglos tipo tablas,
cuadros, concentrados, matrices o bidimensionales en ambos casos son
variables que permiten almacenar un conjunto de datos del mismo tipo a la
vez, su diferencia es en la cantidad de columnas que cada uno de estos tipos
contiene.
Para concluir en pocas palabras, un arreglo es la mejor solucin a la hora de
agrupar distintos datos que sean de un mismo tipo, estos datos se almacenan
en la memoria y reciben un nombre comn para todos.

BIBLIOGRAFIA.

* Titulo: Pascal Introduccin al lenguaje y resolucin de problemas con

programacin estructurada.
Autor: Elliot B. Koffman.
Editorial: Addison Wesley Iberoamericana.