UNIVERSIDAD DE CARABOBO

COMPUTACION

ALGORITMOS Y PROGRAMACIÓN I

Guia de lenguaje de programación pseudoformal

NASPI

Diego Linares

Escuela de Matematica
.

Prefacio
El documento presente es una compilación de los textos del lenguaje pseudoformal NASPI a modo de
resumen, contando con una extensión un poco más ampliada que la que se encuentra disponible en
internet. Se ha adjuntado al final del documento ejercicios resueltos y adjuntado varias tablas de
traducciones del NASPI al lenguaje C. Este documento está dedicado a todas aquellas personas que
necesitan encontrar un poco más de información para los problemas y plantear su solución en este
lenguaje de programación. Los textos sobre este tema son pocos, y los libros sobre la materia se enfocan
en presentar la resolución de los problemas en lenguajes en pseudoformal similares al NASPI, algunos
de manera didáctica, otros no tanto. La principal razón de este texto es el aunar la información
disponible de forma concentrada para tener una guía más concreta de los temas.
Indice de Contenidos
1. Estructura de un algoritmo ............................................................................................................................................................... 4
2. Variables y tipos de datos .................................................................................................................................................................. 4
3. Tipos de datos elementales ................................................................................................................................................................ 4
4. Precedencia de operadores ................................................................................................................................................................ 6
5. Tipo de dato definido por el usuario ................................................................................................................................................. 7
6. Equivalencias de tipos ........................................................................................................................................................................ 8
7. Constantes ........................................................................................................................................................................................... 8
8. Estructuras de control ...................................................................................................................................................................... 8
9. Entrada / salida .................................................................................................................................................................................. 9
10. Funciones y procedimientos ........................................................................................................................................................... 10
11. Archivos .......................................................................................................................................................................................... 10
12. Arreglos y matrices ......................................................................................................................................................................... 15
Tabla de equivalencias entre NASPI y Lenguaje C ........................................................................................................................... 32
Ejercicios resueltos ................................................................................................................................................................................ 42
Notación algorítmica

1. Estructura de un algoritmo

algoritmo nombre
[const
// declaraciones de constantes]
[tipo
// declaraciones de tipos]
[var
// declaraciones de variables globales]
inicio
// cuerpo del algoritmo
fin

2. Variables y tipos de datos

Una o varias variables de un tipo T, con identificadores v1, v2,…, vn, se declaran de la forma:

T v1, v2,…, vn

3. Tipos de datos elementales

3.1. Tipo ordinal
Un tipo elemental T es ordinal sólo si sus elementos están organizados de manera tal que: (1) existen dos
elementos notables en T: el primero y el último, (2) para cada elemento en T, excepto el último; existe un
elemento único que le sigue llamado sucesor (suc), (3) para cada elemento en T, excepto el primero; existe
un elemento único que le precede llamado predecesor (pred), y (4) cada elemento de T tiene un valor entero
asociado con él, llamado número ordinal (ord), que representa la posición relativa del elemento en la
secuencia de valores que define a T. Todos los tipos elementales son ordinales, con excepción del tipo real
que no satisface las tres últimas propiedades de la definición.

Operador Significado
= Igual a
< Menor que
> Mayor que
≤ Menor o igual que
≥ Mayor o igual que
≠ Distinto de

3.2. Tipo entero

Este tipo es un subconjunto finito del conjunto de los números enteros ℤ. Se utiliza la palabra reservada
entero en su declaración. Este tipo de dato además de los operadores vistos en la sección 3.1
presentan las operaciones definidas a continuación.

Operador Significado
- Menos unario
− Resta
+ Suma
* Multiplicación
div División entera
mod Resto de la división entera
** Exponenciación
3.3. Tipo real
Este tipo es un subconjunto finito del conjunto de los números reales ℝ. Se utiliza la palabra reservada
real en su declaración. Este tipo de dato además de los operadores vistos en la sección 3.1 presentan
las operaciones definidas a continuación.

Operador Significado
- Menos unario
− Resta
+ Suma
* Multiplicacion
/ Division Real
 * Multiplicación
/ División real

3.4. Tipo lógico

3.4.
Este tipoTipo lógico
de dato comprende dos valores de verdad que están representados por los identificadores verdadero y falso.
Este tipo de dato reservada
Se utiliza la palabra comprende dos
lógico valores
en su de verdad
declaración. que están
A continuación representados
se presentan por definidas
las operaciones los identificadores
sobre
verdadero y falso. Se
elementos de tipo lógico. utiliza la palabra reservada lógico en su declaración. A continuación se
presentan las operaciones definidas sobre elementos de tipo lógico.
Operador Significado
Operador
¬ Significado
Negación lógica
¬∧ Negación lógica
Multiplicación lógica
∧∨ Multiplicación
Suma lógica lógica
∨ Suma lógica

3.5. Tipo caracter

3.5.
Este tipoTipo caracter
es un conjunto tal que contiene las 26 letras mayúsculas del alfabeto latino, las 26 letras minúsculas, los 10
Este tipo es un conjunto
dígitos de la numeración árabe tal quesímbolos
y otros contiene las 26Seletras
especiales. utiliza mayúsculas del alfabeto
la palabra reservada caracter enlatino, las 26 letras
su declaración.
minúsculas,
A continuaciónlos 10 dígitos
se presentan de la numeración
las operaciones árabe
definidas sobre y otros
elementos símbolos
de tipo carácter. especiales. Se utiliza la palabra
reservada caracter en su declaración. A continuación se presentan las operaciones definidas sobre
elementos de tipo carácter. Operador Significado
= Igual a
Operador
< Significado
Menor que
=> Igual
Mayora que
<≤ Menor
Menor que
o igual que
>≥ Mayor
Mayor que
o igual que
≤≠ Menor
Distintoo de
igual que
≥ Mayor o igual que
3.6. Tipo cadena ≠ Distinto de
Una cadena es una secuencia finita de símbolos con longitud variable. Se utiliza la palabra reservada cadena en su
3.6. Tipo cadena
declaración. Las cadenas son el único tipo de dato compuesto que no requiere declaración. A continuación se
Una cadena es una secuencia
presentan las operaciones finita
definidas sobre de símbolos
elementos con longitud variable. Se utiliza la palabra reservada
de tipo cadena.
cadena en su declaración. Las cadenas son el único tipo de dato compuesto que no requiere
declaración. A continuación se presentan las operaciones definidas sobre elementos de tipo cadena.
Operador Significado
+ Concatenación de cadenas
Operador
long Significado
Longitud de la cadena
+= Concatenación
Igual a de cadenas
long< Longitud
Menor quede la cadena
=> Igual
Mayora que
<≤ Menor
Menor que
o igual que
>≥ Mayor
Mayor que
o igual que
≤≠ Menor
Distintoo de
igual que
≥ Mayor o igual que
≠ Distinto de
4. Precedencia de operadores

4.Los
Precedencia
operadoresdeson
operadores
asociativos a la izquierda. Los operadores binarios utilizan notación infija. La precedencia entre
los operadores está definida a continuación de manera ordenada descendentemente, siendo los operadores primarios los
Los operadores son asociativos a la izquierda. Los operadores binarios utilizan notación infija. La
de mayor precedencia.
precedencia entre los operadores está definida a continuación de manera ordenada descendentemente,
siendo los operadores primarios los
Tipo
de mayor precedencia.
Operador
Primarios ( ) [ ] Paréntesis en expresiones o en llamadas a procedimientos
Tipo Operador
o funciones. Corchetes en índices de arreglos.
Primarios
Unarios ( -,) +,
[ ]¬ Paréntesis en expresiones o en llamadas a procedimientos
Multiplicativos o ∗,funciones.
/, div, mod, ∧, ∗∗ Corchetes en índices de arreglos.
Unarios
Aditivos -,+,+, −, ∨¬
Multiplicativos
De cadena ∗ ,+/, div, mod, ∧, ∗∗
Aditivos
De relación +,=,−, <, ∨>, ≤, ≥, ≠
De cadena +
De relación =, <, >, ≤, ≥, ≠
5. Tipo de dato definido por el usuario
5. Tipo de dato definido por el usuario
5.1. Tipo enumerado
5.1. Tipo enumerado
Un enumerado es una secuencia finita y ordenada de valores referenciados por identificadores. Este tipo
Un enumerado es una secuencia finita y ordenada de valores referenciados por identificadores. Este tipo
está definido por la enumeración explícita de los identificadores que lo conforman. La declaración de un
está definido por la enumeración explícita de los identificadores que lo conforman. La declaración de un
tipo enumerado es de la forma T = (id1,…, idk), donde: (1) T es el identificador del nuevo tipo, (2) los idi
tipo enumerado es de la forma T = (id 1,…, idk), donde: (1) T es el identificador del nuevo tipo, (2) los id i
(1 ≤ i ≤ k) son los identificadores que forman el tipo, y (3) el orden de los identificadores de T está
(1 ≤ i ≤ k) son los identificadores que forman el tipo, y (3) el orden de los identificadores de T está
definido por la regla: 〈∀ ∀ : 1 ≤ i, j ≤ k : (id < id ) ⇒ (i < j)〉. El primer elemento de un tipo enumerado
definido por la regla: 〈∀i ∀i j :j 1 ≤ i, j ≤ k : (idi i< idj)j ⇒ (i < j)〉. El primer elemento de un tipo enumerado
tiene asociado el número ordinal 0. Una variable v de tipo enumerado T sólo puede tomar valores de la
tiene asociado el número ordinal 0. Una variable v de tipo enumerado T sólo puede tomar valores de la
lista de identificadores que define a T. Los únicos operadores asociados con el tipo enumerado son el de
lista de identificadores que define a T. Los únicos operadores asociados con el tipo enumerado son el de
asignación y los de comparación. Un identificador no puede pertenecer a más de un tipo enumerado.
asignación y los de comparación. Un identificador no puede pertenecer a más de un tipo enumerado.
Un ejemplo de declaración de variables de tipo enumerado viene dado por:
Un ejemplo de declaración de variables de tipo enumerado viene dado por:
tipo
tipo
días = (lunes, martes, miércoles, jueves, viernes)
días = (lunes, martes, miércoles, jueves, viernes)

5.2. Tipo intervalo

5.2. Tipo intervalo
La declaración de un tipo intervalo es de la forma T= min .. max, donde: (1) T es el identi ficador del
La declaración de un tipo intervalo es de la forma T= min .. max, donde: (1) T es el identificador del nuevo tipo, (2) min y
nuevo tipo, (2) min y max son constantes del mismo tipo (entero, símbolo o tipo enumerado) que
max son constantes del mismo tipo (entero, símbolo o tipo enumerado) que especifican los límites inferior y superior del
especifican los límites inferior y superior del intervalo, y (3) la definición de un tipo intervalo es
intervalo, y (3) la definición de un tipo intervalo es aceptable sólo si min ≤ max. Las operaciones que se pueden
aceptable sólo si min ≤ max. Las operaciones que se pueden realizar sobre una variable de tipo
realizar sobre una variable de tipo intervalo son iguales que las del tipo a partir del cual está definido. Un ejemplo de
intervalo son iguales que las del tipo a partir del cual está definido. Un ejemplo de declaración de
declaración de variables de tipo intervalo es el siguiente:
variables de tipo intervalo es el siguiente:
tipo
tipo Horas = 0..23
Horas = 0..23
5.3. Tipo arreglo
5.3. Tipo arreglo
La declaración de un tipo arreglo es de la forma T= arreglo [dim1,…, dimk] de T0, donde: (1) T es el identificador del nuevo
La declaración de un tipo arreglo es de la forma T= arreglo [dim1,…, dimk] de T0, donde: (1) T es el
tipo, (2) dimi (1 ≤ i ≤ k) es un intervalo de tipo ordinal que especifica, para cada dimensión, los índices del primer y del
identificador del nuevo tipo, (2) dim (1 ≤ i ≤ k) es un intervalo de tipo ordinal que especifica, para
ultimo elemento del arreglo, y (3) T 0 es el iidentificador de cualquier tipo (elemental o definido por el usuario) que
cada dimensión, los índices del primer y del ultimo elemento del arreglo, y (3) T es el identificador de
especifica el tipo de todos los elementos del arreglo. El acceso a un elemento de un arreglo se realizará0 colocando su índice
cualquier tipo (elemental o definido por el usuario) que especifica el tipo de todos los elementos del
entre corchetes. Un ejemplo para ilustrar el tipo de dato arreglo sería:
arreglo. El acceso a un elemento de un arreglo se realizará colocando su índice entre corchetes. Un
ejemplo para ilustrar el tipo de dato arreglo sería:
tipo
Num_primos = arreglo [1..500] de entero
tipo
Num_primos = arreglo [1..500] de entero
5.4. Tipo registro
Los componentes de un registro se denominan campos. Los nombres de los campos se conocen
5.4. Tipo registro
también como identificadores de campo o selectores. La declaración de un tipo registro es de la forma:
Los componentes de un registro se denominan campos. Los nombres de los campos se conocen
también como identificadores de campo o selectores. La declaración de un tipo registro es de la forma:
tipo
T = registro
tipo
Tcampo1= : T1registro
∶ campo1 : T1
Campok:
∶ Tk
Fregistro
campok: Tk
fregistro
Donde: (1) T es el identificador del nuevo tipo, (2) campoi (1 ≤ i ≤ k) es un identificador que se utilizará para referenciar
Donde:
el i-ésimo (1)
campoT esdel el identificador
registro; y (3) Ti (1del
≤i≤ nuevo
k) es eltipo, (2) campo
tipo (elemental i (1 ≤ por
o definido i ≤ elk)usuario)
es undel\identificador
i-ésimo campo. que
El se
utilizará
acceso paracampo
al iésimo referenciar el i-ésimo
de una variable v de tipocampo del
registro se registro;
realizará y (3)
utilizando Ti (1(.),
el punto ≤ como
i ≤ k) es el tipo
en v.campo i. (elemental o
definido por el usuario) del i-ésimo campo. El acceso al iésimo campo de una variable v de tipo registro
se ejemplo
Un realizaráparautilizando el de
ilustrar el tipo punto (.), como
dato registro sería:en v.campo i.

Un ejemplo para ilustrar el tipo de dato registro sería:

tipo
Votante = registro
Cédula, teléfono: entero
Nombre, dirección: cadena
fregistro

5.5. Tipo apuntador

Un apuntador es una variable que contiene la dirección de memoria de otra variable de un tipo T 0. La
declaración de un tipo apuntador es de la forma ap_T= apuntador a T0, donde ap_T es el identificador del
nuevo tipo y T0 es el tipo referenciado por ap_T.

El tipo referenciado puede ser elemental o compuesto. El apuntador nulo se denota por el valor
constante nulo. Dada una variable P de tipo apuntador que hace referencia a un tipo T 0, las
operaciones permitidas son las siguientes:

• Referenciación (β): Si Y es una variable de tipo T 0, entonces P ← βY asigna a P la dirección de

memoria de Y.
• Desreferenciación (↑): P↑ retorna el contenido de la dirección de memoria almacenada en P.
• Asignación de memoria: la ejecución de la instrucción crear (P): (1) crea una nueva variable
de tipo T0, (2) accede el valor de la dirección de memoria de la variable creada en el ítem
anterior, y (3) asigna este valor a la variable P.
• Liberación de memoria: la ejecución de la instrucción liberar (P): (1) elimina P↑, y (2) el
contenido de P se vuelve indefinido. Pre-condiciones: P↑ fue creado a partir de la instrucción
crear (P) y P todavía hace referencia a este valor.
5.6 Tipo Booleano:
var
Existe, encontrado: booleano
6. Equivalencias de tipos
Existen tres posibles relaciones entre dos tipos de datos T1 y T2: igualdad, compatibilidad y
compatibilidad de asignación.

• Igualdad: Dos tipos T1 y T2 son iguales si por lo menos una de las siguientes afirmaciones es
verdadera: (1) T1 y T2 tienen el mismo identificador, o (2) T1 y T2 tienen identificadores
diferentes y tipo T1 = T2 es una declaración de tipos.
• Compatibilidad: Dos tipos T1 y T2 son compatibles si por lo menos una de las siguientes
afirmaciones es verdadera: (1) T1 y T2 son iguales, (2) T1 es un intervalo de T2 o T2 es un
intervalo de T1, o (3) T1 y T2 son intervalos del mismo tipo.
• Compatibilidad de asignación: Dos tipos T1 y T2 son de asignación compatible si por lo menos
una de las siguientes afirmaciones es verdadera: (1) T1 y T2 son compatibles o (2) uno de ellos
es tipo real y el otro es tipo entero o un intervalo de tipo entero.

7. Constantes
Una constante puede verse como una variable cuyo valor no cambia durante su tiempo de vida. Una
constante es representada y utilizada a través de un identificador único (nombre) que la denota. Una
constante c con valor V se declara de la forma const c = V. El tipo T de una constante c siempre es
elemental, y viene dado por el dominio sobre el cual esté definido el valor V utilizado en la declaración.

8. Estructuras de control
8.1. Condicional

Simple: si (nota ≥ 10) entonces

si (cond) entonces
S aprobados ← aprobados + 1
fsi fsi

Doble:
si (cond) entonces si (a = b) entonces
S1 a←b
sino sino
S2 b←a
fsi
fsi
 selección (a) de
Múltiple:
selección (expr)
1 : result ← 4
lst1 : S1 2 : result ← 8
∶ 3 : result ← 12
lstk−1 : Sk−1 sino
[sino : Sk] escribir(“Caso no definido”)
fselección fselección

Donde
Donde lsti (1 ≤
lsti (1 ≤ ii ≤
≤ k)
k) consistirá
consistirá de
de uno
uno oo más
más valores,
valores, separados
separados por por comas,
comas, del
del mismo
mismo tipo
tipo que
que expr.
expr. Si el valor de expr coincide con alguno de los valores de la primera lista de valores
Si el valor de expr coincide con alguno de los valores de la primera lista de valores (lst 1), entonces (lst 1), se
entonces se ejecutan las instrucciones correspondientes (S ) y sale de la estructura.
ejecutan las instrucciones correspondientes (S 1) y sale de la1 estructura. En caso contrario, evalúa la En caso
contrario, evalúa
siguiente lista de la siguiente
valores, lista
y así de valores, y Las
sucesivamente. así acciones
sucesivamente. Las acciones
de la cláusula de se
sino sólo la cláusula
ejecutarán si
sólovalor
ningún
sino se ejecutarán
de lsti (1 ≤sii ningún valor de
< k) coincide lstexpr.
con i (1 ≤ i < k) coincide con expr.

8.2. Iteración Ejemplo:

Estructura mientras a←0
mientras (cond) hacer mientras (a < 8) hacer
S
fmientras
a←a+1
fmientras
Estructura hacer (repetir) mientras
hacer hacer
S a←a−1
mientras (cond) mientras (a > 8)

Estructura para
para cont ← vi hasta vf en expr hacer para i ← 8 hasta 0 en -2 hacer
S prom ← prom + i
fpara fpara
La secuencia de instrucciones S se evalúa para cada valor de cont comprendido entre vi y vf. expr
especifica, de acuerdo con su signo, la cantidad en la cual se incrementa o decrementa el valor de la
variable cont para la siguiente ejecución de S. Un ejemplo que realice un ciclo que incremente de 1 en 1
sería:

para i ← 1 hasta 8 en 1 hacer

prom ← prom + i
fpara

Un ejemplo que realice un ciclo que decremente de 2 en 2 sería:

para i ← 8 hasta 0 en -2 hacer

prom ← prom + i
fpara

9. Entrada / salida
leer (v1, …, vk)
escribir (expr1, …, exprk)

Ejemplo
leer (i, j)
escribir (“Valor de i: ”, i, “Valor de j: ”, j)
10. Funciones y procedimientos
Funcion func factorial(val n : entero) : entero
func nombre([F1, …, Fk]) :T inicio
var si (n < 2) entonces
[declaraciones locales]
inicio
retornar(1)
sino
∶
retornar(expr) retornar(n ∗ factorial(n − 1))
ffunc fsi
ffunc
Procedimiento
proc nombre([F1, …,Fk]) proc carga(ref M : arreglo [1..N, 1..N] de entero)
var var
[declaraciones locales]
inicio
i, k : entero
inicio
∶
fproc
k←1
para i ← 1 hasta N en 1 hacer
M[ i ] ← k
k←k+1
fpara
fproc
Donde:
• Nombre es el identificador de la función o procedimiento.
• Cada Fi (1 ≤ i ≤ k) es un grupo de parámetros formales de la siguiente forma:
o {ref} Ti pi, donde:
ref indican si el paso de parámetros se realiza por referencia.
pj (1 ≤ j ≤ m) es el identificador del j-ésimo parámetro formal del i-ésimo grupo.
Ti es el tipo (elemental o definido por el usuario) de los parámetros que forman el i -
ésimo grupo.

Además, en el caso de una función:

• T es el tipo (elemental o definido por el usuario) que retorna la función.
• expr es el valor de retorno de la función. El tipo de expr y T deben ser iguales.

11. Archivos

11.1. Archivo

Un archivo es un espacio que se reserva en un dispositivo de memoria de un computador para

almacenar porciones de información que tienen la misma estructura y que pueden manejarse
mediante una instrucción única (RAE, 2011).

Los archivos se forman de una secuencia de elementos del mismo tipo, que residen generalmente en
memoria auxiliar. Son utilizados cuando se necesita procesar grandes volúmenes de datos que no pueden
ser almacenados al mismo tiempo en la memoria central del computador.

Para ocultarle al programador los detalles específicos de cada dispositivo hardware, se usa el
concepto de archivo, el cual es tratado como un objeto abstracto sobre el cual se pueden realizar
operaciones tales como lectura y escritura de información.

Existen dos tipos fundamentales de archivos: archivos de texto y archivos binarios. En los archivos de texto
almacena la información como una secuencia de códigos ASCII. Los archivos binarios, almacenan datos que
no son interpretables como texto (imágenes, video, audio entre otros).
11.2. Características de un Archivo

• Los archivos son utilizados cuando se desea que los datos puedan recuperarse aún después de
haber apagado la máquina y también cuando se manejan grandes volúmenes de información.
• Residen en memoria auxiliar, la cual generalmente, es más económica y grande que la
memoria principal del computador, pero más lenta.
• Los elementos que almacena un archivo pueden ser elementales (texto, números) o
estructurados (arreglos, registros). Para propósitos del curso, sólo se puede leer un archivo
elemento por elemento.
• La cantidad de componentes que constituyen el archivo, no se conoce previamente. Si tiene
cero elementos se dice que es un archivo vacío.

11.3. Tipos de Archivo según su Organización Interna

La organización interna de un archivo se refiere a la estructura lógica de los registros que se

almacenan en el mismo y la forma en la que se puede acceder a estos (Stallings, 2008: 558).

11.3.1. Archivo de Acceso Secuencial

En este tipo de archivo se almacenan elementos, llamados registros, los cuales tienen una
estructura formada por datos dispuestos en un orden particular.
Ejemplos:

María Ortega 19807543 22 1.63

Es un registro que contiene datos de una persona: Nombre, apellido, cedula de identidad, edad y
estatura. El mismo registro puede ser estructurado de una forma distinta:

María Ortega
19807543
22
1.63

Los registros son almacenados uno tras otro en el archivo al igual que los elementos que lo
forman, por lo cual, para acceder a un elemento de un registro en particular hay que procesar
todos los elementos anteriores en el archivo.

Ejemplo: Si se desea saber el apellido de la segunda persona en el archivo, primero se debe

procesar el primer registro, y el primer elemento (nombre) del segundo registro.

María Ortega 19807543 22 1.63

Juan Pérez 17853028 25 1.80

Declaración

La declaración de una variable de tipo archivo de acceso secuencial se escribe de la siguiente

forma:

archivo_s f --> archivo_s queso

donde archivo_s es el identificador de tipo y f es el identificador de la variable.

Operaciones

Las operaciones que pueden ser realizadas sobre un archivo son: apertura, lectura, escritura,
clausura y detección de fin de archivo.

a) Apertura

Prepara al archivo para su acceso posterior.

abrir(f, modo, nombre) --> abrir(queso, l, quesocosto.txt)

donde f es una variable de tipo archivo_s, modo indica el tipo de operación que se realizará
sobre el archivo y nombre es una expresión de tipo cadena que indica la ruta en la cual se
encuentra almacenado el archivo en la memoria secundaria.
Los valores posibles para modo son los siguientes:

• ‘l’: Lectura al comienzo del archivo. El archivo debe existir previamente, sino esto causará
un error.
• ‘e’: Escritura al comienzo del archivo. Si el archivo no existe, la operación crea
automáticamente un archivo vacío; sino, la operación sobrescribe el archivo existente.
• ‘a’: Escritura al final del archivo. Si el archivo no existe, la operación crea automáticamente
un archivo vacío; sino, la operación permite que los registros sean insertados luego de los ya
existentes en el archivo.

b) Lectura

Permite leer elementos del archivo.

leer(f, v) --> leer(queso, precio) - precio es una variable de “queso”

donde f es una variable de tipo archivo_s que ha sido abierto para lectura y v es la variable que
se va a leer.

c) Escritura

Permite escribir elementos en el archivo.

escribir(f, expr)--> escribir(queso, “tal cosa”)

donde f es una variable de tipo archivo_s que ha sido abierto para escritura y expr es una
expresión que se va a escribir, la cual puede ser un literal o el valor de una variable.

d) Clausura

Permite cerrar uno o varios archivos.

cerrar(f1, f2, ...)

donde f1, f2, … son variables de tipo archivo_s.

e) Detección de Fin de Archivo

Función encargada de determinar si durante el recorrido sobre un archivo, ya se ha llegado

al final del mismo. Retorna un valor lógico: “v” verdadero o “f” falso.

fda(f)
11.3.2. Archivo de Acceso Directo

En este tipo de archivo se almacenan registros a los cuales se puede acceder de forma directa
mediante su posición en el archivo.

Declaración

La declaración de una variable de tipo archivo de acceso secuencial se escribe de la siguiente

forma:

archivo_d f

donde archivo_d es el identificador de tipo y f es el identificador de la variable.

Operaciones

Las operaciones que pueden ser realizadas sobre un archivo de acceso directo son: apertura,
lectura, escritura, clausura y detección de fin de archivo.

a) Apertura

Prepara al archivo para su acceso posterior.

abrir(f, modo, nombre) --> abrir(queso, l, queso.txt)

donde f es una variable de tipo archivo_d, modo indica el tipo de operación que se realizará
sobre el archivo y nombre es una expresión de tipo cadena que indica la ruta en la cual se
encuentra almacenado el archivo en la memoria secundaria.

Los valores posibles para modo son los siguientes:

• ‘ld’: Lectura al comienzo del archivo. El archivo debe existir previamente, sino esto causará
un error.
• ‘ed’: Escritura al comienzo del archivo. Si el archivo no existe, la operación crea
automáticamente un archivo vacío; sino, la operación sobrescribe el archivo existente.
• ‘ad’: Lectura/Escritura al comienzo del archivo. Si el archivo no existe, la operación crea
automáticamente un archivo vacío.

b) Lectura

Permite leer elementos del archivo.

leer(f, pos, v)
donde f es una variable de tipo archivo_d que ha sido abierto para lectura, pos es la posición
(numero) del registro a leer y v es la variable que se va a leer.

c) Escritura

Permite escribir elementos en el archivo.

escribir(f, pos, expr)

donde f es una variable de tipo archivo_d que ha sido abierto para escritura, es la posición donde
se escribirá el registro y expr es una expresión que se va a escribir, la cual puede ser un literal o el
valor de una variable.

d) Clausura

Permite cerrar uno o varios archivos.

cerrar(f1, f2, ...)

donde f1, f2, … son variables de tipo archivo_d.

e) Detección de Fin de Archivo

Retorna un valor lógico que permite detectar si se ha llegado o no a la marca de final del
archivo representado por f, la cual se encuentra justo después del último registro del archivo.

fda(f)

12. Arreglos y matrices

Introducción

Los tipos de datos estructurados o tipos compuestos son agrupaciones de otros

tipos de datos simples (enteros, reales, caracteres, entre otros) que se manejan
como si fueran un único dato y que ocupan un espacio concreto en memoria. Estos
tipos de datos pueden ser estáticos o dinámicos. En esta sección sólo nos
enfocaremos en los estáticos.
Los datos estructurados más comunes son:

• Arreglos. Son una colección de datos del mismo tipo.

• Cadenas. También llamadas strings. Se trata de un conjunto de caracteres que
es tratado como un texto completo.
• Estructuras. Llamadas también registros. Son datos compuestos de datos de
distinto tipo. Una estructura podría estar compuesta de un entero, un carácter y
un arreglo por ejemplo.
• Punteros. Permiten definir variables que contienen posiciones de memoria; son
variables que se utilizan para apuntar a otras variables. (Serán abordados en el
curso de Algoritmos y Programación II)
ARREGLO

Imaginemos que deseamos leer las notas de una clase de 25 alumnos.

Desearemos por tanto almacenarlas y para ello con lo que conocemos hasta ahora
no habrá más remedio que declarar 25 variables. Eso es tremendamente pesado de
programar. Manipular esas notas significaría estar continuamente manejando 25
variables. Por ello en C (como en casi todos los lenguajes) se pueden agrupar una
serie de variables del mismo tipo en un tipo de datos más complejo que facilita su
manipulación.

En este tema trataremos el tipo de dato arreglo, de una dimensión denominado vector,
de dos dimensiones o matriz y los n-dimensionales.

Un arreglo (lista o tabla) es una secuencia de datos del mismo tipo. Los datos
se llaman elementos del arreglo y se numeran consecutivamente 0, 1, 2, 3,…etc.
Estos números se denominan valores índice o subindice del arreglo y se utilizan
para localizar la posición del elemento dentro del arreglo, proporcionando acceso
directo al arreglo.

Si el nombre del arreglo es A, entonces a 2 es el nombre del elemento que está en la

posición 2.
 Los arreglos son estructuras de datos caracterizadas por:

• Una colección de datos del mismo tipo, es decir, son estructuras

homogéneas.
• Referenciados mediante un mismo nombre.
• Almacenados en posiciones de memoria físicamente contiguas, de forma
que, la dirección de memoria más baja corresponde a la del primer elemento,
y la dirección de memoria más alta corresponde a la del último elemento.
• Es una estructura finita, es decir, todo arreglo tiene un límite. Se debe
determinar cuál será el número máximo de elementos que podrían formar
parte del arreglo.
• Están ordenados. Se puede saber cuál es el primer elemento, el segundo, el
tercero, en general el n-ésimo término.

¿CÓMO SE DECLARAN LOS ARREGLOS?

Para declarar un arreglo se debe indicar:

• El nombre del arreglo.
• El tipo base: tipo de dato de todos los componentes del arreglo.
• El tipo índice: intervalo de valores que podrá tomar el índice del arreglo,
indicando el límite inferior (Li) y el límite superior (Ls) del rango.
Para declarar arreglos tendremos dos opciones: declaración por variable y
declaración por tipo. Más adelante se indicará la sintaxis de cada declaración.

VECTOR O ARREGLO UNIDIMENSIONAL

Un vector se puede representar gráficamente de la siguiente forma:

Nombre del arreglo Elemento del arreglo ubicado en la posición 3

A 24 10 2 5 15 20

Indices del arreglo 1 2 3 4 5 6 7 8 9

Posiciones utilizadas = 6 Posiciones reservadas = 9

(tamaño del arreglo).

Importante:
• El índice del arreglo debe ser de tipo ordinal (carácter, entero, enumerado).
• Los componentes pueden ser de cualquier tipo (entero, real, cadena, arreglos,
registros, entre otros), siempre que sean todos del mismo tipo.
• Se usan corchetes [ ] para indicar el índice de un arreglo. Entre los corchetes se
debe escribir un valor ordinal, puede ser una variable, una constante o una
 expresión tan compleja como se quiere, pero que genere como resultado un
valor ordinal.
Por ejemplo:
• A[5] acceso al quinto elemento del arreglo, con un índice tipo constante.
• A[i] accedemos al i-ésimo elemento del arreglo, con un índice tipo variable. Este
tipo de acceso es válido siempre que (1≤ i ≤ posiciones reservadas)
• A[i*2+1] en este caso tenemos un acceso a un elemento del arreglo con un
índice tipo expresión. Al igual que el caso anterior este tipo de acceso es válido
siempre que (1≤ i*2 +1 ≤ posiciones reservadas).

Al igual que con cualquier tipo de variable, se debe declarar un arreglo antes de
utilizarlo. Un arreglo se declara de modo similar a otros tipos de datos, excepto que
se debe indicar al compilador el tamaño o longitud del arreglo. La sintaxis para
declarar un arreglo de una dimensión determinada es:

Arreglo <identificador> de <tipo de dato> [Li .. Ls]

Donde: Li es el límite inferior del arreglo (mayor o igual a 1), Ls es el límite

superior del arreglo. En el lenguaje de programación C, el límite inferior es mayor o
igual a 0, es decir, el primer elemento del vector está ubicado en la posición 0.
Este tipo de declaración se conoce con el nombre de: declaración directa o
declaración por variable.

Ejemplos:
Arreglo C de entero [1..5]; // arreglo de 5 enteros
Arreglo A de real [2..5]; // arreglo de 4 elementos de tipo real
Arreglo notas de entero [1..n]; // arreglo de n notas

Existe otra forma de declarar un arreglo, denominada declaración indirecta o

declaración por tipo.
Se realiza en dos pasos: 1) Se declara el arreglo como un nuevo tipo de dato y
2) Se le asigna ese tipo a una o más variables.
La ventaja de esta clase de declaración reside en que no es necesario repetir
todos los datos del arreglo cada vez que se necesite uno, sino que se utilizan tantas
variables como arreglos se necesiten y además simplifica la escritura del algoritmo.
Para declarar un tipo, sólo hace falta anteceder a la especificación la palabra
clave Tipo
La sintaxis es:
• Paso 1, declaración del tipo de dato arreglo <identificador>
Tipo
Arreglo <identificador> de <tipo de dato> [Li .. Ls];

• Paso 2, declaración de las variables de tipo <identificador>

 <identificador> A, B;

Tipo
arreglo vector_notas de entero [1..30]
Variables
vector_notas estud1, estud2

OPERACIONES BÁSICAS EN ARREGLOS UNIDIMENSIONALES

Las operaciones en arreglos pueden clasificarse de la siguiente forma:

a) Escritura
b) Lectura
c) Asignación
d) Actualización
e) Ordenación
f) Búsqueda

A continuación se detallan cada una de estas operaciones. Se dedicará una

sección especial a las operaciones de ordenamiento y búsqueda.

A) OPERACIÓN DE ESCRITURA

Consiste en asignarle un valor a cada elemento del arreglo. La escritura se

realiza de la siguiente manera:

para i ← 1 hasta N hacer

arreglo[i]<--x
fpara

B) OPERACIÓN DE LECTURA

Este proceso consiste en leer un dato de un arreglo y asignar un valor a cada

uno de sus componentes. La lectura se realiza de la siguiente manera:

para i ← 1 hasta N hacer

x ← arreglo[i]
fpara
C) OPERACIÓN DE ASIGNACIÓN

No es posible asignar directamente un valor a todo el arreglo, sino que se debe

asignar el valor deseado en cada componente; por lo que se realiza de la siguiente
manera:

Asignar un valor a todos los elementos del vector

para i ← 1 hasta N hacer
arreglo[i] ← algún_valor
fpara

Asignar el valor deseado a un componente en particular

arreglo[4] ← algún_valor

D) OPERACIÓN DE ACTUALIZACIÓN

Dentro de esta operación se encuentran las operaciones de eliminar, insertar y

modificar datos. Para realizar este tipo de operaciones se debe tomar en cuenta si el
arreglo está o no ordenado.

1. Eliminar un elemento de un vector: consiste en eliminar un elemento en una

posición dentro del vector.
Para eliminar un elemento de un arreglo primero se verifica que no esté vacío el
arreglo, luego se busca el dato, se elimina y, de ser necesario, se desplazan los
demás elementos para cubrir el espacio que quedó vacío.
Ejemplo: supongamos que se tiene un arreglo llamado Nota inicialmente con 6
posiciones utilizadas y se desea eliminar el elemento ubicado en la tercera
posición.

Pos=3 Eliminar elemento ubicado en la 3ra posición

Nota 12 16 07 11 18 12
1 2 3 4 5 6 7 8 9 10

N =Tamaño del arreglo (10) M =número de posiciones utilizadas (6)

Nota 12 16 11 11 18 12 Paso1
1 2 3 4 5 6 7 8 9 10

Nota 12 16 11 18 18 12 Paso2
1 2 3 4 5 6 7 8 9 10
 Nota 12 16 11 18 12 12 Paso3
1 2 3 4 5 6 7 8 9 10 M = M-1

Un fragmento del algoritmo es:

para i pos hasta n-1 hacer

arreglo[i] arreglo[i+1] //secuencia de instrucciones que sirve para desplazar
fpara // a la izquierda los elementos ubicados después de pos
n n-1 //actualizar el tamaño del arreglo, después hacer la eliminación

2. Insertar un elemento: es la operación de añadir un nuevo elemento al

vector. La única condición necesaria para esta operación consistirá en
comprobar si hay espacio de memoria suficiente para el nuevo elemento.

El caso más sencillo es insertar el elemento al final del vector. Pero, es posible
que necesitemos insertar un elemento en una posición diferente a la última, para
ellos debemos hacer espacio en el vector, desplazando los elementos a la
derecha del mismo y redefiniendo el tamaño del vector.
Ejemplo: supongamos que se tiene un arreglo llamado Nota inicialmente con 4
posiciones utilizadas y se desea insertar un elemento en la tercera posición.

Insertar en la 3ra posición la nota=20

Nota 12 16 07 11
1 2 3 4 5 6 7 8 9 10

N =Tamaño del arreglo (10) M =número de posiciones utilizadas (4)

M es menor a N

Nota 12 16 07 11 11 Paso1
1 2 3 4 5 6 7 8 9 10

Nota 12 16 07 07 11 Paso2
1 2 3 4 5 6 7 8 9 10

Nota 12 16 20 07 11 Paso3
1 2 3 4 5 6 7 8 9 10

Insertar la nota=20
 El fragmento del algoritmo que resuelve este problema es:

para i ← M hasta k [decrementando] hacer //donde K vale 3 para este ejemplo

arreglo[i+1] ← arreglo[i]
fpara

arreglo[i] ← p //p es el nuevo valor. Para el ejemplo p=20

M ← M+1 // Incremento de las posiciones utilizadas

3. Modificar un elemento: para modificar un elemento de un arreglo primero se

verifica que no esté vacío el arreglo, luego se busca el dato y se modifica. Esta
operación no altera el tamaño del vector.

MATRICES O ARREGLOS BIDIMENSIONALES

Las matrices, también llamadas arreglos bidimensionales o tablas, no son otra

cosa que vectores con dos dimensiones..

Este tipo de arreglo se caracteriza por:

• El acceso a cada elemento de la matriz se hace colocando el nombre de la

matriz y entre paréntesis la fila y la columna que se desea acceder
• Para localizar o almacenar un valor en el arreglo se deben especificar dos
posiciones (dos subíndices), uno para la fila y otro para la columna
• Todos los elementos son del mismo tipo de dato
• Para calcular el número de elementos de la matriz se multiplica el número de
filas utilizadas por el número de columnas utilizadas.

La figura 4 muestra la representación gráfica habitual de una matriz de datos.

Nombre de la matriz 1 2 3 4 …. n
1
nota 2 Número de columnas
3
:
Número de filas :
m Posición 2,4
fila 2, columna 4

La declaración de una variable matriz tiene la siguiente forma:

• Declaración directa o por variable:

Arreglo <identificador> de <tipo de dato> [ Lifila .. Lsfila , Licol .. Lscol ]

Donde: Li es el límite inferior del arreglo, Ls es el límite superior del arreglo, en

cada una de las dimensiones del arreglo.
 Ejemplo: Arreglo Notas de real [1...8 , 1…30] Representa una matriz de
8 filas y 30 columnas
• Declaración indirecta o por tipo:

Tipo Arreglo <identificador> de <tipo de dato> [ Lifila .. Lsfila , Licol .. Lscol ] La

declaración de la variable es:

<identificador> Tabla1

Ejemplo:
Tipo
Arreglo Dato de entero [1..4][1..4]
Variable
Dato tabla,caja //se han declarado 2 variables de tipo Dato
//y Dato es una matriz de tamaño 4x4

Observación: Las operaciones definidas sobre los vectores, también son

válidas para las matrices. Sin embargo, no debemos olvidar que cualquier
proceso que queramos realizar sobre una matriz involucrará a los dos
subíndices y por lo tanto será necesario utilizar dos ciclos anidados para
recorrer todo el arreglo.

También existen los arreglos multidimensionales, los cuales tienen más de una
dimensión y, en consecuencia, más de un índice. Es posible crear arreglos de
tantas dimensiones como requieran sus aplicaciones, esto es, tres, cuatro o más
dimensiones. Este curso abarca los arreglos hasta 2 dimensiones, por ser los más
usuales.

ALGORITMOS DE BÚSQUEDA EN ARREGLOS

Con frecuencia es necesario determinar si un arreglo contiene un cierto valor, es

decir, verificar la existencia de un elemento dentro de la estructura de datos. El
proceso de encontrar en un arreglo un elemento un particular, se denomina
búsqueda.

El resultado de un algoritmo de búsqueda puede ser:

• Un valor lógico indicando que existe (verdad) o no (falso) el elemento

buscado.
• Un número entero que indique la posición del elemento en el arreglo. Si
no existe devuelve un valor negativo, o cualquier valor fuera del intervalo
definido para el arreglo.
• Un número entero, que indique la cantidad de veces que se encuentra el
elemento buscado.
En esta sección se estudian dos técnicas de búsqueda, la técnica simple de
búsqueda secuencial y una técnica más eficiente llamada búsqueda binaria.
 BÚSQUEDA SECUENCIAL O LINEAL

Consiste en comparar de manera secuencial, cada elemento del arreglo con el

elemento buscado. Dado que el arreglo no está en ningún orden en particular, existe
la misma probabilidad de que el elemento se encuentre en la primera posición o en
la última. Por lo tanto, en promedio el algoritmo tendrá que hacer la comparación con
la mitad de los elementos del arreglo.

Este algoritmo es eficiente cuando el arreglo es pequeño y no necesariamente

está ordenado, pero cuando el arreglo es extenso resulta ineficiente. Si el arreglo
esta ordenado, se puede utilizar la técnica de búsqueda binaria.

Algoritmo Búsqueda_Secuencial
const // Declaración del tipo de dato y la constante para el límite superior
entero max ← 100 // límite superior del arreglo
tipo
arreglo vector de entero [1..max]; // declaración del tipo arreglo Vector
var
vector A // declaración de la variable A de tipo arreglo, donde se hará la búsqueda
entero elem, valor, i // elemento a buscar en el arreglo
booleano encontrado // indica si se encontró el elemento
inicio
para i ← 1 hasta max hacer
A[i] ← leer(valor) // acción que inicializa o llena el arreglo A
fpara

escribir (“Indique el número que quiere buscar dentro del arreglo”)

leer (elem); // leemos el valor que el usuario quiere buscar
encontrado ← falso
i ←1
(i ≤ max) hacer
mientras (encontrado=falso) ^
si (A[i]=elem) entonces
encontrado ← verdad
sino
i ← i+1
fsi
fmientras

si (encontrado=verdad) entonces
escribir (“El valor: ” elem “ existe en el arreglo”)
sino
escribir (“El valor: ” elem “ no está en el
fsi
fin arreglo”)

BÚSQUEDA BINARIA

El algoritmo de búsqueda binaria resulta eficiente cuando se tiene un arreglo

muy grande y está ordenado. Los pasos a seguir son:

a) Comparamos el elemento a buscar con el elemento que está justo en el centro

del arreglo.
b) Si ese elemento es menor que el elemento que buscamos, el algoritmo buscará
solo en la mitad superior del arreglo, si es mayor buscará en la mitad inferior, si
es igual retorna la posición encontrada.
c) Si busca en alguna de las mitades del arreglo, el algoritmo aplicará nuevamente
los pasos a y b, y así sucesivamente hasta que el elemento que buscamos sea
igual al elemento que está justo en la mitad del subarreglo. Si el elemento no se
encuentra en el arreglo la operación se realizará hasta que el subarreglo tenga 1
elemento, el cual es distinto a la clave o elemento buscado.
Esta búsqueda es bastante rápida ya que elimina muchas comparaciones al ir
quitando la mitad de lo que nos queda por examinar.

Algoritmo Búsqueda_Lineal
const // Declaración del tipo de dato y la constante para el límite superior
entero max ← 100 // límite superior del arreglo
tipo
arreglo vector de entero [1..max] // declaración del tipo arreglo Vector
var
vector A // declaración de la variable A de tipo arreglo, donde se hará la búsqueda
entero elem, valor, pos, i
entero inferior, mitad, superior //delimita las dos mitades para hacer la búsqueda
booleano encontrado // indica si se encontró el elemento
inicio
para i ← 1 hasta max hacer
A[i] ← leer(valor) // acción que inicializa o llena el arreglo A
fpara
escribir (“Indique el número que quiere buscar dentro del arreglo”)
leer (elem) // leemos el valor que el usuario quiere buscar
encontrado ← falso
inferior ← 1
superior ← max
pos ← 0
mientras (encontrado=falso) ^ (inferior ≤ superior) hacer
mitad ←( inferior + superior ) div 2
si (A[mitad]=elem) entonces
encontrado ← verdad
pos ← mitad
sino
si A[mitad]< elem entonces
inferior ← mitad+1
sino
si A[mitad] > elem entonces
superior ← mitad -1
fsi
fmientras
si (pos=0) entonces
escribir (“El valor: ” elem
“ no está en el
sino
escribir (“El valor: ” elem arreglo”)
fsi
fin “ existe en el arreglo”)
ORDENACIÓN DE ARREGLOS

La ordenación de arreglos es otra de las tareas usuales en la mayoría de los

programas. La ordenación o clasificación es el procedimiento mediante el cual se
disponen los elementos del arreglo en un orden especificado, tal como orden
alfabético u orden numérico.

Un diccionario es un ejemplo de una lista ordenada alfabéticamente, y una

agenda telefónica o lista de cuentas de un banco es un ejemplo de una lista
ordenada numéricamente. El orden de clasificación u ordenación puede ser
ascendente o descendente.

Existen numerosos algoritmos de ordenación de arreglos: inserción, burbuja,

selección, rápido (quick sort), fusión (merge), montículo (heap), shell, entre otros. En
este curso nos enfocaremos en el algoritmo de burbuja.

ALGORITMO BURBUJA

La ordenación por burbuja es uno de los métodos más fáciles de ordenación. El

algoritmo de ordenación es muy simple. Se compara cada elemento del arreglo con
el siguiente (por parejas), si no están en el orden correcto, se intercambian entre sí
sus valores. El valor más pequeño flota hasta la parte superior del arreglo como si
fuera una burbuja en un vaso de refresco con gas.

A continuación se muestra un ejemplo, que representa una lista de números,

antes, durante las sucesivas comparaciones y a la terminación del algoritmo de la
burbuja. Se van realizando diferentes iteraciones hasta que la lista se encuentra
ordenada totalmente en orden ascendente.

Algoritmo Burbuja
const // Declaración del tipo de dato y la constante para el límite superior
entero max ← 100 // límite superior del arreglo
tipo
arreglo vector de entero [1..max] // declaración del tipo arreglo Vector
var
vector A // declaración de la variable A de tipo arreglo, donde se hará la búsqueda
entero valor, i, j, aux
inicio
para i ← 1 hasta max - 1 hacer
para j← 1 hasta max - 1 hacer
si A[j] > A[j+1] entonces
aux ← A[j]
A[j] ← A[j+1]
A[j+1] ← aux
fsi
fpara
fpara fin
EJERCICIOS PROPUESTOS

1. Calcula la matriz traspuesta de una matriz de enteros. La matriz tendrá unas

dimensiones máximas según la constante MAX.
2. Generar un arreglo Arreglo1, que contenga el promedio entre el elemento
menor de cada fila y el menor de cada columna de una matriz A.
3. Crear un arreglo Arreglo2, que guarde la posición o índice del menor
elemento de cada columna de la matriz A y guarde cuántos elementos de la
columna son iguales al menor (es decir, cuántas veces se repite el menor en
esa columna).
4. Diseñar un algoritmo que permita introducir un vector de 10 números enteros,
calcular su suma y el valor máximo
5. Dados dos arreglos A y B de longitud n y m respectivamente, cuyos
elementos no se repiten. Crear un nuevo arreglo resultado de la suma de A
con B. Crear un nuevo arreglo producto de la multiplicación de A con B. Dado
un entero x, determinar si éste pertenece a ambos arreglos. Por último,
determinar si A = B.

CADENA DE CARACTERES (STRING)

Las cadenas de caracteres son vectores de tipo carácter (char) que reciben un
tratamiento especial en algunos lenguajes de programación como el C, para simular
el tipo de datos “string”, el cual si está presente en lenguajes como: Java, C#,
Python, entre otros.

Para que un vector de caracteres pueda ser considerado como una cadena de
caracteres, el último de los elementos útiles del vector debe ser el carácter nulo
(código ASCII 0). Según esto, si se quiere declarar una cadena formada por N
caracteres, deberá declararse un vector con N + 1 elementos de tipo carácter. Por
ejemplo, la declaración arreglo cadena de caracter [1..5], reserva suficiente espacio
en memoria para almacenar una cadena de 5 caracteres, como la palabra "tres":
Nombre del arreglo

t r e s \0
num
1 2 3 4 5

En pseudoformal el tipo de dato cadena (string) será considerado una secuencia

de caracteres, sin límite predefinido, es decir, de longitud variable. Las cadenas de
caracteres se tratan como un tipo de dato estándar pero estructurado (arreglo de
caracteres).

En el ejemplo anterior la declaración e inicialización de la variable sería:

Pseudoformal Lenguaje C
var Var
cadena num ← “tres” char num [5] = “tres”
 Las operaciones básicas entre cadenas son: asignación, concatenación y
comparación.

El operador de asignación (←) nos permite asignar una cadena a otra, o una
cadena constante a una variable. Es importante recordar que una cadena constante
es una secuencia de caracteres delimitados por comillas, como “palabra”; a
diferencia de una constante de tipo carácter (char) la cual va delimitada por comillas
simples, como „x‟.

Ejemplo de asignación:

Var
Cadena nombre, nombre2

nombre ← “Leonardo Miguel”

nombre2 ← nombre

El operador de concatenación (+) se utiliza para unir varias cadenas.

Ejemplo de concatenación:

Cad1 ← “este es un ejemplo”

Cad2 ← “de concatenación”
Cad ← Cad1 + Cad2
Escribir(Cad)

Se visualizaría: este es un ejemplo de concatenación

Las comparaciones de las cadenas de caracteres se hacen según el orden de los

caracteres en el código ASCII y con los operadores de relación.

Ejemplo:

merced < mercurio porque e < u

perro < zorro porque p < z
señor < señora tienen el mismo prefijo y la más corta es menor
ANA < ana las mayúsculas tienen menor valor en ASCII (A<a)

También disponemos de algunas funciones que nos brindar gran potencialidad a

la hora de resolver problemas que involucren el manejo de texto, estas son: longitud,
posición y subcadena.

Para conocer la longitud de una cadena, es decir, conocer su número de

caracteres se utiliza la función longitud.
 Ejemplo:
Cad1 ← “este es un ejemplo”
Escribir(“El nro. de caracteres de la cadena es: ” Longitud(Cad1))

Se visualizaría: El nro. de caracteres de la cadena es: 18

Nota: Si la cadena es vacía, su longitud es cero

La función posición nos permite determinar si una cadena está contenida en otra.
En este caso, indicará la posición donde comienza la cadena buscada en la cadena
fuente (la primera aparición). Si la cadena no existe el resultado será 0 (cero).

Ejemplo:

cad1 ← “este es un ejemplo de datos estructurados” subc1

←”es”
subc2 ← “os”
escribir(“La palabra <” subc1 “> está en la posición: ” posicion(cad1,subc1)
escribir(“La palabra <” subc2 “> está en la posición: ” posicion(cad1,subc2)

Se visualizaría: La palabra <es> está en la posición: 1

La palabra <os> está en la posición: 26

Por último, tenemos la función subcadena, la cual retorna una subcadena de la

cadena original formada por todos los caracteres a partir de una posición
dada. Además si se le indica la longitud de la nueva subcadena, sólo retornará
los primeros caracteres a partir de la posición indicada.

Ejemplo:

cad ← “algunos ejemplos de cadenas”

subc1 ←subcadena(cad, 9)
subc2 ← subcadena(cad, 9, 8) // retorna la cadena a partir de la posición 9
escribir(“Nueva subcadena: ” subc1) de longitud 8 caracteres
escribir(“Tiene la palabra: ” subc2)

Se visualizaría: Nueva subcadena: ejemplos de cadenas

Tiene la palabra: ejemplos

REGISTROS

Un registro es un tipo de dato estructurado que consta de un conjunto de

elementos que pueden ser del mismo tipo o de tipos diferentes.

Los componentes de un registro se denominan campos. Cada campo tiene un

nombre llamado identificador del campo. Los registros permiten almacenar una serie
de datos relacionados entre sí bajo un nombre y una estructura común.
 En general, los registros permiten almacenar un grupo de elementos bajo un
nombre y un estructura común. Los elementos (campos) de un registro no tienen
que ser homogéneos, de hecho, generalmente son de diferentes tipos. No están
disponibles en todos los lenguajes de programación, razón por la cual muchas veces
es necesario simularlo o definirlo.

Al igual que los arreglos, tenemos dos opciones para declarar este tipo de datos:
declaración directa (por variable) y declaración indirecta (por tipo).

a. Declaración directa o por variable: se declara la variable de tipo registro identificándola

a través de su nombre, se indica la estructura del registro suministrando la definición de sus
campos mediante sus tipos de dato y sus nombres.

Registro <identificador> = // se indica el nombre del registro

<Tipo de dato>1 <Identificador>1
<Tipo de dato>2 <Identificador>2
:
<Tipo de dato>N <Identificador>N
Fregistro
// tipo de dato y nombre del campo 1
// tipo de dato y nombre del campo 2
// tipo de dato y nombre del campo N

Ejemplo: Sea “persona” un registro formado por tres campos: nombre, sexo y
edad. Su representación queda de la siguiente manera:

Registro persona =
cadena nombre
carácter sexo
entero edad
Fregistro

b. Declaración indirecta o por tipo: para declarar un tipo de registro definido por el usuario,
se antecede a la especificación la palabra clave Tipo y luego se definen las variables del tipo.
Tipo Registro fecha =
entero día, mes, año
FRegistro

Var
fecha valor

Por otro lado, al igual que los arreglos existen operaciones para manipular los
registros. El operador de asignación (←) facilita su inicialización.

En el ejemplo anterior, la inicialización de valor (variable de tipo fecha) sería:

fecha valor ← { 14, 12, 2009 }

Por otro lado también tenemos el operador selector, representado por un punto
( . ), mediante el cual podemos acceder directamente a cada campo del registro.

Ejemplo: valor. mes ← 10 valor.dia ← 31

nombre del registro nombre del campo

EJEMPLO DE REGISTROS

1. El gerente de una empresa de computación está interesado en el desarrollo de

un sistema que permita manejar cierta información de sus empleados. Para
cada empleado se requiere el nombre, apellido, cédula de identidad, edad y
cargo (programador, analista o jefe de proyecto).Tipo de empleado (fijo o
contratado), sueldo mensual y antigüedad en la empresa.
• Diseñar una estructura de datos que permita almacenar la información
asociada a los empleados de la empresa. Suponer que el número de
empleados es constante.
• Elaborar un algoritmo que aumente en un 20% el sueldo de los empleados
fijos con una antigüedad mayor o igual a 10 años y que aumente el sueldo en
un 5% a todos los empleados contratados.

Diseño de la estructura de datos

Identificar los elementos a modelar.
Nombre tipo cadena
Apellido tipo cadena
Cedula tipo entero
Edad tipo entero
Cargo tipo enumerado (Programador, Analista, Jefe_proyecto)
Tipo de empleado tipo enumerado (Fijo, Contratado)
Sueldo tipo real
Antigüedad tipo real

Algoritmo Ejemplo_registros

Tipo
Tcargo = (programador, analista, jefe_proyecto);
Templeado = (fijo, contratado);
registro persona =
cadena nombre
cadena apellido
entero cedula
entero edad
Tcargo cargo
Templeado empleo
real sueldo
real antiguedad
fregistro
arreglo empleado de persona [1 .. 200]
var
empleado EMP
entero i
inicio
para i ← 1 hasta 200 hacer
si EMP[i].empleo = “fijo” entonces
si EMP[i].antiguedad ≥ 10 entonces
EMP[i].sueldo ← EMP[i].sueldo + (0.20 ∗ EMP[i].sueldo)
fsi
sino
EMP[i].sueldo ← EMP[i].sueldo + (0.05 ∗ EMP[i].sueldo)
fsi
fpara
fin
Nota: Queda como ejercicio culminar el algoritmo.
TABLA DE EQUIVALENCIAS PARA CONVERSION DE PSEUDOCODIGO A PROGRAMAS EN LENGUAJE C

Estructura de un pseudocódigo Estructura de un programa en lenguaje C

pseudocódigo //titulo del programa
titulo del pseudocódigo //autor

Inicio #include <stdio.h>

#include <stdlib.h>
//Declaracion de Variables y Constantes
int main()
//Datos de entrada {
//Declaracion de Variables y Constantes
//Proceso
//Datos de entrada
//Datos de salida
//Proceso
Fin del pseudocodigo
//Datos de salida

printf("\n");
system("pause");
return 0;

}//fin del main()

Declaraciones pseudocódigo Declaraciones en lenguaje C
entero a int a;
real b float b;
cadena nom char nom[30];
nota: el número entre los corchetes representa la
longitud máxima de la cadena.
caracter resp char resp;
Representación de la orden LEER en Funciones para leer en lenguaje C
pseudocódigo de acuerdo a los diferentes tipos
de datos
entero a leer a scanf("%d", &a);
real b leer b scanf("%f", &b);
cadena nom leer nom gets(nom);
caracter resp leer resp scanf("%c", &resp); o también resp=getchar();
Para imprimir un texto pidiendo un dato en Funcion para imprimir un texto pidiendo un
pseudocodigo dato en lenguaje C
imprimir "Dame el valor de x: " printf( "\nDame el valor de x: ");

Nota: \n indica un salto de línea o return

 TABLA DE EQUIVALENCIAS PARA CONVERSION DE PSEUDOCODIGO A PROGRAMAS EN LENGUAJE C

Representación de la orden IMPRIMIR en Función para imprimir en lenguaje C

pseudocódigo de acuerdo a los diferentes
tipos de datos
entero a imprimir "el valor de a es ", a printf("\nel valor de a es %d", a);
real b imprimir "el valor de b es ", b printf("\nel valor de b es %f", b);
cadena nom imprimir "el nombre es ", nom printf("\nel nombre es %s", nom);
caracter resp imprimir "la respuesta es ", resp printf("\nla respuesta es %c", resp);
Combinando la impresión de más de un dato
cadena nom imprimir "nombre es: ", nom, “ printf ("\n nombre es: %s sueldo es: %f ", nom,
real sueldo sueldo es: ", sueldo sueldo);

entero a=5; res=a+b res=a+b;

entero b=6; imprimir a, "+",b, "=",res printf("\n%d + %d = %d", a,b,res);
entero res;

Impresión de CADENAS en pseudocodigo Función para imprimir CADENAS en lenguaje

C
cadena descripcion char descripcion[40]; //declara cadena

leer cadena; gets(cadena); // lee una cadena

imprimir "La descripcion del articulo es: ", PRIMERA OPCION: printf()
descripcion printf("\n La descripción del articulo es %s: ",
descripción);

Observar que la función printf() permite

imprimir a la vez texto y variables.

SEGUNDA OPCION: puts()

puts("La descripción del articulo es");
puts(descripción);

Reglas para el uso de puts()

1 Solo funciona con CADENAS
2 Solo imprime UN TEXTO o UNA VARIABLE a la
vez.
3 La función incluye un salto de línea al inicio.
No es necesario teclear \n
 TABLA DE EQUIVALENCIAS PARA CONVERSION DE PSEUDOCODIGO A PROGRAMAS EN LENGUAJE C

Representación de constantes en pseudocódigo Representación de constantes en lenguaje C

Usando la directiva del preprocesador define.
(se teclea abajo de los #include )

constante real PI=3.14 #define PI 3.14 //no lleva ;

Representación de una condición en Representación de una condición en lenguaje

pseudocódigo C
si ( condición ) if ( condicion ) //no lleva ;
------------ {
------------ ------------
sino ------------
------------ }
------------ else
fin si {
------------
------------
}

Nota: Cuando se ejecuta UNA SOLA línea de

código ya sea en la parte verdadera o falsa de
la condición. Es válido omitir las llaves.
Ejemplo:

if ( a>b)
mayor=a;
else
mayor=b;

Representación de un si múltiple en pseudocódigo Representación de un si múltiple en LENGUAJE C

Si ( variable ) switch ( variable ) //no lleva ;
caso __: ----------------- {
----------------- case __: -----------------;
Romper -----------------;
caso __: ----------------- break;
----------------- case __: -----------------;
Romper -----------------;
caso __: ----------------- break;
----------------- case __: -----------------;
Romper -----------------;
sino break;
-------------- default:
----------------- --------------;
Fin si múltiple ----------------;
}

Nota: El si múltiple solo funciona con variables de Nota: El switch solo funciona con variable de tipo
tipo entero o caracter int o char
 TABLA DE EQUIVALENCIAS PARA CONVERSION DE PSEUDOCODIGO A PROGRAMAS EN LENGUAJE C

Representación de un ciclo repetir mientras y Representación de un ciclo repetir mientras y

mientras para ciclar una solución en mientras para ciclar una solución en
pseudocódigo LENGUAJE C

carácter resp char resp;

repetir do{
-------- --------
-------- --------
-------- --------
-------- --------
imprimir “otra vez s/n” printf("\n Ejecutar otra vez s/n: ");
leer resp scanf("%c", &resp);
mientras (resp='s ' or resp='S') }while (resp =='s' || resp=='S'); //no olvidar ;

Nota: La comparación de igualdad en lenguaje C se

hace con doble igual

carácter resp='s' char resp='s';

mientras (resp='s' or resp='S ') while (resp =='s' || resp=='S')
-------- {
-------- --------
-------- --------
-------- --------
imprimir "otra vez s/n" --------
leer resp printf("\n Ejecutar otra vez s/n: ");
fin mientras scanf("%c", &resp);
}

Representación de un ciclo mientras en Representación de un ciclo mientras en

pseudocodigo LENGUAJE C
mientras( condición ) while ( condición ) //no lleva ;
-------- { --------
-------- --------
-------- --------
-------- --------
fin mientras }
Representación de un ciclo repetir - mientras Representación de un ciclo repetir - mientras
en pseudocodigo en LENGUAJE C
Repetir do {
-------- --------
-------- --------
-------- --------
-------- --------
mientras( condición ) } while ( condición );
 TABLA DE EQUIVALENCIAS PARA CONVERSION DE PSEUDOCODIGO A PROGRAMAS EN LENGUAJE C

Representación de un ciclo repetir desde en Representación de un ciclo repetir desde en

pseudocodigo LENGUAJE C
repetir desde i=1 mientras i<=n incrementos 1 for (i=1; i<=n; i++) //no lleva ;
-------- { --------
-------- --------
-------- --------
-------- --------
Fin repetir desde }

Asignación de cadenas en pseudocódigo Asignación de cadenas en lenguaje C

cadena articulo char articulo[30];

cadena auxArticulo char auxArticulo[30];

leer articulo gets(articulo);

//Asignar el valor de articulo a auxArticulo //Asignar el valor de articulo a auxArticulo

auxArticulo=articulo strcpy(auxArticulo,articulo)
//Asignar blusa a articulo //Asignar blusa a articulo
articulo="blusa" strcpy(articulo, "blusa")

Nota: Para que la función strcpy() trabaje es

necesario incluir la biblioteca.

#include <string.h>
Comparación de cadenas en pseudocódigo Comparación de cadenas en lenguaje C

cadena articulo1 char articulo1[30];

cadena articulo2 char articulo2[30];

leer articulo1 gets(articulo1);

leer articulo2 gets(articulo2);

si (articulo1 = articulo2) if (strcmp(articulo1,articulo2) == 0 )

imprimr "artículos iguales" printf("\n artículos iguales");
sino else
imprimir "artículos diferentes" printf("\n artículos diferentes");
fin si
Nota:
La función strcmp() regresa un 0 cuando las
cadenas que se comparan son iguales.

Para que la función strcmp() trabaje es

necesario incluir la biblioteca.

#include <string.h>
 TABLA DE EQUIVALENCIAS PARA CONVERSION DE PSEUDOCODIGO A PROGRAMAS EN LENGUAJE C

Operadores aritméticos en pseudocódigo Operadores aritméticos en LENGUAJE C

* *
+ +
- -
mod CAMBIA POR %

/ /

^ CAMBIA POR pow(base,exponente)

nota:
ejemplo: 23 pow(2,3)

para utilizar la función pow es necesario incluir al inicio

del programa la siguiente línea:

#include <math.h>

Operadores relacionales en pseudocódigo Operadores relacionales en LENGUAJE C

> >
>= >=
< <
<= <=
<> CAMBIA POR !=
= CAMBIA POR ==

NOTA: NO confundir el operador relacional == con el OPERADOR DE ASIGNACION =

El primero se usa en condiciones (Ejemplo Si (a == b) ), el segundo se utiliza para asignaciones

( x =23) o en formulas (x = PI*r^2)

Operadores lógicos en pseudocódigo Operadores lógicos en LENGUAJE C

and CAMBIA POR &&

or CAMBIA POR ||
not CAMBIA POR !
Ejercicios resueltos