Tipos de datos (repasando...

)
Introducción a la Algorítmica Retomando lo que hemos visto sobre tipos de datos al comienzo del curso, podemos

y Programación (3300) recordar que los algoritmos generalmente operan sobre datos de distinta naturaleza
(números, letras, palabras, símbolos, etc.) y por lo tanto, los programas que implementan
dichos algoritmos necesitan representarlos de alguna manera.
Prof. Ariel Ferreira Szpiniak - aferreira@[Link]
Departamento de Computación De allí que definimos a un tipo de dato como una clase de objetos
Facultad de Cs. Exactas, Fco-Qcas y Naturales de datos ligados a un conjunto de operaciones para crearlos y
Universidad Nacional de Río Cuarto manipularlos.
Los tipos de datos se caracterizan por:
• Un rango de valores posibles,

Teoría 7 • Un conjunto de operaciones realizables sobre ese tipo

• Una representación interna.

Tipo de Dato Estructurado Homogéneo: Arreglo Por ello se dice que un tipo es el conjunto de valores posibles
que puede tomar una variable.

2023 Lic. Ariel Ferreira Szpiniak 1 2023 Lic. Ariel Ferreira Szpiniak 2

Tipos de datos (repasando...) Tipos de datos (repasando...)

Simples y Estructurados Simples y Estructurados
La solución de cualquier problema informático requiere conocer y saber
Como vimos, un tipo de datos es un conjunto de valores
utilizar herramientas y técnicas tales como la algorítmica y la estructura de
datos. posibles junto con unas operaciones para su manipulación.
Por medio de la algorítmica podemos diseñar una serie de operaciones Tipos de datos como los enteros, reales y caracteres se
que ejecutadas en el orden establecido llevarán a la solución del denominan simples o elementales ya que toman valores
problema. Por otra parte, es necesario definir las características de los atómicos. Esto significa que una variable de estos tipos tan
datos con los que trabajemos y una serie de operaciones que manipulen
sólo puede contener un valor en cada momento.
estos datos de forma eficiente, para que el algoritmo que opera sobre
Sin embargo, existen otros tipos de datos que pueden contener
ellos pueda ser analizado y llevado a la práctica de una forma clara.
Para facilitar la manipulación de los distintos datos se define por un lado el
más de un valor y que se denominan tipos compuestos,
concepto de tipo de datos y por otro el de estructura de datos. estructurados, estructuras de datos o simplemente
estructuras.
2023 Lic. Ariel Ferreira Szpiniak 3 2023 Lic. Ariel Ferreira Szpiniak 4
 Tipos de datos (repasando...) Tipos de datos (repasando...)
Simples y Estructurados Simples y Estructurados
Los objetos del mundo real generalmente son complejos. Por
Una estructura de datos es un tipo de datos con las ello para poder representar esos objetos en programas que
siguientes características: solucionen problemas se necesita de herramientas que faciliten
• posee varias componentes, cada una de las cuales puede dicha tarea.
ser un tipo simple u otra estructura de datos;
• existe una relación entre los distintos componentes que la Es por ello existen tipos de datos Simples, o Elementales, y
dota de un cierto significado y utilidad; Compuestos, o Estructurados. Estos tipos de datos permiten
• se manipulan mediante una serie de operaciones. representar en una computadora las características principales
de los objetos del mundo real.

2023 Lic. Ariel Ferreira Szpiniak 5 2023 Lic. Ariel Ferreira Szpiniak 6

Tipos de datos Arreglo - Motivación

Entero
Real • Problema: tengo la edad de 150 socias/os de un club.
Lógico Necesito informar la edad promedio.
Caracter
Simples o Cadena
Elementales • ¿Cómo hacemos esto?
Subrango
Tipos Enumerado
Puntero Declaro una variable edad, entera positiva (o subrango),
de datos para cada socia/o. Guardo la edad en cada variable y las
Homogéneos Arreglo promedio.

Compuestos o
Estructurados ¡¡¡Pero son 150!!!
Heterogéneos Registro

2023 Lic. Ariel Ferreira Szpiniak 7 2023 Lic. Ariel Ferreira Szpiniak 8
 Arreglo - Motivación Arreglo
Definición: un arreglo es una colección finita (tiene un límite),
Otro problema: aunque declaráramos las 150 variables en el homogénea (elementos del mismo tipo) y “ordenada” (no < o >
léxico de mi algoritmo. sino que se sabe quien es el primero, el segundo, el tercero, etc.)
¿Y si se agrega un socio más al club? ¿Alcanzan las 150 de elementos. Los más comunes son los uni y los bidimensionales.
Columnas
variables? 1 2 3 4
Entonces, ¿qué podemos hacer? 1 2 3 4 5 6 7 1 4 6 -2 1

tempMin 5 6 0 -3 3 8 4 Filas 2 7 8 -4 0

Como todas las variables son del mismo tipo (Z + o 3 9 6 7 3

subrango de Z), necesitaríamos algo que nos permita Tiene dos partes importantes: las componentes y los índices.
“contener” una serie de variables del mismo tipo.
●
Componentes: hacen referencia a los elementos.
●
Índices: es la posición donde se encuentra el elemento.
¿Existe eso? ¡si! ¡Los arreglos! Para poder referirnos a los datos dentro de una posición del
arreglo, se especifica el nombre del arreglo y el número de
posición del elemento.
2023 Lic. Ariel Ferreira Szpiniak 9 2023 Lic. Ariel Ferreira Szpiniak 10

Arreglo Arreglo
• Se llaman array (arreglo es la traducción). Los tipos de arreglo más utilizados son
• Son estáticos, es decir, están disponibles desde el mismo
momento que son declaradas (léxico global, léxico local,
parámetro formal) y conservan el mismo tamaño durante
toda la ejecución. Es decir, se comportan de la misma Unidimensional Bidimensional
Columnas
forma que las variables de tipos simples y registro. En los 1 2 3 4 5 6 7
1 2 3 4
algoritmos adoptaremos el mismo comportamiento. tempMin 5 6 0 -3 3 8 4
4 6 -2 1
1
• En la memoria de una computadora (implementación), las Filas 2 7 8 -4 0

variables de tipo arreglo se almacenan en un grupo de 3 9 6 7 3

posiciones contiguas, relacionadas entre sí, por el hecho También hay Tridimensional. Algunos lenguajes permiten más dimensiones aún.
Las posiciones generalmente se cuentan a partir del 1 como primera posición
de que todas tienen el mismo nombre y los datos que
(Notación Algorítmica) o del 0 (Lenguaje C).
contiene son todos del mismo tipo.
2023 Lic. Ariel Ferreira Szpiniak 11 2023 Lic. Ariel Ferreira Szpiniak 12
 Arreglo Unidimensional
Arreglo Unidimensional Selección de componentes
La estructura más simple es el arreglo de una En Notación Algorítmica y en Lenguaje C la selección de una
dimensión, también llamado vector por ser usado componente se realiza haciendo referencia a la posición.
para resolver problemas matemáticos (álgebra). Esto se logra con el uso del operador [ ] (corchetes),
colocando el índice (número) correspondiente al componente
El arreglo está formado por una sucesión de dentro del corchete, como por ejemplo:
elementos consecutivos. No deben dejarse “huecos”
Para referirse a una componente de un arreglo se utilizará el
(componentes sin datos).
nombre de la variable y un índice entre corchetes ( [índice] ).
Índices Ejemplo: notas[4]
Nombre del Límite máximo
arreglo 1 2 3 4 5 6 7 Índices
Nombre del Límite máximo
notas 5 7 10 9 7 9 4 1 2 3 4 5 6 7
arreglo
Componentes notas 5 7 10 9 7 9 4
Componentes
2023 Lic. Ariel Ferreira Szpiniak 13 2023 Lic. Ariel Ferreira Szpiniak 14

Arreglo Unidimensional Arreglo Unidimensional

Ejemplo Ejemplo
Se desea poder almacenar 7 notas de un estudiante. Se desea poder almacenar 7 notas de un estudiante (otra forma).
Algoritmo GuardarNotas 1 2 3 4 5 6 7 Algoritmo GuardarNotasV2 1 2 3 4 5 6 7
Léxico Léxico
notas notas
NMax = 7 NMax = 7
TArreglo = arreglo [1..NMax] de Z+ TArreglo = arreglo [1..NMax] de Z+
Prueba de Escritorio Prueba de Escritorio
notas  TArreglo // variable de tipo arreglo
notas  TArreglo // variable Traza n  Z+ // variable Traza
i  Z // Z+ o subrango de 1 a NMax+1 Ciclo i i<=NMax i  Z // Z+ o subrango de 1 a NMax+1 Ciclo i i<=NMax
Inicio 0 1 V Inicio 0 1 V
i  1 1 2 V i  1 1 2 V
mientras i<=NMax hacer 2 3 V mientras i<=NMax hacer 2 3 V
3 4 V 3 4 V
Entrada: notas[i] // almacena Entrada: n
4 5 V 4 5 V
i  i+1 5 6 V notas[i]  n //almacena 5 6 V
fmientras 6 7 V i  i+1 6 7 V
Fin 7 8 F fmientras 7 8 F
Fin
2023 Lic. Ariel Ferreira Szpiniak 15 2023 Lic. Ariel Ferreira Szpiniak 16
 Arreglo Unidimensional Arreglo Unidimensional
Ejemplo 1 2 3 4 5 6 7
Ejemplo 1 2 3 4 5 6 7
Algoritmo GuardarNotasV3 Algoritmo GuardarNotasV4
Léxico notas Léxico notas
NMax = 7 NMax = 7 Prueba de Escritorio
Prueba de Escritorio
TArreglo = arreglo [1..NMax] de Z+ TArreglo = arreglo [1..NMax] de Z+ Traza
Traza
notas  TArreglo // variable Ciclo i i<=NMax notas  TArreglo // variable Ciclo i i>NMax
i  Z 0 1 V i  Z - 1 -
Inicio 1 2 V Inicio 1 2 F
para (i1, i<=NMax, ii+1) hacer 2 3 V i  1 2 3 F
Entrada: notas[i] //almacena 3 4 V repetir 3 4 F
4 5 V 4 5 F
fpara Entrada: notas[i] //almacena
5 6 V 5 6 F
Fin i  i+1
6 7 V 6 7 F
hasta que i>NMax 7 8 V
7 8 F
Fin

2023 Lic. Ariel Ferreira Szpiniak 17 2023 Lic. Ariel Ferreira Szpiniak 18

Arreglo Unidimensional Arreglo Unidimensional

Ejemplo Ejemplo 1 2 3 4 5 6 7
Se desea poder almacenar 7 notas de un estudiante e informarlas.
Algoritmo GestionarNotasV2 notas
Algoritmo GestionarNotas 1 2 3 4 5 6 7
Léxico Léxico
NMax = 7 notas NMax = 7
TArreglo = arreglo [1..NMax] de Z + TArreglo = arreglo [1..NMax] de Z +
notas  TArreglo // variable
i  Z Prueba de Escritorio Prueba de Escritorio notas  TArreglo // variable Prueba de Escritorio Prueba de Escritorio
Inicio Ciclo 1 i i<=NMax Ciclo 2 i i<=NMax Ciclo 1 i i<=NMax Ciclo 2 i i<=NMax
i  Z
i  1 0 1 V 0 1 V 0 1 V 0 1 V
mientras i<=NMax hacer Inicio
1 2 V 1 2 V 1 2 V 1 2 V
Entrada: notas[i] //almacena 2 para (i1, i<=NMax, ii+1) hacer
3 V 2 3 V 2 3 V 2 3 V
i  i+1 3 4 V 3 4 V Entrada: notas[i] //almacena 3 4 V 3 4 V
fmientras 4 5 V 4 5 V fpara 4 5 V 4 5 V
i  1 5 6 V 5 6 V para (i1, i<=NMax, ii+1) hacer 5 6 V 5 6 V
mientras i<=NMax hacer 6 7 V 6 7 V Salida: notas[i] //informa 6 7 V 6 7 V
Salida: notas[i] // informa 7 8 F 7 8 F 7 8 F 7 8 F
fpara
i  i+1
Fin
fmientras
Fin
2023 Lic. Ariel Ferreira Szpiniak 19 2023 Lic. Ariel Ferreira Szpiniak 20
 Arreglo Unidimensional
Declaración de Arreglos
Ejemplo 1 2 3 4 5 6 7 Para declarar un arreglo se debe, preferentemente, declarar un nuevo tipo
Algoritmo GestionarNotasV3 previamente (reusabilidad, legibilidad, facilidad de crecimiento, mantenimiento
notas
correctivo, modularización).
Léxico
Se le da un nombre al tipo, y además se define su tamaño y el tipo de datos que
NMax = 7
TArreglo = arreglo [1..NMax] de Z+ alojará en sus componentes (caracter, entero, real, cadena, registro, etc.).
notas  TArreglo // variable Prueba de Escritorio Prueba de Escritorio
Luego se declaran todas las variables del tipo arreglo que sean necesarias.
i  Z Ciclo 1 i Ciclo 2 i
Inicio Notación algorítmica
nombreTipo = arreglo [límiteInferior..límiteSuperior] de tipo
nombreVar  nombreTipo //variable 1 2 3 4 5 6 7
//hacer con repetir... notas
1 2 3 4 5 6 7
Ejemplo:
promedios
NMax = 7 // constante
TArreglo = arreglo [1..NMax] de Z+ (o arreglo [1..NMax] de TElem)
Fin notas, promedios  TArreglo // variables
2023 Lic. Ariel Ferreira Szpiniak 21 2023 Lic. Ariel Ferreira Szpiniak 22

Arreglo Unidimensional Arreglo Unidimensional

1 2 3 250
Ahora volvamos al ejemplo del club Algoritmo ClubEdades
Léxico edadesSocios
¿Qué sucede si no conozco de antemano la cantidad actual de NMax = 250
socios (150) o no es constante, es decir, se dan de alta nuevos TArreglo = arreglo [1..NMax] de Z + // tipo
edadesSocios  TArreglo // variable
socios y otros se dan de baja? cant  (0..NMax) // cantidad a ingresar
i  Z
Entonces, ¿qué podemos hacer? Inicio
i  1
Prueba de Escritorio
●
Podemos declarar el arreglo de mayor cantidad de componentes Entrada: cant // supongamos 3 Ciclo 1 i cant i<=cant
(250 por ejemplo). Lo llamaremos edadesSocios. mientras i<=cant hacer 0 1 3 V
Entrada: edadesSocios[i] 1 2 3 V
●
Podemos agregar una variable en el léxico para llevar la cantidad 2 3 3 V
i  i+1
actual de socios. La llamaremos cant. fmientras 3 4 3 F
i  1 Prueba de Escritorio
1 2 3 250 mientras i<=cant hacer Ciclo 2 i cant i<=cant
(arreglo para guardar las Salida: edadesSocios[i] 0 1 3 V
edadesSocios edades de los socios)
i  i+1 1 2 3 V
cant (variable para llevar la cantidad actual de edades de los socios) fmientras 2 3 3 V
Fin 3 4 3 F
2023 Lic. Ariel Ferreira Szpiniak 23 2023 Lic. Ariel Ferreira Szpiniak 24
 Arreglo Unidimensional Arreglo Unidimensional
1 2 3 250 1 2 3 250
Algoritmo ClubEdades Algoritmo ClubEdades
Léxico edadesSocios Léxico edadesSocios
NMax = 250 NMax = 250
TArreglo = arreglo [1..NMax] de Z + // tipo TArreglo = arreglo [1..NMax] de Z + // tipo
edadesSocios  TArreglo // variable edadesSocios  TArreglo // variable
cant  (0..NMax) // cantidad a ingresar cant  (0..NMax) // cantidad a ingresar
i  Z i  Z
Inicio Prueba de Escritorio Inicio
Ciclo 1 i cant i<=cant Prueba de Escritorio
i  1 i  1 Ciclo 1 i cant i<=cant
Entrada: cant // supongamos 0 Entrada: cant // supongamos 180
mientras i<=cant hacer mientras i<=cant hacer
Entrada: edadesSocios[i] Entrada: edadesSocios[i]
i  i+1 i  i+1
fmientras Prueba de Escritorio fmientras
i  1 Ciclo 2 i cant i<=cant i  1 Prueba de Escritorio
mientras i<=cant hacer mientras i<=cant hacer Ciclo 2 i cant i<=cant
Salida: edadesSocios[i] Salida: edadesSocios[i]
i  i+1 i  i+1
fmientras fmientras
Fin Fin
2023 Lic. Ariel Ferreira Szpiniak 25 2023 Lic. Ariel Ferreira Szpiniak 26

Declaración de Arreglos Arreglo Unidimensional

Si fuera necesario saber la cantidad de elementos que contiene el El mientras y el repetir pueden utilizarse de diferentes formas. La más común
es que forma que vimos en los ejemplos. El repetir no se recomienda porque
arreglo en cada momento, debe definirse una variable adicional. debemos estar seguros de tener datos. El para es el más usado en arreglos
Notación algorítmica (versión sencilla de mientras). Veamos otra forma de usar el ciclo mientras.
Algoritmo GestionarNotas // versión vista anteriormente
nombreTipo = arreglo [límiteInferior..límiteSuperior] de tipo // tipo Léxico
nombreVar  nombreTipo // variable NMax = 7
TArreglo = arreglo [1..NMax] de Z + 1 2 3 4 5 6 7
nombreCant  (límiteInferior-1..límiteSuperior+1) // rango máximo notas  TArreglo // variable notas
1 2 3 250 i  Z
Ejemplo: notas Inicio Prueba de Escritorio Prueba de Escritorio
i  1 Ciclo 1 i i<=NMax Ciclo 2 i i<=NMax
TElem = Z // tipo 1 2 3 250 mientras i<=NMax hacer 0 1 V 0 1 V
NMax = 250 // constante promedios Entrada: notas[i]
i  i+1 1 2 V 1 2 V
TArreglo = arreglo [1..NMax] de TElem 2 3 V 2 3 V
fmientras
notas, promedios  TArreglo // variables i  1 3 4 V 3 4 V
cantNotas, cantPromedios  ? // variables para saber la cantidad mientras i<=NMax hacer 4 5 V 4 5 V
Salida: notas[i] 5 6 V 5 6 V
¿Qué valor mínimo y máximo pueden tomar cantNotas y i  i+1
fmientras 6 7 V 6 7 V
cantPromedios? ¿Tipo Z, Z+ o subrango de Z? Fin 7 8 F 7 8 F
2023 Lic. Ariel Ferreira Szpiniak 27 2023 Lic. Ariel Ferreira Szpiniak 28
 Arreglo Unidimensional Arreglo Unidimensional
En lugar de inicializar i en 1 vamos a hacerlo en 0. ¿En qué Además de inicializar i en 0 vamos utilizar la expresión i+1 para
cambia el ciclo? manejar el índice (en lugar de i). ¿En qué cambia el ciclo?
Algoritmo GestionarNotasV2 // nueva versión con i en 0 Algoritmo GestionarNotasV3 // otra versión con i en 0 e [i+1]
Léxico Léxico
NMax = 7 NMax = 7 1 2 3 4 5 6 7
TArreglo = arreglo [1..NMax] de Z + 1 2 3 4 5 6 7 TArreglo = arreglo [1..NMax] de Z + notas
notas  TArreglo // variable notas notas  TArreglo // variable
i  Z i  Z Prueba de Escritorio Prueba de Escritorio
Inicio Prueba de Escritorio Prueba de Escritorio Inicio Ciclo 1 i i<NMax Ciclo 2 i i<NMax
i  0 Ciclo 1 i i<NMax Ciclo 2 i i<NMax i  0 0 0 V 0 0 V
mientras i<NMax hacer mientras i<NMax hacer
0 0 V 0 0 V 1 1 V 1 1 V
i  i+1 Entrada: notas[i+1]
Entrada: notas[i] 1 1 V 1 1 V i  i+1 2 2 V 2 2 V
fmientras 2 2 V 2 2 V fmientras 3 3 V 3 3 V
i  0 3 3 V 3 3 V i  0 4 4 V 4 4 V
mientras i<NMax hacer 4 4 V 4 4 V mientras i<NMax hacer 5 5 V 5 5 V
i  i+1 Salida: notas[i+1]
5 5 V 5 5 V 6 6 V 6 6 V
Salida: notas[i] i  i+1
fmientras 6 6 V 6 6 V fmientras 7 7 F 7 7 F
Fin 7 7 F 7 7 F Fin
¡No es recomendable! No es una buena práctica. ¿Porqué?
2023 Lic. Ariel Ferreira Szpiniak 29 2023 Lic. Ariel Ferreira Szpiniak 30

Arreglo Unidimensional Arreglo Unidimensional

Ahora volvamos al ejemplo del club Algoritmo ClubEdadesPorDeporte
Léxico
¿Qué sucede si los socios están divididos, de acuerdo a la edad, en NMax = 250
TArreglo = arreglo [1..NMax] de Z+
3 deportes: gimnasia, patín, natación? edadesSocGym, edadesSocPat, edadesSocNat  TArreglo
cantGym, cantPat, cantNat  (0..Nmax) // Z o Z+
Por ahora seguimos almacenando solo la edad de cada socio (Z +). Más i  Z
adelante agregaremos nombre, DNI, etc (registro). Inicio 1 2 3 250
i  1
Entrada: cantGym cantPat cantNat edadesSocGym
1 2 3 250
mientras i<=cantGym hacer
Entonces, ¿qué podemos hacer? Entrada: edadesSocGym[i] edadesSocPat
i  i+1 1 2 3 250
●
Podemos declarar 3 arreglos. Los llamaremos edadesSocGym, fmientras edadesSocNat
edadesSocPat y edadesSocNat. i  1
mientras i<=cantPat hacer cantGym i
●
Podemos agregar 3 variables en el léxico para llevar la cantidad Entrada: edadesSocPat[i]
i  i+1 cantPat
actual de socios por cada categoría. Las llamaremos cantGym, fmientras
NMax
cantPat y cantNat. // continua... cantNat

2023 Lic. Ariel Ferreira Szpiniak 31 2023 Lic. Ariel Ferreira Szpiniak 32
 Arreglo Unidimensional Declaración de Arreglos
//sigue ¿Porqué NO hago Para evitar tener por separado las 3 variables de edades (edadesSocGym,
i  1 edadesSocPat, edadesSocNat) y las 3 variables de cantidades (cantGym,
mientras i<=cantNat hacer todas las entradas
Entrada: edadesSocNat[i] de gimnasia, patín cantPat, cantNat) podemos construir un registro para cada caso. Cada registro
i  i+1 relaciona el arreglo de edades del deporte con la cantidad de cada uno.
fmientras y natación en un
i  1 mismo ciclo? NMax = 250
mientras i<=cantGym hacer TArreglo = arreglo [1..NMax] de Z+
Salida: edadesSocGym[i]
i  i+1 TData = <edades  TArreglo, cant  (0..NMax)>
fmientras
¿Porqué NO hago
edadesSocGym, edadesSocPat, edadesSocNat  TData
i  1 todas las salidas
mientras i<=cantPat hacer i  Z //¿podría ser un subrango?
Salida: edadesSocPat[i] de gimnasia, patín edadesSocGym edadesSocNat
i  i+1 y natación en un 1 2 3 250 1 2 3 250
fmientras
i  1 mismo ciclo? edades edades
cant cant
mientras i<=cantNat hacer
Salida: edadesSocNat[i] edadesSocPat
i  i+1 1 2 3 250
fmientras
edades
Fin
cant

2023 Lic. Ariel Ferreira Szpiniak 33 2023 Lic. Ariel Ferreira Szpiniak 34

Arreglo Unidimensional Arreglo Unidimensional

Algoritmo ClubEdadesPorDeporte
Léxico mientras i<=[Link] hacer
NMax = 250 Entrada: [Link][i]
TArreglo = arreglo [1..NMax] de Z+ i  i+1
TData = <edades  TArreglo, cant  (0..NMax)> fmientras
edadesSocGym, edadesSocPat, edadesSocNat  TData i  1
i  Z //¿podría ser un subrango? mientras i<=[Link] hacer
Salida: [Link][i]
Inicio
i  i+1 ¿Porqué NO hago
i  1
Entrada: [Link] [Link] [Link] fmientras todas las salidas
i  1
mientras i<=[Link] hacer
mientras i<=[Link] hacer de gimnasia, patín
Entrada: [Link][i]
i  i+1 ¿Porqué NO hago Salida: [Link][i] y natación en un
i  i+1
fmientras
i  1 todas las entradas fmientras mismo ciclo?
i  1
mientras i<=[Link] hacer de gimnasia, patín mientras i<=[Link] hacer
Entrada: [Link][i]
i  i+1 y natación en un Salida: [Link][i]
i  i+1
fmientras mismo ciclo? fmientras
// continua...
Fin

2023 Lic. Ariel Ferreira Szpiniak 35 2023 Lic. Ariel Ferreira Szpiniak 36
 Declaración de Arreglos Declaración de Arreglos
Esta propuesta de utilizar un registro de dos campos, uno con el arreglo y otro
con la cantidad de componentes ocupados, es una buena práctica porque
encapsula las edades de cada deporte con las cantidades respectivas. Es la Otra forma, que no es recomendable debido a que obstaculiza la
forma en que trabajaremos con arreglo.
modularización (el pasaje de parámetros, por ejemplo).
Notación algorítmica
nombreTipo = arreglo [límiteInferior..límiteSuperior] de tipo //tipo
Notación algorítmica
nombreRegistro = <campoArreglo  nombreTipo, nombreCant  Nombre  arreglo [límiteInferior..límiteSuperior] de tipo
(límiteInferior-1..límiteSuperior+1)> // nombreCant tiene ese rango máximo Ejemplo:
nombreVar  nombreRegistro //variable notas  arreglo [1..7] de Z
Ejemplo:
TElem = Z //tipo Pero es un estilo muy utilizado en Lenguaje C.
NMax = 7 //constante int notas[7]; // definición clásica
TArreglo = arreglo [1..NMax] de TElem //tipo
TData = <a  TArreglo, cant  (0..NMax)>
notas  TData //variable
2023 Lic. Ariel Ferreira Szpiniak 37 2023 Lic. Ariel Ferreira Szpiniak 38

Arreglo Unidimensional Asignación, Carga y Consulta

En el caso del GestionarNotas, si la cantidad de notas fuera variable, la solución podría ser: • Asignación
{ei: A=[x1, x2, ..., xi, ..., xn-1, xn]} Ejemplos
Algoritmo GestionarNotasEncapsulado
Léxico a[i]  e
NMax = 7 a[4]  29
TArreglo = arreglo [1..NMax] de Z // tipo {ef: A=[x1, x2, ..., e0, ..., xn-1, xn]}
TData = <n  TArreglo, cant  (0..NMax)>
notas  TData //variable a[6]  a[5] + 1
i  Z
• Asignación desde entrada estándar
notas
Inicio {ei : A=[x1, x2, ..., xi, ..., xn-1, xn]}
Entrada: [Link]
1 2 3 4 5 6 7 a[i]  a[4] + a[6]
i  1 n o Entrada:e
Entrada:a[i]
mientras i<=[Link] hacer cant a[i]  e
a[i]  a[i+1] + a[i-1]
Entrada: notas.n[i] {ef: A=[x1, x2, ..., e0, ..., xn-1, xn]}
i  i+1
fmientras a[i+1]  45 + a[6]
i  1 • Consulta
mientras i<=[Link] hacer
Salida: notas.n[i] {ei: A=[x1, x2, ..., xi, ..., xn-1, xn] }
a[i-1]  a[i] + 3
i  i+1 a[i]
fmientras
Fin {ef: A=[x1, x2, ..., xi, ..., xn-1, xn] }

2023 Lic. Ariel Ferreira Szpiniak 39 2023 Lic. Ariel Ferreira Szpiniak 40
 Ejemplo I Ejemplo I
Se necesita almacenar 100 letras. Se necesita almacenar 100 letras.
Nota: resolver utilizando arreglos y estructura iterativa repetir. Nota: resolver utilizando arreglos y estructura iterativa mientras.
Algoritmo MisLetras Algoritmo MisLetras
Léxico
1 2 3 100 Léxico
1 2 3 100
Max = 100 letras Max = 100 letras
TElem = Caracter TElem = Caracter
TLetras = arreglo[1..Max] de Telem // o Caracter TLetras = arreglo[1..Max] de Telem // o Caracter
letras  TLetras letras  TLetras
indice  Z // o subrango Prueba de Escritorio indice  Z // o subrango Prueba de Escritorio
Inicio Inicio
Ciclo indice Ciclo indice

Fin Fin

2023 Lic. Ariel Ferreira Szpiniak 41 2023 Lic. Ariel Ferreira Szpiniak 42

Ejemplo I Ejemplo I bis

Se necesita almacenar 100 letras. Se necesita almacenar 100 letras, y luego informarlas en el mismo orden en que fueron obtenidas.
Nota: resolver utilizando arreglos y estructura iterativa para. Nota: resolver utilizando arreglos y estructura/s iterativa/s a elección.
Algoritmo MisLetras
Léxico
1 2 3 100 Algoritmo MisLetras 1 2 3 100
Léxico
Max = 100 letras Max = 100 letras
TElem = Caracter TElem = Caracter
TLetras = arreglo[1..Max] de Telem // o Caracter TLetras = arreglo[1..Max] de Telem // o Caracter
letras  TLetras letras  TLetras
indice  Z // o subrango Prueba de Escritorio indice  Z // o subrango Prueba de Escritorio Prueba de Escritorio
Inicio
Ciclo indice Inicio
Ciclo 1 indice Ciclo 2 indice

Fin Fin

2023 Lic. Ariel Ferreira Szpiniak 43 2023 Lic. Ariel Ferreira Szpiniak 44
 Ejemplo II Ejemplo III
Se necesita almacenar no más de 100 letras. letras Se necesita almacenar no más de 100 letras, como máximo, y luego informarlas en el
Algoritmo MisLetras mismo orden en que fueron obtenidas. letras
1 2 3 4 …. 100
Léxico Algoritmo MisLetras
Max = 100 l Léxico 1 2 3 4 …. 100
TElem = Caracter
TLetras = arreglo[1..Max] de Telem // o Caracter
cant Max = 100
TElem = Caracter
l
TData = <l  TLetras, cant  (0..Max)> TLetras = arreglo[1..Max] de TElem cant
letras  TData TData = <l  TLetras, cant  (0..Max)>
indice  Z // o subrango letras  TData
Inicio Prueba deEscritorio indice  Z Prueba de Escritorio Prueba de Escritorio
Inicio
Ciclo indice [Link] Ciclo 1 indice [Link] Ciclo 2 indice [Link]

Fin
Fin
2023 Lic. Ariel Ferreira Szpiniak 45 2023 Lic. Ariel Ferreira Szpiniak 46

Ejemplo IV Ejemplo V
Se necesita almacenar no más de 100 letras, como máximo, y luego informarlas en el Se necesita almacenar no más de 100 letras, como máximo, y luego informar todas las
orden inverso en que fueron obtenidas. letras vocales.
Algoritmo MisLetrasInverso Algoritmo MisLetrasInverso
letras
Léxico 1 2 3 4 …. 100 Léxico 1 2 3 4 …. 100
Max = 100 l Max = 100
TElem = Caracter TLetras = arreglo[1..Max] de Caracter l
TLetras = arreglo[1..Max] de TElem cant TData = <l  TLetras, cant  (0..Max)>
cant
TData = <l  TLetras, cant  (0..Max)> letras  TData
letras  TData indice  Z
indice  Z Prueba deEscritorio Prueba de Escritorio Función EsVocal(dato v  Caracter) → Lógico
Inicio … Prueba de Escritorio
Ciclo 1 indice [Link] Ciclo 2 indice [Link] fFunción v 
Inicio

Prueba de Escritorio Prueba de Escritorio

Ciclo 1 indice [Link] Ciclo 2 indice [Link]

Fin Fin
2023 Lic. Ariel Ferreira Szpiniak 47 2023 Lic. Ariel Ferreira Szpiniak 48
 Ejemplo VI Ejemplo VII
Se necesita almacenar a lo sumo 80 vocales (solo vocales) en letra mayúscula y luego Se necesita almacenar n números enteros (150 como máximo), y luego informarlos en
informar la vocal que más veces se repite. orden inverso al que fueron obtenidos.
Algoritmo OrdenInverso
Aclaración: cada vocal debe ser almacenada en mayúscula.
Algoritmo Vocales

2023 Lic. Ariel Ferreira Szpiniak 49 2023 Lic. Ariel Ferreira Szpiniak 50

Ejemplo VII Ejemplo VIII

Se necesita almacenar n números enteros (150 como máximo), y luego informarlos en Desarrollar una acción que permita almacenar hasta 250 notas (entre 1 y 10) de estudiantes.
orden inverso al que fueron obtenidos. datos Algoritmo Notas
Algoritmo OrdenInverso // solución 1 2 3 4 ……. 150 Léxico
Léxico Max = 250
d
Max = 150 TElem = (1..10)
cant
TElem = Z TNumeros = arreglo[1..Max] de TElem
TNumeros = arreglo[1..Max] de TElem TData = <m  TNumeros, cant  (0..Max)>
TData = <d  TNumeros, cant  (0..Max)> Prueba de Escritorio Prueba de Escritorio misNotas  TData
datos  TData
i  Z
Ciclo 1 i [Link] Ciclo 2 i [Link] Acción CargarNotas (resultado notas  TData) notas
Inicio
Léxico local 1 2 3 4 ------ 250
i  1
i  Z
m
Entrada:[Link] Inicio
cant
mientras i <= [Link] hacer // cantidad de notas a cargar
Entrada:[Link]
Entrada:datos.d[i]
i  i+1 para (i1, i<=[Link], ii+1) hacer
Prueba de Escritorio
fmientras // obtener cada nota Ciclo i [Link]
// informar Los datos ingresados
Entrada:notas.m[i]
// del último al primero
fpara
i  [Link]
mientras i >= 1 hacer
Facción
Salida:datos.d[i] Inicio misNotas
i  i-1 CargarNotas(misNotas) 1 2 3 4 ------ 250
fmientras Fin
Fin // lo implementaremos en C // lo implementaremos en C m
cant
2023 Lic. Ariel Ferreira Szpiniak 51 2023 Lic. Ariel Ferreira Szpiniak 52
 Ejemplo IX
Se necesita almacenar a lo sumo 10 vocales (sin superar los 255 caracteres), luego informar la
cantidad de vocales almacenadas, y finalmente cambiar cada vocal por la letra que le sigue en el
Lenguaje C
abecedario (por ejemplo, en lugar de a o A debe colocar b o B).
Algoritmo Encriptación
Arreglo Unidimensional

1 2 3 4 5 6 7 0 1 2 3 4 5 6

notas notas

Notación Algorítmica C

El límite inferior es fijo, siempre comienzan con 0

2023 Lic. Ariel Ferreira Szpiniak 53 2023 Lic. Ariel Ferreira Szpiniak 54

Arreglo Unidimensional en C Arreglo Unidimensional en C

/*
Algoritmo GuardarNotasV2 - definicion basica, sin usar TArreglo // GuardarNotasV2 - definicion basica, sin usar TArreglo
Léxico #include <stdio.h>
NMax = 7 #define NMax 7
notas e arreglo [1..NMax] de Z+ // variable de tipo arreglo int notas[NMax]; // definición clásica
n e Z+ // variable int n;
i e Z // Z+ o subrango de 1 a NMax+1 int i;
Inicio
i <-- 1 int main(){
mientras i<=NMax hacer i=0;
Entrada: n while(i<NMax){
notas[i] <-- n //almacena scanf("%d",&n);
i <-- i+1 notas[i]=n;
fmientras i++;
Fin }
*/ return 0;
// sigue... }

2023 Lic. Ariel Ferreira Szpiniak 55 2023 Lic. Ariel Ferreira Szpiniak 56
 Arreglo Unidimensional en C Arreglo Unidimensional en C
/*
// GuardarNotasV2 - definicion usando TArreglo
Algoritmo GuardarNotasV2 - definicion usando TArreglo
#include <stdio.h>
Léxico
#define NMax 7
NMax = 7
typedef int TArreglo [NMax];
TArreglo = arreglo [1..NMax] de Z+
TArreglo notas;
notas e TArreglo // variable de tipo arreglo
int n;
n e Z+ // variable
int i;
i e Z // Z+ o subrango de 1 a NMax+1
Inicio
int main(){
i <-- 1
i=0;
mientras i<=NMax hacer
while(i<NMax){
Entrada: n
scanf("%d",&n);
notas[i] <-- n //almacena
notas[i]=n;
i <-- i+1
i++;
fmientras
}
Fin
return 0;
*/
}
// sigue...

2023 Lic. Ariel Ferreira Szpiniak 57 2023 Lic. Ariel Ferreira Szpiniak 58

Arreglo Unidimensional en C Arreglo Unidimensional en C

/*
Algoritmo OrdenInverso
/* OrdenInverso Ejemplo VII – usando TData
Léxico
Max = 150 Max = 150
TElem = Z TElem = Z
TNumeros = arreglo[1..Max] de TElem // tipo arreglo TNumeros = arreglo[1..Max] de TElem
TData = <d e TNumeros, cant e (0..Max)>
TData = <d  TNumeros, cant  (0..Max)> //tipo registro
datos e TData
datos  TData i e Z
i  Z Inicio
*/ i <-- 1
Entrada:[Link]
#define Max 150
mientras i <= [Link] hacer
typedef struct { Entrada:datos.d[i]
int d[Max]; i <-- i+1
int cant; fmientras
}TData; // informar Los datos ingresados del último al primero
i <-- [Link]
TData datos; mientras i >= 1 hacer
int i; Salida:datos.d[i]
i <-- i-1
fmientras
Fin
*/

2023 Lic. Ariel Ferreira Szpiniak 59 2023 Lic. Ariel Ferreira Szpiniak 60
 Arreglo Unidimensional en C Arreglo Unidimensional en C
#include <stdio.h> // OrdenInverso Ejemplo VII
#include <string.h>
/*
#define Max 150 Algoritmo GestionarNotas
typedef struct { Léxico
int d[Max]; NMax = 7
int cant; TArreglo = arreglo [1..NMax] de Z // tipo arreglo
}TData; TData = <n e TArreglo, cant e (0..NMax)> // tipo registro
TData datos; notas e TData // variable
int i;
i e Z
int main(){
i=0;
Inicio
printf("Ingrese cantidad de elementos: "); i <-- 1
scanf("%d",&[Link]); mientras i<=NMax hacer
printf("Ingrese %d numeros\n",[Link]); Entrada: notas.n[i] //almacena
while(i<[Link]){ i <-- i+1
scanf("%d",&datos.d[i]); fmientras
i++; i <-- 1
}
mientras i<=NMax hacer
i=[Link]-1;
Salida: notas.n[i] // informa
while(i>=0){
printf("elemento en la posicion %d es %d\n", i,datos.d[i]); i <-- i+1
i--; fmientras
} Fin
return 0; */
}
2023 Lic. Ariel Ferreira Szpiniak 61 2023 Lic. Ariel Ferreira Szpiniak 62

Arreglo Unidimensional en C Arreglo Unidimensional en C

#include <stdio.h> /* Notas Ejemplo VIII
#include <stdio.h>
#include <string.h>
#define NMax 7
typedef struct {
#define Max 250 Al modularizar (en este caso una
typedef struct {
int n[NMax]; int m[Max]; acción de carga) y pasar un
int cant; int cant; TData (registro) como
}TData; }TData;
TData notas; TData misNotas; parámetro, no se agrega nada
int i; void cargarNotas(TData *notas); nuevo.
int main(){
int main(){
i=0;
cargarNotas(&misNotas);
while(i<NMax){ }
scanf("%d",&notas.n[i]);
i++; void cargarNotas(TData *notas){
} int i;
i=0; printf("Ingrese cantidad de elementos: ");
while(i<NMax){ scanf("%d",&notas->cant);
printf("%d",notas.n[i]); printf("Ingrese %d números\n",notas->cant);
for(i=0;i<(*notas).cant;i++){
i++;
scanf("%d",&notas->m[i]);
} } for(i=0;i<(*notas).cant;i++){
return 0; } printf("%d\n",notas->m[i]);
}
}
2023 Lic. Ariel Ferreira Szpiniak 63 2023 Lic. Ariel Ferreira Szpiniak 64
 Arreglo Bidimensional
Arreglo Bidimensional Selección de componentes
Los arreglos de dos dimensiones, también llamados matrices, En Notación Algorítmica y en Lenguaje C la selección de una
se utilizan para representar tablas de valores. componente se realiza haciendo referencia a la posición. En este caso
la posición está determinada por una tupla de dos números (índices),
Se requieren dos índices, uno para las filas y otro para las uno para la fila y otro para la columna.
columnas. Esto se logra con el uso del operador [ ] (corchetes), colocando los
índices (números) correspondientes al componente dentro del corchete,
Columnas
como por ejemplo:
1 2 3 4
Para referirse a un componente de un arreglo
1 4 6 -2 1 bidimensional (matriz) se utilizará el nombre de la variable
Filas 2 7 8 -4 0 y los dos índices entre corchetes ( [fila, columna] ).

3 9 6 7 3 Ejemplo: buscaMinas[5,3]

2023 Lic. Ariel Ferreira Szpiniak 65 2023 Lic. Ariel Ferreira Szpiniak 66

Arreglo Bidimensional Arreglo Bidimensional

Ejemplo I Ejemplo I
Se desea poder rellenar un tablero de 16x30 del juego de buscaminas Inicio Prueba de Escritorio
(cada celda del tablero es un número del 0 al 9). Los valores 0 a 8 indican i1 Traza
cuantas minas hay alrededor de la celda. El valor 9 indica que hay una mientras i <= Fila hacer i j i<=Fila j<=Columna
j  1 1 V
mina en esa celda del tablero.
mientras j <= Columna hacer 1 1 V
Algoritmo Juego
Entrada: buscaMinas[i,j] 1 2 V
Léxico j  j+1 1 3 V
Fila = 16 fmientras ………………...…..
Columna = 30 i  i+1 1 30 V
TMina = arreglo[1..Fila, 1..Columna] de (0..9)
fmientras 1 31 F
i  Z // o subrango
j  Z // o subrango Fin 2 31 V
buscaMinas  TMina //variable 2 1 V
// continua 2 2 V
2 3 V
………………….....

2023 Lic. Ariel Ferreira Szpiniak 67 2023 Lic. Ariel Ferreira Szpiniak 68
 Arreglo Bidimensional Arreglo Bidimensional
Ejemplo II Ejemplo II
Se desea poder almacenar un tablero de 16x30 del juego de buscaminas y luego mostrar
Algoritmo Juego Prueba de Escritorio
los números almacenados.
Léxico i j i<=Fila j<=Columna
Fila = 16 1 V Algoritmo Juego
Columna = 30 1 1 V Léxico
TMina = arreglo[1..Fila, 1..Columna] de (0..9) 1 2 V
i  Z // o subrango Fila = 16
j  Z // o subrango 1 3 V Columna = 30
buscaMinas  TMina // variable ………………...….. TMina = arreglo[1..Fila, 1..Columna] de (0..9)
Inicio 1 30 V i, j  Z // o subrango
1 31 F buscaMinas  TMina // variable
para (i1, i<=Fila, ii+1) hacer
para (j1, j<=Columna, jj+1) hacer 2 31 V
2 1 V // continua
Entrada: buscaMinas[i,j]
2 2 V
fpara
2 3 V
fpara
………………….....
Fin

2023 Lic. Ariel Ferreira Szpiniak 69 2023 Lic. Ariel Ferreira Szpiniak 70

Arreglo Bidimensional Asignación, Carga y Consulta

//sigue
Ejemplo II • Asignación
{ei: A=[x11, x12, ..., x1i, ..., x1(n-1), x1n, x21, x22, ..., x2i, ..., x2 (n-1), x2n]} Ejemplos
Inicio Prueba de Escritorio
i j i<=Fila j<=Columna a[2,1]  e a[1,4]  29
para (i1, i<=Fila, ii+1) hacer {ef: A=[x11, x12, ..., x1i, ..., x1(n-1), x1n, e, x22, ..., x2i, ..., x2 (n-1), x2n]}
para (j1, j<=Columna, jj+1) hacer a[1,6]  a[1,5] + 1
Entrada: buscaMinas[i,j] //rellenar tablero • Asignación desde entrada estándar
fpara {ei: A=[x11, x12, ..., x1i, ..., x1(n-1), x1n, x21, x22, ..., x2i, ..., x2 (n-1), x2n]} a[i,j]  a[i,4]+a[i,6]
fpara o Entrada:e
Entrada:a[2,1]
para (i1, i<=Fila, ii+1) hacer Prueba de Escritorio a[2,1]  e a[i,j]  a[i+1,j]+a[i-1,j]

para (j1, j<=Columna, jj+1) hacer i j i<=Fila j<=Columna {ef: A=[x11, x12, ..., x1i, ..., x1(n-1), x1n, e, x22, ..., x2i, ..., x2 (n-1), x2n]}

Salida: buscaMinas[i,j] //mostrar tablero a[i+1,j]  45+a[6,j]

• Consulta
fpara
{ei: A=[x11, x12, ..., x1i, ..., x1(n-1), x1n, x21, x22, ..., x2i, ..., x2 (n-1), x2n]} a[i-1, j+1]  a[i,j]+3
fpara
Fin a[i,j]
{ef: A=[x11, x12, ..., x1i, ..., x1(n-1), x1n, x21, x22, ..., x2i, ..., x2 (n-1), x2n]}

2023 Lic. Ariel Ferreira Szpiniak 71 2023 Lic. Ariel Ferreira Szpiniak 72
 Declaración de Arreglo Ejemplo III
Bidimensional Se necesitan almacenar los nombres que representan a los estudiantes sentados en el aula 79. El aula
79 contiene 5 hileras (filas) de 7 sillas cada una (columnas).
Para declarar una matriz se debe, preferentemente, declarar un nuevo tipo previamente. Algoritmo Aula79
Se le da un nombre al tipo, y además se define su tamaño y el tipo de datos (caracteres, Léxico
Fila = 5
enteros, etc.) que van a contener los arreglos que se definan en el futuro. Columna = 7
Luego se declaran todas las variables del tipo arreglo que sean necesarias. TAula = arreglo[1..Fila, 1..Columna] de Cadena
i  Z // o subrango
j  Z // o subrango
Notación algorítmica aula79  TAula
Inicio
nombreTipo = arreglo [límiteInfFila..límiteSupFila,
límiteInfCol..límiteSupCol] de tipo //tipo
nombreVar  nombreTipo //variable

Ejemplo:
TElem  Z //tipo
NMaxFila = 7 //constante
NMaxCol = 10 //constante
TMat = arreglo [1..NMaxFila, 1..NMaxCol] de TElem //tipo
notas  TMat //variable
Fin

2023 Lic. Ariel Ferreira Szpiniak 73 2023 Lic. Ariel Ferreira Szpiniak 74

Ejemplo III Declaración de Arreglo

Se necesitan almacenar los nombres que representan a los estudiantes sentados en el aula 79. El aula 79
contiene 5 hileras (filas) de 7 sillas cada una (columnas). Bidimensional
En el caso de ser necesario saber la cantidad de elementos que contiene la matriz, deben definirse
Algoritmo Aula79
dos variables adicionales para almacenar la cantidad filas y columnas.
Léxico
Fila = 5
Columna = 7
Notación algorítmica
Prueba de Escritorio
TAula = arreglo[1..Fila, 1..Columna] de Cadena
i j i<=Fila j<=Columna
nombreTipo = arreglo [límiteInfFila..límiteSupFila,
i  Z // o subrango límiteInfCol..límiteSupCol] de tipo //tipo
j  Z // o subrango
aula79  TAula
nombreVar  nombreTipo //variable
Inicio NombreCantFila  ? // ¿de tipo Z, Z+, subrango de Z (?..?)?
i1
mientras i <= Fila hacer
nombreCantCol  ? // ¿de tipo Z, Z+, subrango de Z (?..?)?
j  1
mientras j <= Columna hacer Ejemplo:
//nombre del alumno sentado en la fila i y columna j del aula 79 TElem  Z //tipo
Entrada: aula79[i,j] NMaxFila = 7 //constante
j  j+1
fmientras NMaxCol = 10 //constante
i  i+1 TMat = arreglo [1..NMaxFila, 1..NMaxCol] de TElem //tipo
fmientras notas  TMat //variable
Fin cantFila  (0..NMaxFila)
cantCol  (0..NMaxCol)
2023 Lic. Ariel Ferreira Szpiniak 75 2023 Lic. Ariel Ferreira Szpiniak 76
 Ejemplo IV Declaración de Arreglo
Se necesitan almacenar los nombres que representan a los estudiantes sentados en las primeras 3 hileras del
aula 79 (3x7).
Algoritmo Aula79
Bidimensional
Léxico
Fila = 5
La propuesta anterior se puede mejorar utilizando un registro para contener el
Columna = 7 arreglo junto a la cantidad elementos que contiene.
TAula = arreglo[1..Fila, 1..Columna] de Cadena
i, j  Z // o subrango Notación algorítmica
cantFila  (0..Fila)
cantColumna  (0..Columna) nombreTipo = arreglo [límiteInfFila..límiteSupFila, límiteInfCol..límiteSupCol] de tipo
aula79  TAula nombreRegistro = <campoMatriz  nombreTipo, nombreCantFila  [límiteInfFila-
Inicio 1..límiteSupFila+1], nombreCantCol  [límiteInfCol-1..límiteSupCol+1]>
i1
cantFila3 nombreVar  nombreRegistro //variable
cantColumna7
mientras i <= cantFila hacer Prueba de Escritorio
j  1 i j i<=Fila j<=Columna
Ejemplo:
mientras j <= cantColumna hacer TElem  Z //tipo
Entrada: aula79[i,j] //nombre del alumno sentado en esa fila y columna NMaxFila = 7 //constante
j  j+1 NMaxCol = 10 //constante
fmientras
i  i+1 TMat = arreglo [1..NMaxFila, 1..NMaxCol] de TElem
fmientras TData = <m  TMat, cantFila  (0..NMaxFila), cantCol  (0..NMaxCol) //tipo
Fin notas  TData //variable

2023 Lic. Ariel Ferreira Szpiniak 77 2023 Lic. Ariel Ferreira Szpiniak 78

Ejemplo IV Arreglo Bidimensional

Se necesitan almacenar los nombres que representan a los estudiantes sentados en las primeras 3 hileras del
aula 79 (3x7). Ejemplo V
Algoritmo Aula79 Se desea poder almacenar las primeras 2 filas un tablero de 16x30 del juego de
Léxico buscaminas y luego mostrar los números almacenados.
Fila = 5
Columna = 7
TAula = arreglo[1..Fila, 1..Columna] de Cadena
Algoritmo Juego2
TData = <a  TAula, cantFil  (0..Fila), cantCol  (0..Columna)> Léxico
i, j  Z // o subrango
aula79  TData
Fil = 16
Inicio Col = 30
i1 TMina = arreglo[1..Fil, 1..Col] de (0..9)
[Link]3
[Link]7
TData = <m  TMina, cantFila  (0..Fil), cantCol  (0..Col) //tipo
mientras i <= [Link] hacer Prueba de Escritorio buscaMinas  TData // variable
j  1 i j i<=….. j<=….. i, j  Z // o subrango
mientras j <= [Link] hacer
Entrada: aula79.a[i,j] //nombre del alumno sentado en esa fila y columna
// continua
j  j+1
fmientras
i  i+1
fmientras
Fin

2023 Lic. Ariel Ferreira Szpiniak 79 2023 Lic. Ariel Ferreira Szpiniak 80
 Arreglo Bidimensional Ejemplo VI
//sigue
Ejemplo V Modificar el algoritmo del Ejemplo IV, diapo 71, para modularizar en una acción el almacenamiento de los
nombres de los estudiantes sentados en las primeras 3 hileras del aula.
Algoritmo Aula79
Inicio
[Link]2
[Link]30
para (i1, i<=[Link], ii+1) hacer
para (j1, j<=[Link], jj+1) hacer
Entrada: buscaMinas.m[i,j]
fpara
fpara
para (i1, i<=[Link], ii+1) hacer
para (j1, j<=[Link], jj+1) hacer
Salida: buscaMinas.m[i,j]
fpara
fpara
Fin
2023 Lic. Ariel Ferreira Szpiniak 81 2023 Lic. Ariel Ferreira Szpiniak 82

Ejemplo VII Ejemplo VIII

Modificar el algoritmo anterior para que luego de ingresar los nombres de los estudiantes, sentados en las Un piso rectangular contiene 20 balsosas de largo y 30 de ancho. Cada baldosa posee un número (entre 0 y 1)
primeras 3 hileras del aula, los informe de atrás para adelante (de la hilera 3 a la hilera 1 y del último al que identifica su dureza. Es necesario almacenar los datos de cada una de las baldosas.
primero).
Algoritmo Piso
Léxico
Fila = 20
Columna = 30
TNumReales = arreglo[1..Fila, 1..Columna] de R
i, j  Z // o subrango
piso  TNumReales
Inicio
i1
mientras i <= Fila hacer Prueba de Escritorio
j  1 i j i<=Fila j<=Columna
mientras j <= Columna hacer
Entrada:piso[i,j]
j  j+1
fmientras
i  i+1
fmientras
Fin

2023 Lic. Ariel Ferreira Szpiniak 83 2023 Lic. Ariel Ferreira Szpiniak 84
 Ejemplo IX Ejemplo X
Resolver el mismo problema anterior pero definiendo la matriz dentro de un registro. Un piso rectangular contiene 20 baldosas de largo y 30 de ancho. Cada baldosa posee
un número (entre 0 y 1) que identifica su dureza. Es necesario almacenar los datos de
cada una de las baldosas y luego calcular el promedio de dureza de todo el piso.
Algoritmo DurezaPromedio
Léxico
N = 20
M = 30
TNumReales = arreglo[1..N, 1..M] de R
acum, promedio  R
i, j  Z
piso  TNumReales
Inicio
i 1
acum  0
mientras i <= N hacer
j  1
Prueba de Escritorio
mientras j <= M hacer i j i<=N j<=M
acum  acum + piso[i,j]
j  j+1
fmientras
i  i+1
fmientras
promedio  acum/(N+M) //dureza promedio
Salida:promedio
Fin

2023 Lic. Ariel Ferreira Szpiniak 85 2023 Lic. Ariel Ferreira Szpiniak 86

Ejemplo XI
Un piso rectangular contiene 20 baldosas de largo y 30 de ancho. Cada baldosa posee un número
(entre 0 y 1) que identifica su dureza. Es necesario almacenar los datos de cada una de las
Lenguaje C
baldosas y luego calcular el promedio de dureza de todo el piso.
Algoritmo DurezaPromedio
Léxico
N = 20
Arreglo Bidimensional
M = 30
TNumReales = arreglo[1..N, 1..M] de R
TData = <a  TNumReales, cantFila  (0..N), cantCol  (0..M)> 1 2 3 4 0 1 2 3
acum, promedio  R
i, j  Z
piso  TData 1 4 6 -2 1 0 4 6 -2 1
Inicio
i 1 2 7 8 -4 0 1 7 8 -4 0
acum  0
mientras i <= [Link] hacer 3 9 6 7 3 2 9 6 7 3
j  1
Prueba de Escritorio
i j i<=N j<=M
mientras j <= [Link] hacer
acum  acum + piso.a[i,j]
Notación Algorítmica C

j j+1
fmientras Los límites inferiores de filas y columnas

son fijos, siempre comienzan con 0
i i+1
fmientras
promedio  acum/(N+M) //dureza promedio
Salida:promedio
Fin
2023 Lic. Ariel Ferreira Szpiniak 87 2023 Lic. Ariel Ferreira Szpiniak 88
 Arreglo Bidimensional en C Arreglo Bidimensional en C
/* Ejemplo V /*
Algoritmo Juego2 - Ejemplo V (buscaMinas)
Fil = 16 Léxico
Col = 30 Fil = 16
TMina = arreglo[1..Fil, 1..Col] de (0..9) Col = 30
TData = <m e TMina, cantFila e (0..Fil), cantCol e (0..Col) TMina = arreglo[1..Fil, 1..Col] de (0..9)
TData = <m e TMina, cantFila e (0..Fil), cantCol e (0..Col) //tipo
//tipo
buscaMinas e TData // variable
buscaMinas e TData // variable i, j e Z // o subrango
i, j e Z // o subrango Inicio
*/ [Link]<--2
[Link]<--30
#define Fil 16 para (i<--1, i<=[Link], i<--i+1) hacer
#define Col 30 para (j<--1, j<=[Link], j<--j+1) hacer
typedef struct { Entrada: buscaMinas.m[i,j]
fpara
int m[Fil][Col]; fpara
int cantFila; para (i<--1, i<=[Link], i<--i+1) hacer
int cantCol; para (j<--1, j<=[Link], j<--j+1) hacer
Salida: buscaMinas.m[i,j]
}TData; fpara
TData buscaMinas; fpara
int i,j; Fin
*/
2023 Lic. Ariel Ferreira Szpiniak 89 2023 Lic. Ariel Ferreira Szpiniak 90

Arreglo Bidimensional en C Arreglo Bidimensional en C

#include <stdio.h> // Ejemplo V /* DurezaPromedio Ejemplo X
#include <string.h>
N = 20
#define Fil 16
#define Col 30 M = 30
typedef struct { TNumReales = arreglo[1..N, 1..M] de R
int m[Fil][Col]; TData = <a  TNumReales, cantFila  (0..N), cantCol  (0..M)>
int cantFila; acum, promedio  Z
int cantCol; i, j  Z
}TData;
piso  TData
TData buscaMinas;
int i,j; */
int main(){ #define N 20
[Link]=2;
[Link]=3;
#define M 30
for(i=0;i<[Link];i++){ typedef struct {
for(j=0;j<[Link];j++){
scanf("%d",&buscaMinas.m[i][j]);
int a[N][M];
} int cantFila;
} int cantCol;
for(i=0;i<[Link];i++){
for(j=0;j<[Link];j++){ }TData;
printf("%d",buscaMinas.m[i][j]); float acum, promedio;
}
} int i,j;
return 0; TData piso;
}
2023 Lic. Ariel Ferreira Szpiniak 91 2023 Lic. Ariel Ferreira Szpiniak 92
 Arreglo Bidimensional en C Bibliografía
// Implementar en C DurezaPromedio Ejemplo X
- Scholl, P. y J.-P. Peyrin, “Esquemas Algorítmicos Fundamentales: Secuencias e
iteración”, Barcelona, Ed. Masson, 1991.
- Lucas, M., J.-P. Peyrin y P. Scholl, “Algorítmica y Representación de Datos. Tomo 1:
Secuencia, Autómata de estados finitos”, Barcelona, Ed. Masson, 1985.
- Watt, David, “Programming Language Concepts and Paradigms“, Prentice-Hall
International Series in Computer Science (1990).
- Biondi, J. y G. Clavel, “Introducción a la Programación. Tomo 1: Algorítmica y
Lenguajes”, 2° ed., Barcelona: Masson, 1985.
- Clavel, G. y Biondi, J., “Introducción a la Programación. Tomo 2: Estructuras de
Datos”, 2° ed., Barcelona: Masson, 1985.
- De Guisti, A. “Algoritmos, datos y programas. Con aplicaciones en Pascal, Delphi y
Visual Da Vinci. Prentice Hall.
- Kernighan, B; Ritchie, D. El lenguaje de programación C. Pearson Educación, 1991.

2023 Lic. Ariel Ferreira Szpiniak 93 2023 Lic. Ariel Ferreira Szpiniak 94

Citar/Atribuir: Ferreira, Szpiniak, A. (2023) Teoría 7: Tipo de Dato Estructurado

Homogéneo: Arreglo.
Introducción a la Algorítmica y Programación (3300). Departamento de Computación.
Facultad de Cs. Exactas, Fco-Qcas y Naturales. Universidad Nacional de Río Cuarto.
Usted es libre para:
Compartir: copiar y redistribuir el material en cualquier medio o formato.
Adaptar: remezclar, transformar y crear a partir del material.
El licenciante no puede revocar estas libertades en tanto usted siga los términos de la
licencia.
Bajo los siguientes términos:
Atribución: Usted debe darle crédito a esta obra de manera adecuada, proporcionando un
enlace a la licencia, e indicando si se han realizado cambios. Puede hacerlo en cualquier forma
razonable, pero no de forma tal que sugiera que usted o su uso tienen el apoyo del licenciante.

Compartir Igual: Si usted mezcla, transforma o crea nuevo material a partir de esta obra,
usted podrá distribuir su contribución siempre que utilice la misma licencia que la obra original.

Este material está bajo una Licencia Creative Commons Atribución-CompartirIgual 4.0 Internacional

2023 Lic. Ariel Ferreira Szpiniak 95