Introduccin a la programacin Pseudocdigo

1 - Introduccin
Una de las mayores dificultades con las que se encuentran los
hispanoparlantes que empiezan a programar es el idioma.
Por una parte, la mayora de lenguajes de programacin se basan en el ingls,
por lo que un estudiante de habla hispana tiene que aprender que "write" o
"print" son las palabras equivalentes a "escribir".
Adems, la mayora de lenguajes tienen rdenes que realmente son
abreviaturas de una o varias palabras inglesas, de modo que el aprendiz tiene
que entender o memorizar palabras como "printf" o "writeln" incluso para
realizar las tareas ms sencillas.
Para colmo, la mayora de entornos de programacin estn tambin en ingls
(mens, mensajes de error y aviso, etc).
Por eso, una herramienta habitual para ayudar a los que empiezan es el
"Pseudocdigo", algo as como un falso lenguaje de programacin en
espaol, que ayuda a asimilar con ms facilidad las ideas bsicas.
El pseudocdigo soluciona el primer problema: no hace falta aprender ingls
para entender los conceptos bsicos. Pero "histricamente" no solucionaba el
problema del "entorno de programacin": no existan entornos para programar
en pseudocdigo, as que tpicamente ha sido una herramienta para usar "con
lapiz y papel".
Algunas universidades han creado sus propios "intrpretes de pseudocdigo",

para ayudar a los alumnos de primer curso a crear los programas "pensando
en espaol", pero permitindoles adems probar esos programas desde un
entorno "casi real".
Existen varios de estos "intrpretes de pseudocdigo", que permiten teclear
nuestro programa y ver cual sera el resultado, pero hay uno que me parece
especialmente bueno: PSEINT, que adems realza con colores la sintaxis de
nuestros programas para ayudar a detectar errores, tiene autocompletado para
permitir ganar tiempo, est disponible para Windows y Linux, es gratuito (1), etc.
ste es el que usaremos en este curso introductorio.
Eso s, no existe un estndar claro en cuanto a pseudocdigo, puede que la
sintaxis que empleen en tu universidad o centro de estudios sea ligeramente
diferente a la que veremos aqu. Aun as, esperamos poder ayudarte a coger
con facilidad las nociones bsicas.
(1) PSEINT realmente es "de cdigo abierto": cualquiera puede ver cmo est creado, de
forma que incluso si su autor perdiera el inters por el proyecto, otras personas podran
retomarlo, lo que le garantiza una vida mucho mayor.

PSEINT se puede descargar desde

http://pseint.sourceforge.net/

Y si me atrevo con el ingls?

PseInt es una herramienta til y que, tras un perdodo de aparente abandono,
ha sido retomada por su autor original, quien le ha aadido nuevas
posibilidades que la modernizan.
Si aun as quieres llegar ms all y no te asusta el ingls, bien porque lo
conozcas o bien porque ests dispuesto a aprender 30 palabras, ests de
suerte: el pseudocdigo en ingls se parece a varios lenguajes de
programacin, as que podras aprender los conceptos bsicos usando
"entornos reales".

Posiblemente Pascal sera el lenguaje que ms se parecera al pseudocdigo,

y por eso durante mucho tiempo se ha considerado un lenguaje muy adecuado
para aprender, pero hoy en da est un tanto anticuado. Una alternativa ms
moderna es Python, bien diseado y que est disponible para muchos sistemas
operativos.
Si quieres aprender cualquier de ellos dos, en mi web podrs encontrar cursos
de ambos: tanto de Pythoncomo Pascal.

2 - Toma de contacto
Vamos a empezar por lo ms sencillo: escribir en pantalla.
Si queremos crear un programa que escriba algo en pantalla, usaremos la
orden ESCRIBIR. A continuacin de esta palabras, entre comillas, escribiremos
el texto que queremos que aparezca en pantalla.
Escribir "Hola"

Crear un programa que escriba Hola en la pantalla usando PSEINT tambin es

igual de simple. En el caso de PSEINT, cada programa debe encerrarse entre
las palabras "Proceso" (para indicar dnde comienza) y "FinProceso" (para
sealar dnde termina). Pero eso no aade ninguna dificultad, porque cuando
entramos a PSEINT, ese esqueleto de programa ya aparece escrito:

Nuestro programa debera tener un nombre: se nos propone que se llame

"sin_titulo", pero mejor podemos hacer clic en esa palabra y escribir otro ttulo
que recuerde mejor lo que va a hacer nuestro programa. De momento, bastar
con "Ejemplo001", por eso de que es nuestro primer ejemplo.
Despus, bajamos a la siguiente lnea y comenzamos a teclear la palabra
"Escribir". Veremos que PSEINT se da cuenta, y nos recuerda cmo era la
orden exacta, incluso cuando apenas llevamos unas pocas letras :

Cuando terminamos la palabra "Escribir", se nos propone que escribamos una

o ms expresiones, separadas por comas; en nuestro caso, ser la palabra
"Hola", entre comillas:

Nuestro programa est completo: podemos comprobar su funcionamiento

pulsando el botn que recuerda al "Play " de los equipos de msica:

Y entonces aparecer una nueva ventana que nos muestra el resultado de

nuestro programa (por supuesto, se trata de la palabra Hola):

Por supuesto, no slo podemos escribir textos prefijados. Podemos usar

nuestro ordenador como calculadora, que nos muestre el resultado de una
operacin aritmtica:
Proceso Ejemplo002
Escribir 20+30
FinProceso

Tambin podemos incluir comentarios, aclaraciones, que nos ayuden a

explicar la lgica del programa o cualquier detalle que no sea evidente. En el
caso de PseInt, cualquier lnea que comience con una doble barra (//) se
considerar un comentario y no se tendr en cuenta en el momento de analizar
nuestro programa:
// Ejemplo de comentario en un fuente de PseInt

En el prximo apartado puntualizaremos un poco ms lo que hemos hecho en

este ltimo programa y poco despus veremos cmo comprobar condiciones.
Ejercicio de repaso propuesto 2.1: Crea un programa que escriba "Comienzo
a aprender"

Ejercicio de repaso propuesto 2.2: Crea un programa que escriba el

resultado de multiplicar 123 por 134 (pista: el smbolo de la multiplicacin
normalmente ser el "asterisco")

3 - Variables
Vamos a hacer algo un poco ms complejo: vamos a sumar dos nmeros que
no estn prefijados dentro del programa, sino que deber teclear el usuario.
Para eso, usaremos la orden "Leer", que nos permite leer lo que el usuario
teclee y dejarlo guardado para utilizarlo despus. Debemos dar un nombre
temporal a estos datos que leemos del usuario. Parece razonable que el primer
n mero que teclee el usuario se llame algo como " primerNumero", y el
segundo sea algo como "segundoNumero ". El resultado que queremos
obtener ser la suma de ese primer nmero y ese segundo nmero, as que
nuestro programa podra quedar as:
Proceso Ejemplo003
Escribir "Dime un numero"
Leer primerNumero
Escribir "Dime otro numero"
Leer segundoNumero
Escribir "Su suma es ", primerNumero + segundoNumero
FinProceso

Esas dos palabras, "primerNumero" y "segundoNumero" representan a

nmeros que no tienen un valor prefijado. Eso es lo que llamaremos
"variables". En las variantes de pseudocdigo que emplean en muchas
universidades y centros de estudio (ya habamos avisado de que no existe
ningn estndar totalmente asentado) debemos " declarar las variables" antes
de usarlas: decir qu tipo de dato es el que querremos representar con ese
nombre. En nuestro ejemplo anterior se trataba de dos nmeros enteros, as
que el programa sera:
Proceso Ejemplo003b

Definir primerNumero como Entero

Definir segundoNumero como Entero

Escribir "Dime un numero"

Leer primerNumero
Escribir "Dime otro numero"
Leer segundoNumero
Escribir "Su suma es ", primerNumero + segundoNumero
FinProceso

Esto se debe a que en la mayora de lenguajes de programacin "reales" es

necesario detallar qu tipo de datos querremos guardar en cada variable, para
que la herramienta de programacin sepa exactamente qu cantidad de
memoria ser necesaria para guardar ese dato.
Insisto: no es el caso de PSEINT; con esta herramienta no es necesario
declarar las variables, el propio entorno presupone de qu estamos hablando.

Por otra parte, no siempre querremos que el valor de una variable lo introduzca
el usuario. Habr veces que seamos nosotros mismos los que demos el valor
inicial a una variable desde nuestro programa, bien para usarlo en una serie de
clculos posteriores, o bien por legibilidad (es ms fcil entender algo como
"longitudCircunferencia = 2 * pi * radio" que algo como "longitudCircunferencia
= 6.28 * radio".
La forma de dar un valor a una variable es con la secuencia de smbolos "<-":
radio <- 3
longitudCircunferencia <- 2 * pi * radio

(esos smbolos representan una flecha, para indicar que el valor 3 se va a

guardar en el espacio de memoria reservado para la variable llamada "radio").

Y qu ocurre si usamos una variable sin haberle dado valor? Esto pasa a
veces por despiste, si tecleamos mal el nombre de una variable, como en este
fragmento de programa:
primerNumero <- 2
Escribir

primerNmero

Si lees ese fragmento con cuidado, vers que el nombre de la variable que
aparece en la segunda lnea es incorrecto, falta la letra "u". Qu sucede en
ese caso? En algunos lenguajes (pocos, afortunadamente) se da por sentado
que es una variable nueva, y se le da el valor 0; en el caso de PseInt, igual que
en la mayora de lenguajes actuales, obtendremos un mensaje de error que
nos dir que estamos usando una variable que no tena valor.
Ejercicio de repaso propuesto 3.1: Crea un programa que escriba el
resultado de multiplicar los dos nmeros que introduzca el usuario
Ejercicio de repaso propuesto 3.2: Crea un programa que calcule la
superficie de un rectngulo a partir de su base y su altura, y que despus
muestre el valor de dicha superficie.
Ejercicio de repaso propuesto 3.3: Crea un programa que calcule la
superficie de un crculo a partir de su radio (la frmula es "PI * radio 2") y que
despus muestre el valor de dicha superficie (pista: para calcular el cuadrado
de un nmero basta con multiplicar el nmero por l mismo: x 2=x*x).

4 - Comprobando condiciones (1: Si)

En casi cualquier secuencia de instrucciones para un ordenador, ser vital
poder comprobar si se cumple alguna condici n. Una primera forma bsica de
comprobar condiciones es con la orden "SI". Su uso bsico sera
Si condicion Entonces
pasos_a_dar_si_es_verdadero
Si No

pasos_a_dar_si_es_falso
FinSi

El bloque "Si No" es opcional: podemos optar por no indicar lo que queremos
que se haga cuando no se cumpla la condici n.
Para ayudarnos a planificar el comportamiento de una secuencia de
instrucciones, se suele usar como ayuda los llamados "diagramas de flujo". En
estos diagramas, una condicin se representa como un rombo, del que salen
dos flechas: una para la secuencia de acciones a realizar si se cumple la
condicin y otra para cuando no se cumple:

As, si en PSeInt hacemos clic en el icono de la parte derecha que representa

la condicin SI, aparece un esqueleto de programa casi completo, para que
hagamos los cambios que nos interesen:

Slo tenemos que escribir la condicin que realmente nos interesa, y la serie
de pasos a dar si se cumple y si no se cumple, de modo que nuestro programa
podra quedar as :
Proceso Ejemplo004

Escribir "Dime un numero"

Leer primerNumero
Escribir "Dime otro numero"
Leer segundoNumero

Si primerNumero > segundoNumero Entonces

Escribir "El primero es mayor"

Sino
Escribir "El segundo es mayor"
FinSi

FinProceso

Su resultado sera ste:

En ese ejemplo hemos comparado si un valor es mayor que el otro ( >). Los
operadores de comparacin que tenemos disponibles son:
Operador relacional

Significado

Ejemplo

>

Mayor que

3>2

<

Menor que

"ABC"<"abc"

Igual que

4=3

<=

Menor o igual que

"a"<="b"

>=

Mayor o igual que

4>=5

Ejercicio de repaso propuesto 4.1: Crea un programa que pida un nmero al

usuario y diga si es positivo, negativo o cero.
Tambin podemos comprobar varias condiciones a la vez, para hacer
construcciones como: "si a es mayor que b y b es mayor que c", o como "si a
es igual a 1 o b es igual a 1 ". Los operadores lgicos que de los que
disponemos son:
Operador lgico

Significado

Ejemplo

&Y

Conjuncin (y).

(7>4) & (2=1) //falso

|O

Disyuncin (o).

(1=1 | 2=1) //verdadero

~ NO

Negacin (no).

~(2<5) //falso

Ejercicio de repaso propuesto 4.2: Crea un programa que pida un nmero al

usuario dos nmeros y diga cuntos de ellos son positivos.
Ejercicio de repaso propuesto 4.3: Crea un programa que pida un nmero al
usuario dos nmeros y muestre su divisin si el segundo no es cero, o un
mensaje de aviso en caso contrario.

5 - Comprobando condiciones (2:

Segun)
Es frecuente tener que comprobar ms de una condici n a la vez, o bien varias
condiciones consecutivas. En concreto, un caso espercialmente habitual es el
de que una variable pueda tomar distintos. Por ejemplo, ciertas notas
numricas tienen " nombres" en espaol: un 5 es un aprobado, un 9 y un 10
son sobresaliente, etc. Si queremos hacer un programa que convierta de la
nota numrica a su equivalente escrito, podr amos emplear varias rdenes IF,
una tras la otra. Pero en muchos lenguajes de programacin (y por tanto,

tambin en muchas variantes de pseudocdigo) existe una alternativa m s

compacta y ms legible: la orden "SEGUN". Esta rden permite hacer unas
cosas u otras segn el valor que tome una variable. Su uso sera as:
Segun variable Hacer
valor1: pasos_a_dar_si_es_el_valor1
valor2: pasos_a_dar_si_es_el_valor2
valor3: pasos_a_dar_si_es_el_valor3
De Otro Modo:
pasos_a_dar_si_es_otro_valor
FinSegun

El bloque "De Otro Modo" es opcional: si detallamos todos los valores posibles,
no sera necesario utilizarlo.
El nmero de valores que podemos probar es indefinido: no tiene por qu ser 3,
sino que pueden ser menos casos o muchos ms.
Segn la variante de pseudocdigo (o el lenguaje de programacin) que
empleemos, puede haberrestricciones en el tipo de datos que es aceptable.
Por ejemplo, en el caso de PseInt, la variable tiene que tener un valor
numrico, no puede ser un texto.
Al igual que ocurra con la orden SI, existe un s mbolo que podemos usar en
los diagramas de flujo para ayudarmos a planificar nuestro programa (aunqe
este smbolo est menos extendido que el de SI):

As, si en PseInt hacemos clic en el icono de la parte derecha que representa la

condicin SI, aparece un esqueleto de programa casi completo, para que
hagamos los cambios que nos interesen:

Slo tenemos que escribir la condicin que realmente nos interesa, y la serie
de pasos a dar si se cumple y si no se cumple, de modo que nuestro programa
podra quedar as :
Proceso EjemploCasos
Escribir "Introduzca la nota";
Leer nota;
Segun nota Hacer
10:

Escribir "Ha obtenido un sobresaliente alto";

9:
Escribir "Ha obtenido un sobresaliente bajo";
8:
Escribir "Ha obtenido un notable alto";
7:
Escribir "Ha obtenido un notable bajo";
6:
Escribir "Ha obtenido un aprobado alto";
5:
Escribir "Ha obtenido un aprobado";
De Otro Modo:
Escribir "Ha suspendido";
FinSegun
FinProceso

Su resultado sera ste:

Pero no siempre habr que comprobar condiciones una nica vez. Es muy
frecuente que haya que hacerlo de forma repetitiva. Por ejemplo, "pedir una
contrasea al usuario hasta que sea la correcta", o an ms cercano al mundo

real, "pedir una contrasea al usuario hasta que sea la correcta o agote sus
intentos". De eso hablaremos en la prxima entrega.
Ejercicio de repaso propuesto 5.1: Crea un programa que pida un nmero al
usuario un nmero de mes (por ejemplo, el 4) y escriba el nombre del mes
correspondiente (por ejemplo, "abril").

6 - Condiciones repetitivas (1:

Mientras)
Habitualmente, una condicin se deber comprobar ms de una vez. Por
ejemplo, una condicin de error puede repetirse: el usuario que introduce mal
una contrasea por primera vez puede equivocarse en una segunda ocasin.
Por eso, igual que cualquier lenguaje de programacin tiene una orden "si", la
gran mayora de ellos tendr una orden "mientras", que permite que un
fragmento de un programa se repita mientras una cierta condicin se siga
cumpliendo (por ejemplo, mientras la contrasea que teclee el usuario sea
incorrecta, el usuario deber volver a introducirla).
Tambin existe un smbolo habitual en los diagramas de flujo para representar
este tipo de condiciones repetitivas, en las que si se cumple la condicin, se
realiza una serie de acciones y se vuelve a comprobar la condicin, y as
sucesivamente hasta que la condicin no se cumpla:

Y en el caso de PseInt, ese icono generara un esqueleto de programa como

ste:

Por ejemplo, un programa capaz de sumar muchos nmeros, todos los que el
usuario quisiera, y en el que hubiera que escribir "0" para indicar que queremos
terminar, podra ser as:
Proceso Mientras01
Escribir "Dime un numero";
Leer x;
suma <- 0;
Mientras x <> 0 Hacer
suma <- suma + x;
Escribir "Hasta ahora, la suma es ", suma;
Escribir "Dime otro numero";
Leer x;
FinMientras
Escribir "Terminado";
FinProceso

Y su ejecucin mostrara algo como:

Hay ms formas de comprobar condiciones repetitivas. Pronto las veremos...

Ejercicio de repaso propuesto 6.1: Crea un programa que genere dos
nmeros al azar entre el 0 y el 100, y pida al usuario que calcule e introduzca
su suma. Si la respuesta no es correcta, deber volver a pedirla tantas veces
como sea necesario hasta que el usuario acierte.
Pista: como vers en el apartado 10, para generar un nmero al azar del 0 al
100 puedes hacer numero <- AZAR(101)

7 - Condiciones repetitivas (2: Repetirhasta)

Es tambin muy frecuente que un bloque de programa que quiz se repita,
deba ejecutarse al menos una vez. Por ejemplo, si queremos pedir un dato al
usuario, quiz exista alg n error y haya que insistir, pero al menos deberemos
ped rselo una primera vez.

En estos casos, la estructura "mientras" no es la m s adecuada: no podemos

comprobar la condicin al principio, sino despus de haber pedir el valor. En
estos casos (que son muy frecuentes), sera ms razonable usar otra
estructura de programacin en la que la condici n se compruebe despus de
dar ciertos pasos. Esa estructura es "repetir... hasta":
Su representacin en un diagrama de flujo sera:

Y en el caso de PseInt, ese icono generara un esqueleto de programa como

ste:

Por ejemplo, un programa que pida al usuario una clave de acceso, y que no le
permita seguir hasta que la introduzca correctamente, se podra hacer as:
Proceso Repetir01
Repetir
Escribir "Dime tu clave de acceso";
Leer clave;
Si clave <> 1234 Entonces
Escribir "Clave incorrecta";
FinSi
Hasta Que clave=1234
Escribir "Bienvenido!";
FinProceso

Cuyo resultado sera:

Queda otra forma de repetir fragmentos de programa. Pronto estaremos con

ella...

8 - Repetir un cierto nmero de veces:

Para
En muchas ocasiones, no querremos que algo se repita mientras se cumpla
una condicin, sino un cierto nmero de veces. Por ejemplo, para escribir
"Hola" 3 veces en pantalla existe una orden ms cmoda que la orden
"mientras" o la orden "repetir... hasta".
Es la orden "para", que hace que una variable tome una serie de valores que
se van incrementando. Por ejemplo, una estructura como "para x con valores
desde 2 hasta 4" hara que un bloque de programa se repitiera 3 veces. En la
primera repeticin, la variable "x" tendra el valor 2, en la segunda tendra el
valor 3 y en la tercera tendra el valor 4. La sintaxis exacta en PseInt es: "
Para variable <- valorInicial Hasta valorFinalHacer"

Su representacin en un diagrama de flujo sera:

Y en el caso de PseInt, ese icono generara un esqueleto de programa como

ste:

Por ejemplo, un programa que mostrara los nmeros del 1 al 10, podra ser:
Proceso Para01
Para x <- 1 Hasta 10 Hacer

Escribir x;
FinPara
FinProceso

Cuyo resultado sera:

Si no queremos avanzar de uno en uno, podemos indicar otro tamao de

"paso":
Proceso Para02
Para x <- 10 Hasta 20 Con Paso 2 Hacer
Escribir x;
FinPara
FinProceso

Y obtendramos:

Hemos visto casi todas las construcciones que podremos encontrar en los
lenguajes de programacin convencionales (y, por tanto, al planificarlos usando
pseudocdigo). En la prxima entrega veremos alguna otra posibilidad, como el
manejo de matrices y las funciones matemticas, para pasar despus a
algunos ejemplos completos.
Ejercicio de repaso propuesto 8.1: Crea un programa que escriba los
mltiplos del 3, desde el 3 hasta el 30.
Ejercicio de repaso propuesto 8.2: Crea un programa que escriba los
nmeros del 20 al 10, descendiendo.
Ejercicio de repaso propuesto 8.3: Crea un programa que escriba la tabla de
multiplicar del 5: desde "5 x 0 = 0" hasta "5 x 10 = 50"

9 - Matrices
Cuando necesitamos manejar muchos datos, generalmente hay soluciones
ms efectivas que tener muchas variables. Por ejemplo, si hay que guardar 100
nmeros, suele ser ms eficiente almacenar esos 100 datos "juntos", formando
una "matriz", en vez de usar 100 variables distintas.

La palabra "matriz" es una traduccin del ingls "array". Algunos autores lo

traducen alternativamente como tabla, vector o incluso "arreglo".
Normalmente, en una matriz podremos acceder individualmente a cada uno de
sus elementos usando corchetes: el primer dato ser a algo como "dato[1]".
Vamos a ver un ejemplo que nos pida 6 datos y luego los muestre en orden
contrario al que se han introducido:
Proceso MostrarAlReves

Dimension datos[6]

Para i <- 1 Hasta 6 Hacer

Escribir "Dime el dato numero ", i
Leer datos[i]
FinPara

Escribir "Los datos al reves son: "

Para i <- 6 Hasta 1 Con Paso -1 Hacer
Escribir datos[i]
FinPara

FinProceso

Que mostrara algo como:

(Haremos ejemplos ms avanzados como parte de los ejercicios)

Ejercicio de repaso propuesto 9.1: Crea un programa que pida un nmero al
usuario un nmero de mes (por ejemplo, el 4) y diga cuntos das tiene (por
ejemplo, 30). Debes usar una matriz.

10 - Funciones matemticas.
Casi cualquier lenguaje de programacin tiene incorporadas ciertas funciones
matemticas, de modo que nos permita calcular races cuadradas, logaritmos,
senos y cosenos, etc.
Lo mismo ocurre en muchas variantes de pseudocdigo. Por ejemplo, PseInt
incluye las siguientes funciones matemticas:

Funcin

Significado

RC(X)

Raz Cuadrada de X

ABS(X)

Valor Absoluto de X

LN(X)

Logaritmo Natural de X

EXP(X)

Funcin Exponencial de X

SEN(X)

Seno de X

COS(X)

Coseno de X

TAN(X)

Tangente de X

ASEN(X)

Arco seno de X

ACOS(X)

Arco coseno de X

ATAN(X)

Arco tangente de X

TRUNC(X)

Parte entera de X

REDON(X)

Entero ms cercano a X

AZAR(X)

Entero aleatorio entre 0 y x-1

(Si no sabes qu hace alguna de estas funciones, no te preocupes mucho, es

seal de que hasta ahora no la has necesitado... ;-) Las ms importantes de
ellas las probaremos directamente como parte de los ejercicios)
Ejercicio de repaso propuesto 10.1: Crea un programa que genere un
nmero al azar entre el 1 y el 100. El usuario tendr 7 oportunidades para
adivinarlo. Tras cada intento, se le dir si se ha pasado o se ha quedado corto.

11 - Ejercicios resueltos
a) Enunciados
1.- Crear un algoritmo que escriba "Hola" cinco veces.
2.- Crear un algoritmo que pida al usuario un nmero y le diga si es positivo,
negativo o cero.
3.- Crear un algoritmo que pida al usuario 5 datos y muestre su suma.
4.- Crear un algoritmo que calcule la raz cuadrada del nmero que introduzca
el usuario. Si se introduce un nmero negativo, debe mostrar un mensaje de
error y volver a pedirlo (tantas veces como sea necesario).
5.- Crear un algoritmo que pida al usuario un nmero y un smbolo, y dibuje un
cuadrado usando ese smbolo. El cuadrado tendr el tamao que ha indicado
el usuario. Por ejemplo, si el usuario introduce 4 como tamao y * como
smbolo, deber escribirse algo como:
****
****
****
****

b) Ejemplos de soluciones con PseInt

1.- Crear un algoritmo que escriba "Hola" cinco veces.
// 1.- Crear un algoritmo que escriba "Hola" cinco veces.

Proceso Resuelto01
Para x <- 1 Hasta 5 Hacer
Escribir "Hola";
FinPara

FinProceso

2.- Crear un algoritmo que pida al usuario un nmero y le diga si es positivo,

negativo o cero.
// 2.- Crear un algoritmo que pida al usuario un numero y le diga si
es positivo, negativo o cero.

Proceso Resuelto02
Escribir "Dime un numero";
Leer x;
Si x > 0 Entonces
Escribir "Es positivo";
Sino
Si x < 0 Entonces
Escribir "Es negativo";
Sino
Escribir "Es cero";
FinSi
FinSi
FinProceso

3.- Crear un algoritmo que pida al usuario 5 datos y muestre su suma.

// 3.- Crear un algoritmo que pida al usuario 5 datos y muestre su
suma.
// Forma (a), sin usar matrices

Proceso Resuelto03
suma <- 0
Para x <- 1 Hasta 5 Hacer
Escribir "Dime un dato";
Leer x;
suma <- suma + x;
FinPara
Escribir "Su suma es ", suma;

FinProceso

o de forma alternativa, usando matrices:

// 3.- Crear un algoritmo que pida al usuario 5 datos y muestre su
suma.
// Forma (b), usando matrices

Proceso Resuelto03

Dimension dato[5]

Para x <- 1 Hasta 5 Hacer

Escribir "Dime un dato";
Leer dato[x];
FinPara

suma <- 0

Para x <- 1 Hasta 5 Hacer

suma <- suma + dato[x];
FinPara

Escribir "Su suma es ", suma;

FinProceso

4.- Crear un algoritmo que calcule la raz cuadrada del nmero que introduzca
el usuario. Si se introduce un nmero negativo, debe mostrar un mensaje de
error y volver a pedirlo (tantas veces como sea necesario).
// 4.- Crear un algoritmo que calcule la raz cuadrada del nmero
// que introduzca el usuario. Si se introduce un nmero negativo,
// debe mostrar un mensaje de error y volver a pedirlo
// (tantas veces como sea necesario).

Proceso Resuelto04

Repetir
Escribir "Dime un numero";
Leer x;
Si x < 0 Entonces
Escribir "No puede ser negativo";
FinSi
Hasta Que x >= 0

Escribir "Su raiz es ", rc(x);

FinProceso

5.- Crear un algoritmo que pida al usuario un nmero y un smbolo, y dibuje un

cuadrado usando ese smbolo. El cuadrado tendr el tamao que ha indicado
el usuario.
(No funcionar correctamente en versiones de PseInt anteriores a agosto de
2011)
// 5.- Crear un algoritmo que pida al usuario un nmero y un smbolo,
// y dibuje un cuadrado usando ese smbolo. El cuadrado tendr el
tamao
// que ha indicado el usuario.

// No funciona con versiones de PseInt de antes de Agosto de 2011,

// porque las versiones previas a la 20110801 no permiten escribir
// sin avanzar de linea

Proceso Resuelto05
Escribir "Dime el lado";
Leer lado;

Escribir "Dime el simbolo de relleno";

Leer simbolo;

Para fila<-1 Hasta lado Hacer

Para columna <- 1 Hasta lado Hacer

Escribir Sin Saltar simbolo ; // Escribir sin bajar de lnea
FinPara

Escribir "";

// Avance de lnea tras cada fila

FinPara

FinProceso

12 - Ejercicios propuestos
1.- Crear un algoritmo que pida al usuario 10 datos y muestre su promedio.
2.- Crear un algoritmo que calcule la raz cuadrada del nmero que introduzca
el usuario. Si se introduce un nmero negativo, debe mostrar un mensaje de
error y volver a pedirlo (tantas veces como sea necesario).
3.- Crear un algoritmo que pida al usuario 3 datos y diga cual es el mayor de
los tres.
4.- Crear un algoritmo que pida al usuario 5 datos, luego le pida un valor con el
que comparar, y finalmente diga cuales de esos 5 datos son mayores que el
valor de comparacin.
5.- Crear un algoritmo que resuelva una ecuacin de segundo grado del tipo
ax2+bx+c=0. Las soluciones son x1 = (- b + raiz (b2 - 4ac)) / (2 a) , x2 = (- b - raiz
(b2 - 4ac)) / (2 a)
6.- Crear un algoritmo que genere un nmero al azar entre el 1 y el 1000, y d
al usuario la oportunidad de acertarlo en 10 intentos. Tras cada intento se le
dir si ha acertado (y en ese caso terminar la ejecucin), si se ha quedado
corto o si se ha pasado.

7.- Crear un algoritmo que pida al usuario una cantidad no definida de datos y
calcule su suma. Debe estar preparado para un mximo de 100 nmeros, que
pedir de uno en uno. Cuando se introduzca un valor 0, mostrar la suma de
todos los anteriores y terminar la ejecucin.
8.- Crear un algoritmo que pida al usuario que introduzca una frase, y diga
cuntas veces contiene la letra A (ya sea en maysculas o en minsculas).

13 - Funciones de cadenas de texto

Desde octubre de 2012, PseInt incluye ciertas funciones de manejo de cadenas
de texto que es habitual encontrar en casi cualquier lenguaje de programacin.
Las dos ms sencillas son las que permiten convertir un texto a maysculas y a
minsculas:
Proceso Cadenas01
Escribir "Dime tu nombre"
Leer nombre

Escribir "En maysculas quedara:"

Escribir Mayusculas(nombre)

Escribir "En minsculas quedara:"

Escribir Minusculas(nombre)
FinProceso

Para resolver problemas reales de computacin, hay otras dos funciones que
dan mucho ms juego: una nos dicen la longitud de una cadena y otra permite
extraer una subcadena, desde cierta posicin inicial hasta cierta posicin final:
Proceso Cadenas02
Escribir "Dime tu nombre"
Leer texto

Escribir "Con espacios quedara:"

Para x <- 1 Hasta Longitud(texto) Hacer
Escribir Sin Saltar Subcadena(texto, x, x)
Escribir Sin Saltar " "
FinPara
Escribir ""
FinProceso

(Si dejamos las opciones de PseInt sin modificar, las posiciones dentro de la
cadena se empezarn a contar desde uno; ya sabemos, como vimos en el
apartado sobre "Matrices", que en muchos otros lenguajes de programacin se
empieza a contar desde cero).
Tambin tenemos la posibilidad de "concatenar" dos cadenas, para formar una
nueva cadena a partir de esas dos seguidas. As el quinto ejercicio resuelto se
podra plantear tambin creando una Pero todava no est tan bien como
debera: siempre estamos escribiendo 20 guiones, aunque el texto sea ms
largo o ms corto. En la mayora de lenguajes de programacin se puede
indicar detalles adicionales ("parmetros") para que se puedan utilizar desde
dentro de esa subrutina. Por ejemplo, en nuestro caso podramos indicarle qu
texto queremos escribir y qu longitud queremos que tenga la secuencia de
guiones:
// Crear un algoritmo que pida al usuario un nmero y un smbolo,
// y dibuje un cuadrado usando ese smbolo. El cuadrado tendr el
// tamao que ha indicado el usuario.

// Versin concatenando cadenas.

// No funciona con versiones de PseInt de antes de Octubre de 2012

Proceso Resuelto05b
Escribir "Dime el lado"
Leer lado

Escribir "Dime el simbolo de relleno"

Leer simbolo

filaDeSimbolos <- ""

Para columna <- 1 Hasta lado Hacer
filaDeSimbolos <- Concatenar( filaDeSimbolos, simbolo )
FinPara

Para fila<-1 Hasta lado Hacer

Escribir filaDeSimbolos
FinPara

FinProceso

Ejercicios propuestos:
1. Crea un programa que pida su nombre al usuario y lo escriba al revs (de
principio a fin)
2. Crea un programa que pida su nombre al usuario y lo escriba alternando letras
maysculas y minsculas (por ejemplo, "Nacho" se mostrara como "NaChO"
3. Crea un programa que pida su nombre al usuario y diga cuntas vocales
contiene

14 - Creacin de funciones y
procedimientos (subprocesos)
En muchos casos, nos encontraremos con tareas que tenemos que repetir
varias veces en distintos puntos de nuestro programa. Si tecleamos varias
veces el mismo fragmento de programa no slo tardaremos ms en escribir:
adems el programa final resultar menos legible, ser ms tambin ser ms
fcil que cometamos algn error alguna de las veces que volvemos a teclear el
fragmento repetitivo, o que decidamos hacer una modificacin y olvidemos
hacerla en alguno de los fragmentos. Por eso, conviene evitar que nuestro

programa contenga cdigo repetitivo. Una de las formas de evitarlo es usar

"subrutinas", una posibilidad que permite casi cualquier lenguaje de
programacin, y que en ocasiones recibe el nombre de "procedimientos" o de
"funciones" (a veces, con algn matiz que hace que esas palabras no sean
realmente sinnimos).
PseInt permite definir "subrutinas" (o "funciones") dentro del pseudocdigo,
desde la versin del 10 de octubre de 2012. En su caso, se llaman
"subprocesos". Veamos un ejemplo de su uso:
Vamos a empezar por crear un subproceso (o "subrutina", o "procedimiento")
que escriba 20 guiones, que podramos utilizar para subrayar textos. Un
programa completo que escribiera tres textos y los subrayara podra ser:
Proceso SubProcesos01
Escribir " Primer ejemplo"
Para x <- 1 Hasta 20 Hacer
Escribir Sin Saltar "-"
FinPara
Escribir ""

Escribir " Segundo ejemplo"

Para x <- 1 Hasta 20 Hacer
Escribir Sin Saltar "-"
FinPara
Escribir ""

Escribir " Tercer ejemplo"

Para x <- 1 Hasta 20 Hacer
Escribir Sin Saltar "-"
FinPara
Escribir ""
FinProceso

Muy repetitivo. Sera un poco ms elegante si lo reescribimos as:

Proceso SubProcesos02
Escribir " Primer ejemplo"
Subrayar

Escribir " Segundo ejemplo"

Subrayar

Escribir " Tercer ejemplo"

Subrayar
FinProceso

Subproceso Subrayar
Para x <- 1 Hasta 20 Hacer
Escribir Sin Saltar "-"
FinPara
Escribir ""
FinSubproceso

Mucho ms legible. Pero todava no est tan bien como debera: siempre
estamos escribiendo 20 guiones, aunque el texto sea ms largo o ms corto.
En la mayora de lenguajes de programacin se puede indicar detalles
adicionales ("parmetros") para que se puedan utilizar desde dentro de esa
subrutina. Por ejemplo, en nuestro caso podramos indicarle qu texto
queremos escribir y qu longitud queremos que tenga la secuencia de guiones:
Proceso SubProcesos03
EscribirSubrayado(" Primer ejemplo", 16)
EscribirSubrayado(" Segundo ejemplo", 17)
EscribirSubrayado(" Tercer ejemplo", 16)
FinProceso

Subproceso EscribirSubrayado(texto, cantidad)

Escribir texto
Para x <- 1 Hasta cantidad Hacer
Escribir Sin Saltar "-"

FinPara
Escribir ""
FinSubproceso

Aunque todava es un poco redundante: en general, querremos escribir tantos

guiones como letras tenga el texto, as que no ser necesario indicar ese dato.
Desde octubre de 2012, PseInt incluye ciertas funciones predefinidas para
manejo de cadenas de texto; una de ellas es "Longitud", que nos indica la
cantidad de letras que tiene un texto, de modo que nuestro programa se podra
simplificar as:
Proceso SubProcesos04
EscribirSubrayado("Primer ejemplo")
EscribirSubrayado("Segundo ejemplo")
EscribirSubrayado("Tercer ejemplo")
FinProceso

Subproceso EscribirSubrayado(texto)
Escribir texto
Para x <- 1 Hasta Longitud(texto) Hacer
Escribir Sin Saltar "-"
FinPara
Escribir ""
FinSubproceso

Tambin podemos crear funciones que realicen ciertas operaciones aritmticas

y devuelvan un resultado, como las funciones matemticas que vimos en el
tema 10. Se puede hacer con la misma palabra "subproceso" que hemos
empleado hasta ahora, pero muchos lenguajes de programacin distinguen
entre un "procedimiento" o "subrutina", cuando se da una serie de pasos pero
no se devuelve ningn valor, y una "funcin", cuando s se devuelve un
resultado, as que usaremos esta ltima nomenclatura. Se parece mucho a lo

que hemos hecho hasta ahora, con la diferencia de que escogeremos un

nombre para la variable que guardar el resultado, as:
Funcion resultado <- Maximo( n1, n2)
Si n1 > n2

Entonces

resultado <- n1
Sino
resultado <- n2
FinSi
FinFuncion

Proceso Funciones01
Escribir "El mximo de 5 y 12 es:"
Escribir Maximo(5,12);
Escribir "El mximo de 25 y 12 es:"
Escribir Maximo(25,12);
Finproceso

Este programa crea una funcin que calcula cul es el mayor de los dos
nmeros que se le indican como parmetro, y la usa dos veces, para mostrar el
mximo de dos valores prefijados.
No slo pdemos devolver valores numricos; tambin podemos devolver
cadenas (como las funciones que vimos en el apartado 13) o "valores de
verdad" (verdadero, falso). Por ejemplo, podemos crear una funcin que diga si
un nmero es primo o no (lo vamos a hacer de la forma ms simple pero
tambin de la menos eficiente: aplicar la definicin, probando a dividir entre
todos los nmeros que hay entre 1 y n; si hemos encontrado dos divisores -o
menos, para el nmero uno-, entonces el nmero es primo):
SubProceso resultado <- Primo ( num )
cantidadDivisores <- 0
Para cont <- 1 Hasta num Hacer
Si num % cont = 0 Entonces
cantidadDivisores <- cantidadDivisores + 1

FinSi
Fin Para
Si cantidadDivisores <= 2 Entonces
resultado <- verdadero
Sino
resultado <- falso
Fin Si
Fin SubProceso

Proceso PrimosDel1Al30
Para n <- 1 hasta 30
si Primo(n) Entonces
Imprimir n
FinSi
FinPara
FinProceso

Hay ms detalles que comentar sobre funciones, pero son un poco ms

avanzados, as que vamos a descansar un poco aqu de nuevos conceptos y a
practicar lo que hemos visto...

Ejercicios propuestos:
1. Crea un subproceso que reciba como parmetro un texto y lo escriba centrado
en pantalla (suponiendo una anchura de 80 columnas)
2. Crea una funcin que reciba un nmero entero y devuelva la cantidad de
divisores (por ejemplo, para el nmero 16, sus divisores son 1, 2, 4, 8, 16,
luego la respuesta debera ser 5).
3. Crea un programa que pida dos nmero enteros al usuario y diga si alguno de
ellos es mltiplo del otro. Crea una funcin EsMultiplo que te ayude a que el
proceso principal sea legible.