Lecturas de Cátedra

Problemas
y algoritmos
Un enfoque práctico

Edith Lovos
Martín Goin
ProBlEMas y algoritMOS
Lecturas de Cátedra

ProBlEMas y algoritMOS
UN eNfoqUe pRáctico

Edith Lovos
Martín Goin
 Utilice su escáner de
código QR para acceder a
la versión digital
Índice

Dedicatorias...................................................................................9
Agradecimientos............................................................................10
Prólogo..........................................................................................11
Capítulo 1. Conceptos básicos de programación...................................13
1.1. Etapas en la programació n....................................................................15
1.1. 1. Definición del problema................................................................16
1. 1. 2. Análisis del problema.........................................................................16
1. 1. 3. Diseñ o del algoritmo......................................................................16
1. 2. Pre y poscondiciones de un algoritmo..............................................17
1. 3. Ejercicios propuestos................................................................................18
1.4. Expresió n de algoritmos.........................................................................19
Capítulo 2. Diagramación lógica......................................................21
2.1. Programa FreeDFD...............................................................................23
2. 2. ¿Qué son las variables?.............................................................................27
2. 2. 1. Có mo darle valor a una variable.....................................................28
2. 2. 2. Intercambio de variables...................................................................29
2. 3. Estructuras de control..............................................................................30
2. 3. 1. Estructura de control de decisió n o selecció n..........................30
2. 3. 1. 1. Estructura de control de decisió n simple..........................30
2. 3. 1. 2. Estructura de control de decisió n doble............................32
2. 3. 1. 3. Estructura de control de decisiones anidadas.................35
2. 3. 1. 4. Estructura de control de decisiones independientes 36
2. 4. Operadores de relació n............................................................................37
2. 5. Operadores ló gicos.....................................................................................37
2. 5. 1. Conjunción ló gica o producto ló gico «and»...........................38
2. 5. 2. Disyunción ló gica inclusiva o suma ló gica «or»....................39
2. 5. 3. Negación o complemento ló gico «not»....................................39
2. 6. Otros operadores matemáticos especiales....................................43
2. 7. Problemas: Diagramació n ló gica – Estructura de control
de decisió n.............................................................................................48
2. 8. Estructura de control de repetició n...................................................50
2. 8. 1. Estructura de control de repetició n (sentencia «para»)........53
2. 8. 2. Variables como acumuladores........................................................55
2. 8. 3. Variable contadora...............................................................................55
2. 8. 4. Máximos y mínimos......................................................................62
2. 8. 5. Problemas: Diagramación ló gica – Estructura de control
de repetició n «para»............................................................................65
2. 8. 6. Estructura de control de repetició n (sentencia «mientras») 66
2.8. 7. Problemas: Diagramación ló gica – Estructura de control de
repetición «mientras».....................................................................72
Capítulo 3. Pseudocódigo..............................................................73
3. 1. PSeInt..................................................................................................73
3. 2. Operadores ló gicos....................................................................................80
3.3. Ejercicios: pseudocó digo.........................................................................87
Capítulo 4. Entorno de programación visual........................................89
4.1. Variables del programa DaVinci.......................................................93
4. 2. Conociendo la ciudad del robot............................................................94
4. 2. Repetició n.........................................................................................97
4. 3. Modularizació n..............................................................................106
4. 4. Parámetros formales y reales...............................................................110
4. 5. Variables globales y locales...................................................................112
4. 6. Ejercicios Da Vinci..............................................................................114
Dedicatorias

Se resume en el siguiente diagrama de Venn

DedicaTORia |9
Agradecimientos

Al Centro Interdisciplinario de Estudios sobre Derechos, Inclusió n y

Socie- dad (ciedis), al área de Desarrollo Estudiantil y al Departamento de
Asun- tos Estudiantiles de la Universidad Nacional de Río Negro (unRn).

20 | LOVOs y GOin
Prólogo

Este libro surge en el marco de una actividad de formació n denominada Cur-

so virtual de resolución de problemas usando algoritmos. Un espacio para el desarrollo
de competencias (Res. 683/2016) que se lleva adelante a través del Programa de
Mejora de las Ciencias Exactas y Naturales en la Escuela Secundaria. Como
resultado de esa actividad, el libro busca promover en el lector el desarrollo
de su capacidad analítica y creadora, mejorando su destreza en el diseñ o de
algoritmos que sirven como base para el desarrollo de programas.
La enseñ anza y aprendizaje de la programació n es una actividad com-
pleja tanto para docentes como para estudiantes. En este sentido, este libro
busca ser una herramienta de apoyo. En él se exponen numerosos ejemplos
y se intenta ayudar y acompañ ar al lector a resolver los problemas
planteados.
El libro funciona como un tutorial que explica paso a paso, las bases
de la programació n de modo muy sencillo. Está orientado a los primeros
cursos de grado de carreras –ingenierías, profesorados, licenciaturas,
tec- nicaturas– que incluyan asignaturas vinculadas a la programació n. De
esta forma, resulta ideal para aquellos estudiantes que incursionan por
primera vez en el mundo de la programació n.
El material se divide en cuatro capítulos. El primero es un
resumen teó rico en el que se abordan los conceptos bá sicos de la
programació n. El segundo capítulo tiene por objetivo avanzar de modo
progresivo en el proceso de resolució n de problemas con algoritmos
usando como recurso el diagrama de flujo para su representació n. Con la
intenció n de facilitar el proceso cognitivo se utilizará el software
FreeDFD, que es de uso libre y gratuito. Este capítulo incluye cerca de 30
ejemplos prácticos que per- miten probar el programa y verificar los
resultados. Además aborda los siguientes temas: variables, intercambio,
estructuras de control de deci- sió n (simple, doble, decisiones anidadas e
independientes), operadores (de relació n, ló gicos, matemáticos
especiales), estructuras de control e ite- ració n («para», «mientras»),
variables contadoras y sumadoras, máximos y mínimos. El tercer
capítulo presenta el pasaje del diagrama de flujo al pseudocó digo, si
bien no es programable, la intenció n es aproximarnos al lenguaje de
programació n realizando una traducció n del modo gráfico al có digo
(texto). Se propone el uso del software PSeInt de carácter libre y gratuito.
Esta herramienta, al igual que FreeDFD, permite la ejecució n de los
algoritmos posibilitando la autocorrecció n. Por ú ltimo, se presenta un
capítulo especial dedicado a la resolució n de problemas usando el aplica-
tivo visual DaVinci Concurrente.

PRÓlOGO | 11
 De esta forma se ofrecen diversas herramientas de asistencia en el
aprendizaje de los conceptos básicos de programació n, sumado a un con-
junto de ejemplos.
En el libro se presentan ejemplos prácticos resueltos. Además se pro-
pone un conjunto de situaciones problemáticas que le permitirán al
lector desarrollar las habilidades de resolució n de problemas usando
algoritmos.

12 | LOVOs y GOin
Capítulo 1
Conceptos básicos de programación
Aprender a programar es programar para aprender
Mitchel Resnick (1956)
La frase pertenece al destacado profesor, físico, informático, periodista
y programador. Participó del diseño y desarrollo del Scratch (lenguaje
de programación para educación, 2005).

Fuente: Joi Ito, 2011.

Vivimos en un mundo donde la tecnología tiene un protagonismo muy

importante en nuestra vida cotidiana. Usamos cajeros automáticos, reali-
zamos diferentes transacciones (bancarias, comerciales y otras) a través de
la web, buscamos informació n en Internet, nos mantenemos comunicados
a través de dispositivos mó viles (celulares, tabletas, etcétera), nos ubicamos
y jugamos usando tecnología de geoposicionamiento (Gps). La tecnología
está íntimamente relacionada a la programació n; sin esta nada tiene sen-
tido, nada funciona. Cuando hablamos de programació n, la asociamos a
la palabra informá tica.

La Real Academia Española, define la palabra informática como:

«El conjunto de conocimientos científicos y técnicas que hacen
posible el tratamiento automático y racional de la información por
medio de computadoras.»

Ahora bien, se deben precisar las respuestas a las siguientes preguntas:

¿Qué es informació n? ¿Qué significa tratar la informació n? ¿Qué significa
que una parte del tratamiento sea automático y otra racional?
Se entiende por informació n a los hechos y representaciones de una
situació n, los cuales pueden o no tener relació n. La informació n, para
que pueda ser tratada por una máquina (computadora), necesita ser
codificada en un lenguaje entendible por la má quina.
Entonces, hablar de tratamiento automá tico significa que será la má-
quina (autó mata) la que llevará adelante el proceso. ¿Y có mo se logra esto?
Se logra codificando el razonamiento humano a través de una secuencia de
instrucciones (programa).

COncepTOs BásicOs de |
pROGRaMación
 En la actualidad, programar no es una actividad reservada solo a
unas pocas personas (técnicos, ingenieros, expertos, licenciados,
etcétera), mu- chas lo toman como un juego, un beneficio, un desafío y
hasta una afició n.
Como en toda disciplina, hay áreas que son más sencillas de aprender
y otras no tanto. Empezar por algo muy accesible nos dará el gusto de
co- menzar a programar. Luego, la creació n de soluciones más elaboradas
para problemas más complejos nos ayudará a incorporar conocimientos.
Mientras existan la creatividad y las ganas de aprender tendremos la
libertad de programar.
Si tenemos que definir el término programació n, decimos que es la
ac- ció n y el efecto de programar.
Programar es lo más cercano que tenemos a un superpoder
Drew Houston (1983)
Creador de Dropbox (almacenamiento de archivos en la nube para trabajar y compar

Fuente: Adaptado de Financial Times, 2011.

Los programadores son los magos del futuro

Gabe Newell (1962)
Director general de Valve Software (empresa desarrolladora de videojuegos)

Fuente: Game Developers Choice Awards, 2010.

El verbo programar tiene varios usos. Se refiere a idear y ordenar las ac-
ciones que se realizarán en el marco de un proyecto, como por ejemplo
la preparació n de máquinas para cumplir con una cierta tarea específica,
la preparació n de un espectáculo deportivo o artístico, la preparació n de
da- tos necesarios para obtener la solució n de un cálculo a través de una
calcu- ladora, el diseñ o del sistema y la distribució n de materias para una
carrera o de temas para un curso o asignatura, etcétera.
En la actualidad, la noció n de programació n se encuentra má s asocia-
da a la programació n en ciencias informáticas. En este sentido,
programar
14 | LOVOs y GOin
podría resumirse como el proceso por el cual un programador escribe,
prueba, depura y mantiene un có digo a partir del uso de un lenguaje de
programació n. Así, aprender a programar implica aprender ciencia y tec-
nología. La tecnología puede verse como el conjunto de herramientas, téc-
nicas y estándares que permiten llevar adelante la programació n. Al hablar
de ciencia se hace referencia a una teoría amplia y profunda que permite
entender la programació n. Ambos conocimientos son importantes, ya que
posibilitan enfrentar los retos de la evolució n tecnoló gica.
Por otra parte, en estos tiempos, como señ alan Patricia Compañ -Rosique
y otros (2015), la programació n es una vía posible para el desarrollo del pen-
samiento computacional. Es decir, hacer uso de conceptos fundamentales de
la informática para resolver problemas del quehacer cotidiano.

1. 1. Etapas en la programación

En la figura 1.1 se muestran las etapas para el desarrollo de un programa:

Figura 1. 1. Etapas de la programación

COncepTOs BásicOs de |
pROGRaMación
 En este libro abordaremos las tres primeras: definició n del problema,
aná lisis del problema y diseñ o del algoritmo.

1. 1. 1. Definición del problema

Esta fase está dada por la especificació n del problema, el cual requiere una
definició n clara y precisa. Es importante saber lo que se desea que realice la
computadora; mientras esta definició n no sea lo suficientemente clara,
no tiene mucho sentido continuar con la siguiente etapa.

1. 1. 2. Análisis del problema

Esta fase requiere de una clara definició n en la que se contemple exacta-

mente qué debe hacer el programa y el resultado o la solució n deseada.

Entonces es necesario definir:

• datos de entrada (tipo y cantidad);
• datos de salida (tipo y cantidad);
• los métodos y las operaciones que se necesitan para procesar los datos.

En esta etapa se determina qué debe hacer el programa para resolver el

problema, es decir, la solució n al mismo.
Una recomendació n muy práctica es la de ponernos en el lugar de la
computadora y analizar qué es lo que necesitamos ordenar y en qué se-
cuencia, para producir los resultados esperados.

1. 1. 3. Diseño del algoritmo

En esta etapa se determina cómo debe ser el proceso que lleva a la

resolució n del problema. La palabra algoritmo deriva del nombre de un
matemático árabe del siglo ix, llamado Al-Khuwarizmi, quien describió
varios métodos para resolver cierto tipo de problemas aritméticos.
El diseñ o de algoritmos es un recurso fundamental que permite
resol- ver problemas relacionados con casi todas las disciplinas.
La intenció n de este libro es que el lector adquiera las bases
necesarias para poder diseñ ar e implementar, de manera fácil y rápida,
soluciones algorítmicas.
Definició n de algoritmo: es una secuencia no ambigua, finita y
ordena- da de pasos para poder resolver un problema.
• No ambigua implica que cada paso del algoritmo debe poder ser
in- terpretado de una única forma.
• Finita significa que la cantidad de pasos que componen el
algoritmo está limitada. El algoritmo empieza y termina.

16 | LOVOs y GOin
 • Orden. Los pasos del algoritmo deben seguirse en una determinada
secuencia para llegar a la solució n del problema.

Resumiendo, un algoritmo se puede pensar como una receta, un

conjunto de instrucciones o de especificaciones sobre un proceso para
hacer algo, que cumple con las características antes mencionadas.

Ejemplos
Problema 1: Indique la manera de endulzar una taza que contiene café.
Algoritmo A: Ponerle un poco de azúcar a la taza y revolver
Algoritmo B: Agregarle una cucharadita de azúcar a la taza, revolver y degustar.
El algoritmo A presenta una solución ambigua al problema planteado. ¿A cuánto
El algoritmo B presenta una solución adecuada al problema.

Problema 2: Desarrolle un algoritmo que describa la forma de determinar la su

En este caso, no es posible encontrar un algoritmo que resuelva el problema. Y

Problema 3: Llenar un pozo con piedras de un bolsón.

Algoritmo: Tomar una pala. Mientras haya piedras en el bolsón cargar la pala c
Esta solución es un algoritmo, ya que cada paso es no ambiguo. Por otra parte,
¿Qué sucedería si no contamos con la pala? ¿Se podría llevar adelante el proces

1. 2. Pre y postcondiciones de un algoritmo

Precondición: es la información que se conoce como verdadera antes de

comenzar el algoritmo.

COncepTOs BásicOs de |
pROGRaMación
Postcondición: es la información que se conoce como verdadera después de
finalizado el algoritmo, siempre que se cumpla con las precondiciones.

Problema 4: Determinar el resto de la división entera entre dos números ente

Precondición: N y M son números enteros. M debe ser distinto de 0. Postcondi

Problema 5: Indique la manera de endulzar una taza que contiene café.

Precondición: Contar con una cucharita y azúcar suflciente.
Poscondición: El café quedó dulce al finalizar el proceso.

Problema 6: Determinar si el número 437 es primo.

Algoritmo: Dividir el número 437 entre cada uno de los números 1, 2, 3, 4,..
436. Si una de las divisiones es exacta (resto 0), entonces el número 437 no
es primo, caso contrario es primo.
Precondición: No hay ningún requerimiento.
Poscondición: Se ha podido determinar si el número 437 es primo o no.

Preguntas: ¿Consideran que es una buena solució n?

¿Qué otra/s podrían pensarse?

1. 3. Ejercicios propuestos

1. Escriba un algoritmo que permita cambiar una lámpara quemada.

Indique pre y postcondiciones.
2. Escriba un algoritmo que indique có mo hacer un huevo frito. Indi-
que pre y postcondiciones. ¿En qué cambiaría el algoritmo si
quisié- ramos cocinar 3 huevos en lugar de 1?
3. Escriba un algoritmo para comprar 1 kg de pan migñ on en la pana-
dería de la esquina de casa.
4. Observe las dos soluciones que se presentan a continuació n e indique
si son o no un algoritmo. Si no lo son, modifíquelas para que lo sean.

18 | LOVOs y GOin
 Algoritmo 1 Algoritmo 2
Me visto rápidamente. Traer las herramientas que voy a usar.
Me levanto por la mañana. Hacer el arreglo con esmero.
Tomo una ducha de 10 minutos. Localizar el desperfecto
Tomo un té con leche y me voy. del depósito.
Termino de ducharme a las 7:25. Pasar la factura por el trabajo hecho.
Llego temprano al colegio. Organizar cómo voy a hacer el trabajo.
El reloj marca las 7:15. Ver qué tipo de arreglo necesita.
Comprobar la eficiencia del arreglo.

1. 4. Expresión de algoritmos

Para el diseñ o de un algoritmo puede utilizarse la diagramació n ló gica

(dl) y/o el pseudocó digo.
La diagramació n ló gica se basa en la representació n gráfica,
esquemá- tica de un algoritmo. Es altamente intuitiva y didá ctica e
implica la cons- trucció n de circuitos ló gicos utilizando símbolos,
mientras que el pseudo- có digo es la representació n descriptiva y textual
(en lenguaje natural, por ejemplo, el españ ol) de las operaciones que
realiza un algoritmo.
En este libro, vamos a trabajar con ambas, ya que consideramos que son
un buen complemento para iniciarnos en la actividad de programar solu-
ciones algorítmicas.
Para aquellos que incursionan por primera vez en el mundo de la progra-
mació n es recomendable comenzar con la utilizació n del diagrama de flujo.
Recordemos que el procedimiento de desarrollo de algoritmos es inde-
pendiente del lenguaje de programació n que utilicemos más adelante. Es
decir, una vez diseñ ado el algoritmo, este podrá ser luego escrito
(traduci-
do) en diferentes lenguajes de programació n.
Hasta aquí podemos resumir las características de un algoritmo:
• Debe tener un punto particular de inicio.
• Debe estar definido sin ambigü edades, es decir, no debe permitir
dobles interpretaciones.
• Debe ser general, es decir, soportar las variantes que puedan presen-
tarse en la definició n del problema.
• Debe ser finito en tamañ o y tiempo de ejecució n.

Adicionalmente, los algoritmos pueden requerir de datos de entrada

para producir datos de salida.

COncepTOs BásicOs de |
pROGRaMación
 Figura 1. 2. Algoritmo

Datos de entrada: un algoritmo tiene cero o más entradas, es decir la

informació n que recibe el algoritmo al comenzar o, dinámicamente, mien-
tras el algoritmo se ejecuta.
Procesamiento de datos: incluye las operaciones aritmético-ló gicas,
cuyo objetivo es obtener la solució n del problema.
Salida de resultados: permite comunicar al exterior el resultado. Un al-
goritmo puede producir una o má s salidas.

Entonces, la computadora es una máquina (herramienta) que por sí sola no

puede hacer nada, necesita ser programada, es decir, que se le suministren
instrucciones u ó rdenes indicándole aquello que debe hacer.
Un programa es la solució n a un problema inicial, así que todo comien-
za allí: en el problema. Así, dado un determinado problema es necesario
idear una solució n y expresarla algorítmicamente. Luego de esto, será
ne- cesario traducir el algoritmo (codificarlo) en un determinado
lenguaje de programació n y, por ú ltimo, ejecutar el programa en la
computadora. Esto es, a grandes rasgos, lo que hace el programador.
El diseñ o de algoritmos será tema de los pró ximos capítulos, comen-
zando con la diagramació n ló gica y luego con el pseudocó digo.

Proteo de las máquinas. Su esencia es su universalidad, su poder de simular.

Seymour Papert (1928-2016)
cación. Es uno de los pioneros de la inteligencia artificial y creador del Logo (lenguaje
de programación para educación).
Fuente: Adaptado de ak_mardini, 2006.

20 | LOVOs y GOin
Capítulo 2
Diagramación lógica

Vamos a dar inicio a este capítulo con un ejemplo muy sencillo:

El algoritmo permite el ingreso de dos nú meros, los suma y, por ú ltimo,

muestra el resultado.
Para poder comprender el concepto de este gráfico es necesario deter-
minar el significado de cada uno de sus componentes.
A continuació n se describen cada uno de los elementos utilizados en el
algoritmo:

Comienza el algoritmo.

Ingreso de datos (en estos casos se

trata de dos valores numéricos A y B).

Asignación (en este caso se le

asigna a la variable C la suma
de A y B, es decir C = A+B).

DiaGRaMaCión lóGiCa | 21
 Salida de datos (en este caso se
imprime lo que contiene la variable C)

Termina el algoritmo.

Las flechas indican la dirección del

circuito (de ahí viene el nombre flujo).

La lectura de un diagrama se hace de la misma manera que la lectura de

un libro (de izquierda a derecha y de arriba abajo).

Problema 1: Hallar el perímetro y el área de un rectángulo ingresando la base

Es posible observar que en una misma caja de asignació n se puede

ha- cer más de una operació n (en este caso para asignar el resultado del
cálculo del perímetro y del á rea de un rectá ngulo).

22 | LOVOs y GOin
Nota: En la salida se pueden alternar carteles (mensajes) y datos, mien-
tras los primeros estén entre comillas y ambos separados por comas. En
este caso será “El Perímetro es “,P,” y el Área es “,A.
Ejemplo: si ingresamos b y h como 3 y 5 entonces la salida imprime
lo siguiente: El Perímetro es 16 y el Área es 15
Atención: Las operaciones aritméticas en los algoritmos deben expresar-
se siempre en una línea, por ejemplo, si queremos realizar la
siguiente operació n:
B  9
C 2A
es necesario escribirla de la siguiente manera: C = (-B+9)/(2*A). El asterisco
* representa la multiplicació n y la barra inclinada a derecha / la divisió n.

2.1. Programa FreeDFD

Para trabajar con diagramas de flujos, se recomienda utilizar un

software libre y gratuito, FreeDFD 1.1. Este aplicativo fue desarrollado por
estudian- tes de la Universidad de Magdalena, Colombia, y se distribuye bajo
la licen- cia pú blica GNU (GPL).
Además de ofrecer un manejo muy sencillo, permite crear, editar, eje-
cutar y corregir (cuando se presentan errores) el diagrama de flujo para
verificar su funcionamiento.
El programa es muy intuitivo, por tratarse de una herramienta gráfica,
e incluye además un menú de ayuda muy completo.
En esta secció n nos centraremos en el uso básico de las herramientas de
diseñ o y depuració n.
El programa puede descargarse desde el sitio http://code.google.com/p/
freedfd. En Windows, el archivo comprimido llamado FreeDFD-1.1.zip, tie-
ne que ser descomprimido en una carpeta con su mismo nombre (esto es
automático). En el grupo de archivos de dicha carpeta aparecen tres ejecu-
tables (uno para cada idioma: portugués, inglés y españ ol), el nuestro será
la aplicació n ejecutable dfd-españ ol. En sistemas operativos GNU/Linux
puede instalarse usando el software Wine.
Al ingresar al programa nos encontraremos con la siguiente pantalla:

DiaGRaMaCión lóGiCa | 23
 Figura 1. 3. Pantalla FreeDFD

En la parte superior tenemos el menú principal para acceder a todas las

op- ciones posibles y, debajo, la barra de herramientas que funcionan como
atajos.
Má s abajo, el sector de edició n de trabajo. Siempre comienza con los
conectores «inicio» y «fin».
Respecto a la barra de herramientas o botones:

Figura 1. 4. Botones FreeDFD

Los objetos son los elementos que permiten representar la solució n

al problema. De izquierda a derecha son: cursor, asignació n, ciclo
«mientras», ciclo «para», decisió n, lectura, salida y llamada.
Por ejemplo, si queremos construir el primer diagrama de flujo del
ejemplo del libro tendríamos que seguir los siguientes pasos:

24 | LOVOs y GOin
1. Para introducir entre los conectores «inicio» y «fin» el símbolo de
ingreso, primero hacemos click en el ícono «lectura» de la barra «ob-
jetos» y luego nos acercamos con el mouse al destino deseado (a).
La mano nos indica el sector permitido para colocar el objeto, de
lo contrario aparecerá un cartel de prohibido (b).
Luego de elegir la ubicació n del objeto aparecen las marcas que indi-
can que está seleccionado (c).

a b c

2. Haciendo doble click sobre el objeto aparece la siguiente ventana.

Dentro de la caja escribiremos las variables de entrada, para nuestro

caso: A,B
3. La entrada está lista y se verá así:

DiaGRaMaCión lóGiCa | 25
 4. Luego de armar por completo el diagrama de flujo como se
observa en el primer ejemplo, hay que ponerlo a prueba, aunque
se reco- mienda primero guardar el archivo («Archivo» – «Guardar

como»).
5. Hacemos un click en el botó n «ejecutar» (barra de ejecució n) y
apa- rece la ventana («entrada de valores por teclado»).
Ingresamos entonces los valores (uno por cada entrada).

6. Luego muestra la salida (el resultado final) con la siguiente pantalla:

26 | LOVOs y GOin
 7. Si el programa funcionó sin generar errores, FreeDFD nos mostrará
la siguiente ventana:

Error de ejecució n: Si creamos el siguiente algoritmo y lo ejecuta-

mos, finalmente nos va a mostrar el error.

Y ademá s nos va a indicar en color rojo el objeto donde se produjo

el inconveniente. En este caso lo va a marcar en el objeto de salida
porque la variable C no contiene valor alguno.

Nota: Sería beneficioso probar el ejemplo con el error y luego realizar y

ejecutar el problema 1.

2. 2. ¿Qué son las variables?

Una variable es un espacio en la memoria de la computadora que

permite almacenar temporalmente informació n (dato) durante la
ejecució n del al- goritmo, y cuyo contenido puede cambiar mientras se
ejecuta el algoritmo.
Para reconocer una variable es necesario darle un nombre o etiqueta,
que permita identificarla.
Los nombres o etiquetas de las variables siempre deben empezar con
una letra y no pueden contener espacios en blanco. Si usamos má s de un
carácter para su identificació n empezamos con una letra y luego
podemos seguir con nú meros o letras. Está permitido usar “_” entre
medio.

DiaGRaMaCión lóGiCa | 27
Ejemplos válidos: A, a , B1 , A20 , AA1 , Aa1 , B2B , Promedio , SUMATORIA
, A_1 , b1_2
Ejemplos no validos: 1B , 2c , _S , ¿A, La variable

Se recomienda que el nombre de una variable represente el dato en sí y

que no sea extenso, algunos ejemplos:
Para una sumatoria → S
Para dos sumatorias → S1 , S2
Para la sumatoria de edades → SE
Para contar → C
Para un promedio → P o Prom
Para el promedio de edades de mujeres → PEM

Atención: No puede existir má s de una variable con el mismo nombre

(identificació n) en un mismo algoritmo y con distinta finalidad.

Las variables pueden contener informació n numérica como

alfanumé- rica, es decir letras y símbolos, siempre y cuando estos ú ltimos
sean expre- sados entre comillas.

Ejemplos: A1=”20” Nombre=”Sofía” Simbolo=”&”

En cambio, las variables que contienen nú meros no necesitan de las comillas.

Ejemplos: G1=20 Precio=129,85 Temperatura = -0,3

Analizar la diferencia entre las variables G1 y A1 de los ejemplos anterio-

res. No representan la misma informació n, en un caso es un valor
numérico y en otro una expresió n alfanumé rica.

Ejemplos: Calle=”San Martin” Numero=”201” Domicilio=”Moreno 77”

Nota: Los nombres de las variables no se acentú an.

El valor de las variables y el tipo de operaciones que se puede

realizar con ellas dependerá de si estas son numéricas o alfanuméricas.
En el caso de las variables numéricas, las cuatro operaciones aritméticas
básicas son:
suma (+), resta (–), divisió n (/) y multiplicació n (*).
En el caso de las variables alfanuméricas se puede utilizar el operador +,
para concatenar. Analicemos el problema 2.

28 | LOVOs y GOin
 2. 2. 1. Cómo darle valor a una variable

Existen dos formas de darle valor a una variable: a través de la asignació n o

a travé s de la lectura de un valor.
En FreeDFD para asignarle un valor podemos usar el operador de
asig- nació n ← o una funcionalidad propia del aplicativo que nos permite
leer un dato desde un dispositivo de entrada (ejemplo teclado).
Es importante recordar que una variable tiene un ú nico contenido en
un momento dado, es decir, un valor actual. Este valor puede cambiar du-
rante la ejecució n del programa, pero siempre será ú nico y no quedará re-
gistro de cuáles fueron los contenidos anteriores de la variable.
Problema 2: Ingresar un nombre y un apellido en distintas variables y luego most

Atención: Si se ingresa N=”Manuel” y luego A=”Belgrano” el resultado de

la suma será “ManuelBelgrano” (falta separar el nombre y el apellido),
en- tonces podríamos dejar un espacio en blanco al final de “Manuel “, o bien
al principio de “ Belgrano” para solucionarlo. ¡Hagan la prueba!

Pregunta: ¿Qué sucedería si se quita la instrucció n que permite la lectura

de A y N?

DiaGRaMaCión lóGiCa | 29
Importante: Una cuestió n problemá tica con las variables es su va-
lor o contenido inicial. En algunos lenguajes si una variable se usa
sin antes haberle asignado un valor, se le dará un valor por defecto,
mientras que en otros lenguajes eso podría generar un error duran-
te la ejecució n del programa. Entonces para evitar estas situacio-
nes, siempre que usemos una variable debemos darle un valor inicial.
Sugerencia: Editar y ejecutar los problemas propuestos en el software
FreeDFD para una mejor comprensió n.

2. 2. 2. Intercambio de variables

El intercambio (swap) de los valores de dos variables no es un procedimien-

to que pueda hacerse en forma directa, es decir, por ejemplo: si A=8 y
B=2 entonces si A=B (le asignamos a A el valor de B, se pierde el valor
original de A) y si luego hacemos B=A (le asignamos a B el valor de A),
finalmente los valores de A y B serán los mismos (en este caso ambos serán
iguales a 2).
Para solucionar esta situació n debemos usar una variable auxiliar.
Para el caso anterior será: C=A, A=B y B=C. Entonces ahora
tendremos A=2 y B=8. En este caso C será la variable auxiliar.
Recordemos que solo podemos intercambiar variables que tengan el
mismo tipo. ¿Qué sucede si dadas dos variables A=5 y B=7 intentamos llevar
adelante las siguientes operaciones: C=A, A=B, B=C?

Importante: El tipo de una variable especifica el conjunto de valores que

puede tomar y las operaciones que pueden hacerse con ella.

2. 3. Estructuras de control

Las estructuras de control permiten controlar el flujo de ejecució n de las

instrucciones del programa: tomar decisiones, realizar acciones repeti-
tivas, etcétera, dependiendo de unas condiciones que nosotros mismos
establezcamos.
El concepto de flujo de control se refiere al orden en que se ejecutan
las sentencias o acciones (instrucciones) de un programa.
En los ejemplos anteriores se ha trabajado con un flujo lineal también
llamado estructura secuencial, así las estructuras de control (de selecció n y
repetició n) permiten alterar este orden de ejecució n secuencial.

30 | LOVOs y GOin
 2. 3. 1. Estructura de control de decisión o selección

También llamada de alternativa, permite bifurcar el flujo de ejecució n del

programa en funció n de una expresió n ló gica o condició n ló gica.
Con frecuencia aparecen en algoritmos situaciones en las cuales se debe
elegir un camino dependiendo de los datos de entrada y la condició n impuesta.

El símbolo es un rombo acostado que tiene dos posibles salidas, como se observa en la figura

Una decisión puede clasificarse en simple,doble,anidadas y/o independientes.

2. 3. 1. 1. Estructura de control de decisió n simple

Veamos un ejemplo de un algoritmo que utiliza una decisió n simple.

Problema 3: Mostrar el perímetro de una circunferencia, siempre y cuando el rad

DiaGRaMaCión lóGiCa | 31
 En este caso, si al ejecutar el algoritmo se ingresa un valor de radio
negativo o cero, el programa simplemente termina, ya que solo funciona
cuando la condició n radio > 0 (expresió n ló gica) es verdadera.
Cuando se cumple la condició n dentro del rombo el flujo de datos va
para el lado del Sí, caso contrario se dirige hacia el No.

Atención: La estructura de control de decisió n debe tener como mí-

nimo una acció n a ejecutar en caso que se cumpla la condició n.
En el ejemplo anterior podríamos haber establecido la condició n del SI
con (radio < = 0) en vez de (radio > 0), entonces nos quedaría de la
si- guiente manera:

Lo cual es incorrecto.

32 | LOVOs y GOin
 2. 3. 1. 2. Estructura de control de decisió n doble

Esta estructura es similar a la anterior con la salvedad de que se indican

acciones no solo para la rama verdadera sino también para la falsa, es decir,
en caso de que la expresió n ló gica sea cierta se ejecuta una acció n o
grupo de acciones y, en caso de ser falsa, se ejecuta otro grupo de acciones.
Problema 4: Ídem al ejemplo anterior pero en el caso de ingresar un radio erró

Cuando es falsa la expresió n ló gica (radio > 0) se ejecuta el camino

que va en direcció n del No.

Nota: Los carteles en la salida siempre van entre comillas, en este

caso “ERROR”.

DiaGRaMaCión lóGiCa | 33
 Veamos otro ejemplo.
Problema 5: Se pide ingresar dos números y luego mostrar por mensaje cuál e

En las salidas es posible combinar cartel y variable (texto y nú meros).

Por ejemplo, probemos ingresar por pantalla los nú meros 3 y 7, entonces el
camino que tomará el algoritmo será el No, al ser falsa la condició n A>B,
en consecuencia su salida mostrará El mayor es 7.

Nota: ¿Qué sucede si ingresamos dos nú meros iguales? ¿Cuál sería el re-
sultado? Lo verificamos ejecutando el algoritmo.

Para solucionar el problema anterior debemos utilizar decisiones anidadas.

En el objeto de salida del diagrama se pueden combinar texto y variables como en el caso a

34 | LOVOs y GOin
 2. 3. 1. 3. Estructura de control de decisiones anidadas

Existe la posibilidad de tener una decisió n dentro de otra, a esto se lo llama

decisiones anidadas y se usa cuando tenemos más de una alternativa.
Para resolver el problema anterior (ingreso de dos nú meros iguales),
desarrolla- mos las indicaciones en el siguiente problema.
Problema 6: Mostrar el número más grande (entre dos) ingresado por teclado.
Si los dos números son iguales mostrar el cartel “Son iguales”.

Nota: Y si la primera condició n es A=B ¿Có mo cambiarías el algorit-

mo para que siga funcionando perfectamente? ¿Te animá s a hacerlo?
Atención: La anidació n también se puede hacer dentro del camino del Sí
y ademá s se podría producir má s de una vez.

DiaGRaMaCión lóGiCa | 35
 2. 3. 1. 4. Estructura de control de decisiones independientes

Las decisiones independientes son aquellas que se establecen sin depender

una de otras, es decir, sin estar relacionadas. Simplemente se ubican una
debajo de la otra y en cualquier orden, ya que el orden no afectará su ejecu-
ció n. Veamos un ejemplo.
Problema 7: Ingresar dos números por teclado y sumarlos. En caso que los n

Nota: En este caso tenemos dos decisiones simples que son independien-
tes (podrían estar en cualquier orden). La operació n N = (-1)*N hace cam-
biar el signo de negativo a positivo.

36 | LOVOs y GOin
2. 4. Operadores de relación

La siguiente tabla nos muestra los distintos operadores de relació n entre

dos nú meros:

Operador Significado Equivalente en

matemática
> Mayor que >
< Menor que <
>= Mayor o igual que ≥
<= Menor o igual que ≤
= Igual =
!= Distinto ≠

Nota: Es importante el orden en los símbolos cuando interviene el igual >=

y <=.

Estos operadores nos permiten establecer comparaciones entre variables.

Ejemplo: Establecer una comparación alfabética entre dos variables

alfanuméricas. Provincia1=”Neuquén” Provincia2=”Chubut” entonces
decimos que la expresión (Provincia1>Provincia2) es verdadera y la
expresión (Provincia1<Provincia2) es falsa.

2. 5. Operadores lógicos

Supongamos que quisiéramos saber si tres nú meros son iguales utilizando

decisiones. Una solució n posible sería:

DiaGRaMaCión lóGiCa | 37
 Es decir que una decisió n depende de la anterior.

Lo incorrecto es que suceda lo siguiente, ya que las desigualdades siempre deben relacion

Para solucionarlo es necesario trabajar con los operadores ló gicos «and»,

«or» y «not».

2. 5. 1. Conjunción lógica o producto lógico «and»

El efecto del operador «and» es la evaluació n simultánea del estado de ver-

dad de las variables ló gicas involucradas.
Así por ejemplo la expresió n ló gica: A and B, será verdadera ú nicamen-
te si A y B lo son. Cualquier otro estado para ambas variables dará como

38 | LOVOs y GOin
resultado el valor falso, puesto que basta con que una de las dos
variables tenga valor falso para que ambas no sean simultáneamente
verdaderas.

Variables lógicas Resultado

A B A and B
Verdadero Verdadero Verdadero
Verdadero Falso Falso
Falso Verdadero Falso
Falso Falso Falso

2. 5. 2. Disyunción lógica inclusiva o suma lógica «or»

El efecto de este operador es la evaluació n no simultánea del estado de ver-

dad de las variables ló gicas involucradas. Esto implica que al tener
estado verdadero por lo menos una de las variables afectadas, la operació n
dará un resultado verdadero.
Así tendremos que la expresió n: A or B, será falsa ú nicamente cuando
el estado de ambas variables sea falso. En cualquier otro caso, la operació n
será verdadera.

Variables lógicas Resultado

A B A and B
Verdadero Verdadero Verdadero
Verdadero Falso Verdadero
Falso Verdadero Verdadero
Falso Falso Falso

2. 5. 3. Negación o complemento lógico «not»

El efecto de este operador es negar el valor de la expresió n ló gica, como

se indica en la siguiente tabla.

Variables lógicas A Resultado not A

Verdadero Falso
Falso Verdadero

Veamos algunos ejemplos para poder comprender un poco más el concepto

de operadores ló gicos.

DiaGRaMaCión lóGiCa | 39
Problema 8: Solicitar al usuario un número natural y verificar que el número

Nota: La decisió n podría reescribirse como: (N>=1) and (N<=12).

No es posible indicarlo como: 1<=N<=12. Esto generaría un error, porque
no sería una expresió n ló gica.

Ahora el problema de los tres nú meros iguales se puede resolver usando

el operador ló gico «and» de la siguiente manera:

40 | LOVOs y GOin
 Nota: Si al evaluar (A=B) se obtiene un resultado falso entonces no es
necesario evaluar la expresió n (A=C). Esto se denomina evaluació n de
circuito corto, si la primera expresió n es falsa como el operador que las
vincula es un and aunque la segunda sea verdadera el resultado será
falso, de ahí que no tenga sentido realizar la evaluació n.

Una condició n puede expresarse en forma ló gica, usando más de un

operador (o, y, negació n). A continuació n se presenta un ejemplo.
Problema 9: Se ingresa por teclado la categoría de un socio del club deportivo So

DiaGRaMaCión lóGiCa | 41
 La expresió n ló gica: (Cat=’A’)or((Ant>=10)and(Ant<=20)) permite ase-
gurar que el socio cumple con las condiciones impuestas.

Atención: En FreeDFD para expresar un valor alfanumé rico es

necesa- rio usar comillas simples. Ejemplo: Cat ← ‘B’. En este caso a
la varia- ble Cat se le asigna el valor ‘B’. En cambio Cat=‘B’ expresa
una com- paració n entre el valor de la variable y el cará cter
alfanumé rico ‘B’. Es un error en una asignació n expresar ‘A’ ← Cat
porque la varia- ble debe ir a la izquierda y el valor asignado a la
misma a la derecha, pero si se tratara de una condició n da lo
mismo: Cat=‘A’ o ‘A’=Cat.
¿Qué pasaría si ingresa ‘a’ (minú scula)? ¿Nuestro socio será vip? Si
no funciona, ¿có mo podríamos solucionarlo?

42 | LOVOs y GOin
 Es comú n cometer errores usando operadores ló gicos, por ejemplo:

(A>B) and (A=B)

(N<10) and (N>20)

¿Cuándo se cumplirán estas condiciones?

2.6. Otros operadores matemáticos especiales

Además de los operadores básicos matemáticos como (+,-,/ y *) existen

otros operadores que se irán trabajando a lo largo del texto. En este capítulo
veremos los que son propios de la sintaxis de FreeDFD.
La siguiente tabla muestra algunos de los operadores matemáticos
es- peciales, para N, N1, N2 variables numéricas:

Operación Símbolo Sintaxis

Potencia ^ N1^N2

Raíz cuadrada sqrt sqrt(N)

Valor absoluto abs abs(N)

Seno sin sin(N)

Coseno cos cos(N)

Tangente tan tan(N)

Logaritmo neperiano ln ln(N)

Logaritmo decimal log log(N)

Exponencial e exp exp(N)

Número aleatorio random random(N)

Módulo mod N1 mod N2

A continuació n se trabajarán unos ejemplos con los operadores analizados.

DiaGRaMaCión lóGiCa | 43
Problema 10: Se lee desde el teclado el valor de un ángulo en grados. Se de

Nota: En el FreeDFD se puede optar por trabajar con á ngulos en ra-

dianes o en grados simplemente clickeando en «Opciones» del menú .
Importante: No es posible utilizar como identificadores de variables las
palabras cos, sin, tan, abs, etcétera, por ser palabras reservadas del len-
guaje de FreeDFD.

44 | LOVOs y GOin
Problema 11: Se ingresan por teclado los catetos de un triángulo rectángulo. S

Problema 12: Ingresar un número natural por teclado. Se desea saber y mostra
si es par o impar.

DiaGRaMaCión lóGiCa | 45
 El operador «mod» nos devuelve el resto de la divisió n entre
nú meros enteros. Para este caso cualquier nú mero natural (1,2,3,..,∞)
dividido 2 nos da un 1 o un 0 (cero), entonces los nú meros pares tendrán
como resultado un 0, mientras que los impares un 1.
Problema 13: Ingresar un número entero para saber si es divisible por 7 y es m

Al tratarse de dos condiciones que se requiere que sean verdaderas,

es necesario utilizar el operador ló gico «and».
El operador «random» sirve para generar nú meros al azar. Por ejemplo,
si necesitamos generar nú meros enteros entre el 0 y el 9 entonces la
sinta- xis será random(10), es decir que el valor N que se indica entre
paréntesis permitirá generar nú meros entre el 0 hasta el N-1.
La siguiente tabla muestra algunas variantes para conseguir nú meros
aleatorios:

46 | LOVOs y GOin
 Ejemplos Rango de valores obtenidos
random(2) 0y1
radom(10)+1 Del 1 al 10
random(21)-10 Del -10 al 10
random(100)/10 Del 0,0 al 9,9
random(101)/10 Del 0,0 al 10,0
random(1001)/100-5 Del -5,00 al 5,00
random(10)*2 0, 2, 4, 6, 8, 10,…,18

Problema 14: Mostrar en letras el número de la cara de un dado obtenido al azar

DiaGRaMaCión lóGiCa | 47
 Sabemos que son 6 las caras de un dado, entonces la expresió n ran-
dom(6)+1 genera nú meros del 1 al 6. ¿Qué podría suceder si cambiamos
la primera instrucció n de asignació n por dado ← random(7)?

Nota: La ú ltima decisió n del ejercicio anterior funciona por descarte ya

que no necesita realizar otra consulta en el No, se da por descartado que
se trata de un 6. En estos casos cuando se tiene N casos posibles las deci-
siones será n N-1.
Problema 15: Generar aleatoriamente una temperatura entre los -20º y los

2. 7. Problemas: Diagramación lógica –

Estructura de control de decisión
1. Diseñ ar un algoritmo que, dados dos nú meros, muestre por pantalla
su suma.
2. Realice un algoritmo que solicite dos datos: país y capital. Y luego
muestre la capital del país. El cartel debe ser como lo indica el si-
guiente ejemplo: “Katmandú es la capital de Nepal”.
3. Crear un algoritmo que muestre por pantalla el doble y el triple de
un nú mero ingresado por teclado.
4. Diseñ ar un algoritmo que imprima el cuadrado y el cubo de un nú -
mero ingresado por teclado.

48 | LOVOs y GOin
5. Diseñ ar un algoritmo que pida un nú mero por teclado y luego im-
prima el nú mero siguiente al ingresado.
6. Diseñ ar un algoritmo que genere un nú mero aleatorio del 0 al
200, lo muestre y luego calcule y muestre el mismo nú mero
aumentado en un 30 %.
7. Diseñ ar un algoritmo que genere un nú mero aleatorio del 10 al
50, lo muestre y luego calcule y muestre el mismo nú mero
disminuido en un 15 %.
8. Diseñ ar un algoritmo que, dados tres nú meros enteros, calcule e im-
prima el promedio entre ellos.
9. Diseñ e un algoritmo para ingresar dos palabras (A, B) y luego realice
el intercambio de sus valores. Finalmente mostrar el contenido de
A y de B.
10.Diseñ ar un algoritmo que imprima el área y el perímetro de un
rec- tá ngulo ingresando su base y altura.
11.Realice un algoritmo que calcule el volumen de un cilindro a
partir de los valores de su radio y altura.
12.Crear un algoritmo que convierta y muestre un valor ingresado en
centímetros a yardas, metros, pies y pulgadas.
13.Diseñ ar un algoritmo que convierta y muestre la temperatura en
Fahrenheit ingresando la temperatura en Celsius.
14.Diseñ ar un algoritmo que calcule el volumen de un cilindro dados su
radio y altura (primero el programa deberá verificar si son positivas).
15.Crear un algoritmo que calcule si dos nú meros son divisibles. Para
ello, se piden un primer nú mero y un segundo nú mero, entonces
mostrar un cartel que diga “es divisible” si el segundo nú mero es
divisible al primero.
16.Diseñ ar un algoritmo para calcular el porcentaje de hombres y de
mujeres que hay en un grupo, dados los totales de hombres y de
mujeres.
17.Diseñ ar un algoritmo que indique con carteles si el nú mero ingresa-
do es negativo, positivo o nulo.
18.Ingresar tres nú meros y mostrar el mayor (asuma que todos son dis-
tintos entre sí).
19.Realice un algoritmo para mostrar un cartel que indique si un trián-
gulo es «escaleno», «equilátero» o «isó sceles» ingresando sus lados.
20.Diseñ ar un algoritmo que imprima con un cartel el nú mero de do-
cena («primera», «segunda» o «tercera») dado el resultado de una
jugada de ruleta (del 0 al 36). Utilizar el operador ló gico and.
21.Crear un algoritmo que permita obtener y mostrar la cantidad de
dígi- tos de un nú mero ingresado, sabiendo que el máximo permitido
es 4.

DiaGRaMaCión lóGiCa | 49
 22.Crear un algoritmo que muestre cada uno de los dígitos de un nú -
mero ingresado por el usuario. El máximo permitido es de 4 dígitos.
Por ejemplo: si se ingresa el nú mero 187, entonces debe mostrar en
un ú nico cartel lo siguiente: “d1 = 0, d2 = 1, d3 = 8 y d4 =7”.
23.Ídem al anterior pero se pide que muestre la suma de los dígitos
del nú mero ingresado (má ximo 4 dígitos).
24.Diseñ ar un algoritmo que imprima con un cartel «Correcto» segú n
el siguiente caso: si el numero N es mú ltiplo de 5 y se encuentra
en- tre los 25 primeros nú meros. N debe ser obtenido
aleatoriamente entre nú meros del 1 al 1000. Primero debe mostrar
N.
25.Diseñ ar un algoritmo que ingresando un numero de 5 dígitos
detec- te si es capicú a y muestre un cartel «Es capicú a» o «No es
capicú a» segú n el resultado.
26.Crear un algoritmo que muestre las soluciones de una ecuació n cua-
drática (usando Bhaskara), a partir del ingreso de los valores de los
co- eficientes del polinomio. El polinomio tiene la forma: P(x) =
ax2+bx+c
27. Probar con: a) P(x) = x2+3x+2 b) P(x) = 2x2+4x+2 c) P(x) = 3x2+2

2. 8. Estructura de control de repetición

Hasta el momento, se han presentado problemas que no requieren de re-

peticiones de sentencias o acciones. Sin embargo al momento de
resolver problemas, es muy comú n encontrarnos con situaciones
repetitivas.
Pensemos en el siguiente problema: se desea determinar el promedio
de las edades de 5 personas. Una solució n posible podría ser leer 5 edades
(variables) y luego calcular su promedio. Ahora bien, ¿qué sucede si en lugar
de 5 personas son 100 o un valor N que ingresa el usuario?
No es lo mismo hallar el promedio de tres nú meros que el promedio
de 100 o de un valor N que ingresa el usuario. Veamos justamente có mo
podríamos resolver el problema propuesto con las herramientas trabajadas
hasta el momento para tener una mejor idea.

50 | LOVOs y GOin
Problema 16: Ingresar 10 números (edades de personas) y luego hallar y
mostrar su promedio.

Solución 1

DiaGRaMaCión lóGiCa | 51
 Solución 2

Nota: Por una cuestió n de espacio se escribieron puntos suspensivos en

reemplazo de lectura A y la asignació n S ← S + A.

52 | LOVOs y GOin
 La primera solució n resuelve el problema en pocas líneas, pero utiliza
una gran cantidad de variables. La segunda solució n utiliza pocas variables,
pero muchas líneas de comando que se repiten de a pares (leer y sumar).
Basta imaginar si el algoritmo en vez de resolver el promedio con
diez nú meros debiera resolverlo para cien, necesitaríamos para la
solució n 1 cien variables y para la solució n 2 más de doscientas líneas de
trabajo.
Para poder tratar con este tipo de situaciones, existen las estructuras de
control de repetició n: «para», «mientras» y «hacer-mientras».

2. 8. 1. Estructura de control de repetición (sentencia «para»)

Cuando se desea ejecutar un conjunto de acciones un determinado

nú me- ro de veces, usamos la sentencia «para».
En estos casos se requiere que conozcamos por anticipado el nú mero de
repeticiones. Para solucionar el problema del ejercicio anterior, hacemos lo
siguiente:

DiaGRaMaCión lóGiCa | 53
 De esta manera todo lo que encierra desde Para hasta Fin (Para) se re-
pite tantas veces como lo indica el control de repetició n.
La variable S funciona como sumador o acumulador de A.

La variable i comienza a contar los ciclos

(vueltas) desde 1 hasta 10 con saltos de
un paso.

Se repiten las instrucciones que se

encuentran entre el Para y el Fin (Para).

Problema 17: Hallar la sumatoria de 10 números generados al azar. Los núme

Preguntas: Esta solució n, ¿resuelve el problema? ¿Cuántas veces se

ejecu- tan las instrucciones que se encuentran dentro del Para? ¿En qué
cambia el algoritmo si quisiéramos hacer esto para 200 nú meros?

54 | LOVOs y GOin
2. 8. 2. Variables como acumuladores

Es una variable que, como su nombre lo indica, va a ser usada para

sumar sobre sí misma un conjunto de valores. Cuando se utiliza dentro de
un ciclo de repetició n Para, al finalizar el mismo, esta variable contendrá
la suma- toria de todos los valores que cumplen una determinada
condició n (tam- bién puede servir para decrementar valores variables). Es
necesario haber inicializado su valor antes del comienzo de un ciclo de
repetició n «para».
La inicializació n consiste en asignarle al sumador un valor inicial, es de-
cir el valor desde el cual necesitamos se inicie la sumatoria (por lo
general comienzan en cero).

Ejemplo: S = 0
S=S+N

2. 8. 3. Variable contadora

Es una variable que se encuentra en ambos miembros de una asignació n

a la que se le suma un valor constante. Un contador es una variable cuyo
valor se incrementa o decrementa en una cantidad constante cada vez
que se produce un determinado suceso, acció n o iteració n. Los contadores
se utilizan con la finalidad de registrar la cantidad de sucesos, acciones o
iteraciones internas en un bucle, proceso, subrutina o donde se requiera
cuantificar. Como cualquier variable es necesario inicializarla antes del co-
mienzo de un ciclo de repetició n.
La inicializació n implica darle un valor inicial, en este caso, el nú mero
des- de el cual necesitamos se inicie el conteo (por lo general comienzan en
cero).

Ejemplos: C=0 (inicializa la variable C en 0)

C=C+1 (incrementar)
H=H-1 (decrementar).

Nota: La diferencia entre un sumador y un contador es que mien-

tras el primero va aumentando en una cantidad fija preestableci-
da, el acumulador va aumentando en una cantidad o valor variable.
Tanto si es una variable contadora sumadora o acumuladora, es necesario
asignarle un valor inicial antes de comenzar a utilizarla, por ejemplo en
un bucle. Cuando se desean calcular promedios o porcentajes se requiere
de ambos tipos de variables.

DiaGRaMaCión lóGiCa | 55
Problema 18: En una veterinaria se desea saber el promedio de edad de g

Atención: Es muy importante tomar en cuenta que los prome-

dios siempre deben ser calculados fuera del ciclo de repetició n
Para - Fin (Para). ¿Qué sucedería si se calculan dentro del ciclo?
Recordar que el ingreso de caracteres, en este caso el tipo de animal (gato/
perro) debe estar entre comillas: “Gato” y “Perro”.

56 | LOVOs y GOin
Problema 19: Se pide lo mismo que el problema anterior, pero la diferencia ra

DiaGRaMaCión lóGiCa | 57
 Es decir que, por descarte, otro tipo de animal caería en el ú ltimo No de
la decisió n y, entonces, incrementaría en uno la variable CA.

Importante: Todo contador y acumulador (sumador) debe iniciarse con un

nú mero antes del comienzo del ciclo de repetició n, en el caso anterior con
cero. Nota: Para una mejor comprensió n en las respuestas, lo ideal sería en
la sa- lida combinar carteles y resultados, por ejemplo para el problema
anterior.

La cantidad de iteraciones del bucle «para» también se puede

determinar ingresando el dato necesario. A continuació n un ejercicio
relacionado.

58 | LOVOs y GOin
Problema 20: Solicitar al usuario que ingrese un número entero N, luego gener

DiaGRaMaCión lóGiCa | 59
 Pregunta: ¿Qué precondició n debe cumplir N? ¿Qué sucede si el nú mero
que ingresa el usuario es -1?

También podemos usar el ciclo decrementando el contador de

vueltas del Para. Desde N a 1 mientras el paso sea -1.

A continuació n un ejemplo relacionado.

Problema 21: Solicitar al usuario que ingrese un valor N y mostrar todos los v

60 | LOVOs y GOin
Problema 22: El factorial de un número entero se denota de la siguiente mane
«n!» y su resultado es n!=n*(n-1)*(n-2)*…*1. Por ejemplo: 5!=5*4*3*2*1 siendo el

DiaGRaMaCión lóGiCa | 61
 2. 8. 4. Máximos y mínimos
Problema 23: Hallar la persona de mayor edad, sabiendo que se leen datos c

El valor inicial de la variable EMAX es un nú mero absurdo por ser una

edad de un nú mero negativo (-1000). Cuando se ingresa el primer valor
E dentro del bucle, la condició n (E > EMAX) se cumple por ser verdadera,
en- tonces el valor de EMAX cambia por el valor de la edad E.
A medida que se continú a ejecutando el bucle, la sentencia evalú a si
aparece un valor mayor o no a EMAX, en caso afirmativo se le asigna
al mismo el nuevo valor de E.

62 | LOVOs y GOin
 Tomar en cuenta que si se produce el caso de empate la condició n es
falsa, por lo tanto, no sufre efecto.
Si el ejercicio además solicitara hallar la mínima edad entre las 20
per- sonas, entonces será necesario agregar otra variable, por ejemplo
EMIN y asignarle un valor extremadamente grande de entrada (por
ejemplo: EMIN = 1000) y la condició n (E < EMIN) para la decisió n.
A continuació n se muestra un ejemplo de có mo hallar el mínimo.

Nota: ¿Qué alternativa sugerís, de manera de evitar la asignació n de valor

absurdo a EMAX y EMIN?

Problema 24: Hallar la persona de menor altura, sabiendo que se leen datos corr

DiaGRaMaCión lóGiCa | 63
 El valor absurdo de entrada será AMIN=1000 (ninguna persona mide 10 m).
¿Qué sucede si además de registrar la mínima altura de la persona, se
desea conocer en qué ubicació n (orden dentro de la lista de valores
leídos) se encuentra tal persona?
Problema 25: Mostrar la mínima altura registrada de un grupo de 30 personas

64 | LOVOs y GOin
 A la variable UMIN se le asigna el valor de la variable de iteració n i
del Para. Por ejemplo, si la altura mínima se produce en la vuelta 8 significa
que i es igual a 8.
De esta manera se tiene el registro de cuándo se produce la ú ltima
con- dició n verdadera de la decisió n.
En caso de empate, el ú nico registro que se produce es el primero que llega.

2.8. 5. Problemas: Diagramación lógica –Estructura de control

de repetición «para»

28.Mostrar por pantalla los nú meros del 10 al 1.

29.Mostrar por pantalla las tres primeras potencias de los nú meros del
1 al 5.
30.Dado un nú mero, mostrar por pantalla su tabla de multiplicar (del
1 a 10).
31.Mostrar por pantalla la cantidad de personas mayores de edad (≥18)
de un total de N edades leídas desde teclado.
32.Mostrar por pantalla la cantidad de mujeres y hombres (M/H)
de un total de N valores leídos desde teclado. Mostrar también su
porcentaje.
33. Mostrar por pantalla la cantidad de mujeres mayores de edad y la
cantidad de hombres menores de edad de un total de N edades y
sexo leídos desde teclado.
34.A un grupo de 10 personas se les consulta la edad y se desea calcular
el promedio de edad del grupo. Mostrar el promedio y cuántas de las
10 personas son mayores de 18 añ os, leyendo la informació n
desde teclado.
35.Se desea conocer el peso acumulado de 10 personas. ¿En qué cam-
biaría la solució n si ahora son 100 personas?
36.Se desea conocer el peso promedio de 5 personas.
37.Realice un algoritmo que permita ingresar 10 edades de personas
para luego hallar y mostrar el % de gente mayor de edad (≥ 18) y el
% de menores de edad.
38.Crear un algoritmo que genere al azar 5 nú meros de la ruleta (del
0 al 36) y muestre el % de nú meros pares, % de impares y % de ceros
generados.
39.Ingresar 10 temperaturas por teclado y mostrar la mayor.
40.Se ingresan 10 pares de temperaturas (T1 y T2). Hallar el promedio
de las temperaturas T1 y el promedio de las temperaturas T2.

DiaGRaMaCión lóGiCa | 65
 2. 8. 6. Estructura de control de iteración (sentencia «mientras»)

Esta estructura de control permite repetir una instrucció n o grupo de

ins- trucciones mientras una expresió n ló gica sea verdadera. De esta
forma, la cantidad de veces que se reiteran las instrucciones no necesita
conocerse por anticipado, sino que depende de una condició n.
Lo primero que hace esta sentencia es evaluar si se cumple la condició n.
En caso que se cumpla se ejecuta el bucle. Si la primera vez que se evalú a la
condició n esta no se cumple, entonces no se ejecutará ninguna acció n. En
otras palabras, mientras la condició n se cumpla el bucle sigue iterando, por
eso es importante no caer en ciclos de repetició n infinitos.
Veamos como ejemplo el siguiente problema.

Problema 26: Calcular la suma de los números ingresados por teclado hasta q

66 | LOVOs y GOin
 Es necesario leer el valor de la variable N antes de comenzar con el bucle
«mientras», porque se debe evaluar la condició n al entrar al ciclo de repeti-
ció n. Luego es importante no olvidarse de volver a leer N dentro del bucle,
porque si no lo hacemos caeremos en un ciclo de repetició n infinito.
¿Cuál será el resultado si arrancamos ingresando un cero?

Mientras que la condición se cumpla el ciclo

se sigue ejecutando.
MQ (significa mientras que)

Se repite las instrucciones que se encuentran

entre el MQ y el Fin (MQ)

Problema 27: Hallar el promedio de números ingresados por teclado hasta que se

DiaGRaMaCión lóGiCa | 67
Nota: También se puede introducir en la salida la combinació n de un car-
tel y un cálculo, como en el caso anterior donde se realiza el promedio
S/C sin depender de otra variable: prom ← S/C.

¿Qué pasaría si de entrada ingresamos un nú mero que no cumple la

condició n del «mientras»? Probemos con N=5 o con N=80.
Se produce el error que muestra la figura:

Esto es así porque estamos dividiendo por cero, ya que C nunca pudo
incrementarse. ¿Có mo podríamos solucionar este problema? ¿En qué casos
es posible hallar el promedio?

Nota: Para poder solucionar este problema tendremos que recurrir a una
decisió n antes de efectuar la divisió n, de la siguiente manera:

68 | LOVOs y GOin
Problema 28: Se leen números que ingresa el usuario desde teclado, hasta que

DiaGRaMaCión lóGiCa | 69
 Mientras la condició n del ciclo de repetició n cumpla con N mayor o
igual a cero, se determina si dicho nú mero es distinto a 0 y luego si es par o
impar para incrementar CP o CI respectivamente.

Nota: No olvidarse de leer N antes del ciclo y dentro del mismo. ¿Qué
sucedería si no leemos dentro del ciclo?
Problema 29: Diseñar un algoritmo que calcule cuánto es el cociente entre

70 | LOVOs y GOin
 Nota: Se asignan al inicio del algoritmo a las variables N1 y N2 el valor 1
(uno) para que puedan entrar a los ciclos de repetició n «mientras» y así
pedir el nuevo valor.
Prueben ingresar valores impares y verán como repite el ingreso hasta
que se lea un valor par.

Dentro de un ciclo de repetició n pueden incluirse otros ciclos de repeti-

ció n como el «mientras» o el «para» y/o condiciones de selecció n. Es decir,
las estructuras de control se pueden combinar para resolver un problema. A
continuació n se presenta un ejercicio con dicha combinació n.
Problema 30: Diseñar usando FreeDFD un algoritmo que muestre por pantalla 10

DiaGRaMaCión lóGiCa | 71
Nota: Antes de entrar al ciclo de repetició n Para se le asigna a la variable N
un valor 2 obligando a entrar al ciclo «mientras» hasta encontrar un nú mero
N impar. Esto sucede 10 veces porque se encuentra dentro del Para.

2.8. 7. Problemas: Diagramación lógica –

Estructura de control de repetición «mientras»

41.Diseñ ar un algoritmo que genere nú meros al azar mú ltiplos de 5,

mientras el usuario no ingresa la opció n ‘S’ (Salir).
42.Diseñ ar un algoritmo que lea un nú mero desde teclado y
determine si el mismo es primo o no.
43.Diseñ ar un algoritmo que lea desde teclado la informació n sobre
altura, edad, y sexo (F/M) de los participantes de un curso. La lectura
finaliza cuando se lee un valor de altura negativo. Luego calcule:
a. Promedio de altura de las mujeres.
b. Promedio de altura de los varones.
c. Promedio de edad de los participantes.
44.Se ingresan 10 nú meros cuyos valores corresponden a los de la
ru- leta (0,1,2,…,36), se pide hallar y mostrar por pantalla lo
siguiente:
a. Cantidad de nú meros impares.
b. Promedio de los nú meros pares (no contar los ceros).
c. Cantidad de nú meros que se encuentran en la 2º docena (13 al 24).
d. El nú mero más grande.
e. ¿En qué cambia la solució n si en lugar de leer 10 nú meros, ahora se
leen nú meros hasta que llega el valor 36?
45.Se leen desde teclado pares de temperaturas (T1 y T2) hasta que T1
sea cero. Hallar el promedio de las temperaturas ingresadas que es-
tá n comprendidas entre 5° y 15° (incluidos).
46.Se leen desde teclado nú meros hasta que la suma de los mismos lle-
gue a 1000. Mientras tanto debe hallar:
a. La cantidad de nú meros mú ltiplos de 6.
b. La suma de los nú meros que se encuentran entre el 1 y el 10
(incluidos).

72 | LOVOs y GOin
Capítulo 3
Pseudocódigo

Pseudo deriva del griego seudo, que significa ‘falso’, mientras que código pro-
viene del latín: codices, codex. Estos se empleaban para referirse a los docu-
mentos o libros donde los romanos tenían escritas todas y cada una de
sus leyes. En definitiva pseudocó digo significa ‘falso lenguaje’.
Como se explicó en el capítulo introductorio, el diseñ o del algoritmo es
independiente del lenguaje de programació n, es decir, una solució n a un
problema puede ser escrita en diferentes lenguajes. Así, el pseudocó digo
está diseñ ado para facilitar la comprensió n de la solució n algorítmica. En
pocas palabras, es una herramienta que facilita el proceso de programar.
Aunque no existe una sintaxis estándar para el pseudocó digo, las
dife- rentes versiones utilizan un lenguaje similar al lenguaje natural y, en
gene- ral, su escritura exige la indentació n (sangría en el margen
izquierdo) de diferentes líneas. En el caso de este libro, se usará la sintaxis
provista por el aplicativo PSeInt.

3.1. PSeInt

PSeInt es un software educativo libre y multiplataforma, dirigido a aquellos

que quieren comenzar a incursionar en la programació n y el desarrollo
de la ló gica. El software fue creado en el añ o 2003 por el ingeniero en
informá- tica Pablo Novara en la Facultad de Ingeniería y Ciencias
Hídricas (fich) de la Universidad Nacional del Litoral (unl) de la
Argentina.
PSeInt se distribuye bajo licencia Gpl (General Public License) y es
uno de los softwares más utilizados en las universidades latinoamericanas
para la construcció n de algoritmos. Su manejo es simple e intuitivo a
través de un editor de programas escritos en un pseudolenguaje en
españ ol. Su in- terfaz gráfica permite crear, almacenar, ejecutar y
corregir fácilmente los programas.
El objetivo es permitir centrar la atenció n en conceptos fundamenta-
les de aprendizaje sin detenerse en detalles para la interpretació n de un
compilador. De esta forma, se facilita la tarea de escritura de algoritmos
y se proporciona un conjunto de ayudas y asistencias, junto a algunas herra-
mientas que asisten a un programador novato a encontrar errores y
com- prender la ló gica de los algoritmos. El software no deja de
actualizarse y para descargarlo tenemos que dirigirnos al siguiente vínculo
http://pseint. sourceforge.net/

PseudOCÓdiG |
O
 Una vez descargado e instalado se puede ejecutar a través del icono:

La primera ventana que aparece es la que muestra la figura 2. 1:

Figura 2. 1. Pantalla PSeInt

En la barra ubicada arriba de la pantalla figura el menú principal que

contiene el total de las opciones; en el panel derecho, los comandos para
armar el algoritmo; y, en el centro, aparece el sector de trabajo o edició n.
A medida que avancemos incorporaremos los comandos necesarios
para abordar cada uno de los problemas vistos en el capítulo 2
(diagrama de flujo).
A continuació n, se muestra paso a paso có mo editar y probar el primer
ejercicio, en el que se ingresaban dos nú meros enteros para hallar y
mos- trar la suma.

74 | LOVOs y GOin
 Se describen con detalle todos los pasos a seguir en PSeInt para resolver
el problema 1.

1. Escribir el nombre del programa

a la derecha de «Proceso», en el
espacio que dice “sin_titulo”
En este caso, recomendamos
que escriban “Problema1”
Nota: El título no debe contener
espacios en blanco.
2. Ubicamos el cursor en la línea 2
haciendo un click y luego elegimos
el comando «Leer».

En la lista de variables escribimos las variables A, B.

3. Insertamos en la línea 3 el Allí escribiremos en
comando de asignación. «variable<-expresión» lo siguiente:
C<-A+B

4. Para finalizar el algoritmo, Reemplazamos en la lista de expresiones la

insertamos en la línea 4 el variable C.
comando

PseudOCÓdiG |
O
 Una vez terminado el programa en el sector de trabajo es necesario
probarlo ejecutándolo con el ícono o directamente con la tecla F9.

Se ingresa por teclado un nú mero Enter y luego otro nú mero Enter.

Finalmente el resultado será el siguiente:

En caso de error se muestra en un panel inferior el nú mero del error

cometido y la informació n detallada.

Importante:
i) Evitar dejar líneas de comando en blanco.
ii) Tener en cuenta al nombrar variables que no se diferencian
mi- nú sculas de mayú sculas.
iii)Las palabras reservadas del programa aparecen en negrita.
iv)Guardar los archivos.
v)Probar el funcionamiento de cada programa.
vi)Para empezar un nuevo algoritmo hacer un click en el ícono .
Nota: Realizar en PSeInt el problema 2 (del capítulo 2).

Con respecto a la estructura de control de decisió n el comando del

PSeInt es:

76 | LOVOs y GOin
 Atención: Es muy importante tomar en cuenta las tabulaciones que
se presentan. En este caso, lo que va dentro del Si y Sino se tabula.
Esta acció n tiene por nombre indentación y PSeInt la realiza
automáticamente. La indentació n es lo que permite determinar un
bloque de acciones que se ejecutarán juntas. Luego, cada lenguaje de
programació n usará sus propios símbolos para esto, por ejemplo, en el
lenguaje C se usan las llaves
{}; en Pascal, las palabras reservadas «Begin-End». Es muy importante
acostumbrarse a escribir có digo indentado ya que facilita la lectura y la
detecció n de errores.

Problema 3 (del capítulo 2): Mostrar el perímetro de una circunferencia, siempre

PseudOCÓdiG |
O
 A continuació n, se muestra el problema 4, donde se presenta un caso de
decisió n doble.

Problema 4 (del capítulo 2): Igual al ejemplo anterior pero en el caso de ingre

En el problema 6 se presenta un caso de decisiones anidadas.

78 | LOVOs y GOin
Problema 6 (del capítulo 2): Mostrar el número más grande (entre dos) ingresa

Acontinuació n se exhibe un caso donde las decisiones son independientes.

Atención: Se recomienda directamente editar el algoritmo en el

sector de trabajo sin la necesidad de utilizar los comandos del panel
derecho. Importante: A partir de ahora se incorporan comentarios en
el algoritmo. Para ello, se inicia la línea con un par de barras
inclinadas //. Resulta importante que en cada algoritmo, en la cabecera,
escriban todas las variables en uso y el tipo al que pertenecen:
alfanumérico, entero o decimal. Por ejemplo, en el caso anterior
(problema 6) el programa quedaría de la siguiente manera:

Nota: Los comentarios en PSeInt se muestran siempre en color gris.

PseudOCÓdiG |
O
Problema 7 (del capítulo 2): Ingresar dos números por teclado y sumarlos, c

3. 2. Operadores lógicos

Los operadores ló gicos en pseudocó digo se relacionan de la siguiente forma:

Diagrama de flujo Pseudocódigo Ejemplo

and & (N>10) & (M==’X’)
or | (R==0) | (R>=100)
not no no (C<1)

A continuació n, se muestran algunos ejemplos relacionados con los

operadores ló gicos.

80 | LOVOs y GOin
Problema 8 (del capítulo 2): Verificar que el número ingresado por teclado se

Realice el pseudocó digo del problema 9 (del capítulo 2).

Atención: Los operadores aritmé ticos bá sicos, los de relació n (>, <, =,
<= y >=) y la mayoría de los operadores especiales se mantienen con
respecto al diagrama de flujo. A continuació n se presentan aquellos que
se diferencian.

Operación Símbolo Sintaxis

Raíz cuadrada raiz raiz(N)
Seno sen sen(N)
Número aleatorio azar azar(N)

Importante: En PSeInt la desigualdad se escribe de la siguiente manera:

<>

El problema 12 es un ejemplo con un operador aritmético especial.

PseudOCÓdiG |
O
Problema 12 (del capítulo 2): Ingresar un número natural por teclado. Se d

Nota: Recuerde que el operador «mod» nos devuelve el resto de la divisió n

entre nú meros enteros.

Realice los ejercicios 13, 14 y 15 en pseudocó digo del capítulo anterior.

Atención: Recuerde que el operador especial «random» que se utiliza en

el FreeDFD, tiene su equivalente en PSeInt: «azar».

82 | LOVOs y GOin
 Para el caso de la estructura de control de repetició n «para», el comando
del PSeInt es:

Para el problema 17 (del capítulo 2) que consistía en hallar la

sumato- ria de 10 nú meros generados al azar, los nú meros deben
comprender el siguiente rango de valores [1...20].

A continuació n se presenta directamente el pasaje a pseudocó digo

del problema 18 (del capítulo 2). En el mismo se pedía lo siguiente: en
una veterinaria se desea saber el promedio de edad de gatos y perros
(por se- parados) que fueron asistidos durante un mes. En total se
registraron 200 animales y la veterinaria solo atiende gatos y perros.

PseudOCÓdiG |
O
Nota: En el problema 18 se utilizan variables de diferentes tipos; entero,
decimales y alfanumé ricos. Con la intenció n de mejorar la lectura del
có digo se han agrupados los tipos por línea.

Recordar que el problema 19 (del capítulo 2) pide lo mismo que el

pro- blema anterior, pero la diferencia radica en que no solo la veterinaria
atien- de gatos y perros, puede que sean otros animales también.
Justamente lo que se pide es ademá s contar la cantidad de esos animales
que no son ni gatos y ni perros.

84 | LOVOs y GOin
Nota: Realice los problemas 20, 21 y 22 directamente utilizando el programa
PSeInt sin depender del diagrama de flujo.

El siguiente es el problema 23 (del capítulo 2) de máximos y mínimos

en pseudocó digo.

Nota: Realizar los ejercicios 24 y 25.

PseudOCÓdiG |
O
 Para el caso de la estructura de control de repetició n «mientras» el
co- mando del PSeInt es:

Tomar el problema 26 (del capítulo 2) en diagrama y pseudocó digo para

comparar. En el mismo se pedía calcular la suma de nú meros ingresados
por teclado hasta que se ingrese un cero.

Nota: Realizar los problemas 27, 28, 29 y 30 del capítulo anterior utilizando
directamente el software PSeInt (sin la necesidad de recurrir al
diagrama de flujo).

86 | LOVOs y GOin
3.3. Ejercicios: pseudocódigo

46.Se ingresan por teclado 10 pares de temperaturas (T1 y T2) para

hallar el promedio de las temperaturas que están entre 5° y 15°
(incluidos).
47.Se ingresan 10 nú meros por teclado para hallar tres datos:
a. La cantidad de nú meros negativos.
b. La suma de los nú meros que se encuentran entre el 1 y el 10 (no
incluidos).
c. El promedio de todos los nú meros.
48.Se generan nú meros enteros en forma aleatoria entre [0 y 200] hasta
que la sumatoria de los mismos sea mayor a 500. Al finalizar indicar:
a. La cantidad de nú meros nulos (0) leídos.
b. La sumatoria de los nú meros que se encuentran entre el 10 y el
100 (incluidos).
c. El promedio de los nú meros menores a 150.
d. El nú mero mayor generado.
49.La sucesió n de Fibonacci genera la siguiente secuencia de
nú meros: 1, 1, 2, 3, 5, 8, etcétera. Es decir que se obtiene de sumar
los dos nú - meros anteriores.
El siguiente es el término general: an=an-1+an-2
Se pide que diseñ e un programa que le solicite al usuario un nú mero
entero positivo K y luego muestre en pantalla el K-ésimo término
de la sucesió n de Fibonacci. Por ejemplo, si el usuario ingresa por
teclado el nú mero 10 entonces el algoritmo debe mostrar el valor
correspondiente a a10
50.Realice los ejercicios 25, 37, 38, 43 y 46 del capítulo anterior en
pseudocó digo.

PseudOCÓdiG |
O
Capítulo 4
Entorno de programación visual

Existen otras formas de aprender a programar. Una de ellas consiste en uti-

lizar lenguajes visuales a través de entornos de desarrollo integrado
(ide) que, a diferencia de las herramientas anteriores, posibilitan la
ejecució n y visualizació n de un algoritmo al mismo tiempo.
DaVinci Concurrente, la herramienta a la que vamos a dedicar este ú l-
timo capítulo, es un entorno integrado de desarrollo (ide) que facilita la
comprensió n de situaciones problemáticas y permite la visualizació n de
la ejecució n de los algoritmos que se resuelven. Fue desarrollado original-
mente por un grupo de investigadores del Instituto de Investigació n en
Informática lidi (iii-lidi) de la Facultad de Informática de la unlp,
enca- bezado por el licenciado Raú l Champredonde.
Luego, a través de un trabajo de tesis de grado (Aguil Mallea, 2012)
de la Universidad Nacional de la Patagonia San Juan Bosco (Ushuaia), se
de- sarrolló una segunda versió n que permite la introducció n a los
conceptos básicos de la programació n concurrente. Y esta ú ltima versió n
es la que vamos a utilizar aquí.
Este lenguaje está directamente ligado a la enseñ anza de la
programa- ció n estructurada, tanto para la etapa inicial de la programació n
secuencial como para los conceptos básicos de la programació n
concurrente.
La versió n actual del aplicativo está desarrollada en lenguaje de progra-
mació n Java, por lo tanto, uno de los requisitos es tener instalado el plug-in
de Java en la computadora donde se va a ejecutar. El mismo se puede
des- cargar en el siguiente sitio: www.java.com/getjava y el enlace para
descar- gar el DaVinci es http://davinci-c.sourceforge.net/
Da Vinci se basa en la programació n de un robot (Lubo-I) situado en una
ciudad cuadrada con avenidas y calles. Este puede realizar diferentes accio-
nes, desde movimientos dentro de los límites de la ciudad hasta interaccio-
nes con los objetos (flores, papeles y obstáculos) que se encuentran en ella.
DaVinci permite que los usuarios puedan programar los movimientos de
un robot abstracto en una ciudad también abstracta. La ciudad es un cuadra-
do que contiene 10 calles horizontales y 10 avenidas verticales, como se puede
observar en la figura 4.1. El robot camina de una esquina a la otra ejecutando
las instrucciones especificadas en el programa. Durante la ejecució n, el robot
puede recoger o depositar dos tipos de objetos: flores y papeles. Para esto dis-
pone de dos bolsas, una para cada tipo de objeto. Cuenta además con la posi-
bilidad de incorporar obstáculos en las esquinas de manera de bloquear un
ca- mino, contar objetos y mostrar resultados. El lenguaje define las
instrucciones
EnTORnO de pROGRaMaCión | 89
visual
primitivas que el robot ejecuta y las construcciones necesarias que permiten
una programació n modular y estructurada. En Da Vinci Concurrente, un pro-
grama puede ser desarrollado en modo texto o visualmente. Cualquiera sea el
modo seleccionado, todo lo que se hace en una representació n, simultánea y
automáticamente se reproduce en el otro modo. La verificació n sintáctica y la
ejecució n de los programas desarrollados se llevan a cabo sobre el có digo en
modo texto, de manera de independizar la eficiencia del lenguaje del formato
visual del algoritmo (Champredonde y otros, 2000).
En el presente capítulo, se trabajan conceptos básicos de ló gica proposi-
cional vistos en capítulos anteriores, para representar condiciones comple-
jas utilizadas en las estructuras del ambiente, aplicadas específicamente en
este caso a problemas con el robot.
Ahora bien, para darle instrucciones al robot Lubo-I, es necesario cono-
cer a qué primitivas (instrucciones) responde.
La herramienta permite configurar la ciudad de manera manual o
alea- toria, para que aparezcan en las esquinas objetos como flores,
papeles u obstá culos.
Además, el robot puede acceder y modificar los valores de variables que
el sistema ofrece y dejar o no un rastro a medida que transita por la ciudad.
Al igual que PSeInt, el aplicativo DaVinci Concurrente nos brinda un
lenguaje sencillo para la incorporació n y el manejo de conceptos básicos de
la programació n estructurada y modular, empleando palabras clave, primi-
tivas, sentencias simples o compuestas, estructuras de control, expresiones
y constructores de subprogramas.
Podremos utilizar cero, uno o más robots en cada programa.
Primero empezaremos por el reconocimiento del entorno de trabajo del
DaVinci, integrado básicamente por cuatro paneles: 1) de edició n de có digo
fuente, 2) el de resultados, donde se pueden visualizar los mensajes, 3) el de
estado de ejecució n, 4) el de la ciudad donde transitan el/los robot/s y
los objetos que la componen.

90 | LOVOs y GOin
 Figura 4.1. Entorno gráfico del programa DaVinci

La franja superior es la barra de íconos que permiten crear, abrir y guar-

dar programas fuentes; dentro del programa se puede cortar, copiar y pegar
texto; ejecutar, pausar, continuar y frenar el funcionamiento del algoritmo,
así como también depurar.
Empecemos con nuestro primer ejemplo, sin utilizar el robot por ahora.
Al mismo tiempo indicaremos las diferencias con PSeInt en la escritura
del algoritmo.

Recomendación: Ir probando los ejercicios propuestos a medida que avan-

zamos.

Ejemplo 1: Pedimos que el usuario ingrese el nombre de su localidad para

mostrar por pantalla “Bienvenido a la ciudad_________”, donde las líneas
representarían la ciudad o pueblo que se ha introducido previamente.
Escribimos el algoritmo en el sector 1 (editor de código fuente).

EnTORnO de pROGRaMaCión | 91
visual
Para ejecutar el programa se debe presionar el ícono de ejecución (barra de
botones octavo de izquierda a derecha), nos aparecerá la siguiente ventana
de carga:

Esto sucede gracias a la instrucción «pedir» del algoritmo.

Luego de ingresar la localidad (supongamos que ingresamos Comallo) y acep-
tar el paso, nos aparece en el sector 2 (panel inferior izquierdo) lo siguiente:
Yo vivo en la localidad de Comallo.

Recomendaciones: Es importante mantener la indentació n (tabulació n),

pues organiza y mejora la lectura del programa, aunque funcione sin ella.
Notarán cambios de colores en la fuente para diferenciar las palabras re-
servadas del lenguaje del resto.
El nombre del programa, en este caso “ejemplo1” no debe tener es-
pacios en blanco ni símbolos, salvo el guion de abajo “ejemplo_1”.
Se aconseja ir guardando el archivo con un nombre adecuado (identifi-
catorio) siendo la extensió n punto j (es decir .j, tercer ícono de izquierda
a derecha).

La sintaxis del lenguaje es similar a la de PSeInt, a continuació n se pre-

senta una tabla comparativa:

DaVinci PSeInt
Programa Proceso
Pedir Leer
Informar Mostrar por pantalla
Fin FinProceso

Además contiene las instrucciones «comenzar» y «variable» y utiliza los

paréntesis () para los ingresos por teclado y salida de mensajes a diferencia
de PSeInt. Para comentar una línea de có digo se utilizan los símbolos //. Las
variables son indiferentes a minú sculas o mayú sculas.
DaVinci nos obliga a definir todas las variables que vamos a usar en
nuestro programa previo a su uso. Veamos un ejemplo.

92 | LOVOs y GOin
Ejemplo 2: Pedimos que el usuario ingrese los lados de un rectángulo
para mostrar el perímetro y área del mismo en un único cartel de salida “El
períme- tro es y el área es “

Las asignaciones difieren en el símbolo “:=” (en PSeInt es) A ← L1*L2 (en
Da- Vinci es) A := L1*L2
Al igual que en el PSeInt se pueden alternar en la salida texto y variables
con la instrucción «informar».

4.1. Variables del programa DaVinci

Se pueden utilizar las variables de tipo nú mero, texto y ló gico.

Operaciones
Tipo Contenido
Aritmética Comparación
Número Números enteros +-*/% <= >= ><<> =
Combinación entre +
Texto <= >= ><<> =
números y letras (para concatenar)
Lógico v/f (verdadero/falso) &|! = <>

Atención: Cuando operamos con enteros y obtenemos nú meros decima-

les (no enteros) su salida o respuesta será truncada (solo la parte
entera), por ejemplo 30,8 será 30.

A continuació n mostraremos ejemplos con la intervenció n del robot

(Lubo-I).

EnTORnO de pROGRaMaCión | 93
visual
4. 2. Conociendo la ciudad del robot

La ciudad de 81 cuadras está conformada por 10 avenidas y 10 calles, orien-

tadas de modo vertical y horizontal, respectivamente.
La avenida 1 y calle 1 se ubica en la parte inferior izquierda como se
muestra a continuació n.

Figura 4.2. Ciudad DaVinci

Para una mejor orientació n, la estrella está ubicada en la avenida 6 y la

calle 3. El robot siempre se mueve de esquina en esquina y podemos
elegir des-
de donde parte.
Para configurar la ciudad y sus objetos vamos al menú superior:

Al acceder a «Configurar Ciudad» emerge la siguiente ventana:

94 | LOVOs y GOin
 Figura 4.3. Configuración de ciudad

En los espacios se agrega la cantidad y ubicació n de flores, papeles y

obstáculos que quisiéramos de entrada. Por ejemplo, si la cantidad de flores
es 10, entonces debemos elegir la ubicació n (avenida y calle) por cada una.
Lo mismo sucede con los papeles y los obstáculos.

Atención: En una esquina se puede depositar más de un objeto (del mis-

mo tipo o no) por ejemplo: en la avenida 4 calle 7, tres flores y dos papeles.

Ejemplo 3: Recorrer una cuadra entera desde la avenida 5 calle 7 en sentido

horario llegando hasta el punto de partida.

EnTORnO de pROGRaMaCión | 95
visual
En este programa no se utilizan variables. El comando «pos(5,7)» indica la po-
sición inicial del robot, es decir, de modo genérico «pos(avenida,calle)».
Atención: Si al ejecutar el programa no se alcanza a ver el movimiento
del robot, entonces podemos cambiar la velocidad con la opció n de la
barra del menú superior «Configurar intérprete» dá ndole un mayor
retardo. Por defecto el robot siempre se dirige verticalmente hacia
arriba. Para activar el robot debemos escribir en el programa «iniciar»
luego de
«comenzar».

Ejemplo 4: Hacer lo mismo que el ejercicio anterior pero en sentido contrario.

Dado que el robot solo puede girar a la derecha es necesario moverlo 3 veces a
derecha para orientar el robot a la izquierda y para eso utilizamos repetir 3.

Sin estructura de repetición Con estructura de repetición

derecha repetir 3
derecha derecha
derecha

Atención: la instrucció n derecha, al estar dentro de la estructura de repe-

tició n «repetir», se ubica indentada (tabulada).

96 | LOVOs y GOin
Ejemplo 5: Recorrer en forma de escalera desde avenida 2 y calle 4, comenzando
horizontalmente hasta llegar a la avenida 7 y calle 8 e informar la posición final.

Los comandos posAV y posCA nos brindan la posición del robot, en este
caso, al finalizar el recorrido.

4.2. Repetición

Volvamos al ejemplo 4, es posible observar que hay un conjunto de

pasos que se repiten:

Entonces es posible reescribir el algoritmo como sigue:

EnTORnO de pROGRaMaCión | 97
visual
 De esta forma, no solo reducimos la cantidad de comandos, sino que es
má s fá cil determinar qué hace el programa.
Para el ejemplo 5 la solució n será la siguiente:

Ejemplo 6: Recorrer el borde de la ciudad desde avenida 1 y calle 10,

mientras tanto debe contar la cantidad de esquinas en las que hay flores. Al
finalizar debe informar esa cantidad.

Atención: Para realizar este ejercicio primero tendremos que configurar

la ciudad poniendo flores en las esquinas. Podemos hacerlo ubicando
cada una en esquinas elegidas por el usuario o bien de modo
aleatorio. Supongamos que se colocan 10 flores de modo aleatorio,
entonces ten- dremos que ir a «Configurar Ciudad» y en la solapa
«Flores» elegir «10» en la secció n «Aleatorias». Estas aparecerán recién
cuando ejecutemos el algoritmo.

La variable c de tipo nú mero por defecto se inicializa con el valor cero

para luego ser usado como contador incrementando en uno c:=c+1 (cada
vez que encuentra una flor).

98 | LOVOs y GOin
 La primitiva hayflorenlaesquina devuelve verdadero si en la esquina
hay alguna flor o falso en caso contrario.

Atención: La distribució n de flores aparecerá cuando ejecutemos el

al- goritmo y ademá s hay que tomar en cuenta que en una esquina
puede haber má s de una flor. En este caso, no contemplamos la
cantidad que debe haber en cada esquina, solo si existen o no flores.
Nota: Las instrucciones comenzar y fin no solo sirven para abrir y cerrar
el proceso del algoritmo, se utilizan también para delimitar las
sentencias dentro de las siguientes estructuras de control: «repetir»,
«mientras» y
«si», siempre y cuando haya más de una sentencia dentro de cada una.

Ejemplo 7: Igual al anterior pero tomando en cuenta la cantidad real de flores.

Puede pasar que en una esquina exista más de una flor.

EnTORnO de pROGRaMaCión | 99
visual
 A diferencia del ejemplo anterior, reemplazamos el si por el control
de repetició n mientras, que se ejecuta hasta que no haya más flores en la
es- quina y (para no caer en un bucle infinito) debemos ir juntando flores.
Esta primitiva se llama tomarflor y permite capturar de a una las flores
para depositarlas en una bolsa.

Atención: Antes de utilizar la primitiva tomarflor es necesario asegurar-

se que exista al menos una flor. Para averiguar la existencia de flores se
utiliza la primitiva hayflorenlaesquina.

Ejemplo 8: Recorrer el borde de la ciudad desde avenida 1 y calle 10,

mientras tanto debe contar la cantidad real de flores y papeles que
encuentra en el ca- mino. Al finalizar debe informar la cantidad hallada.
Atención: Antes de continuar, debemos agregar de modo aleatorio los
papeles en las esquinas de la ciudad, entrando por el menú «Opciones»
– «Configurar Ciudad» y luego en la solapa «Papeles» agregamos la canti-
dad en la secció n «Aleatorias».

Se utilizan en este caso dos contadores: cf y cp (contador de flores y

de papeles, respectivamente).

100 | LOVOs y GOin

Importante: Cuando un bloque de acciones tiene má s de una acció n
es necesario delimitar el bloque usando las palabras reservadas
comen- zar y fin, no siendo necesario cuando se trata de una sola
instrucció n. Recuerden que en DaVinci no es necesario inicializar la
variable conta- dora/sumadora, alcanza con definirla en el sector
«variables» y automá - ticamente toma el valor 0. Sin embargo, como
buena prá ctica de pro- gramació n, siempre que se declara una variable
es importante darle un valor inicial.
Ejemplo 8b: ¿Qué sucede si deseamos que el robot cuente la cantidad de flo-
res halladas pero sin alterar el estado de la ciudad? Es decir, dejando flores
y papeles en el mismo sitio.
El robot también puede moverse teletransportándose, es decir, sin la necesi-
dad de caminar a la esquina deseada, simplemente usando el comando pos.
A continuació n, presentamos un ejemplo relacionado.

Ejemplo 9: Recorrer las avenidas de números impares (1, 3, 5, 7 y 9) de arriba

hacia abajo (desde la calle 10 a la 1).

Atención: Primero, para dirigir el robot hacia abajo debemos girar

dos veces 90º con derecha derecha. La estructura de repetició n se
efectú a 5 veces para recorrer las avenidas impares 1,3,5,7 y 9 que se
incrementan de dos en dos con la asignació n avenida:=avenida+2.

EnTORnO de pROGRaMaCión |
visual
Ejemplo 10: Recorrer la diagonal principal de la ciudad (desde 1,1 a 10,10).

Nó tese que a diferencia de los demás ejercicios donde interviene el mo-

vimiento del robot, este no pinta el trayecto ya que va saltando de
esquina en esquina.

Atención: Al ser la diagonal principal, se trata de recorrerla manteniendo

el mismo valor de avenida y calle pos(1,1) pos(2,2) …pos(10,10). Por lo tan-
to, podemos reducir las líneas de comandos de nuestro algoritmo usando
solo una variable numérica, por ejemplo x, entonces pos(x,x).

Ejemplo 11: Recorrer la calle 4 en avenidas pares (2,4,6,8 y 10) e informar la

cantidad de esquinas donde no hay flores.

102 | LOVOs y GOin

Atención: Si el robot excede el límite de la ciudad, se le informa dicho
error en el sector 2 de resultados (panel inferior izquierdo).

En este ejemplo, el valor de la variable calle se mantiene en 4

mientras que la variable avenida va incrementándose de a dos. El
símbolo ! repre- senta la negació n o complemento de la respuesta de
«hayflorenlaesquina».
DaVinci simboliza los operadores ló gicos de forma similar al lenguaje
de programació n C.

Símbolo Significado Ejemplo

(p>4 & p<10) el valor de p se encuentra entre 4 y
& Disyunción o División
10 (no incluidos)
(p>8 | p<=1) el valor de p es mayor a 8 o es menor
| Conjunción o Unión
o igual que 1
Negación o
! !haypapelenlaesquina → No hay papel
Complemento
A continuació n, mostramos un ejemplo donde hay disyunció n y nega-
ció n al mismo tiempo.

Ejemplo 12: Recorrer todas las esquinas de las avenidas 4 y 8 e informar la can-
tidad de esquinas donde hay flores y no papeles.

En este caso, el robot recorre las dos avenidas dejando la marca porque
estamos usando la instrucció n mover.

EnTORnO de pROGRaMaCión |
visual
 El ultimo objeto que nos falta ver es el obstáculo. A diferencia de las flo-
res y papeles estos se deben ubicar en la ciudad de modo manual, para eso
debemos ir a «Opciones» – «Configurar Ciudad» y hacer click en la solapa
«Obstá culos».

Figura 4.4. Configurar obstáculos

En la figura 4. 4 hay un obstáculo en la avenida 3 y calle 5 generado a mano.

Nota: Podemos agregar una por esquina y el límite está determinado por
la cantidad total de esquinas de la ciudad.

104 | LOVOs y GOin

Ejemplo 13: Recorrer la ciudad (avenida por avenida) desde la posición (1,1),
hasta encontrar un obstáculo, mientras tanto ir contando las esquinas que
tienen flores y mostrar el resultado.

Nota: Por cada paso que da el robot, se evalú a la estructura de control mien-
tras y se decide si avanza o no el ciclo dependiendo de dos situaciones:
a) Que no se pase del límite de la ciudad avenida<11.
b) Que no aparezca en su camino un obstáculo !hayobstaculo.
Atención: Para probar la solució n, previo a la ejecució n, agregar a la
ciudad por lo menos un obstá culo.

EnTORnO de pROGRaMaCión |
visual
Ejemplo 14: Recorrer la ciudad de modo aleatorio hasta encontrar 6 esquinas con
papeles o hasta toparse con un obstáculo. En cada paso, debe contabilizar y
reco- lectar los papeles que vaya encontrando, utilizar la instrucción
tomarpapel.

Nota: La funció n aleatorio(N) devuelve un nú mero entero entre 0 al

N-1, es decir que con aleatorio(10) retorna un valor entero compren-
dido entre 0 y 9. Si le sumamos 1 se convierte al rango entre 1 y 10, coin-
cidiendo con los posibles nú meros de avenidas y calles de la ciudad.
Atención: El algoritmo finaliza cuando llega a 6 la cantidad de papeles o
cuando el robot se encuentra con un obstáculo. ¿Qué sucedería si se quita la
instrucció n tomarpapel? ¿La salida del algoritmo sería la misma?

4. 3. Modularización

A lo largo de la historia de la ingeniería de sistemas de informació n se

han desarrollado diferentes técnicas para construir programas. El primer
gran avance se conoce como programació n modular y complementa la
progra- mació n estructurada. La programació n modular utiliza abstracció n
de pro- cedimientos (Di Mare, 1991). Ahora bien ¿qué significa abstraer y
por qué este concepto resulta tan importante en la ciencia informática?
La abstracció n es un proceso mental que consiste en identificar los
detalles importantes cuando nos enfrentamos a un problema, mientras se
ignoran los detalles irrelevantes. Este proceso permite simplificar el
problema ya que la cantidad de informació n a manejar en un determinado
momento disminuye.

106 | LOVOs y GOin

 La programació n modular consiste en definir mó dulos, una especie
de cajas negras que tienen una forma de comunicarse (interfaz)
claramente definida. Usando abstracció n de procedimientos el
programador puede separar el qué hace el mó dulo del cómo lo hace.
Así, es posible descomponer funcionalmente un programa en subpro-
gramas. El propó sito es facilitar la resolució n de problemas, dividiendo
el problema en subproblemas mas simples, basándose en la idea «divide
y vencerás». Una metodología de resolució n de problemas con estas caracte-
rísticas es el diseñ o top -down.
Ejemplo: Se desea preparar una tarta de manzanas.

Figura 4.5. Ejemplo de modularización

En el ejemplo de la figura 4.5, cada caja (mó dulo) cumple una funció n
específica (qué hace) y, en algunos casos, comparte informació n con otras
(interfaz).
En general, en las soluciones modularizadas, un programa es también un
mó dulo, llamado programa principal (en el ejemplo: preparar tarta de man-
zana). Este mó dulo se encarga de controlar todo lo que sucede y es el
respon- sable de transferir el control a los submó dulos de modo que ellos
puedan lle- var adelante su funció n y resolver el problema. Cada uno de los
submó dulos, cuando finaliza su trabajo, devuelve el control al mó dulo que lo
invocó .
Los invitamos a navegar una animació n desarrollada por docentes
de la facultad de informática de la unlp sobre el concepto de modulari-
zació n, siguiendo este vínculo: http://weblidi.info.unlp.edu.ar/catedras/
ingreso/material2013/IAI/Adicional/DemoModularizacion/MODULOS.
html.

EnTORnO de pROGRaMaCión |
visual
 Hasta el momento, vimos ejemplos con programas a partir de la utiliza-
ció n de una secuencia de instrucciones de modo lineal:

Muy ú tiles cuando trabajamos con problemas sencillos, pero cuando se

nos presentan problemas más complejos es conveniente subdividirlos
de acuerdo a las diferentes funcionalidades que encontramos en el
problema. De esta forma, la resolució n del problema general se obtendrá
resolviendo cada uno de los subproblemas. Si logramos que la solució n
(algoritmo) a cada uno de estos subproblemas maneje su propio
conjunto de datos se tendrán soluciones (algoritmos) independientes
que podrán codificarse por separado y reutilizarse en otros problemas
La estructura de un programa en DaVinci ahora sería la siguiente:

No es nuestra intenció n hacer un capítulo destinado en profundidad a

modularizació n, pero si consideramos importante clarificar algunos con-
ceptos. Existen dos tipos de mó dulos: procedimientos y funciones. En líneas
generales una funció n es un mó dulo que recibe uno o más datos
(paráme- tros) y produce un valor o resultado que es ú nico y de alguno
de los tipos permitidos en el lenguaje. Por ejemplo, logaritmo(unNro,
unaBase) es una funció n que recibe un nú mero entero y una base entera
y retorna un valor numérico que representa el logaritmo en base unaBase
del nú mero unNro.
Un procedimiento, en cambio, está formado por un conjunto de sen-
tencias o instrucciones que realizan una determinada tarea y que
pueden recibir 0, 1 o más datos (parámetros) y devolver 0, 1 o más
resultados.
En el caso de Visual DaVinci solo trabaja con procedimientos denomi-
nados en su sintaxis como procesos.
108 | LOVOs y GOin
 Má s arriba dijimos que los mó dulos pueden compartir informació n y
esto se logra a través del pasaje de parámetros. La interfaz del mó dulo indi-
ca qué parámetros (su tipo) y en qué orden serán recibidos.

Ejemplo 15: Juntar todas las flores de las esquinas de la avenida 6. Tenga en
cuenta que podría existir más de una flor.

Figura 4.6. Procedimiento juntarflores

Nota: Los procedimientos simplemente se invocan o llaman por su nom-

bre en el cuerpo del programa. Y deben estar declarados previo a su
uso. En este caso el procedimiento JuntarFlores no recibe
pará metros. Su acció n es solo tomar las flores de las esquinas sin
contabilizarlas. Atención: Si quisiéramos retornar la cantidad de
flores que se recogie- ron, debemos utilizar pará metros en el
procedimiento JuntarFlores. Esto se hace agregando entre paréntesis el
parámetro cantidad de tipo nú mero. En el pró ximo ejemplo lo
detallamos.

EnTORnO de pROGRaMaCión |
visual
Ejemplo 16: Juntar todas las flores de las esquinas de la avenida 6. Informar
en cada esquina la cantidad juntada y al finalizar el recorrido informar el
total de flores que se recogieron. Tenga en cuenta que podría existir más
de una flor en cada esquina.

Nota: El procedimiento JuntarFlores ahora tiene un pará metro (de sali-

da) de tipo numero (sa cantidad:numero). El identificador sa indica que
el pará metro cantidad es un pará metro de salida.
Cada vez que se invoca o llama al procedimiento, la variable se
limpia comenzando nuevamente en cero y dentro del mó dulo cambiará
depen- diendo de lo que haga el programador con dicha variable.
Cuando se invoca el procedimiento en el cuerpo del programa se deben
respe- tar los parámetros, su tipo, cantidad y ubicació n. En este caso, se trata
de un parámetro c, es decir JuntarFlores(c), siendo c el resultado de cantidad.

4. 4. Parámetros formales y reales

Cuando se declara un procedimiento se habla de parámetros formales y

cuando se lo invoca se habla de parámetros reales o actuales. En el ejem-
plo 16 el procedimiento JuntarFlores(sa cantidad:numero) contiene el

110 | LOVOs y GOin

parámetro formal cantidad que está en la definició n del procedimiento,
mientras que JuntarFlores(c) contiene el parámetro real “c”.
En general, los lenguajes de programació n exigen que el nú mero de pará-
metros reales y formales coincidan en tipo y cantidad. DaVinci Concurrente
chequea esta condició n y en caso de no cumplirse, no permite que se ejecute el
programa.

Ejemplo 17: El robot debe recorrer un circuito rectangular dentro de la

ciudad cuyos parámetros deben ser ingresados por el usuario (coordenada
inicial y tamaño). Debe dejar la huella y comenzar a moverse hacia arriba
desde el punto inicial.

Nota: El procedimiento MovRectan solo recibe parámetros de entrada, y

en DaVinci esto se indica usando el identificador en para cada parámetro
de entrada (en AVini:numero; en CAini:numero;…).
Atención: Recordar que los pará metros reales, los que se usan en la
in- vocació n deben coincidir en tipo y orden con la especificació n de
los parámetros formales. Así mismo, para que funcione correctamente
un mó dulo es importante verificar previo a la invocació n del mismo que
los valores de los parámetros cumplan con las precondiciones
establecidas. En este caso, el mó dulo MovRectan no especifica ninguna
precondició n, entonces el mó dulo deberá validar que el robot no exceda
los límites de la

EnTORnO de pROGRaMaCión |
visual
ciudad. ¿Có mo lo resolverían?

4. 5. Variables globales y locales

Las variables que se encuentran dentro del procedimiento se llaman locales

y tiene su alcance limitado al mismo, mientras las variables que se designan
fuera de los procedimientos son globales, y son visibles en todo el programa.
De esta forma, en cualquier subprograma podría referenciarlas o modifi-
carlas. Es importante para preservar la independencia de los mó dulos que
si necesitan compartir informació n, se haga a través del pasaje de paráme-
tros y no referenciando a variables globales.
Los parámetros de un procedimiento pueden funcionar como entrada
exclusiva, salida exclusiva o entrada/salida usando para cada caso el pre-
fijo: en, sa o es. En el caso del procedimiento MovRectan (del ejercicio
17) usamos solo pará metros de entrada.
Veremos un caso de procedimiento con parámetros de salida.

Ejemplo 18: El robot se dirige a una esquina elegida por el usuario para contar la
cantidad de papeles y flores. Además, indique pre y poscondiciones para el

módulo.
Nota: El robot primero solicita la esquina elegida por el usuario y luego
llama (invoca) al procedimiento ContarPapelFlor que tiene dos parámetros
de en- trada (av, calle) y dos parámetros de salida (Papeles, Flores). ¿Cuáles
son las precondiciones que deben cumplir los parámetros de entrada?

112 | LOVOs y GOin

 Ahora veremos có mo se pueden hacer llamadas de procedimientos den-
tro de procedimientos.

Ejemplo 19: Se pide diseñar e implementar un programa modularizado, don-

de el robot recorra un rectángulo de 4 x 4 a partir de una coordenada inicial
indicada por el usuario. Se pretende que el robot deje la huella de su
recorrido y que comience a moverse hacia arriba desde el punto inicial,
contando la cantidad de papeles y flores de cada esquina.

Pregunta: ¿Cuáles serían la pre y poscondiciones de cada módulo?

Nota: Cuando se realiza la invocació n a un mó dulo con parámetros de entra-

da-salida o salida, los parámetros reales deben ser siempre variables, ya que
no se copia un valor sino una referencia a una posició n en memoria.

EnTORnO de pROGRaMaCión |
visual
4.6. Ejercicios Da Vinci

51.Diseñ e e implemente un programa que permita que el robot recorra

la ciudad completa (pasando por todas las esquinas) y dejando la
huella. El robot debe comenzar su recorrido en la coordenada (1,1).
52. Igual al ejercicio anterior pero informando al final del recorrido
la cantidad de esquinas que tienen flores.
53.Diseñ e e implemente un programa que permita que el robot recorra
la diagonal inversa desde (1,10) hasta (10,1) sin dejar marca.
54. Diseñ e e implemente un programa para que el robot dibuje
(dejan- do huella) la palabra LES. Las letras deben tener la misma
altura que la ciudad.
55.Diseñ e e implemente un programa que permita que el robot realice
un recorrido en modo escalera desde la posició n (1,10) bajando has-
ta (10,1) dejando huella.
56. Diseñ e e implemente un programa que permita al usuario
ingresar la coordenada de partida (Avenida, Calle) y luego el robot
realice un recorrido en un rectángulo de 3x3 en sentido contrario al
movimien- to del reloj y dejando la huella.

Nota: El programa principal debe controlar que el robot no sobre-

pase los límites de la ciudad.

57. Igual ejercicio anterior, pero además el programa deberá informar al

finalizar la cantidad de esquinas que no tienen objetos (papel o
flores).
58.Diseñ e e implemente un programa que permita que el robot recorra
solo las calles pares dejando huellas e informe al finalizar la cantidad
(por separado) de flores y papeles que ha encontrado en las esquinas
durante su recorrido.

Nota: Tenga en cuenta que en una esquina podría haber más de un

elemento (flor/papel).

59. Diseñ e e implemente un programa que permita que el robot reco-

rra solo las calles impares dejando huellas e informe al finalizar la
cantidad de esquinas que tienen la misma cantidad de flores que
de papeles a excepció n de las que están vacías.

114 | LOVOs y GOin

60.Diseñ e e implemente un programa que permita que el robot recorra
la ciudad con direcció n al azar comenzando desde la posició n
(3,4), sin dejar huella y sin saltar. El azar se determina en cada
esquina y el programa finaliza cuando llegue a la posició n (7,7).

Nota: Si el robot intenta irse fuera de los límites de la ciudad debe

hacer un paso hacia atrás (direcció n contraria al ú ltimo paso).

61. Se tienen ubicados en la ciudad cuatro obstáculos en las posicio-

nes: (2,2); (2,8); (8,2) y (8,8). Diseñ e e implemente un programa, que
permita que el robot recorra la ciudad al azar usando el mismo crite-
rio que el ejercicio anterior. Cuando se encuentra con un
obstáculo debe saltar hacia otro lugar también al azar. El
algoritmo termina cuando se encuentra con más de dos
obstáculos.

Nota: Recordar que para ubicar los obstáculos se debe ir a «Opcio-

nes» – «Configurar ciudad» – «Obstá culos».

62.Igual al ejercicio anterior pero informando la cantidad total de flo-

res y papeles (por separado) al finalizar el recorrido.

EnTORnO de pROGRaMaCión |
visual
Listas de referencias

Lista de referencias bibliográficas

Champredonde, R., Ainchil, V., y Palacios, A. (2000). Teaching experiences in

program- ming using the visual Da Vinci language. En First International
Congress on Tools for Teaching Logic: proceedings: University of Salamanca, June 2000
(pp. 17-21). Uni- versidad de Salamanca.
Compañ -Rosique, P., Satorre-Cuerda, R., Llorens-Largo, F. y Molina-Carmona, R. (2015).
Enseñ ando a programar: un camino directo para desarrollar el pensamiento
computacional. Revista de Educación a Distancia, (46).
De Giusti, A. E., Madoz, M. C., Bertone, R. A. y Naiouf, R. M. (2001). Algoritmos, datos y
programas: con aplicaciones en Pascal, Delphi y Visual Da Vinci. Prentice Hall.
Depetris, B. O., Aguil Mallea, D., Pendenti, H., Tejero, G., Feierherd, G. E. y Prisching,
G. (2015). La enseñ anza y el aprendizaje de la programació n y la programació n
concurrente con DaVinci Concurrente. En x Congreso sobre Tecnología en Educa-
ción & Educación en Tecnología (te & et). Corrientes.
Di Mare, A. (1991). Tipos abstractos de datos y programació n por objetos, Reporte Técnico
piBdC-03-91, proyecto 326-89-019, Escuela de Ciencias de la Computació n e Infor-
mática, uCR, 1991. Revisió n 2010. http://www.di-mare.com/adolfo/p/oop-adt.htm
García, C. E. (2012). Algoritmos y programación I. Guía para docentes. Fundació n Gabriela
Piedrahita Uribe.
Guerrero, M., Guamán, D. S. y Caiza, J. C. (2015). Revisió n de herramientas de apoyo en el
proceso de enseñ anza-aprendizaje de programació n. Revista Politécnica, 35(1), p. 84.
Goin, M. (2016). Caminando junto al lenguaje C. Editorial unRn.
Joyanes Aguilar, L. (2008). Fundamentos de programación. McGraw-Hill Interamericana.
Ló pez, L. M., Amaro, S., Alonso de Armiñ o, A. C., Godoy, I., Leiva, M. y Piñ ero, J. C.
(2016,
May). Aplicando nuevos aspectos en la Programació n de Computadoras. En
xviii Workshop de Investigadores en Ciencias de la Computación wicc 2016, Entre Ríos,
Argentina.
Mallea Aguil, D. E. (2012). Un intérprete multiplataforma para la iniciació n a la progra-
mació n estructurada y concurrente. Da Vinci Concurrente. [Tesis de grado de
Licenciatura]. Facultad de ingeniería de la Universidad Nacional de la Patago-
nia. San Juan Bosco. Ushuaia, Tierra del Fuego.
Polya, G. (2004). How to Solve It. Princeton Science Library Edition.

LisTas de RefeRenCias |
Lista de figuras

Financial Times. (2011). Drew Hoston [Fotografía]. https://www.flickr.com/photos/

financialtimes/6478266407/in/photostream. CC-By-2.0
Game Developers Choice Awards. (2010). Gabe Newell [Fotografía]. https://www.flickr.
com/photos/officialgdc/4427575126/. CC-By-2.0
Joi Ito. (2011). Mitchel Resnick [Fotografía]. https://commons.wikimedia.org/wiki/File:Mitchel_
Resnick.jpg. CC-By-2.0
Usuario: ak_mardini. (2006). Seymour Papert [Fotografía]. https://www.flickr.com/photos/
mardinix/152833938/. CC-By-sa-2.0

118 | LOVOs y GOin

Problemas y algoritmos : un enfoque práctico
Edith Lovos y Martin Goin.
Primera edición. Viedma: Universidad Nacional de Río Negro,
2021. 120 p. ; 23 x 15 cm. Lecturas de cátedra
isbn 978-987-4960-31-3
1. Algoritmo. 2. Sistemas de Información. I. Lovos, Edith. II. Título.
cDD 005.01

© Universidad Nacional de Río Negro, 2021.

editorial.unrn.edu.ar
© Edith Lovos y Martin Goin, 2021.

Queda hecho el depósito que dispone la Ley 11.723.

Diseño de colección: Dirección de Publicaciones-Editorial de la UnRn

Dirección editorial: Ignacio Artola
Coordinación de edición y edición de textos: Diego Martín Salinas
Corrección de textos: Verónica García Bianchi
Diagramación y diseño: Sergio Campozano
Imagen de tapa: Editorial UnRn, 2021.

Licencia Creative Commons

Usted es libre de: compartir-copiar, distribuir, ejecutar y
comunicar públicamente esta obra bajo las condiciones de:
Atribución – No comercial – Sin obra derivada
PRObLeMAS y ALgoRiTMOS
Un enfoque práctico
fue compuesto con la familia tipográfica Alegreya en sus diferentes variables.
Se editó en abril de 2021 en la Dirección de Publicaciones-Editorial de la
UnRn.
Problemas y algoritmos
Un enfoque práctico
El desarrollo de la capacidad analítica y creadora para resolver
problemas constituye el punto de partida para quienes desean
incursionar en el mundo de la programación informática. Es
esa capacidad la que permite enfocar el elemento clave del
pensamiento computacional: el algoritmo.
Como un tutorial que avanza paso a paso a través de ejercicios
y ejemplos, este libro busca ayudar al lector interesado a adquirir
las destrezas necesarias para poder diseñar e implementar, de
manera fácil y rápida, soluciones algorítmicas básicas, previo a la
inmersión en el uso de uno o más lenguajes de programación en
particular.
Es por ello que Problemas y algoritmos es un valioso material de
apoyo tanto para docentes como para estudiantes de nivel medio y
superior, en este último caso, que cursen las asignaturas iniciales de
tecnicaturas, ingenierías, profesorados y licenciaturas orientadas o
vinculadas a la informática.