Manual de Pseudocodigo y Programacion Estructurada Ariel Villar PDF

Manual de Pseudocódigo – Programación Estructurada
Introducción
El presente trabajo es una recopilación y adaptación de obras dedicadas a la

enseñanza de la programación Estructurada.
La presente obra está realizada para fines solamente educativos, y la difusión

gratuita del conocimiento.
“Lo que gratis recibes, dalo también gratis…”
Prof. Ariel Villar
Recopilación Prof. Ariel Villar 2

ÍNDICE GENERAL
Introducción ............................................................................................................................................. 2
Introducción a la Programación ............................................................................................................... 4
Definición intuitiva de Programa ......................................................................................................... 6
Variables y Operadores ............................................................................................................................ 9
Asignaciones .......................................................................................................................................... 13
Entrada y Salida de Información ............................................................................................................ 15
Resolución de Problemas ....................................................................................................................... 17
Contador ................................................................................................................................................. 19
Acumulador o Sumador ......................................................................................................................... 19
Estructuras de Selección......................................................................................................................... 20
Estructuras Repetitivas ........................................................................................................................... 25
Estructura Mientras ............................................................................................................................ 28
Estructura Repetir ............................................................................................................................... 29
Vectores .............................................................................................................................................. 31
Matrices .............................................................................................................................................. 35
Funciones y Procedimientos................................................................................................................... 41
Funciones ........................................................................................................................................... 42
Procedimientos ................................................................................................................................... 46
Pseudocódigo ......................................................................................................................................... 48
Introducción a la programación - Autor: Lola Cárdenas Luque ............................................................ 55
Estructuras de control; secuenciales y selectivas ............................................................................... 56
Asignaciones ...................................................................................................................................... 57
Alternativas dobles ............................................................................................................................. 59
Alternativas múltiples ........................................................................................................................ 60
BIBLIOGRAFÍA .................................................................................................................................... 63

Introducción a la Programación
INTRODUCCIÓN:
Muchas veces el término programación puede llegar tener interpretaciones tan variadas como confusas. Lo
cierto es que la programación en el ser humano es tan connatural de lo que pensamos. Los programas de
computadoras pueden ser comparados como una receta de cocina. Si Ud. tiene un problema a resolver y
quiere realizar la preparación de un huevo frito, deberá seguir las instrucciones que diga la receta para ese tipo
de preparación, es decir, se deberá respetar una serie de pasos para llegar a la preparación del plato de
cocina. Estos pasos deben respetarse siguiendo un camino lógico, porque de lo contrario, si no se respetase
no se podría llegar al fin que es la preparación del plato. Por ejemplo, para preparar una tortilla de papa la
receta podría ser:
1. Encender la hornalla de la cocina.

2. Colocar el aceite al sartén.
3. Colocar el sartén en la hornalla encendida.
4. Esperar que el aceite se caliente.
5. Tomar un huevo.
6. Partir el huevo.
7. Volcar la clara y la yema.
8. Esperar hasta que el huevo se frite y tome color blanco la clara.
9. Sacar el huevo frito con la espátula.
10. Colocar el huevo frito en un plato.
11. Colocar sal a gusto.
12. Apagar la hornalla de la cocina.
13. Etc.
Ahora bien, si en estos pasos que nos indica la receta, llegáramos a invertir o permutar cualquiera de sus
pasos, se podría correr el riesgo de no llegar a concluir la preparación de la comida propuesta, es decir, no se
llegaría al fin propuesto. Es decir que las recetas se pueden definir con el conjunto de pasos, ordenados con un
criterio adecuado, para cumplir un determinado fin. Lo mismo ocurre con los programas informáticos, también
son un conjunto de instrucciones ordenadas lógicamente, que el computador es capaz de interpretar, con el fin
de conseguir un fin determinado.
Para ilustrar, otro ejemplo de la vida cotidiana, se verá el caso de los pasos que realizamos para ver una
película de vídeo, podría hacer:
1. Elijo una película de las de mi colección.

2. Compruebo SI TV y vídeo están conectados a la red (y procedo).
3. SI la TV está apagada, la enciendo, SI NO, pues no. Y lo mismo con el vídeo.
4. Abro el estuche de la película.
5. Saco la película de su estuche.
6. Introduzco la película en el vídeo. Dejo el estuche sobre el vídeo.
7. SI la TV no está en el canal adecuado, la cambio, SI NO, pues no.
8. Cojo los mandos a distancia (el del TV y el del vídeo).
9. Me pongo cómodo.
10. Pulso PLAY en el mando del vídeo.
De los dos ejemplos propuestos, ambos poseen cosas en común:
1. La descripción de cada paso no me lleva a ambigüedades: los pasos son absolutamente explícitos
y no inducen a error.
2. El número de pasos es finito.
Ejercicio Grupal:
En grupo de hasta 4 alumnos, deberán dar un ejemplo de la vida cotidiana donde se deberá detallar los pasos
a seguir para cumplir el fin del ejemplo propuesto.

Hasta aquí, han aparecido conceptos muy significativos para introducirnos en el mundo de la programación,
ellos son: conjunto, secuencia, orden, problema, ambigüedad, etc.
De ahí que nace un concepto que se puede abarcar de manera intuitiva, y es el concepto de Algoritmo. Se
puede considerar al Algoritmo como la series de pasos a seguir, ordenados lógicamente de acuerdo a un
criterio determinado, con el fin de resolver un problema concreto.
¿QUÉ ES UN ALGORITMO?
Esta palabra se deriva MUSA AL-KHOWARIZMI, nombre de un matemático árabe que vivió en el siglo IX. El
diccionario de la RAE lo define como el “método y notación en las distintas formas de cálculo”.
La conceptualización algoritmo, para los fines de éste curso, se va a definir como el conjunto de operaciones
perfectamente especificadas y ordenadas, cuyo objeto es obtener un resultado partiendo de unos datos a fin de
resolver un problema concreto.
Ejemplo 1:
¿Cuál es el algoritmo que nos permite conocer la superficie de un rectángulo

teniendo como datos los lados (alto y largo)?
Solución:
S: superficie del cuadrado.
A: longitud en alto.
T: longitud en ancho.
Entonces el algoritmo buscado es: S= A x T .
Conclusión: Este modelo de algoritmo representa la solución para hallar cualquier superficie de
un rectángulo conociendo sus dos lados.
“S”, “A” y “T” son las variables de nuestro algoritmo porque las mismas varían según el valor
que le asignemos a “A” y “T”.
En este ejemplo “A” y “T” se denominan variables independientes porque a dichas variables se
le pueden asignar valores arbitrarios o al azar.
A la variable “S”, se la denomina variable dependiente porque “depende” su valor del valor
asignado por las variables independientes.
Por ejemplo: si A=3 y T=4, entonces S=12; en cambio, si A=8 y T=9, entonces S=72.
Ejemplo 2:
La superficie de un triángulo es base por altura, todo divido por dos.
La representación de un algoritmo podría ser:
R: Superficie del triangulo

A: Altura
B: Base
Entonces el algoritmo buscado es R= (B x A) / 2 .
Por analogía del ejemplo 1, podemos decir que R, A, B son la variables de nuestro algoritmo (porque
se valor varían dependiendo del ejemplo que busquemos).
Las variables B y A son variables independientes, y la variable R es dependiente.
Ahora, bien, el valor “2”, dentro del algoritmo, siempre va a seguir siendo “2”. Decimos pues, que el 2
de nuestro algoritmo es una constante del problema porque nunca va a variar su valor.
A saber, siempre en un algoritmo aparecen dos elemento fundamentales las constantes y las variables.

Definición intuitiva de Programa

¿QUÉ ES UN PROGRAMA?
Si llevamos la lógica que un algoritmo es un “camino” que nos conduce a la resolución de un problema;
podemos decir que la aplicación de un algoritmo a la informática se denominaría PROGRAMA DE
COMPUTACIÓN.
ALGORITMO PROGRAMA
Entonces, en un programa de computación se pueden aplicar todos los conocimientos apropiados sobre
algoritmos como ser: variables, constantes, operadores, expresiones. Lo nuevo que se agrega al concepto de
programa es término “Palabra Reservada”. Una palabra reservada debe ser clara y precisa; y es aquella capaz
de ser reconocida por el computador y llevar a cabo (una orden) durante la ejecución de un programa
informático.
En sentido amplio, podemos decir que
Programa: es un secuencia de órdenes claras y precisas ordenadas dadas al computador, que puede ser
capaz de cumplirlas para resolver un problema.
Orden 1
Orden 2 PROGRAMA
Orden 3
...
Orden n
¿Porqué decimos que es una secuencia de Órdenes claras y precisas?

Rta. Porque las ordenes que se dan en un programa deben ser de manera que no contengan lugar a
una doble interpretación, por ejemplo
Si en la vida cotidiana digo la orden: siéntate...!!!
Entonces la persona al cual yo estoy ordenando puede cumplir mi orden sentándose en una silla, o en el suelo, o en la mesa,
etc.
En cambio si digo: Siéntate en esta silla de madera... , entonces se podrá cumplir la orden sin lugar a dudas.
¿Porqué decimos que los comandos, órdenes o instrucciones deben estar ordenadas?
Rta. Veamos con un ejemplo: si en la vida cotidiana necesitamos poner en marcha el arranque de un automóvil, el número
los pasos serían:
1. Abrir la puerta
2. Sentarse
3. Colocar la llave en el tambor
4. Dar arranque
5. Escuchar que el motor arranque
6. Se encendió el motor.
Analicemos (descompongamos) nuestro ejemplo. Lo hemos divido en 6 pasos básicos, asumiendo que se pueden subdividir
en muchos mas, ahora nos preguntamos ¿qué pasaría si permutamos el paso 3 por el 1 y el 4 por el 6? ¿Podríamos cumplir
con nuestro fin...?
Lo mismo pasa con nuestros programas, el conjuntos de ordenes que hacemos deben tener un orden lógico u ordenado o
con algún sentido, de manera tal que al ser ejecutado por el procesador de nuestro computador obtengamos como resultado
un programa coherente.
OTRA DEFINICION DE PROGRAMA

Fuente: http://www.wikipedia.org Edición Española digita, 2010.
Un programa informático es un conjunto de instrucciones que una vez ejecutadas realizarán

una o varias tareas en una computadora. Sin programas, estas máquinas no pueden funcionar
[1] [2]
correctamente. Al conjunto general de programas, se le denomina software y así, se refiere
al equipamiento lógico o soporte lógico de una computadora digital.
En informática, se los denomina comúnmente binarios, (propio en sistemas unix, donde debido
a la estructura de este último, los ficheros no necesitan hacer uso de extensiones.
Posteriormente, los presentaron como ficheros ejecutables, con extensión .exe, en los sistemas
operativos de la familia Windows) debido a que una vez que han pasado por el proceso de
compilación y han sido creados, las instrucciones que se escribieron en un lenguaje de
programación que los humanos usan para escribirlos con mayor facilidad, se han traducido al
único idioma que la máquina comprende, combinaciones de ceros y unos llamada código
máquina. El mismo término, puede referirse tanto a un programa ejecutable, como a su código
fuente, el cual es transformado en un binario cuando es compilado.
Generalmente el código fuente lo escriben profesionales conocidos como programadores. Se
escribe en un lenguaje que sigue uno de los siguientes dos paradigmas: imperativo o
declarativo y que posteriormente puede ser convertido en una imagen ejecutable por un
compilador. Cuando se pide que el programa sea ejecutado, el procesador ejecuta instrucción
por instrucción.
De acuerdo a sus funciones, se clasifican en software de sistema y software de aplicación. En
los computadores actuales, al hecho de ejecutar varios programas de forma simultánea y
eficiente, se le conoce como multitarea.

PSEUDOCÓDIGO
¿Qué es el PseudoCódigo? ¿Para qué sirve?...
Veamos un ejemplo, de la vida cotidiana….
Aller travailler à Andare a
Go work at sept heures du lavorare alle
Ve a trabajar a las seven in the soir. sette di sera.
siete de la tarde... evening. Francés Italiano
Español Inglés
Una persona que habla varios idiomas. Pero el pensamiento de dar el mensaje que la persona tenga que ir a trabajar a la
tarde es Universal.
De la misma manera ocurre en el Mundo de la programación…
Mostrar. Pantalla “Hola Mundo”
En este ejemplo, vemos aun programador que quiere mostrar por pantalla un Mensaje “Hola Mundo”, ese pensamiento o
estructura universal se denomina PseudoCódigo. Después, él elegirá el Lenguaje de Programación (Idioma) que más sea
apropiado según sea el caso.
Definición Formal de PseudoCódigo:

En ciencias de la computación, y análisis numérico el pseudocódigo (o falso lenguaje) es una descripción informal1 de alto nivel de un algoritmo
informático de programación, compacto e informal, que utiliza las convenciones estructurales de un lenguaje de programación verdadero2 , pero que está
diseñado para la lectura humana en lugar de la lectura mediante máquina, y con independencia de cualquier otro lenguaje de programación. Normalmente,
el pseudocódigo omite detalles que no son esenciales para la comprensión humana del algoritmo, tales como declaraciones de variables, código específico
del sistema y algunas subrutinas. El lenguaje de programación se complementa, donde sea conveniente, con descripciones detalladas en lenguaje natural, o
con notación matemática compacta. Se utiliza pseudocódigo pues este es más fácil de entender para las personas que el código de lenguaje de
programación convencional, ya que es una descripción eficiente y con un entorno independiente de los principios fundamentales de un algoritmo. Se
utiliza comúnmente en los libros de texto y publicaciones científicas que se documentan varios algoritmos, y también en la planificación del desarrollo de
programas informáticos, para esbozar la estructura del programa antes de realizar la efectiva codificación. No existe una sintaxis estándar para el
pseudocódigo, aunque los cincos IDE's que manejan pseudocódigo tengan su sintaxis propia. Aunque sea parecido, el pseudocódigo no debe confundirse
con los programas esqueleto que incluyen código ficticio, que pueden ser compilados sin errores. Los diagramas de flujo y UML pueden ser considerados
como una alternativa gráfica al pseudocódigo, aunque sean más amplios en papel.
 Peña Marí, Ricardo (2005) (en español). Diseño de programas: formalismo y abstracción (3 edición). Pearson Alhambra. pp. 488. ISBN 978-
84-205-4191-4.
 (en español) Pseudocódigos y programación estructurada (1 edición). Centro Técnico Europeo de Enseñanzas Profesionales. 2 de 1997. ISBN
978-84-8199-065-2.
 Brassard, Gilles; Bratley, Paul (1996) (en español). Algorítmica: concepción y análisis. Peña Mari, Ricardo Tr. (1 edición). Masson, S.A.. pp.
384. ISBN 978-84-458-0535-0.
 Rodeira, ed (6 de 1994) (en Gallego). Pseudocódigos e programación estructurada (1 edición). ISBN 978-84-8116-287-5.
 Edebé, ed (8 de 1993) (en español). Pseudocódigos y programación estructurada (1 edición). ISBN 978-84-236-3126-1.

Variables y Operadores
Datos y Tipos de Datos
Las cosas se definen en la computadora mediante datos, los algoritmos que vamos a
diseñar van operar sobre esos datos. A nivel de la máquina los datos se representan como
una serie de bits (dígito 1 ó 0). Los tipos de datos que vamos a manejar a lo largo del tutorial
son: numéricos y carácter (también llamados alfanuméricos), existen además, los datos de
tipo lógicos que solo pueden tener uno de dos valores : verdadero o falso.
Datos Numéricos
Los datos numéricos pueden ser de varias clases: enteros, enteros largos, de doble
precisión, de simple precisión, de coma flotante, reales; cuya definición depende del
lenguaje de programación utilizado.
Ejemplos: 1,0,-5,12.432, …
Datos Alfanuméricos – o String – o Tipo Cadena de Caracteres:
Los datos de tipo carácter o alfanuméricos están compuestos por el conjunto finito y
ordenado de caracteres que la computadora reconoce:
Ejemplos:
 caracteres alfabéticos : A,B,C,.......Z ; a,b,c,.......z
 caracteres numéricos : 0,1,2, ......9 (que no son números)
 caracteres especiales : +, /, *, ?,%,$, #, !, ,ä,¦,{},~,etc.
Una cadena de caracteres o string es una sucesión de caracteres que se encuentran

delimitados por comillas ( " " ). La longitud de la cadena es la cantidad de caracteres que la
forma, incluyendo los espacios que son un carácter más. Así:
"Asunción, Paraguay" es una cadena de longitud 18
"Miércoles 7 de Marzo de 2001" es una cadena de longitud 28 (el 7 y el 2001 no son números)
"123456" es una cadena de longitud 6.
Nota: no es el número 123.456 sobre "123456" no se puede realizar
ninguna operación aritmética como sumar, restar, etc, ya que se trata
de una cadena alfanumérica.
Variables
Cuando representamos datos, numéricos o alfanuméricos, debemos darles un

nombre. Una variable es un nombre que representa el valor de un dato.
En esencia, una variable es una zona o posición de memoria en la computadora donde se
almacena información. En un pseudocódigo y también en un programa se pueden crear
tantas variables como queramos. Así tenemos:
A = 50; Variable tipo numérica A cuyo valor es 50.
Ciudad = "Asunción"; Variable alfanumérica o de tipo carácter Ciudad, cuyo valor es "Asunción"
X = C + B; Variable numérica X cuyo valor es la suma de los valores de las variables numéricas C y B.
Es una variable calculada
Ten en cuenta que las operaciones que se pueden realizar con dos o más variables
exigen que éstas sean del mismo tipo. No podemos "sumar", por ejemplo una variable
alfanumérica a otra numérica y viceversa como por ejemplo:
FechaNueva="1 de Junio de 1.971" + 5 Esto no se puede hacer!!
Importante: No se pude juntar numérico con alfanumérico. Analogía: No se puede juntar

papa con camote.
Normas para dar nombres a las Variables

Para dar nombres a las variables hay que seguir ciertas reglas:
 Pueden tener hasta 40 caracteres
 Debe empezar obligatoriamente con una letra (a-z o A-Z)
 No pueden contener espacios en blanco
 El resto de los dígitos pueden ser números
 Se pueden incluir caracteres especiales como el guión o el punto.
Ejemplos de nombres válidos de variables

FechaNueva
C1
totalGuaranies
CONTADOR-5
H123
cantidad_de_Alumnos
Pedido.Almacen
Ejemplos de nombres de variables NO válidos

Fecha nueva
1contador
24ABC
primer-valor N
Algunos lenguajes de programación exigen la declaración de las variables que se van

a utilizar en todo el programa; es decir, que al comenzar el programa se debe decir que
nombre tiene, de que tipo es (numérica o alfanumérica) y un valor inicial. Como aquí no
estamos tratando con ningún lenguaje, la declaración de las variables puede omitirse.
Las variables también pueden inicializarse; darles un valor inicial. Por defecto, todas
las variables para las que no especifiquemos un valor inicial, valen cero si son de tipo
numérica y nulo (nulo no es cero ni espacio en blanco; es nulo) si son de tipo carácter.
Operaciones
Las variables se pueden procesar utilizando operaciones apropiadas para su tipo.
Los operadores son de 4 clases:

OPERADORES
Relacionales
Aritméticos
Alfanuméricos
Lógicos
Los operadores relacionales se utilizan para formar expresiones que al ser
evaluadas producen un valor de tipo lógico: verdadero o falso. Ellos son:
Signo Operador
> Mayor que
< Menor que
= Igual a
<= Menor o igual que
>= Mayor o igual que
<> Distinto
Ejemplos:
Ejemplo Resultado
25 <= 25 Verdadero
25 <> 25 Falso
25 <> 4 Verdadero
50 <= 100 Verdadero
500 >= 1 Verdadero
1=6 Falso
Cuando se comparan caracteres alfanuméricos se hace uno a uno, comenzando por
la izquierda hacia la derecha.
Si las variables son de diferente longitud, pero exactamente iguales, se considera que
la de menor longitud es menor.
Los datos alfanuméricos son iguales si y solo si tienen la misma longitud y los mismos
componentes.
Las letras minúsculas son mayores que las mayúsculas y cualquier caracter numérico
es menor que cualquier letra mayúscula o minúscula; Así:
carácter numérico < mayúsculas < minúsculas.
Ejemplos:
Comparación Resultado
"A" < "B" Verdadero
"AAAA" > "AAA" Verdadero
"B" > "AAAA" Verdadero
"C" < "c" Verdadero
"2" < "12" Falso
Estas comparaciones se realizan utilizando el valor ASCII de cada carácter
Para tratar los números se utilizan los operadores aritméticos:
Signo Significado
+ Suma
- Resta
* Multiplicación
/ División
^ Potenciación
MOD o ENT Resto de la división entera
El único operador alfanumérico se utiliza para unir o concatenar datos de este tipo:
Signo Significado
+ Concatenación
Ejemplos:
Expresión Resultado
"Pseudo" + "código" "Pseudocódigo"
"3" + "4567" "34567"
"Hola " + "que tal ?" "Hola que tal ?"
Los operadores lógicos combinan sus operandos de acuerdo con las reglas del álgebra de
Boole para producir un nuevo valor que se convierte en el valor de la expresión, puede ser
verdadero o falso.
Signo Significado
OR Suma lógica (O)
AND Producto lógico (Y)
NOT Negación (NO)
Ejemplos:
Expresión Resultado
Verdad AND Falso Falso
NOT Falso Verdad
Verdad OR Falso Verdad
Por ejemplo, la expresión:

 (12 + 5) OR (7 + 3) = 10 es verdadera (se cumple una y Verdad OR Falso es Verdad)
 La expresión (12 * 5) AND (3 + 2) = 60 es falsa (verdad AND falso = Falso).
¿Cómo se evalúan los operadores? La prioridad de los operadores es:

 Paréntesis (de adentro hacia afuera)
 Potencias
 Productos y Divisiones
 Sumas y restas
 Concatenación
 Relacionales
 Lógicos
Ejemplo:
Importe=55
saldo=2000
edad=30
sexo=1
((saldo>20 AND importe<100) OR (edad<>0 AND sexo=1)) &&expresión original

((saldo>20 AND importe<100) OR (edad<>0 AND sexo=1)) && paréntesis
((saldo>20 AND importe<100) OR (edad<>0 AND sexo=1)) &&relaciones
((saldo>20 AND importe<100) OR (edad<>0 AND sexo=1)) &&lógicos

Asignaciones
La operación de dar valor a una variable se llama asignación. La asignación vamos a

representarla con el símbolo:
 <<= una flecha apuntando a la izquierda.
  En algunos software se designa con la flecha común
 Nota: No utilizaremos en signo = ya que el operador de asignación varía de
acuerdo con el lenguaje de programación utilizado.
 Veremos varias posibilidades de anotación)

 nombre_variable <<= expresión
 nombre_variable  expresión (Por ejemplo en Pseint)
 nombre_variable = expresión (Ejemplo en Foxpro)
La flecha se sustituye en los lenguajes de programación por = (basic); : = (foxpro).

Pero para evitar ambigüedades en el pseudocódigo utilizaremos la flecha para la asignación
y el símbolo = para indicar igualdad. He aquí algunos ejemplos:
A  100; significa que a la variable A se le ha asignado el valor 100, ahora A vale 100.
suma  5+10; asigna el valor 15 a la variable suma a través de una asignación aritmética.
x  (z + v); asigna el valor de la suma de las variables z y v a la variable x. El resultado depende de los
valores que se asignen a x y a z
Importante:
 Toda asignación es destructiva.
 Esto quiere decir que el valor que tuviera antes la variable se pierde y se reemplaza
por el nuevo valor que asignamos, así cuando se ejecuta esta secuencia:
o B  25
o B  100
o B  77
Significa que el valor final que toma B será 77 pues los valores 25 y 100 han sido
destruidos.
Cuando una variable aparece a ambos lados del símbolo de asignación como:
CC+1
Consejos:
 Conviene inicializarlas al comenzar el programa con cero, aunque no es
obligatorio por ahora (en algunos lenguajes de programación sí es necesario).
 Recordemos que no se pueden asignar valores a una variable de un tipo
diferente al suyo.
Pongamos atención a este ejemplo de asignaciones:

AA+2*B
BC-A
Supongamos que A toma el valor 3 y B el valor 4.

C  A+2*B
La expresión tomará el valor 3 + 2 * 4 = 3 + 8 = 11

C vale entonces 11.

BC–A
C vale 11, A vale 3, por lo tanto B valdrá 11 - 3 = 8

Como toda asignación es destructiva, el valor anterior de B se pierde y pasa a valer
ahora 8.
Otro ejemplo:
J J*3
¿Qué valor tiene J al final ? Veamos.
Primero se asigna 33 a la variable J, J vale entonces 33; luego:
J <<= J + 5
Esto es: Sumar 5 al valor de J y asignarlo a la variable J. J vale 33.

J  33 + 5 ; J  38
J vale ahora 38.
El valor anterior que era 33 se destruyó.
Seguimos: J  J * 3
Esto es: Multiplicar 3 al valor de J y asignarlo a la variable J.
J <<= 38 * 3 ; J <<= 114
El valor final de J es 114.

Entrada y Salida de Información
Los datos que vamos a obtener del usuario para procesarlos también deben ser
asignados a variables, la operación de lectura, lee un dato y lo asigna a una variable. La
instrucción para la lectura de un dato es leer o también ingresar. Por ejemplo:
leer numero
Esta instrucción pide al usuario un valor que será asignado a la variable numero, es decir, en
numero se almacena el valor ingresado por el usuario.
leer Edad, Peso, Sexo
Representa la lectura de tres valores que se van a almacenar en las variables Edad, Peso y
Sexo; en ese mismo orden.
Ya tenemos nuestro primer comando: leer
Ahora bien, cuando queramos mostrar el resultado del algoritmo, un mensaje, un valor, etc,
vamos a utilizar el comando que muestre los resultados por pantalla. A continuación
mostraremos algunos comandos de salida de pantalla en distintos software o lenguajes:
 Imprimir-mostrar Es el comando general para pseudocódigo
 Escribir Es el comando para Pseint
 @ fila, columna say Es el comando para Foxpro
 printf(“cadena control”, variable); Es el comando para C
 Etc.
Vemos algunos ejemplos en Pseudocógico
imprimir-mostrar "Hola" ; muestra en la pantalla el mensaje Hola, Hola va entre comillas porque es una cadena.
imprimir-mostrar A; muestra en la pantalla el valor que está almacenado en la variable A.
imprimir-mostrar "El valor del promedio es:", promedio

Esta instrucción muestra el mensaje que está entre comillas y luego el valor de la variable promedio. La coma
separa el mensaje de la variable. Si promedio vale 5, lo que se verá en la pantalla será:
El valor del promedio es: 5
Ya conocemos dos comandos que vamos a utilizar en nuestros pseudocódigos: leer e

imprimir-mostrar
También podemos mostrar un mensaje cuando solicitamos algún dato al usuario por
medio del comando leer así:
leer "Ingrese su edad", edad

El valor de la variable que pedimos al usuario se asigna a edad. Esta instrucción se
verá así en la pantalla:
Ingrese su edad
Entonces, en la escritura de pseudocódigos, las acciones de lectura y escritura se

representan por los siguientes formatos:
leer Variable o lista de variables separadas por comas. Ejemplos:
leer Edad
leer Ciudad, País
imprimir-mostrar Variable o lista de variables separadas por comas.
Ejemplos:
Imprimir-mostrar promedio
Imprimir-mostrar TotalMes, TotalAño, TotalGeneral
Imprimir-mostrar "Así se muestra un mensaje o comentario"
En resumen: Las instrucciones disponibles para escribir un programa dependen del lenguaje
de programación utilizado. Existen instrucciones -o acciones- básicas que se pueden
implementar de modo general en cualquier algoritmo y que soportan todos los lenguajes de
programación. Estas son:
1- Instrucciones de inicio/fin
2- Instrucciones de asignación
3- Instrucciones de lectura
4- Instrucciones de escritura
Tipo de Instrucción Pseudocódigo

Comienzo de proceso inicio
Fin de proceso fin
Entrada (Lectura) leer
Salida (Escritura) imprimir o escribir
Asignación <<= o  o = (dependiendo del software que utilicemos)

Resolución de Problemas
Antes de resolver un problema por medio de un pseudocódigo, es necesario definirlo

y comprenderlo claramente. Leeremos con atención el enunciado del problema y una vez
comprendido responderemos a las preguntas:
 ¿Qué información debe proporcionar la resolución del problema?
 ¿Cuáles son los datos que necesito para resolver el problema?
La respuesta de la primera pregunta nos dice que salidas va a proporcionar el

algoritmo y la segunda qué datos se nos proporcionan para resolver el problema y cuáles
debemos calcularlos.
Problema: Leer las longitudes de un rectángulo y calcular la superficie y el perímetro.
Para calcular el área y el perímetro de un rectángulo, se necesitan las medidas del

ancho y el alto, estas medidas serán leídas en dos variables.
Las salidas serán los valores del área y el perímetro que serán calculados utilizando
fórmulas.
Entradas: largo, ancho
Salidas: perímetro, área
El pseudocódigo es:
inicio
leer largo
leer ancho
perimetro <<= largo + ancho * 2
area <<= largo * ancho
imprimir perimetro
imprimir area
fin
Problema: Escribir un pseudocódigo que intercambie el valor de dos variables.
Si se tienen, por ejemplo A = 5 y B = 10, se quiere intercambiar el valor de las variables, así:
A = 10; B = 5.
No podemos asignar directamente el valor de una a la otra porque uno de los valores
se destruiría; de modo que esto no se puede hacer:
A <<= B (el valor de A se pierde y quedaría A = 10 ; B = 10) .
La solución consiste en asignar el valor de una de las variables a otra variable auxiliar.
inicio
leer A,B
Auxiliar <<= A
A <<= B
B <<= Auxiliar
imprimir A,B
fin

Sigamos paso a paso el pseudocódigo:
leer A,B ........ Se pide al usuario dos valores.

Supongamos que se ha ingresado A = 100 ; B = 5
Auxiliar <<= A ........ Se asigna a Auxiliar el valor 10. Auxiliar vale 10.
El valor de las variables es:
A B Auxiliar
10 5 10
A <<= B ........ Se asigna a A el valor de B para intercambiar. Ahora el valor de las variables es:
A B Auxiliar
5 5 10
B <<= Auxiliar ........ El valor de A que se guardó en Auxiliar se asigna a B para el intercambio.
A B Auxiliar
5 10 10
El intercambio está hecho. Luego se imprimen los respectivos valores ya intercambiados con la línea:
imprimir.mostrar A,B

Contador
Un contador es una variable destinada a contener valores que se van incrementando o
decrementando cada vez que se ejecuta la acción que lo contiene. El incremento o decremento es
llamado paso de contador y es siempre constante.
Por ejemplo; el marcador de un partido de fútbol, cada vez que un equipo anota un gol,
aumenta su marcador en una unidad.
En las carrera de automóviles, cada vez que un vehículo pasa por la línea de meta, se
incrementa en una unidad el número de vueltas dadas al circuito, o bien se decrementa en una
unidad el número de vueltas que quedan por realizar.
Aunque el incremento es siempre constante, el paso de contador no necesariamente puede
ser la unidad como en los ejemplos que se han dado más arriba; también puede incrementarse o
decrementarse a de dos, tres, cuatro,.... n; es decir, puede ser cualquier número que conserva el
mismo valor durante todo el programa.
La sintaxis de una variable contador es:
variable <<= variable + constante (al incrementar)

variable <<= variable - constante (al decrementar)
Ejemplos:
gol_local <<= gol_local + 1
vueltas <<= vueltas + 1
faltan <<= faltan – 1
de_cinco <<= de_cinco + 5
c <<= c + 1
x <<= x – 3
Observación: Cuando una variable aparece a ambos lados del símbolo de asignación,
conviene inicializarlas a cero.
Acumulador o Sumador
Es una variable que nos permite guardar un valor que se incrementa o decrementa en
forma NO constante durante el proceso. En un momento determinado tendrá un valor y al
siguiente tendrá otro valor igual o distinto. Por ejemplo; cuando realizamos un depósito en el
banco, la cantidad depositada cada vez no es siempre la misma; unas veces será una
cantidad y otras veces distinta. Lo mismo ocurre cuando realizamos algún retiro, pero
decrementando la cantidad total.
La sintaxis es:
acumulador <<= acumulador + variable (al incrementar)
acumulador <<= acumulador - variable (al decrementar)
acumulador es la variable en la que se almacena el resultado.

variable contiene el número que estamos incrementando o decrementando
Ejemplos:
saldo <<= saldo + entrega
saldo <<= saldo – retiro
suma <<= suma + numero
A <<= A + edad

Estructuras de Selección
La estructura de selección, se ejecuta condicionalmente, es decir, si una cierta
condición es verdadera se ejecuta un bloque de instrucciones, si es falsa se ejecuta un
bloque diferente de instrucciones. Por ejemplo, si en el cine proyectan "Star Wars Episode I",
entonces hay que formar fila para comprar los billetes e ingresar al cine, si no, decidimos
otra actividad como ir a bailar.
Si utilizamos una selección es para indicar que según el resultado cierto o falso de
una expresión vamos a tomar una decisión de realizar determinadas acciones especificadas;
seleccionamos las acciones a realizar.
La instrucción que permite tomar una decisión, basada en una condición es Si...Entonces. Al
evaluar la condición, Si...entonces puede devolver solo dos resultados posibles: Verdadero o
Falso; es decir, Si o No.
El formato de la estructura de selección es:
si <condición> entonces
instrucción 1
instrucción 2
...................
instrucción n
si-no
instrucción a
instrucción b
...................
instrucción z
fin-si
Observa como el sangrado permite identificar fácilmente que grupo de instrucciones

se ejecutan en cada caso.
Por ejemplo, Cuando realizamos una llamada telefónica:
Si {señal de ocupado} entonces

Colgar el teléfono
si - no
Iniciar la conversación
fin – si
En este caso, la condición es {señal de ocupado}, que puede ser verdadera o falsa. Si
es verdadera, entonces debemos colgar el teléfono y si no, podemos realizar la
conversación.
Ejemplo:
Si A = 5 entonces
imprimir "A es 5"
si - no
imprimir "A no es igual a 5"
fin – si
También puede obviarse el si - no cuando no nos interesa ejecutar un bloque de

instrucciones en caso de que la condición no se cumpla.
Si {condición} entonces
instrucción 1
instrucción 2
.........
instrucción n
fin – si
Por ejemplo;
Si {hoy es Miércoles} entonces

Comprar entradas para el cine
fin – si
Ejemplos
Introducir un número por teclado y determinar si es positivo o negativo.-
Para saber si un número es positivo o negativo, debemos saber si es menor o mayor a cero.
Si es mayor, el número es positivo y si es menor resulta negativo. Utilizamos Si... para
evaluar como es el número con respecto a cero y mostramos los mensajes correspondientes
en cada caso. Así:
inicio
leer Numero
Si Numero < 0 entonces
imprimir "El número es negativo"
si-no
imprimir "El número es positivo"
fin-si
fin
Ejemplo 2. Dados dos números, establecer cuál es mayor .

Comenzamos leyendo ambos números, que en el ejemplo se llamarán Número A y Número
B. Luego debemos comparar como es uno contra el otro (puede ser Número A contra
Número B o bien comparar Número B contra Número A):
inicio
leer Número A, Número B
Si Número A < Número B entonces
Imprimir-mostrar “El menor es:", Número B
si-no
imprimir-mostrar "El mayor es:", Número A
fin-si
fin
En este ejemplo, que pasaría si los números fueran iguales?. Hagamos la prueba
Luego de leer los números, por ejemplo: Número A=100 y Número B=100 se ejecutan
las instrucciones:

imprimir "El mayor es:", Número B
El resultado de la condición
Por lo tanto, al ser falsa la condición, se ejecuta la instrucción imprimir "El mayor es:",
Número A.
Por tanto, el algoritmo ofrecerá una solución incorrecta cuando los números son iguales.
Para solucionar esto, tenemos que prever el caso de que los números sean iguales.
inicio
leer Número A, Número B

imprimir "El mayor es:", Número B
si-no
Si Número B < Número A entonces
imprimir "El mayor es:", Número A
si-no
imprimir "Los números son iguales"
fin-si
fin-si
fin
Esta solución contiene dos estructuras de repetición, una dentro de la otra (anidada).
En caso de ser necesario podemos anidar tantas estructuras de selección como sea
necesario. El algoritmo averigua si A es menor a B, si no lo es, tenemos otras dos
posibilidades: que sea menor o igual, esto es lo que determina la estructura anidada.
Otro ejemplo de estructuras de repetición anidadas, consiste en dado un número del 1
al 7, establecer al día de la semana.
inicio
leer numero
Si número =1 entonces
imprimir "Domingo"
si-no
imprimir ="Lunes"
si-no
Si número =3
imprimir "Martes"
si-no
imprimir "Miércoles"
si-no
Si Número =5 entonces
imprimir "Jueves"
si-no
imprimir "Viernes"
si-no
imprimir "Sábado"
si-no
imprimir "El número debe estar entre 1 y 7"
fin-si
fin-si
fin-si
fin-si
fin-si
fin-si
fin-si
fin

Notarás que tenemos varios Si...entonces anidados, ya que si el número ingreso no

es 1, tenemos que preguntar si es 2 ó 3 ó 4...etc. El último Si...entonces es para verificar que
el número ingresado no es 1, 2, 3, 4, 5, 6 ó 7; sino cualquier otro que no nos interesa.
Repasa los algoritmos anteriores.
Resulta bastante tedioso anidar un montón de Si ... entonces, como en el ejemplo del
día de la semana. Cuando queramos o necesitemos hacer numerosas comparaciones
podemos usar otra estructura de selección llamada Según Sea. El formato de estructura de
selección Según sea es:
Según sea <variable>
Caso = <condición>
Caso = <condición>
instrucción o instrucciones
Otro caso
instrucción o instrucciones
fin-según
Así, utilizando esta estructura, el problema del día de la semana será así:
inicio
Leer numero
Según sea numero
Caso = 1
imprimir "Domingo"
Caso = 2
imprimir =“Lunes"
Caso = 3
imprimir ="Martes"
Caso = 4
imprimir "Miércoles"
Caso = 5
imprimir "Jueves"
Caso = 6
imprimir "Viernes"
Caso = 7
imprimir "Sábado"
Otro Caso
imprimir "El número debe estar entre 1 y 7"
fin-según
fin
Lo cual resulta menos engorroso que varios Si... entonces anidados. Es posible anidar
Si... entonces dentro de estructuras Según sea y viceversa.
Observa que la instrucción Otro Caso ejecuta una o varias instrucciones cuando no se
cumple ningún caso de los contemplados más arriba. Otro Caso debe estar siempre al final
(cuando sea necesario, si no o es se puede omitir Otro Caso)
El uso de una u otra estructura depende de cada persona, pero en general cuando las
condiciones a evaluar son muchas, se utiliza Según Sea.-
La estructura según sea admite varias condiciones por ejemplo:

Según sea MES
caso = 1,3,5,7,8,10,12
TDias = 31
caso = 2,4,6,11
TDías =30
caso = 2
TDías=28
fin-según
Este pequeño ejemplo establece el número de días de un mes determinado

almacenado en la variable MES (para años no bisiestos). En lugar de escribir varios Caso =
1, Caso =2, etc, se puede especificar acción o acciones (en este caso la asignación de días
a TDías) cuando la variable tome uno de los valores separados por comas. Es decir si TDías
es 1 ó 3 ó 5 ó 7 ó 8 ó 10 ó 12; se ejecuta TDias=31.

Estructuras Repetitivas
La estructura repetitiva se utiliza cuando se quiere que un conjunto de instrucciones

se ejecuten un cierto número finito de veces. Llamamos bucle o ciclo a todo proceso que se
repite un cierto número de veces dentro de un pseudocódigo o un programa.
Existen dos tipos de estructuras repetitivas; la primera es aquella en donde se tiene
perfectamente establecido el número de veces que un grupo de acciones se van a ejecutar
(20, 5, 2 veces), y la segunda en la que el número de repeticiones es desconocido y se hará
hasta que se cumpla o no cierta condición.
Un ejemplo de la primera sería imprimir los datos de los alumnos de una clase (se
conoce cuantos alumnos hay) y un ejemplo de la segunda puede ser el mostrar un mensaje
de error cada vez que el usuario pulse una determinada tecla (no sabemos cuantas veces
pulsará esa tecla).
Las acciones que forman parte del cuerpo del bucle son ejecutadas de forma
repetitiva mediante la ocurrencia o no de una condición.
Cuando conocemos de antemano el número de veces en que se desea ejecutar una
acción o grupo de acciones, se utiliza la estructura repetitiva Desde o Para.
Esta estructura ejecuta las acciones del cuerpo del bucle un número especificado de veces,
y de modo automático controla el número de iteraciones o pasos.
La sintaxis es:
desde variable = Vi hasta Vf [incremento]

acción o acciones
fin-desde
Donde:
variable: variable índice
Vi: valor inicial de la variable índice
Vf: valor final de la variable índice
[incremento]: el número que se incrementa (o decrementa) a la variable índice en cada
iteración del bucle, si se omite es 1.
Ejemplo:
Imprimir todos los números del 1 al 100.
Inicio
desde I = 1 hasta 100
imprimir I
fin-desde
fin
I es la variable índice con un valor inicial de 1, se incrementa uno en cada paso hasta
100.
Podemos notar que la estructura desde comienza con un valor inicial de la variable
índice y las acciones se ejecutan hasta que el valor inicial sea MAYOR que el que el Valor
final.
La variable índice se incremente en uno (en el ejemplo) y si este nuevo valor del
índice no es mayor que el valor final, se ejecuta de nuevo la acción imprimir.
En este caso se visualizará los números 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ....97, 98, 99, 100 El
incremento o paso de contador es siempre 1 si no es especifica lo contrario.
Otro Ejemplo:
Imprimir todos los números pares desde 2 hasta el 300

desde I= 2 hasta 300 incremento 2
imprimir I
fin-desde
Dónde:
La variable índice comienza en 2, se imprime 2 y en el siguiente paso se incrementa
(suma) 2 a la variable índice que pasa a valer 4; se imprime el 4 y como 4 es menor que 300
(valor final) , se pasa a una nueva iteración incrementando nuevamente en 2 el índice, que
ahora vale 6; y así sucesivamente...
Aquí se visualizan: 2, 4, 6, 8, 10, 12, 14, 16, 18, ..... 296, 298, 300
Si deseamos mostrar los impares el algoritmo es el siguiente:
desde I= 1 hasta 300 incremento 2

imprimir I
fin-desde
La variable índice toma estos valores:

índice o Paso (veces que se ejecuta Valor de
el ciclo) I
1 1
2 3
3 5
4 7
5 9
6 11
.... ....
150 299
Vemos los valores: 1, 3, 5, 7, 9, 11, 13, .... , 299

El ciclo termina mostrando 299 puesto que en el siguiente paso, La variable I valdría
301 y es mayor al límite establecido de 300. I pasa a valer realmente 301 en el último paso,
solo que la instrucción de imprimir no se ejecuta porque el limite de 300 se supera.
Si diéramos la instrucción de imprimir el valor de I, inmediatamente después del fin-desde,
veíamos 301.
Ejemplo 3: Imprimir los valores comprendidos entre el 460 y 500 en orden inverso.
Debemos mostrar: 500, 499, 498, 497, ..... 462, 461, 460. En este caso haremos un
decremento a la variable índice (no un incremento como en los ejemplos anteriores).
Tenemos que comenzar nuestra variable índice en 500 y decrementar una unidad hasta
alcanzar el 460, así:
desde I= 500 hasta 460 incremento -1

imprimir I
fin-desde
índice o Paso (veces que se ejecuta Valor de
el ciclo) I
1 500
2 499
3 498
4 497
5 496
.... ....
39 462
40 461
41 460
Como salida tenemos, entonces: 500, 499, 498, 497, 496, 495, 494, .... 464, 463, 462,
461, 460.
El segundo tipo de estructura repetitiva se diferencia de la primera en que no se

conoce el número de repeticiones o iteraciones en que se va a ejecutar una instrucción o un
bloque de instrucciones.
Estas estructuras son básicamente dos: Estructura mientras....fin-mientras y la
estructura repetir.... hasta. Estas dos se diferencian en que la verificación de la condición
para repetir el ciclo se hace al inicio con mientras y al final con repetir
También existen estructuras repetitivas que son combinaciones de estas dos que
mencionamos, pero aquí no las estudiaremos.

Estructura Mientras
Como su nombre lo indica, esta estructura repite el cuerpo del bucle mientras se
cumpla una determinada condición. Su sintaxis es:
mientras {condición}
acción 1
acción 2
acción 3
.....
acción n
fin mientras
instrucción X
Lo primero que el computador hace es examinar la condición, lo que puede dar como
resultado dos posibilidades:
- La condición se cumple: Se ejecutan acción 1, acción 2, acción 3, ..., acción n.

Las estará repitiendo hasta que la condición no se cumpla, entonces se sale del ciclo y se
siguen ejecutando la o las instrucciones que vienen a continuación y están fuera del bucle;
instrucción X.
- La condición no se cumple: No entrará en el ciclo. Se ejecutan las instrucciones que vienen

después del bucle, instrucción X, por ejemplo.
De esto se deduce que el cuerpo del bucle de una estructura mientras puede repetirse cero
o más veces, veces que son determinadas por el cumplimiento o no de la condición.
Ejemplo
mientras contraseña < > "josua"

imprimir "La contraseña es incorrecta !"
fin-mientras
imprimir "Ha ingresado la contraseña correcta"
Veremos más ejemplos de esta estructura en la sección ejercicios. Al analizarlos

comprenderemos mejor como funciona.-

Estructura Repetir
La estructura repetir cumple la misma función que la estructura mientras. La diferencia
está en que la estructura mientras comprueba la condición al inicio y repetir lo hace al final;
por eso la estructura repetir se ejecuta por lo menos una vez..
La sintaxis es:
repetir
instrucción 1
instrucción 2
instrucción 3
......
hasta {condición}
instrucción X
Repetir es opuesta a la estructura mientras. Repetir se ejecuta hasta que se cumpla

una condición que se comprueba al final del bucle. Esto implica que las instrucciones que
forman el cuerpo del bucle se ejecutan por lo menos una vez. Con la estructura mientras el
bucle puede ejecutarse 0 o más veces.
Lo que la computadora hace al ejecutar la estructura repetir es:
- Se ejecutan: instrucción 1, instrucción 2, instrucción 3, ......

- Se evalúa la condición. Si esta es FALSA se vuelve a repetir el ciclo y se ejecutan
instrucción 1, instrucción 2, instrucción 3, ......
- Si la condición es VERDADERA se sale del ciclo y se ejecuta instrucción X.
Recordemos una vez más las diferencias entre las estructuras mientras y repetir
MIENTRAS REPETIR
Comprobación de la condición al final,
Comprobación de la condición al inicio, antes de
después de haber ingresado una vez al
entrar al bucle
bucle
Las instrucciones del cuerpo del bucle se
Las instrucciones del cuerpo del bucle se
ejecutan en forma repetitiva si la condición es
ejecutan si la condición es falsa
verdadera
Las acciones del bucle se pueden ejecutar 0 o Las acciones del bucle se ejecutan por lo
más veces menos una vez
Ejemplo
repetir
imprimir "La contraseña es incorrecta !"
hasta contraseña = "josua"
Más ejemplos en la sección Ejercicios.
En resumen, hemos visto dos tipos de estructuras repetitivas, el primer tipo en la que
conocemos el número de veces que se repetirá el bucle o ciclo (Desde ....fin-desde; y el
segundo tipo en el cual no conocemos el numero de veces en se repite el ciclo ya que está
determinado por el cumplimiento o no de una condición (mientras ..... fin-mientras y
repetir....hasta).
Toda estructura Desde....fin-desde tiene una estructura mientras....fin-mientras o
repetir.....hasta equivalente.
Pero las estructuras mientras... o hacer ... no tienen NINGÚN desde.....fin-desde

equivalente.

Vectores
Hasta ahora hemos trabajado con datos simples que representaban un número, un
carácter o una cadena. Sin embargo, en ocasiones se necesita procesar una colección de
valores que están relacionados entre sí por algún método, por ejemplo, una lista de
calificaciones, de los meses del año, temperaturas a lo largo de una semana, etc.
El procesamiento de estos datos utilizando datos simples es muy difícil. Por eso, se
han definido en la programación varias estructuras de datos, que son una colección
caracterizada por alguna organización y por las operaciones que se definen en ella.
Una de estas estructuras son los vectores.
Un vector es un conjunto de elementos del mismo tipo que comparten un nombre
común; algo así como una variable que puede almacenar al mismo tiempo más de un valor.
Los vectores reciben también el nombre de tablas, listas o arrays.
Un vector es un conjunto ordenado y homogéneo. Ordenado porque el primer
elemento, segundo, tercero... n-ésimo puede ser identificado y homogéneo porque sus
elementos son todos del mismo tipo (numéricos o alfanuméricos, pero no una combinación
de ambos).
Gráficamente, un vector se representa como una tabla:
De igual forma que cualquier variable, un vector debe tener un nombre.
Aquí hemos llamado A a nuestro vector ejemplo.

Los elementos que están en el vector A ocupan todos una determinada posición dentro de
él:
Así, el número -5 se encuentra en la posición 3; el 99 en la posición 10 y el 12 en la posición

1.
A(3) = - 5
A(10) = 99
A(1) = 12
Vemos, entonces que un elemento se referencia por el nombre del vector y la posición
que ocupa dentro de él. El número que se coloca entre paréntesis se llama índice y designa
la posición del elemento en el vector.
Cada elemento del vector se puede procesar como si fuera una variable simple.
La dimensión de un vector está dada por la cantidad de elementos que contiene y
debe ser definida al comenzar el programa.
Cargar un vector
La asignación de valores a los elementos de un vector se realiza de esta forma:
A(4) <<= 0
A(7) <<= 4
etc.

Por lo tanto, para que el vector A contenga los valores que se han mostrado como
ejemplo, se han hecho estas asignaciones:
A(1) <<= 12
A(2) <<= 50
A(3) <<= -5
A(4) <<= 0
A(5) <<= 100
A(6) <<= 33
A(7) <<= 4
A(8) <<= 7
A(9) <<= 5
A(10) <<= 99
Por supuesto que no vamos a cargar un vector de 100 elementos, escribiendo 100
asignaciones.
La carga de un vector se hace por medio del ciclo desde....fin desde . Nuestro bucle
va a comenzar en 1 hasta un número N que es la longitud del vector.
Pero antes, no demos olvidar que el vector debe ser dimensionado. Al dimensionar un
vector le decimos a la máquina que reserve los espacios de memoria necesarios para los
elementos del vector.
Los problemas relacionados con vectores tendrán casi siempre esta forma
inicio
Leer dimensión del vector
Dimensionar Vector
Cargar Vector
Procesamiento de los elementos del vector (según lo que se pida)
Imprimir Vector
fin
Por lo tanto, vamos a tener tres desde...fin desde bien diferenciados:

Un bucle para la carga
Un bucle para el proceso
Un bucle para la impresión
Aunque la carga y el proceso pueden hacerse dentro de un solo bucle, particularmente no

recomiendo esta práctica, ya que casi siempre crea dificultades innecesarias.
Cargar el vector
Ejercicio: Cargar un vector de 30 componentes.
No olvidemos que antes de cargar un vector debemos dimensionarlo. En este caso la

dimensión del vector es 30.
Luego habilitaremos un bucle desde....fin desde comenzando en 1 hasta 30. Llamaremos V a
nuestro vector.
inicio
dimensionar V(30)
desde I = 1 hasta 30
leer V(I)
fin desde
fin
De esta forma hemos cargado un vector V con de componentes.

Ahora bien, el usuario deberá siempre poder determinar la dimensión del vector sobre
el que quiera trabajar. Por eso, vamos a leer la dimensión del vector en una variable:
inicio
Leer N
dimensionar V(N)
desde I = 1 hasta N
Leer V(I)
fin desde
fin
Así vamos a cargar un vector SIEMPRE
Imprimir un vector
El procedimiento para imprimir un vector es casi exactamente igual al proceso de
carga, con la diferencia que en lugar de leer, vamos a imprimir. Para el caso de nuestro
vector V de N componentes:
desde I = 1 hasta N
imprimir V(I)
fin desde
Es bueno volver a señalar que los elementos de un vector son todos del mismo tipo
(todos numéricos o todos alfanuméricos).
Ejercicio: Leer un vector de N componentes. Hallar la suma y el promedio de los

elementos del vector.
Se pide la suma y el promedio de los elementos. Sabemos que el promedio lo hallaremos
dividiendo la suma todos los elementos, sobre la cantidad.
Nuestro vector (al que llamaremos H) va a tener una dimensión D, que será determinada
por el usuario.
Siguiendo el esquema que habíamos visto, vamos a tener primeramente un bucle para la
carga del vector, otro para el proceso y otro para imprimir el vector.
inicio
suma 0
leer D
dimensionar H (D)
desde I = 1 hasta D
leer H (I)
fin desde
desde I = 1 hasta D
suma suma + H(I)
fin desde
promedio
imprimir H (I)
fin desde
imprimir ""La suma de los elementos del vector es:", suma
imprimir "El promedio es:", promedio
fin
Arrays
Un array es conjunto finito y ordenado de elementos del mismo tipo (homogéneos). Son
ordenados porque siempre se tiene un criterio para identificar el primer, segundo,....n-

ésimo elemento. Son homogéneos porque los datos que contiene son todos del mismo
tipo (alfanuméricos o numéricos pero no una mezcla de ambos).
El tipo más simple de array es el denominado array unidimensional o vector. Es
unidimensional porque solo se necesita un índice para designar la posición de un
elemento dentro del array.
Existen datos que están mejor representados en forma de tablas o matrices con dos o
más subíndices.
Un tablero de ajedrez es el ejemplo típico de un array de dos dimensiones, ya que se
necesitan dos índices para determinar la posición exacta de un elemento dentro del array.
Se pueden definir arrays multidimensionales, es decir de tres, cuatro, cinco.....n-
dimensiones; aunque el manejo de arrarys con más de tres dimensiones es bastante
complicado.
En el apartado siguiente vamos a estudiar a los arrays bidimensionales o matrices.
Más ejemplos de vectores en la sección Ejercicios.-

Matrices
Un array bidimensional o matriz es un conjunto de datos homogéneos (todos del
mismo tipo), cada uno de los cuales debe referenciarse por dos índices. Los índices
determinan la posición de una fila y una columna.
En este ejemplo tenemos una matriz de dimensión M * N, en donde M es el número

de columnas y N el número de filas. Aquí M=5 y N=6.
El número total de elementos de la matriz será entonces 5*6 = 30.
De la misma forma que los vectores, una matriz debe tener un nombre. Llamaremos
MAT a nuestra matriz ejemplo y determinaremos la posición de algunos de sus elementos.
MAT será de tipo alfanumérico.
La matriz MAT está definida con 5 filas y 6 columnas. La notación para el

dimensionamiento de una matriz es
NOMBRE (cantidad de filas, cantidad de columnas); luego:
MAT(5, 6)
Una vez que la matriz contenga datos (veremos más adelante como cargar una
matriz) para referirnos a un elemento debemos conocer en que fila y que columna reside ese
elemento, por ejemplo:

MAT (1,1) = "A"

MAT(3, 5) ="Ñ"
MAT (4,3)= "OK"
MAT (5,4)="L"
Dimensionamiento y Carga de una matriz

Así como un vector tiene que ser nombrado y dimensionado antes de ser utilizado,
una matriz también. La instrucción para dimensionar un matriz es :
dimensionar M(5,6)
La carga de datos se realiza de la misma forma que un vector, por medio de un bucle
desde....fin desde; solo que en este caso, vamos a necesitar 2 bucles; uno que recorra las
filas y otro las columnas:
desde fila = 1 hasta 5
desde columna = 1 hasta 6
leer MAT(fila, columna)
fin-desde
fin-desde
en este ejemplo, la variable fila comienza en el valor 1, luego se da inicio al bucle

columna que desde 1 hasta 6. El bucle de las columnas debe terminar todo su recorrido para
que pueda comenzar el siguiente valor de fila. Los índices van tomando estos valores:
MAT (1, 1)
MAT (1, 2)
MAT (1, 3)
MAT (1, 4)
MAT (1, 5)
MAT (1, 6) ------------- aquí termina el primer bucle de columnas
MAT (2, 1) -------------- comienza el segundo bucle para recorrer la segunda fila
MAT (2, 2)
MAT (2, 3)
MAT (2, 4)
MAT (2, 5)
MAT (2, 6)------------- aquí termina el segundo bucle de columnas
MAT (3, 1) -------------- comienza el tercer bucle para recorrer la tercera fila
MAT (3, 2)
MAT (3, 3)
MAT (3, 4)
MAT (3, 5)
MAT (3, 6)
MAT(4, 1) -------------- comienza el cuarto bucle para recorrer la cuarta fila
MAT(4, 2)
MAT(4, 3)
MAT(4, 4)
MAT(4, 5)
MAT(4, 6)
MAT(5, 1) -------------- comienza el quinto bucle para recorrer la quinta fila
MAT(5, 2)
MAT(5, 3)
MAT(5, 4)
MAT(5, 5)
MAT(5, 6) -------------- Fin de ambos bucles
El recorrido de una matriz se hace, por tanto de esta manera:
Una matriz también puede recorrerse por columnas. Al programar, no siempre podremos
predefinir el tamaño de un matriz, por eso, solicitaremos al usuario que ingrese la cantidad
de filas y columnas con las que desea dimensionar una matriz:
inicio
leer cantfila, cantcolumna
dimensionar MAT(cantfila, cantcolumna)
desde fila=1 hasta cantfila
desde columna=1 hasta cantcolumna
leer MAT(fila,columna)
fin-desde
fin-desde
fin
Este pseudocódigo solicita las dimensiones de la matriz, la dimensiona y luego

procede a cargarla.
Una matriz se imprime utilizando también dos índices:
inicio
dimensionar MAT(cantfila, cantcolumna) ------ se dimensiona

leer MAT(fila,columna) ------- lectura
fin-desde
fin-desde
imprimir MAT(fila,columna) -------- impresión
fin-desde
fin-desde
fin
Procesando una matriz.

Proceso de una matriz se realiza también forma análoga a los ejemplos anteriores.
Utilicemos un ejemplo que calcula el promedio de los elementos de una matriz.
inicio
dimensionar M (cantfila, cantcolumna)
desde I = 1 hasta cantfila
desde J=1 hasta cantcolumna
leer M(I, J)
fin-desde
fin-desde
desde I=1 hasta cantfila
suma suma + M(I, J)
fin-desde
fin-desde
promedio f suma / (cantfila * cantcolumna)
desde I = 1 hasta cantfila
imprimir M(I, J)
fin-desde
fin-desde
fin
Una matriz que tiene la misma cantidad de filas y de columnas se llama matriz
cuadrada.
1 2 3 4 5
2
3
4
5
Esta es una matriz cuadrada de orden 5.
Las matrices cuadradas tienen ciertas características; por ejemplo, los elementos en
donde el número de filas es igual al número de columnas se llama diagonal principal
(señalados en amarillo): Los elementos de la diagonal principal tienen, entonces, la
propiedad de que fila = columna
La diagonal principal define así dos áreas bien notorias, una que está por encima y
otra por debajo. La región determinada por los elementos situados sobre la diagonal
principal se llama matriz triangular superior que tiene la propiedad de que fila < columna.
La matriz triangular inferior es la zona situada debajo de la diagonal principal, cuyos

índices cumplen con la propiedad: fila > columna.
Elementos de la Matriz triangular superior Elementos de la Matriz triangular inferior
Operaciones con Matrices
1- Suma de matrices: Si A y B son dos matrices de igual dimensión (MxN), entonces la

suma de Ay B existe y es igual a una matriz C también de dimensión MxN en donde
cada C (i, j) = A (i, j) + B (i, j):
Matriz A
10 8 3 0
7 -3 33 45
9 15 71 29
Matriz B
1 6 9 69
14 22 56 7
3 5 80 1
A y B son de igual dimensión, por lo tanto existe una matriz C que es la suma de A y B
11 14 13 69
21 19 89 52
12 20 151 30
2- Producto Escalar por una matriz: Si A es una matriz de orden (dimensión) MxN y K
es un escalar, el producto de K*A es igual a otra matriz D también de orden MxN en donde
casa D (i, j) = K * A (i ,j):
Matriz A:
1 2 3 4 5 6
7 8 9 10 11 12
0 -1 -2 -3 21 22
33 3 0 5 12 4
Escalar: 5
Resultado de multiplicar la matriz A por el escalar (numero) 5
Matriz D
5 10 15 20 15 30
35 40 45 50 55 60
0 -5 -10 -15 105 110
165 15 0 25 60 20
3- Traspuesta de una matriz: Si A es una matriz de orden MxN, la traspuesta de A,

denotada como A°, es otra matriz de orden NxM donde cada B (i, j) = A (j,i). Una matriz es
simétrica si A° = A:
Matriz A:
0 1 2
3 4 5
6 7 8
9 10 11
Traspuesta de A, A°:
0 3 6 9
1 4 7 10
2 5 8 11

Funciones y Procedimientos
En general un problema complejo puede ser resuelto de manera más fácil y eficiente
si se divide en problemas más pequeños y concentrándonos en cada etapa en la solución de
ese "subproblema". Esto implica que el gran problema original será resuelto por medio de
varios módulos, cada uno de los cuales se encarga de resolver un subproblema
determinado. Esos módulos, se conocen con el nombre de subalgoritmos. Un subalgoritmo
no es más que un algoritmo que tiene la función de resolver un subproblema.
Los subalgoritmos se escriben sólo una vez, luego es posible hacer referencia a ellos
("llamarlos") desde diferentes puntos de un pseudocódigo. La ventaja obvia es que nos
permite reutilización y evita la duplicación de códigos.
Los subalgoritmos son independientes entre si, en el sentido de que se puede escribir
y verificar cada módulo en forma separada sin preocuparse por los demás módulos. Por ello,
es menos complicado localizar un error y también se puede modificar el código sin tener que
tocar o rehacer varias partes del mismo.
Los subalgoritmos pueden ser dos tipos: Funciones y Procedimientos (también
llamadas subrutinas o subprogramas).
Notemos que al utilizar procedimientos y funciones se establece un límite para el
alcance de las variables, unas tendrán efecto y valor sólo en el subalgoritmo y otras en el
algoritmo principal, también es posible especificar que una variable tenga efecto en el
algoritmo principal y todos los subalgoritmos. Este punto lo estudiaremos con más detalle en
la sección Ámbito de variables.
Los subalgoritmos pueden recibir valores del algoritmo principal (parámetros) ,
trabajar con ellos y devolver un resultado al algoritmo principal: No existen limitaciones en
cuanto a las acciones que pueda ejecutar un subalgoritmo. Un subprograma puede, a su
vez, invocar o llamar a otros o a sus propios subprogramas, inclusive puede llamarse a sí
mismo (esto se conoce como recursividad).

Funciones
Desde el punto de vista matemático, una función es una expresión que toma uno o
más valores llamados argumentos y produce un valor que se llama resultado. Este resultado
es además, único. Ejemplos de funciones matemáticas son los logaritmos, funciones
trigonométricas (seno, coseno, etc).
El en ambiente de programación y diseño de algoritmos, las funciones tienen
exactamente el mismo significado. Es decir, se realizan ciertos cálculos con una o más
variables de entrada y se produce un único resultado. En programación y diseño de
algoritmos, este resultado podrá ser un valor numérico, alfanumérico o lógico. Es decir, una
función puede devolver un resultado que puede ser una cadena, un número o un valor de
tipo lógico (verdadero o falso). Esto hace que en los lenguajes de programación, debamos
especificar de que tipo es una función. Una función será de tipo numérica cuando devuelva
un número y será de tipo alfanumérica o string cuando devuelva una cadena. En el caso de
las funciones de tipo numérico se tienen subdivisiones que están dadas por los tipos de
datos soportados por el lenguaje (integer o entero, simple o single, doble precisión o double,
real, etc). O sea que cuando una función numérica devuelva un valor numérico entero (sin
decimales) será de tipo entera o integer. Si devuelve un valor decimal será doble o simple,
dependiendo del grado de exactitud que se desea; sin embargo como esto es propio de
lenguajes de programación no se tendrá en cuenta en este tutorial (las funciones serán
numéricas cuando devuelvan un dato numérico y de tipo string cuando devuelvan una
cadena, sin necesidad de especificar esto previamente en el algoritmo). Puedes consultar al
profesor de la materia que te proporcione más detalles sobre los tipos de datos y su
aplicación en las funciones.
Tomemos como ejemplo al función matemática sen(x). En este caso la función se
llama sen (seno) y el argumento o valor que se pasa a la función para que lo procese es x.
Así sen(90º)=1. Este valor es además único (por eso se llama función), es decir no existe
ningún otro número que la función pueda procesar y devolver 1 más que 90º.
Cuando utilicemos esta función en un pseudocódigo y necesitemos el valor del
sen(90º), debemos asignarlo a una variable, así:
valor = sen(90)
en este caso, la variable valor será = 1, por la tanto nuestra función es numérica.
Es así como se llaman a las funciones desde un pseudocódigo. Asignándolas siempre
a una variable que contendrá el valor devuelto por la función. Si no hacemos esta
asignación, la función no podrá ejecutarse ya que no tendrá un "lugar" donde descargar el
resultado. Por lo tanto la llamada a una función será siempre:
variable = función (parámetros)
Ejemplos: La llamada a una función MES que devuelva el nombre del mes, pasándole
el valor numérico correspondiente será:
nombre_mes <<= MES(2) (esto devolvería "Febrero")
La función es de tipo string porque devuelve una cadena como resultado en la

variable nombre_mes.
Ya sabemos como llamar a una función, ahora veremos como se escribe la función.
Como las funciones y procedimientos no se escriben en el algoritmo principal (en
programación existen espacios destinados a ellos) todas las funciones y procedimientos que
utlice un algoritmo se podrán escribir antes o después del algoritmo principal. Para efectos
de este tutorial las funciones y procedimientos se escribirán siempre al final del algoritmo
principal.

Una función se identifica mediante su nombre. De la misma manera que cuando

escribimos un algoritmo comenzamos poniendo: inicio y al final fin, debemos hacer lo mismo
para una función. Esto nos dirá donde comienza y donde termina la función. La sintaxis es:
Función nombre_funcion (parámetros)

<instrucciones>
<instrucciones>
Fin función
Todas las funciones devuelven un sólo valor. Siempre debemos indicar a la función
mediante una instrucción que devuelva el valor al algoritmo principal (recordemos que la
función será llamada desde un algoritmo). Esto se debe hacer en el cuerpo de la función
cuando tengamos el resultado. así que, tomando como ejemplo la función MES, veremos
como se escribe el algoritmo principal, como se llama a la función desde el algoritmo
principal y cómo se declara la función:
Algoritmo principal inicio

leer numero_mes
mientras numero_mes <=0 ó numero_mes >12
imprimir "Debe ingresar un número entre 1 y 12" > Validación del número entre 1 y 12
leer numero_mes
fin mientras
nombre_mes <<= MES (numero_mes) > Llamada a la función MES
imprimir "El mes correspondiente es: ", nombre_mes
fin
Función MES (valor)

Según sea valor
caso=1
nombre="Enero"
caso=2
nombre= "Febrero"
caso=3
nombre = "Marzo"
caso =4
nombre = "Abril"
caso=5
nombre = "Mayo"
caso=6
nombre = "Junio"
caso=7
nombre ="Julio"
caso=8
nombre="Agosto"
caso=9
nombre="Setiembre"
caso= 10
nombre = "Octubre"
caso=11
nombre= "Noviembre"
caso= "12"
nombre="Diciembre"
fin caso

MES <<= nombre > Le decimos a la función que devuelva el resultado al algoritmo
principal
Fin función
Debes notar como pasan los valores desde el algoritmo principal a la función. en este
caso, cuando se llama a la función
nombre_mes MES (numero_mes)
el valor que se pasa a la misma está en la variable numero_mes que toma un valor
comprendido entre 1 y 12.
Cuando se llama a la función, este valor debe ser recibido por la misma, en este caso
en el cuerpo de la función se coloca entre paréntesis el nombre de la variable que recibirá el
valor:
Función MES (valor)
Si se pasan varios valores, todos deben ser recibidos en su correspondiente
variables.
La función toma el valor pasado desde el algoritmo y lo guarda en la variable valor
para procesarlo. Luego de que obtiene un resultado, en este caso el valor de nombre_mes,
se le ordena a la función que devuelva ese valor al algoritmo principal:
MES <<= nombre

Esto es siempre así : nombre_funcion <<= resultado
Es en este punto donde se retorna a la línea siguiente a la que llamó a la función en el
algoritmo principal:
imprimir "El mes correspondiente es: ", nombre_mes
Resumiendo. Una función devuelve un sólo valor, para que funcione la función debe
recibir uno o varios valores desde el algoritmo principal, realizar el proceso y devolver el
resultado. La función se escribe de igual forma que cualquier algoritmo, la diferencia consiste
en que en lugar de inicio y fin, ponemos
Función <nombre_función>
fin_función
La llamada a la función se hace con su nombre y el o los valores que le pasamos.
Cuando necesitemos procesar uno o varios valores y ofrecer UN resultado,
utilizaremos funciones.
Ejemplos de Funciones
A continuación, estudiaremos ejemplos de funciones. De esta forma comprenderemos
mejor el su funcionamiento.
* Ejemplo1: Escribir una función que devuelva la raíz cuadrada de un número ingresado por
teclado.
Aunque todos los lenguajes de programación tiene instrucciones para calcular una
raiz cuadrada, como aquí no estamos escribiendo código, encontraremos la raiz cuadrada
de un número elevando a la potencia 1/2. En general, la raíz x de un número se obtiene
elevando ese número a la potencia 1/x.
Llamaremos RAIZCUA a la función que vamos a escribir. La función RAIZCUA debe
obtener un valor que se pasa desde el algoritmo principal (el número del cual queremos
calcular la raiz cuadrada), elevarlo a la potencia 1/2 y luego devolver este valor al algoritmo
principal. Recordemos que no podemos permitir el ingreso de números negativos.
inicio
leer numero
mientras numero < = 0
imprimir "Ingrese un número positivo"
leer numero
fin-mientras
resultado <<=RAIZCUA(numero)
imprimir "La raiz cuadrada es:", resultado

fin
Función RAIZCUA(valor)
raiz <<= valor ^ 1/2
RAIZCUA <<= raiz
fin-función
Este algoritmo comienza leyendo el numero, verifica que sea un número positivo con
la estructura repetitiva mientras y luego hace el llamado a la función RAIZCUA pasándole la
variable numero. El valor de esa función se recibe en una variable resultado.
La función RAIZCUA recibe el numero que el programa le pasa en la variable valor,
luego eleva ese numero a la potencia 1/2 y lo asigna a la variable raiz.
Para que la función devuelva el resultado del proceso al algoritmo principal, se asigna
la variable raiz a la función, así: raiz (esto será así para todas las funciones
que escribamos).-
Observa que existen variables tanto en el algoritmo principal como en la función.
Hablemos de ellas.
Ámbito de las variables

En programación existen dos tipos de variables, las llamadas locales y las variables
globales.
Variables Locales: Son aquellas que se encuentran dentro de un subprograma
(procedimiento o función) y es distinta de las variables que están en el algoritmo principal.
El valor se confina al subprograma en el que está declarada.
Variables Globales: Son las que se definen o están declaradas en el algoritmo principal y
tiene efecto tanto en el algoritmo principal como en cualquiera de sus subprogramas.
Tomando como referencia la función RAIZCUA, las variables globales son: numero y
resultado. Y las variables locales son: valor y raíz.
valor y raiz sólo existen en la función RAIZCUA, si en el algoritmo principal tratamos de
utilizar estas variables o imprimirlas, no obtendremos nada, ya que para el algoritmo estas
variables son locales y desde su punto de vista NO EXISTEN.
numero y resultado son variables globales, es decir que están disponibles en el algoritmo
principal y también en la función RAIZCUA.
Una variable local (de un subprograma) no tiene ningún significado en el algoritmo principal y
otros subprogramas. Si un subprograma asigna un valor a una de sus variables locales, este
valor no es accesible a otros subprogramas, es decir, no pueden utilizar este valor. Las
variables globales tienen la ventaja de compartir información de diferentes subprogramas.
En resumen: las variables locales son las que se definen en subprogramas y solo tienen
valor dentro de él. Las variables locales son las definidas en el algoritmo principal y tienen
valor y se pueden utilizar en cualquier parte de algoritmo o en cualquier subprograma.
* Ejemplo 2: Diseñar una función que calcule la media de tres números.

inicio
leer numero1, numero2, numero3
prom <<= PROMEDIO(numero1, numero2, numero3)
imprimir "El promedio es:", prom
fin
Función PROMEDIO(valor1, valor2,valor3)

promedio <<= (valor1 + valor2 + valor3) / 3
PROMEDIO <<= promedio
fin-función

Procedimientos
Hemos visto que las funciones se utilizan para devolver como resultado un valor Sin
embargo, en ocasiones necesitaremos devolver más de un resultado o también ejecutar las
mismas líneas de código varias veces en un algoritmo (como por ejemplo una ordenación,
etc.) En estas situaciones la función no es apropiada y se utilizarán los procedimientos
(también llamados subrutinas).
Un procedimiento es un conjunto de sentencias o instrucciones que realizan una
determinada tarea y que pueden ser ejecutados desde más de un punto del programa
principal. Un procedimiento tiene una llamada, cuando el procedimiento se ejecuta
totalmente, vuelve al punto desde donde fue llamado y se ejecuta la siguiente instrucción.
El procedimiento se escribe como cualquier otro algoritmo, solo existen diferencias en
la parte inicial y final. Para nombrar los procedimientos se deben seguir las mismas reglas
que para las variables. Notemos que el objetivo de los procedimientos es ayudar en la
modularidad del programa y evitar la repetición de instrucciones ya que estas se pueden
escribir en un procedimiento y en lugar de repetirlas, llamar al procedimiento cuantas veces
sea necesario.
Desde el programa principal es posible pasar valores (numéricos, alfanuméricos o
combinación de ambos) al procedimiento. este utilizará esos valores para realizar un
determinado proceso. Los valores que se pasan a un procedimiento (en forma de variables)
se llaman parámetros (de igual forma que en las funciones).
Declaración de un procedimiento
La sintaxis para la declaración de un procedimiento es la siguiente:
Procedimiento Nombre_procedimiento (parámetros)
<......acciones...>
<......acciones...>
Fin Procedimiento
La llamada a un procedimiento se hace simplemente por su nombre:
Nombre_procedimiento(parámetros)
También es posible que no se pase ningún parámetro al procedimiento, en cuyo caso
la llamada se hace así:
Nombre_procedimiento()
Cuando no se pasan parámetros se puede obviar los paréntesis.
Nombre_procedimiento
Podemos utilizar procedimientos, por ejemplo para dibujar recuadros en la pantalla,
mostrar mensajes de error, realizar procesos en los que se debe devolver más de un
resultado, colocar en un procedimiento las líneas de código que se repiten varias veces en
un algoritmo.
Cuando necesitemos devolver más de un valor en un procedimiento, las variables que
se devolverán los resultados deben figurar en la lista de parámetros.
* Ejemplo: Procedimiento para calcular el cociente y resto de la división entre dos números
inicio
leer numeroA, numeroB
DIVISION (numeroA, numeroB, P, Q)
imprimir P, Q
fin
Procedimiento DIVISION (dividendo, divisor, cociente, resto)

cociente dividendo / divisor
dividendo - cociente * resto
fin-procedimiento
En este ejemplo, se pasan los números el dividendo y divisor (numeroA y numeroB

respectivamente) y también en los parámetros de llamada al procedimiento deben figurar las
variables en las que se devolverán los resultados de cociente y resto (P y Q
respectivamente) por eso la llamada es
DIVISION (numeroA, numeroB, P, Q)
El procedimiento recibe los valores numeroA en dividendo, numeroB en divisor y se
colocan las variables en las que se pasarán al programa principal el cociente y resto. P
recibirá el valor de cociente y Q recibirá el valor del resto.
Es decir, que cuando necesitemos devolver más de un valor, los parámetros del
procedimiento deben ser los valores que se pasan al procedimiento y luego las variables en
las que se recibirán los resultados.
El objetivo de esta sección es ayudar a comprender cómo funcionan las funciones y
procedimiento. Puedes pedir a tu profesor más ejemplos de procedimientos y funciones.-

Pseudocódigo
El pseudocódigo que a continuación se define fue tomado de la guía EGEL lnfo-Comp del
CENEVAL. Sirve para escribir programas de computadora en lenguaje natural de tal manera que se
facilite la comprensión, prueba y posterior codificación en un lenguaje de programación específico.
1. Convenciones
2. Tipos de datos
3. Estructuras de datos
4. Operadores
5. Operaciones de cadenas
6. Comentarios
7. Estructuras de control
8. Funciones o procedimientos
9. Operaciones de entrada/salida
Bibliografía
1. Convenciones
La relación de convenciones empleadas en el pseudocódigo es la siguiente:
El pseudocódigo se escribe empleando la fuente Times New Roman Las palabras reservadas
del pseudocódigo se muestran en negritas
Los puntos "..." indican la posibilidad de repetir algún elemento del pseudocódigo
Cuando exista la posibilidad de elegir algún elemento a partir de un conjunto de elementos,
éstos se listarán separados por el símbolo "|"
Las diferentes opciones o posibilidades de uso del pseudocódigo se listan con viñetas
El pseudocódigo posee las características siguientes:
Se emplean oraciones en lenguaje natural, donde cada una se refiere a una actividad general
o específica
Se utiliza un lenguaje común, sin palabras rebuscadas
Se evitan errores gramaticales, abreviaciones y puntuaciones
2. Tipos de datos
Los tipos de datos básicos son:
string cadena de caracteres
integer número entero
real número real
boolean falso o verdadero
Estos tipos de datos se declaran de acuerdo con las formas siguientes:
tipo variable1
tipo variable2, variable3 , ... , variablen
tipo variablen1, variablen2, ... , variablenm = valor
donde: tipo puede ser string, integer, real o boolean.
3. Estructuras de datos
Las estructuras de datos son:
arreglos
tipo array1[rango1,...,rangon], ... , array2[rango1, ... , rangon]
donde: rangon: número de localidades deseadas. La primera localidad se referencia con uno.
tipo: es alguno de los tipos de datos básicos o alguna estructura de datos.
registros
Declaración:
record nombre_registro
tipo variable1
... ...
tipo variablen

end
Creación de un registro:
nombre_registro registro
La referencia a un campo de un registro se efectúa de la forma: registro.nombre_campo
archivos
Declaración:
file nombre_archivo
clases
Declaración:
class nombre_clase
variables y funciones miembros
end
Instanciación de un objeto:
nombre_clase objeto
La referencia a un campo de una clase se efectúa de la forma: objeto.nombre_campo. El
llamado a una función de una clase se efectúa de la forma:
objeto.nombre_función(lista_parámetros)
4. Operadores
Aritméticos:
+ suma
- resta
* multiplicación
/ división
mod módulo
div división entera
de comparación:
= igual
<> diferente
< menor que
> mayor que
<= menor o igual que
>= mayor o igual que
lógicos:
AND La expresión será verdadera si y sólo si ambas expresiones son verdaderas
OR La expresión será verdadera si al menos una expresión es verdadera
XOR La expresión será verdadera si y sólo si ambas expresiones son diferentes (verdadero y falso, o
viceversa)
NOT El valor de la expresión es la negación de la expresión original
Nota: La precedencia de los operadores la establecerán los paréntesis
5. Operaciones de cadenas
Las funciones para cadenas son las siguientes:
length (nombre_de_la_cadena)
Regresa un valor entero que "contiene" la longitud de la cadena nombre_de_la_cadena
substring(nombre_de_la_cadena,posición_inicial,longitud)
Regresa una cadena, en donde:
posición inicial es la posición a partir de la cual se copiará el contenido de nombre_de_la_cadena
longitud es el número de caracteres que se copiarán
La forma para copiar el contenido de una cadena hacia otra es:
cadena1=cadena2
La concatenación de cadenas puede ser:
cadena_1 =cadena_2 +cadena_3
cadena_1 =cadena_1 +cadena_2
6. Comentarios
-- comentario
/* línea1
línea2
...
línean */
7. Estructuras de control
variable = valor1 | expresión1 | variable

Secuenciación:
e1
e2
.
en
o bien: e1, e2, ... ,en
Condición:
if c1 then
e1
if c1 then
e1
else
e2
case variable | expresión of
valor1: e1
valor2: e2
...
valorn: en
otherwise: ex
end
donde: otherwise es opcional
lteraciones condicionales
while c1
e1
do
e1
until c1
for variable = valor_inicial to c1, incremento | decremento
e1
Notas:
Es posible efectuar combinaciones de las estructuras de control de secuenciación, condición e
iteración condicional
en puede ser una asignación, alguna estructura de control, combinación de estas últimas o una
secuenciación delimitada por las palabras reservadas de: begin y end
cn es una condición
Se recomienda que los pseudocódigos posean una indentación o sangría consistente
8. Funciones o procedimientos
func nombre_función (lista_parámetros): tipo
begin
e1
...
en
return variable | expresión | valor
end
donde:
lista_parámetros, : tipo y return son opcionales
Para llamar a una función o procedimiento se escribe: nombre_función(lista_parámetros)

lista_parámetros en la definición de la función es de la forma: tipo variable1, tipo variable2, ..., tipo
variablen
lista_parámetros en el llamado a la función es de la forma: variable1, variable2, ..., variablen
9. Operaciones de entrada/salida
read(variable1, variable2, ..., variablen)
Lee una(s) variable(s) del teclado
write("texto1", ... , "texton", variable1, ... , variablen)
Despliega texto(s) o el valor de una(s) variable(s) en el monitor
open(archivo, read | write | append | read/write)
Abre un archivo en algún modo (escritura, lectura, adición o lectura/escritura, respectivamente)
close(archivo)
Cierra un archivo previamente abierto
readfile(archivo, nombreRegistro)
Lee un registro de archivo dejando la información leída en nombreRegistro
writefile(archivo, nombreRegistro)
Escribe o sobreescribe el contenido de nombreRegistro en el registro actual de archivo
EOF(archivo)
Regresa verdadero si es el fin de archivo y falso en caso contrario
ERROR(archivo)
Regresa verdadero si se presentó un error en la última instrucción ejecutada en un archivo y falso en
caso contrario
seek(archivo, inicio | final | registron)
Se posiciona al inicio, al final o en un registro x de archivo
position(archivo)
Regresa el número de registro actual en archivo
Pseudocódigo - Primera aproximación a la programación (Algoritmos,

Leer, Escribir, Si )

Algoritmo
Algoritmo: Secuencia finita de pasos (acciones) que sirven para resolver un problema.
Ejemplo de Rueda pinchada.
Algoritmo rueda pinchada
Abrir baúl
Sacar rueda auxilio
Sacar gato
Levantar coche
Repetir
Sacar tuerca
Hasta que No halla más tuercas
Sacar Rueda
Poner Rueda de Auxilio
Repetir
Poner Tuerca
Hasta que estén todas
Bajar coche
Guardar Rueda
Guardar Gato
Fin algoritmo
Herramientas para construir Algoritmos: Diagrama de flujo, diagrama de Jackson,
Pseudocódigo
Pseudocódigo: Se utiliza durante toda la carrera. Se asemeja al lenguaje de prog..
Una vez construido el algoritmo en pseudocódigo, se traduce a un lenguaje que “entiende la computadora”
quedando construido el programa.
El lenguaje que se utilizará es el Pascal, Versión Turbo Pascal 7.0.
Introducción al Pseudocódigo
Variable
Concepto de Variable: Casillero que tiene un Nombre (Referencia) y Contenido
Nombre: Identificador, debe ser una palabra compuesta sólo por letras, el carácter „_‟ y números. No puede
comenzar con un número.
Ej. Hola, Letra, Let1, A , Z etc.

No pueden ser Nombres de variables: 1, 1Hola, f. Etc.
Contenido: Valor que contiene la variable (Casillero).

Se pueden clasificar en los siguientes Tipos:
Números: Ej. 4, 5, 6.7 etc.

Caracteres: „A‟, „.‟, „2‟ Etc. (Existe una tabla que contiene todos los caracteres en orden)
Lógicos: V o F.
Expresión
Expresión: Representa un valor
Está formada por:
è Valor o Variable
è Variable o Valor operador Expresión
Ej. De Valor: 4, „a‟,5,V, F

Ej. De Variables: A, Hola etc.
Operadores
Los operadores pueden utilizarse:
Entre Números: Deben estar entre expresiones numéricas
Enteros : +, - , *, Div, Mod
Reales: +,-,*,%
Entre valores Lógicos: Deben estar entre expresiones lógicas
^ , v, ¬
Lógicos : >,<, >=, =<,=, +

Ejercicios de expresiones.
Indicar que valor representan las sig. Expresiones:
Exp1: 5+1
Exp2: A v B ^ (5>=Numero) A=V B=F Numero=4
Exp3: V ^ C C=F
Indicar que tipo de valores deben tener las siguientes variables para que las expresiones sean correctas.
Exp1: 5+Num/4
Exp2: (Letra + 5) v Numero
Exp3: (Numero * 7 / Letra) = „a‟
Acciones de Secuencia:
Asignar
Leer
Escribir
Escribir
Escribir: Permite exteriorizar una expresión.
Sintaxis:
Escribir(Expresión o Expresiones (Separadas por comas))
Ejemplo:
Escribir(Numero+3)
Escribir(Letra, Numero+1, „Hola‟)
Nota: „Hola‟ no es un valor de ningún tipo conocido, es decir, no es un carácter, pero se anotará de esta forma
cuando se quiera escribir „H‟, ‟o‟, ‟l‟, ‟a‟.
Ejercicio:
Ingresar un Número y luego imprimir el cubo del mismo.
Asignar
Asignar, Permite almacenar una expresión en una variable
Sintaxis:
Variable <- Expresión
Ejemplo:
Numero<-7
Letra<-„s‟
Ejercicio:
2
Almacenar en una variable el 8 * 6
Leer
Leer, Permite entrar un dato, y almacenarlo en una variable.
Sintaxis:
Leer(Variable)
Ejemplo:
Leer(Numero) Cuando se ejecuta la acción se ingresará un valor y quedará almacenado en la variable
Leer(Letra)
Ejercicio:
Ingresar un Número y luego imprimir el cubo del mismo.
Acciones de Selección:
Si
Si, Permite tomar una decisión a partir de una expresión lógica.
Sintaxis:
Si <expresión lógica> Entonces
Acción/es
Fin si
Ejemplo:
Si (Numero=4) Entonces
Escribir(„El número es un cuatro‟)
Escribir(„Ingrese otro número‟)
Leer (Numero)
Fin si
Ejercicio:
Ingresar un Número y decir si es mayor menor o igual a cero

EJERCITACION:
Estructuras repetitivas
01) Escribir un algoritmo que calcule el área de un triángulo.
02) Escribir un algoritmo que calcule el área de un rectángulo.
03) Escribir un algoritmo que calcule el área de un trapecio.
04) Escribir un algoritmo que calcule el precio de un artículo tras aplicarle un 16% de IVA.
05) Escribir un algoritmo que intercambie el contenido de dos variables.
Estructuras alternativas
01) Diseñar un esquema de menú de opciones, por ejemplo, un menú para seleccionar un
libro a leer de entre siete disponibles.
02) Escribir un algoritmo que lea tres números e imprima por pantalla el mayor de ellos.
03) Escribir un algoritmo que lea tres números e imprima por pantalla el menor de ellos.
Introducción a la programación - Autor: Lola Cárdenas Luque
En esta página:
Estructuras de control; secuenciales y selectivas
Elementos básicos para la descripción de algoritmos
El principio y el fin
Asignaciones
Comentarios
Estructuras de control
Estructuras secuenciales
Estructuras selectivas
Ejercicios
Sobre estructuras secuenciales
Sobre estructuras selectivas
Estructuras de control; secuenciales y selectivas

Bueno, bueno: ya hemos hablado un poco de variables; qué son, y cosas que
podemos hacer con ellas. También hablamos un poco por encima de lo que es un algoritmo,
pero aún no sabemos cosas sobre ellos. Una posible "definición rigurosa" sería la siguiente
(no hay que tomarla como un dogma de fe):
Un algoritmo es una sucesión finita de pasos no ambiguos que se pueden llevar a
cabo en un tiempo finito.
Sucesión finita es lo contrario de infinita: esto quiere decir que se acaba en algún
momento ;)
Pasos no ambiguos son pasos tan claros que hasta una máquina los puede entender,
de ahí la necesidad de la no ambigüedad ;)
Lo del tiempo finito es una cuestión práctica: no creo que tengamos tanta paciencia (ni
que lleguemos vivos, sobre todo) como para ver la salida de un programa que calcule Pi :)
No vamos a entrar en filosofías de qué puede ser considerado como un algoritmo, qué
no lo es, etc... , no porque no sea interesante en sí, sino porque a nosotros lo que nos
preocupa en estos momentos es aprender a resolver problemas, y a eso es a lo que vamos.
No hay que confundirse: un algoritmo no es lo mismo que un programa, para hacer un
programa necesitamos algo más: unas estructuras de datos.
Hay distintas formas de escribir un algoritmo, bien usando un lenguaje específico de
descripción de algoritmos, bien mediante representaciones gráficas.
Yo he elegido la primera: el pseudocódigo. Que sea un lenguaje específico no
significa que haya que aprender un idioma nuevo, lo único que quiere decir es que hay unas
cuantas palabras que son clave, y que son las palabras que, de acuerdo a unas reglas muy
sencillitas, nos ayudan a describir el algoritmo.
La estructura del pseudocódigo es bastante parecida a la de algunos lenguajes de
programación (por ejemplo, el Pascal), por ello me ha parecido la más recomendable.
El pseudocódigo tiene algunas ventajas:
Es fácil hacer cambios si nos equivocamos en la lógica del programa
Es independiente del lenguaje de programación que vaya a usarse; un algoritmo que
esté escrito en pseudocódigo es fácilmente traducible a muchos lenguajes de programación.
Y ya, sin más preámbulos, vamos a lo que nos interesa: nosotros queremos resolver
problemas con el ordenador, ¿no es así? Pues veamos con qué herramientas nos podemos
defender para escribir nuestros propios algoritmos.
Elementos básicos para la descripción de algoritmos El principio y el fin
Para delimitar el comienzo y el final de un algoritmo, o de un trozo de algoritmo (por
ejemplo, en los bucles, y otros, como vamos a ver), haremos lo siguiente:
inicio
... Aquí va el algoritmo en cuestión
fin
También, en vez de inicio y fin se puede usar "empezar" y "fin", o lo que queráis, pero
siempre quedando clara la intención. No hay que ser estrictamente riguroso con la aplicación
del "inicio-fin", muchas veces, una buena indentación hace su papel.
Asignaciones
Sobre las asignaciones ya hablamos la vez pasada, al tratar el tema de las variables,
vamos a recordarlo brevemente:
Cuando hayamos declarado una variable, llegará un momento en el que querremos
que la variable tome algún valor. Por ejemplo, tenemos una variable de tipo entero que se
llama I y queremos asignarle el valor 3, entonces, escribiremos:
I <- 3
Comentarios
Poner comentarios de lo que vamos haciendo es muy útil, sobre todo cuando llega la
hora de revisar el algoritmo, si no, más de una vez nos encontraremos diciendo "uumm...
¿qué demonios hacía esto?"
No cuesta nada documentar el código y nos ahorrará dolores de cabeza :) La
convención que seguiremos será poner los comentario entre llaves. Así, {esto será un
comentario}
Estructuras de control
Las estructuras de control tienen una finalidad bastante definida: su objetivo es ir
señalando el orden en que tienen que sucederse los pasos de un algoritmo.
Veamos un ejemplo: supongamos que acabamos de mostrar un mensaje en la
pantalla que pregunte al usuario "¿desea seguir adelante?".
Obviamente, de la respuesta del usuario va a depender la siguiente acción del
programa. Por ejemplo, si este mensaje se nos presenta tras haber pulsado un botón de
cerrar la aplicación, si nosotros elegimos "Sí", la aplicación se cerrará, y si elegimos "No", la
aplicación seguirá adelante.
El programador tiene que haber escrito código para las dos posibilidades, aunque
cuando el programa esté funcionando, sólo se elegirá una.
Las estructuras de control son de tres tipos:
Secuenciales
Selectivas
Repetitivas
Estructuras secuenciales
Una estructura de control secuencial, en realidad, no es más que escribir un paso del
algoritmo detrás de otro, el que primero se haya escrito será el que primero se ejecute (al
implementarlo, por ejemplo).
Veamos un ejemplo: queremos leer el radio de un círculo, calcular su área y mostrar
por pantalla al usuario el resultado.
Declaración de variables
REAL: radio, area
fin declaración de variables
inicio
mostrar por pantalla 'dame el radio del circulo'
leer del teclado la variable radio
área <- 3.14159*radio
mostrar por pantalla 'el área del circulo es:'
mostrar por pantalla el contenido de la variable área
fin
Notar una cosa: cuando queremos hacer cosas relativas a entrada o salida por algún
dispositivo, como el teclado, la pantalla o la impresora, yo pongo cosas como "mostrar por
pantalla", o "leer del teclado". Dado que cada lenguaje de programación tiene sus funciones
de entrada / salida, no uso la forma particular de ninguno, simplemente, lo que le diríamos al
ordenador en caso de que fuera una persona ("oye, por favor, sácame esto por impresora").

Por otro lado, cuando queramos decir que nos muestre el contenido de una variable,
yo he puesto "mostrar por pantalla el contenido de la variable área", pero podía haber puesto
igualmente "mostrar por pantalla área", o cosas similares. Vosotros elegís la forma que os
resulte más clara o más cómoda, lo importante es que las intenciones sean claras, o, lo que
es lo mismo, "no ambiguas" ;)
Además, si os fijáis, para que quede claro que una cosa es mostrar por pantalla una
cadena, y otra cosa es mostrar por pantalla el valor de una variable, el texto que aparece
entre ' ' es una cadena, mientras que el que no aparece entre ' ' no es una cadena, sino que
se refiere a una variable.
Ahora vamos a pasar a las estructuras selectivas y a las repetitivas. Para ello,
necesitamos primero hablar un poco de... CONDICIONES.
La palabra condición nos sugiere frases como "lo haré a condición de que me dejes tu
boli". Analicemos esta frase con un poco de detenimiento.
Decimos "lo haré", pero, ¿"lo haré" siempre, pase lo que pase? o, por el contrario, ¿"lo
haré" si antes hay algo que debe cumplirse? En la frase está claro que no se ha dicho "lo
haré" sin más, si no que hay como una pequeña cláusula "SI me dejas tu boli".
Ya nos ha vuelto a aparecer el SI; esto parece querer decir que debe ser algo
importante.
Lo que significa "SI me dejas tu boli" es lo siguiente, en caso de que la acción
"dejarme tu boli" sea cierta (o verdad, usaré ambas palabras), yo "lo haré". Pero si la acción
"dejarme tu boli" es falsa (o mentira), yo NO "lo haré".
En esto reside el "quid" de las estructuras que vamos a ver a continuación: se
EVALUA una condición, y se actúa en consecuencia, según que la condición sea
VERDADERA o FALSA.
Estructuras selectivas
Estas estructuras se utilizan para TOMAR DECISIONES (por eso también se llaman
estructuras de decisión o alternativas). Lo que se hace es EVALUAR una condición, y, a
continuación, en función del resultado, se lleva a cabo una opción u otra.
Alternativas simples
Son los conocidos "si... entonces". Se usan de la siguiente manera (una vez más, la
escritura es más o menos personal, siempre que las intenciones queden claras para todos):
yo quiero evaluar una condición, y si se cumple (es decir, si es cierta), entonces realizaré
una serie de pasos. Esto lo podemos escribir así:
SI se cumple la condición, ENTONCES:
Hago el paso 1
....
Hago el paso N
fin del SI
Muy estrictamente, sería:
inicio
Hago el paso 1
....
Hago el paso N
fin
fin del SI
pero con una buena sangría nos podemos evitar escribir de más ;) es importante
cerrar el SI, ya que, si no se cumple la condición, el programa seguirá a continuación de
donde termina el SI.
Por ejemplo, queremos calcular la raíz cuadrada de un número; sin embargo todos
sabemos (¡supongo! ;)) que la raíz cuadrada de un número negativo NO es un número real.
Esto quiere decir que, tras leer el número por teclado, tendremos que ver si es positivo, ya
que sólo en este caso podremos calcular su raíz cuadrada.
Veamos como queda:

REAL: numero, raíz
inicio
mostrar por pantalla 'introduce un numero'
leer del teclado la variable numero
SI numero >= 0 ENTONCES:
raíz <- raiz_cuadrada(numero)
mostrar por pantalla 'la raíz cuadrada es:'
mostrar por pantalla raíz
fin del SI
fin
Como extraer una raíz cuadrada es una operación que, en principio, no es elemental,
yo he puesto raiz_cuadrada(numero), eso significa que, en alguna parte, tengo definida una
función que me calcula la raíz cuadrada de un número. Ya hablaremos de funciones y
subrutinas más adelante, pero hago esta aclaración para que conste que raiz_cuadrada no
forma parte de ningún tipo de especificación de pseudocódigo ;-)
Sin embargo, hubiera sido bonito haber podido avisar al usuario de que no podíamos
calcular la raíz cuadrada en caso de que el número fuera negativo, pero no os preocupéis,
para ello tenemos las...
Alternativas dobles
O el famoso trío "si ... entonces ... sino" ;-D
Se usan de esta forma: queremos evaluar una condición, si es verdad, realizaré una
serie de pasos, y SI NO es verdad (es decir, si es falsa, si es una puerca mentira cochina... ;)
), entonces realizaré otra serie de pasos. Esto lo podemos escribir así:
Hago el paso A1
....
Hago el paso AN
y SI NO se cumple la condición, ENTONCES:
Hago el paso B1
....
Hago el paso BM
fin del SI
Con esto, nuestro algoritmo para la raíz cuadrada quedaría:
REAL: numero, raíz
inicio
mostrar por pantalla 'introduce un numero'
leer del teclado la variable numero
SI numero >= 0 ENTONCES:
raíz <- raiz_cuadrada(numero)
mostrar por pantalla 'la raíz cuadrada es:'
mostrar por pantalla raíz
SI NO es numero >=0 ENTONCES: {es decir, si numero es negativo}
mostrar por pantalla 'lo siento, no puedo calcular
la raíz cuadrada de un numero negativo'
fin del SI
fin
Alternativas múltiples
Es muy probable que tengamos la necesidad de incluir en nuestros programas
alternativas con muchas opciones posibles. Esto lo podríamos hacer a base de anidar "si ...
entonces ... si no", pero si es un número elevado de alternativas, se hace demasiado
farragoso como para resultar inteligibles.
Por ejemplo, si queremos hacer un menú que dé a elegir cuatro opciones, un posible
algoritmo sería:
{Algoritmo MENU a base de 'si ... entonces ... sino'}
ENTEROS: opción
inicio
mostrar por pantalla 'menú de opciones:'
mostrar por pantalla '1. Diccionario de sinónimos'
mostrar por pantalla '2. Diccionario de antónimos'
mostrar por pantalla '3. Buscar palabra'
mostrar por pantalla '4. Salir'
leer del teclado la variable opción
SI opción = 1 ENTONCES
{lo que toque a esta opción}
SI NO, ENTONCES
SI NO, ENTONCES
SI NO, ENTONCES
SI NO, ENTONCES
mostrar por pantalla 'opción incorrecta'
fin del SI
fin del SI
fin del SI
fin del SI
fin
Farragoso, ¿verdad?
Para evitar esto (¿os imagináis que en vez de cuatro fueran 20 las alternativas?), está
la estructura "según sea". La idea es esta; por ejemplo, como en el algoritmo que hemos
puesto del menú, pedimos al usuario que entre una opción, y hay cuatro posibilidades,
cuatro posibles valores para los que haremos algo.
Entonces, SEGUN lo que valga la variable opción, elegiremos una alternativa de entre
todas las posibles.
La forma de escribir esto en pseudocódigo es:
SEGUN SEA la variable o la expresión HACER
VALOR1: {las acciones que toque}
...
VALORN: {las acciones que toque}
por defecto: {las acciones que toque}
fin SEGUN
¿Qué pinta ahí ese 'por defecto'?
No es más que una alternativa por si acaso se elige alguna opción no contemplada
entre las que se ofrece.
Como ejemplo, vamos a ver nuestro menú utilizando la alternativa múltiple
SEGUN SEA:
{Algoritmo MENU a base de 'según sea'}
ENTEROS: opción
inicio
mostrar por pantalla 'menú de opciones'
mostrar por pantalla '1. Diccionario de sinónimos'
mostrar por pantalla '2. Diccionario de antónimos'
mostrar por pantalla '3. Buscar palabra'
mostrar por pantalla '4. Salir'
leer del teclado la variable opción
SEGUN SEA opción HACER:

opción = 1 : {lo que toque a esta opción}
por defecto: {mostrar un posible mensaje de error}
fin SEGUN
fin
Así queda mucho más claro, no sólo para nosotros, si no para cualquier persona que
tuviera que leerlo; además, es una forma más sencilla de manejar una alternativa múltiple :)
Podemos abreviar un poquito el texto; es igualmente válido poner, dentro del SEGUN,
lo siguiente:
SEGUN SEA opción HACER:
1 : {lo que toque a esta opción}
por defecto: {mostrar un posible mensaje de error}
fin SEGUN
Me quedan las estructuras repetitivas, que las veremos en la próxima entrega, si no
esto puede ser mucho trago de golpe O:)
En cualquier caso, ya tienen cosas para ir empezando a pensar en la escritura de
algoritmos. Yo sugiero los siguientes...
Ejercicios
Sobre estructuras secuenciales
1. Escribid un algoritmo que calcule el área de un triángulo.
2. Escribid un algoritmo que calcule el área de un rectángulo.
3. Escribid un algoritmo que calcule el área de un trapecio.
4. Escribid un algoritmo que calcule el precio de un artículo tras
5. aplicarle un 16% de IVA.
6. Escribid un algoritmo que intercambie el contenido de dos variables.
7. Sobre estructuras selectivas
8. Escribid un algoritmo que resuelva una ecuación de segundo grado,
9. teniendo en cuenta todas las posibles alternativas.
10. Diseñad un esquema de menú de opciones, por ejemplo, un menú para

11. seleccionar un libro a leer de entre siete disponibles.
12. Escribid un algoritmo que lea tres números e imprima por pantalla el
13. mayor de ellos.
14. Escribid un algoritmo que lea tres números e imprima por pantalla el
15. menor de ellos.

BIBLIOGRAFÍA
 Manual del Programador – Lenguaje C. J. Carlos López Ardao

 Lenguaje, Fundamentos y Técnicas de Programación. Rubén Iglesias. Editorial
Computec – Rama.
 BASIC para Maestros. Antonio Bellido y Arsenio Sánchez. Editorial Paraninfo.
 APRESTAMIENTO INFORMÁTICO. Elsa S. De Fernández de Durán. Editorial Estrada.
 Material Teórico Curso de Ingreso 2008 y 2009, I.E.S. 9-012, Prof. Gustavo Martínez,
Ariel Villar.
 Material de Apuntes de Programación, Prof. Oscar Camilletti. San Rafael Mza.
 Material de Apuntes del Espacio „Diagramación Lógica‟, I.E.S. 9-012, Prof. Gustavo
Martínez. Año 1996
 CENEVAL. (1999) Guía de Estudio del Examen General para el Egreso de la
Licenciatura en Informática-Computación. (EGEL Info-Comp) Perfil "D". Centro Nacional
de Evaluación para la Educación Superior, A.C. (CENEVAL). Primera edición. México.
 Sitio Web Oficial Aprender a Programar, Edición digital, 2010,
http://www.aprendeaprogramar.com/

Manual de Pseudocodigo y Programacion Estructurada Ariel Villar PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual de Pseudocodigo y Programacion Estructurada Ariel Villar PDF

Cargado por

Copyright:

Formatos disponibles

Manual de Pseudocódigo – Programación Estructurada

El presente trabajo es una recopilación y adaptación de obras dedicadas a la

La presente obra está realizada para fines solamente educativos, y la difusión

“Lo que gratis recibes, dalo también gratis…”

Prof. Ariel Villar

Recopilación Prof. Ariel Villar 2

Recopilación Prof. Ariel Villar 3

1. Encender la hornalla de la cocina.

1. Elijo una película de las de mi colección.

De los dos ejemplos propuestos, ambos poseen cosas en común:

Recopilación Prof. Ariel Villar 4

¿Cuál es el algoritmo que nos permite conocer la superficie de un rectángulo

Entonces el algoritmo buscado es: S= A x T .

R: Superficie del triangulo

Entonces el algoritmo buscado es R= (B x A) / 2 .

Recopilación Prof. Ariel Villar 5

Definición intuitiva de Programa

En sentido amplio, podemos decir que

¿Porqué decimos que es una secuencia de Órdenes claras y precisas?

OTRA DEFINICION DE PROGRAMA

Fuente: http://www.wikipedia.org Edición Española digita, 2010.

Un programa informático es un conjunto de instrucciones que una vez ejecutadas realizarán

Recopilación Prof. Ariel Villar 7

De la misma manera ocurre en el Mundo de la programación…

Mostrar. Pantalla “Hola Mundo”

Definición Formal de PseudoCódigo:

Recopilación Prof. Ariel Villar 8

Datos y Tipos de Datos

Datos Alfanuméricos – o String – o Tipo Cadena de Caracteres:

Una cadena de caracteres o string es una sucesión de caracteres que se encuentran

Cuando representamos datos, numéricos o alfanuméricos, debemos darles un

FechaNueva="1 de Junio de 1.971" + 5 Esto no se puede hacer!!

Importante: No se pude juntar numérico con alfanumérico. Analogía: No se puede juntar

Normas para dar nombres a las Variables

Ejemplos de nombres válidos de variables

Ejemplos de nombres de variables NO válidos

Algunos lenguajes de programación exigen la declaración de las variables que se van

Recopilación Prof. Ariel Villar 10

Por ejemplo, la expresión:

¿Cómo se evalúan los operadores? La prioridad de los operadores es:

((saldo>20 AND importe<100) OR (edad<>0 AND sexo=1)) &&expresión original

Recopilación Prof. Ariel Villar 12

La operación de dar valor a una variable se llama asignación. La asignación vamos a

 Veremos varias posibilidades de anotación)

La flecha se sustituye en los lenguajes de programación por = (basic); : = (foxpro).

Pongamos atención a este ejemplo de asignaciones:

Supongamos que A toma el valor 3 y B el valor 4.

La expresión tomará el valor 3 + 2 * 4 = 3 + 8 = 11

Recopilación Prof. Ariel Villar 13

C vale 11, A vale 3, por lo tanto B valdrá 11 - 3 = 8

Esto es: Sumar 5 al valor de J y asignarlo a la variable J. J vale 33.

El valor final de J es 114.

Recopilación Prof. Ariel Villar 14

Entrada y Salida de Información

leer Edad, Peso, Sexo

Ya tenemos nuestro primer comando: leer

Vemos algunos ejemplos en Pseudocógico

imprimir-mostrar A; muestra en la pantalla el valor que está almacenado en la variable A.

imprimir-mostrar "El valor del promedio es:", promedio

Ya conocemos dos comandos que vamos a utilizar en nuestros pseudocódigos: leer e

leer "Ingrese su edad", edad

Entonces, en la escritura de pseudocódigos, las acciones de lectura y escritura se

Tipo de Instrucción Pseudocódigo