GUIA - Alg y Prog - ParteII

Universidad Bolivariana de Venezuela
Programa de Formación de Grado en Informática para la Gestión Social
GUIA
UNIDAD CURRICULAR
ALGORITMOS Y PROGRAMACIÓN
Parte II
CONTENIDO
Capítulo 6 Concepto y Clasificación de Tipos de Datos.............................................................................18

6.1.- Definición de Tipo de Dato.............................................................................................................18
6.2.- Características de los Ttipos de Datos.............................................................................................18
6.3.- Ventajas de los Tipos de Datos.......................................................................................................18
6.4.- Verificación de Tipos de Datos.......................................................................................................19
6.5.- Compatibilidad de Tipos de Datos..................................................................................................19
6.6.- Especificación e implementación de los Tipos de Datos................................................................20
6.7.- Clasificación de los Tipos de Datos predefinidos...........................................................................20
6.7.1.- Tipos de Datos Elementales o no estructurados.......................................................................21
6.7.2.- Tipos de Datos Estructurados...................................................................................................28
Capítulo 7 Lenguaje para expresar los algoritmos: Pseudo-Código............................................................37
7.1.- Variables..........................................................................................................................................37
7.2.- Instrucciones Algorítmicas Básicas................................................................................................39
7.3.- Expresiones Aritméticas..................................................................................................................41
7.3.1.- Operadores Aritméticos............................................................................................................41
7.4.- Expresiones Lógicas........................................................................................................................44
7.4.1.- Operadores relacionales y lógicos............................................................................................44
Capítulo 8 Estructuras de Control................................................................................................................45
8.1.- Selección..........................................................................................................................................45
8.2.- Condiciones....................................................................................................................................45
8.3.- Bifurcación.....................................................................................................................................46
8.4.- Iteración..........................................................................................................................................47
Bloque de instrucciones...........................................................................................................................49
17
Capítulo 6
Concepto y Clasificación de Tipos de Datos
6.1.- Definición de Tipo de Dato

Un Tipo de dato es un conjunto de valores junto a una serie de operaciones que
pueden ser aplicadas sobre dichos valores.
Por ejemplo, objetos de tipo Entero puede tomar valores del conjunto de los
enteros, y las operaciones sobre dichos valores son la adición, la sustracción, la
multiplicación y la división.
6.2.- Características de los Ttipos de Datos

- Un tipo determina la clase de valores que puede asumir una variable o una
expresión. En ocasiones una variable determina el tipo de una expresión: por
ejemplo en C, entero=entero*real, real=entero*real.
- Cada variable pertenece a un solo tipo (salvo en EOO).
- Cada operador actúa sobre operandos de algún tipo (o algunos tipos cuando
se tiene polimorfismo paramétrico: como +, *, /, etc.), y da como resultado un
valor de algún tipo (según los operandos y las reglas específicas del lenguaje).
6.3.- Ventajas de los Tipos de Datos

- La verificación de tipos es realizada por el traductor.
- Tiene asociado la abstracción de datos y procedural: Permite agrupar un
conjunto de valores y permite ver las operaciones sobre los valores de manera
indivisibles.
- Ocultamiento de la representación interna: se ve sólo la especificación y no la
implementación.
- permiten cambiar la representación interna de las abstracciones sin afectar los
programas que las untilizan. Por ejemplo, el tipo punto puede representarse
como un arreglo de dos reales, o un registro de dos reales, sin afectar los
programas que lo utilizan.
- Aumento en la portabilidad en los programas. Ejemplo: Usamos el tipo
coordenada como un entero de 2 bytes (typedef int Coordenada). En otras
arquitecturas el int es de 4 bytes; así que solo cambiamos el tipo por un entero
18
corto: (typedef short int Coordenada), y no tenemos que hacer mayores

cambios en los programas.
6.4.- Verificación de Tipos de Datos

Verificar tipos significa detectar que cada operación reciba el número adecuado de
argumentos, y que dichos argumentos sean del tipo adecuado. (un argumento de
un operador es como un operando). Dependiendo del momento en que se realiza
la operación, podemos tener una verificación estática (en tiempo de traducción) o
una verificación dinámica (en tiempo de ejecución).
Para realizar la verificación de tipos se requiere la siguiente información:
Para cada operación: Cantidad, orden y tipo de argumento; y tipo de resultado
Para cada variable, el conjunto de valores que puede tomar (según su tipo)
Para cada constante, se asocia un tipo.
Ejemplo:
Int X, Y;
X = Factorial(n)+3*Y.
Para factorial, se chequea si los argumentos están conformados por un solo
entero. Para '+' se determina el retorno de Factorial (entero), y el otro operando
que en este caso es 3*Y. Para la asignación, el lado derecho debe ser del mismo
tipo que el lado izquierdo salvo que haya conversión automática de tipos.
6.5.- Compatibilidad de Tipos de Datos

Dos tipos son compatibles, según la equivalencia entre argumento y variable para
el lenguaje usado:
Equivalencia por nombre: Dos variables tiene tipos compatibles si tienen el
mismo nombre de tipo. Ejemplo: Si A y B son enteros -> son compatibles. Si A y B
son de tipo Punto Þ Son compatibles.
Equivalencia estructural: Dos variables tienen tipos compatibles si tienen la
misma estructura interna. Ejemplo: Sean A y B como sigue:
A=Arreglo[1..n] de entero; B=Arreglo[1..n] de entero Þ A y B son compatibles
Otro ejemplo:
Tipo Coordenada=entero;
Var x,y: Coordenada;
z: entero;
19
x = z; // esta asignación es válida desde el punto de vista estructural
Si los tipos son compatibles (entre argumento y parámetro por ejemplo), se acepta
el argumento y se continúa la operación. Si son distintos y según el lenguaje
puede suceder:
- Error fatal: Inconsistencia de tipos.
- Conversión de tipos (por ejemplo en C, en la asignación entero = real, el real
es convertido a entero automáticamente).
6.6.- Especificación e implementación de los Tipos de Datos

Los tipos de datos pueden ser estudiados en dos niveles de abstracción
diferentes:
a) Especificación: define la organización lógica del tipo, la cual se compone de
valores, atributos y operaciones.
Para la especificación de las operaciones, colocamos el encabezado de la
operación, y la precondición que se debe cumplir en le momento de la llamada (si
la hay), y la postcondición, condición que debe cumplirse al finalizar la operación,
lo cual determina el efecto.
Acción Suma(Punto a; Punto b; Var Punto c)

Pre: Ninguna
Post: Sea a=(x1,y1), b=(x2,y2)  c=(x1+x2, y1+y2)
Arg1 / Arg2 // división

Pre: Arg2 <> 0
Post: retorna la parte entera de la división
b) Implementación: Define la forma en la cual los atributos y operaciones son

representados internamente. Para ello se elige una representación de los datos
(estructuras de datos) y se implementan las operaciones usando esta
representación.
6.7.- Clasificación de los Tipos de Datos predefinidos

El criterio para clasificar los tipos de datos predefinidos (generalmente presentes
en los lenguajes de programación) está dado por el número de componentes
20
(determina si es estructurado o no) y según el tipo de sus componentes (si es no

estructurado equivale al tipo, y si es estructurado determina si es homogéneo o
heterogéneo).
Podemos referirnos a objetos de tipo no estructurado, cuando el conjunto de

valores que pueden tomar son no estructurados, y objetos de tipo estructurado,
cuando el conjunto de valores que pueden tomar son estructurados.
6.7.1.- Tipos de Datos Elementales o no estructurados
Los tipos de datos no estructurados que están disponibles en la mayoría de los
lenguajes de programación son el tipo entero, caracter, real y lógico. Muchos
lenguajes permiten la definición de tipos subrango o subintervalos, y enumerados.
A continuación explicaremos brevemente cada uno de estos tipos.
1) Tipo entero:
a) Conjunto de valores: Subconjunto de los enteros
b) Conjunto de operaciones: adición (+), sustracción (-), multiplicación (*), división
entera (DIV), y residuo de la división (MOD). Las operaciones que se realizan
sobre enteros son exactas (salvo desbordamiento u operaciones inválidas como
dividir por cero). La especificación de las operaciones es trivial por lo que no
entraremos en detalle con todas.
Note que se pueden expresar unas operaciones en función de otras, siempre y
cuando no ocurran ciclos.
c) Implementación de la representación:
La implementación viene dada en el computador virtual. Si un computador utiliza n
bits para representar un entero en notación complemento a2, entonces el conjunto
de enteros representables comprende 2n valores desde -2n-1 hasta 2n-1-1. En
complemento A2, los números positivos se almacenan tal cual, y el bit de signo
vale 0. Pero los negativos están complementados y sumado 1, y el bit de signo en
1. Por ejemplo, el número -1 en 16 bits es 1111111111111110. Para decodificarlo,
21
se complementan los bits de mantisa y se suma 1, osea, 1000000000000001. La

representación signo magnitud consiste en un bit de signo, y n-1 bits para la
magnitud del número, y puede tomar valores desde -2n-1 hasta 2n-1. Según el
lenguaje (como los interpretados), un entero puede tener un descriptor a momento
de ejecución, que simplemente dice el tipo de dato, y cualquier otro atributo que el
lenguaje considere necesario.
1 n-1 bits
E Magnitud
Signo
Tipo de dato = Entero
d) Cardinalidad: La cardinalidad se define como el conjunto de valores que puede

tomar una variable de un tipo de dato dado. Se puede decir que la cardinalidad
está determinada por el conjunto de valores asociados a un tipo. La cardinalidad
de un entero de n bits es 2n en complemento A2. En signo magnitud, en entero
tiene doble representación (-0,+0), y por ende su cardinalidad es 2n-1. El
descriptor indica que el dato es un entero y se usa en tiempo de compilación nada
más. Sin embargo, en lenguajes como LISP todo átomo o lista tiene un descriptor,
ya que la verificación de tipos se hace en RUN-TIME, en parte por ser un lenguaje
interpretado.
2) Tipo real:
a) Conjunto de valores: El tipo real tiene asociado un subconjunto de los reales.
b) Conjunto de operaciones: Las operaciones más comunes sobre reales son la
adición, resta, multiplicación y división. La especificación de estas operaciones es
trivial por lo que no entraremos en detalles. Las operaciones sobre reales permiten
manipular un gran rango de números; sin embargo, por errores de truncamiento y
redondeo se tiene un error asociado a las operaciones y a la representación
numérica.
c) Implementacióin de la representación: Se representan en el computador como
un par de enteros, generalmente de rangos distintos, de la forma:
22
donde la mantisa y el exponente están representados análogamente a un entero

(signo-magnitud, complemento A1, A2 u otro). En ocasiones se puede tener los
signos seguidos de las magnitudes de cada entero. R (descriptor) indica que el
dato es un real, y se usa sólo en tiempo de traducción.
Esta representación del real proviene del hecho de que cada número real puede
ser expresado en notación científica. Por ejemplo, el número -45.32 puede
expresarse como -0.4532x102. La mantisa sería 4532 y el exponente 2.
Generalmente el número de bits que se reservan para la mantisa es mayor que
para el exponente. Para un ejemplo real, en binario el número 1.01 puede
escribirse como 0.101x21, siendo la mantisa 101, y el exponente 1.
d) Cardinalidad: La cardinalidad de un real con n bits para la mantisa y m bits para
el exponente es CARD(real) = 2n.2m = 2n+m, si la mantisa y el exponente están
representados en complemento A2. Si usan signo magnitud, el cero tiene
representación doble en la mantisa y el exponente; por lo tanto, la cardinalidad es
(2n-1)*(2m-1).
3) Tipo caracter:
a) Conjunto de valores: Corresponde a un conjunto de caracteres y operaciones
sobre ellos. Depende del sistema de codificación. Ejemplo: Tabla ASCII tiene 128
caracteres, y la ASCII extendida 256 caracteres.
b) Conjunto de operaciones: Como veremos posteriormente, el conjunto de
caracteres es un conjunto ordenado, por lo que las operaciones más comunes
entre ellos son: operaciones relacionales (>, <, >=, <=, <>, =), Primero, Ultimo,
Sucesor, Predecesor, Ordinal y Caract.
Función Ordinal(c: Caracter)  Entero;

{retorna el entero asociado al caracter según su ubicación en el sistema de
codificación. Ejemplo, el sistema ASCII.}
Pre: Niguna
Post: Retorna la posición del carácter en la tabla
Función Sucesor(c: Caracter)  Carácter

Pre: c <> Ultimo()
Post: Retorna Sucesor(x)=Caract(Ordinal(x)+1)
...// Puede seguir con las otras operaciones??. TAREA
23
c) Implementación de la representación: Desafortunadamente no existe un

conjunto de caracteres que se use en todos los sistemas de computación. Sin
embargo, la Organización Internacional de Normas (ISO) define el código
Estadounidense ASCII (Código Estándar Estadounidense para el Intercambio de
Información), el cual constituye el código más aceptado. Este código consta de
128 caracteres, de los cuales, 99 son imprimibles y los restantes 33 son de
control. En muchas máquinas se usan 8 bits para representar los caracteres, y
suele usarse la tabla ASCII extendida, que consta de 256 caracteres (los mismos
128 del Código ASCII, y otros 128 caracteres).
En el conjunto de caracteres se tienen las 26 letras mayúsculas latinas, las 26
minúsculas, los 10 números arábigos, y otros caracteres como los signos de
puntuación y el espacio. Entre los caracteres hay un orden, que viene dado por el
valor binario que tiene asociado. Este orden depende del sistema de codificación
que se use. Sin embargo, en general el subconjunto de letras y números son
ordenados y contiguos, cumpliéndose:
'a' < 'b' < .... < 'z'

'A' < 'B' < .... < 'Z'
'0' < '1' < .... < '9'
Esto hace que los operadores relacionales puedan aplicarse, en muchos

lenguajes, sobre los caracteres. Así mismo, muchos lenguajes de alto nivel
proveen herramientas para poder realizar operaciones aritméticas sobre el
conjunto de los caracteres. En Pascal Succ('a') = 'b'; Chr(ORD('a')+1)='b'. En C,
sencillamente 'a'+1='b'. Si se tiene a lo sumo 256 caracteres, con un byte pueden
representarse todos estos valores, y sumado a un descriptor poco común puede
verse como sigue:
C 8 bits para el caracter
Tipo de dato=Caracter
d) Cardinalidad: La cardinalidad de un caracter es 128 en caso de usar el sistema

de codificación ASCII, o 256 en caso de usar ASCII extendido.
24
4) Tipo lógico:
a) Conjunto de valores: Se asocia con el conjunto de valores lógicos verdadero y
falso.
b) Conjunto de operaciones: Las más comunes entre valores lógicos son: O (Or),
Y (And) y No (Not). En muchos lenguajes se provee otras operaciones que se
pueden obtener como composición de las anteriores; por ejemplo, Ó (Xor). La
especificación de estas operaciones es trivial por lo que no se entrará en detalles.
Los operadores relacionales pueden aplicarse entre los lógicos, ya que en la
representación se le asigna un valor entero a verdadero, y otro valor a falso.
c) Implementación de la representación: Computacionalmente estos dos valores
se representan en general como 1 y 0 respectivamente. Para almacenar estos
valores bastaría con la unidad mínima de información en un computador: el bit; sin
embargo, la unidad mínima de direccionamiento en la mayoría de los
computadores es el byte, por lo que el tipo lógico puede representarse como un
byte (o incluso una palabra) cuyos valores posibles son 1 y 0. Si este es el caso,
existe un orden en este conjunto: falso < verdadero.
L Valor del Lógico
Tipo de dato=Lógico
En algunos lenguajes, se le asocia el valor cero a falso, mientras que verdadero es

cualquier valor distinto de cero. Esto ocurre en lenguaje C, donde los lógicos no
están definidos como un tipo de dato, aunque al momento de plantear
condiciones, el valor de falso es 0 y verdadero cualquier valor no nulo.
d) Cardinalidad: La cardinalidad de este conjunto es CARD(Lógico) = 2.
5) Tipo subrango:
a) Conjunto de valores: Con frecuencia sucede que una variable caracter o entera
toma valores sólo dentro de un intervalo. En estos casos, se puede definir un tipo
de dato, cuyo conjunto de valores asociado es dicho subintervalo (tipo subrango).
Este tipo de dato es definido por el usuario, pero también es no estructurado,
porque los valores válidos que puede tomar una variable de este tipo, es un
subconjunto de los enteros o caracteres, según el caso. A continuación veremos
unos ejemplos de la definición de subrangos.
Tipo año = [1900 .. 2000]
Tipo letra = ['A' .. 'Z']
25
Tipo Dígito = ['0' .. '9']

Tipo índice = [1 .. 100]
b) Conjunto de operaciones: Las operaciones son heredadas de las operaciones

del tipo de dato original del cual se define un subrango (Tipo caracter o entero).
Por esto no entraremos en detalle.
c) Implementación de la representación: Usaremos la siguiente definición de tipo
subrango general para detallar la representación.
Tipo <Nombre-Subrango> = [<Li> .. <Ls>]
En muchos lenguajes se maneja un descriptor que contiene el tipo de dato

(subrango), el tipo base del subrango (caracter o entero) y los límites del subrango
para determinar cuando una variable sobrepasa su rango (desbordamiento).
Tipo subrango
De enteros o caracteres
S E/C Li Ls Valor
d) Cardinalidad: La cardinalidad del subrango es CARD(SubRango-Type) = Ls-

Li+1.
6) Tipo Enumerado:
Es usado para definir un conjunto de constantes.
a) Conjunto de valores: A cada constante del conjunto se le asocia con un valor
entero, comenzando por defecto desde el cero, y sucesivamente en incrementos
de una unidad.
b) Conjunto de operaciones: Como entre estos elementos existe un orden (según
el orden de la declaración), y como se oculta la representación, las operaciones
aritméticas no pueden operar directamente sobre éstos, por lo que tenemos
Sucesor, Predecesor, Ordinal, etc.
c) Implementación de la representación: A cada constante del enumerado se le
asigna un valor entero comenzando desde el cero, y de manera consecutiva. De
aquí que el descriptor de variables enumerado debe tener, el tipo de variable
(enumerado), y el valor de la última constante del enumerado. Si el valor de la
26
primera constante es no necesariamente cero, entonces se agrega Li al descriptor,

similar al tipo subrango.
Tipo subrango
valor tope que puede tomar
En Ls Valor
Estudiaremos la implementación manera de definirlos en los lenguajes Pascal, y

C.
Caso1: Lenguaje Pascal.

Type <Nombre-Tipo> = (<Id1>, ..., <Idn>).
<Idi> = un identificador (String que comienza por un caracter
alfabetico).
Al identificador Idi se le asocia el valor entero i-1
Ejemplo:
Type Dia = (Lunes,Martes,Miércoles,Jueves,Viernes,Sábado,Domingo)
Caso 2: Lenguaje C.
typedef enum {<Id1> [=<Valor1>], ..., <Idn> [=<Valorn>]} <Nombre-Tipo>
<Id1> = un identificador
<Valori> = Un valor por defecto (caracter o entero)
Al valor Idi se le asocia el sucesor de Idi-1, a menos que se le asigne
directamente un valor por defecto.
Ejemplo:
typedef enum
{Lunes,Martes,Miércoles,Jueves=15,Viernes,Sábado,Domingo} Dia;
En Pseudoformal la notación a adoptar es la siguiente:
Tipo Dia = (Lunes,Martes,Miércoles,Jueves,Viernes,Sábado,Domingo)
d) Cardinalidad: La cardinalidad de un tipo enumerado es igual al número de

elementos definidos dentro del enumerado.
27
6.7.2.- Tipos de Datos Estructurados
1) Arreglos Unidimensionales
Un arreglo unidimensional es una estructura da datos homogénea, porque está
formada por elementos del mismo tipo (tipo base), sobre los cuales existe una
correspondencia uno a uno con algún subconjunto finito de los enteros (tipo
índice). De esta forma, un arreglo unidimensional puede definirse como una
aplicación entre un tipo índice y un tipo base, cuyos elementos pueden ser no
estructurados o registros. El acceso de los elementos del arreglo unidimensional
es al azar, de tal forma que cualquier elemento puede seleccionarse y accederse
cuando se desee.
Elementos que intervienen en la definición: El tipo base, el tipo índice, y el arreglo
como tal.
Tipo <Nombre-Indice> = [<Li> .. <Ls>]

Tipo <Nombre-Tarreglo> = Arreglo [<Nombre-Indice>] de <Tbase>
Conjunto de valores: Valores estructurados (e<Li>, e<Li>+1, ..., e<Ls>) en donde

ei es del tipo base del arreglo, y el número de elementos del arreglo es <Ls>-
<Li>+1.
Operación selectora: Permite referenciar una componente individual del arreglo.

La sintaxis es
<nombre de la variables> [<indice>]
El índice puede ser una constante, variable o expresión. En cualquier caso, este
se evalúa y se accede el elemento que este indique.
Operación constructora: Consiste en asociar un valor estructurado a un arreglo,
que se corresponda con sus características (#elementos y tipo de elementos).
Cardinalidad: La cardinalidad de un arreglo es:
28
2) Arreglos Multidimensionales
El concepto de arreglo multidimensional es una extensión del concepto de arreglo

unidimensional, al considerar que el tipo base está formado por componentes
estructuradas del tipo arreglo (unidimensional o multidimensional). De esta forma
una arreglo bidimensional (comúnmente llamado matriz) es una arreglo cuyas
componentes son arreglo unidimensionales; un arreglo tridimensional es un
arreglo cuyas componentes son arreglos bidimensionales, y en general, un arreglo
n-dimensional es una arreglo cuyas componentes son arreglos de dimensión n-1.
a) Arreglos bidimensionales
Elementos que intervienen en la definición: El tipo base, los tipos índice, y el
arreglo bidimensional como tal.
Tipo <Indice1> = [<Li1> .. <Ls1>]

Tipo <Indice2> = [<Li2> .. <Ls2>]
Tipo <Nombre-Tarreglo> = Arreglo [<Indice1>..<Indice2>] de <Tbase>
Conjunto de valores: Valores estructurados (e<Li1>,<Li2>, ... , e<Ls1>,<Ls2>) en

donde ei es del tipo base del arreglo, y el número de elementos es:
(<Ls1>-<Li1>+1)*(<Ls2>-<Li2>+1).
Operación selectora: Permite referenciar una componente individual del arreglo.

Sintaxis: <Nombre-Arreglo>[<Índice1>,<indice2>] ----> Tbase
Sea i,j valores válidos para Índice1 e Indice2 resp. Entonces:

<Nombre-Arreglo>[i,j] Referencia el elemento de posición i,j del arreglo
Operación constructora:
<Nombre-Arreglo> = ((e11,e12,...,e1m), ..., (en1, en2, ..., enm))
Cardinalidad: La cardinalidad de un arreglo bidimensional viene dada por:
29
// De tarea, plantear para una matriz n-dimensional
b) Extensión a arreglos n-dimensionales:
Tipo <Ind1> = [<Li1> .. <Ls1>]

Tipo <Ind2> = [<Li2> .. <Ls2>]
...
Tipo <Indn> = [<Lin> .. <Lsn>]
Tipo <N-ndim> = Arreglo [<Ind1>, <Ind2>, ..., <Indn>] de <Tbase>
Uso de arreglos en un lenguaje de programación
Un arreglo es un medio de guardar un conjunto de objetos de la misma clase. Se

accede a cada elemento individual del arreglo mediante un número entero
denominado índice. 0 es el índice del primer elemento y n-1 es el índice del último
elemento, siendo n, la dimensión del arreglo. Los arreglos son objetos en Java y
como tales vamos a ver los pasos que hemos de seguir para usarlos
convenientemente
- Declarar el arreglo
- Crear el arreglo
- Inicializar los elementos del arreglo
- Usar el arreglo
Declarar y crear un arreglo
Para declarar un arreglo se escribe
tipo_de_dato[] nombre_del_arreglo;
Para declarar un arreglo de enteros escribimos

int[] numeros;
Para crear un arreglo de 4 número enteros escribimos

numeros=new int[4];
30
La declaración y la creación del arreglo se puede hacer en una misma línea.

int[] numeros =new int[4];
Inicializar y usar los elementos del arreglo

Para inicializar el arreglo de 4 enteros escribimos
numeros[0]=2;
numeros[1]=-4;
numeros[2]=15;
numeros[3]=-25;
Se pueden inicializar en un bucle for como resultado de alguna operación

for(int i=0; i<4; i++){
numeros[i]=i*i+4;
}
No necesitamos recordar el número de elementos del arreglo, su miembro dato

length nos proporciona la dimensión del arreglo. Escribimos de forma equivalente
for(int i=0; i<numeros.length; i++){
numeros[i]=i*i+4;
}
Los arreglos se pueden declarar, crear e inicializar en una misma línea, del
siguiente modo
int[] numeros={2, -4, 15, -25};
String[] nombres={"Juan", "José", "Miguel", "Antonio"};
Para imprimir a los elementos de arreglo nombres se escribe

for(int i=0; i<nombres.length; i++){
System.out.println(nombres[i]);
}
31
Java verifica que el índice no sea mayor o igual que la dimensión del arreglo, lo
que facilita mucho el trabajo al programador.
Para crear un arreglo de tres objetos de la clase Rectangulo se escribe
Declarar
Rectangulo[] rectangulos;
Crear el arreglo
rectangulos=new Rectangulo[3];
Inicializar los elementos del arreglo
rectangulos[0]=new Rectangulo(10, 20, 30, 40);
rectangulos[1]=new Rectangulo(30, 40);
rectangulos[2]=new Rectangulo(50, 80);
O bien, en una sola línea
Rectangulo[] rectangulos={new Rectangulo(10, 20, 30, 40),
new Rectangulo(30, 40), new Rectangulo(50, 80)};
Usar el arreglo
Para calcular y mostrar el área de los rectángulos escribimos
for(int i=0; i<rectangulos.length; i++){
System.out.println(rectangulos[i].calcularArea());
}
Uso de Arreglos multidimensionales

Una matriz bidimensional puede tener varias filas, y en cada fila no tiene por qué
haber el mismo número de elementos o columnas. Por ejemplo, podemos declarar
e inicializar la siguiente matriz bidimensional
double[][] matriz={{1,2,3,4},{5,6},{7,8,9,10,11,12},{13}};
La primer fila tiene cuatro elementos {1,2,3,4}
La segunda fila tiene dos elementos {5,6}
La tercera fila tiene seis elementos {7,8,9,10,11,12}
La cuarta fila tiene un elemento {13}
32
Para mostrar los elementos de este arreglo bidimensional escribimos el siguiente

código
for (int i=0; i < matriz.length; i++) {

for (int j=0; j < matriz[i].length; j++) {
System.out.print(matriz[i][j]+"\t");
}
System.out.println("");
}
Como podemos apreciar, matriz.length nos proporciona el número de filas

(cuatro), y matriz[i].length, nos proporciona el número de elementos en cada fila.
Mostramos los elementos de una fila separados por un tabulador usando la
función print. Una vez completada una fila se pasa a la siguiente mediante println.
Los arreglos bidimensionales nos permiten guardar los elementos de una matriz.
Queremos crear y mostrar una matriz cuadrada unidad de dimensión 4.
Recordaremos que una matriz unidad es aquella cuyos elementos son ceros
excepto los de la diagonal principal i==j, que son unos. Mediante un doble bucle
for recorremos los elementos de la matriz especificando su fila i y su columna j. En
el siguiente programa
Se crea una matriz cuadrada de dimensión cuatro

Se inicializa los elementos de la matriz (matriz unidad)
Se muestra la matriz una fila debajo de la otra separando los elementos de una fila
por tabuladores.
public class MatrizUnidadApp {

public static void main (String[] args) {
double[][] mUnidad= new double[4][4];
for (int i=0; i < mUnidad.length; i++) {

for (int j=0; j < mUnidad[i].length; j++) {
33
if (i == j) {
mUnidad[i][j]=1.0;
}else {
mUnidad[i][j] = 0.0;
}
}
}
for (int i=0; i < mUnidad.length; i++) {

for (int j=0; j < mUnidad[i].length; j++) {
System.out.print(mUnidad[i][j]+"\t");
}
System.out.println("");
}
}
}
Un ejemplo del uso de break con etiqueta y arreglos multidimensionales
int[][] matriz={ {32, 87, 3, 589},

{12, -30, 190, 0},
{622, 127, 981, -3, -5}};
int numero=12;
int i=0, j=0;
buscado:
for(i=0; i<matriz.length; i++){
for(j=0; j<matriz[i].length; j++){
34
if(matriz[i][j]==numero){
break buscado;
}
}
}
System.out.println("buscado: matriz("+ i+", "+j+")="+matriz[i][j]);
2) Registros
a) Registros fijos
El registro es una estructura de datos formada por una colección finita de

elementos no necesariamente homogéneos, llamados campos. Es muy usado
cuando se tiene un conjunto de datos que guardan cierta relación entre sí, y es
considerado la manera más general para definir tipos estructurados
En general un registro se define como sigue:
Tipo <N-reg> = Registro

<C1>: <T1>
<C2>: <T2>
...
<Cn>: <Tn>
FinRegistro
donde <Ci> es el nombre del campo i-ésimo del registro, y <Ti> su tipo asociado.
a) Conjunto de valores: Valores estructurados (e1, ... , en) en donde ei es de tipo
<Ti>.
b) Cardinalidad: La cardinalidad de un registro es:
c) Operación selectora:
Sintaxis: <N-reg>.<Ci> ---> Tbase
Semántica: <N-reg>.<Ci> retorna el valor del campo i-ésimo del registro
35
d) Operación constructora: Permite asignar un valor estructurado a un registro,

acorde con su definición.
<N-reg> = (e1, e2, ..., en) donde ei es de tipo Ti
b) Registros Variantes
En general un registro se define como sigue:
Tipo <N-reg> = Registro

<C1>: <T1>
<C2>: <T2>
...
<Cn>: <Tn>
En caso de <Disc.>:<Tipo>
<Caso1>: <Campos1>;
<Caso2>: <Campos2>;
...
<Caso_m>: <Campos_m>;
FinRegistro
donde <Ci> es el nombre del campo i-ésimo del registro, y <Ti> su tipo asociado.
Partes de un registro variante:
1) Parte fija: Corresponde al conjunto de atributos minimal o comunes que tendrá
el registro variante. En la sisntaxis dada, está conformada por los <Ci>.
2) Discriminante: Permite especificar con que conjunto de datos se está trabajando
en un momento determinado.
3) Parte variable: Corresponde a un conjunto de atributos que puede variar según
el valor del discriminante.
36
Capítulo 7
Lenguaje para expresar los algoritmos: Pseudo-Código
El pseudocódigo es un lenguaje utilizado para escribir los algoritmos

computacionales. Como lenguaje, el pseudocódigo es una imitación de uno o más
lenguajes de programación. De esta manera podemos encontrar pseudocódigos
orientados a lenguajes de programación Pascal, Java, C, C++, etc. En el caso de
este curso orientaremos los pseudocódigos a los lenguajes Java, C y C++. El
objetivo del pseudocódigo es permitir que el programador se centre en los
aspectos lógicos de la solución, evitando las reglas de sintáxis de los lenguajes de
programación. No siendo el pseudocódigo un lenguaje formal, los pseudocódigos
varían de un programador a otro, es decir, no hay un pseudocódigo estándar.
7.1.- Variables
Una variable tiene un nombre, un tipo de dato y un valor. Antes de poder utilizar
una variable es necesario declararla especificando su nombre y su tipo de dato.
Una variable puede visualizarse como un casillero en la memoria principal que
almacena un valor que puede cambiar en el transcurso de la ejecución del
programa. Cuando un programa necesita almacenar un dato, necesita una
variable.
Para declarar declarar variables usaremos los siguientes formatos:

tipo nombre
Declaración de varias variables con el mismo tipo de dato:

tipo nombre1, nombre2, nombre3, ..., nombren
Donde:
tipo Es el tipo de dato de la variable que puede ser:

ENTERO (si la variable almacenará un número entero)
, REAL (si la variable almacenará un número
37
decimal) , CARACTER (si la variable almacenará un

carácter), CADENA (si la variable almacenará un
conjunto de carácteres) o LOGICO (si la variable
almacenará el valor verdadero o el valor falso).
nombre1, nombre2, ...,
Nombres de las variables. El nombre de una variable
nombren
debe comenzar con una letra, un símbolo de
subrayado o un símbolo de dólar. Los demás
caractéres del nombre puede ser letras, símbolos de
subrayado o símbolo de dólar. Debe considerarse
también que una letra mayúscula se considera
diferente de una letra minúscula.
Ejemplo 1.- Declaración de variables.
La siguiente instrucción declara la variable edad de tipo entero y la variable

descuento de tipo real.
ENTERO edad
REAL descuento
Esto crea los casilleros de memoria edad y descuento. Luego de la creación, las
variables están indefinidas.
edad ?
descuento ?
La siguiente instrucción declara las variables nota1, nota2 y nota3, todas de tipo
ENTERO.
ENTERO nota1, nota2, nota3
Esto crea los casilleros de memoria nota1, nota2 y nota3. Luego de la creación,
las variables están indefinidas ( ? ).
nota1 ?
nota2
?
38
nota3 ?
Literales
Se denominan literales a todos aquellos valores que figuran en el pseudocódigo y
pueden ser:
- Literales enteros. Ejemplo: 12, 20300, 15, etc.
- Literales reales. Ejemplo: 3.1416, 2345.456, etc.
- Literales de carácter. Ejemplo. 'a', 'B', ';', '<', '+', etc.
- Literales de cadena: Ejemplo: "Hola", "Algoritmos Computacionales", etc.
- Literales lógicos: Ejemplo: verdadero, falso
7.2.- Instrucciones Algorítmicas Básicas

Existen tres instrucciones algorítmicas básicas que son las siguientes
a) Entrada
Consiste en obtener un dato de un dispositivo de entrada, como el teclado, y
almacenarlo en una variable. En general, la acción de ingresar un dato a una
variable se expresa en el pseudocódigo mediante la palabra LEER, de la
siguiente forma:
LEER variable
Por ejemplo, la instrucción:
LEER estatura
Solicita el ingreso de un valor, desde algún dispositivo de entrada (como el
teclado), para la variable estatura.
b) Salida
Consiste en mostrar el valor de una variable en un dispositivo de salida, como la
pantalla. En general, la acción de mostrar el valor de una variable se expresa en el
pseudocódigo mediante la palabra IMPRIMIR de la siguiente forma:
IMPRIMIR variable
39
Por ejemplo, la instrucción:
IMPRIMIR importeCompra
Muestra, en algún dispositivo de salida (como la pantalla), el valor de la variable

importeCompra.
c) Asignación
Consiste en asignar a una variable el valor de una expresión. La expresión puede
ser una simple variable, un simple literal o una combinación de variables, literales
y operadores. La asignación se expresa en el pseudocódigo de la siguiente forma:
variable = expresión
Donde variable y el valor de expresión deben tener el mismo tipo de dato.

Cuando se asigna un valor ENTERO a una variable REAL, entonces el valor
ENTERO se convertirá en REAL antes de almacenarse. Así, al asignar el valor
ENTERO 25 a una variable REAL, se almacenará 25.0.
Ejemplo 1: Algoritmo para expresar en centímetros y pulgadas una cantidad dada

en metros.
Esta es una solución en pseudocódigo utilizando conceptos computacionales de
variable, entrada de datos y salida de resultados. La solución considera que 1
metro = 100 centímetros y que 1 pulgada = 2.54 centímetros.
INICIO
// Declara las variables M, C y P
REAL M, C, P
// Solicita el ingreso de la cantidad en metros
LEER M
// Calcula la cantidad en centímetros y lo asigna a la variable C
C = M*100
// Calcula la cantidad en pulgadas y lo asigna a la variable P
P = C/2.54
// Muestra los valores de las variables C y P
IMPRIMIR C, P
FIN
40
7.3.- Expresiones Aritméticas

Una expresión aritmética es una combinación de variables, literales y operadores
aritméticos.
7.3.1.- Operadores Aritméticos

En la tabla que sigue se muestran los operadores aritméticos que vamos a utilizar.
Tabla 1 Operadores aritméticos
Operador Significado Ejemplo
+ Suma a+b
- Resta a-b
* Multiplicación a*b
/ División a/b
% Residuo a%b
Los operadores aritméticos pueden utilizarse con tipos enteros y reales. Si en una
operación con dos operandos, ambos operandos son enteros, el resultado es un
entero; si alguno de ellos es real, el resultado es real. Así, 15/4 es 3 y no 3.75; en
cambio, 15.0/4 es 3.75.
Reglas de jerarquía de los operadores aritméticos

Cuando una expresión aritmética tiene más de un operador aritmético, el orden de
aplicación de los operadores sigue un orden preciso determinado por las reglas de
jerarquía de los operadores aritméticos, que se muestran en la siguiente tabla:
Tabla 2: Reglas de jerarquía de los operadores aritméticos
Operador Orden de evaluación
() Se evalúan en primer lugar
*, /, % Se evalúan en segundo lugar
41
+, - Se evalúan en tercer lugar
Si existen paréntesis anidados, se evalúa primero la expresión en el par más

interno. Si varios operadores o paréntesis tienen la misma jerarquía, la evaluación
será de izquierda a derecha.
Ejemplo 2.- ¿Cuál es el equivalente en pseudocódigo de la siguiente expresión
algebraica?
Solución:
e = a/b/c
Como todos los operadores tienen la misma jerarquía, la evaluación será de

izquierda a derecha:
1) se dividirá a entre b.
2) el resultado ya obtenido de a/b se dividirá entre c.
Note que el orden de ejecución esta de acuerdo con la expresión algebraica, por lo
que no se requiere ninguna pareja de paréntesis.

algebraica?
Solución:
e = a*b*c/d/e
42
Como todos los operadores tienen la misma jerarquía, la evaluación será de

izquierda a derecha:
1) se multiplicará a por b.
2) el resultado ya obtenido de a*b se multiplicará por c.
3) el resultado ya obtenido de a*b*c se dividirá entre d.
4) el resultado ya obtenido de a*b*c/d se divivirá entre e.
Note que el orden de ejecución esta de acuerdo con la expresión algebraica, por lo
que no se requiere ninguna pareja de paréntesis.

algebraica?
Solución:
e = 4/((a+b)/(c/d)) + v/w/p + 5*m*n*q
Aplicando las reglas de jerarquía de los operadores aritméticos:
1) se sumará a más b.
2) se dividirá c entre d.
3) el resultado obtenido de a+b se dividirá entre el resultado ya obtenido de c/d.
4) se dividirá 4 entre el resultado ya obtenido de ((a+b)/(c/d))
5) se dividirá v entre w.
6) se dividirá el resultado ya obtenido de v/w entre p.
7) se multiplicará 5 por m.
8) se multiplicará el resultado ya obtenido de 5*m por n.
9) se multiplicará el resultado ya obtenido de 5*m*n por q.
10) se sumará el resultado obtenido de 4/((a+b)/(c/d)) y el resultado obtenido de
v/w/p.
11) se sumará el resultado obtenido de 4/((a+b)/(c/d)) + v/w/p y el resultado
obtenido de 5*m*n*q.
Se ha utilizado la mínima cantidad posible de paréntesis. Pueden usarse
paréntesis adicionales, lo que no es un error. Por ejemplo, otra solución posible
que arroja el mismo resultado final es:
e = (4/((a+b)/(c/d))) + ((v/w)/p) + (5*m*n*q)
Note que usando correctamente las reglas de jerarquía, es posible usar menos
parejas de paréntesis.
43
7.4.- Expresiones Lógicas

Una expresión lógica combina variables, literales, operadores aritméticos,
operadores relacionales y operadores lógicos. Los operadores relacionales y los
operadores lógicos se muestran en las tablas 3 y 4.
7.4.1.- Operadores relacionales y lógicos
Tabla 3 Operadores relacionales
> mayor que a>b
>= mayor o igual que a >= b
< menor que a<b
<= menor o igual que a <= b
= igual a a=b
≠ diferente de a≠b
Tabla 4 Operadores lógicos

not no not a
and y a and b
or ó a or b
Capítulo 8
Estructuras de Control
Se definen las siguientes sentencias básicas del pseudocódigo.

8.1.- Selección
En pseudocódigo:
44
si c1 entonces
e1
En Java:
if (c1)
e1;
8.2.- Condiciones
Una condición es una expresión booleana que se evalua en true o en false.

Java tiene varios operadores que producen un resultado verdadero o falso:
- De igualdad
- Relacionales
- Lógicos
Los operadores aritméticos son evaluados antes que los operadores de igualdad y
los relacionales. Recuerde que los parentésis son utilizados para alterar su
precedencia.
Operadores relacionales y lógicos en Java
Operador Significado
== Igual a
!= Distinto a
< Menor que
<= Menor o igual que
> Mayor que
>= Mayor o igual que
Operadores lógicos:
Operador Significado
! No
&& AND
|| OR
45
Ejemplo 5:
/**
* Determina la edad mental de una persona
*/
class Niño
{
public static void main (String [] a)
{
System.out.print ("Dame tu edad ");
int edad = Teclado.readInt ();
if (edad <= 18)
System.out.println ("Eres un niño");
System.out.println ("La edad es un estado mental");
}
}
Ejemplo de ejecución
8.3.- Bifurcación
En pseudocódigo
si c1 entonces
e1
otro
e2
En Java:
if ( c1 )
e1;
else
e2;
Ejemplo 6:
class Par
{
{
46
System.out.print ("Escribe un número ");

int numero = Teclado.readInt ();
if (numero % 2 == 0)
System.out.println (numero + "es par");
else
System.out.println (numero + "no es par");
}
}
Complementar la siguiente clase para determinar la mejor calificación:
/**
** Determina la mejor calificación entre 2 dadas
**/
class MejorCali
{
{
System.out.println ("Escribe la calificación de un compañero: ");
int tuCali = Teclado.readInt ();
System.out.println ("Escribe tu calificación: ");
int miCali = Teclado.readInt ();
int mejorCalif ....
System.out.println ("La mejor calificación es: " + mejorCalif);

}
}
8.4.- Iteración
Iteración fija:
Repite una instrucción un número especificado de veces hasta que una condición
se cumple.
En pseudocódigo:
para var <-- valorInicial hasta valorFinal, incremento

e1
En Java:
47
for (inicialización ; prueba; incremento )

e1;
1) Antes de que inicie el ciclo se ejecuta la inicialización

2) se evalua la condición booleana antes del cuerpodel ciclo, si es verdadera, se
ejecuta e1, seguida del incremento.
Note que la inicialización sólo se realiza una vez, pero el incremento se realiza
después de cada iteración del ciclo.
Dentro de la inicialización puede declararse la variable entera.
Ejemplo 7:
for (int i = 0; i < 10; i++)

System.out.println (i);
o bien, antes de ser utilizada dentro del for, así:
int i;
for (i = 0; i < 10; i++)
System.out.println (i);
La diferencia entre el primer caso y el segundo es que el contexto de la variable,

que posteriormente se estudiara. Por el momento la diferencia esque cuando se
termina el primer ciclo la variable i deja de existir, mientrasque enel segundo caso,
la variable i puede ser utilizada o accesada posteriormente.
Ejecute la siguiente clase para determinar que números se imprimen
class EjemPara
{
{
for (int i = 0; i < 10; i++)
System.out.println (i + " ");
}
Modifique la clase anterior para que imprima los números pares entre 0 y 35.
Iteración “mientras”
Se usa para repetir una instrucción durante todo el tiempo en queuna condición
particular sea verdadera.
48
En pseudocódigo:
mientras c1
e1
En Java:
while ( c1)
e1;
Ejemplo 8:
int i = 0;
while (i < 10)
i = i + 1;
Este proceso se repite hasta que la condición sea false.
Bloque de instrucciones
Cuando se quiere encapsular un conjunto de instrucciones, se crea un bloque. El

principio y el final de un bloque se especifica con los caracteres de llave que abre
({) para el inicio y la llave que cierra ( }) para finalizar. En pseudocódigo esto
corresponde al comienzo y al fin.
Ejemplo 9:
class EjemMientras
{
public static void main (String [] args)
{
int i = 0;
while (i < 10)
{
System.out.print(i + " ");
i++;
}
}
}
Ejercicio: Modificar la clase anterior para que imprima los pares entre 0 y 10
inclusive.
49
Traduzca el pseudocódigo de la clase DeterminaPrimo siguiente
clase DeterminaPrimo
{
principal
comienza
escribe "Dame un entero"
lee num
int i <-- 2
mientras num mod i != 0
i++
escribe "El número " + num
si i = num
escribe "es un primo"
otro
escribe "no es un primo"
termina
}
Iteración “ Repite”
En pseudocódigo:
repite
e1
mientras c1
En Java:
do
{
enunciados
} while (c1 );
El enunciado do es similar al while, excepto que la condición de terminación es al

final del cuerpo del ciclo. El ciclo do ejecuta las sentencias dentro del cuerpo hasta
que la condición es falsa. Elcuerpo de un ciclo do al menos se ejecuta una vez.
Ejemplo 9:
class ejemRepite
{
{
final int LIMITE = 7; //constante entera
50
int cuenta = 0;
do
{
cuenta++;
System.out.println ("Cuenta: " + cuenta);
}
while (cuenta < LIMITE);
}
}
Considere la siguiente clase:
class repite
{
{
int z = 0, x = 1;
do
{
z = z +x;
x++;
System.out.println ( x = " + x+ ” z = " + z);
}
while ( x < 6 );
}
}
Escriba otra equivalente que utilice for y otra que utilice un while y que produzca
el mismo resultado
51

GUIA - Alg y Prog - ParteII

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

GUIA - Alg y Prog - ParteII

Cargado por

Copyright:

Formatos disponibles

Universidad Bolivariana de Venezuela

Programa de Formación de Grado en Informática para la Gestión Social

Capítulo 6 Concepto y Clasificación de Tipos de Datos.............................................................................18

Concepto y Clasificación de Tipos de Datos

6.1.- Definición de Tipo de Dato

6.2.- Características de los Ttipos de Datos

6.3.- Ventajas de los Tipos de Datos

corto: (typedef short int Coordenada), y no tenemos que hacer mayores

6.4.- Verificación de Tipos de Datos

6.5.- Compatibilidad de Tipos de Datos

x = z; // esta asignación es válida desde el punto de vista estructural

6.6.- Especificación e implementación de los Tipos de Datos

Acción Suma(Punto a; Punto b; Var Punto c)

Arg1 / Arg2 // división

b) Implementación: Define la forma en la cual los atributos y operaciones son

6.7.- Clasificación de los Tipos de Datos predefinidos

(determina si es estructurado o no) y según el tipo de sus componentes (si es no

Podemos referirnos a objetos de tipo no estructurado, cuando el conjunto de

se complementan los bits de mantisa y se suma 1, osea, 1000000000000001. La

d) Cardinalidad: La cardinalidad se define como el conjunto de valores que puede

donde la mantisa y el exponente están representados análogamente a un entero

Función Ordinal(c: Caracter)  Entero;

Función Sucesor(c: Caracter)  Carácter

...// Puede seguir con las otras operaciones??. TAREA

c) Implementación de la representación: Desafortunadamente no existe un

'a' < 'b' < .... < 'z'

Esto hace que los operadores relacionales puedan aplicarse, en muchos

C 8 bits para el caracter

d) Cardinalidad: La cardinalidad de un caracter es 128 en caso de usar el sistema

L Valor del Lógico

En algunos lenguajes, se le asocia el valor cero a falso, mientras que verdadero es

Tipo Dígito = ['0' .. '9']

b) Conjunto de operaciones: Las operaciones son heredadas de las operaciones

Tipo <Nombre-Subrango> = [<Li> .. <Ls>]

En muchos lenguajes se maneja un descriptor que contiene el tipo de dato

d) Cardinalidad: La cardinalidad del subrango es CARD(SubRango-Type) = Ls-

primera constante es no necesariamente cero, entonces se agrega Li al descriptor,

Estudiaremos la implementación manera de definirlos en los lenguajes Pascal, y

Caso1: Lenguaje Pascal.

En Pseudoformal la notación a adoptar es la siguiente:

Tipo Dia = (Lunes,Martes,Miércoles,Jueves,Viernes,Sábado,Domingo)

d) Cardinalidad: La cardinalidad de un tipo enumerado es igual al número de

6.7.2.- Tipos de Datos Estructurados

Tipo <Nombre-Indice> = [<Li> .. <Ls>]

Conjunto de valores: Valores estructurados (e<Li>, e<Li>+1, ..., e<Ls>) en donde

Operación selectora: Permite referenciar una componente individual del arreglo.

El concepto de arreglo multidimensional es una extensión del concepto de arreglo

Tipo <Indice1> = [<Li1> .. <Ls1>]

Conjunto de valores: Valores estructurados (e<Li1>,<Li2>, ... , e<Ls1>,<Ls2>) en

Operación selectora: Permite referenciar una componente individual del arreglo.

Sea i,j valores válidos para Índice1 e Indice2 resp. Entonces:

Cardinalidad: La cardinalidad de un arreglo bidimensional viene dada por:

// De tarea, plantear para una matriz n-dimensional

b) Extensión a arreglos n-dimensionales:

Tipo <Ind1> = [<Li1> .. <Ls1>]

Uso de arreglos en un lenguaje de programación

Un arreglo es un medio de guardar un conjunto de objetos de la misma clase. Se

Declarar y crear un arreglo

Para declarar un arreglo se escribe

Para declarar un arreglo de enteros escribimos

Para crear un arreglo de 4 número enteros escribimos

La declaración y la creación del arreglo se puede hacer en una misma línea.

Inicializar y usar los elementos del arreglo