2004 - CONICET Santa Fe

Universidad Nacional del Litoral
Facultad de Ingeniería Química
Departamento de Matemáticas
Notas para los cursos de
Computación y Programación
con el lenguaje Pascal
Néstor Aguilera
Año 2004

Índice general
1. Preliminares 1
1.1. ¿Qué esesto? ............................. 1
1.2. Cómo usar este libro . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.3. Organización y convenciones usadas ................ 3
1.3.1. Versión electrónica ...................... 3
1.4. Para los viejos y/o insomnes . . . . . . . . . . . . . . . . . . . . . 4
1.5. Sobre la versión 2004 . . . . . . . . . . . . . . . . . . . . . . . . . 6
2. El primer contacto 7
2.1. Un poco, muy poco, sobre cómo funciona la computadora .... 7
2.2. Programas: edición, compilación, ejecución ............. 8
2.3. El puntapié inicial . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.4. Comentarios Bibliográficos ...................... 12
3. Tipos de datos elementales 13
3.1. Tipos, variables e identificadores .................. 13
3.2. Tipos numéricos: entero y real .................... 16
3.2.1. “Readln” . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2.2. Funciones numéricas . . . . . . . . . . . . . . . . . . . . . 18
3.2.3. La codificación de enteros y reales ............. 19
3.3. Variables lógicas . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.4. Caracteres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.5. Comentarios Bibliográficos ...................... 24
4. Tomando control 25
4.1. “If” .................................. 26
4.2. “While” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.3. “Repeat” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.4. “For” ................................. 35
4.5. Ingresando muchos datos: “Eoln” .................. 37
4.6. Comentarios Bibliográficos ...................... 39
5. Aplicaciones 40
5.1. Cálculo numérico elemental . . . . . . . . . . . . . . . . . . . . . 40
5.1.1. Mezclando números grandes y pequeños . . . . . . . . . . 40
5.1.2. Métodos iterativos: puntos fijos ............... 42
5.1.3. El método babilónico . . . . . . . . . . . . . . . . . . . . . 45
5.2. Números enteros y divisibilidad . . . . . . . . . . . . . . . . . . . 48

Pág. ii Índice general
5.2.1. Ecuaciones diofánticas . . . . . . . . . . . . . . . . . . . . 48
5.2.2. Máximo común divisor y el algoritmo de Euclides . . . . . 49
5.2.3. Números primos . . . . . . . . . . . . . . . . . . . . . . . 52
5.3. Problemas Adicionales ........................ 53
5.4. Comentarios Bibliográficos ...................... 54
6. Arreglos 55
6.1. Dimensionamiento de arreglos . . . . . . . . . . . . . . . . . . . . 55
6.2. Búsqueda Lineal ........................... 57
6.3. Cribas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
6.4. Polinomios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
6.5. Problemas Adicionales ........................ 64
6.6. Comentarios Bibliográficos ...................... 65
7. Funciones y Procedimientos 66
7.1. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
7.2. El método de la bisección ...................... 70
7.3. Procedimientos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
7.4. Pasando por valor o por referencia . . . . . . . . . . . . . . . . . 77
7.5. Comentarios Bibliográficos ...................... 80
8. Todos juntos: arreglos, funciones y procedimientos 81
8.1. Definiendo nuestros propios tipos de datos: “type” . . . . . . . . 81
8.2. Ingreso e impresión de arreglos . . . . . . . . . . . . . . . . . . . 82
8.3. La caja de herramientas . . . . . . . . . . . . . . . . . . . . . . . 84
8.4. Arreglos multidimensionales . . . . . . . . . . . . . . . . . . . . . 85
8.5. “Strings” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
8.6. Manejo elemental de archivos de texto . . . . . . . . . . . . . . . 86
8.7. Problemas Adicionales ........................ 89
8.8. Comentarios Bibliográficos ...................... 90
9. Números Aleatorios y Simulación 91
9.1. Números aleatorios . . . . . . . . . . . . . . . . . . . . . . . . . . 91
9.2. Aplicaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
9.3. Problemas Adicionales ........................ 94
10.Búsqueda y clasificación 96
10.1. Búsqueda lineal con centinela . . . . . . . . . . . . . . . . . . . . 96
10.2. Búsqueda binaria ........................... 98
10.3. Métodos elementales de clasificación . . . . . . . . . . . . . . . . 101
10.4. Registros (Records) . . . . . . . . . . . . . . . . . . . . . . . . . . 105
10.5. Problemas Adicionales ........................108
10.6. Comentarios Bibliográficos ......................109
11.Recursión 110
11.1. Funciones y procedimientos definidos recursivamente . . . . . . . 110
11.2. Los Grandes Clásicos de la Recursión . . . . . . . . . . . . . . . . 113
11.3. Problemas Adicionales ........................116
11.4. Comentarios Bibliográficos ......................118

Índice general Pág. iii
12.Generando objetos combinatorios 119
12.1. Pilas y colas ..............................119
12.2. Generando Subconjuntos . . . . . . . . . . . . . . . . . . . . . . . 121
12.3. Generando permutaciones ......................124
12.4. Árboles binarios ordenados . . . . . . . . . . . . . . . . . . . . . 126
12.5. Problemas Adicionales ........................131
12.6. Comentarios Bibliográficos ......................132
13.Grafos y árboles 133
13.1. Representación de grafos en la computadora ............136
13.2. Recorriendo un grafo . . . . . . . . . . . . . . . . . . . . . . . . . 137
13.3. Recorrido a lo ancho y en profundidad ...............139
13.4. Camino más corto: Dijkstra . . . . . . . . . . . . . . . . . . . . . 141
13.5. Mínimo árbol generador: Prim . . . . . . . . . . . . . . . . . . . 145
13.6. Problemas Adicionales ........................148
13.6.1. El algoritmo de Kruskal . . . . . . . . . . . . . . . . . . . 149
13.7. Comentarios Bibliográficos ......................154
14.Punteros y listas encadenadas 155
14.1. Punteros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
14.2. Listas encadenadas . . . . . . . . . . . . . . . . . . . . . . . . . . 157
14.3. Otras estructuras dinámicas . . . . . . . . . . . . . . . . . . . . . 160
14.4. Problemas Adicionales ........................162
14.5. Comentarios Bibliográficos ......................162
15.Más problemas 163
15.1. Polinomios interpoladores de Lagrange ...............163
15.2. Cuenta de Goldbach . . . . . . . . . . . . . . . . . . . . . . . . . 164
15.3. El juego de “la generala” ......................164
15.4. Visibilidad en el plano ........................164
15.5. Aproximando e con dados ......................164
15.6. Generando “manos” aleatoriamente ................165
15.7. Clasificación por fusión . . . . . . . . . . . . . . . . . . . . . . . 166
15.8. Media, mediana y moda . . . . . . . . . . . . . . . . . . . . . . . 168
15.9. Números de Fibonacci: Zeckendof ..................168
15.10. La Cola de Supermercado . . . . . . . . . . . . . . . . . . . . . 168
15.11. La Producción de la Fábrica ....................169
15.12. Pasos en búsqueda binaria . . . . . . . . . . . . . . . . . . . . . 169
15.13. El Juego de Nim . . . . . . . . . . . . . . . . . . . . . . . . . . 169
15.14. Comentarios Bibliográficos . . . . . . . . . . . . . . . . . . . . . 171
A. Programas mencionados 173
Problema 2.2: holamundo . . . . . . . . . . . . . . . . . . . . . . . . . 173
Problema 3.2: sumardos . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Problema 3.3: leerdato . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
Problema 3.4: raiz .............................174
Problema 3.7: enteroareal . . . . . . . . . . . . . . . . . . . . . . . . . 174
Problema 3.13: segundos . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Problema 3.16: positivo . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
Problema 3.18: caracteres1 . . . . . . . . . . . . . . . . . . . . . . . . . 175

Pág. iv Índice general
Problema 4.2: valorabsoluto ........................176
Problema 4.4: comparar . . . . . . . . . . . . . . . . . . . . . . . . . . 176
Problema 4.5: caracteres2 .........................176
Problema 4.11: resto . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Problema 4.12: tablaseno . . . . . . . . . . . . . . . . . . . . . . . . . . 177
Problema 4.13: gauss . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Problema 4.16: cifras . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
Problema 4.17: epsmin ...........................179
Problema 4.18: potencia . . . . . . . . . . . . . . . . . . . . . . . . . . 180
Problema 4.22: eolnprueba .........................180
Problema 4.23: sumardatos .........................181
Problema 5.10: babilonico .........................181
Problema 5.15: euclides ...........................182
Problema 5.20: factoresprimos . . . . . . . . . . . . . . . . . . . . . . . 183
Problema 6.1: unidades ...........................184
Problema 6.2: busquedalineal ........................184
Problema 6.5: eratostenes .........................186
Problema 6.7: flaviojosefo1 .........................187
Problema 7.1: potencias2 . . . . . . . . . . . . . . . . . . . . . . . . . . 188
Problema 7.2: potencias3 . . . . . . . . . . . . . . . . . . . . . . . . . . 188
Problema 7.3: biseccion ...........................189
Problema 7.6: tablaseno2 . . . . . . . . . . . . . . . . . . . . . . . . . . 191
Problema 7.7: intercambio .........................192
Problema 8.2: maximocaracter . . . . . . . . . . . . . . . . . . . . . . . 192
Problema 8.8: deconsolaaarchivo ......................194
Problema 8.8: dearchivoaconsola ......................195
Problema 9.1: dado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
Problema 9.2: dados . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Problema 12.6: arbolbinario ........................197
Problema 13.4: anchoprimero . . . . . . . . . . . . . . . . . . . . . . . 199
Problema 13.8: dijkstra ...........................202
Problema 14.1: listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
Problema 14.9: grafos ...........................209
B. Sobre los compiladores Pascal 214
C. Breve referencia de Pascal 215
C.1. Resumen de operadores . . . . . . . . . . . . . . . . . . . . . . . 215
C.1.1. Operadores aritméticos . . . . . . . . . . . . . . . . . . . 215
C.1.2. Operadores relacionales . . . . . . . . . . . . . . . . . . . 215
C.1.3. Operadores lógicos ......................215
C.2. Identificadores estándares ......................215
C.3. Nombres Reservados .........................217
D. Algunas notaciones y símbolos usados 218
D.1. Lógica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
D.2. Conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
D.3. Números: conjuntos, relaciones, funciones .............219
D.4. Números importantes en programación . . . . . . . . . . . . . . . 220
D.5. Generales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220

Índice general Pág. v
Bibliografía 221
Índice de figuras 223
Índice de cuadros 224
Índice alfabético 225

Capítulo 1
Preliminares
1.1. ¿Qué esesto?
Algunos se enloquecen por la cerveza, otros prefieren vino, y también están
los abstemios. Pero todos estamos de acuerdo en que la computadora ocupa, y
cada vez más, un lugar importante en nuestras vidas.
Decimos esto pensando en internet, el acceso a la información, la cuenta
del banco y los impuestos, multimedios como gráficos, sonidos, películas y juegos
(videos), y siguiendo con una larga lista que, sin embargo, difícilmente incluirá
resolución de problemas matemáticos.
Y nuestras creencias están de acuerdo con nuestras experiencias. Los primeros
encuentros con la computadora y sus aplicaciones tienen que ver con hacer
“click” con el “ratón” para acceder a juegos, “browsers” y el correo electrónico.
Después aprendemos algo del funcionamiento del sistema operativo, procesadores
de texto y planillas de cálculo, y el software que se use en nuestro trabajo.
No es ningún misterio que estas aplicaciones están diseñadas y realizadas
por personas, ingenieros y técnicos de sistemas, y programadores. Consecuentemente,
el primer curso de programación usualmente está orientado hacia las
aplicaciones de sistemas informáticos, por ejemplo hacia el manejo de archivos
con vistas a bases de datos, lo cual es muy comprensible.
La propuesta aquí es un tanto diferente: hacer el primer curso de programación
pensando en las aplicaciones matemáticas. Después de todo, el nombre
“computadora” tiene que ver más con matemáticas que con “informática”.
En el libro se va entrelazando la introducción de los elementos de programación
estructurada con la resolución de problemas de análisis y cálculo numérico,
teoría de números, combinatoria y grafos, sirviendo tanto de introducción de
algunos temas como de repaso y fortalecimiento de otros.
Quedan aparte temas de álgebra lineal, ya que la resolución numérica de
problemas lineales requiere un estudio cuidadoso de los errores, que está fuera
del propósito introductorio del libro.
1.2. Cómo usar este libro
Uno puede darse una idea de cómo cocinar mirando un libro de cocina, pero
seguramente la experiencia es mucho más completa y satisfactoria si se tienen

Pág. 2 Preliminares
los ingredientes, las cacerolas y la misma cocina. Del mismo modo, se puede
apreciar qué es la programación mirando un libro, pero nosotros supondremos
que el lector dispone además de una computadora y un compilador Pascal con
los que trabajar.
Así como el aprendiz aprende observando al artesano, en programación es
muy importante copiar (y tomar ideas y estructuras de) programas ya hechos,
aunque a veces no se entienda exactamente del porqué detalocualsintaxis.
Idealmente quien trabaje con los contenidos de este libro copiará (preferentemente
de un diskette o de internet) los programas presentados, y hará variaciones
ocopiarápartesdeunoomás de ellos para resolver los distintos problemas.
Muchos principiantes se ponen ansiosamente a tipear un programa sin tener
un plan específico, quizás por su experiencia previa con la computadora. Una
buena parte de los problemas que planteamos no son sencillos de resolver, y
seguramente no se resuelven probando con distintos “botones”. Más aún, varios
de los problemas no necesitan de la computadora.
Quien quiera sacar provecho de este libro deberá hacer uso del lápiz y papel
para trazarse un plan de resolución antes de copiar o modificar los programas,
pero para eso debe entender primero qué es lo que hacen las distintas partes y
—por sobre todo— a dónde se quiere llegar.
La adquisición de conocimientos no es gratuita y requiere esfuerzo y tiempo,
y las equivocaciones forman parte inevitable de este proceso:
¡habrá que estar dispuesto a pasar un buen rato en
la silla!
Aún cuando no podamos resolver un problema en programación o en matemáticas,
es poco útil que alguien nos cuente la solución si antes no hemos
hecho un trabajo propio: de este modo podremos apreciar, e inclusive criticar,
la que nos proponen.
En algunos problemas se incluyen “sugerencias” para la resolución, que están
puestas como orientación cuando se está “perdido”. La recomendación es “tapar”
la sugerencia, y recurrir a ella en segunda instancia o cuando ya se ha
resuelto el problema para ver si hay otras posibilidades de resolución.
Esto nos trae al tema de que tanto en programación como en matemáticas,
no hay una única forma de hacer los programas o resolver los problemas. Lo
presentado es sólo una posibilidad.
A algunos les parecerá que las sugerencias son oscuras o escasas, a otros
les parecerá que el material presentado es excesivo, y habrá otros que querrán
resolver más problemas: para éstos se incluye una sección de “Problemas Adicionales”
en los capítulos más avanzados, así como todo el capítulo 15.
A todos les recomendamos los libros de Engel [4], Wirth [15, 16] —autordel
lenguaje que usamos, Pascal— y Jensen y Wirth [7] para temas específicos de
Pascal, que forman la base sobre la cual está hecho este libro.
En fin, habrá algunos que querrán seguir avanzando aún más, quizás después
de terminar este libro, y una posibilidad muy interesante es tomar problemas
de las competencias estudiantiles de la ACM (Association for Computing Ma-

1.3. Organización y convenciones usadas Pág. 3
chinery (1) ), en las que los representantes de nuestro país vienen participando
exitosamente desde hace varios años.
1.3. Organización y convenciones usadas
En los capítulos 2 a 15 se presentan los temas y problemas, agrupados en
secciones y a veces subsecciones. Los problemas están numerados comenzando
con 1 en cada capítulo, de modo que el “problema 4.5” se refiere al problema 5
del capítulo 4. De modo similar, la “sección 3.2” se refiere a la sección 2 del
capítulo 3.
En muchos de los problemas se mencionan programas completos, que se han
puesto juntos en el apéndice A, al que le sigue información sobre compiladores
Pascal (apéndice B) disponibles en internet. A modo de glosarios, finalizamos
con una breve referencia de Pascal (apéndice C) y notaciones usadas en el libro
(apéndice D).
A veces intercalaremos texto entre los problemas, por lo que para indicar el
fin del enunciado de un problema colocamos el signo ✄, que puede leerse como
“la cortamos acá”.
Intercalados entre texto y enunciados de problemas, hay algunas notas y
comentarios, en tipo de letra más chico para no distraer demasiado del texto
principal, y puede omitirse su lectura.
En los comentarios, en itálica, se hacen referencias históricas, orientadoras,
curiosidades, etc. Son de la forma
Esto es un comentario.
Por otra parte, las notas son en general de índole más técnica, y son de la
forma
✎ Esto es una nota.
Usamos otros tipos de letra para indicar los nombres de los programas, así,
mientras que lo que escribiremos en la computadora está indicado en “monotipo”,
así, algunas veces entre comillas dobles, para recalcar algún fragmento,
“ como éste ”, reservando las comillas simples para caracteres, como ‘ a ’.
Siguiendo la tradición norteamericana, la computadora expresa los números
poniendo un “punto” decimal en vez de la “coma”, y para no confundirnos
seguiremos esa práctica en todo el texto. Así, 1.589 es un númeroentre1y2,
mientras que 1589 es un número entero, mayor que mil.
También se hace complicado trabajar con acentos o tildes (como en “ á ”o
“ ~n ”) al escribir los programas o mostrar resultados por pantalla, de modo que
en la escritura de códigos los obviaremos (escribiendo “ a ”o“ni ”).
En fin, en el texto indicamos con el pulsado de la tecla “Retorno”
(o “Return” en teclados ingleses) para iniciar un nuevo renglón. Dependiendo
del sistema operativo, es posible que deba pulsarse en cambio la tecla “Intro”
(o “Enter” en inglés).
1.3.1. Versión electrónica
La versión electrónica (2) en formato “pdf” tiene algunas ventajas:
(1) http://icpc.baylor.edu/icpc/
(2) Disponible en http://math.unl.edu.ar/~aguilera/libro2004

Pág. 4 Preliminares
• Se puede leer e imprimir desde distintas plataformas (Unix, Windows, etc.)
usando el software gratuito Adobe Reader (anteriormente Adobe Acrobat
Reader) (3) .
• Es muy fácil moverse dentro del documento, subiendo o bajando una página
o ir a una página determinada, y también se puede ver en distintos
tamaños.
• Se puede buscar dentro del documento algún fragmento de texto. . . tratando
de evitar acentos como en “á”, tildes como en “ñ” o “ligaduras”
como en “fi”.
• Eligiendo la “herramienta de texto”, marcada con una gran “T”, es posible
copiar algún fragmento de texto desde un archivo “pdf” a otro documento
hecho con otro software. Esto es especialmente útil para copiar partes de
programas.
• Tiene capacidades de “hipertexto”: referencias en color pueden seleccionarse
para moverse en el documento o internet, y es sencillo volver al lugar
anterior.
Pero. . .
– al imprimir en blanco y negro los colores se ven como grises,
– puede suceder que la posición en la página a la que se llegue esté un
poco corrida hacia arriba o abajo, lo que es especialmente confuso
cuando justo hay un cambio de página,
– o peor, que directamente nos lleve al lugar incorrecto: ¡no sólo los
alumnos y los profes hacen programas imperfectos!
1.4. Para los viejos y/o insomnes
El núcleo del libro es la resolución de problemas para desarrollar el pensamiento
matemático y las conexiones con el pensamiento algorítmico, pasando
de abstracciones al resultado concreto de un programa para la computadora.
Hemos tratado de ubicarnos entre dos extremos. Por un lado el uso de la
computadora como un fin y no como un medio, donde lo importante es la computadora
relegando a un plano secundario, o aún ignorando, las matemáticas.
Por otro lado, el aprendizaje de sistemas avanzados con los que “apretando botones”
obtenemos resultados, muchas veces sin saber de dónde salen ni cuán
confiables son (o de qué estamos hablando).
Y seguramente que queremos apartarnos lo másposibledelapeordetodas
las propuestas, lamentablemente muy difundida: el aprendizaje rutinario de
técnicas de dudoso valor que son rápidamente olvidadas.
Esta relación entre abstracto y concreto se realimenta al usar la computadora
como banco experimental para encontrar patrones, llegar a conjeturas y a su
eventual demostración matemática.
Interpuestos más que nada como comentarios, se tocan temas de eficiencia
y complejidad de algoritmos, pero no se incluyen temas de corrección de
programas.
(3) Disponible en http://www.adobe.com/products/acrobat/readermain.html

1.4. Para los viejos y/o insomnes Pág. 5
Una característica del libro, además de los temas que se presentan, es la
inclusión de muchos programas acabados, pues en programación —mucho más
que en matemáticas— se aprende mirando lo que han hecho otros, y es inclusive
deseable el “reuso” de partes ya hechas. Sin embargo los programas presentados
difícilmente puedan considerarse “estado del arte”, y se han sacrificado la
eficiencia y la brevedad tratando de hacer una presentación clara.
También sólo se usa seudo-código en los capítulos más avanzados (y en mínima
medida), a contra corriente de otros cursos introductorios, con la convicción
de que es muy difícil entender —e imposible concretar— qué seestádiciendo en seudo-código. Es como tratar de aprender una síntesis de los idiomas antes
de aprender a hablar en alguno (4) .
En el libro usamos el lenguaje Pascal. Considerado “obsoleto” por distintas
razones, tiene la gran ventaja de haber sido diseñado especialmente para la
enseñanza de programación por uno de los grandes autores, N. Wirth, y brinda
la posibilidad de una clara formulación de los programas y —mucho más
importante— una sólida base para el futuro.
Habiendo elegido Pascal, hemos tratado de ceñirnos lo más posible a su
estándar pues debe conocerse y apreciarse la importancia de la portabilidad y
consistencia entre diferentes sistemas operativos.
Los capítulos 2, 3, 4, 6, 7, 8, 10 y 11 son más o menos comunes a todos los
cursos de programación, aunque —como mencionamos— hay un fuerte énfasis
hacia las matemáticas dejando de lado la informática. En cambio, los capítulos 5
y 9 cubren temas de matemáticas (teóricas o aplicadas) que normalmente no se
dan.
Aunque pilas y colas es un tema normalmente incluido en cursos de programación,
la perspectiva que damos en el capítulo 12 es bastante distinta:
allí trabajamos con objetos combinatorios, como subconjuntos, permutaciones
yárboles binarios, donde aparece verdaderamente la fuerza de recursión.
Lossiguientesdoscapítulos toman rumbos distintos y son bastante independientes
entre sí. El capítulo 13 está pensado para aquéllos que ya hayan visto
un curso de matemática discreta o teoría de grafos, implementando (en forma
elemental) los primeros algoritmos de grafos. En cambio, el capítulo 14 muestra
las posibilidades de las listas encadenadas, liberándonos de algunas ataduras de
los arreglos.
En el capítulo final hay algunos temas y problemas, algunos más avanzados,
que hemos preferido separar del cuerpo principal del libro.
En la redacción se puede notar la influencia de los libros de Kernighan y
Ritchie [10] yWirth[16] en lo referente a programación, y de Engel [4] yGentile
[5] en cuanto a basar el curso en resolución de problemas (y varios de los
temas considerados). Por otro lado, hemos seguido el estándar Pascal según [7].
Al final de algunos capítulos damos referencias bibliográficas sobre temas y
problemas particulares, pero muchos de ellos pertenecen al “folklore” y es difícil
determinar el origen.
En cuanto a las notas de carácter histórico, muchas han sido basadas en el
material de http://www-groups.dcs.st-and.ac.uk/˜history
(4) Los más viejos recordamos el fracaso de la “matemática moderna”.

Pág. 6 Preliminares
1.5. Sobre la versión 2004
Estas notas se van modificando añoaaño en base a la experiencia que se va
ganando en el dictado del curso. Algunos temas se han eliminado o cambiado,
mientras que otros se han agregado. En particular, para la versión 2004 hemos
agregado muchos más gráficos, y por lo tanto bastante más páginas, así como
el hipertexto en la versión electrónica. También hemos agregado un índice
alfabético que seguramente dista de ser perfecto.
Por supuesto, hemos tratado de corregir los errores encontrados (tipográficos
o conceptuales) en notas de años anteriores, por lo cual debo agradecer
especialmente a Luis Bianculli, Jorge D’Elía y Egle Haye.

Capítulo 2
El primer contacto
2.1. Un poco, muy poco, sobre cómo funciona
la computadora
Conceptualmente, la computadora es una máquina que toma o accede a
datos, los procesa y devuelve resultados. Los datos o entradas y los resultados
o salidas pueden ser simples como números o letras, o mucho más complicados
como una matriz o una base de datos (1) , que podemos esquematizar como
entrada procesamiento salida
En el modelo de computadora con el que trabajaremos (o de von Neumann),
pensaremos que el procesamiento está a cargo de una única unidad, llamada
CPU por “Central Processing Unit” o Unidad Central de Procesamiento, que
accede los datos y retorna los resultados secuencialmente, es decir, de a uno por
vez, y los datos a los que accede se guardan en una lugar denominado memoria.
John von Neumann (1903–1957) se interesó inicialmente en lógica, teoría
de conjuntos, de la medida, y mecánica cuántica, tocando luego temas de análisis
funcional, teoría ergódica, siendo fundador de la teoría de juegos. En sus
últimos años también tuvo influencia decisiva en ecuaciones en derivadas parciales
y en teoría de autómatas, en la que sintetizó sus conocimientos e ideas
de lógica y grandes computadoras electrónicas.
En los programas que haremos normalmente nos comunicaremos con la computadora
entrando los datos con el teclado y recibiendo los resultados en la pantalla,
refiriéndonos en general como terminal o consola al conjunto combinado
de teclado y pantalla. Estos datos que entramos o recibimos no son directamente
procesadosporlaCPU,sinoquesontransferidosaodesdelamemoriamediante
la misma CPU u otro procesador dedicado.
Un esquema del movimiento de datos entre periféricos (consola, discos, impresora,
etc.), memoria y CPU está indicado en la figura 2.1.
Nos imaginaremos que la memoria, en donde se almacenan los datos, está
constituida por muchas cajitas pequeñas llamadas bits por “Binary Digit”
(1) Es como pensar en una máquina de hacer chorizos: ponemos los ingredientes (mezcla,
tripa, etc.), y después de dar vuelta la manija tenemos los chorizos.

Pág. 8 El primer contacto
consola
pantalla
teclado
discos
impresora
otros
memoria
(datos)
CPU
(procesamiento)
Figura 2.1: Esquema de transferencia de datos en la computadora.
odígito binario, en cada una de las cuales sólo se puede guardar un 0 o un
1.Puestoqueestacajaesdemasiadopequeña para guardar información más
complicada que “sí/no” o “blanco/negro”, los bits se agrupan en cajas un poco
más grandes llamadas bytes, que generalmente tienen 8 bits, conceptualmente
alineados, puesto que queremos que 00001111 sea distinto de 11110000. Ver
esquema en la figura 2.2.
un byte
1 0 1 0 1 0 0 1
bits
Figura 2.2: Bits y byte.
Problema 2.1. Suponiendo que un byte tenga 8 bits:
a) ¿Cuántas “ristras” distintas de 0’s y 1’s puede tener? Sugerencia: hacer la
cuenta primero para un byte de 1 bit, luego para un byte de 2 bits, luego
para un byte de 3 bits,. . .
b) Si no importara el orden de los bits que forman el byte, y entonces 00001111,
11110000, 10100101 fueran indistinguibles entre sí, ¿cuántos elementos distintos
podría contener un byte? Sugerencia: si el byte tiene 8 bits puede ser
que hayan 8 ceros y ningún uno, o 7 ceros y 1 uno, o. . . ✄
A su vez, para las computadoras más recientes, estas unidades resultan demasiado
pequeñas para alimentar a la CPU, por lo que los bits o bytes se agrupan
formando cajas de, por ejemplo, 32, 64 o 128 bits (usualmente potencias de 2),
siempre conceptualmente alineadas.
2.2. Programas: edición, compilación, ejecución
Por supuesto, queremos que la computadora “haga algo” con los datos que
le damos, pero tenemos que darle instrucciones sobre cómo hacerlo. El conjunto
de instrucciones y datos para realizar determinada tarea es lo que llamaremos
programa, y los mismos programas pueden considerarse como un tipo especial
de datos.

2.2. Programas: edición, compilación, ejecución Pág. 9
En particular, el sistema operativo de la computadora es un programa que
alimenta constantemente a la CPU, y le va a indicar, por ejemplo, que ejecute
(o corra) nuestro programa, leyendo las instrucciones que contiene.
Los lenguajes de programación son “abstracciones” que nos permiten escribir
las instrucciones de un programa de forma que un ser humano puede entender
más fácilmente que ristras de ceros y unos. Las instrucciones para la máquina
se escriben como sentencias —de acuerdo a las reglas del lenguaje— en lo que
se llama programa fuente.
Hay distintos tipos de lenguajes de programación, cada uno con sus defectos
y virtudes. Dentro de los que más se usan en matemáticas, están (en orden más o
menos cronológico) Fortran,“C”,Pascal, “C++”, y otros integrados a sistemas
con posibilidades gráficas y/o simbólicas como Matlab, Maple o Mathematica. En
estas notas usaremos el lenguaje Pascal, que ha sido diseñado para la enseñanza
de programación.
N. Wirth dio el nombre de Pascal al lenguaje en honor al matemático
francés Blaise Pascal (1623–1662), quien fue uno de los primeros en desarrollar
una calculadora mecánica, cuando tenía unos 20 años.
Sin embargo hubo muchas otras calculadoras antes, como las computadoras
lunares y planetarias del astrónomo iraní al-Kashi (1393–1449), o la de W.
Schickard (1592–1635) que multiplicaba y dividía, mientras que la de Pascal
(construida entre los años 1642–1644) sólo sumaba y restaba.
Luego de elegir un lenguaje de programación, al desarrollar un programa lo
usual es primero escribir el programa fuente (el que nosotros entendemos) con
un editor de textos en la computadora, eventualmente guardando lo escrito en
el disco rígido o un diskette.
El programa fuente debe ser traducido a algo que la CPU pueda entender,
es decir las famosas ristras de 0’s y 1’s. Este proceso se llama compilado, dando
por resultado un programa ejecutable, que es el que en realidad va a usar la
computadora.
✎ Esta descripción basta para nuestros propósitos, en realidad todo el proceso
requiere otros pasos intermedios que en nuestro caso serán hechos
automáticamente.
✎ Algunos lenguajes son interpretados, es decir no existe la compilación y no
se crea el ejecutable.
En la mayoría de los casos —aún para gente experimentada— habrá problemas
en la compilación (por ejemplo, por errores de sintaxis), o al ejecutar
el programa los resultados no serán los esperados. Esto da lugar a un ciclo de
trabajo esquematizado en la figura 2.3.
Editar fuente Compilar ejecutable Ejecutar
Corregir
Figura 2.3: Esquema del desarrollo de un programa.
En fin, al momento de usar el programa ejecutable, el sistema operativo lo
aloja en algún lugar disponible de la memoria, quedando un esquema como el
de la figura 2.4.

Pág. 10 El primer contacto
Memoria
programa
ejecutable
datos
instrucciones
Figura 2.4: Esquema del programa ejecutable en la memoria.
2.3. El puntapié inicial
Para lo que sigue, será conveniente ir mirando el primer programa Pascal
con el que trabajaremos: el programa holamundo (pág. 173).
En Pascal, todos los programas (fuentes) se dividen en dos partes o cuerpos.
En la primera, a veces llamada de declaraciones, se coloca el nombre del
programa mediante “ program nombre(input,output)” yotrassentenciasque
iremos viendo.
✎ Siguiendo el estándar Pascal. Muchos compiladores aceptan, sin embargo,
la omisión de “ (input, output) ”.
La segunda parte, a veces llamada principal, empieza con “ begin ”ytermina
con “ end. ” (punto “ . ” incluido), y entre ellos se ponen sentencias para realizar
“acciones”.
En ambas partes, de declaraciones y principal, las sentencias se separan
mediante “ ; ”. En cualquier lugar se pueden agregar comentarios, encerrados
entre “ (* ”y“*) ” que nos ayudan a entender lo que hicimos cuando volvemos
amirardespués de un par de semanas.
✎ También se pueden encerrar comentarios entre “ { ”y“} ”, pero no los
usaremos a fin de seguir una sintaxis más parecida a otros lenguajes como
“C” o Mathematica.
Para evitar confusiones, normalmente se guarda el programa fuente en un
archivo con el mismo nombre que en la sentencia “ program nombre ... ”, y
con extensión “ .p ”o“.pas ”, para indicar que se trata de un programa Pascal.
Así, generalmente guardaremos el programa fuente de nombre pepe en el archivo
“ pepe.p ”o“pepe.pas”. Al compilarlo, el ejecutable cambia la extensión a
“ .exe ”, de modo que obtenemos el archivo “ pepe.exe”.
✎ La extensión para el ejecutable depende del sistema operativo, y puede no
existir. Asimismo, puede no existir la extensión para el programa fuente.
La prueba de fuego es editar, compilar y ejecutar el primer programa. Sin
embargo, los detalles de cómo realizar el ciclo de edición-compilación-ejecución
dependen del sistema operativo y el compilador (la marca del compilador) que
estemos usando, de modo que habrá que seguir las instrucciones de los manuales
o pedir auxilio a algún conocido con este primer paso.
Problema 2.2 (Hola Mundo). Copiar, compilar y ejecutar el programa holamundo,
guardándolo en disco o diskette como “ holamundo.pas”.
✎ Muchos compiladores, entre ellos el muy difundido Turbo Pascal, hacen que
al ejecutar un programa como holamundo se abra una ventana distinta que
se cierra automáticamente al finalizar la ejecución del programa. El proceso

2.3. El puntapié inicial Pág. 11
puede ser tan rápido que apenas nos damos cuenta de que ha sucedido algo.
En estos casos es conveniente agregar un renglón con las instrucciones
writeln(’ para fin’); readln
al terminar el programa, antes de “ end. ” y agregando un “ ; ”alfindel
renglón anterior.
Turbo Pascal y otros compiladores similares no crean el ejecutable automáticamente,
sino que hay que darle instrucciones para que lo hagan.
Para nuestros propósitos, no será necesario crear el ejecutable.
a) Observar con cuidado los signos de puntuación y qué hace cada una de las
instrucciones:
• El renglón inicial que comienza con “ program...”, y que termina en
“ ; ”. En este programa es la única sentencia de la parte declarativa.
• El comentario inmediatamente después de “ program...”, explicando al
que lee el programa fuente cuál es el propósito.
• El cuerpo principal que empieza con “ begin ”yterminaen“end. ”.
• Hay tres sentencias en la parte principal, separadas por dos “ ; ”.
• “ writeln ” escribe un renglón en la pantalla, y el texto a escribir se
encierra entre “ ’ ” (comillas simples). Si no tiene argumentos, “ writeln ”
escribe un renglón “vacío”.
b) Eliminar, repetir o cambiar las instrucciones. Por ejemplo:
i) eliminar el segundo “ writeln ”,
ii) y después también el tercero,
iii) cambiar “ writeln ”por“WRITELN ”, y después por “ Writeln ”,
iv) cambiar “ ’Hola Mundo!’ ”por“’HOLA MUNDO!’ ”,
v) modificar el programa para que se escriba “ bye, bye ”envezde“y
Chau! ”.
c) En general, al escribir el programa usamos indentación o sangrías, i.e. espacios
al comienzo de algunos de los renglones, y a veces renglones enteros
en blanco, para resaltar la estructura del programa. Esto no es necesario, e
inclusive podría escribirse el programa en un único renglón, y un espacio o
varios no hacen diferencia:
i) Eliminar o agregar espacios al comienzo, en el medio y/o al final de
algunos renglones, compilar el programa y verificar que se obtiene el
mismo resultado.
ii) Agregar renglones en blanco o poner dos (o todos los que se quiera)
renglones en uno solo, y verificar que se obtiene el mismo resultado (y
recordar que “ ; ” se usa en Pascal como en castellano: para separar
sentencias).
✎ A los fines del programa fuente, los espacios, tabulaciones (tecla tab o
similar) y renglones son intercambiables (mientras no estén encerrados
entre comillas simples).
d) Agregar y/o eliminar comentarios. Por ejemplo, agregar el comentario “colorin,
colorado” después de writeln(’y Chau!’), en el mismo renglón y/o
en el siguiente. ✄
El uso de “ ; ” en Pascal resulta un poco confuso al principio, pero debe
tenerse en mente que se usa como “ , ”o“; ” se usan al construir una oración

Pág. 12 El primer contacto
en castellano: para separar sentencias. Del mismo modo, el “ . ”enPascaltiene
el mismo sentido que el punto final en castellano. En cambio, la “ , ”seusaen
forma distinta, por ejemplo, para separar argumentos de funciones como se hace
en matemáticas.
Pero no desesperar: por el momento no es necesario entender todo lo que se
hace.
2.4. Comentarios Bibliográficos
El programa holamundo está tomado de [10], y es clásica su inclusión al
aprender a programar.

Capítulo 3
Tipos de datos elementales
Recordemos que la información, incluyendo el programa ejecutable, se guarda
en un lugar de memoria, como ristras de ceros y unos. Como números y
caracteres se representan de esta forma, la computadora al tomar un dato debe
saber si se trata de uno u otro. Esto da lugar a distintos tipos de datos, como
estudiamos en este capítulo.
3.1. Tipos, variables e identificadores
Supongamos que guardamos las letras siguiendo el orden del abecedario, ‘ a ’
como 0, ‘ b ’como1,‘c ’ como 10, y así sucesivamente. Vemos que no podríamos
distinguir entre el par de letras “ ba ”ylaúnica letra “ c ”, pues ambas ser
representarían como 10.
Para evitar esta confusión, se decide que todas las letras ocupen siempre el
mismo espacio, por ejemplo un byte de 8 bits. De esta forma tendremos (ver el
problema 2.1) 2 8 = 256 posibilidades para los caracteres, lo cual es suficiente
para guardar las letras de nuestro alfabeto (pero no los de algunos alfabetos
orientales).
Habiendo decidido esto, nos toca ahora guardar números. Como antes, es
conveniente guardar a todos los números en la misma cantidad de bits. Si usáramos
8 bits como hicimos para las letras, tendríamos sólo 256 números disponibles,
lo cual es bien pobre. Es conveniente que las “cajas” sean más grandes.
Cuando la máquina lea estas cajas que guardan letras o números, tiene que
saber cuántos bits juntos tiene que leer, e interpretar la ristra de bits según sea
una letra o un número. Surgen así cuatro tipos elementales de datos, cada uno
con distinta codificación interna:
• boolean para guardar los valores “ true ” (verdadero) o “ false ”(falso),
• char para guardar caracteres, i.e. letras, signos de puntuación y otros que
veremos más adelante,
• integer para guardar números enteros, como 1, 0, −5, y
• real para guardar números reales, i.e. números como 123.456.
Llamamos a las variables lógicas “booleanas”, en honor a G. Boole (1815–
1864), quien hizo importantes progresos al “algebrizar” la lógica.

Pág. 14 Tipos de datos elementales
En la figura 3.1 ilustramos algunas cajas con datos dentro de la memoria,
con sus tipos correspondientes.
a 1234 123.456
char integer real
verdadero 4321 98.7654
boolean integer real
Figura 3.1: Datos de tipos elementales en la memoria.
Ahora tenemos el problema de cómo acceder a esas cajas que guardan caracteres
o números. Esto es sencillo: les ponemos nombres para identificarlas. Las
cajas así nombradas se llaman variables pues podremos colocar en ellas datos
distintos o (¡ejem!) variables y los nombres que reciben se llaman identificadores.
En la figura 3.2 mostramos algunos nombres posibles para las cajas que
mostramos en la figura 3.1.
a 1234 123.456
codigo a x
verdadero 4321 98.7654
fin m y
Figura 3.2: Los datos con sus identificadores.
Cuando redactamos el programa, debemos indicar al compilador los nombres
y tipos de variables que usaremos, procedimiento llamado de declaración de
variables. En el programa se pone una lista de variables y tipos después de la
palabra clave “ var ”.
Una cosa trae a la otra, y tenemos el problema de que no podemos poner
cualquier nombre. Por ejemplo, no es conveniente usar “ program ”o“writeln ”
que usa Pascal para instrucciones del lenguaje. Además, en Pascal hay nombres
reservados, que no podemos usar como identificadores.
✎ La lista completa de los nombres reservados está en la sección C.3,pág. 217.
Aparte de estas palabras prohibidas, los identificadores en Pascal pueden ser
cualquier sucesión de letras mayúsculas o minúsculas y dígitos, pero
• siempre tienen que empezar con una letra,

3.1. Tipos, variables e identificadores Pág. 15
• no pueden tener espacios entre medio,
• ni pueden tener caracteres como $, ,+,etc.,
• y por supuesto, dos variables distintas no pueden tener el mismo nombre.
A diferencia de otros lenguajes (como “C” o Mathematica), según el estándar
Pascal no se distingue entre mayúsculas o minúsculas tanto en los identificadores
como en palabras claves. Así, podemos poner sin problemas en alguna parte
“ writeln ”yenotra“WriteLn ” (como hemos hecho en el problema 2.2).
✎ Sin embargo, algunos compiladores sí diferencian entre mayúsculas y minúsculas
en identificadores y palabras reservadas.
Problema 3.1. Decidir cuáles de los siguientes son identificadores válidos en
Pascal:
a) mn32xy b) 32xymn c) mn32 xy d) M32nxY e) mn 32 ✄
También tenemos otro problema: cómo colocar los datos en estas cajas o
variables, proceso que se llama asignación.
Una forma de hacerlo es mediante “ := ” (sin espacios intermedios). Así, si
queremos guardar un 2 en la variable n queesdetipoenteroponemos“n := 2”,
y si queremos copiar los contenidos de la caja o variable a en la caja o variable
b, ponemos “ b := a”. Hay que tener un poco de cuidado en este último caso,
pues siempre se pueden hacer asignaciones entre variables del mismo tipo, pero
no es posible hacer asignaciones arbitrarias entre distintos tipos de variables, lo
que veremos con algún detalle en el problema 3.11.
✎ Aunque no debe dejarse espacio entremedio en “ := ”, los espacios a cada
lado no son necesarios. Así, “ n:=2 ”o“n := 2” tienen el mismo efecto.
✎ Otros lenguajes usan otros símbolos para la asignación, en vez de “ := ”. Al
escribir en “seudo código”, muchas veces se usa el símbolo ←, que parece
mucho más apropiado y evita confusiones con el símbolo =.
Otra forma de colocar datos en las respectivas variables es mediante la lectura
de datos, por ejemplo, si a está declarado como “ real ”, la instrucción
“ readln(a)” (que veremos en la sección 3.2.1) lee el número que se ingresa por
terminal y lo guarda en la variable a.
Desde ya que
¡nunca hay que usar el valor de una variable sin antes
haber hecho una asignaciónalavariable!
aunque hay compiladores que automáticamente ponen algún valor al hacer las
declaraciones.
Para tratar de entender esta jerigonza, pasemos a estudiar algunos ejemplos
comenzando con los tipos numéricos “ integer ”y“real ”, para luego considerar
los tipos “ boolean ”y“char ”.

Pág. 16 Tipos de datos elementales
3.2. Tipos numéricos: entero y real
La vida sería un tanto aburrida si sólo pudiéramos cambiar valores de lugar,
es más interesante si podemos realizar operaciones entre estas variables. Así,
suponiendo que las variables a, b y c son del tipo adecuado, una instrucción
como “ a := b + c” hace que la CPU tome los datos que están en las cajas o
variables b y c, las sume, y coloque el resultado en la caja o variable a.
Problema 3.2. Compilar y ejecutar el programa sumardos (pág. 173) analizando
la sintaxis y qué hacen las distintas instrucciones. Por ejemplo:
a) ¿Cuántos comentarios tiene el programa fuente?, ¿qué pasa si se los elimina?
✎ Nosotros pondremos siempre un primer comentario en el programa
fuente para indicar qué hace el programa. A su vez, al ejecutar el
programa trataremos de imprimir un cartel similar para que el usuario
sepa qué es lo que se pretende hacer.
b) La parte declarativa del programa tiene dos sentencias. En la primera estáel
nombre del programa y en la segunda se declaran a y b como de tipo entero,
separando los identificadores con “ , ”.
Ver qué ocurre si se cambia “ var a, b: integer;” por
i) var a; b: integer;
ii) var a: integer; var b: integer;
iii) var a: integer; b: integer;
c) ¿Quépasa si cambiamos el nombre de a por sumardos?
✎ El resultado puede depender del compilador. En general no es aconsejable
usar como nombre del programa una de las palabras reservadas
de Pascal o de una de las variables que aparecen en el mismo programa
fuente, aún cuando el compilador lo acepte.
d) ¿Cuáles son las instrucciones en el cuerpo principal?
e) Observar el uso de la asignación “ := ”, como en “ a := 1” donde se guarda
el valor 1 en a. Cambiar el valor de a para que sea −1 y volver a ejecutar
el programa.
f ) “write ” escribe su/s argumento/s sin terminar un renglón, a diferencia de
“ writeln ”. En cualquier caso, los argumentos (si hay más de uno) están
separados por “ , ”.
i) Cambiar todas las ocurrencias de “ write ”por“writeln ”, y observar
los cambios en la salida del programa.
ii) Cambiar los renglones
write(’La suma de ’, a);
write(’ y ’, b);
writeln(’ es ’, a + b);
por el único renglón
writeln(’La suma de ’, a,’ y ’, b, ’ es ’, a + b);
¿Hay alguna diferencia en la salida?
g) La última línea, “ writeln; writeln(’** Fin **’) ”essólo para avisar
al usuario que el programa ha terminado, y el programa ya no realizará acciones.
Eliminarla y verificar el comportamiento del programa (recordando
la nota al principio del problema 2.2).

3.2. Tipos numéricos: entero y real Pág. 17
h) Cambiar las sentencias de modo de obtener la suma de números reales, i.e.
poner “ real ”envezde“integer ”enladeclaraciónde variables. Compilar
y ejecutar el programa, observando los cambios en la salida.
i) Agregar una variable c, de tipo entero o real según corresponda, hacer la
asignación “ c := a + b” e imprimir c en vez de a + b.
j ) Modificarlo de modo de escribir también la resta (“ - ”), producto (“ * ”) y
división (“ div ” para enteros y “ / ” para reales), tanto en el caso de enteros
como de reales.
k) ¿Quépasacuando se divide por 0? ✄
Conceptualmente hay que distinguir en Pascal entre la variable, elidentificador
yelvalor, i.e. entre la caja, su nombre y lo que contiene.
A fin de no ser demasiado latosos, es común tanto en Pascal como en matemáticas
o la vida real, no distinguir entre identificador, valor y variable, uso
que nosotros seguiremos salvo cuando lleve a confusión: cuando decimos “Josées
simpático”, en general queremos decir “la persona cuyo nombre es José tiene la
cualidad de ser simpática”, y no que el nombre en sí essimpático, en cuyo caso
diríamos “el nombre José essimpático”.
3.2.1. “Readln”
Es un poco tedioso estar cambiando los valores en el programa fuente para
hacer los cálculos. Mucho más razonable es ingresar los datos a nuestro antojo:
Problema 3.3. El programa leerdato (pág. 173) lee un entero ingresado por
terminal y lo imprime. Observar la sintaxis e instrucciones, similares al programa
sumardos, laúnica novedad es el uso de “ readln ”.
a) Compilar y ejecutar el programa, comprobando su funcionamiento.
b) Ingresar, en ejecuciones sucesivas del programa, los siguientes datos (lo que
está entre “ ”, pero sin las comillas) seguidos de , conservando los
espacios intermedios cuando corresponda:
i) “ 23 ”; ii) “2 ”; iii) “2 3”;
iv) “2a ”; v) “a2 ”; vi) “2”.
c) Si“readln ” no tiene argumentos, se lee el renglón entrado —lo escrito
hasta — y lo escrito no se guarda (como la instrucción en la nota
al principio del problema 2.2, enlapág. 10): agregar el renglón
readln;
antes de
write(’Entrar un ...
¿Qué pasasiseingresa“” yluego“1”?,¿ysise
ingresa “ 1” yluego“2”?
d) Combinando los programas sumardos y leerdato, hacer un programa para
ingresar por terminal dos números enteros e imprimir su suma.
✎ Además de “ readln ” existe la función “ read ”, pero postergaremos su uso
para más adelante. Basta decir por ahora que la instrucción “ readln(a) ”
es equivalente a las instrucciones “ read(a); readln ”.

Pág. 18 Tipos de datos elementales
Así como con “ writeln ”y“write ” podemos escribir más de un argumento,
con “ readln ”(y“read ”) podemos leer varios argumentos a la
vez, pero no usaremos esta facilidad para evitar confusiones.
Los comportamientos de “ write ”y“writeln ” para leer, y de “ read ”
y“readln ”sonprácticamente simétricos, aunque existen algunas diferencias
importantes. Por ejemplo, en el tratamiento de los ’s como
hemos visto en el inciso b.vi): “ readln(a) ” los ignora mientras no aparezca
el dato a, pero“writeln(a) ”escribeunúnico renglón por vez. ✄
Cuando se programa profesionalmente, es muy importante que el programa
funcione aún cuando los datos ingresados sean erróneos, por ejemplo si se ingresa
una letra en vez de un número, o el número 0 como divisor de un cociente.
Posiblemente se dedique más tiempo a esta fase, y a la interacción con el usuario,
que a hacer un programa que funcione cuando las entradas son correctas.
Nosotros supondremos que el usuario siempre ingresa
datos apropiados, y no haremos (salvo excepcionalmente)
detección de errores. Y mucho menos
nos preocuparemos por ofrecer una interfase estéticamente
agradable.
En cambio, trataremos de dejar claro mediante carteles
qué hace el programa, qué datos han de ingresarse
en cada momento y dar una señal de finalización.
3.2.2. Funciones numéricas
Pero volvamos a los tipos numéricos.
No sólo podemos sumar o multiplicar números sino que, al igual que en las
calculadoras, hay ya funciones predeterminadas como la raíz cuadrada, que en
Pascal se indica por “ sqrt ”.
Problema 3.4. El programa raiz (pág. 174) calcula la raíz cuadrada de un
númerononegativoentradoporterminal.
a) Compilar y ejecutar el programa, analizando qué hacen las distintas instrucciones.
Probar el programa ingresando números reales, enteros, positivos y
negativos.
b) A fin de escribir en pantalla √ x, no es necesario hacer la asignación previa
“ y := sqrt(x) ”:
i) Reemplazar “ y ”por“sqrt(x) ”enlasentencia“writeln ”, compilar
y ejecutar el programa, verificando que el resultado es el mismo.
ii) Eliminar la variable y del programa por completo (eliminando inclusive
su declaración).
c) ¿Quépasasiseingresa un dato menor que 0?
d) Muchas veces se confunde “ sqrt ”con“sqr ”, que encuentra el cuadrado de
un número, y no su raíz cuadrada. Cambiar “ sqrt ”por“sqr ”yverificar
el comportamiento del programa. ✄

3.2. Tipos numéricos: entero y real Pág. 19
✎ Una lista de las funciones predefinidas en Pascal está enelapéndice C
(pág. 215).
3.2.3. La codificación de enteros y reales
En Pascal, los números ocupan un número fijo de bits, por ejemplo 16 bits
para el tipo “ integer ” y 32 bits para el tipo “ real ” (1) ,porloque
En la máquina sólo pueden representarse un número
finito de números, ya sean enteros o reales.
En otras palabras, “la gran mayoría” de los números
no se pueden representar exactamente en la computadora.
Así, hay un máximo entero representable, que en Pascal se llama maxint,
y hay un menor número real positivo representable que llamaremos εmin ydel
cual hablaremos en el problema 4.17.
Problema 3.5.
a) Suponiendo que el tipo “ integer ” tenga asignados 16 bits, ¿cuántos números
enteros pueden representarse?
b) Análogamente, si el tipo “ real ” tiene asignados 32 bits, ¿cuántos números
reales pueden representarse en la máquina? ✄
Problema 3.6. Hacer un programa para imprimir el valor de maxint correspondiente
al compilador que se usa: no declarar variables y poner el renglón
writeln(’ El entero máximo es: ’, maxint)
✎ En los compiladores más viejos, maxint = 32767. ✄
Sea que las variables de tipo “ integer ”y“real ” ocupen el mismo lugar
o no, su codificación como cadenas de bits es bien distinta. Los enteros se
representan consecutivamente (del menor al mayor), mientras que para representar
los números reales se dividen los bits en dos grupos, uno representando
la mantisa yotroelexponente, como se hace en la notación “científica” al escribir
0.123 × 10 45 (0.123 es la mantisa y 45 el exponente en base 10, pero la
computadora trabaja en base 2).
La representación de números reales mediante mantisa y exponente hace que
—a diferencia de lo que sucede con los números enteros— la distancia entre un
número real que se puede representar y el próximo vaya aumentando a medida
que sus valores absolutos aumentan. Esta propiedad de densidad variable trae
inconvenientes para el cálculo aproximado, como veremos en el problema 4.17
y en la sección 5.1.
(1) La cantidad de bits en cada caso depende del compilador. Incluso ambos tipos podrían
tener asignados la misma cantidad de bits.

Pág. 20 Tipos de datos elementales
1 2 4 8 16
Figura 3.3: Esquema de la “densidad variable” en la codificación de números
reales.
✎ Para entender la “densidad variable”, puede pensarse que hay la misma
cantidad de números representados entre 1 (inclusive) y 2 (exclusive) que
entre2y4,oqueentre4y8,etc.Porejemplo,sihubieransólo4puntos en
cada uno de estos intervalos, tendríamos un gráfico como el de la figura 3.3.
Por el contrario, hay tantos números enteros representados entre 10
(inclusive) y 20 (exclusive), como entre 20 y 30, etc. Es decir, entre 20 y 40
hay el doble de números enteros representados que entre 10 y 20. En este
caso, la “densidad es constante”.
Como todo número entero es en particular un número real, es conveniente
poder pasar de la representación como tipo “ integer ”alarepresentación
como tipo “ real ”. Esto se hace automáticamente en Pascal: si a es de tipo
“ integer ”yx es de tipo “ real ”, la asignación
x := a
hace que automáticamente se guarde el valor que tiene a (un entero) en x ,de
modo que ahora el valor se codifica como real.
✎ En particular, la cantidad de bits (y los valores de éstos) usados en la
representaciones como “ integer ”o“real ” son distintas.
✎ También la conversión se hace automáticamente al ingresar datos: si x es
de tipo real, y tenemos la instrucción “ readln(x) ”, el ingreso de 1 como
dato —un entero— hace que se guarde codificado como real en x.
Problema 3.7. Compilar y ejecutar el programa enteroareal (pág. 174). Observar
la declaración de variables de distinto tipo en el mismo programa. ✄
Problema 3.8. Decir por qué las siguientes declaraciones de variables son incorrectas:
i) var a, b, c: integer; c, d, e: real;
ii) var a, b, c: integer; 2c, d, e: real;
iii) var: a, b, c: integer; d, e: real;
iv) var a, b, c: integer; var d, e: real; ✄
Así como escribimos un entero como real, es posible que queramos pasar de
un real a un entero:
Problema 3.9. Modificar el programa enteroareal de modo de leer x , hacer la
asignación “ a := x” e imprimir a: ¿cuál es el resultado? ✄
Como puede observarse, no es posible cambiar de real a entero directamente:
debe eliminarse primero la parte fraccionaria del real, lo que tradicionalmente
se hace de dos formas distintas.
Una es truncar el real, eliminando la parte decimal. Así, cuando truncamos:
1.1 → 1, 1.9 → 1, −1.9 →−1.
Otra forma es redondear el número real reemplazándolo por el entero más
cercano. Claro que en el redondeo tenemos que decidir qué hacer con números

3.2. Tipos numéricos: entero y real Pág. 21
como 0.5, y adoptamos la convención que se “redondea hacia arriba”: 1.1 → 1,
1.9 → 2, −1.9 →−2. 0.5 → 1, −0.5 →−1.
Problema 3.10. Las funciones de Pascal “ trunc ”, correspondiente a truncar,
y“round ”, correspondiente a redondear, cuando aplicadas a un número real en
la forma “ trunc(x)” o“round(x)” dannúmeros enteros.
✎ Las definiciones de ±, pisoytechoestán en la sección D.3.
a) Hacer un programa para averiguar el comportamiento de estas funciones,
tomando las 8 entradas ±3, ±3.1, ±3.5, ±3.7.
b) ¿Quérelaciónhay entre estas funciones y las funciones piso, ⌊x⌋, ytecho,
⌈x⌉?, es decir, ¿cómo pueden escribirse unas en términos de las otras y
viceversa? ✄
En el próximo problema abundamos sobre las asignaciones entre variables
numéricas de distinto tipo:
Problema 3.11 (Asignaciones entre distintos tipos). Supongamos que
hemos declarado
var n: integer; x: real;
En los siguientes, decir cuál es el valor de la última variable asignada o si se
produce un error (sugerencia: hacer un programa, compilarlo y ejecutarlo):
a) x := 3.7; n := x;
b) x := 3.7; n := trunc(x);
c) x := 3.5; n := trunc(x);
d) x := 3.7; n := trunc(-x);
e) x := 3.5; n := trunc(-x);
f ) x := 3.7; n := round(x);
g) x := 3.5; n := round(x);
h) x := 3.7; n := round(-x);
i) x := 3.5; n := round(-x);
j ) n := maxint div 2; n := n * (n+1) / 2;
k) n := maxint div 2; n := n * (n+1) div 2;
l) n := maxint div 2; x := n * (n+1) / 2; ✄
También es posible hacer operaciones mezclando variables numéricas de distintos
tipos:
Problema 3.12. Hacer un programa donde se declara a de tipo entero y b de
tipo real, se lean a y b, y se escriban en pantalla los resultados de: a + b, a ∗ b,
a/b, b/a. ¿Dequétiposon los resultados en cada caso? Sugerencia: modificar
la declaración de variables en el programa sumardos. ✄
De aquí enmás supondremos que el lector compilará
yejecutará cada programa mencionado en los
problemas, probándolo con distintos datos. En lo sucesivo,
generalmente omitiremos esta instrucción.

Pág. 22 Tipos de datos elementales
Problema 3.13. El programa segundos (pág. 175) permite pasar de segundos
a horas, minutos y segundos, usando la función “ mod ”: “ a mod b ”daesencialmente
el resto de la división de a por b.
✎ El número de segundos a ingresar no debe superar maxint.
a) Agregarle instrucciones de modo de poder verificar si el resultado es correcto,
pasando de horas, minutos y segundos a segundos.
b) ¿Quépasa si se coloca el renglón “ writeln(hs, ’ hs, ’,... ”inmediatamente
después del renglón “ writeln(segs, ’ segundos...” yantesde
“ mins := segs div ... ”? ✄
Problema 3.14.
a) Hacer un programa para averiguar el comportamiento de “ mod ”, tomando
como entradas a = ±7 yb = ±3, calculando “ a mod b ”.
b) Comprobar si el valor de “ (a div b) * b + (a mod b) ” coincide con el
de a. ✄
3.3. Variables lógicas
Estamos acostumbrados a valores numéricos, y no es sorpresa que por ejemplo
las variables del tipo “ integer ” o entero, admitan valores como 1 o −987.
Sin embargo, cuesta acostumbrarse a las variables de tipo lógico o “ boolean ”,
que sólo admiten valores verdadero o “ true ”, y falso o “ false ”. Antes de
trabajar con estas variables en programación, practiquemos un poco:
Problema 3.15. En cada caso, decidir si la expresión es verdadera o falsa:
i) 1=2. ii) 1> 2.
iii) 1≤ 2. iv) 4× 5 > 3
4 .
v) 1< 2 < 3. vi) 1< 2 < 0.
vii) 1< 2o2< 0. viii) 1 = cos 1.
ix ) {a, b, c} = {b, a, c}. x ) {0, 1, 2, 3}⊂N. ✄
Habiendo estirado un poco los músculos, tiene sentido preguntarle a la computadora
si un número es positivo o no, y que guarde el resultado en una variable
lógica:
Problema 3.16. Compilar y ejecutar el programa positivo (pág. 175), analizando
qué hacen las distintas instrucciones.
Agregar una variable pos, declarada como lógica (“ boolean ”), incluir en el
cuerpo del programa la asignación “ pos := a > 0 ” e imprimir pos,envezde
“ a > 0”. ✄
Debemos destacar que al comparar números, Pascal usa a veces una sintaxis
ligeramente diferente a la usual:
Matemáticas Pascal
= =
=
> >
≥ >=
< <
≤

3.4. Caracteres Pág. 23
debiendo tener cuidado en no confundir “ := ”, que indica asignación, con “ = ”,
que pregunta si los valores a ambos lados coinciden:
• “ a := a + 1” significa tomar el valor de a, agregarle 1 y guardar el
resultado en a,
• mientras que “ a = a + 1” es una proposición lógica con valor “falso”, y
no se modifica el valor de a.
Así como para números tenemos la suma, el producto o el inverso aditivo,
para variables lógicas tenemos la conjunción y, a veces simbolizada con ∧, la
disyunción o, simbolizada con ∨, y la negación no, simbolizada con ¬. EnPascal
usamos respectivamente “ and ”, “ or ”y“not ”.
Por ejemplo si a y b son de tipo entero, pondríamos
Matemáticas Pascal
(a >0) ∧ (b >0) (a > 0) and (b > 0)
(a >0) ∨ (b >0) (a > 0) or (b > 0)
¬(a >0) not (a > 0)
pero la expresión matemática a

Pág. 24 Tipos de datos elementales
En Pascal, dado un carácter podemos encontrar su número de orden mediante
“ ord ”yrecíprocamente, dado un entero podemos ver qué carácter le
corresponde mediante la función “ chr ” (2) .Elestándar Pascal establece que:
• Los caracteres ‘ 0 ’,‘ 1 ’,. . . ,‘ 9 ’están numéricamente ordenados y son consecutivos,
pero
• las letras minúsculas, ‘ a ’,‘ b ’,...,‘z ’, si bien están ordenadas, ¡no son
necesariamente consecutivas!
• y lo mismo para las letras mayúsculas.
Afortunadamente, el código ASCII —con el que trabajaremos— satisface
estos requisitos, y más aún, las letras minúsculas ‘ a ’,...,‘z ’ son consecutivas y
lo mismo para las mayúsculas.
Desafortunadamente, si bien para nosotros ‘ ~n ’estáentre‘n ’y‘o ’, esto no es
asíenelcódigo ASCII, pues la letra ‘ ~n ’nisiquieraestácodificada.Niquéhablar
de ch o ll, que se consideran (en cada caso) como dos caracteres distintos. Todo
esto puede traer problemas al clasificar u ordenar alfabéticamente.
Problema 3.18 (Ordinales y caracteres). El programa caracteres1 (pág.
175) toma un carácter como entrada, retorna su número de orden y verifica la
corrección.
a) ¿Quépasa si cambiamos el nombre del programa de “ caracteres1” a
“ char ”?, ¿ya “char1 ”?
✎ Recordar lo dicho sobre identificadores al principio del capítulo y en
el problema 3.2.c).
b) ¿Quépasasiseescribecomoentrada“tonto ”?
c) ¿Cuál es el ordinal correspondiente a los caracteres ‘ a ’, ‘ A ’, ‘ ’ (espacio),
y tabulación (tecla “tab”)?
d) Hacer un programa que, inversamente, dado un número retorne el carácter
correspondiente.
e) Averiguar si hay caracteres correspondientes a números mayores que 127 (el
resultado dependerá delamáquina). ¿Y a números mayores que 255?
f ) ¿Cuál es el carácter correspondiente al número 7 (en ASCII)? ✄
3.5. Comentarios Bibliográficos
Los problemas 3.1 y 3.8 están basados en similares de [3].
(2) ¡No confundir “ char ”con“chr ”!

Capítulo 4
Tomando control
Con las operaciones que hemos visto no podemos hacer mucho más que lo
que hace una calculadora sencilla. Las cosas empiezan a ponerse interesantes
cuando disponemos de estructuras de control de flujo, esto es, instrucciones que
nos permiten tomar decisiones sobre si realizar o no determinadas instrucciones
o realizarlas repetidas veces.
Al disponer de estructuras de control, podremos verdaderamente comenzar a
describir algoritmos, es decir, instrucciones (no necesariamente en un lenguaje de
programación) que nos permiten llegar a determinado resultado, y apuntar hacia
el principal objetivo de este curso: pensar en los algoritmos y cómo traducirlos
a un lenguaje de programación.
✎ Se conocen pocos detalles de la vida de Abu Ja’far Muhammad ibn Musa
al-Khwarizmi’. Presuntamente nació alrededor de 780 en Bagdad (Irak)
—cuando Harun al-Rashid, el califa de “Las mil y una noches”, comenzaba
su califato— y murió en 850.
Al-Mamun hijo y sucesor de al-Rashid, continuó la tradición de su
padre de patrocinar las ciencias y fundó laacademia“Casadelsaber”,a
la que se incorporó Al-Khwarizmi.
Al-Khwarizmi escribió y tradujo varios textos científicos (de matemática,
geografía, etc.) del griego al árabe. El más importante de ellos es “Hisab
al-jabr w’al-muqabala”, de donde surge la palabra “álgebra” conque ahora
designamos a esa rama de la matemática.
Al-Khwarizmi también escribió un tratado sobre números indo-arábigos
que se ha perdido, pero se conservó una traducción al latín llamada
“Algoritmi de numero Indorum”, para indicar su autor, que dio lugar a la
palabra “algoritmo” que usamos.
Los programas irán aumentando en longitud, lo que nos obligará a encarar
de forma diferente su confección, debiendo pensar con más cuidado primero en
qué queremos hacer, luego en cómo lo vamos a hacer, y finalmente pasar a los
detalles. Pascal, y casi todos los lenguajes de programación, son poco “naturales”
en este sentido, exigiendo —por ejemplo— la declaración de variables al
principio del programa fuente, mientras que nosotros pensaremos el programa
de “abajo hacia arriba” (o casi), y recién al final miraremos cómo declarar las
variables necesarias.
En Pascal, las estructuras fundamentales de control son “ if ”, “ while ”,
“ repeat ”y“for ”, que pasamos a estudiar.

Pág. 26 Tomando control
✎ En Pascal hay otras estructuras de control, como “ case ”, que no veremos.
En otros lenguajes de programación existen otras estructuras, pero casi
siempre están los equivalentes de “ if ”y“while ”, con las que se pueden
simular las otras.
4.1. “If”
Supongamos que al cocinar decidimos bajar el fuego si el agua hierve, es decir
realizar cierta acción si se cumplen ciertos requisitos. Podríamos esquematizar
esta decisión con la sentencia:
si el agua hierve entonces bajar el fuego.
A veces queremos realizar una acción si se cumplen ciertos requisitos y
además realizar una acción alternativa si no se cumplen. Por ejemplo, si para
ir al trabajo podemos tomar el colectivo o un taxi —que es más rápido pero
más caro que el colectivo— dependiendo del tiempo que tengamos decidiríamos
tomar uno u otro, que podríamos esquematizar como:
si es temprano entonces tomar el colectivo en otro caso tomar el taxi.
En Pascal podemos tomar este tipo de decisiones, usando la construcción
“ if...then...” para el esquema “si ...entonces ...”, mientras que para la
variante “si ...entonces ...en otro caso ...” usamos“if...then...else...”
Por supuesto, entre “ if ”y“then ” tenemos que poner una condición (una
expresión lógica) que pueda evaluarse como verdadera o falsa.
Problema 4.1.
a) Agregar el siguiente renglón al programa leerdato (pág. 173):
if (a > 10) then writeln(chr(7));
inmediatamente después del renglón “ writeln(’El entero...);”.
¿Cuál es el efecto de agregar este renglón?
b) Modificar el programa leerdato de modo que la computadora emita un sonido
cuando el número entrado es mayor que 0 y menor o igual a 10 (y no haga
nada en otro caso). ✄
Problema 4.2. El valor absoluto para x ∈ R se define como
x si x ≥ 0,
|x| =
−x en otro caso.
El programa valorabsoluto (pág. 176) realiza este cálculo. Observar en especial
la estructura “ if...then...else...”. ¿Qué pasa si se eliminan los
paréntesis después del “ if ”?,¿ysisecambia“>= ”por“> ” ?, ¿y si se agrega
“ ; ”antesde“else ”?
La función “ abs ” de Pascal hace el cálculo del valor absoluto. Incorporarla
al programa y verificar que se obtienen los mismos resultados. ✄
Problema 4.3. Hacer un programa que, dado un número real, encuentre su
piso y su techo. Sugerencia: recordar el problema 3.10. ✄

4.1. “If” Pág. 27
A veces es conveniente encadenar varios “ if ”:
Problema 4.4. El programa comparar (pág. 176) toma como datos los números
enteros a y b y determina cuál es mayor o si son iguales.
a) ¿Quépasa si se escriben las líneas que empiezan con “ if ”yterminanen
“ ; ”enunsolorenglón?
b) ¿Quépasasiseincluyen“; ” al final de cada uno de los renglones originales?
c) Modificar el programa para que siempre escriba en la salida el número a
primero (i.e. si a = −5 yb = 3 escriba “ -5 es menor que 3 ”envezde“3
es mayor que -5 ”).
d) Modificarloparaquesólo decida si a = b o a = b.
e) Modificarlo para que sólo decida si a>bo a ≤ b. ✄
Problema 4.5 (Comparación de caracteres). El programa caracteres2 (en
la pág. 176) decide si un carácter entrado por terminal es una letra minúscula
o una mayúscula o no es una letra, mediante comparación.
Modificarlo de modo de hacer un programa para clasificar un carácter ingresado
como uno de los siguientes:
a) una letra minúscula vocal, b) una letra minúscula consonante,
c) una letra mayúscula vocal, d) una letra mayúscula consonante,
e) undígito (0, 1,...,9), f )niletranidígito.
✎ Recordando lo dicho al principio de la sección 3.4, no deben ingresarse
vocales acentuadas o “ ~n ”. ✄
Problema 4.6. El Gobierno ha decidido establecer impuestos a las ganancias
en forma escalonada: los ciudadanos con ingresos hasta $10000 no pagarán
impuestos; aquéllos con ingresos superiores a $10000 pero que no sobrepasen
$30000, deberán pagar 10 % de impuestos; aquéllos cuyos ingresos sobrepasen
$30000 pero no sean superiores a $50000 deberán pagar 20 % de impuestos, y
los que tengan ingresos superiores a $50000 deberán pagar 35 % de impuestos.
a) Hacer un programa para calcular el impuesto dado el monto de la ganancia.
¿Qué tipos de datos habrá que usar?
b) Modificarlo para determinar también la ganancia neta (una vez deducidos
los impuestos) del ciudadano.
c) Modificarlo de modo que los impuestos y ganancia neta se impriman hasta
el centavo (y no más). ✄
Problema 4.7 (Años bisiestos). Desarrollar un programa para decidir si un
año dado es o no bisiesto.
Julio César (alrededor de 100–44 a. de C.) cambió el calendario egipcio, que
estaba basado en un año de exactamente 365 días, a un nuevo calendario, el juliano,
conañosbisiestos cada 4 años aproximando mejor la verdadera longitud
del año. Sin embargo, cálculos posteriores mostraron que la longitud del año
es aproximadamente 365.2422 días. Con el paso de los siglos, las diferencias
anuales de 0.0078 días en promedio se fueron acumulando, y hacia el año 1582
el Papa Gregorio comenzó un nuevo calendario (el gregoriano). Por un lado,
se agregaron 10 días a la fecha, de modo que el 5 de octubre de 1582 pasó aser
el 15 de octubre (y nunca existieron los días entre el 6 y el 14 de octubre de
ese año). Por otro lado, se decidió quelosañosbisiestos serían precisamente

Pág. 28 Tomando control
los divisibles por 4, excepto que aquéllos que fueran divisibles por 100 serían
bisiestos sólo cuando fueran divisibles por 400 (así elaño 1700 no es bisiesto
pero sí el 2000). Con esta convención, el año promedio tiene 365.2425 días. No
todos los países del mundo adoptaron este calendario inmediatamente. En Gran
Bretaña y lo que es ahora Estados Unidos de Norteamérica, se adoptó recién
en 1752, por lo que se debieron agregar 11 días más; Japón cambió en 1873,
Rusia en 1917 y Grecia en 1923. Aún hoy algunas iglesias ortodoxas mantienen
el calendario juliano, especialmente para determinar la fecha de las Pascuas.
✎ A veces con un pequeño esfuerzo podemos hacer el cálculo más eficiente.
Un esquema para resolver el problema anterior, si anio es el año ingresado,
es
write(anio);
if (anio mod 400 = 0) then writeln(’ es bisiesto’)
else if (anio mod 100 = 0) then writeln(’ no es bisiesto’)
else if (anio mod 4 = 0) then writeln(’ es bisiesto’)
else writeln(’ no es bisiesto’)
Sin embargo, el esquema
write(anio);
if (anio mod 4 0) then writeln(’ no es bisiesto’)
else if (anio mod 100 0) then writeln(’ es bisiesto’)
else if (anio mod 400 0) then writeln(’ no es bisiesto’)
else writeln(’ es bisiesto’)
es más eficiente, pues siendo que la mayoría de los números no son múltiplos
de 4, en la mayoría de los casos haremos sólo una pregunta con el segundo
esquema pero tres con el primero.
Nosotros no vamos a preocuparnos por la eficiencia del programa, pero
haremos comentarios (¡como éste!) de tanto en tanto. ✄
Problema 4.8. Desarrollar un programa que, tomando como entrada un número
natural entre 1 y 3000, lo escriba en romano (e.g. entrando 2999 se debe
obtener MMCMXCIX). Sugerencia: primero hacer un programa para tratar el
caso entre 1 y 30, y después ir agregando posibilidades.
✎ Las letras usadas para números romanos son I, V, X, L, C, D, M, correspondientes
respectivamente a 1, 5, 10, 50, 100, 500, 1000.
✎ El problema es ciertamente tedioso para escribir, pero es típico de muchas
aplicaciones, en las que no hay atajos. ✄
A veces es conveniente y aún necesario agrupar instrucciones, lo que en
Pascal se hace mediante “ begin...end”, como en la parte principal de todo
programa.
✎ La expresión “ end. ” (con punto) sólo debe aparecer al final del programa
fuente.
Este “agrupar” es similar al uso de paréntesis en expresiones matemáticas,
“ ( ” correspondiendo a “ begin ”y“) ” correspondiendo a “ end ”.
Como “ begin...end” es similar a los paréntesis, “ begin ”y“end ”noson
sentencias en sí, por lo tanto
Es incorrecto poner un “ ; ” inmediatamente antes
de un “ end ”.

4.1. “If” Pág. 29
Veamos un ejemplo donde podríamos usar “ begin...end”:
Problema 4.9. Sea f : R → R la función definida como
x
f(x) =
2 si x>0,
0 si x ≤ 0.
a) Hacer un esquema del gráfico de la función.
b) Hacer un programa para que, dando x como entrada, se imprima f(x).
c) Supongamos que queremos imprimir además un cartel diciendo si el valor
entrado es positivo (y por lo tanto f(x) =x2 ) o si no lo es (y por lo tanto
f(x) = 0). Una posibilidad es, habiendo declarado a x y y como de tipo
“ real ”, poner dos “ if ”’s consecutivos, por ejemplo:
if (x > 0) then writeln( x, ’ es positivo’)
else writeln( x, ’ no es positivo’);
if (x > 0) then y := x*x else y := 0;
writeln(’El valor de la funcion es ’, y);
Incluir en el programa del inciso anterior estas modificaciones.
d) Otra posibilidad, que puede parecer más coherente, es poner un único “ if ”,
agrupando las instrucciones en cada caso:
if (x > 0) then begin
writeln( x, ’ es positivo’);
y := x*x
end
else begin
writeln( x, ’ no es positivo’);
y := 0
end;
writeln(’El valor de la funcion es ’, y);
Modificar el programa del inciso b) incorporando esta variante. ¿Quépasa
si se elimina el “ end ”antesdel“else ”?,¿ysisepone“; ”entre“end ”
y“else ”? ✄
Otras veces el uso de “ begin...end” evita confusiones:
Problema 4.10. Supongamos que hemos declarado
var a, b, n, z: integer;
y que tenemos el renglón
if (n > 0) then if (a > b) then z := a else z := b;
a) ¿Quétiene de confuso este renglón?
b) Decir cuál es el valor de z inmediatamente después de ejecutar el renglón
original cuando los valores de a, b, n y z son:
i) a =1,b =2,n =1,z =0;
ii) a =1,b =2,n = −1, z =0;
iii) a =2,b =1,n =1,z =0;
iv) a =2,b =1,n = −1, z =0;

Pág. 30 Tomando control
c) Decir si el renglón es equivalente a:
i) if (n > 0) then begin
if (a > b) then z := a else z := b end;
ii) if (n > 0) then begin
if (a > b) then z := a end else z := b; ✄
4.2. “While”
La estructura “ while ” es una estructura para realizar repetidas veces una
misma tarea. Junto con “ repeat ”y“for ” —que veremos más adelante— reciben
el nombre común de lazos o bucles para indicar esta capacidad de repetición.
Supongamos que voy al supermercado con cierto dinero para comprar la
mayor cantidad posible de botellas de cerveza. Podría ir calculando el dinero
que me va quedando a medida que pongo botellas en el carrito: cuando no
alcance para más botellas, iré a la caja. Una forma de poner esquemáticamente
esta acción es
mientras me alcanza el dinero, poner botellas en el carrito.
En Pascal, este esquema se realiza con la construcción “ while...do...”,
donde “ do ” reemplaza a la “ , ” en la sentencia anterior, y entre “ while ”y
“ do ” debe ponerse una expresión lógica.
Observamos desde ya que:
• Si la condición no es cierta al comienzo, nunca se realiza la acción: si el
dinero inicial no me alcanza, no pongo ninguna botella en el carrito.
• En cambio, si la condición es cierta al principio, debe modificarse con
alguna acción posterior, ya que en otro caso llegamos a un lazo “infinito”
que nunca termina.
Por ejemplo, si tomamos un número positivo y le sumamos 1, al resultado
le sumamos 1, y así sucesivamente mientras los resultados sean positivos.
O si tomamos un número positivo y lo dividimos por 2, luego otra vez por
2, etc. mientras el resultado sea positivo.
✎ Al menos en teoría. Como veremos en los problemas 4.15 y 4.17, la
máquina tiene un comportamiento “propio”.
Por cierto, en el ejemplo de las botellas en el supermercado podríamos realizar
directamente el cociente entre el dinero disponible y el precio de cada botella,
en vez de realizar el lazo mientras. Esloquevemosenelpróximo problema:
Problema 4.11. El programa resto (pág. 177) calcula el resto de la división de
a ∈ N por b ∈ N mediante restas sucesivas.
a) Antes de compilar y ejecutar el programa, hacemos una “prueba de escritorio”.
Por ejemplo, si ingresamos a =10yb =3,podríamos poner

4.2. “While” Pág. 31
Paso acción a b r
0 (antes de empezar) sin valor sin valor sin valor
1 leer a 10
2 leer b 3
3 r := a 10
4 r ≥ b: verdadero
5 r := r - b 7
6 r ≥ b: verdadero
7 r := r - b 4
8 r ≥ b: verdadero
9 r := r - b 1
10 r ≥ b: falso
11 imprimir r
donde indicamos los pasos sucesivos que se van realizando y los valores de
las variables a, b y r (el último valor que aparece es el que tiene antes de
ejecutarse el paso correspondiente). Podemos comprobar entonces que los
valores de a y b al terminar el programa son los valores originales, mientras
que r se modifica varias veces.
✎ El lector puede la “prueba de escritorio” como le parezca más clara.
La presentada es sólo una posibilidad.
Las “pruebas de escritorio” sirven para entender el comportamiento
del programa y detectar algunos errores (pero no todos). Son útiles
al comenzar a programar, en programas ni demasiado sencillos, como
los que hemos visto hasta ahora, ni demasiado complicados como
varios de los que veremos en los capítulos siguientes.
Otra forma —bastante más primitiva— de entender el comportamiento
de un programa y eventualmente encontrar errores, es probarlo
con distintas entradas, como hemos hecho desde el comienzo, por ejemplo
en el problema 2.2 yprácticamente en todo el capítulo 3.
Alentamos al lector para que haga las “pruebas de escritorio” de
los restantes problemas de éste y el siguiente capítulos.
b) Hacer una “prueba de escritorio” con otros valores de a y b, por ejemplo
con 0

Pág. 32 Tomando control
valor obtenido en el inciso f )?, ¿podrías explicar por qué?
h) ¿Hay algún ejemplo donde tenga sentido declarar las variables a, b y r como
de tipo real en vez de entero? Sugerencia: pensarenradianesyb =2π. ✄
Problema 4.12. El programa tablaseno (pág. 177) produce una tabla del seno
para ángulos expresados en grados. Tanto el ángulo inicial, el ángulo final como
el incremento, son entrados por el usuario.
a) Observar el uso de “ const ”—porconstante— para dar un valor aproximado
de π, anterior a la declaración de variables. Observar también que no
se hace una asignación a pi, sino que se usa el signo “ = ”. El uso de const
hace que no se puedan hacer asignaciones a pi pues no es una variable (es
una constante): tratar de hacer una asignación a pi yobservarquépasa. b) Antes o después de ejecutar el programa, verificar que se obtienen los mismos
resultados de una “prueba de escritorio” (como en el problema 4.11, ahora
con las variables inicial, final, incremento, grados y radianes).
c) Algunos compiladores Pascal tienen pre-definida la constante pi, peronoes
estándar. Verificar si el compilador usado está en esta categoría comentando
el renglón donde se define pi, i.e. encerrándo el renglón entre “ (* ”y“*) ”.
d) En vez de poner manualmente un valor aproximado de π, escomún usar la
igualdad π =4× arctan 1.
i) Cambiar el valor “ 3.14159265” dadoapi en el programa original,
reemplazándolo por “ 4 * arctan(1)”. En general los compiladores
no aceptan este cambio, pues el estándar Pascal no lo permite.
ii) Eliminar el renglón donde se define a pi como una constante y definir
en cambio pi como una variable de tipo real, y en el cuerpo del programa
hacer la asignación de la igualdad anterior. Comparar con los
resultados obtenidos originalmente.
✎ Podría usarse otro valor similar para π, como2×arccos 0 o 2×arcsen 1,
pero arctan (el arco tangente) es la única función trigonométrica inversa
definida en el estándar Pascal.
e) ¿Qué pasa si el valor de incremento es cero? ¿Y si el valor de incremento
es positivo pero el de final es menor que el de inicial?
f ) Modificar el programa tablaseno para producir en cambio una tabla de logaritmos
en base 10, donde los valores inicial , final e incremento son de tipo
real. Sugerencia: enPascalestá definido ln x =log e x, yparacualquiera, b
y x razonables, log a x =log b x/ log b a. ✄
Otro uso muy común de los lazos (“ while ”, “ repeat ”o“for ”) es el cálculo
de sumas o productos de muchos términos. En forma similar al contador k del
problema 4.11.f ), si el resultado se va a guardar en la variable resultado, ésta se
inicializaa0enelcasodelasumaoa1enelcasodelproductoantes del lazo,
yenéste se van sumando o multiplicando los términos deseados modificando
resultado. Ilustramos esta técnica en el siguiente problema:
Problema 4.13 (Suma de Gauss). Para n ∈ N consideremos la suma
sn =1+2+3+···+ n =
n
i,
i=1

4.2. “While” Pág. 33
que, según la fórmula de Gauss, es
sn =
n × (n +1)
.
2
Según se dice, Karl Friederich Gauss (1777–1855) tenía8años cuando el
maestro de la escuela le dio como tarea sumar los números de 1 a 100 para
mantenerlo ocupado (y que no molestara). Sin embargo, hizo la suma muy
rápidamente al observar que la suma era 50 × 101.
Las contribuciones de Gauss van mucho más allá deestaanécdota, sus
trabajos son tan profundos y en tantas ramas de las matemáticas que le valieron
el apodo de “príncipe de los matemáticos”. Para algunos, fue el más grande
matemático de todos los tiempos.
El programa gauss (pág. 178) calculasnsumando los términos (y no usando
la fórmula de Gauss).
a) ¿Cuál es el valor de n al final del lazo? Sugerencia: hacer una “prueba de
escritorio”.
b) ¿Quépasasiseingresan≤0? c) Lavariablesuma está declarada como de tipo real. Si se declarara como de
tipo entero, ¿cuál sería el máximo n para el cual se podría calcular sn (i.e.
para el cual sn ≤ maxint)?
d) ¿Cuántas asignaciones se realizan (en términos de n) dentro del lazo?
e) Modificar el programa de modo que a la salida exprese también el valor
original de n (algo como “ La suma de 1 a 100 es 5050 ” cuando n =
100).
f )Modificarellazo“while ” para que se sume “al derecho”, i.e. primero los
términos más chicos. ✄
Problema 4.14.
a) Modificar el programa gauss para obtener, dado n ∈ N, sufactorial, denotado
por n! y definido como
n! =1× 2 ×···×n.
Sugerencia: recordar lo dicho antes del problema 4.13 sobre el cálculo de
sumasyproductosdevariostérminos.
b) ¿Hay alguna diferencia entre los resultados multiplicando “al derecho” (de
menor a mayor) y “al revés” (de mayor a menor)?
✎ Es posible que sí cuando n es grande, debido a errores numéricos.
c) Determinar cuántos ceros hay al final de la expresión decimal de 30!, y comparar
con la cantidad de ceros que aparecen en el resultado del programa.
Sugerencia: contar las veces que 2 y 5 son factores de 30!.
✎ 30! tiene 33 cifras decimales. ✄
Problema 4.15. Recordando que la suma y producto de enteros son enteros,
nos preguntamos si el siguiente programa termina o no:
program terminaono(input, output);
var i: integer;
begin

Pág. 34 Tomando control
i := 1;
while (i * i

4.4. “For” Pág. 35
b) ¿Quépasasisecalculaεmaq mediante
eps := 1;
repeat eps := eps/2 until (1 + eps = 1);
eps := 2 * eps;
writeln(’epsmaq es: ’, eps); ?
✎ Es posible que los valores sean distintos, debido a la forma de trabajo
internadelamáquina.
c) Cambiar el lazo “ repeat ”enelcálculo de εmin porunlazo“while ”haciendo
las modificaciones necesarias. ¿Cuál es más natural, “repeat ”o
“ while ”? ✄
Para calcular εmaq y εmin hemos violado justamente la regla de oro:
4.4. “For”
¡Nunca deben compararse números reales por igualdad
sino por diferencias suficientemente pequeñas!
Hay veces que queremos repetir una acción un número fijo de veces. Por
ejemplo, al subir una escalera con 10 escalones haríamos algo como
hacer 10 veces: subir un escalón.
En Pascal no existe una estructura que traduzca esta acción directamente.
✎ Pero sí en Modula, el sucesor de Pascal también desarrollado por N. Wirth.
En cambio, Pascal cuenta con una estructura un poco más flexible que nos
permite imitarla: si contamos los escalones con el “contador” e, quevariaráentre
1 y 10, podríamos poner el esquema
para e desde1a10hacer subir el e-ésimo escalón.
Este esquema se reproduce en Pascal (habiendo declarando e como de tipo
entero) con la estructura
for e := 1 to 10 do subir el e-ésimo escalón
que ciertamente podría cambiarse por un lazo “ while ”:
e := 1;
while (e

Pág. 36 Tomando control
Así, una de las diferencias entre “ while ”(o“repeat ”) y “ for ”esque
no aparece explícitamente una condición lógica. Otra de las diferencias es que,
según el estándar Pascal, el valor de la variable que indica el paso, llamada
variable de control (en el ejemplo e) no está definido al finalizar el lazo “ for ”,
aunque muchos compiladores no respetan esta convención.
En general, usaremos “ for ” cuando sabemos exactamente la cantidad de
veces que hay que pasar por el lazo, por ejemplo para calcular la potencia x n
cuando x ∈ R y n ∈ N, donde debemos multiplicar x por sí mismon veces:
Problema 4.18. El programa potencia (pág. 180) calcula la potencia n-ésima
del real x.
a) Compilarlo y ejecutarlo, verificando su comportamiento.
b) No es posible tomar bases y exponentes muy grandes sin que haya overflow
o underflow, i.e. resultados que no se pueden representar en la máquina por
ser muy grandes o muy pequeños. Probar con distintos valores hasta obtener
este comportamiento, e.g. 10 10 , 100 100 ,(1/10) 10 ,(1/100) 100 ,etc.
c) Modificar el programa de modo de imprimir el valor de i al finalizar el lazo.
✎ Como mencionáramos, según el estándar el valor no está definido, pero
muchos compiladores no respetan esta convención y el valor obtenido
puede depender del compilador: no debe usarse esta variable después
del lazo “ for ” sin antes re-asignarla.
d) Agregar sentencias para considerar también el caso de n negativo. Sugerencia:
a b =1/a −b , usar la función “ abs ” y/o condicional “ if ”.
e) Una variante de “ for...to...do...”, que va incrementando la variable
de control usada de a 1, es usar “ for...downto...do...”, que va disminuyéndola
en 1 en cada paso.
Cambiar el renglón
for i := 1 to n do pot := pot * x;
por el siguiente:
for i := n downto 1 do pot := pot * x;
y verificar que el comportamiento es el mismo. Observar que con “ downto ”
el valor inicial debe ser mayor o igual que el valor final para que se realice
algún paso.
f ) Algunos compiladores admiten la operación “ x ** y”, que no es del estándar
Pascal, para el cálculo de la potencia xy (x ∈ R+, y ∈ R). Verificar si
el compilador usado admite esta sentencia y, en caso afirmativo, comparar
con el resultado anterior cuando y ∈ N.
g) Otra forma de calcular la potencia en general es usar x y = e y×ln x .Incorporar
esta fórmula al programa para comparar con los resultados anteriores.
✎ Es posible que difieran debido a errores numéricos. ✄
Muchos de los problemas que hemos visto usando “ while ”o“repeat ”
pueden hacerse con “ for ” con modificaciones sencillas, observando que para
considerar valores descendientes con “ for ”, se debe usar “ downto ”envezde
“ to ”. Por ejemplo, en el programa gauss (pág. 178) ellazo
while (n > 0) do begin suma := suma + n; n := n-1 end;

4.5. Ingresando muchos datos: “Eoln” Pág. 37
podría reemplazarse por el lazo
for i := n downto 1 do suma := suma + i;
donde la variable i es de tipo entero.
Sin embargo, no siempre se puede o es sencillo usar “ for ”:
Problema 4.19.
a) Modificar los programas tablaseno (pág. 177) ygauss (pág. 178) cambiando
el lazo “ while ” por uno “ for ”.
b) ¿Podría cambiarse el lazo “ while ” por uno “ for ” en el programa resto
(problema 4.11)?, ¿y el lazo “ repeat ” por uno “ for ” en el programa
epsmin (problema 4.17)? ✄
4.5. Ingresando muchos datos: “Eoln”
En esta sección veremos distintas formas de ingresar muchos datos, que es
una operación muy común en las aplicaciones.
Problema 4.20. Hacer un programa que —usando un lazo “ for ”— calcule e
imprima la suma de cierta cantidad de enteros entrados por terminal. El usuario
debe ingresar primero el número de datos y después cada uno de los datos a
sumar. ✄
Problema 4.21. Cuando entramos datos, muchas veces es molesto contar la
cantidad de datos antes de entrarlos: es mucho más cómodo ingresarlos y dar
una señal al programa de que la entrada de datos ha terminado. Una posibilidad
es usar un “dato imposible” como señal, por ejemplo si se ingresa −1 cuando
los datos a sumar son positivos.
Haciendo esta suposición (i.e. el usuario sólo ingresa los datos a sumar que
son positivos, y la señal de fin de datos que es −1), modificar el programa del
problema 4.20 cambiando el lazo “ for ” por uno “ while ”o“repeat ”.
Sugerencia: agregar una variable booleana findatos.
Sugerencia si la anterior no alcanza: usar un esquema como
suma := 0; findatos := false;
repeat
write(’Entrar un dato (fin = -1): ’); readln(x);
if (x = -1) then findatos := true
else suma := suma + x
until (findatos); ✄
Ciertamente el “dato imposible −1” del problema 4.21 no es muy conveniente,
ya que tendremos que modificar el programa si en algún momento queremos
usarlo para sumar datos que pueden ser negativos. Más cómodo sería ingresar
como “dato imposible” alguna señal que no imponga limitaciones sobre los
númerosaentrar(salvoqueseandetipoenterooreal).
Una posibilidad es poner como “dato imposible” un “dato vacío”, es decir,
nada, o más concretamente un sin entrada de datos, usando la función
de Pascal “ eoln ”.
Pero antes de describir esta función, será conveniente que el lector repase un
poco lo dicho —y hecho— al introducir la función “ readln ” en la sección 3.2.1.

Pág. 38 Tomando control
Cuando ingresamos un dato, éste no es leído por el programa hasta que
ingresemos , dándonos la oportunidad de cambiarlo en caso de error
de tipeo.
Si hemos declarado la variable a (de algún tipo), la sentencia “ readln(a)”
hace que el programa lea el primer dato que no sea justamente ylo
guarde en a si el dato es correcto (si es incorrecto, puede pasar cualquier cosa:
ver el problema 3.3.b)).
Si en el programa fuente tenemos la instrucción “ readln ”, sin argumentos,
entonces se lee el renglón ingresado, y si hemos entrado otros datos antes de
, éstos son ignorados (ver el problema 3.3.c)).
Al ingresar nosotros , nosólo estamos indicando que terminamos
de ingresar nuestros datos, sino que se emite una señal especial que llamaremos
fin de línea.
✎ La señal de “fin de línea” depende del sistema operativo, y puede consisir
de uno o más caracteres.
Cuando ponemos “ readln(a) ” lo que hacemos efectivamente es “leer” la
señaldefindelínea además del dato a, yalponer“readln ” (sin argumentos)
loquesehaceesleersólolaseñaldefindelínea que no se guarda en ninguna
variable.
La función de Pascal “ eoln ” (una abreviatura de “end of line” o fin de
línea), sin argumentos, devuelve un valor lógico, i.e. verdadero o falso, según
haya o no un ofindelínea por leer.
Como “ readln ”, “ eoln ” se queda a la espera de ingreso de datos, que
necesariamente deben incluir un . Si se han ingresado datos antes
de , “eoln ”retornafalso ysino,verdadero. Pero a diferencia de
“ readln ”, “ eoln ” no “lee” el fin de línea, y debemos realizar esta “lectura”
con “ readln ” sin argumentos.
✎ Sin embargo, después de evaluarse “ eoln ”, un nuevo “ readln ” con argumentos
hará que se ignoren los ’s que hayamos introducido
aunque no se hayan “leído”, como ya hemos verificado en el problema 3.3.
Problema 4.22. El programa eolnprueba (pág. 180) es una prueba del funcionamiento
de “ eoln ”, en el que se usa la variable a para entender el flujo de las
instrucciones.
a) Compilar y ejecutar el programa, observando que luego de imprimir el valor
de a antes del lazo, queda a la espera del ingreso de datos:
i) Ingresar “”, sin otros caracteres, y observar el valor final
de a. ¿Cuáles de las instrucciones en “ if ” se ejecutaron?, ¿qué valor
ha dado “ eoln ”yporqué?
ii) Si en vez de ingresar sólo “ ”, se ingresa “ ”
(con un espacio antes), ¿cuál será el valor de a queseimprimeal
final? Verificar la respuesta ejecutando el programa con esa entrada.
b) Después del renglón “ writeln(’Ahora el valor... ” agregar los renglones
write(’Entrar un nuevo valor de a: ’);
readln(a);
writeln(’El valor final de a es ’, a);

4.6. Comentarios Bibliográficos Pág. 39
i) Ejecutar el programa e ingresar “ ” y“3” (con
un 3 antes), ¿cuáles son los valores sucesivos de a?, ¿por qué?
ii) Si en la nueva variante ingresamos “ 4” (conun4antes)y
luego “ 5” (con un 5 antes), ¿cuáles son los valores sucesivos
de a?, ¿por qué?
En cada caso ejecutar el programa y verificar la respuesta. ✄
Problema 4.23. El programa sumardatos (pág. 181) calcula la suma de números
reales entrados por terminal, donde para finalizar la entrada de datos se
ingresa sin dato.
✎ Comparar con las sugerencias del problema 4.21.
a) Observar el uso de “ eoln ” para detectar que se ha entrado un
sin dato, y el uso de “ readln ”para“leer”elfindelínea que ha quedado.
¿Qué pasasiseeliminaeste“readln ”?
b) Modificar el programa para que a la salida indique también la cantidad de
datos ingresados.
c) Modificar el programa para que también indique el promedio de los datos
entrados. ✄
Problema 4.24. El lazo “ repeat...until (findatos)” del programa sumardatos:
a) ¿Podría cambiarse por
repeat
write(’Entrar un dato (fin = ): ’);
readln(x); s := s + x
until (eoln) ?
b) ¿Y por
while (not eoln) do begin
write(’Entrar un dato (fin = ): ’);
readln(x); s := s + x
end ?
Explicar en cada caso, eventualmente haciendo un programa para verificar
que las respuestas son correctas. ✄
4.6. Comentarios Bibliográficos
Los comentarios históricos sobre años bisiestos están basados en [13].

Capítulo 5
Aplicaciones
En este capítulo mostramos que se puede hacer bastante matemáticas con
los recursos de programación que hemos visto.
5.1. Cálculo numérico elemental
Ciertamente una de las aplicaciones más importantes de la computadora —y
a la cual debe su nombre— es la obtención de resultados numéricos. A veces es
sencillo obtener los resultados deseados pero a veces —debido a lo complicado
del problema o a los errores numéricos— es sumamente difícil, lo que ha dado
lugar a toda un área de matemáticas llamada “cálculo numérico”.
5.1.1. Mezclando números grandes y pequeños
Sorprendentemente, al trabajar con números de tipo “ real ” pueden pasar
cosas curiosas como:
• al sumar un número grande a uno pequeño (en relación) puede dar nuevamente
el número grande,
• que la diferencia sea 0 aún cuando los números son distintos,
• o que la suma no sea conmutativa.
Por supuesto, ya hemos visto este tipo de comportamiento al calcular εmaq
(problema 4.17), debido fundamentalmente a la densidad variable de números
de tipo “ real ” mencionada en la sección 3.2.3 (pág. 19).
Problema 5.1.
a) Encontrar x de tipo real tal que, para la máquina, ¡x = x +1!.
Sugerencia: buscar una potencia de 2, usando algo como
x := 1; repeat x := 2 * x; y := x + 1 until (x = y)
b) ¿Quérelación hay entre x y1/εmaq? Por ejemplo, ¿es x × εmaq = 1 o
parecido? ✄

5.1. Cálculo numérico elemental Pág. 41
Problema 5.2 (Números armónicos). Para n ∈ N, el n-ésimo número
armónico se definen como
Hn =1+ 1 1 1
+ + ···+
2 3 n =
n 1
i .
i=1
Así, H1 =1,H2 =3/2, H3 =11/6, H4 =25/12, H5 = 137/60.
a) Desarrollar un programa (siguiendo las ideas del problema 4.13 sobre suma
de Gauss), para calcular Hn aproximadamente.
b) En este caso particular, puede demostrarse que es más preciso hacer la
suma “de atrás hacia adelante” que “de adelante hacia atrás”. Comprobar
que para n grande difieren los resultados realizando las sumas en estas dos
formas.
c) En los cursos de análisis o cálculo matemáticosevequeamedidaquen
crece, Hn crece indefinidamente como ln n.
Ver que efectivamente la diferencia Hn − ln n es aproximadamente constante
para valores grandes de n (esta constante es la constante de Euler
γ = 0.5772156649 ...), por ejemplo calculando las diferencias para n =
100, 1000, 10000. ✄
El siguiente problema muestra algunos de los inconvenientes al restar cantidades
grandes y similares.
Problema 5.3 (Problemas numéricos en la ecuación cuadrática). Como
es sabido, la ecuación cuadrática
ax 2 + bx + c =0 (5.1)
donde a, b, c ∈ R son datos con a = 0, tiene soluciones reales si
no es negativo, y están dadas por
x1 = −b + √ d
2a
d = b 2 − 4ac
y x2 = −b − √ d
. (5.2)
2a
a) Hacer un programa que, dados a, b y c, verifiquesia= 0yd ≥ 0, poniendo
un aviso en caso contrario, y en caso afirmativo calcule x1 y x2 usando las
ecuaciones (5.2), y también las cantidades ax2 i + bxi + c, i =1, 2, viendo
cuán cerca están de 0.
b) Cuando d ≈ b2 , i.e. cuando |4ac| ≪b2 , pueden surgir inconvenientes numéricos.
Por ejemplo, calcular las raíces usando el programa del inciso anterior,
cuando a =1,b = 10000 y c = 1, verificando si se satisface la ecuación (5.1)
en cada caso.
✎ Las soluciones con varios dígitos son:
x1 = −0.000100000001000 ... y x2 = −9999.999899999998999 ...
c) Uno de los problemas en el ejemplo del inciso anterior surge de restar números
grandes que son comparables. El siguiente fragmento de programa alivia
un poco la situación:

Pág. 42 Aplicaciones
if (b > 0) then x1 := -(b + sqrt(d))/(2 * a)
else x1 := (sqrt(d) - b)/(2 * a);
x2 := c / (x1 * a);
i) Justificar esta construcción. Sugerencia: recordar que x1 + x2 = −b/a
y x1x2 = c/a.
ii) Hacer un programa con estas modificaciones y comparar con los resultados
en b).
No es importante recordar el “truco”. El ejemplo está aquí para mostrar
cómo el área de cálculo numérico se preocupa en dar soluciones a las
dificultades computacionales. ✄
El siguiente problema muestra dificultades no sólo computacionales sino también
matemáticas al considerar una sucesiónqueseaproximaa1peroquees
elevada a potencias cada vez más grandes.
Problema 5.4. Consideremos la sucesión
an = 1+ 1
n , para n ∈ N.
n
a) Hacer un programa para generar an dado n (¿de qué tiposserán n y an),
y usarlo para varios valores de n. En base a la experiencia, ¿podrías decir
que an es creciente (i.e. si an

5.1. Cálculo numérico elemental Pág. 43
hacer un programa que ingresando x ∈ R+ y n ∈ N, calcule
√x
··· (= x 1/2n
).
n raíces
b) Ejecutar el programa para distintos valores de x (positivo) y n (más o menos
grande dependiendo de x). ¿Qué seobserva? ✄
Como el lector habrá comprobado en el problema anterior, a medida que
aumentamos el número de iteraciones, i.e. el valor de n, nos aproximamos cada
vez más a 1. Por supuesto que si empezamos con x = 1, obtendremos siempre
el mismo 1 como resultado, ya que √ 1=1.
En general, si tenemos una función f, un punto x en el rango de f se dice
punto fijo de f si
f(x) =x,
de modo que 1 es un punto fijo de la función f(x) = √ x.
Problema 5.6. ¿Hay algún otro punto fijo de la raíz cuadrada, además de
x =1? ✄
En lo que resta de la sección trabajaremos con funciones continuas, es decir,
funciones que “pueden dibujarse sin levantar el lápiz del papel”. Ejemplos de
funciones continuas son: cualquier polinomio P (x), |x|, cosx, y √ x (para x>
0) que acabamos de ver. Para nosotros será suficiente esta idea intuitiva: la
definición rigurosa de función continua se da en los cursos de análisis o cálculo
matemático.
✎ Por supuesto, hay funciones continuas que “no se pueden dibujar” como
• 1/x para x>0, pues cerca de x = 0 se nos acaba el papel,
• sen 1/x para x>0, pues cerca de x = 0 oscila demasiado,
•
f(x) =
x sen 1/x
0
si x = 0,
si x =0
pues cerca de x = 0 oscila demasiado,
y hay funciones que no son continuas como
• signo(x) parax∈Ê, pues pega un “salto” en x =0,
• la función de Dirichlet,
f(x) =
una función imposible de visualizar.
1 si x ∈ É,
0 si x ∈ Ê \ É,
Muchas funciones de interés interactúan de manera interesante con sus puntosfijoscomoenelcasodelaraíz
cuadrada: supongamos que x0 es un punto
dado o inicial y definimos
x1 = f(x0),x2 = f(x1),...,xn = f(xn−1),...
y supongamos que tenemos la suerte que xn se aproxima o converge a ℓ amedida
que n crece, i.e.
xn ≈ ℓ cuando n es muy grande.

Pág. 44 Aplicaciones
1
0.5
y
y = x
y =cosx
0.5 1 1.5
Figura 5.1: Gráficos de y =cosx y y = x.
Puede demostrarse entonces que, si f es continua, ℓ es un punto fijo de f.
Por ejemplo, supongamos que queremos encontrar x tal que cos x = x. Mirando
el gráfico de la figura 5.1, vemos que efectivamente hay un punto fijo de
f(x) =cosx, i.e. un punto x ∗ tal que f(x ∗ )=x ∗ . Podemos apreciar en el gráfico
que el punto buscado está entre0.5 y1,yprobamoslatécnica mencionada:
dado x0 ∈ R definimos
xn+1 =cosxn
x
para n =0, 1, 2,...,
ytratamosdeversixn se aproxima a algún punto cuando n crece.
En la figura 5.2, vemos cómo a partir de x0 = 0, nos vamos aproximando al
punto fijo, donde los trazos horizontales van desde puntos en el gráfico de f a
la diagonal y = x y los verticales vuelven al gráfico de f:
1
0.5
y
0.5 1 1.5
Figura 5.2: Aproximándose al punto fijo de cos x.
Problema 5.7 (Punto fijo de f(x) =cosx). Con las notaciones anteriores
para f y xi:
a) Usando un lazo “ for ”, hacer un programa que dados x0 y n calcule xn, y
observar el comportamiento para distintos valores de x0 y n.
b) Modificar el programa para que también imprima cos xn y comprobar que
para n más o menos grande se tiene xn ≈ cos xn.
c) Modificar el programa para hacer 200 iteraciones, mostrando los resultados
intermedios cada 10. Observar que después de cierta cantidad de iteraciones,
los valores de xk no varían.
x

5.1. Cálculo numérico elemental Pág. 45
✎ El valor de x200 es una buena aproximación al único punto fijo de
f(x) =cosx,aún cuando puede ser que x200 = cosx200(= x201) debido
a errores numéricos. El “verdadero” punto fijo es 0.7390851332 ....
d) Modificar el programa de modo que no se hagan más iteraciones si
|xk+1 − xk| 0esunparámetro entrado por el usuario (e.g. ε =0.00001), aún
cuando k sea menor que n.
Sugerencia: hay que cambiar el lazo “ for ” a uno “ while ”o“repeat ”.
Sugerencia si la anterior no alcanza: suponiendo que x0 es el dato inicial
y n el número máximo de iteraciones, usando un lazo “ while ”podríamos
poner:
k := 1; x := x0; y := cos(x);
while ((k < n) and (abs(y - x) >= eps)) do begin
k := k + 1; x := y; y := cos(x)
end
✎ Observar que la condición |xk+1−xk|

Pág. 46 Aplicaciones
sección es una versión actualizada de una técnica usada por los babilónicos hace
miles de años para aproximar a la raíz cuadrada.
Los babilonios tomaron poder de la Mesopotamia (entre los ríos Tigris y
Éufrates) alrededor de 2000 a. de C., desalojando a los sumerios, quienes
habían estado allí desde 3500 a. de C. Fueron los sumerios los que desarrollaron
el sistema sexagesimal (en base 60) que nos llega a la actualidad en la
división de horas en minutos y segundos, y los babilonios continuaron con el
desarrollo del sistema en base 60, llegando a un sistema que en algunos sentidos
era más avanzado que el decimal nuestro.
Pero los babilonios también estudiaron la resolución de ecuaciones cuadráticas
y cúbicas, llegando al equivalente de la ecuación cuadrática (5.1) ymuy
posiblemente al método que presentamos en esta sección para aproximar raíces
cuadradas. El método estaría descripto en la tableta “Yale”, fechada entre 1800
y 1650 a. de C.
Para llegar a este método, los babilonios habrían usado ideas geométricas
para aproximar la media geométrica de los números x y a/x,
Ö a
x ×
x ,
que es el número √ a buscado, por su media aritmética (o promedio),
1
a
x + .
2 x
Mucho más tarde, Isaac Newton (1642–1727) desarrolló unmétodo basado
en el análisis matemático para encontrar raíces de funciones mucho más generales,
que tiene como caso particular al método babilónico. El método de Newton
también es conocido como de Newton-Raphson, pues J. Raphson (1648–1715)
publicó este resultado unos 50 años antes que se publicara el de Newton.
Variantes del método de Newton-Raphson, que se estudia en los cursos
de cálculo numérico, son los que usan las computadoras y calculadoras para
calcular funciones como el seno o el logaritmo.
Problema 5.9 (Método babilónico I). Este método para aproximar la raíz
cuadrada de a ∈ R+, consiste en aplicar sucesivamente las iteraciones
xn = 1
xn−1 +
2
a
para n =1, 2,..., (5.3)
xn−1
a partir de un valor inicial x0 dado (x0 > 0). Es decir xn = fa(xn−1), donde
fa : R+ → R+ está definida como
fa(x) = 1
2
x + a
x
a) Probar que si a>0yx>0, entonces fa(x) > 0, y si fa(x) =x (x es un
punto fijo de fa) entonces x = √ a.
b) En particular, si x0 > 0 y definimos xn como en la ecuación (5.3), entonces
xn > 0paratodon∈N, ysixn = √ a para algún n, entonces xn = xn−1 =
··· = x0 = √ a. Por lo tanto, si suponemos precisión “infinita” el método
nunca da la respuesta exacta salvo que x0 = √ a.
c) Bosquejar un gráfico similar al segundo del problema 5.7, cuando a =2y
x0 =1.
d) ¿Quépasasia =0?¿Ysix0 =0?
.

5.1. Cálculo numérico elemental Pág. 47
e) ¿Quépasasix0 < 0ya>0?
f )¿Quépasasia0).
✎ En el programa original se consideran errores absolutos en vez de relativos.
Estos errores se estudian en cursos de cálculo numérico y estadística,
y también en otras ciencias como física o química.
El procedimiento de normalización o escalado que hicimos en este
inciso es esencial en cálculo numérico: trabajar con papas y manzanas
ynoconátomos y planetas, o, más científicamente, con magnitudes
del mismo orden.
Cuando se comparan papas con manzanas en la computadora, se
tiene en cuenta el valor de εmaq, pero al trabajar cerca del 0 hay que
tener en cuenta a εmin.
f ) Verificar el comportamiento del programa en los casos de los incisos d), e)
y f )delproblema5.9.
✎ En el caso a 1, o en forma oscilatoria, si
f(x) =−x 3 y x0 > 1.
Es decir, un método iterativo puede no converger a una solución.
Por otro lado, como hemos visto también en el problema 5.8, aún

Pág. 48 Aplicaciones
cuando un método iterativo converja a una solución, no siempre obtenemos
el punto fijo que buscamos, salvo que empecemos con un valor
“razonablemente” cercano. ✄
5.2. Números enteros y divisibilidad
No sólo podemos obtener resultados numéricos con la computadora, sino que
podemos inferir resultados teóricos experimentando:
Problema 5.11.
a) Hacer un programa para calcular la suma de los primeros n números impares
positivos (n ∈ N),
tn =1+3+···+(2n − 1) =
n
(2k − 1).
b) Obtener el valor para distintos valores de n, y conjeturar una fórmula similar
a la de Gauss en el problema 4.13.
c) Tratar de demostrar la fórmula. Sugerencia: usarlafórmula de Gauss o, si
se conoce el método, usar inducción. ✄
5.2.1. Ecuaciones diofánticas
k=1
Problema 5.12. Queremos resolver el siguiente problema:
Geri y Guille compraron botellas de vino para la reunión. Ambos
querían quedar bien y Guille gastó $5 por botella, mientras que Geri,
que es más sibarita, gastó $8 por botella. Si entre los dos gastaron
$81, ¿cuántas botellas compró cada uno?
a) Hacer un programa para resolver el problema. Sugerencia: se trata de resolver
la ecuación 5x +8y = 81, con x, y ∈ Z, x, y ≥ 0. Por lo tanto,
0 ≤ x ≤⌊81 5 ⌋. Usando un lazo “ for ”, recorrer los valores de x posibles,
x =0, 1,...,16, buscando y ∈ Z, y ≥ 0.
✎ Hay dos soluciones posibles.
✎ En este caso es más eficiente recorrer los valores de y (desde 0 hasta
⌋ = 10) pues hay menos valores a considerar.
⌊ 81
8
b) Generalizar el programa para resolver ecuaciones de la forma ax + by = c,
donde a, b, c ∈ N son dados por el usuario y x, y son incógnitas enteras no
negativas. El programa debe exhibir todas los pares (x, y) de soluciones o
decir que no hay soluciones posibles.
✎ La estrategia de resolución es recorrer todas las posibilidades, una por
una, y por eso se llama de barrido, pero hay algoritmos más eficientes para
este caso basados en que el máximo común divisor entre a y b, mcd(a, b)
puede escribirse como mcd(a, b) =Aa + Bb para A, B ∈ , y que valores
apropiados de A y B pueden obtenerse mediante el algoritmo de Euclides,
que veremos luego. Los detalles se ven en cursos de matemática discreta o
teoría elemental de números. ✄

5.2. Números enteros y divisibilidad Pág. 49
Diofanto de Alejandría (aproximadamente 200–284 d. de C.) fue el primero
en estudiar sistemáticamente problemas de ecuaciones con soluciones enteras,
siendo autor del influyente libro “Aritmética”. En su honor, las ecuaciones
donde las incógnitas son enteros se llaman diofánticas o diofantinas.
Otras ecuaciones diofánticas bien conocidas son las de la forma x n + y n =
z n , donde las incógnitas son x, y, z ∈ Æ y n ∈ Æ está dado. Cuando n =2,las
soluciones (x, y, z) forman una terna pitagórica, y cuando n>2, tenemos la
célebre ecuación de Fermat-Wiles, que no tiene soluciones.
Justamente Fermat (1601–1665) fue quien escribió en el margen de su copia
de la “Aritmética” de Diofanto (traducida por Bachet) sobre la imposibilidad
de resolución de la ecuación x n + y n = z n en enteros cuando n>2:
Encontré una demostración verdaderamente destacable, pero el margen
del libro es demasiado pequeño para contenerla.
Wiles demostró el teorema en 1994, ¡casi 350 años después!
La técnica del problema anterior puede extenderse para “barrer” más de dos
números:
Problema 5.13. En los partidos de rugby se consiguen tantos mediante tries
(5 tantos cada try), tries convertidos (7 tantos cada uno) y penales convertidos
(3 tantos cada uno).
Hacer un programa que ingresando la cantidad total de puntos que obtuvo
un equipo al final de un partido, determine las formas posibles de obtener ese
resultado.
Por ejemplo, si un equipo obtuvo 21 tantos, las formas posibles son:
Posibilidad Tries Tries convertidos Penales
1 0 0 7
2 0 3 0
3 1 1 3
4 3 0 2 ✄
También la técnica de “barrido” puede usarse para ecuaciones no lineales:
Problema 5.14.
a) Hacer un programa para que dado n ∈ N determine si existen enteros nonegativos
x, y tales que x2 + y2 = n, exhibiendo en caso positivo un par de
valores de x, y posibles, y en caso contrario imprimiendo un cartel adecuado.
b) En base a los resultados anteriores, ¿cuáles son los n ∈ N que se pueden
escribir como suma de dos cuadrados?
✎ Se puede demostrar (lo que se ve en teoría elemental de números) que
todo entero positivo es suma de cuatro cuadrados (algunos eventualmente
nulos), y que un entero positivo es suma de dos cuadrados si y
sólosiesdelaformaab, donde a es una potencia de 4 (eventualmente
4 0 =1)yb tiene resto 1 al dividirlo por 4. ✄
5.2.2. Máximo común divisor y el algoritmo de Euclides
Dados a, b ∈ N, elmáximo común divisor entre a y b, mcd(a, b), se define (1)
como el máximo elemento del conjunto de divisores comunes de a y b:
(1) ¡Como su nombre lo indica!
mcd(a, b) =máx D,

Pág. 50 Aplicaciones
donde
y
D = {d ∈ Z : d | a y d | b}.
✎ D= ∅, pues 1 ∈D.Además, D está acotado superiormente (por mín{a, b}),
por lo que mcd(a, b) está bien definido.
Cuando a, b ∈ Z, definimos
mcd(a, b) =mcd(|a|, |b|)
mcd(0,z)=mcd(z,0) = |z|z para todo z ∈ Z, z = 0.
No tiene mucho sentido mcd(0, 0), pero por comodidad ponemos
mcd(0, 0) = 0.
Cuando mcd(a, b) = 1, es usual decir que los enteros a y b son primos entre
sí o coprimos.
En la escuela elemental a veces se enseña a calcular el máximo común divisor
efectuando primeramente la descomposición en primos (2) . Sin embargo, la
factorización en primos es computacionalmente difícil (3) y en general bastante
menos eficiente que el algoritmo de Euclides, que aún después de 2000 años, es
el más indicado (con pocas variantes) para calcular el máximo común divisor.
Euclides (alrededor de 325–265 a. de C., aunque hay discusión sobre si se
trata de una persona o un grupo) escribió una serie de libros de enorme influencia
en las matemáticas, inclusive en las actuales. En la proposición 1 del libro VII,
se enuncia:
Dados dos números distintos, y restando sucesiva y continuamente
el menor del mayor, si el número que queda nunca mide el anterior a
él hasta que queda una unidad, los números originales serán primos
entre sí.
Yenlaproposición 2,
Dados dos números y no primos entre sí, encontrar su máxima medida
común.
procediendo a construirlo. En lenguaje moderno, nos dice que para encontrar
el máximo común divisor, “la máxima medida común”, entre a y b, debemos
restar el menor del mayor hasta que los dos sean iguales.
✎ Por supuesto que Euclides con “números” se refiere a lo que nosotros llamamos
números naturales. En los tiempos de Euclides se pensaba en números
como longitudes de segmentos, y la multiplicación de números es un área.
Un poco antes de Euclides, con Pitágoras y el descubrimiento de la
irracionalidad de √ 2, surgió elproblemadelaconmensurabilidad de segmentos,
es decir si dados dos segmentos de longitudes a y b existe otro de
longitud c tal que a y b son múltiplos enteros de c, i.e. c =mcd(a, b). Si
a es irracional, como √ 2, y b =1,entoncesnoexistec, y el algoritmo de
Euclides no termina.
(2) La definición de número primo está en la sección 5.2.3.
(3) Ver también las notas después del problema 5.20.

5.2. Números enteros y divisibilidad Pág. 51
Problema 5.15 (Algoritmo de Euclides). El programa euclides (pág. 182)
es una versión de este algoritmo para encontrar mcd(a, b) cuando a, b ∈ Z, cambiando
las restas sucesivas por el cálculo del resto mediante la función “ mod ”.
✎ En el problema 4.11 hemos hecho el proceso inverso: para calcular el resto
hicimos restas sucesivas.
a) Teniendo en cuenta la descripción original del algoritmo, ¿sería correcto
cambiar el lazo principal por
(* lazo principal *)
repeat
if (a > b) then a := a - b else b := b - a
until (a = b); ?
¿Y por
(* lazo principal *)
repeat
if (a > b) then a := a - b
else if (a < b) then b := b - a
until (a = b); ?
Explicar en cada caso.
b) Ver que el programa termina en un número finito de pasos, por ejemplo en
no más de |a| pasos.
✎ Observar que en el método babilónico (sección 5.1.3), hemos debido
poner “criterios de parada”, pero no aquí. Recordar también la nota
inmediatamente antes de este problema.
c) Modificar el programa de modo que a la salida escriba la cantidad de veces
que realizó ellazo“while ”.
d) ¿Quépasasise cambia la instrucción “ while (b 0) do ”por“while
(b > 0) do”?
e) ¿Quépasa si se eliminan los renglones donde se consideran los casos a

Pág. 52 Aplicaciones
✎ Recordando el tema de la conmensurabilidad mencionado al introducir el
algoritmo de Euclides, no siempre el problema tiene solución. Por ejemplo,
si Pablito hace 1 metro cada 2 pasos y el papá √ 2 metros cada 2 pasos. ✄
Problema 5.17. El mínimo común múltiplo de a, b ∈ N, mcm(a, b), se define
en forma análoga al máximo común divisor: es el menor entero del conjunto
{k ∈ N : a | k y b | k}.
a) En la escuela nos enseñan (4) que si a, b ∈ N entonces
mcm(a, b) × mcd(a, b) =a × b.
Escribir un programa para calcular mcm(a, b) paraa, b ∈ N, usando esta
relación.
b) ¿Cómo podría extenderse la definición de mcm(a, b) paraa, b ∈ Z? ¿Cuál
sería el valor de mcm(0,z)? ✄
Problema 5.18.
a) ¿Quérelación hay entre el máximo común divisor o el mínimo común múltiplo
con el problema 5.16 (de Pablito y su papá)? Sugerencia: recordando
que el problema no siempre tiene solución, volver a mirar la descripción
dada por Euclides de su algoritmo pensando en números cualesquiera, restando
el mayor del menor hasta llegar a una “medida común”, y quizás el
inciso h) delproblema4.11 (pág. 32).
b) Hacer un programa para resolver ese problema, donde las entradas son el
número de pasos y la cantidad de metros recorridos tanto para Pablito como
para su papá.
✎ Como para la computadora todos los números son racionales, el problema
siempre tiene solución. ✄
5.2.3. Números primos
Recordemos que un número n ∈ N es primo si n>1ysusúnicos divisores
(positivos) son 1 y él mismo. Los primeros primos son 2, 3, 5, 7 y 11.
✎ Algunos autores consideran que −2, −3, etc. también son primos, pero
nosotros los consideraremos siempre mayores que 1.
También en sus libros Euclides demuestra muchos teoremas importantes sobre
números primos: en el Libro VII, Proposiciones 31 y 32, que todo número
se puede escribir como producto de primos, y en el Libro IX, Proposición 20
—con una de las demostraciones más hermosas de las matemáticas— que hay
infinitos primos.
Problema 5.19.
a) Probar que si el entero a>1 no es primo, entonces existen enteros b y c,
ambos mayores que 1, tales que b ≤ √ a y a = b × c. Sugerencia: sia = b × c
y1

5.3. Problemas Adicionales Pág. 53
Problema 5.20. El programa factoresprimos (pág. 183) es una elaboración del
programa en el problema 5.19, e imprime todos los factores primos del número
a>1 entrado por terminal.
a) Ver que efectivamente el programa determina todos los factores primos cuando
a>1.
b) Sin embargo, cuando a =1o0elprogramaretornaa, que no es primo.
c) ¿Quépasa cuando a0 entonces:
a) fa(x) − √ a = (x − √ a) 2
.
2x
b) fa(x) 2 − a = (x2 − a) 2
4x2 .
c) Six> √ a,0< (x − √ a)/x < 1, y |fa(x) − √ a| < 1
2 |x − √ a|, i.e. acortamos
más de la mitad la distancia a √ a.
d) x1 ≥ x2 ≥···≥xn ≥···≥ √ a.

Pág. 54 Aplicaciones
✎ Enloscursosdeanálisis o cálculo matemático se ve que por lo tanto,
para n ≥ 1losvaloresdexn decrecen monótonamente hacia un número
b, ycomofa es “continua”, resultará fa(b) =b = √ a.
e) Si x0 = √ a,paran≥1valen las desigualdades
|xn+1 − √
1
a| < mín
2 |xn − √ a|, |xn − √ a| 2
2 √
a
y
4a
.
✎ Decimos que la convergencia del método es global y cuadrática puesto
que se verifica una desigualdad como la primera. ✄
|x 2 n+1 − a| < (x2 n − a) 2
Problema 5.23 (Conjetura de Goldbach). La conjetura de Goldbach, originada
en la correspondencia entre Christian Goldbach y Euler en 1742, dice que
todo número par mayor que 4 puede escribirse como la suma de dos números
primos impares (no necesariamente distintos).
✎ Aún no se ha podido demostrar que la conjetura sea verdadera o falsa.
a) Hacer un programa que dado el número n par, n ≥ 6, lo descomponga en
suma de dos primos impares, exhibiéndolos (verificando la conjetura) o en
su defecto diga que no se puede descomponer así.
b) Relacionado con la conjetura, en 1937 Vinogradov demostró que todo número
impar suficientemente grande puede escribirse como suma de tres primos
impares. Hacer un programa (que podría usar el anterior) para verificar que
todo número n impar, n ≥ 9, puede escribirse como suma de tres primos
impares. ✄
5.4. Comentarios Bibliográficos
Las citas de los libros de Euclides están tomadas de [9].

Capítulo 6
Arreglos
A veces queremos tener muchas variables del mismo tipo, por ejemplo una
lista de los 10 primeros números primos. Escribir un nombre para cada una de
las variables ya sería engorroso, pero ¿qué pasa si ahora el problema requiere
una lista de 100 o 1000 en vez de 10 datos? Para estos casos es conveniente
usar una estructura similar a la de vector, que podríamos pensar como v =
(v1,v2,...,vn), para guardar los datos. En programación, esta estructura se
llama arreglo (unidimensional).
Por ejemplo, los 10 primeros números primos son
2, 3, 5, 7, 9, 11, 13, 17, 19, 23,
que podríamos guardar en el vector o arreglo v =(v1,v2,...,v10) donde
v1 =2, v2 =3, v3 =5, v4 =7, v5 =11,
v6 =13, v7 =17, v8 =19, v9 =23, v10 =29.
6.1. Dimensionamiento de arreglos
En presencia de un arreglo, la máquina guarda lugares consecutivos de memoria,
todos del mismo tipo, a los cuales se accede mediante índices (como
un vector) poniendo “ v[i] ”envezdevi en el programa fuente. Puesto que
ocupan un lugar de memoria, y este lugar depende del tipo de sus elementos
ydelacantidadodimensión, debemos hacer una declaración apropiada en el
encabezamiento del programa.
Así, en el caso querer guardar en el arreglo v =(v1,v2,...,v10) los primeros
10 primos (que son enteros), haríamos la declaración
v: array[1..10] of integer;
La parte “ 1..10 ” indica el rango donde se moverán los índices. A diferencia
de los vectores de matemáticaofísica, cuyos índices siempre empiezan con 1,
podemos hacer que los índices tengan cualquier rango, e inclusive que sean negativos,
poniendo por ejemplo “ -30..20 ”, aunque nosotros casi siempre usaremos
arreglos con índices que empiezan en 1 o 0.
Sin embargo,

Pág. 56 Arreglos
Los índices de los arreglos deben ser de tipo entero
(“ integer ”), por lo que los rangos posibles dependen
de maxint.
Para guardar los 10 primeros primos en v, habiéndolo declarado como antes,
haríamos las asignaciones:
v[1] := 2; v[2] := 3; v[3] := 5; v[4] := 7;
v[5] := 11; v[6] := 13; v[7] := 17; v[8] := 19;
v[9] := 23; v[10] := 29;
En la figura 6.1 esquematizamos cómo el arreglo v se guarda en la memoria
de la máquina: las componentes tienen identificadores v[1], v[2], etc., y ocupan
lugares consecutivos del mismo tipo.
v
2
v[1]
3
v[2]
5 7 11 13 17 19 23 29
v[3] v[4] v[5] v[6] v[7] v[8] v[9] v[10]
Figura 6.1: Esquema del arreglo v guardado en memoria.
Problema 6.1. Supongamos que en una serie de números queremos encontrar
cuántos terminan en 0, cuántos en 1, etc.
a) Hacer un programa para realizar esta tarea, sin usar arreglos, donde la
lectura y fin de datos se haga en forma similar al programa sumardatos
(pág. 181). Al terminar de ingresar los datos, el programa debe imprimir la
cantidad de datos que terminaron en 0, 1,...,9.
b) En el programa unidades (pág. 184) se hace el mismo programa, pero usando
arreglos.
• En vez de declarar un contador para cada dígito 0, 1,...,9, declaramos
el arreglo terminaen que nos provee de los 10 contadores necesarios.
Así, la dimensión del arreglo terminaen es 10, y sus índices varían
entre 0 y 9.
• Elusodelarreglonosólo facilita la declaración, sino que después
es mucho más sencillo incrementar el contador pues no tenemos que
hacer una serie de “ if ”’s para determinar el contador adecuado.
• Al comenzar el programa los valores del arreglo no están definidos, y
hay que inicializarlos.
• El ingreso de datos es similar al del programa sumardatos, conunlazo
“ while ”envezde“repeat ” (recordar el problema 4.24).
¿Por qué no se pone directamente “ digito := dato mod 10 ”envez
de “ digito := abs(dato) mod 10 ”paradeterminarelúltimo dígito?
c) El arreglo terminaen está declarado de modo que sus índices puedan variar
entre 0 y 9. Agregar el renglón
writeln(’indice 10: ’, terminaen[10]);

6.2. Búsqueda Lineal Pág. 57
antes del renglón “ writeln; writeln(’** Fin **’) ” y ver que los valores
que se obtienen no tienen sentido (si es que el compilador no se queja). ✄
Muchas veces necesitaremos un arreglo con, digamos, n elementos, pero no
conocemos n de antemano, y es muy fácil cometer errores en la programación
porque podríamos tratar de usar una componente que no existe. Por ejemplo si
declaramos “ a: array[1..10] of integer ”, sería un error poner “ a[0] :=
1 ”o“a[20] := 0 ”, como observamos al final del problema 6.1.
✎ Algunos compiladores pueden agregar instrucciones de modo de comprobar
que cuando se corra el programa se verifique que los índices están dentro
del rango permitido. Por supuesto, esto hace que la ejecución del programa
sea más lenta.
En estos casos tratamos de hacer la declaración para guardar d elementos,
con d prudentemente más grande que el rango con el que pensamos trabajar.
Claro que si hemos declarado el arreglo con d = 100 elementos y usamos sólo
n = 20 lugares, estamos desperdiciando lugar.
Como el cambio de dimensión es frecuente, y sobre todo cuando hay muchos
arreglos con la misma dimensión, es usual declarar una constante, mediante
“ const ”, para indicar las dimensiones y mantenerlas en un lugar destacado del
programa. Así, es conveniente hacer las declaraciones
.
const MAXN = 20;
.
var ..
a: array[1..MAXN] of integer;
.
.
Si queremos usar un arreglo mayor, bastará cambiar el valor de MAXN .
Veamos estas ideas en un ejemplo concreto.
6.2. Búsqueda Lineal
Problema 6.2 (Búsqueda lineal). Una de las primeras aplicaciones de arreglos
es ver si cierto elemento aparece o no en el arreglo, a veces llamado problema
de búsqueda. Más concretamente, dados un arreglo a =(a1,a2,...,an) y
un objeto x (del mismo tipo que los elementos de a), queremos ver si existe i,
1 ≤ i ≤ n, talquex = ai.
La forma más sencilla de hacer la búsqueda es comparar sucesivamente o
linealmente los elementos a1,a2,...,an del arreglo con x, técnica que se llama
de búsqueda lineal.
✎ Como veremos más adelante, podríamos pensar en otros tipos de estrategias
para la búsqueda, como al azar olabinaria.
El programa busquedalineal (pág. 184) muestraestatécnica, donde se ingresa
un arreglo de ndatos enteros y el número x a buscar. Observar que:
• Se leen datos como en el programa sumardatos (pág. 181), donde el fin de
la entrada de datos se señala con sin datos. Como el número

Pág. 58 Arreglos
de dato a ingresar es uno más que el número de datos ya ingresado, se
mantiene ndatos “adelantado” en 1, y al terminar se lo retrocede.
• El programa decide con un lazo “ repeat ”sixesonounelementodelarre glo recorriendo el arreglo linealmente, es decir comparando sucesivamente
a1,a2,...,andatos con x, terminando cuando se encuentra coincidencia o
cuando se han analizado todos los elementos.
a) Sin embargo, al ingresar datos no se verifica si el número de datos leído es
ya MAXN . Modificar el lazo de modo de que esa constante sea tenida en
cuenta (impidiendo que se entren más de MAXN datos).
b) Manteniendo la modificación anterior, cambiar el programa para que en vez
de ingresar un arreglo de longitud máxima 20, se pueda ingresar un arreglo
de longitud máxima 50. Sugerencia: sólo habrá quecambiarunnúmero.
c) Observar que en la impresión del arreglo inicial se usa la función “ mod ”
para imprimir un máximo de 5 datos por renglón.
i) ¿Por quéseponeelrenglón
if ((ndatos mod 5) 0) then writeln; ?
ii) El 5 que indica la cantidad de datos por renglón se usa en dos lugares,
de modo que si se cambia el 5 por otro número, hay que acordarse de
cambiar ambos.
Definir la constante maxrenglon al principio del programa para
eliminar este problema.
iii) Ahora modificar el programa de modo de imprimir 8 datos por renglón
como máximo, cambiando el programa en un único lugar.
d) Para buscar x en el arreglo, se usa un lazo “ repeat ”. Cambiarlo por uno
“ while ” (¡y que el programa siga funcionando correctamente!). Sugerencia:
mirar el programa unidades (pág. 184).
e) Cambiar el lazo principal de modo que, de estar x en el arreglo, se obtenga
el último índice i tal que ai = x, envezdelprimero como hace el programa.
Sugerencia: empezar recorriendo desde atrás.
f ) ¿Podría cambiarse la última parte del programa original por
(* lazo principal *)
i := ndatos;
while ((a[i] x) and (i > 1)) do i := i - 1;
(* resultados *)
if (x a[i]) then writeln(’no se encontro’)
else writeln(’se encontro en el lugar ’, i:1) ?
En caso negativo, decir por qué no, y en caso afirmativo, qué ventajasy
desventajas tendría. Sugerencia: ¿cuál es el último valor de i si x no está en
el arreglo?
g) Modificar el lazo principal de modo que al terminar el programa diga cuántas
veces aparece x en el arreglo, y los índices correspondientes (i.e. los i para
los cuales ai = x).
✎ Observar que el lazo principal cambia sustancialmente.
Sugerencia: una posibilidad es ir imprimiendo i a medida que aparece. Otra
posibilidad es agregar un arreglo para guardar los índices i, por ejemplo:

6.3. Cribas Pág. 59
(* lazo principal *)
veces := 0;
for i := 1 to ndatos do
if (a[i] = x) then begin
veces := veces + 1;
indice[veces] := i
end;
y luego imprimir el arreglo indice (entre 1 y veces si veces > 0). Observar
que en esta variante no es necesaria la variable seencontro. ✄
Problema 6.3. Hacer un programa que dados los arreglos a =(a1,a2,...,am)
y b =(b1,b2,...,bn) (ambos dimensionados por MAXN ), forme un tercer arreglo
c =(c1,c2,...,cm+n) (dimensionado por 2 × MAXN ), consistente en los
elementos de a seguidos por los de b.
Por ejemplo, si
tendremos m =4,n =5,y
a =(1, 3, 5, 3) y b =(7, 1, 5, 8, 3),
c =(1, 3, 5, 3, 7, 1, 5, 8, 3).
Hacer el ingreso de datos (para a y b) repitiendo el esquema del programa
busquedalineal (pág. 184). ✄
Problema 6.4. Hacer un programa que dado el arreglo a lo “purgue”, i.e. elimine
los elementos repetidos. Por ejemplo, si inicialmente a =(3, 5, 2, 6, 2, 1, 3, 2),
al final del programa debe ser a =(3, 5, 2, 6, 1). Sugerencia: “buscar” cada elemento
entre los ya puestos para decidir si agregarlo o no. ✄
6.3. Cribas
Cuando debemos seleccionar en un arreglo todos los elementos que satisfacen
cierto criterio, y el criterio para cada elemento depende de los elementos que le
precedieron, es conveniente usar una criba (o cedazo o tamiz). Quizás la más
conocida de las cribas sea la atribuida a Eratóstenes para encontrar los números
primos entre 1 y n (n ∈ N), donde el criterio para decidir si un número k es
primo o no es la divisibilidad por los números que le precedieron.
Eratóstenes (contemporáneo de Arquímedes y posterior a Euclides) nació en
Cirene (en Libia de hoy) alrededor del 276 a. de C.. Vivió gran parte de su
vida en Alejandría (Egipto), donde murió alrededor de 194 a. de C., después de
haber sido bibliotecario de la famosa biblioteca. Hizo importantes contribuciones
en matemáticas, astronomía, geografía y filosofía. Por ejemplo, fue el primero
en medir correctamente la circunferencia de la Tierra (y pensar que Colón
usaba un huevo, ¡1700 años después!).
Problema 6.5 (Criba de Eratóstenes). Supongamos que queremos encontrar
todos los primos menores o iguales que un dado n ∈ N. Una posibilidad es
verificar si cada uno de los números 2, 3, 4,... es primo, usando la técnica del
problema 5.19. Sin embargo, una forma mucho más eficiente es hacer la criba
de Eratóstenes.
La idea es empezar con la lista

Pág. 60 Arreglos
2 3 4 ... n.
Recuadramos 2, y tachamos los restantes múltiplos de 2 de la lista, quedando
2 3 4 5 6 ...
Ahora miramos al primer número que no está marcado (no tiene recuadro
ni está tachado): 3. Lo recuadramos, y tachamos de la lista todos los múltiplos
de 3 que quedan sin marcar. La lista ahora es
2 3 4 5 6 7 8 9 10 11 12 ...
y seguimos de esta forma, recuadrando y tachando múltiplos hasta agotar la
lista.
a) Ver que el algoritmo es correcto, i.e. los números recuadrados que quedan
finalmente son todos los primos que no superan n.
b) Ver que el programa eratostenes (pág. 186) es una implementación de esta
idea, donde indicamos que un número está tachado o no con el arreglo
esprimo que tiene valores booleanos. Observar también que el arreglo
está dimensionado como “ 2..MAXP ”, es decir, no existe “ esprimo[1]”.
c) ¿Quépasasien el lazo principal se elimina la variable i reemplazándola
directamente por p, poniendo “ for p := 2 to MAXP do ”, etc.?
d) Observamos que podemos mejorar el programa de dos formas:
i) Podemos empezar directamente diciendo que 2 es primo y considerar
sólo la lista de impares para recuadrar y tachar, reduciendo el tamaño
de la lista inicial esencialmente a la mitad.
ii) En el algoritmo original tachamos demasiadas veces un mismo número.
Por ejemplo 105 = 3 × 5 × 7 se tacha al considerar 3, 5 y 7. Vemos
que sólo es necesario tachar los múltiplos de, digamos, 7 a partir de
49 = 7 × 7. Claro que tenemos que tener cuidado de no multiplicar
un entero por sí mismo si el producto supera maxint (recordando los
problemas 3.11 y 4.15).
Introducir estas modificaciones en el programa eratostenes, cambiando o
agregando las siguientes sentencias en lugares apropiados:
• const MAXN = 4999; (* = (MAXP-1) div 2,
= tama~no del arreglo esprimo *)
• maxp, raizdemaxint: integer;
• esprimo: array[1..MAXN] of boolean;
• maxp := 2 * MAXN + 1;
• (* inicializacion *)
for i := 1 to MAXN do esprimo[i] := true;
cuenta := 1; (* el primer primo es 2 *)
raizdemaxint := trunc(sqrt(maxint));
• (* lazo principal *)
for i := 1 to MAXN do
if (esprimo[i]) then begin
(* p = 2i + 1 es primo *)
cuenta := cuenta + 1; p := 2*i + 1;

6.3. Cribas Pág. 61
(* ahora eliminar multiplos impares de p *)
if (p

Pág. 62 Arreglos
1
3
4
5
Figura 6.2: Esquema del problema de Flavio Josefo con n =5ym =3.
4
2
5
3
b) ¿Cuál es el sobreviviente si n = 1234 y m =3?Sugerencia: no imprimir
todos los valores, y tener cuidado con el dimensionamiento.
c) Modificar el programa de modo que responda cuántas vueltas sobrevivió la
persona que estaba inicialmente en el lugar s (el usuario entrará n, m y s).
d) Modificar el programa de modo de imprimir una tabla, dando la posición
inicial y el orden de ejecución, algo como
Posición en el círculo Orden de ejecución
1 2
2 4
3 1
4 5
5 3
cuando n =5ym =3.
Sugerencia: eliminar el arreglo flavio y usar otro, digamos orden, demodo
que “ orden[i]” indicará enquévuelta fue eliminado i. Siseinicializa
“ orden[i] := n ”paratodoi, y consideramos que en cada vuelta
“ orden[i] = n ” indica que vive, tampoco es necesario el arreglo vive ni el
lazo para encontrar el sobreviviente: será elúnico con “ orden[i] = n ”al
terminar.
e) ¿Cómo podría modificarse el programa, de modo que siempre se trabaje
con un arreglo (o sub-arreglo) de longitud (por ejemplo) vivos, demodode
no tener que considerar los que ya no viven? Sugerencia: ir “corriendo” las
posiciones en el arreglo a medida que “se cierra” el círculo.
✎ En el problema 14.5 veremos que las listas encadenadas se adaptan
mejor que los arreglos para esta variante.
f ) El lazo “repeat...until (cuenta = m) ” en el programa original es muy
primitivo. Por ejemplo, si n = 1000, m = 100, cuando quedan 10 sobrevivientes
debemos pasar unas 10 veces por cada uno de los 1000 elementos.
¿Podría mejorarse el lazo usando “ mod ”? Sugerencia: recordar el programa
resto (pág. 177). ✄
6.4. Polinomios
¿Para qué estudiar polinomios? ¿No basta con estudiar las funciones lineales
(y = ax + b) yalosumolascuadráticas (y = ax 2 + bx + c)?
¡Humm! Por un lado, los polinomios son las funciones más sencillas que podemos
considerar, para su cálculo sólo se necesitan sumas y productos. Además
1
2

6.4. Polinomios Pág. 63
los usamos diariamente, por ejemplo un númeroenbase10esenrealidadun
polinomio evaluado en 10.
Pero también los polinomios sirven para aproximar tantocomosedeseea
casi cualquier función, lo que constituye un tema central de las matemáticas, y
se estudia tanto en los cursos teóricos de análisis matemático como en los aplicados
de análisis numérico. A modo de ejemplo visual, en la figura 15.1 mostramos
cómo se podría aproximar a la función seno mediante los denominados polinomios
interpoladores de Lagrange.
Nuestra primer tarea será evaluar un polinomio dado:
Problema 6.8 (Evaluación de Polinomios). Hacer un programa que dada
una lista de coeficientes (reales) de un polinomio, (a0,a1,a2,...,an) yunnúmero
x ∈ R, entrados por terminal, evalúe el polinomio anx n + an−1 x n−1 +
···+ a1x + a0.
Hacerlo de tres formas:
a) Calculando la suma de términos como se indica, calculando x k como en el
problema 4.18.
b) Como el anterior, pero las potencias en la forma x k+1 = x k × x, guardando
x k en cada paso.
c) Usando la regla de Horner
((···((an x + an−1) x + an−2) +···) x + a1) x + a0.
✎ En las dos primeras versiones se hacen n sumas, n productos y se calculan
n − 1 potencias, que en la primera versión representan otros 1 + 2 + ···+
(n − 1) = n(n − 1)/2 productos, mientras que en la segunda, los productos
provenientes de las potencias se reducen a n − 1. Finalmente, en la regla
de Horner, tenemos sólo n sumas y n productos.
William George Horner (1786–1837) fue indudablemente una persona muy
capaz: a los 18 años era director de la escuela Kingswood (en Bristol, Inglaterra).
Sin embargo, sus contribuciones matemáticas no han sido demasiadas, y
conservamos el nombre de “regla de Horner” pues De Morgan la denominó asíy
le dio amplia difusión en los muchos artículos que escribió. Sin embargo, el
método era conocido por Zhu Shijie unos 500 años antes. ✄
Problema 6.9 (Escritura en base entera). La idea de la regla de Horner
se usa también en el caso de escritura en base b (entero > 1). Si n ∈ Z es
no-negativo y
n =
k
aib i , donde ai ∈ Z y0≤ ai

Pág. 64 Arreglos
y para encontrar n dados los coeficientes en base b (si ak es el último coeficiente
no nulo)
j := k; n := a[j];
while (j > 0) do begin j := j-1; n := n * b + a[j] end
a) Implementar dos programas para que dados la base b y n, encontrar los coeficientes
ai, yrecíprocamente, dados la base b y los coeficientes ai, calcular
n usando la regla de Horner.
b) En la ecuación (6.1), ¿cómo se relacionan k ylogbn (si ak = 0)? ✄
Problema 6.10. De la escuela recordamos que todo número racional p/q ∈ Q
tiene una “expresión decimal periódica”. Por ejemplo, 1/7 =0.14285701428 ...
tiene período 142857, 617/4950 = 0.124646 ... tiene período 46, 1/4 =0.25 =
0.2500 ... tiene período 0.
✎ Inclusive es posible que recordemos que hay una regla para reconstruir la
fracción dados el de período y el anteperíodo.
Hacer un programa que dados p, q ∈ N, calcule el período (en base 10) de la
fracción p/q.
Sugerencia: poniendo r0 = resto de dividir p por q, los sucesivos dígitos di de
la parte decimal se obtienen de la ecuación
10rn−1 = dnq + rn,
para n =1, 2,..., y hay que buscar (por ejemplo linealmente) si un resto se
vuelve a repetir.
Sugerencia si la anterior no alcanza: Luego de ingresar p y q, poner
n := 0; r[0] := p mod q;
repeat
c := 10 * r[n];
n := n + 1;
d[n] := c div q;
r[n] := c mod q;
(* ahora ver si r[n] ya estaba en r *)
i := 0;
while (r[i] r[n]) do i := i + 1
until (i < n);
El período está formado por los dígitos di+1,...,dn.
✎ A fin de evitar problemas de dimensionamiento al usar arreglos, considerar
q ≤ 1000: para fracciones de la forma p/q con q ≤ 1000 la longitud del
período y anteperíodo es a lo sumo de 982 (cuando q = 983). ✄
6.5. Problemas Adicionales
Problema 6.11. Modificar la criba de Eratóstenes para determinar cuántos de
los 1000 primeros primos terminan respectivamente en 1, 3, 7 y 9.
✎ Observar que, al menos en el rango considerado, la distribución entre los
queterminanen1,3,7o9esmuypareja.

6.6. Comentarios Bibliográficos Pág. 65
El matemático Johann Peter Gustav Lejeune Dirichlet (1805–1859) nació
enDüren que en aquel entonces pertenecía al imperio francés pero hoy
está enAlemania,ydeallíqueavecessedicequeesfrancés y otras veces
que es alemán. El primer trabajo que publicó fue sobre el teorema de Fermat-
Wiles, resolviendo el caso n =5, pero también trabajó en temas de análisis
(anticipando las “series de Fourier”).
Dirichlet demostró en 1837 que toda progresión aritmética a + bk, k =
1, 2,..., contiene infinitos primos si mcd(a, b) =1(el resultado fue conjeturado
por Gauss e implica el resultado de Euclides sobre que hay infinitos primos).
En el presente problema, si pensamos que b =10,ya es cualquier número
que no tenga como factores a 2 ni a 5, este teorema de Dirichlet dice que hay
infinitos primos que terminan en 1, infinitos que terminan en 3, etc. ✄
Problema 6.12 (Potencias binarias). Otra variante de la idea de la regla de
Horner (problema 6.8) eselcálculo de una potencia “pura”. Si x ∈ R y n ∈ N,
podemos calcular xn escribiendo n en base 2:
y hacer
n =
k
ai2 i ,
i=0
x n = x a0+2a1+22a2+···+2 k−1 ak−1+2 k ak =
= x a0 · (x 2 ) a1 · (x 4 ) a2 ···(x 2k−1
) ak−1 2
· (x k
) ak .
a) Implementar un programa para el cálculo de potencias “puras” con estas
ideas.
✎ Si los coeficientes se conocen, un esquema es
if (a[0] = 1) then producto := x else producto := 1;
potencia := x;
for j := 1 to k do begin
potencia := potencia * potencia; (* = x**{2**j} *)
if (a[j] = 1) then producto := producto * potencia
end
mientras que si los coeficientes no se conocen (encontrando aj en cada
paso):
m := n; potencia := x;
if (m mod 2 = 1) then producto := x else producto := 1;
while (m > 0) do begin
m := m div 2; potencia := potencia * potencia;
if (m mod 2 = 1) then producto := producto * potencia
end
b) Comparando con el problema 4.18, donde se usaba un lazo “ for ”: ¿cuántos
operaciones aritméticas (productos y divisiones) se realizan en cada caso?
(Recordar el problema 6.9.b)).
✎ Debido a su alta eficiencia, la misma técnica se usa para encriptar mensajes
usando números primos de varias decenas de cifras. ✄
6.6. Comentarios Bibliográficos
Los problemas 6.6 y 6.7 están tomados de [4].

Capítulo 7
Funciones y Procedimientos
Nuestros programas se han hecho cada vez más largos, y a medida que avancemos
lo serán aún más. La longitud y complejidad de los programas profesionales
es tal que una sola persona no puede siquiera escribirlos completamente.
A fin de abordar esta dificultad, se han desarrollado una serie de técnicas, y
en este capítulo daremos los primeros pasos hacia una de ellas, la modularización,
para lo cual Pascal cuenta con dos mecanismos: funciones y procedimientos.
Aunque la ventaja de usar funciones o procedimientos irá quedando más
clara con los ejemplos que veremos en éste y otros capítulos, podemos decir que
en general son convenientes para:
• Poner en un único lugar cálculos idénticos que se realizan en distintas
partes del programa,
• o poner por separado alguna acción permitiendo su fácil reemplazo (y con
menor posibilidad de error),
• y no menos importante, haciendo el programa más fácil de entender, dejando
una visión más global y no tan detallada en cada parte (viendo el
bosque y no el árbol).
El lector seguramente recordará el uso que con el mismo espíritu hemos dado
a“const ”, por ejemplo en el problema 6.2, para hacer un único cambio que
afecta a varias partes del programa.
7.1. Funciones
Como hemos visto, Pascal cuenta con una serie de funciones pre-definidas,
como “cos” o “ln”, de una variable, o la suma, “+”, que se aplica a dos o más
variables. Pero —necesariamente— no puede tener todas las funciones y sólo
algunas se han incluido. Por ejemplo, el cálculo de la potencia x n cuando x ∈ R
y n ∈ N no está incluida en Pascal, pero lo hemos hecho en el problema 4.18.
Supongamos que queremos hacer un programa para comparar los valores x n
y y m , donde x, y ∈ R y n, m ∈ N son datos ingresados por el usuario. Nuestro
programa tendría los siguientes pasos:
1. Poner carteles iniciales.

7.1. Funciones Pág. 67
2. Leer los datos x y n, yluegolosdatosyym. 3. Calcular xn y ym .
4. Comparar el resultado, imprimiendo la decisión.
5. Imprimir un cartel final.
Cada una de las acciones mencionadas no es difícil. Por ejemplo para calcular
xn y ym podríamos poner
xn := 1; for k := 1 to n do xn := xn * x;
ym := 1; for k := 1 to m do ym := ym * y;
Problema 7.1. En el programa potencias2 (pág. 188) hemos implementado
estas ideas. Leerlo, reconociendo la estructura mencionada, y ejecutarlo a fin de
verificar su funcionamiento. ✄
Claro que si contáramos con una función de Pascal para calcular xn para
x ∈ R y n ∈ N, digamos “ potencia(x,n)”, podríamos reemplazar los dos
renglones anteriores por
xn := potencia(x,n); ym := potencia(y,m);
Aunque Pascal no cuenta con una funciónquerealiceestecálculo, nos da un
mecanismo para definirla nosotros.
En Pascal, las funciones (y procedimientos que veremos en un rato) se declaran
en la parte declarativa (1) del programa, formando un bloque de estructura
similar a la de los programas.
Por ejemplo, para definir la función potencia (2) pondríamos antes del cuerpo
principal del programa,
function potencia(a: real; b: integer): real;
var k: integer; z: real;
begin
z := 1;
for k := 1 to b do z := z * a;
potencia := z
end;
Observamos que
• Se comienza poniendo el nombre de la función, poniendo “ function ”(o
“ procedure” para procedimientos) en vez de “ program ”, luego una parte
de declaraciones propias, y después un cuerpo principal encerrado entre
“ begin ”y“end; ”(con“; ”envezde“. ”porquenoeselfinaldel
programa).
• Los argumentos de la función deben ser declarados. En nuestro ejemplo hay
dos argumentos, a, detipo“real ”, y b,detipo“integer ”. Por supuesto,
el orden de los argumentos es importante: 2 3 =3 2 . Estos argumentos son
equivalentes al “ (input, output) ” de un programa Pascal.
• Las funciones en Pascal calculan un valor de alguno de los tipos elementales
boolean, char, integer o real.
(1) ¿Podría ser de otro modo?
(2) Usaremos estetipodeletra para señalar que se trata de una función o procedimiento hecho
por nosotros.

Pág. 68 Funciones y Procedimientos
✎ También podrían ser de tipo “ text ”, que veremos en el capítulo 8,
o puntero, que veremos en el capítulo 14. Según el estándar no deben
ser de otro tipo, como arreglos, aunque muchos compiladores lo
permiten.
El tipo del valor calculado debe ser declarado, lo que se hace mediante
la colocación de “ : ” luego de la declaración de argumentos. En nuestro
ejemplo, el resultado es de tipo “ real ”.
Decimos que la función devuelve o retorna el valor calculado.
• Dentro del bloque correspondiente a la función,elnombredeésta debe
ser asignado, y será el valor “retornado” a otras partes del programa.
✎ Sin embargo, el nombre de la función no es el identificador de una
variable. Ver el problema 7.2.d).
✎ No es importante el lugar de la asignación dentro de la función, y
no tiene por qué serlaúltima instrucción en la función. Inclusive es
posible hacer varias asignaciones, pero al menos debe haber una que
se ejecute antes de que termine la función.
• Además de los argumentos y el valor a retornar, la función puede tener
otras variables propias. En nuestro ejemplo, k de tipo “ integer ”yz de
tipo “ real ”. Todas estas variables propias, en nuestro ejemplo a, b, k y
z, se llaman locales, y se desconocen fuera de la función.
• Finalmente, el valor calculado por la función tiene que ser asignado (o
impreso) dentro de la parte principal del programa.
✎ O en otras funciones o procedimientos declaradas posteriormente.
Veremos ejemplos más adelante.
En estos casos decimos que el programa llama o invoca alafunción. Por
ejemplo, llamaríamos a la función potencia con la instrucción
xn := potencia(x,n)
Problema 7.2. En el programa potencias3 (pág. 188) hemos incorporado la
función “ potencia” y los cambios mencionados. Leerlo, estudiando las distintas
instrucciones, y ejecutarlo.
a) Observar que la variable k ya no está definida al comienzo del programa,
sino sólo en la función “ potencia”: es local alafunción pero desconocida
para el resto del programa.
i) Incluir el renglón
writeln(’ El valor de k es: ’, k:1);
inmediatamente antes del cartel final del programa. El compilador seguramente
rechazará esta acción pues k no está declarada.
ii) Manteniendo el renglón problemático, incluir la declaración de k como
estaba en el programa potencias2, y hacer la asignación “ k := 1”
antes del renglón del inciso anterior. Compilar y ejecutar nuevamente
el programa, observando que ahora no hay inconvenientes.

7.1. Funciones Pág. 69
iii) Repetir los pasos anteriores cambiando k por z, comprobando que z
“vive” sólodentrodelafunción.
b) Observar que al declarar la función, los argumentos a y b se separan con
“ ; ”, pero que al llamar la función se invoca con “ , ” separando los argumentos:
“ potencia(x,n)”.
i) Cambiar “ ; ”por“, ” en la declaración de la función, i.e. poner
function potencia(a: real, b: integer): real;
y comprobar que el compilador no acepta el cambio.
ii) De modo similar, cambiar “ xn := potencia(x,n);” por
xn := potencia(x;n);
y comprobar que este cambio tampoco es aceptado.
✎ Sin embargo, si dos o más argumentos consecutivos son del mismo
tipo, podemos separarlos con una coma juntando las declaraciones.
Para ejemplificar, si a y b son de tipo “ real ”, podemos declarar tanto
function f(a: real; b: real):...
como
function f(a, b: real):...
Es decir, el uso es similar a las “ , ” que se usan al declarar variables
con “ var ”. Veremos un ejemplo en el problema 7.7.
c) Las variables que son argumentos de la función también son locales a ella,
y es posible que coincidan con los nombres de otras variables del programa,
llamadas globales.
i) Cambiar la definición de la función a
function potencia(x: real; n: integer): real;
var k: integer; z: real;
begin
z := 1;
for k := 1 to n do z := z * x;
potencia := z
end;
y comprobar (compilando y ejecutando el programa) que el comportamiento
es el mismo.
ii) La localidad de los argumentos también se traduce en que podemos
modificarlos dentro de la función, sin modificar otras variables con el
mismo identificador del programa.
Por ejemplo, cambiar la declaración de la función poniendo
function potencia(x: real; n: integer): real;
var z: real;
begin
z := 1;
while (n > 0) do begin
z := x * z; n := n - 1 end;
potencia := z
end;

Pág. 70 Funciones y Procedimientos
Observar que el valor final de z es el mismo en uno u otro caso,
pero el valor de la variable n (localalafunción) se va modificando
con la nueva definición.
Ejecutar el programa, y verificar que sin embargo, el valor de n
que se imprime al final es el mismo que el ingresado inicialmente:
corresponde a la variable global n, y no a la variable n local a la
función.
✎ Si bien podemos poner cualquier identificador a los argumentos,
no deben ser los mismos que las otras variables locales a la
función. Por ejemplo no debemos poner
function potencia(x: real; n: integer): real;
var k: integer; x: real;
.
d) Ya hemos mencionado que el nombre de la función debe ser asignado antes
de terminar la función,peronoesunavariable:¿qué pasa si se pone
function potencia(x: real; n: integer): real;
begin
potencia := x;
while (n > 1) do begin
potencia := x * potencia; n := n - 1 end
end; ?
e) Cambiar la función potencia de modo de que el cálculo se haga mediante la
fórmula
x n =exp(nln x),
comprobando que se obtienen los resultados correctos. ✄
7.2. El método de la bisección
Supongamos que tenemos una función continua f definida sobre el intervalo
[a, b] a valores reales (3) ,yquef(a) yf(b) tienen distinto signo, como en la
figura 7.1. Cuando la dibujamos desde el punto (a, f(a)) hasta (b, f(b)), vemos
que en algún momento cruzamos el eje x, yallí encontramos una raíz de f, i.e.
un valor de x tal que f(x) =0.
En el método de la bisección se comienza tomando a0 = a y b0 = b, ypara
i =0, 1, 2,... se va dividiendo sucesivamente en dos el intervalo [ai,bi] tomando
el punto medio ci, y considerando como nuevo intervalo [ai+1,bi+1] alintervalo
[ai,ci] o[ci,bi], manteniendo la propiedad que en los extremos los signos de f
son opuestos (que podemos expresar como f(ai)f(bi) < 0). Se finaliza cuando
se obtiene un valor de x tal que |f(x)| es suficientemente chico, |f(x)|

7.2. El método de la bisección Pág. 71
a = a0
c0 = a1 = a2
c2
c1 = b2
b = b0 = b1
Figura 7.1: Una función continua con distintos signos en los extremos.
✎ También en este sentido, observamos que 2 10 = 1024 ≈ 10 3 y 2 20 =
1048576 ≈ 10 6 , por lo que el intervalo inicial se divide aproximadamente
en 1000 después de 10 iteraciones y en 1000000 = 10 6 después de 20
iteraciones. Es decir, después de 10 iteraciones el intervalo mide el 0.1%
del intervalo original, y después de 20 iteraciones mide el 0.0001 % del intervalo
original: no tiene mucho sentido poner mucho más de 10 iteraciones.
Problema 7.3 (Método de la bisección para encontrar raíces). El programa
biseccion (pág. 189) utiliza el método de bisección para encontrar raíces
en el caso particular
f(x) =x(x +1)(x +2)(x − 4/3).
a) Observar la declaración de la función f en Pascal, y la estructura del cuerpo
principal:
1. Carteles iniciales.
2. Entrada de los extremos del intervalo inicial: la cota inferior se llama
poco ylasuperiormucho.
3. En la inicialización, se calculan los valores de f en ambos extremos,
llamados ypoco y ymucho, y se inicializa a 0 el contador de iteraciones,
iter.
Dado que se sigue iterando si la función toma signos distintos en los
extremos, se define la variable lógica seguir que indica si la condición
es cierta o no.
4. En el lazo principal:
• Se incrementa el contador iter, se calcula el punto medio del intervalo,
medio, yelvalordefen este punto, ymedio.
• Si el valor absoluto de ymedio es suficientemente chico, paramos.
Esto se indica poniendo seguir en falso.
• También paramos si ya hemos llegado al máximo de iteraciones.
• Si no, calculamos el nuevo intervalo, cuidando de que los signos en
losextremosseandistintos.
Observar que sólo necesitamos el signo de ypoco para determinar
el nuevo intervalo, de modo que no hemos conservado el valor de
ymucho.

Pág. 72 Funciones y Procedimientos
5. En la salida tenemos en cuenta las distintas posibilidades por las cuales
seguir es falsa:
• Si la condición de distinto signo en los extremos no se satisfacía
inicialmente, no se han realizado iteraciones (por lo que el valor de
iter es 0), y ponemos un cartel apropiado.
• En otro caso señalamos los valores obtenidos, poniendo un cartel
especial si el error no es suficientemente pequeño (y por lo tanto el
número de iteraciones es máximo).
6. Terminamos poniendo un cartel de “Fin”.
b) Dada la forma de f, en este caso conocemos exactamente las raíces. Bosquejar
el gráfico de f en el intervalo [−3, 2], y dar valores iniciales de poco
y mucho para obtener aproximaciones a cada una de ellas ejecutando el
programa.
c) En caso de que haya más de una raíz en el intervalo inicial, la solución elegida
depende de los datos iniciales. Verificar este comportamiento ejecutando
el programa sucesivamente con los valores .8, 1 y 1.2 paramucho, pero
tomando poco = −3 en todos estos casos.
d) ¿Por quésiponemos poco = −3 ymucho =1obtenemoslaraíz x = −1 en
una iteración?
✎ En general, nunca obtendremos el valor exacto de la raíz: recordar que
en la computadora sólo existen racionales (¡y pocos!).
e) x =0esraíz, pero ¿qué pasa si ponemos poco =0ymucho =1?Modificar
el programa de modo que si f(poco) of(mucho) sean en valor absoluto
suficientemente pequeños, entonces se imprima la correspondiente solución
y no se realice el lazo de bisección.
f ) Agregar también la impresión de carteles apropiados cuando f(poco) ×
f(mucho) ≥ 0ynoseestáenlas condiciones del inciso anterior.
g) El programa no verifica si poco < mucho, ypodría suceder que poco >
mucho. ¿Tieneestoimportancia?
h) Teniendo en cuenta las notas al principio de la sección, ¿tendría sentido
agregar al programa un criterio de modo de parar si los extremos del intervalo
están suficientemente cerca? Si la nueva tolerancia fuera εx, ¿cuántas
iteraciones deben realizarse para alcanzarla, en términos de εx ylosvalores
originales de mucho y poco?
i) Modificar el programa de modo que en vez de considerar hasta un máximo
de iteraciones, el programa termine cuando o bien se ha encontrado x tal que
|f(x)|

7.2. El método de la bisección Pág. 73
a) Resolver aproximadamente las ecuaciones:
i) x 2 − 5x +2=0, ii) x 3 − x 2 − 2x +2=0.
Resolver también estas ecuaciones en forma exacta y comparar con los resultados
obtenidos.
✎ La primera ecuación tiene 2 raíces y la segunda 3.
b) Encontrar una solución aproximada de cos x = x y comparar con los resultados
del problema 5.7.
c) Obtener una solución aproximada de cada una de las ecuaciones
2 − ln x = x y x 3 sen x +1=0.
✎ La primera ecuación tiene una raíz, y la segunda tiene infinitas. ✄
Problema 7.5 (Interés sobre saldo). Consideremos el siguiente problema:
Un artículo cuesta $100 de lista. Puedo comprarlo al contado con un
10 % de descuento, o con un plan de pagos de anticipo y 9 cuotas
mensuales de $10 c/u, ¿cuál es la tasa de interés (nominal anual)
que están cobrando?
Resulta que hay muchas formas de calcularla (4) . En este problema estudiamos
el llamado interés sobre saldo, que da como respuesta a la pregunta anterior
una tasa de 29.07 %.
Supongamos que pedimos prestada una cantidad c (en $) con un tasa de
interés anual (nominal) r (en %), que pagaremos en cuotas mensuales fijas de p
(en $) comenzando al final del primer mes, y que el préstamo tiene las característica
de que el interés se considera sobre el saldo, esto es, si bm es el saldo
adeudado a fin del mes m, justo antes de pagar la cuota m-ésima, y cm es el
saldo inmediatamente después de pagar esa cuota, poniendo t =1+r/(100×12),
tendremos:
y en general
b1 = tc, c1 = b1 − p, b2 = tc1, c2 = b2 − p,...
cm = bm−1 − p = tcm−1 − p, (7.1)
donde inclusive podríamos poner c0 = c.
a) Programar una función saldo(c, r, p, m) que dados el monto inicial c, latasa
r, y el pago mensual p, calcule el saldo inmediatamente después de pagar la
m-ésima cuota, cm = saldo(c, r, p, m) param =1, 2,... Aclaración: nose
pide encontrar una fórmula, sólo escribir la función Pascal.
b) Verificar la corrección de la función anterior (dentro de un programa),
usando los datos de la pregunta al principio del problema (se financian
$90 − $10 = $80 en 9 cuotas de $10, a una tasa de 29.07 %; el saldo correspondiente
debe ser aproximadamente 0).
c) Considerando que c y r están fijos, ¿existe un valor de p de modo que el
saldo sea siempre el mismo, i.e. cm+1 = cm para m =1, 2,...?, ¿cuál?
(4) Yelcontadordirá“¿cuánto querés que te de?”

Pág. 74 Funciones y Procedimientos
d) Para c, r y p fijos, la función saldo(c, r, p, m) esdecreciente con m si p es
mayor que el monto calculado en el inciso c). ¿Cómo es el comportamiento
cuando sólo varía c?, ¿y si sólo varía r?
e) Hacer un programa de modo que dados r, c y p (p mayor que el monto en c))
calcule el número total de cuotas n. Aclaración: todas las cuotas deben ser
iguales, excepto tal vez la última que puede ser menor.
f ) Hacer un programa que usando el método de bisección, y dados c, r y
el número total de cuotas n, calculepde modo que la deuda se cancele
exactamente con n cuotas fijas, es decir cn =0.¿Podríamos usar poco =0
y mucho = a?
g) El resultado anterior, p, en general no podrá pagarse en pesos y centavos
(habrá más de dos decimales). Si los pagos se harán en pesos y centavos,
¿qué tolerancias en p pondremos? Modificar (si es necesario) el programa
anterior para incorporar esta tolerancia.
h) Modificar el programa para que dados r (latasaquemecobran),p (la cuota
que estoy dispuesto a pagar) y n (la cantidad de meses), calcule el monto c
(al que podría acceder).
✎ En calculadoras financieras y “planillas de cálculo” están implementadas
funciones similares.
Por ejemplo, en (la versión inglesa de) Excel están las funciones:
PMT: Para calcular p dados n, r y c: “PMT(r/12,n,c) ”.
PV: Para calcular c dados n, r y p: “PV(r/12,n,p) ”(pnega tivo pues es un pago).
RATE: Para calcular r dados n, c y p: “RATE(n,p,c)*12 ”(p
negativo pues es un pago).
NPER: Calcular n dados r, a y p: “NPER(r/12,p,c) ”(pne gativo pues es un pago).
Así, para calcular el pago mensual si r =8%,n =10yc = $10000,
ponemos “ PMT(8 %/12,10,10000) ” para obtener −1037.03. ✄
7.3. Procedimientos
Los procedimientos y funciones son muy parecidos entre sí, y a veces se
los engloba bajo el nombre común de rutinas (5) . De hecho, en lenguajes como
“C” no hay distinción entre ellos. En Pascal, la diferencia más obvia es que los
procedimientos no tienen “un resultado” visible.
Pascal nos permite mezclar funciones y procedimientos, con la única restricción
de que se deben declarar en el orden en que son usados: una función o
procedimiento no puede llamar a una función o procedimiento que no ha sido
aún declarada.
✎ Una posibilidad intermedia es el uso de “ forward ”, que no veremos.
Más aún, como veremos en el problema 7.6.d) y en el problema 7.8.b), es posible
poner una funciónoprocedimientodentrodeotrafunción o procedimiento,
yaquéllos serán locales aéstos (desconocidos para otras partes del programa).
Esta acción se llama anidamiento de funciones o procedimientos.
(5) Aunque en algunos lenguajes, ¡las rutinas son nuestros procedimientos!

7.3. Procedimientos Pág. 75
Podemos pensar, recordando la figura 2.4, que al alojarse en la memoria el
programa ejecutable, hay un espacio reservado para funciones y procedimientos,
como se indica en la figura 7.2. A su vez, funciones y programas pueden repetir
el esquema si hay anidamiento.
programa
ejecutable
datos
globales
funciones,
procedimientos
instrucciones
(parte
principal)
datos
locales
instrucciones
locales
datos
locales
instrucciones
locales
Figura 7.2: Esquema de programa, funciones y procedimientos en la memoria.
Volvamos al problema 4.12 (pág. 32) donde hicimos una tabla del seno usando
el programa tablaseno (pág. 177). Podemos esquematizar ese programa por
medio de los siguientes pasos:
1. Poner carteles.
2. Leer los datos, en este caso inicial, final e incremento.
3. Hacer e imprimir la tabla.
4. Señalar el fin del programa.
Pascal nos permite poner cada uno de estos pasos como procedimiento, poniendo
en el cuerpo principal del programa (6) :
begin
cartelesiniciales;
leerdatos;
imprimirtabla;
cartelfinal
end.
donde cartelesiniciales, leerdatos, imprimirtabla y cartelfinal son procedimientos
que realizarán las acciones correspondientes.
La ventaja de hacerlo es que podemos preocuparnos por cada uno de los
procedimientos —y si las hubiera, funciones— por separado. Así, podríamos
definir el procedimiento cartelesiniciales como
procedure cartelesiniciales;
begin
writeln(’Hacer una tabla del seno dando valores’);
writeln(’inicial, final, y del incremento (en grados).’);
writeln
end;
(6) Claro que es una exageración. Lo hacemos sólo a modo de ejemplo.

Pág. 76 Funciones y Procedimientos
Problema 7.6. En el programa tablaseno2 (pág. 191) hemos reescrito el programa
tablaseno, con las modificaciones mencionadas.
a) Comparar ambos programas, observando cómo se han declarado los procedimientos
en tablaseno2 ycómo se corresponden con las sentencias de
tablaseno.
Observar que las variables inicial , final e incremento se han declarado
como globales, puesto que se usan en distintas partes, mientras que grados
y radianes son locales al procedimiento imprimirtabla, pueseselúnico que
las usa.
b) Compilar y ejecutar tablaseno2 verificando su comportamiento.
c) En el problema 4.12 nos preocupamos por cómo dar un valor aproximado de
π, teniendo las alternativas de definirlo “manualmente” o usar una fórmula
como π =4× arctan 1, a la que podríamos agregar el uso de la técnica de
punto fijo del problema 5.8.
Eliminar la declaración de pi como constante en el programa tablaseno2,
declararlo en cambio como variable real e incluir el procedimiento:
procedure calculodepi;
begin
pi := 4 * arctan(1)
end;
como primer procedimiento, incluyendo la sentencia “ calculodepi” enel
cuerpo principal del programa. Compilar y ejecutar el programa con estas
modificaciones.
d) En realidad, el valor de pi se usa sólo para pasar de grados a radianes. Eliminar
las declaraciones de pi, calculodepi ylasentencia“calculodepi” del
programa, y en cambio colocarlas dentro del procedimiento imprimirtabla.
Debería quedar algo como:
procedure imprimirtabla;
var
grados: integer;
radianes, pi: real;
procedure calculodepi;
begin pi := 4 * arctan(1) end;
begin
calculodepi;
writeln(’Angulo Seno’);
grados := inicial;
while (grados

7.4. Pasando por valor o por referencia Pág. 77
7.4. Pasando por valor o por referencia
Tanto los procedimientos como las funciones tienen en general uno o más
parámetros que son los argumentos para evaluarlos (7) . Tenemos que distinguir
entre los parámetros que están en la descripción de la función o procedimiento,
llamados parámetros formales y los que se especifican en cada llamada de la
función o procedimiento, llamados parámetros reales.
Los parámetros formales se utilizan solamente dentro del cuerpo de la función
o procedimiento y son locales a él, es decir, son desconocidos fuera de la
función o procedimiento. Por supuesto, los parámetros reales deben tener el
mismo tipo que los formales. De alguna forma, podemos pensar que la función
o procedimiento tiene sus propias “cajas” (los parámetros formales) en las que
alojar las variables que son pasadas (los parámetros reales).
Por ejemplo, volviendo al programa potencias3 (problema 7.2), recordemos
que la función potencia se declaraba como
function potencia(a: real; b: integer):...
En este caso, los parámetros a y b son los parámetros formales, mientras que
al hacer la llamada
xn := potencia(x,n)
x y n se convierten en los parámetros reales. Los valores de x y n —“cajas”
globales del programa— se copian (respectivamente) en las “cajas” locales a y
b.
Pero no siempre esta “copia de valores” es adecuada:
Problema 7.7 (Intercambio de variables). Supongamos que queremos intercambiar
los valores de las variables u y v, es decir poner en u lo que está en
v yrecíprocamente. No podemos poner sencillamente “ u := v; v := u” pues
quedaría u = v (8) . La forma usual de hacer el intercambio es usando una variable
intermedia o temporal t (del mismo tipo que u y v), siguiendo un esquema
como “ t := u; u := v; v := t”, como se indica en la figura 7.3.
2
u v
1 3
t
Figura 7.3: Intercambio de los valores de u y v usando la variable intermedia t.
Los números indican el orden de los pasos a realizar.
Si queremos implementar este intercambio como procedimiento, el primer
impulso es poner (suponiendo variables enteras) un procedimiento como en el
programa intercambio (pág. 192).
✎ Observar la declaración de los argumentos en incorrecto: cuando hay dos
(o más) consecutivos del mismo tipo, en este caso “ integer ”, podemos
separarlos por comas poniendo “ a, b: integer ”, en vez del equivalente
a“a: integer; b: integer ”.
(7) Pero podrían no tenerlos, como en el procedimiento carteles del programa tablaseno2.
(8) Ante la duda, recomendamos hacer “pruebas de escritorio” en este problema.

Pág. 78 Funciones y Procedimientos
a) Ejecutar el programa, y comprobar que los valores de x y y no han cambiado.
El mecanismo de copiar los valores de x, y en las cajas locales a, b es la que
produce el resultado no deseado. Por suerte, existe un mecanismo que al llamar
a la función o procedimiento hace equivalentes las variables correspondientes.
En Pascal, esto se hace incorporando la palabra “ var ” a las variables deseadas:
b) Cambiar el procedimiento incorrecto del programa anterior por el siguiente:
procedure correcto(var a, b: integer);
(* a, b pasados por referencia *)
var t: integer;
begin t := a; a := b; b := t end;
Probarlo y comprobar que los valores finales de x y y son ahora los correctos.
✄
Como hemos visto en el problema anterior, en funciones y procedimientos
podemos indicar si queremos trabajar con una copia de los parámetros reales,
o directamente con éstos. Este mecanismo se llama de “sustitución” y es usual
distinguir las siguientes clases de sustitución de parámetros:
Sustitución por valor: El parámetro real se evalúa, y el valor resultante
sustituye al correspondiente parámetro formal.
Sustitución por referencia: El parámetro real es una variable; los posibles
índices se evalúan, y la variable así identificada sustituye a su
correspondiente parámetro formal. Es utilizada si el parámetro representa
el resultado de un procedimiento.
Por ejemplo, dado el fragmento
var i: integer; a: array[1..2] of integer;
procedure P(x: integer);
begin i := i + 1; x := x + 2 end;
begin (* cuerpo principal *)
a[1] := 10; a[2] := 20; i := 1; P(a[i])
end.
nos preguntamos cuáles son los valores finales del arreglo a.
En este caso, tenemos la sustitución por valor: lavariablexen el procedimiento
P tiene valor inicial 10 = a1. El valor final de a es (10, 20).
Si cambiamos la definición del procedimiento P a
procedure P(var x: integer);
begin i := i + 1; x := x + 2 end;
tendremos la sustitución por referencia: en el procedimiento P , x = a1 yla
sentencia “ x := x + 2” significa “ a[1] := a[1] + 2 ”. Por lo tanto, el valor
final de a es (12, 20).
Recordar entonces que
• En Pascal la sustitución por valor es la usual, si queremos sustitución por
referencia anteponemos la palabra “ var ”alparámetro formal.
• No podemos poner como parámetro real una constante cuando el parámetro
se pasa por referencia. Por ejemplo las declaraciones:

7.4. Pasando por valor o por referencia Pág. 79
.
procedure P(var x: integer):
.
begin (* parte principal *)
.
P(1);
.
.
end.
son incorrectas.
• Si hay varios parámetros, algunos pueden pasarse por valor y otros por
referencia (con “ var ”). Si hay una lista de parámetros separados por
“ , ”, como en “ proc(var a, b: integer; c, d: integer)”, entonces
los parámetros a y b se pasan por referencia mientras que los parámetros
c y d se pasan por valor (aunque es conveniente evitar estas confusiones,
poniendo explícitamente la palabra “ var ” delante de cada parámetro que
se pasará por referencia).
Problema 7.8. En los siguientes programas determinar los valores de los parámetros
de las sentencias “ writeln ” y luego comprobar las respuestas ejecutándolos
(agregando encabezado):
a) var a, b, c: integer;
procedure P(x, y: integer; var z: integer);
begin z := x + y + z; writeln(x, y, z) end;
begin a:= 5; b := 8; c := 3;
P(a, b, c); P(7, a + b + c, a); P( a * b, a div b, c)
end.
b) var i, j, k: integer;
procedure P(var i: integer);
begin i := i + 1; writeln(i, j, k) end;
procedure Q( h: integer; var j: integer);
var i: integer;
procedure R;
begin i := i + 1 end;
begin i := j;
if (h = 0) then P(j) else if h = 1 then P(i) else R;
writeln( i, j, k)
end;
begin i := 0; j := 1; k := 2; Q(0,k); Q(1,i); Q(2,j)
end.

Pág. 80 Funciones y Procedimientos
✎ Observar que el procedimiento “ R ” es local al procedimiento “ Q ”, y desconocido
globalmente. Recordar el problema 7.6.d). ✄
7.5. Comentarios Bibliográficos
La sección 7.4 —incluyendo los problemas— está basada en los libros de
Wirth [15] y[16].

Capítulo 8
Todos juntos: arreglos,
funciones y procedimientos
8.1. Definiendo nuestros propios tipos de datos:
“type”
Hemos visto cuatro tipos de datos elementales —“ boolean”, “ char ”, “ integer
”y“real ”— pero Pascal también nos permite crear nuevos tipos mediante
la palabra “ type ”. Esto es especialmente conveniente cuando trabajamos
con varios arreglos de las mismas características (y como veremos más tarde,
también para otras estructuras).
Supongamos por ejemplo que queremos trabajar con dos arreglos, a y b,
declarados como
var a, b: array[1..100] of integer
Puesto que tienen las mismas características, podríamos definir un tipo para
estos arreglos, por ejemplo
type arregloentero = array[1..100] of integer
después de la declaración de constantes y antes de la de variables. Observar que
usamos el signo “ = ”, como en las constantes, y no “ : ” que usamos al declarar
variables.
Luego podemos declarar (en la parte de “ var ”)
a, b: arregloentero
lo que nos permite hacer asignaciones de la forma “ a := b”, y no tener que
hacer un lazo para la asignación (1) .Más importante, es altamente conveniente y
recomendable usar como argumentos de funciones o procedimientos únicamente
parámetros de los tipos elementales o declarados con “ type ”, a fin de evitar
errores.
La estructura de un programa Pascal —a la que ya no haremos modificaciones—
toma entonces la forma del cuadro 8.1, y la estructura de funciones
(1) No obstante, no es posible hacer la comparación “ a = b”. En este caso habrá que usar
un lazo.

Pág. 82 Todos juntos: arreglos, funciones y procedimientos
y procedimientos es similar (pueden tener constantes, tipos, etc. propios), sólo
que terminan con “ end; ”envezde“end. ”.
1. program nombre (input, output);
2. const si hubiera que definir constantes.
3. type si hubiera definidos tipos propios.
4. var si hay variables.
5. Si las hubiera, funciones (con “ function ”) y procedimientos
(con “ procedure ”). Deben declararse teniendo en cuenta
el orden en que serán usadas.
6. begin
7. Instrucciones.
8. end.
Cuadro 8.1: Estructura de un programa Pascal.
8.2. Ingreso e impresión de arreglos
Ahora que contamos con funciones, es un buen momento para repasar la
entrada de datos del programa busquedalineal del problema 6.2.
Problema 8.1 (Ingreso de arreglos). Supongamos que queremos ingresar
un arreglo a =(a1,a2,...,an) de datos (de algún tipo), ingresando un dato
por renglón, poniendo los carteles en cada paso, y terminando la entrada con
“ sin datos”. Siguiendo el esquema del programa busquedalineal, e
incorporando el control del número de datos, de ahora en más vamos a usar un
procedimiento para englobar esta acción.
Si declaramos “ const MAXN = 100; ” y los tipos
tipodato = integer; (* real, char,... *);
tipoarreglo = array[1..MAXN] of tipodato;
podemos leer arreglos del tipo “ tipoarreglo” mediante el siguiente procedimiento:
procedure leerarreglo(var a: tipoarreglo; var n: integer);
var findatos: boolean;
begin
write(’Entrar numeros enteros,’); (* o reales o... *)
writeln(’ uno por renglon y no mas de ’, MAXN:1, ’.’);
writeln(’ Fin con retorno sin entrada de datos.’);
n := 1; findatos := false;
repeat
if (n > MAXN) then findatos := true
else begin
write(’Entrar el dato ’, n:2);
write(’ (fin = ): ’);
if (eoln) then begin findatos := true; readln end
else begin readln(a[n]); n := n + 1 end
end

8.2. Ingreso e impresión de arreglos Pág. 83
until findatos;
n := n - 1
end;
Podemos también copiar la impresión de arreglos del mismo programa, con
las modificaciones del problema 6.2:
procedure escribirarreglo(a: tipoarreglo; n: integer);
const maxrenglon = 10; (* maxima cantidad por renglon *)
var i: integer;
begin
for i := 1 to n do begin
write(a[i]:6); (* cambiar formato para reales,... *)
if ((i mod maxrenglon) = 0) then writeln
end;
if ((n mod maxrenglon) > 0) then writeln
end;
Hacer un programa con los procedimientos leerarreglo y escribirarreglo (que
acabamos de describir), para leer y luego imprimir un arreglo de enteros, de
modo que el cuerpo principal sea
begin
writeln(’** Prueba de lectura e impresion de arreglos’);
writeln;
leerarreglo( arreglo, ndatos);
writeln(’El arreglo leido es:’);
escribirarreglo( arreglo, ndatos);
writeln; writeln(’** Fin **’)
end.
Cuando esté funcionando correctamente, cambiar el tipo de datos ingresado
de entero a real. ✄
Problema 8.2. En el programa maximocaracter (pág. 192) se ingresa un arreglo
de caracteres (un renglón), lo reproduce y encuentra su máximo.
Observar la declaración del tipo tiporenglon con “ type ”.
✎ Según el estándar Pascal, son incorrectas la declaraciones del tipo
var s: array[1..10] of char
como hacemos en el programa maximocaracter, ydeberían declararse como
var s: packed array[1..10] of char
Sin embargo, hemos preferido no adherir al estándar en este caso, para
no introducir el concepto de “packed”. Si el compilador no lo admite,
habrá que hacer la declaración según el estándar.
Observar también que el procedimiento para leer el arreglo es ahora diferente
al procedimiento leerarreglo del problema 8.1, pues no queremos entrar una letra
por renglón: debemos cambiar “ readln(c)” por“read(c) ”, que lee el carácter
c, pero no el fin de línea.
✎ Recordando el problema 3.3.b), si pusiéramos “ readln(c) ” leeríamos c y
se ignorarían los restantes caracteres hasta el fin de línea.
a) max es un procedimiento y no una función, ¿por qué?

Pág. 84 Todos juntos: arreglos, funciones y procedimientos
b) Observar que el argumento t en max es del tipo “ tiporenglon” y se pasa
por referencia (mediante “ var ”).
✎ En otro caso, habría que hacer una copia del arreglo (local a la función),
ocupando lugar y tiempo. En los ejemplos con los que estamos
trabajando, esto no tiene mayor importancia, debido al tamaño pequeño.
c) max supone que long > 0. Dar un ejemplo donde es 0 y modificar el programa
para considerar este caso.
d) Modificarlo de modo de encontrar también el mínimo, usando un nuevo
procedimiento.
e) Modificarlo de modo que se intercambien las posiciones del máximo y el
último elemento, imprimiendo el nuevo renglón. ✄
Problema 8.3. Desarrollar un programa que, dado un arreglo de enteros entrado
como en el problema 8.1, y sin usar otro arreglo adicional, lo invierta, i.e.
si el arreglo inicialmente es (a1,a2,...,an), el arreglo final es (an,...,a2,a1).
Sugerencia: hacer los intercambios a1 ↔ an, a2 ↔ an−1,. . . ✄
Problema 8.4. Desarrollar un programa que leyendo un renglón (como en el
programa maximocaracter), lo escriba al revés, e.g. si la entrada es
“ dabale arroz a la zorra el abad ”
el programa escriba
“ daba le arroz al a zorra elabad ”
Sugerencia: ver el problema anterior. ✄
8.3. La caja de herramientas
Iremos presentando cada vez menos programas completos, bajo el entendimiento
de que cuestiones “comunes” ya han sido vistas, como leer o imprimir
arreglos.
Es una buena idea armar una “caja de herramientas” formada por archivos
de texto en el disco, con las funciones o procedimientos que nos parecen más
usados, o quizás más difíciles de reproducir. De esta forma, cuando necesitemos
alguno, podemos simplemente hacer una copia en el programa, haciendo quizás
pequeños cambios, sin necesidad de escribirlos —mucho menos pensarlos— cada
vez.
✎ Los sistemas de programación más avanzados incluyen en bibliotecas estas
funciones o procedimientos, muchas veces en forma binaria difícil de modificar.
Aunque similar, el concepto es ligeramente diferente del de la “caja
de herramientas”.
Por ejemplo, los procedimientos leerarreglo y escribirarreglo del problema 8.1
nos dan una “plantilla” (o “template”) para leer o imprimir arreglos de números
eventualmente modificando el índice inicial, e.g. “ array[1..MAXN]”, o el tipo
de dato del arreglo, e.g “ real ”envezde“integer ”.

8.4. Arreglos multidimensionales Pág. 85
Problema 8.5 (La Caja de Herramientas). Copiar en sendos archivos de
texto (2) , los procedimientos leerarreglo y escribirarreglo del problema 8.1,ypracticar
incorporarlos en un programa para leer y escribir un arreglo de enteros
(como en el problema 8.1). ✄
Seguramente habrá muchos procedimientos o funciones que querrás incorporar
a la caja de herramientas, algunos que ya hemos visto como el método de la
bisección (sección 7.3), y otros que veremos más adelante, como alguno de los
métodos de búsqueda y clasificación del capítulo 10.
8.4. Arreglos multidimensionales
Los arreglos unidimensionales no son apropiados para guardar la información
contenida en una tabla (como la del seno o del logaritmo). En estos casos
es más conveniente usar un “arreglo de arreglos”, también llamado arreglo multidimensional.
Por ejemplo, si queremos guardar una matriz de reales de 2 × 3, podemos
pensar que necesitamos un arreglo de dimensión 2 (cantidad de filas), cuyos
elementos individuales son arreglos de dimensión 3 (cantidad de columnas).
Hacemos entonces la declaración
m: array[1..2] of array[1..3] of real;
o equivalentemente,
m: array[1..2,1..3] of real;
y accedemos al elemento (i, j) usando indistintamente “ m[i][j] ”o“m[i,j] ”.
Las matrices son un ejemplo de estructura de dos dimensiones, pero no hay
inconvenientes en considerar estructuras con cualquier número de dimensiones.
Si en vez de números guardamos caracteres, las filas pueden pensarse como
renglones, como hacemos en el siguiente problema.
Problema 8.6. En este problema consideraremos un texto como una serie de
renglones o líneas no vacías (cada una tiene al menos un carácter). Declaramos
const
MAXC = 255; (* maxima cantidad de caracteres por renglon *)
MAXR = 20; (* maximo numero de renglones *)
type
tiporenglon = array[1..MAXC] of char;
tipotexto = array[1..MAXR] of tiporenglon;
caracteresenrenglon = array[1..MAXR] of integer;
var
nr, (* numero de renglones *)
nc (* numero de caracteres en renglon *)
: integer;
texto: tipotexto;
cenr: caracteresenrenglon;
(2) En algunos sistemas operativos, es conveniente que tengan la extensión “ .txt ”.

Pág. 86 Todos juntos: arreglos, funciones y procedimientos
eventualmente recordando la nota en el problema 8.2.
a) Desarrollar un procedimiento o función para leer no más de MAXR renglones,
con no más de MAXC caracteres por renglón, dando como señal de fin
de entrada un “renglón vacío”.
Sugerencia: copiar las ideas del programa maximocaracter.
Sugerencia si la anterior no alcanza:
nr := 0; (* numero de renglon leido, al ppo. ninguno *)
while (not eoln) do begin
(* mientras el renglon a leer no sea vacio... *)
nr := nr + 1; (* hay un renglon mas *)
nc := 0; (* que todavia no tiene caracteres leidos *)
repeat (* leemos los caracteres *)
nc := nc + 1; (* y los guardamos en el *)
read(texto[nr][nc]) (* lugar correspondiente *)
until (eoln); (* hasta llegar al fin del renglon *)
readln; (* leemos el fin de linea *)
cenr[nr] := nc (* nro. de caracteres en renglon nr *)
end;
b) Incorporar un procedimiento para escribir renglones, y verificar que el proceso
de lectura desarrollada en el inciso anterior es correcto.
✎ A veces arreglos como texto y cenr se dicen paralelos, pues la información
se va actualizando simultáneamente. Cuando veamos registros, en la
sección 10.4, veremos otra forma de guardar información de este tipo. ✄
8.5. “Strings”
Problema 8.7. El tipo “ string ”noesestándar en Pascal, pero existe en casi
todos los compiladores, en particular en Turbo Pascal. Probar el comportamiento
del compilador con un programa que lee un renglón entrado por terminal, vía
“ readln(s) ”, donde se declara s como “ string[100]”, indicando su longitud,
y/o simplemente como “ string ”.
En caso de aceptar alguna de estas variantes, agregar al programa las instrucciones:
a) “writeln(s)”, para escribir s,
b) “length(s) ”, para averiguar su longitud, y
c) “for i := 1 to length(s) do writeln( i:3, ’: ’, s[i]) ”, para escribirlo
carácter por carácter, indicando el índice.
d) Modificar el programa del problema 8.6, cambiando el tipo “ renglon ”por
el tipo “ string ”.
✎ Según el estándar Pascal, el tipo “string” es una denominación genérica
para el tipo char y para arreglos empaquetados de caracteres, como los
mencionados en la nota del problema 8.2. ✄
8.6. Manejo elemental de archivos de texto
A veces resulta útil guardar los resultados obtenidos por un programa, para
después leerlos, imprimirlos o utilizarlos en otros programas. Dado el tamaño

8.6. Manejo elemental de archivos de texto Pág. 87
de las “salidas” de los programas con los que trabajamos, será suficiente para
nosotros trabajar con archivos de texto, es decir, archivos que podemos abrir
(para leer, modificar o imprimir) con un editor de textos.
El lenguaje Pascal no es especialmente apto para leer y escribir archivos, y es
por ello que se han realizado muchas extensiones (que no respetan el estándar)
tratando de mejorarlo, pero trataremos de ceñirnos al estándar. En él se establece
otro tipo elemental de datos, además de los que ya hemos visto: el tipo
“ text ”, o archivo de texto.
✎ Las variables de tipo “ text ” que son argumentos de una función o procedimiento
deben pasarse por referencia, i.e. anteponiendo “ var ”(versección
7.4).
Dos estructuras fundamentales para el manejo de archivos son: copiar de
consola a archivo, y copiar de archivo a consola, que mostramos en los programas
deconsolaaarchivo (pág. 194) ydearchivoaconsola (pág. 195) respectivamente, y
que pasamos a comentar.
• Al leer los programas, observamos que el el archivo a leer o escribir tiene
una variable asignada, curiosamente llamada archivo, declarada como de
tipo “ text ”. Una de las primeras cosas que hemos de hacer es relacionar
este identificador, interno al programa, con el nombre que el archivo tiene
o tendrá en el disco. Para eso, primeramente el usuario ingresa el nombre
tal como aparece o aparecerá eneldisco.
✎ Nos hemos permitido usar “ string ” para la variable correspondiente,
aunque no es estándar y habrá que hacer modificaciones si el
compilador no lo acepta. Recordar la nota en el problema 8.2.
• Luego el nombre interno y el externo se relacionan mediante “ rewrite ”
si el archivo se escribirá, o mediante “ reset ” si el archivo se leerá.
Ha de tenerse cuidado con “ rewrite ”, pues si el archivo no existe, se crea
uno nuevo, pero si ya existe, sus contenidos son borrados.
✎ En compiladores que siguen el modelo de Turbo Pascal para entrada/salida,
hay que modificar los programas, ya que no aceptan el
estándar.
Para escribir un archivo, hay que cambiar el renglón
rewrite(archivo, nombre);
por
assign(archivo, nombre); rewrite(archivo);
en el programa deconsolaaarchivo. Del mismo modo, para leer desde
un archivo, hay que modificar el renglón
reset(archivo, nombre);
por
assign(archivo, nombre); reset(archivo);
en el programa dearchivoaconsola.
Sintetizamos estas diferencias en el cuadro 8.2.

Pág. 88 Todos juntos: arreglos, funciones y procedimientos
Estándar Turbo Pascal
escribir rewrite(archivo, nombre) assign(archivo, nombre);
archivo rewrite(archivo)
leer reset(archivo, nombre) assign(archivo, nombre);
archivo reset(archivo)
Cuadro 8.2: Diferencias entre el estándar y Turbo Pascal para leer o escribir
archivos.
• Luego de leer el nombre externo y relacionarlo con el interno, debemos
leer de consola e ir escribiendo el archivo en un caso, y recíprocamente,
leer del archivo y escribir en consola en el otro.
En el primer caso vemos una estructura similar a la lectura de renglones
del problema 8.6, exceptoquealescribirnousamos“write(c)” sino
“ write(archivo, c) ”paraescribircen el archivo y no la consola, debiendo
incorporar el nombre del archivo. Del mismo modo, “ writeln(archivo)
”(sinelargumentoc) escribeun“findelínea” terminando el
renglón en el archivo.
En el segundo caso, cuando leemos del archivo en dearchivoaconsola eimprimimos
en la terminal, volvemos a encontrar una estructura conocida,
excepto que ahora el “fin de datos” que anteriormente señalábamos con
“ vacío”, ahora se señala de un modo especial para archivos de
textos: el “fin de archivo”.
De modo similar a “ eoln ”, “ eof(archivo)” pregunta si ya hemos llegado
aestaseñal en el archivo que estamos leyendo.
✎ Hay que tener cuidado pues no debe llamarse a “ eoln ”siseha
llegado al final del archivo, ya que un archivo de texto puede no
tener fin de línea: primero siempre debe llamarse a “ eof ”.
También, “ read(c) ” se cambia por “ read(archivo,c)” para leer c desde
el archivo y no la consola.
• Al terminar de leer o escribir el archivo, usamos “ close(archivo)”, lo
que hace que ya no se relacionen el nombre del archivo en el disco y la
variable nombre, y —en el caso de estar escribiendo— coloca en el archivo
la señal de “fin de archivo”.
Problema 8.8 (Archivos de texto).
✎ Recordar los cambios a realizar —usando “ assign ”— si se sigue el modelo
de Turbo Pascal.
a) Compilar y ejecutar el programa deconsoloaarchivo, y verificar su comportamiento
abriendo el archivo creado con un editor de textos.
✎ El “directorio” en el cual el programa creará o buscará el archivo
depende de la instalación del compilador. Las posibilidades son: dar
una ubicación “absoluta”, indicando el “camino” completo; o crear
un archivo y encontrar dónde se instaló, a veces el mismo compilador
permite determinar el directorio donde se trabajará.
✎ En algunos sistemas operativos es conveniente que los archivos de texto
tengan la extensión “ .txt ”.

8.7. Problemas Adicionales Pág. 89
b) Del mismo modo, compilar y ejecutar el programa dearchivoaconsola.
c) Tomando las partes necesarias de los programas deconsolaaarchivo y dearchivoaconsola,
y tal vez del problema 8.6, hacer un programa dearchivoaarchivo
para copiar un archivo en otro (nuevo) archivo, y verificar con un editor de
textos que el nuevo archivo es correcto. Sugerencia: dar distintos nombres
a las variables para el archivo de entrada y el de salida.
✎ Ya que estamos usando “ string ”, podríamos haber leído todo un renglón
en vez de carácter por carácter. Sin embargo, es posible que los “renglones”
tengan más de la longitud permitida por “ string ”, usualmente 256
caracteres. ✄
Problema 8.9.
a) Hacer una función que dado n ∈ N, determine la longitud del período de la
fracción 1/n (recordar el problema 6.10, pág. 64).
b) Usando la función anterior, hacer un programa para crear un archivo con
las longitudes de los períodos de las fracciones 1/n, paran =1, 2,...,100,
escribiendo 10 longitudes por renglón. Verificar el contenido abriendo el
archivo creado con un editor de textos.
c) Hacer otro programa que lea el archivo creado en el inciso anterior, y determine
el promedio de los períodos. ✄
8.7. Problemas Adicionales
Problema 8.10. Hacer un programa que dado un arreglo de n enteros, lo
rote en m posiciones hacia la izquierda, sin usar un arreglo auxiliar. E.g. si
n = 10 y m = 3, el arreglo (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) debe transformarse en
(3, 4, 5, 6, 7, 8, 9, 0, 1, 2).
Sugerencia: el problema consiste en transformar el vector de dos bloques AB
en BA. Si A R es la operación de invertir el arreglo A (ver problema 8.3),
(A R B R ) R = BA. Implementar la inversión como función o procedimiento. ✄
Problema 8.11 (Contando palabras en texto). Al usar un editor de textos
es frecuentemente necesario contar la cantidad de palabras, por ejemplo porque
el informe que estamos haciendo no puede superar cierto número de palabras.
Hacer un programa para leer renglones de caracteres (marcando fin de la
entrada con sin otro dato) y contar el número de palabras ingresados,
donde para simplificar y complicar, supondremos que:
• Sólo se ingresan letras (mayúsculas o minúsculas) sin acentos ni tildes,
números, espacios en blanco o ’s. O sea no se ingresan signos de
puntuación ni tabulación.
• Una palabra es una sucesión máxima de letras y/o números sin espacios
intermedios.
• Pero puede haber varios espacios en blanco consecutivos o al principio o
fin de cada renglón.
Por ejemplo, si ingresamos

Pág. 90 Todos juntos: arreglos, funciones y procedimientos
hay 23 sapos que nacieron tristes
la variable era x27
menos mal que las vacas no vuelan
el programa debe responder que se ingresaron 17 palabras.
Modificarlo de modo de contar las palabras en un archivo de texto, donde
los caracteres que no son letras, números, espacios en blanco o finales de línea
son ignorados, y no hay acentos ni tildes: como en un programa fuente. ✄
8.8. Comentarios Bibliográficos
La descripción de tipos y archivos de textos en Pascal está basada en [7]. El
problema 8.10 está tomado de [4].

Capítulo 9
Números Aleatorios y
Simulación
Muchas veces se piensa que en matemáticas las respuestas son “siempre exactas”,
olvidando que las probabilidades forman parte de ella y que son muchas
las aplicaciones de esta teoría.
Una de estas aplicaciones es la simulación, técnica muy usada por físicos,
ingenieros y economistas cuando es difícil llegar a una fórmula que describa el
sistema o proceso. Así, simulación es usada para cosas tan diversas como el
estudio de las colisiones de partículas en física nuclear y el estudio de cuántos
cajeros poner en el supermercado para que el tiempo de espera de los clientes
en las colas no sea excesivo.
La simulación mediante el uso de la computadora es tan difundida, que hay
lenguajes de programación (en vez del Pascal o “C”) especialmente destinados
aestepropósito.
9.1. Números aleatorios
Cuando en la simulación interviene el azar o la probabilidad, se usan números
generados por la computadora que reciben el nombre de “aleatorios” (o, más
correctamente, “seudo-aleatorios”). No es nuestra intención aquí hacer una descripción
de quésonestosnúmeros o cómo se obtienen: basta con la idea intuitiva
de que la computadora nos da un número en cierto rango, y cualquier número
del rango tiene la misma probabilidad de ser elegido por la computadora.
En general, los números aleatorios se obtienen a partir de un valor inicial o
semilla (“seed” en inglés); de modo que si no se indica lo contrario —cambiando
la semilla— siempre obtenemos la misma sucesión de números aleatorios. Un
método eficaz para obtener “números verdaderamente aleatorios”, es cambiar
la semilla de acuerdo a la hora que indica el reloj de la computadora.
Lamentablemente, en el estándar Pascal no está definida una función para
generar números aleatorios. Aún cuando un compilador tenga implementada
una tal función, el nombre con la que se llama y aún el tipo de resultado —por
ejemplo si son números reales entre 0 y 1 o enteros entre 0 y maxint— dependen
también del compilador.

Pág. 92 Números Aleatorios y Simulación
Dado que muchos compiladores siguen el modelo de Turbo Pascal, nosotros
seguiremos la notación de este compilador para no complicar más de lo necesario,
apartándonos del estándar.
✎ Si no se dispone de una rutina para generar números aleatorios, es necesario
instalar una propia. Sin embargo, obtener números aleatorios con
la computadora no es tan sencillo como tirar dados, y hay mucha teoría
matemática detrás de los “buenos” generadores: el lector interesado puede
consultar el excelente libro de Knuth [11, vol.2].
Una posibilidad es usar las rutinas que aparecen como ejemplo en el
mismo estándar de Pascal extendido (ISO 10206) adaptado al estándar
estándar de Pascal sin extensiones que es el que usamos (1) .
Turbo Pascal cuenta con las funciones “ random ”y“randomize ”, y la variable
randseed .“random ” sin argumentos da un número aleatorio entre 0 y 1;
y cuando incluimos un argumento n ∈ N, “random(n)” daunnúmero aleatorio
entero entre 0 y n−1. La semilla es la variable “ randseed ”, que puede cambiarse
de acuerdo al reloj de la computadora mediante la instrucción “ randomize”.
9.2. Aplicaciones
Problema 9.1. El programa dado (pág. 195) hace una simulación de tirar un
dado mediante números aleatorios obtenidos con la sentencia “ random ”.
a) La sentencia “randomize” sirve para comenzar una nueva serie de números
aleatorios. Eliminarla, comentándola, ejecutar repetidas veces el programa
y comprobar que siempre se obtienen los mismos resultados (o sea no es
muy al azar).
✎ Salvo para programas que tienen un tiempo de ejecución grande, no
debe hacerse más de una llamada a “ randomize ”.
b) Modificar el programa para simular tirar una moneda con resultados “cara”
o “ceca”. ✄
Problema 9.2. El programa dados (pág. 196) hace una simulación para encontrar
la cantidad de veces que se necesita tirar un dado hasta que aparezca un
número prefijado, entrado por el usuario. Gracias a la sentencia “ randomize”, el
resultado en general será distinto con cada ejecución. Observar que si el usuario
entra un número menor que 1 o mayor que 6, el programa no termina nunca.
a) Ejecutar el programa repetidas veces, para tener una idea de cuánto tarda
en aparecer un número.
b) En vez de correr varias veces el programa, modificarlo de modo de realizar
n simulaciones (n entrado por el usuario), mostrando como resultado el
promedio de los tiros en que tardó en aparecer el número predeterminado.
Sugerencia: encerrar el lazo “ repeat ”dentrodeunlazo“for ”.
c) Modificar el programa original a fin de simular que se tiran simultáneamente
dos dados, y contar el número de tiros necesarios hasta obtener un resultado
ingresado por el usuario (entre 2 y 12). ✄
(1) Una copia del estándar en formato pdf puede encontrarse en
http://www.pascal-central.com/standards.html
El ejemplo en el estándar está tomado, a su vez, del artículo de Wichmann and Hill, Building
a Random-Number Generator, Byte, marzo 1987, págs. 127–128.

9.2. Aplicaciones Pág. 93
Problema 9.3. Tomando como base el problema anterior y el programa dados,
hacer un programa que diga cuántas veces debió tirarse un dado hasta que
aparecieron k seis consecutivos, donde k es ingresado por el usuario. Sugerencia:
poner un contador c inicialmente en 0, y dentro de un lazo “ repeat ” (donde
se hace la llamada a “ random ”) el contador se incrementa en 1 si salió unseis
ysinosevuelvea0.
✎ En éste y en el problema 9.2, surge la duda de si el programa terminará alguna
vez, dado que existe la posibilidad de que nunca salga el número
prefijado, o que nunca salga k veces consecutivas. Sin embargo, se puede
demostrar matemáticamente que la probabilidad de que esto suceda es 0
(suponiendo que el generador de números aleatorios sea correcto). ✄
Problema 9.4. En este problema usaremos la sentencia “ random ”(sinargumentos)
de Turbo Pascal que da un número aleatorio real entre 0 y 1.
a) Hacer un programa que elija aleatoriamente el número 1 aproximadamente
el 45 % de las veces, el número 2 el 35 % de las veces, el 3 el 15 % de las
veces y el 4 el 5 % de las veces. Sugerencia: considerar las sumas parciales
.45,.45 + .35,...
b) Generalizar al caso en que en vez de la lista (1, 2, 3, 4) se dé una lista
(a1,a2,...,an) y que en vez de las frecuencias (.45,.35,.15,.5) se dé una
lista (f1,f2,...,fn), con n
i=1 fi = 1. Probarlo para distintos valores y
verificar que las frecuencias son similares a las deseadas. ✄
Problema 9.5. El compilador de Pascal de Ana tiene la sentencia “ aleat ”,
que obtiene números aleatorios r ∈ R con 0 ≤ r

Pág. 94 Números Aleatorios y Simulación
elemento se repite. Sugerencia: agregar un segundo arreglo para contar las
apariciones.
✎ La cantidad de apariciones deberían ser muy similares, aproximadamente
r/s cada uno, cuando r ≫ s. ✄
Problema 9.8 (Dos con el mismo cumpleaños). Mucha gente suele sorprenderse
cuando en un grupo de personas hay dos con el mismo día de cumpleaños:
la probabilidad de que esto suceda es bastante más alta de lo que se
cree normalmente.
Supongamos que en una sala hay n (n ∈ N) personas y supongamos, para
simplificar, que no hay años bisiestos (no existe el 29 de febrero), de modo que
podemos numerar los posibles días de cumpleaños 1, 2,...,365.
a) ¿Para quévalores de n se garantiza que haya al menos dos personas que
cumplen años el mismo día? Sugerencia: recordar el principio del casillero,
también conocido como del palomar o de Dirichlet
✎ El principio de Dirichlet dice que si hay n + 1 objetos repartidos en n
casillas, hay al menos una casilla con 2 o más objetos.
b) Si la sala es un cine al cual van entrando de a una las personas, ¿cuántas
personas, en promedio, entrarán hasta que dos de ellas tengan el mismo
día de cumpleaños? Responder esta pregunta escribiendo un programa que
genere aleatoriamente días de cumpleaños (números entre 1 y 365) hasta que
haya dos que coincidan, retornando la cantidad de “personas” necesarias.
Hacer varias “corridas” para tener una idea más acabada.
Si en el programa se usan arreglos, ¿cuál será ladimensión, de acuerdo
al inciso anterior?
c) Basado en el punto anterior, si en tu curso hay 30 compañeros, ¿apostarías
que hay dos que cumplen años el mismo día? ✄
9.3. Problemas Adicionales
Problema 9.9 (Aguja de Buffon). Una aguja fina (teóricamente un segmento)
de longitud l ≤ 1, es arrojada sobre un tablero dividido por líneas paralelas
donde la distancia entre dos consecutivas es 1. Mostrar, mediante un programa,
que el promedio de veces que la aguja cruzará una de las líneas es aproximadamente
2l/π.
Georges Louis Leclerc, Conde de Buffon (1707–1788) planteó este problema
en 1733, dando vigor a la teoría de probabilidad geométrica. Este problema en
particular es más que nada de interés teórico e introductorio al tema, pues las
aproximaciones experimentales de π no son buenas. ✄
Problema 9.10 (El Show de Televisión). Un problema que causó gran
revuelo hacia 1990 en Estados Unidos es el siguiente:
En un show televisivo el locutor anuncia al participante que detrás
de una de las tres puertas que ve hay un auto 0 km, no habiendo nada
detrás de las otras dos. El locutor le pide al participante que elija
una de las puertas. Sin abrir la puerta elegida por el participante, el
locutor abre otra puerta mostrándole que no hay nada detrás de ésta,
yledalaopción al participante de cambiar su elección (pudiendo

9.3. Problemas Adicionales Pág. 95
optar entre mantener su primera elección o elegir la tercer puerta).
El participante gana el auto si éste está detrás de la puerta que elige
finalmente.
a) Intuitivamente y sin dar una justificación rigurosa, ¿es más conveniente para
el participante mantener su primera elección, cambiarla o es indiferente?
b) Hacer un programa que simule el juego para tener mejor idea: i) el programa
elige una de las puertas donde estará el auto (sin que nosotros sepamos
el resultado); ii) nosotros hagamos una elección; iii) que en base a esta
elección, el “locutor” elija una segunda puerta detrás de la cual no está el
auto, al azar si hay dos posibilidades; iv) que nosotros mantengamos o
cambiemos la elección; y v) que diga si ganamos o no el auto.
c) Modificar el programa anterior de modo de hacer automáticamente n juegos
en los que siempre elegimos una puerta al azar y luego cambiamos,
retornando el número de veces que ganamos. Correrlo para n = 1000 (¡primero
hacerlo para n =5paraversiestáfuncionando bien!). Comparar el
resultado con la respuesta en a). ✄

Capítulo 10
Búsqueda y clasificación
Siempre estamos buscando algo y es mucho más fácil encontrarlo si los datos
están clasificados u ordenados. No es sorpresa que búsqueda y clasificación sean
temas centrales en informática y que haya una enorme cantidad de material
escrito al respecto. Por ejemplo, en sus clásicos libros [11] Knuth dedica al tema
todo el Volumen 3 (que por supuesto, usa material de los volúmenes anteriores).
Acá hacemos una introducción al tema siguiendo, en mínima proporción, la
presentacióndeWirthen[16].
10.1. Búsqueda lineal con centinela
Empecemos recordando lo hecho en el problema 6.2 y el programa busquedalineal
en el que recorríamos “linealmente” el arreglo a =(a1,a2,...,an) buscando
x (suponiendo n>0).
Problema 10.1. Al buscar x en el arreglo (a1,a2,...,an), el programa busquedalineal
(pág. 184) usaunlazo“repeat ”:
i := 0;
repeat i := i + 1; seencontro := (a[i] = x)
until (seencontro or (i = n));
if (seencontro) then... (* se encontro en la posicion i *)
¿Con cuáles de las siguientes alternativas se podría reemplazar este lazo?:
a) i := 0;
repeat i := i + 1 until ((i = n) or (x = a[i]));
if (x = a[i]) then... (* se encontro en la posicion i *)
b) i := 1;
while ((i

10.1. Búsqueda lineal con centinela Pág. 97
while ((a[i] x) and (i > 1)) do i := i - 1;
if (x = a[i]) then... (* se encontro en la posicion i *) ✄
En el lazo “ while ”o“repeat ” de los esquemas en el problema anterior para
búsqueda lineal se hacen dos comparaciones, pero podemos mejorarlo haciendo
una sola colocando a x como “centinela” en alguna posición de modo que siempre
lo encontremos.
Por ejemplo, una modificación del esquema del inciso d) del problema anterior
—que es correcto— suponiendo que el arreglo a está dimensionado adecuadamente,
es:
(* a debe ser declarado de modo de admitir a[0] *)
a[0] := x; i := n;
while (x a[i]) do i := i - 1;
if (i > 0) then... (* se encontro en la posicion i *)
Observamos que siempre termina, ya sea porque x es un elemento del arreglo
original, en cuyo caso i es el lugar que ocupa, o bien porque no se encontró, en
cuyo caso i =0.
✎ No hay nada misterioso en ir desde atrás hacia adelante, podríamos haber
puesto el “centinela” en la posición n+1 y recorrer de adelante hacia atrás.
Problema 10.2 (Búsqueda lineal con centinela). Hacer una implementación
con ambas variantes (con y sin centinela) como procedimientos, incluyendo
un contador para la cantidad de comparaciones en cada una, y probar el comportamiento
en distintos ejemplos (entrar el arreglo como en el procedimiento
leerarreglo, pág. 82, o generar uno aleatoriamente). ✄
Problema 10.3. En este problema queremos hacer un procedimiento para eliminar
elementos repetidos del arreglo de enteros a = (a1,a2,...,an), como
en el problema 6.4, pero cuando a está ordenado de menor a mayor, e.g. si
a =(1, 2, 2, 5, 6, 6, 9), queremos que al fin del procedimiento sea a =(1, 2, 5, 6, 9).
En este caso podemos poner algo como
procedure purgarordenado(var a: arreglo; var n: integer);
(* sacar elementos repetidos del arreglo
ordenado a de longitud n. *)
var i, m: integer;
begin
m := 1; (* a[1],...,a[m] son los elementos sin repetir *)
for i := 2 to n do
(* incluir a[i] si no es a[m] *)
if (a[m] < a[i]) then begin
m := m + 1; a[m] := a[i] end;
n := m
end;
Hacer un programa para verificar el comportamiento de este procedimiento.
✄
Problema 10.4 (Fusión o mezcla de arreglos ordenados). Supongamos
que tenemos dos arreglos a = (a1,a2,...,an) yb = (b1,b2,...,bm) ordenados
de menor a mayor (con n, m ≥ 1), y queremos construir un arreglo c =

Pág. 98 Búsqueda y clasificación
(c1,c2,...,ck) queestétambién ordenado y de modo que tenga los elementos
de a y b. Por ejemplo, si a = (1, 2, 5, 5) y b =(2, 3, 4), deberá serc =
(1, 2, 2, 3, 4, 5, 5).
✎ Recordar el problema 6.3.
Hacer un procedimiento para obtener c, usando un esquema como
i := 1; j := 1; k := 0;
while ((i

10.2. Búsqueda binaria Pág. 99
i) Verificar que (10.1) implica (10.2).
ii) Verificar que si en cambio, mucho ≥ poco +2, entonces poco < medio <
mucho.
c) Si se cambiara el esquema del inciso a) a
poco := 1; mucho := n;
while (poco + 1 < mucho) do begin
medio := (poco + mucho) div 2;
if (a[medio] < x) then poco := medio
else mucho := medio
end;
(* a continuación comparar x
con a[mucho] y con a[poco] *)
¿sería ahora correcto?
d) Si en vez de considerar poco + 1 en la condición del lazo del inciso anterior,
lo incorporamos a la asignación, llegamos a:
poco := 1; mucho := n;
while (poco < mucho) do begin
medio := (poco + mucho) div 2;
if (a[medio] < x) then poco := medio + 1
else mucho := medio
end
(* a continuación comparar x con a[mucho] *)
En este inciso veremos que el nuevo esquema es correcto:
i) En todo momento poco ≤ mucho, la distancia entre ellos se acorta en
cada “vuelta” del lazo, y al terminar es poco = mucho (y no puede ser
poco > mucho) (recordar el inciso b.ii)).
ii) Si x ≤ a1, poco queda fijo, y al final se compara x con a1.
iii) Si x>an, mucho queda fijo en las siguientes iteraciones, y al final se
compara x con an (y obtendremos que x/∈ a).
iv) Si apoco

Pág. 100 Búsqueda y clasificación
until ((a[k] = x) or (i >= j))
b) i := 1; j := n;
repeat
k := (i + j) div 2;
if (x = j)
d) Muchos autores presentan un algoritmo un poco más ineficiente que el del
problema 10.5.d), comparando x con amedio en cada paso de modo que hay
dos comparaciones por “vuelta” de lazo:
poco := 1; mucho := n; encontrado := false;
while ((poco a[medio]) then poco := medio + 1
else mucho := medio - 1
end;
Ver que el esquema es correcto. ✄
Problema 10.7. Se ha roto un cable maestro de electricidad en algún punto
de su recorrido subterráneo de 50 cuadras. La compañía local de electricidad
puede hacer un pozo en cualquier lugar para comprobar si hasta allí elcable
está sano, y bastará con detectar el lugar de la falla con una precisión de 5m.
Por supuesto, una posibilidad es ir haciendo pozos cada 5m, pero el encargado
no está muy entusiasmado con la idea de hacer tantos pozos, porque hacer
(y después tapar) los pozos cuesta tiempo y dinero, y los vecinos siempre se
quejan por el tránsito, que no tienen luz, etc.
¿Qué lepodrías sugerir al encargado? ✄
Problema 10.8 (El regalo en las cajas). Propongamos el siguiente juego:
Se esconde un “regalo” en una de diez cajas alineadas de izquierda
a derecha, y nos dan cuatro oportunidades para acertar. Después de
cada intento nuestro, nos dicen si ganamos o si el regalo está hacia
la derecha o izquierda.
a) Ver que siempre se puede ganar si nos dan cuatro oportunidades.
b) Simular este juego en la computadora: la computadora elige aleatoriamente
una ubicación para el regalo, y luego en cada elección del usuario el programa
responde si el regalo está en la caja elegida (y termina), a la derecha o a la
izquierda, orientando la búsqueda. Si después de cuatro oportunidades no
se acertó la ubicación, el programa termina dando el número de caja donde
estaba el regalo.

10.3. Métodos elementales de clasificación Pág. 101
c) Cambiar el programa de cuatro a tres oportunidades, y ver que no siempre
se puede ganar.
d) ¿Cuántas oportunidades habrá que dar para n cajas, suponiendo una estrategia
de búsqueda binaria? Sugerencia: la respuesta involucra las funciones
techo y log2. ✄
10.3. Métodos elementales de clasificación
Nuestra próxima tarea consistirá en ver cómo clasificar u ordenar un arreglo
a =(a1,a2,...,an) de elementos no necesariamente distintos, poniendo el
resultado en el mismo arreglo a —tratando de evitar usar otro arreglo—, pero
con sus elementos ordenados de menor a mayor. Para ello veremos tres métodos
elementales para clasificar que podemos relacionar con la forma con que
generalmente cada uno ordena las cartas de un juego:
Inserción directa: Levantamos una carta, buscamos su posición de derecha
a izquierda en el abanico que tenemos en la mano, la colocamos en
el lugar correspondiente y continuamos levantando la próxima carta.
Podemos escribir el algoritmo resultante como:
for i := 2 to n do begin
x := a[i]; a[0] := x; j := i;
while (x < a[j-1]) do begin
a[j] := a[j-1]; j := j-1
end;
a[j] := x
end
✎ Observar el uso de centinela: a debe ser declarado de modo de
admitir a0.
Selección directa: Levantamos las cartas al mismo tiempo (todas juntas),
las abrimos en abanico, y comenzando desde la izquierda buscamos la
menor y la colocamos al principio, luego buscamos la segunda menor
y la ubicamos en la segunda posición, etc.
Acá podemosponer:
for i := 1 to n-1 do begin
k := i; x := a[i];
for j := i+1 to n do
if (x > a[j]) then begin
(* nuevo maximo *)
k := j; x := a[k] end;
a[k] := a[i]; a[i] := x
end
✎ Comparar con el inciso e) delproblema8.2.
Intercambio directo o burbujeo: Aquítambién levantamos las cartas al
mismo tiempo y las abrimos en abanico, pero vamos mirando de derecha
a izquierda buscando un par de cartas consecutivas fuera de
orden y cuando lo encontramos lo invertimos. Seguimos recorriendo

Pág. 102 Búsqueda y clasificación
con la mirada el abanico hasta que no haya ningún par fuera de orden.
Un posible esquema es:
for i := 2 to n do
for j := n downto i do
if (a[j-1] > a[j]) then begin
(* intercambiar *)
x := a[j-1]; a[j-1] := a[j]; a[j] := x
end
✎ Por supuesto en cada uno de los métodos podemos cambiar el sentido del
recorrido, empezando desde la derecha o desde la izquierda.
Problema 10.9 (Métodos elementales de clasificación). Implementar los
algoritmos anteriores como procedimientos en un único programa. Agregar en
cada uno contadores para el número de asignaciones y comparaciones (entre
datos como x o ak ynoentreíndices como i, j o k) hechas en cada caso, y
comparar estas cantidades cuando:
a =(1, 2, 3, 4, 5, 6), a =(6, 5, 4, 3, 2, 1), a =(2, 6, 8, 7, 4, 5, 1, 3, 6, 4). ✄
En el cuadro 10.1 mostramos una comparación entre los tres métodos y el de
“clasificación por fusión” —un método avanzado que explicamos en el problema
15.7— con arreglos de 10 000 enteros construidos de tres formas: ordenado,
ordenado al revés, y aleatorio. Los tiempos en el cuadro son para una máquina
particular (y no demasiado rápida para los estándares cuando se realizaron las
pruebas) y determinado compilador, y debe considerarse sólo la proporción entre
ellos (la cifra 0.00 para el tiempo indica que la fracción de segundo es menor
a1/60 = 0.0166 ...). Se contaron las comparaciones y asignaciones de arreglos
(y no cuando se comparan o asignan índices).
Observamos en la tabla que tanto selección directa como intercambio directo
realizan siempre el mismo número de comparaciones, n(n − 1)/2, y que aún
cuando no se hacen asignaciones (como en el caso de intercambio directo, cuando
el arreglo está ordenado), la enorme cantidad de comparaciones lleva tiempo.
En cuanto a las asignaciones, hemos de destacar que hemos tomado arreglos
de enteros, por lo que individualmente no llevan demasiado tiempo, y en el
caso de inserción directa con un arreglo aleatorio, hay muchas asignaciones pero
—comparando con los otros métodos elementales— no llevan tanto tiempo.
Sería distinto si los elementos fueran arreglos, por ejemplo “strings” al clasificar
palabras, o registros (que veremos un poco más adelante).
Algunos autores usan búsqueda binaria en vez de búsqueda lineal en inserción
directa, disminuyendo en principio el número de comparaciones. Pero las
ventajas son marginales y aún pueden empeorar el algoritmo (ver [16, pág. 87]).
Muchos libros de programación insisten en presentar el método de intercambio
directo o burbujeo —y a veces ningún otro— que es claramente inferior a
cualquiera de los otros: aún en el caso del arreglo ordenado, se hace la misma
cantidad de comparaciones que selección directa, y ninguna asignación, pero ¡el
tiempo es superior! Hemos incluido este método sólo para que el lector sepa
que existe y que es bastante malo: nosotros casi siempre elegiremos el de selección
directa o inserción directa: selección directa hace relativamente pocas
asignaciones, inserción directa relativamente pocas comparaciones.

10.3. Métodos elementales de clasificación Pág. 103
Arreglo ya ordenado
fusión selección intercambio inserción
comparaciones 71 712 49 995 000 49 995 000 9 999
asignaciones 140 000 29 997 0 29 997
tiempo (segs.) 0.00 1.10 1.43 0.00
Arreglo ordenado al revés
fusión selección intercambio inserción
comparaciones 64 608 49 995 000 49 995 000 50 004 999
asignaciones 140 000 25 029 997 149 985 000 50 024 997
tiempo (segs.) 0.00 1.27 1.87 1.45
Arreglo aleatorio
fusión selección intercambio inserción
comparaciones 123 582 49 995 000 49 995 000 25 023 757
asignaciones 140 000 103 894 75 041 274 25 043 755
tiempo (segs.) 0.00 1.10 1.75 0.72
Cuadro 10.1: Comparación de algoritmos de clasificación, para arreglos enteros
de longitud 10000.
Problema 10.10 (Clasificación por conteo). La clasificación es muy sencilla
si sabemos de antemano que el rango de los elementos de a =(a1,a2,...,an) es
pequeño, digamos 1 ≤ ai ≤ m para i =1, 2,...,n.
En efecto, imaginemos que tenemos n bolitas alineadas cada una con un
númeroentre1ym: armamos m cajas numeradas de 1 a m, luego colocamos
cadabolitaenlacajaquetienesunúmero, y finalmente será cuestión de vaciar
los contenidos de las cajas ordenadamente, empezando desde la primera, alineando
las bolitas a medida que las sacamos, como ilustramos en la figura 10.1.
① ③ ③ ② ① ② ① ② ① ③
disposición inicial
①
① ② ③
① ② ③
① ② ③
1 2 3
poniendo en cajas
① ① ① ① ② ② ② ③ ③ ③
disposición final
Figura 10.1: Ordenando por conteo.
En el algoritmo, en vez de “colocar cada bolita en su caja”, contamos las
veces que apareció:

Pág. 104 Búsqueda y clasificación
for k := 1 to m do cuenta[k] := 0;
for i := 1 to n do cuenta[a[i]] := cuenta[a[i]] + 1;
i := 0;
for k := 1 to m do
while (cuenta[k] > 0) do begin
i := i + 1; a[i] := k; cuenta[k] := cuenta[k] - 1 end
a) Ver que el algoritmo es correcto, i.e. al finalizar el arreglo a está ordenado,
aún cuando haya valores r, 1≤ r ≤ m tales que ai = r para todo i.
b) Implementar el algoritmo y comparar su eficiencia con los otros métodos,
poniendo contadores para el número de asignaciones y comparaciones.
c) ¿A lo sumo cuántas asignaciones de arreglos se hacen en este algoritmo (la
respuesta involucra n y m)? ¿Cuándo lo usarías? ✄
Problema 10.11 (Arreglos como conjuntos). Cuando queremos tratar a
un arreglo a =(a1,a2,...,an) como un conjunto, es decir no nos interesan los
elementos repetidos ni el orden, es conveniente primero ordenarlo (de menor a
mayor) y quitar sus elementos repetidos, por ejemplo con el procedimiento del
problema 10.3, para facilitar las operaciones entre conjuntos.
a) Hacer un procedimiento, que a su vez usa un procedimiento de clasificar
y otro de purgar, para “pasar el arreglo a a conjunto” ordenándolo
y “purgándolo”.
✎ Aunque se puede hacer un único procedimiento modificando un procedimiento
de clasificación elemental de modo de eliminar elementos
repetidos, es más sencillo, y desde el punto de vista de la modularidad
más razonable, el llamar a dos procedimientos separados, uno para
clasificar y otro para “purgar”. Así, se puede cambiar, por ejemplo, el
procedimiento de clasificación por uno más conveniente sin tener que
revisar todo el procedimiento de este inciso.
Además, con métodos más avanzados es más eficiente primero clasificar
y luego “purgar” que al revés.
b) Dados dos arreglos a =(a1,a2,...,an) yb =(b1,b2,...,bm), considerados
como conjuntos, hacer un procedimiento para construir el “conjunto intersección”,
i.e. un arreglo ordenado c =(c1,c2,...,cr) con todos los elementos
que están en a y b simultáneamente (pero aparecen en c una sola vez).
Sugerencia: suponiendo que a =(a1,a2,...,an) yb =(b1,b2,...,bm) ya
están ordenados y purgados, una posibilidad es considerar el esquema
i := 1; j := 1; r := 0;
repeat
if (a[i] > b[j]) then j := j + 1
else if (a[i] < b[j]) then i := i + 1
else begin (* a[i] = b[j]: ponerlo en c *)
r := r + 1;
c[r] := a[i];
i := i + 1;
j := j + 1
end
until ((i > n) or (j > m))
Cuando r = 0, los arreglos originales no tienen elementos comunes.

10.4. Registros (Records) Pág. 105
c) Del mismo modo, hacer un procedimiento para construir el “conjunto unión”,
i.e. un arreglo ordenado c =(c1,c2,...,cs) con todos los elementos
que están en a o b (pero aparecen en c una sola vez).
Sugerencia: podría ponerse un arreglo a continuación del otro, haciendo
for i := 1 to n do c[i] := a[i];
for i := 1 to m do c[i+n] := b[i];
y luego “purgar” el arreglo c que tiene longitud m + n.
Otra posibilidad es, si a y b ya están ordenados y clasificados, usar la
“fusión” o “mezcla” del problema 10.4. ✄
10.4. Registros (Records)
En aplicaciones informáticas, y aún en algunas matemáticas como veremos,
es conveniente agrupar la información que tenemos sobre un objeto. Por ejemplo,
para una persona podríamos tener su apellido, nombres, número de identidad,
etc. Una forma de hacerlo es mediante arreglos paralelos, e.g. un arreglo para
los apellidos, otro para los nombres, etc., donde una persona tendría el mismo
índice para cada uno de los arreglos. Otra forma más razonable es el uso de
registros.
Un registro es una estructura que consiste en un número fijo de componentes
llamadas campos. A diferencia del arreglo, las componentes de un registro pueden
ser de diferentes tipos, pero no pueden ser indexados.
Al definir un tipo de registro, se especifica el tipo de cada componente y su
identificador. Por ejemplo, si que queremos trabajar con números complejos de
la forma a + bi,cona, b ∈ R, podemosponer:
type complejo = record re, im: real end;
var z: complejo;
✎ Observar que la declaración del registro termina con “ end ”, pero no hay
un “ begin ”.
El registro ocupa un lugar de memoria donde los campos son consecutivos,
de modo que podemos pensar que el complejo z = a + bi se guarda en una caja
como se muestra en la figura 10.2. Enelejemplo,cada“sub-caja”ocampoes
de tipo real.
a b
re im
Figura 10.2: Esquema del registro de tipo “ complejo ”enmemoria.
Para acceder a una componente del registro, el nombre del registro es seguido
por un punto (“ . ”) y el correspondiente identificador del campo. Así, si
quisiéramos asignar a z el valor 3 + 5 i, pondríamos
z.re := 3; z.im := 5;
Si z ′ es otro número complejo, podemos hacer la asignación
zp := z;

Pág. 106 Búsqueda y clasificación
mientras que la suma z ′′ = z + z ′ puede expresarse como:
zpp.re := z.re + zp.re; zpp.im := z.im + zp.im;
Las dos operaciones válidas para variables de registro
(completas) son la selección de componentes y la
asignación.
Es importante destacar también la localidad de los nombres de los campos
de un registro. La declaración
var a: array[2..8] of integer;
a: real;
es incorrecta, pero la declaración
var a: array[2..8] of integer;
b: record
a: real;
b: boolean
end;
es correcta, pues “ b.a ” indica la componente “ a ”de“b ”, mientras que “ a ”
indica un arreglo.
Cuando trabajamos con un registro en Pascal, es posible acceder directamente
a sus componentes mediante la sentencia “ with ” (en castellano, con).
Por ejemplo, para asignar a z el valor 3 + 5 i, podríamos poner:
with z do begin re := 3; im := 5 end;
Problema 10.12. Suponiendo que declaramos el tipo “ complejo” comomás
arriba:
a) Hacer procedimientos para leer y escribir un complejo por terminal.
b) Recordando que el producto de complejos se define como
(a + bi) × (c + di)=(ac − bd)+(ad + bc) i,
hacer un programa para calcular la suma y el producto de dos complejos
entrados por terminal. ✄
En los dos siguientes problemas, suponemos que el compilador admite el tipo
“ string ”.
Problema 10.13. Supongamos que queremos trabajar con un arreglo de registros,
en cada uno de los cuales se guarda un nombre y un número de identificación.
Declaramos
const MAXN = 20;
type
tipoinfo = record nombre: string; nroid: integer end;
tipoarreglo = array[0..MAXN] of tipoinfo;

10.4. Registros (Records) Pág. 107
Una variante del procedimiento leerarreglo (capítulo 8, pág. 82), para leer
datos es:
procedure leerdatos(var a: tipoarreglo; var n: integer);
function nuevodato: boolean;
begin
if (n > MAXN) then nuevodato := false
else begin
writeln;
write(’Entrar el dato ’, n:2);
writeln(’ (fin = ): ’);
write(’ Entrar el nombre: ’);
if (eoln) then begin readln; nuevodato := false end
else begin
with a[n] do begin
readln(nombre);
write(’ Entrar el numero de id: ’);
readln(nroid)
end;
nuevodato := true
end
end
end;
begin
writeln(’** Entrada de datos’);
n := 1;
while (nuevodato) do n := n + 1;
n := n - 1
end;
Hacer un procedimiento para escribir arreglos de este tipo, y hacer un programa
incorporando ambos procedimientos para probarlos. ✄
Problema 10.14 (Clasificación de arreglos de registros). Supongamos
que hemos hecho las declaraciones del problema 10.13, y queremos clasificar el
arreglo a de tipo “ tipoarreglo”, que puede ser según nombre osegún nroid.
La componente por la cual se clasifica se denomina llave o clave (en inglés
“key”). Por ejemplo si tenemos el registro x con el nombre “ Geri ”yelnúmero
de identidad “ 5 ”, y el registro y con el nombre “ Ana ”ynúmero “ 10 ”, ordenándolos
(de menor a mayor) por nombre vendrá primero y antes que x, pero
si los ordenamos por nroid vendrá primero x.
✎ La comparación de strings se hace como la comparación entre números
(en Pascal), e.g. “ s1 y.z ” donde z puede ser nombre o nroid según el valor de llave.

Pág. 108 Búsqueda y clasificación
b) Modificar alguno de los métodos de clasificación vistos, de modo de poder
clasificar un arreglo de registros, cambiando la comparación entre datos de
la forma x>ypor “ mayor(x, y, llave) ”.
c) Hacer un programa para ingresar el arreglo a y clasificarlo según nombre o
nroid a elección del usuario, escribiendo por pantalla el resultado. ✄
Problema 10.15. Queremos escribir un programa que tome como entradas
caracteres (un carácter por línea y fin de entrada con sin datos),
y como salida escriba los caracteres ingresados y la cantidad de apariciones,
ordenados decrecientemente según la cantidad de apariciones.
Por ejemplo, si la entrada son los caracteres ‘ a ’, ‘ b ’, ‘ c ’, ‘ c ’, ‘ d ’, ‘ b ’, ‘ c ’,
‘ d ’, ‘ c ’, ‘ b ’, ‘ b ’, ‘ c ’, (uno por línea), la salida debe ser algo como:
Caracter Cantidad de apariciones
c 5
b 4
d 2
a 1
Para esta tarea vamos a construir los tipos de datos
type
tipoinfo = record letra: char; cuenta: integer end;
tipoarreglo = array[1..MAXN] of tipoinfo;
A medida que se ingresa una letra la comparamos con las letras ya ingresadas
mediante búsqueda lineal (eventualmente con centinela al final). Si la letra ya
apareció, se incrementa en 1 el campo cuenta correspondiente, en otro caso, se
agrega al arreglo un nuevo registro con la nueva letra, poniendo cuenta =1.
Luego se puede ordenar el arreglo de registros según el campo veces,enforma
similar a la del problema 10.14.
Hacer un programa con estas ideas. ✄
10.5. Problemas Adicionales
Problema 10.16. Hacer un programa para un juego como el del regalo en las
cajas (problema 10.8), pero ahora jugando en un tablero de m × n. El jugador
da las coordenadas (i, j), 1 ≤ i ≤ m, 1≤ j ≤ n, de la casilla que elige y la
búsqueda se orienta dando direcciones hacia donde está el regalo: N, NE, E, SE,
S, SO, O, NO.
Recordando el problema del regalo en las cajas, ¿cuántas oportunidades
habrá que dar en el caso de las m × n casillas? ✄
Problema 10.17. Otra variante del juego de las cajas (problema 10.8) esla
siguiente: Dado un número (entero) entre 1 y 100 (generado aleatoriamente),
tratar de encontrarlo mediante “encajonamiento”, o sea vamos dando números a
y b (a ≤ b) y la computadora nos va respondiendo si el número está a la izquierda
de a, “atrapado” entre a y b, oaladerechadeb. Elnúmero será encontrado
cuando a y b coincidan con el número a acertar, terminando el juego. Hacer un
programa para este juego, y pensar una estrategia para encontrar el número en
“pocas” jugadas. ✄

10.6. Comentarios Bibliográficos Pág. 109
Problema 10.18 (Estabilidad para clasificación). Un método de clasificación
se llama estable si el orden relativo de elementos con llaves iguales
permanece inalterado en el proceso de clasificación.
a) Decidir si el método de clasificación usado en el programa en el problema
10.14 es estable o no, e.g. si ordenando primero por nroid ydespués
por nombre, personas con el mismo nombre aparecen en orden creciente de
nroid.
b) Decidir cuáles de los métodos elementales de clasificación que hemos visto
(inserción directa, selección directa, intercambio directo) son estables. ✄
10.6. Comentarios Bibliográficos
Los temas de búsqueda (con centinela y binaria) y clasificación están tomados
de [16] como mencionamos. Partes de la sección 10.4 están basadas en [7,Cap.7].

Capítulo 11
Recursión
Teniendo en mente las sumas de Gauss (problema 4.13), supongamos que
queremos encontrar todas las sumas
s1 =1, s2 =1+2, s3 =1+2+3, ... sn =1+2+···+ n. (11.1)
Podríamos calcular cada una de ellas separadamente, por ejemplo usando la
fórmula de Gauss an = n × (n +1)/2, pero también podríamos poner
s1 =1, s2 = s1 +2, s3 = s2 +3, ... sn = sn−1 + n. (11.2)
Claro que no habría mucha diferencia con el esquema que vimos en el problema
4.13, en el que cambiando la variable suma por un arreglo tendríamos
suma[0] := 0; for i := 1 to n do suma[i] := suma[i-1] + i
calculando en cada paso del lazo “ for ”lacantidadsi.
Cambiando suma por producto en las ecuaciones (11.1) o(11.2), obtenemos
el factorial (recordar el problema 4.14), y en realidad es usual definir n! como
1! = 1 y n! =n × (n − 1)! para n ∈ N, n>1. (11.3)
Esto es típico de inducción en matemáticas o de recursión en programación:
dar un valor inicial y una “fórmula” para calcular los valores subsiguientes.
Por ejemplo, si queremos calcular 5! usando la ecuación (11.3), tendríamos
sucesivamente:
5! = 5 × 4! = 5 × (4 × 3!) = 5 × 4 × (3 × 2!) =
=5× 4 × 3 × (2 × 1!) = 5 × 4 × 3 × 2 × 1 = 120.
En fin, ya hemos visto este esquema anteriormente, por ejemplo al calcular la
función cm = saldo(c, r, p, m) enelproblema7.5 según la ecuación (7.1), donde
c0 = c.
11.1. Funciones y procedimientos definidos recursivamente
En los problemas siguientes vamos a encontrar varios ejemplos que anteriormente
resolvíamos con un lazo “ for ” o similar, ahora reescritos en forma
recursiva.

11.1. Funciones y procedimientos definidos recursivamente Pág. 111
Problema 11.1 (Factorial recursivo). El siguiente esquema muestra una
función recursiva, i.e. que se llama a sí misma, para calcular n!, basado en la
ecuación (11.3):
function factorial(n: integer): integer;
begin
if (n > 1) then factorial := n * factorial(n - 1)
else factorial := 1
end;
✎ Observar que la variable “sobre la que se hace la recursión”, en este caso
n, no tiene antepuesta la palabra “ var ”enladefiniciónde la función. No
tiene sentido hacerlo, pues cuando llamamos factorial(n−1), n−1 notiene
asignado un lugar (aunque lo tenga n): n − 1 tiene que pasarse por valor y
no referencia.
✎ Ahora podemos apreciar un poco más por qué la función (o procedimiento)
no es una variable local a la función (recordar problema 7.2.d)).
a) Hacer un programa para calcular n! usando la función anterior.
b) Obtener el máximo valor de n para el cual se puede calcular n! (i.e. n! ≤
maxint) enlaversióndel inciso a).
En vista de este resultado, es conveniente cambiar el tipo de los valores
retornados por factorial de “ integer ”a“real ” en la función en a) (como
hemos hecho en los problemas 4.13 y 4.14).
c) Lafórmula de Stirling establece que cuando n es bastante grande,
n! ≈ n n e −n√ 2πn.
Hacer un programa para calcular esta aproximación, y probarla con n =
10, 100, 1000. Comparar con los resultados obtenidos en a) (habiendo hecho
las modificaciones indicadas en la nota del inciso b)). ✄
Expliquemos un poco cómo funciona recursión.
Una función o procedimiento que no usa recursión(nosellamaasímisma),
ocupa un lugar en la memoria al momento de correr el programa. Ese
lugar contiene las “cajas” correspondientes a sus variables locales, y también
las instrucciones que debe seguir (recordar la figura 7.2, pág. 75).
Cuando la función o procedimiento se llama a sí misma, podemos pensar
que al ejecutarse el programa se generan automáticamente copias de la función
(tantas como sean necesarias), cada copia con sus propios lugares para código
y variables locales. Cuando la copia de la función o procedimiento que ha sido
llamada por la recursión termina su tarea, el espacio es liberado. Este espacio de
memoria usado por recursión no está reservado por el programa en el momento
de compilar (como sucede con los arreglos y las funciones declaradas), pues no
puede saber de antemano cuántas veces se usará la recursión. Por ejemplo, para
calcular n!, se necesitan unas n copias de la función: cambiando n cambiamos el
número de copias necesarias. Este espacio de memoria especial se llama “stack”
o “pila”, estructura que veremos también en el problema 11.5 yunpocomás
formalmente en la sección 12.1.
✎ Un resultado de computación teórica dice que toda función o procedimiento
recursiva puede reescribirse sin usar recursión con lazos “ while ” y arreglos
(que se usan como “pilas” para ir guardando los datos intermedios).

Pág. 112 Recursión
Problema 11.2. Rehacer el problema 7.5, cambiando la definición de la función
saldo a una recursiva, según la ecuación (7.1). ✄
La recursión también puede usarse en procedimientos:
Problema 11.3. Hacer un programa implementando la clasificación por selección
directa (pág. 101) como un procedimiento recursivo, declarando el procedimiento
como “ seleccion(var a: arreglo; n: integer) ” y haciendo recursión
en n, colocando el mayor elemento en la posición final antes de llamar al
procedimiento con n − 1(vertambién el problema 8.2.e)). ✄
La recursión se puede usar en más de un argumento, i.e. no siempre se “llama
a la función con n − 1” (ver también el problema 11.7):
Problema 11.4. Para m, n ∈ N, consideremos una cuadrícula rectangular de
dimensiones m × n (4 × 3enlafigura11.1), e imaginémosnos que se trata
de un mapa, donde los segmentos son calles y los puntos remarcados son las
intersecciones.
1 4 10 20 35
1
1
3
2
6
3
10
1 1 1 1
Figura 11.1: Contando la cantidad de caminos posibles.
Nos preguntamos de cuántas maneras podremos ir desde la esquina más
hacia el sudoeste, de coordenadas (0, 0), a la esquina más hacia el noreste, de
coordenadas (m, n), si estamos limitados a recorrer las calles únicamente en
sentido oeste–este o sur–norte, según corresponda.
Para resolver el problema, podemos pensar que para llegar a una intersección
hay que hacerlo desde el oeste o desde el sur (salvo cuando la intersección estáen
el borde oeste o sur), y por lo tanto la cantidad de caminos para llegar a la
intersección es la suma de la cantidad de caminos llegando desde el oeste (si
se puede) más la cantidad de caminos llegando desde el sur (si se puede). Los
números en la figura 11.1 indican, para cada intersección, la cantidad de caminos
para llegar allí desde(0, 0) mediante movimientos permitidos.
a) Hacer un programa para calcular la cantidad h(m, n) de caminos para llegar
desde (0, 0) a (m, n), donde m y n son ingresados por el usuario.
b) En cursos de matemática discreta se demuestra que
h(m, n) =
(m + n)!
m! n!
4
(m + n) × (m + n − 1) ×···×(m +1)
= .
n × (n − 1) ×···×1
Incorporar al programa del inciso anterior una función con el cálculo de
h(m, n) (por ejemplo, con un lazo) y comparar con el obtenido anteriormente.
15
5

11.2. Los Grandes Clásicos de la Recursión Pág. 113
c) Modificar el programa del inciso a) demododecalcularlacantidadde
caminos cuando la intersección (r, s) estábloqueada y no se puede pasar
por allí, donde r y s son ingresados por el usuario (0

Pág. 114 Recursión
Tapa del juego original Fotografía del juego
Figura 11.2: Las torres de Hanoi.
type aguja = array[0..10] of integer
y declarar, por ejemplo, var a, b, c: aguja. Usamos la posición 0 para guardar
la cantidad de discos en la aguja (e.g a0 = na), y las siguientes posiciones,
(a1,a2,...,ana), para indicar que en la posición 1 (la de más abajo) de la aguja a
estáeldiscoa1, enla2eldiscoa2, etc. Inicialmente será a =(n, n, n−1,...,2, 1)
(de mayor a menor), b =(0,...)yc =(0,...).
Si hay n discos en la aguja a, y ninguno en la agujas b y c, para poner el
disco más grande en la aguja b, habráque poner los n − 1 restantes en la aguja
c primero, después colocar la n-ésima en la aguja b, y volver a poner los n − 1
en la aguja b. Paramoverlosn−1delaaguja a a la aguja c, habráquemover
n − 2 a la aguja b, pasar el n − 1alaagujac,...
a) Definir un procedimiento pasar (k, x, y, z) que “pase” k discos de la aguja
x alay usando la z (2) , imprimiendo los discos que hay en cada aguja al
terminar.
Sugerencia: parak =1sólo hay que mover la aguja que está enlacimade
x hacia y, yparak>1, podemos poner pasar (k, x, y, z) como consistente
de los siguientes pasos:
pasar(k-1,x,z,y); pasar(1,x,y,z); pasar(k-1,z,y,x)
Sugerencia si la anterior no alcanza:
procedure pasar( k: integer; var x, y, z: aguja);
(* pasar k discos de x a y, usando z *)
begin
if (k > 1) then begin
pasar(k-1, x, z, y);
pasar(1, x, y, z);
pasar(k-1, z, y, x)
end
else begin (* pasar una de x a y *)
y[0] := y[0] + 1; y[y[0]] := x[x[0]]; x[0] := x[0] - 1;
imprimir
end
end;
donde hemos supuesto un procedimiento imprimir que imprime los elemen-
(2) Con movimientos permitidos: recordar que el disco a pasar de una aguja a otra debe ser
menor que cualquier otro disco en esas agujas.

11.2. Los Grandes Clásicos de la Recursión Pág. 115
tos que tiene cada arreglo (hasta la longitud correspondiente). Observar que
k se pasa por valor, pero x, y y z se pasan por referencia: los arreglos pueden
modificarse en el procedimiento.
b) Usar el procedimiento del inciso anterior en un programa que imprima una
sucesión de movimientos para transferir n discos de una aguja a otra. Verificar
el programa para n =1, 2, 3, 4, 5.
c) Agregar un contador para contar la cantidad de veces que se transfiere un
disco de una aguja a otra (en pasar ), e imprimirlo al terminar el programa.
En base a este resultado (para n =1, 2, 3, 4, 5) conjeturar la cantidad
de movimientos necesarios para transferir n discos de una aguja a otra, y
demostrarlo.
Sugerencia: 2 n − 1=1+2+4+···+2 n−1 =1+2(1+2+···+2 n−2 )=
1+2(2 n−1 − 1).
d) Suponiendo que transfieren un disco por segundo, ¿cuánto tardarán los monjes
en transferir los 64 discos? ¿Cuántos años tardaría una computadora en
calcular la solución para n = 64, suponiendo que tarda un nanosegundo por
movimiento (3) (nano = dividir por mil millones)? Bajo la misma suposición
sobre la velocidad de la computadora, ¿cuál es el valor máximo de n para
calcular los movimientos en 1 minuto?
✎ La suposición que lo que tarda la computadora por movimiento es
independiente de n es una aproximación muy buena. Si es posible,
comprobarla (tomando por ejemplo n =19, 20,...), sin imprimir los
movimientos, y estimar lo que tarda la computadora por movimiento
en cada caso (del orden de micro segundo, micro = dividir por un
millón).
✎ En el problema 11.9 se da una variante para resolver el problema de las
torres de Hanoi sin usar arreglos.
✎ La estructura que estamos usando para los arreglos, agregando atrás y
sacando también desde atrás, es un ejemplo de pila (como la de platos),
sobre la que hablaremos más en la sección 12.1.
Hay muchas variantes del problema de las torres de Hanoi, por ejemplo:
¿qué pasa si los discos no están inicialmente todos sobre una misma aguja
(pero respetan la distribución de mayor a menor)?, ¿qué pasa si hay más de
tres agujas? ✄
Problema 11.6 (Números de Fibonacci). En 1202 Fibonacci propuso el
siguiente problema en su libro Liber Abaci:
¿Cuántos pares de conejos se producen a partir de una única pareja
en un año si cada mes cada par de conejos da nacimiento a un nuevo
par, el que después del segundo mes se reproduce, y no hay muertes?
a) Resolver el problema.
Los números que aparecen en la solución de este problema se conocen como
números de Fibonacci, definidos recursivamente como:
f1 =1, f2 =1, y fn = fn−1 + fn−2 para n ≥ 3.
(3) ¡Y que no hay cortes de luz!

Pág. 116 Recursión
b) Hacer un programa para calcular los números de Fibonacci:
i) Usando recursión sobre dos parámetros con dos condiciones iniciales.
ii) Sin usar recursión. Sugerencia: un esquema posible como función es
a := 1; b := 1;
for i := 3 to n do begin c := a + b; b := a; a := c end;
fibonacci := a
c) La fórmula de Euler-Binet establece que
2n √ . (11.4)
5
Créase o no, el miembro derecho es un número entero (¿podrías decir por
qué, si no supieras el resultado?).
Implementar el miembro derecho de esta igualdad como función y comparar
con los resultados del inciso anterior.
d) Según la fórmula 11.4, fn crece exponencialmente, porloquerápidamente
toma valores muy grandes, y al implementarse como función debe retornar
valores de tipo “ real ” (como en el caso de n!). Encontrar el máximo n tal
que fn ≤ maxint.
fn = (1 + √ 5) n − (1 − √ 5) n
Leonardo Bigollo es el verdadero nombre de Leonardo de Pisa (1180–1250),
también conocido como Fibonacci (contracción de las palabras “hijo de Bonacci”).
Además de “Liber Abaci”, publicó numerosos tratados sobre teoría de
números, geometría y la relación entre ellos. Sin embargo, fue prácticamente
ignorado durante la Edad Media, apareciendo sus resultados nuevamente publicados
(por Maurico) unos 300 años después.
Jacques Binet (1786–1856) publicó lafórmula para los números de Fibonacci
en 1843, pero ya había sido publicada por Leonhard Euler (1707–1783)
en 1765. Sin embargo, aún antes A. de Moivre (1667–1754) la había publicado
(y en forma más general) en 1730.
Mucho después de Fibonacci, se observó quelosnúmeros fn aparecen en
muy diversos contextos, algunos insospechados como en la forma de las flores
del girasol, y son de importancia tanto en las aplicaciones prácticas como
teóricas. Por ejemplo, han sido usados para resolver problemas de confiabilidad
de comunicaciones.
En cuanto a aplicaciones teóricas, vale la pena mencionar que en el Congreso
Internacional de Matemáticas de 1900, David Hilbert propuso una serie
de problemas que consideró de importancia para resolver durante el siglo XX.
Entre ellos, el décimo pide encontrar un algoritmo para determinar si un polinomio
con coeficientes enteros, arbitrariamente prescripto, tiene raíces enteras
(resolver la ecuación diofántica asociada). Recién en 1970 pudo obtenerse una
respuesta al problema, cuando el matemático ruso Yuri Matijasevich (quien
tenía 22 años) demostró que el problema es irresoluble, es decir, no existe algoritmo
que pueda determinar si una ecuación diofántica polinomial arbitraria
tiene soluciones enteras. En su demostración, Matijasevich usa la tasa de crecimiento
de los números de Fibonacci. ✄
11.3. Problemas Adicionales
Problema 11.7. Usando recursión, reescribir el algoritmo de Euclides (sección
5.2.2) para encontrar el máximo común divisor entre dos enteros positivos.
Sugerencia: mcd(a, b) =mcd(a − b, b) sia>b. ✄

11.3. Problemas Adicionales Pág. 117
Problema 11.8. En este problema queremos encontrar los factores primos de
n ∈ N usando recursión.
a) Podemos probar si 2 divide a n y en caso afirmativo probar nuevamente si
2 divide a n/2, o bien probar con 3, y así sucesivamente, imprimiendo cada
factor encontrado:
procedure factorizar(n, k: integer);
begin
if (n > 1) then
if ((n mod k) = 0) then begin
write(k:10);
factorizar(n div k, k)
end
else factorizar(n, k+1)
end;
haciendo la llamada “ factorizar(n,2)” enlaparteprincipal.
✎ Refiriéndonos a comentarios anteriores, observar que en el procedimiento
n y k son llamados por valor y no referencia.
i) Ver que el procedimiento es correcto y que, en particular, los números
que se imprimen son siempre primos.
ii) Hacer un programa para escribir los factores de n ∈ N, n>1, usando
este procedimiento.
b) Recordando los problemas 5.19 y 5.20, ver que se puede mejorar el procedimiento
del inciso anterior a:
procedure factorizar(n, inic: integer);
var x: real;
begin
x := sqrt(n);
while ((inic x) then writeln(n:10) (* n es primo *)
else begin
write(inic:10);
factorizar(n div inic, inic)
end
end; ✄
Problema 11.9 (Torres de Hanoi sin arreglos). Flor, que siempre le lleva
la contra al profe y está compitiendo con él, hizo un programa para resolver el
problema de las torres de Hanoi sin usar arreglos. Más aún, ¡cambió arreglos
por caracteres!:
program hanoisinarreglos(input, output);
(*
Solucion recursiva de las torres de Hanoi,
sin usar arreglos.
*)
type aguja = char;

Pág. 118 Recursión
var n: integer;
procedure pasar( n: integer; x, y, z: aguja);
(* pasar n discos de x a y usando z *)
begin
if (n > 1) then begin
pasar(n-1, x, z, y);
write(’pasar el disco ’, n:1);
writeln(’ de "’, x, ’" a "’, y,’"’);
pasar(n-1, z, y, x)
end
else begin
write(’pasar el disco 1’);
writeln(’ de "’, x, ’" a "’, y,’"’)
end
end;
begin
writeln(’** Problema de las torres de Hanoi:’);
writeln(’ Pasar n discos de la aguja "a" a la "b"’);
write(’ usando la "c", mediante movimientos ’);
writeln(’ permitidos.’);
writeln;
write(’ Entrar el numero de discos: ’); readln(n);
writeln;
pasar(n, ’a’, ’b’, ’c’);
writeln; writeln(’** Fin **’)
end.
¿Es correcto el programa de Flor? ¿Por qué? ✄
Problema 11.10. Recordando la fórmula de Euler-Binet (11.4), comparar el
número de Fibonacci fn con el redondeo (“ round ”) de
(1 + √ 5) n
2n √ .
5
¿A partir de qué n son iguales?, ¿podrías decir por qué? ✄
11.4. Comentarios Bibliográficos
y
Las fotografías en la figura 11.2 están tomadas de
http://www.cs.wm.edu/~pkstoc/
http://en.wikipedia.org/wiki/Tower of Hanoi
respectivamente.

Capítulo 12
Generando objetos
combinatorios
Muchos de los problemas que vimos en el capítulo anterior se pueden reescribir
sin recursión con lazos “ for ”, como el factorial, selección directa, los
números de Fibonacci, o aún la cantidad de caminos del problema 11.4, ynos
quedamos con la impresión de que recursión no es muy útil. Otro problema muy
distinto al de contar objetos es generarlos, por ejemplo para encontrar alguno o
todos los que satisfacen cierto criterio, y aquí es donde recursión muestra toda
su potencia.
Puesto que el número de objetos a generar puede ser muy grande, como
2 n o n!, es conveniente no tener —por ejemplo— un arreglo para cada uno de
ellos, sino tener uno solo que se va modificando a medida que vamos creando
los objetos. Una estructura particularmente útil para esta modificación es la de
“pila”, con la que comenzamos.
12.1. Pilas y colas
Las pilas, como las de platos, y las colas, como las de supermercados, son dos
estructuras familiares que trataremos de formalizar un poco aquí, más que nada
para poner en perspectiva lo que estamos haciendo y no siendo estrictamente
rigurosos.
Tanto en pilas como en colas podemos pensar que tenemos una serie de
objetos —todos del mismo tipo— esperando en línea a ser tratados. En el caso
de la pila, o cola lifo, por “last in first out”, el último en llegar es el primero en
ser tratado. En cambio en lo que denominamos comúnmente cola (sin aditivos),
omás formalmente cola fifo, por “first in first out”, el primero en llegar es el
primero en ser tratado.
No es difícil imaginar distintas acciones comunes:
Crear o inicializar la cola, construyendo la cola “vacía”.
Agregar un elemento, ubicándolo al final y actualizando la cola.
Quitar un elemento, tomando, según corresponda, el primero o el último
y actualizando la cola.

Pág. 120 Generando objetos combinatorios
Destruir la cola, cuando no la necesitamos más, limpiando lo que ensuciamos.
En fin, podríamos agregar otras, como averiguar el estado de la cola (si
está vacía o llena).
Es tradicional en computación llamar con distintos nombres a estas acciones,
según se trate de una pila o cola. Por ejemplo, agregar el elemento a en una pila
se llama push yenlacolaput. En cambio, el quitar un elemento se llama pop
para pilas y get para colas.
No es casualidad que put y get sean nombres en Pascal de funciones o procedimientos
para entrada o salida (que no cubriremos, siendo más “primitivas”
que read y write). Efectivamente, la entrada y salida en la computadora se
implementan como colas fifo: los datos se leen o escriben en el orden en que
van surgiendo. Dado que put y get tienen significados especiales en Pascal, es
conveniente evitar estos nombres.
El concepto de cola, que tiene muchísimas generalizaciones, constituye un
tipo de datos abstracto (TDA): no importa tanto cómo se va a implementar o
representar en la máquina, sino saber que contamos con las operaciones de crear
o destruir la cola, agregarle o quitarle un elemento, etc.
Sin embargo, la implementación de una cola como “fifo” o “lifo” puede tener
consecuencias decisivas en los algoritmos, como veremos en el capítulo 13.
Además, en lenguajes no tan abstractos como Pascal, debemos tener cuidado en
la implementación de TDA’s. En el capítulo 14 introduciremos punteros y listas
encadenadas de Pascal, que son más apropiados para implementar colas, pero a
fin de no complicar la presentación, por ahora “nos arreglaremos con arreglos”.
Como sabemos, si queremos trabajar con un arreglo tenemos que declararlo
al comienzo, dando su dimensión y el tipo de elementos. Por lo tanto, si vamos a
representar una cola con un arreglo, no podemos “crearlo de la nada”, y tenemos
que prever su existencia y dar una dimensión adecuada al problema. Del mismo
modo, no podemos “destruirlo”, y nos limitaremos a ignorarlo cuando no lo
necesitemos más.
Suponiendo que hemos declarado el tipo “ dato ”, que puede ser un registro
u otro arreglo, podemos implementar una pila declarando
pila: array[1..MAXP] of dato
donde MAXP es una constante apropiada. Si npila es la cantidad de elementos,
declarado con la misma localidad que pila, podemos hacer:
Crear la pila:
procedure inicializar;
begin npila := 0 end;
Agregar d:
procedure push(d: dato);
begin
if (npila < MAXP) then begin
npila := npila + 1; pila[npila] := d
end
end;

12.2. Generando Subconjuntos Pág. 121
✎ Siguiendo con la filosofía de no poner en general mensajes de
aviso, tratando de ver el bosque y no el árbol, no hemos agregado
acciones para el caso en que npila = MAXP antes de
incorporar el dato.
Quitar un elemento:
function pop: dato;
begin
if (npila > 0) then begin
pop := pila[npila]; npila := npila - 1
end
end;
✎ Valen los mismos comentarios anteriores: no hemos previsto acciones
para cuando se quiera sacar un elemento de una cola
vacía. En general, preguntaremos si hay elementos antes de sacar.
Observar la simetría entre las acciones de push y pop: una realiza exactamente
los pasos inversos de la otra. Esta simetría se traslada a que push es un
procedimiento con el dato como parámetro, mientras que pop es una función
que devuelve el dato (y por lo tanto debe hacerse alguna asignación o similar).
Para colas (fifo), las cosas son ligeramente diferentes. En vez de tener un índice
como en el caso de la pila, mantenemos dos: uno, digamos ppocola,señalando
el principio de la cola en el arreglo, y otro, digamos fincola, señalando el final.
fincola se incrementa al agregar un dato, mientras que ppocola aumenta cuando
se extrae un dato, de modo que los elementos “vivos” en principio estarán entre
ppcola y fincola (inclusivo en ambos casos).
Claro que si la cola está definida como un arreglo de MAXC elementos,
las cosas se complican cuando agregamos más de MAXC elementos a la cola
(aún cuando hayamos quitado algunos), y necesitamos usar aritmética módulo
MAXC . No entramos en detalles porque en los ejemplos que daremos en
los capítulos posteriores supondremos que MAXC es lo suficientemente grande
como para evitar este problema.
Volviendo a las pilas, no podemos dejar de observar que los procedimientos
inicializar y push son viejos conocidos que usamos al leer los datos de un arreglo,
por ejemplo en el programa maximocaracter (pág. 192). También hemos visto
un atisbo del uso de pilas en el problema 11.5 de las torres de Hanoi, donde las
agujas eran pilas en sí.
En la próxima sección veremos que la técnica de mezclar recursión con pilas
puede usarse para generar distintos objetos combinatorios, aunque las pilas no
siempre aparecerán explícitamente.
12.2. Generando Subconjuntos
Problema 12.1. Supongamos que queremos imprimir todas las cadenas de bits
(arreglos de 0’s y 1’s) de longitud n. Dado que las cadenas de bits de longitud
n se obtienen agregando un 0 o un 1 a las cadenas de longitud n − 1, podríamos
declarar un arreglo global a como
a: array[1..10] of integer,

Pág. 122 Generando objetos combinatorios
donde iremos construyendo las cadenas, y hacer la llamada en el cuerpo principal
a“cadena(1)”, donde cadena está dadapor:
procedure cadena(k: integer);
var i, j: integer;
begin
for i := 0 to 1 do begin
a[k] := i; (* poner 0 o 1 en el lugar k *)
if (k < n) then cadena(k+1)
else begin
(* imprimir la cadena cuando k = n *)
write(’ ’);
for j := 1 to n do write(a[j]:1);
writeln
end (* else *)
end (* for *)
end;
Observar que usamos al arreglo a como una pila. Para k fijo, el elemento
en la posición k tiene un valor de 0 cuando i = 0, que se mantiene para valores
superiores a k pero luego es cambiado para i = 1, y obviamente cambia
varias veces cuando es llamado desde valores inferiores a k. Sin embargo, k es
el parámetro del procedimiento y no una variable global.
a) Hacer una prueba de escritorio del procedimiento cuando n =3.
b) Hacer un programa que dado n ∈ N imprima todas las cadenas de bits de
longitud n, siguiendo las indicaciones anteriores.
c) Agregar un contador (global) para contar las cadenas de longitud n, yver
que la cantidad de cadenas es 2n .
d) En el procedimiento cadena propuesto, se va “hacia adelante”, llamando
a“cadena(1) ” en el cuerpo principal y se va aumentando el valor del
parámetro k en cada llamada del procedimiento hasta llegar a k = n, ya
que n es global. Esto contrasta con el uso de recursión de, por ejemplo, el
factorial, donde vamos “hacia atrás” disminuyendo el valor del parámetro en
cada llamada. ¿Cómo podría redefinirse el procedimiento de modo de hacer
la llamada “ cadena(n)” en el cuerpo principal, y que en vez comparar k
con n se compare con 0 o 1?
✎ En el problema 12.7 vemos otra forma de encontrar las cadenas de bits, sin
usar recursión. ✄
Problema 12.2 (Subconjuntos). En el problema anterior esencialmente se
construyen todos los subconjuntos de {1, 2,...,n}, ya que las cadenas de bits de
longitud n se pueden considerar como vectores característicos. Dado un conjunto
A ⊂ {1, 2,...,n} definimos su vector característico, b(A) = (b1,b2,...,bn),
mediante
1 si i ∈ A,
bi =
0 si no.
Es claro que dos conjuntos distintos tienen vectores característicos distintos,
y que por otro lado, dada una cadena de bits podemos encontrar un conjunto
A tal que b(A) sea esa cadena. Por lo tanto, hay una correspondencia biunívoca
entre cadenas de bits de longitud n y subconjuntos de {1, 2,...,n}.

12.2. Generando Subconjuntos Pág. 123
Modificar el programa del problema 12.1 para que en vez de imprimir cadenas
de bits, imprima el subconjunto correspondiente en {1, 2,...,n}, representando
al conjunto vacío con una raya “ - ”.
Por ejemplo, si n = 2 la salida debería ser algo como:
- 1 2 1 2 ✄
Una vez que sabemos cómo generar una familia de objetos, es más sencillo
generar o contar objetos de la familia con características particulares. Por
ejemplo:
Problema 12.3. Supongamos que queremos contar la cantidad h(n) de cadenas
de n bits que no contienen dos 0’s sucesivos:
a) Hacer un programa para calcular h(n) paran∈N, usando el programa
del problema 12.1 y una variante de búsqueda lineal para encontrar dos 0’s
consecutivos en cada cadena construida, verificando si se trata de una cadena
válida antes de aumentar el contador. Sugerencia: recordar el problema 9.3.
b) Comparar el número h(n) obtenido anteriormente con los números de Fibonacci
y hacer un nuevo programa para calcular h(n) directamente. ✄
Problema 12.4. En este problema imprimiremos todos los caminos que hemos
contado en el problema 11.4. Para ello consideramos una arreglo global camino
en el que guardaremos las “intersecciones” o “esquinas” por las que hay que
pasar. Como éstas tienen dos coordenadas, digamos x y y, declaramos
type esquina = record x, y: integer end;
y
camino: array[1..MAXK] of esquina;
donde MAXK es una constante para la máxima longitud del camino. En el problema
original todos los caminos tienen longitud m+n,peropodrían ser distintas
si, por ejemplo, también consideráramos la posibilidad de ir en diagonales de
suroeste a noreste. Para nuestros ejemplos, 10 o 20 son valores razonables para
MAXK .
También consideramos a los datos m y n como variables globales, y agregamos
la variable global k que indicará la longitud del camino construido. Inicialmente
tendremos k = 0, puesto que no tenemos camino.
El trabajo lo hará el procedimiento llegardesde, haciendo la única llamada
“ llegardesde(0,0)” enelcuerpoprincipal:
procedure llegardesde(i, j: integer);
var r: integer;
begin
k := k + 1;
with camino[k] do begin x := i; y := j end;
if (i < m) then llegardesde(i+1,j);
if (j < n) then llegardesde(i,j+1);
if ((i = m) and (j = n)) then (* llegamos *)
begin
(* imprimir *)
write(’ ’);
for r := 1 to k do

Pág. 124 Generando objetos combinatorios
with camino[r] do
write(’ (’, x:1, ’,’, y:1, ’)’);
writeln
end; (* if i = m and j = n *)
k := k - 1
end;
Estudiemos este procedimiento, haciendo una “prueba de escritorio” en todo
caso:
• k, inicialmente en 0, se incrementa en 1 al entrar al procedimiento, y se
incorpora la intersección (i, j) alcamino en la (nueva) posición k.
Es decir, k indica la cantidad de objetos en la pila camino. Al comienzo,
la pila está vacía, y se van incorporando elementos atrás.
A diferencia del problema 12.1, k es global y no el parámetro del procedimiento.
• Si i

12.3. Generando permutaciones Pág. 125
y por lo tanto no lo haremos aquí, que si el conjunto tiene n elementos entonces
hay n! permutaciones posibles.
Problema 12.5 (Generación de permutaciones). En este problema, copiando
las ideas de los problemas anteriores, generamos todas las permutaciones
de {1, 2,...,n} usando el procedimiento poner :
procedure poner(k: integer);
(* poner en la posicion k los que faltan *)
var j: integer;
begin
if (k < n) then
(* buscar y agregar los que faltan *)
for j := 1 to n do begin
if (falta[j]) then begin
falta[j] := false; a[k] := j;
poner(k+1); (* ir a proxima posicion *)
falta[j] := true (* borrar huellas *)
end (* if *)
end (* for *)
else (* k = n: nueva permutacion *)
begin
(* buscar y agregar el que falta *)
j := 0; repeat j := j + 1 until falta[j];
a[n] := j;
(* imprimir *)
write(’ ’); for j := 1 to n do write(a[j]:3);
writeln
end
end;
donde a es un arreglo global en el que guardamos la permutación que estamos
construyendo, y falta es un arreglo cuyos elementos son de tipo “ boolean ”(y
tiene la misma longitud de a), de modo que falta i es falso o verdadero de acuerdo
asielelementoi ya ha sido colocado o no (respectivamente) en la permutación.
Observamos que
• Los arreglos a y falta deben tener una longitud adecuada. 10 es suficiente
para nosotros.
• n debe ser una variable global. En cambio, k es el parámetro del procedimiento,comoenelproblema12.1.
• Inicialmente “faltan” todos los elementos en la permutación, i.e. falta i es
verdadero para todo i =1,...,n.
• En cualquier paso, cuando se agrega el elemento j en la posición k (k

Pág. 126 Generando objetos combinatorios
los valores en lugares arbitrarios y en cada momento son importantes todos
los valores, no sólo los primeros.
• Se hace la única llamada “ poner(1) ”enelcuerpoprincipal.
a) Usando las ideas anteriores, hacer un programa para generar todas las permutaciones
de n elementos.
b) En el procedimiento poner , al buscar los elementos que faltan se pone
if (k < n) then
for j := 1 to n do begin
if (falta[j]) then begin
.
end (* if *)
end (* for *)
¿Qué función cumple el par “ begin-end” que encierra a “ if ” (el primer
“ begin ”conelúltimo “ end ”) en este caso?, ¿es redundante?
¿Sería equivalente poner
if (k < n) then begin
for j := 1 to n do
if (falta[j]) then begin
.
end (* if *)
end (* if *) ?
c) Eliminar (comentándolo) el renglón “ falta[j] := true ” del procedimiento
poner , y comprobar el comportamiento.
d) Agregar un contador, como en los problemas anteriores, a fin de ir contando
las permutaciones obtenidas, imprimiendo cada permutaciónconsunúmero
de orden.
✎ Hay varios algoritmos para generar las permutaciones de {1,...,n}, algunos
bastante diferentes al que presentamos, y otros más eficientes. Observar
que con el presentado, las permutaciones obtenidas están ordenadas “lexicográficamente”,
cosa que no ocurre en otros algoritmos. ✄
12.4. Árboles binarios ordenados
Como mencionáramos al presentar los métodos de clasificación en la sección
10.3, una de las mayores causas de ineficiencia al clasificar es el “movimiento”
de datos, problema que se agudiza al mover “grandes” datos como
arreglos o registros. En esta sección nos preocuparemos por dar un método donde
clasificamos datos pero una vez construido un registro éste “no se mueve”.
Hasta ahora nos hemos concentrado en la estructura “lineal” de los arreglos
para guardar información, como se ilustra en la figura 12.1, donde cada punto
o nodo representa un elemento del arreglo, y las flechas señalan al siguiente
elemento.
Figura 12.1: Una estructura “lineal”.

12.4. Árboles binarios ordenados Pág. 127
Pero podemos pensar en una configuración como la de la figura 12.2, donde
también tenemos nodos unidos por flechas. Los nodos están en distintos “pisos”
o niveles, marcados por las rectas punteadas (sí, a medida que bajamos el nivel
aumenta).
nivel 0
nivel 1
nivel 2
nivel 3
Figura 12.2: Un árbol binario ordenado.
Si tuviéramos nodos hasta un nivel k, vemos que para ir desde el punto
superior a cualquier otro usando los segmentos, necesitamos a lo sumo k pasos.
Por lo tanto, podemos ir desde cualquier punto a otro cualquiera en a lo sumo
2k pasos, aún cuando puede haber hasta
1+2+4+···+2 k =2 k+1 − 1
nodos. Esta observación es muy importante si guardamos y buscamos datos en
los nodos: la diferencia entre las estructuras de las figuras 12.2 y 12.1 es similar
a la que hay entre búsqueda binaria y búsqueda lineal.
Unaestructuracomoladelafigura12.2 se llama árbol binario ordenado
o simplemente árbol binario (1) .Elnododemás arriba (en el nivel 0) se llama
raíz, y cada nodo está conectadohaciaabajocon0,1o2(ynomás) hijos, ala
izquierdaoaladerecha.
✎ El nombre de árbol binario ordenado parece un poco largo. Informalmente,
se llama árbol por la forma de “ramas”, aunque la raíz se representa arriba,
binario porque cada rama se divide en a lo sumo 2, y ordenado porque
distinguimos entre el hijo a la izquierda y a la derecha.
✎ Como vimos, un árbol binario con k niveles puede tener hasta 2 k+1 − 1
nodos. En contrapartida, si tiene exactamente k niveles, no puede tener
menos de k + 1 nodos.
Veamos cómo usar esta estructura para guardar información.
Supongamos que, como en el problema 10.15, ingresamos letras, por ejemplo
‘ b ’, ‘ d ’, ‘ c ’, ‘ d ’, ‘ a ’, ‘ d ’, ‘ a ’, ‘ a ’, ‘ d ’, ‘ e ’, ‘ d ’, ‘ e ’, ‘ a ’, ‘ b ’, ‘ a ’,
en ese orden, y queremos imprimir la cantidad de veces que apareció cada una
de ellas, pero ordenadas alfabéticamente, i.e. queremos una salida como
Caracter Cantidad de apariciones
a 5
b 2
c 1
d 5
e 2
(1) Sólo veremos árboles binarios ordenados.

Pág. 128 Generando objetos combinatorios
Si declaramos, en forma similar al problema 10.15,
type
tipodato = char; (* el tipo de datos a ingresar *)
nodo = record
llave: tipodato; (* dato *)
cuenta: integer (* veces que aparecio *)
end;
tipoarreglo = array[1..MAXN] of nodo;
y guardamos los datos en un arreglo de tipo “ tipoarreglo”, digamos arreglo,
después de ingresar los datos como en el aquel problema, y antes de clasificarlos,
tendríamos una disposición como en la figura 12.3.
‘ b ’ 2 ‘ d ’ 5 ‘ c ’ 1 ‘ a ’ 5 ‘ e ’ 2
arreglo 1 arreglo 2 arreglo 3 arreglo 4 arreglo 5
Figura 12.3: Disposición del arreglo de registros luego de ingresar los datos.
Para dar una estructura de árbol binario a los datos, hacemos lo siguiente: el
primer dato ingresado es la raíz del árbol, y al ingresar cada dato subsiguiente lo
comparamos con los ya existentes, yendo hacia abajo a la izquierda si el nuevo
dato es menor o hacia la derecha si es mayor (o incrementando cuenta si es
igual). Así, al terminar de ingresar los datos en nuestro ejemplo quedaría un
árbol binario como el de la figura 12.4.
‘ b ’ 2
‘ a ’ 5 ‘ d ’ 5
‘ c ’ 1 ‘ e ’ 2
Figura 12.4: Disposición del árbol binario luego de ingresar los datos.
Después de mirar un rato esta figura, nos damos cuenta que si “proyectamos”
los registros sobre una recta horizontal como en la figura 12.5, obtenemos los
registros clasificados alfabéticamente. Después de pensar otro rato más, nos
damos cuenta que no se trata de una casualidad: en la figura 12.4 todo lo
que queda a la izquierda y abajo de un registro tiene que tener menor llave
yanálogamente hacia la derecha y abajo. Así, en nuestro ejemplo, todo lo que
es menor que ‘ b ’, i.e. ‘ a ’, está a la izquierda, mientras que ‘ c ’, ‘ d ’y‘e ’están
a la derecha. Cuando miramos a ‘ d ’, ‘ c ’está a la izquierda, pero también ‘ b ’
(que tenía a ‘ d ’asuderecha)y‘a ’ (que estaba a la izquierda de ‘ b ’), etc.
‘ a ’ 5 ‘ b ’ 2 ‘ c ’ 1 ‘ d ’ 5 ‘ e ’ 2
Figura 12.5: Los registros de la figura 12.4 “proyectados”.
Nos queda la inquietud de cómo guardar las “flechas” en la computadora,
i.e. la información sobre los hijos a izquierda y derecha. Para esto agregamos a
los registros dos campos donde se guardará elíndice del hijo correspondiente:

12.4. Árboles binarios ordenados Pág. 129
type
indice = integer; (* para senialar los indices *)
tipodato = char; (* el tipo de datos a ingresar *)
nodo = record
llave: tipodato; (* dato *)
cuenta: integer; (* veces que aparecio *)
izquierda: indice; (* hijo a la izquierda *)
derecha: indice (* hijo a la derecha *)
end;
tipoarbol = array[1..MAXN] of nodo;
Aún cuando el arreglo con los datos ingresados sigue formando una pila,
ahora nos queda una disposición como en la figura 12.6, donde con 0 indicamos
que no hay hijos (a izquierda o derecha) y, claro, dibujamos las flechas sólo
para orientarnos (no están en la computadora). Observar que esta figura es
básicamente la figura 12.3 a la que hemos agregado flechas, pero también es
equivalente a la figura 12.4.
‘ b ’ 2 4 2 ‘ d ’ 5 3 5 ‘ c ’ 1 0 0 ‘ a ’ 5 0 0 ‘ e ’ 2 0 0
Figura 12.6: Los registros con índices para la estructura de árbol binario.
Ya estamos en condiciones de abordar el siguiente problema:
Problema 12.6. El programa arbolbinario, muestra la construcción de un árbol
binario ordenado usando arreglos como indicamos anteriormente.
En los nodos se guarda información, que en nuestro ejemplo es llave y cuenta.
En llave guardamos un entero, pero podría ser una palabra de un texto, o
un apellido, etc., mientras que en cuenta guardamos el número de veces que
apareció esedato.Enelárbol, un nodo tiene a su izquierda un subárbol cuyos
nodos tienen menor llave, y a su derecha nodos con mayor llave.
A la salida se imprimen los datos ordenados por orden creciente de llave y
las veces que apareció el dato.
Estudiando el programa, observamos que
• Cada nodo guardará cuatro datos: la llave, la cantidad de veces que apareció,
y cómo encontrar a sus hijos. Por lo tanto necesitamos un registro
con 4 campos.
• Los nodos con la información se guardan en un arreglo de nodos llamado
(¡curiosamente!) arbol.
• Hay una función booleana entrardatos, modificando un poco lo hecho en
el procedimiento leerarreglo del problema 8.1.
• El árbol se va construyendo en el arreglo arbol como pila con narbol elementos:
a medida que llega nueva información se aumenta narbol yse
incorpora al final.

Pág. 130 Generando objetos combinatorios
• Pero la información de la estructura de árbol —bien diferente a la de
pila— se guarda en los registros: en izquierda (o derecha) colocamos la
posición en el arreglo del hijo a la izquierda (o derecha). Para indicar que
no hay un hijo (a izquierda o derecha) introducimos la constante nada,que
podría tomar cualquier valor “imposible” para índices del arreglo arbol y
que hemos puesto en 0.
• Para procesar los datos ingresados, usamos el procedimiento recursivo
binario que primero se fija si se está en una posición “vacía”, i.e. sin
datos, en cuyo caso se agrega un nodo al árbol, se guarda el dato, se
coloca cuenta en 1, y se inicializan los hijos a nada pues están vacíos.
Si la posición no está vacía, se pregunta si el dato es el mismo que se
guarda en ese nodo, en cuyo caso se incrementa cuenta, osidebeirala
izquierdaencasoqueseamenoroaladerecha.
• El procedimiento enorden imprime los datos en (¡ejem!) orden con la cantidad
de apariciones en forma recursiva: para mantener el orden, deben
imprimirse primero los descendientes a la izquierda, luego el nodo mismo,
y finalmente los descendientes a derecha. La condición “de parada” para
la recursión es encontrar el valor nada.
Observar que no necesitamos intercambiar los registros para poder imprimirlos
ordenadamente (recordar la “proyección” mencionada anteriormente).
a) Cambiar la impresión en orden por post orden (primero se imprimen los
subárboles y después el nodo) y por pre orden (primero el nodo y después
los subárboles).
b) Cambiar el procedimiento enorden para imprimir los datos clasificados de
mayor a menor (en vez de menor a mayor).
c) Cambiar el procedimiento enorden para imprimir también el nivel en que
se ha alojado la información.
Sugerencia: agregar un argumento para el nivel, formando parte de la recursión,
o, alternativamente, redefinir los nodos de modo de incluir el nivel
cuando se construyen.
Sugerencia si la anterior no alcanza: paralaprimervariantepodríamos
poner
procedure enorden(w: indice; nivel: integer);
begin
if (w nada) then
with arbol[w] do begin
enorden(izquierda, nivel+1);
writeln(llave:10, cuenta:20, nivel:20);
enorden(derecha, nivel+1)
end
end;
haciendo la llamada “ enorden(raiz, 0) ” en la parte principal.
d) Agregar al programa la impresión de la profundidad (= máximo nivel) del
árbol al terminar de ingresar los datos.

12.5. Problemas Adicionales Pág. 131
e) Ver que si los datos se ingresan ya ordenados, el árbol correspondiente se
reduce básicamente a un arreglo unidimensional: dar un ejemplo con 5 caracteres
distintos, donde la profundidad sea 4.
✎ Para eliminar este problema, se han diseñado una serie de variantes,
como árboles balanceados, árboles “B”, etc. Observar que sacar nodos
de un árbol es un proceso bastante más complicado que sacar nodos
de una lista (ver [16, Cap.4]). ✄
El lector se preguntará porqué hemos incluido el tema de árboles binarios
en este capítulo de “objetos combinatorios”: créase o no, en este capítulo
ya habíamos visto y recorrido árboles binarios, aunque tenían una estructura
particular que nos permitía ahorrar espacio.
Porejemplo,enelproblema12.1 construíamos todas las cadenas de bits
de longitud n o, equivalentemente, los subconjuntos de {1,...,n}. Dada una
cadena c de bits de longitud k, podemos considerar el “hijo a izquierda” como
la cadena c0 de longitud k + 1 que se obtiene de c agregando a la derecha un 0, y
de la misma forma considerar el “hijo a derecha” como la cadena c1 de longitud
k + 1 que se obtiene agregando un 1. En la función recursiva del problema 12.1
el nivel que estábamos construyendo era precisamente k, y cuando llegábamos
a k = n, imprimíamos la cadena.
También hay “árboles” en los problemas 12.4 y 12.5, sólo que los nodos
pueden tener más de dos hijos. A diferencia del problema de los subconjuntos o
cadenas de bits, el “recorrido” del árbol (que no es binario) es más complicado
porque la descripción de los nodos lo es.
✎ La variable k del procedimiento llegardesde oenelprocedimientoponer
indica también el nivel que estamos recorriendo. Las instrucciones “ k :=
k - 1”y“falta[j] := true ”, respectivamente, hacen que vayamos “un
nivel hacia arriba” antes de descender nuevamente, y por eso la técnica de
“borrar las huellas” que usamos en ambos casos es conocida como backtracking
o “rastreo inverso”.
12.5. Problemas Adicionales
Problema 12.7. Resolver el problema 12.1 sin usar recursión, usando que las
cadenas de bits de longitud n pueden pensarse como los coeficientes en base 2
de los números entre 0 y 2 n − 1. Sugerencia: parak =0,...,2 n − 1, construir
la lista de coeficientes e imprimirla. ✄
Problema 12.8. Hacer un programa que dados n, k ∈ N imprima todos los
subconjuntos de {1, 2,...,n} que tienen exactamente k elementos. ✄
Problema 12.9 (Problema del Viajante). Supongamos que un viajante
tiene que recorrer n ciudades (exactamente) volviendo a la de partida, sin repetir
su visita a ninguna (salvo la inicial), y que el costo de viajar desde la ciudad i
a la ciudad j es cij ≥ 0. El problema del viajante es encontrar una permutación
(a1,a2,...,an) de(1, 2,...,n) de modo que el costo total del recorrido, ca1a2 +
ca2a3 + ···+ can−1an + cana1, seamínimo. Como se recorre un ciclo, es suficiente
tomar a1 =1.
a) Usando una variante del programa del problema 12.5, hacer un programa
para encontrar una solución al problema cuando el costo cij es:

Pág. 132 Generando objetos combinatorios
i) i + j.
ii) |i − j|.
iii) i × j.
iv) dado como entero aleatorio entre 1 y 10.
Sugerencia: definir una variable min de tipo “ real ” y un arreglo opt donde
se guardarán el costo más chico obtenido y la permutación correspondiente,
y
poner
inicialmente min a un valor muy grande e inalcanzable como 1 +
i j cij. A medida que se van recorriendo las permutaciones, calcular
el costo de la permutación y compararlo con min, cambiando min y opt
acordemente. Tomar n pequeño, 4 o 5 al principio, mientras se prueba el
programa, y no mayor que 10–12 en cualquier caso.
b) Ver que en el caso i) del inciso anterior, el costo es el mismo para cualquier
permutación.
c) ¿Podrías decir cuál es el óptimo en el caso ii) para cualquier n? Sugerencia:
podemos pensar que los puntos 1,...,n están sobre una recta y los costos
son las distancias.
✎ En los ejemplos i–iii) los costos son simétricos, i.e. cij = cji. Como recorrer
un ciclo en uno u otro sentido no cambia el costo, estamos trabajando (al
menos) el doble de lo necesario con la propuesta.
El problema del viajante y otros similares son sumamente importantes y
se aplican a problemas de recorridos en general. Por ejemplo, para “ruteo” de
vehículos, máquinas para perforar o atornillar, circuitos impresos y “chips”,
etc., donde el costo puede medirse en dinero, tiempo, longitud, etc. Consecuentemente,
hay toda una área de las matemáticas y computación dedicada al
estudio de su resolución eficiente. Hasta el momento no se conocen algoritmos
verdaderamente buenos, resolviéndose exactamente el caso de unos pocos miles
de “ciudades” y costos arbitrarios. Aunque se sospecha que no hay algoritmos
“eficientes”, aún no se ha demostrado que no los hay (para esto, hay que desarrollar
toda una teoría matemática de qué significa “eficiente”). El algoritmo
propuesto acá esquizás el menos eficiente, pues analiza todas las soluciones
posibles, y por eso se lo llama de búsqueda exhaustiva. ✄
12.6. Comentarios Bibliográficos
El programa arbolbinario está basado en las presentaciones de [16, pág. 210]
y[10, pág. 153].

Capítulo 13
Grafos y árboles
Si tomamos un conjunto de ciudades y las carreteras que las unen, y representamos
gráficamente a las ciudades como puntos y a las carreteras como
segmentos o curvas uniendo esos puntos, obtenemos una figura similar a la 11.4,
en la cual pensábamos que los segmentos eran calles y los puntos las intersecciones.
La idea subyacente en ambos casos es la de grafo, unconjuntodevértices
(las ciudades o intersecciones) que indicaremos por V , y un conjunto de aristas
(las rutas o calles), E, cada una de las cuales queda definida por dos vértices.
No sólo los grafos están relacionados con calles o rutas. En comunicaciones
también podemos pensar que los vértices son computadoras y las aristas representan
la posibilidad de que dos computadoras se conecten entre sí. O, saliendo
de las comunicaciones, podemos pensar en un árbol genealógico, donde los vértices
son las personas y las aristas relacionan padres con hijos. En fin, los ejemplos
de aplicaciones de grafos son muy variadas, y muchas veces sorprendentes.
Euler (1707–1783) fue uno de los más grandes y prolíficos matemáticos,
y ya hemos mencionado su nombre en conexión con análisis (la constante de
Euler), teoría de números (la función φ ylafórmula de Euler-Binet), aunque
éstas son comparativamente contribuciones menores suyas. Fue tan grande su
influencia en las matemáticas que se unificaron notaciones que el ideó, como
la de π (= 3.14159 ...) (del griego “perypheria” o circunferencia), i (= √ −1)
(por imaginario), y e (= 2.71828 ...) (del alemán “einhalt” o unidad).
Entre otras tantas, Euler fue quien originó el estudio de teoría de grafos y
la topología al resolver en 1736 el famoso problema de los puentes de Königsberg
(hoy Kaliningrad, en Rusia), donde el río Pregel se bifurcaba dejando dos
islas (y dos costas), y las islas y las costas se unían por siete puentes. Euler
resolvió el problema, demostrando que no se podían recorrer todos los puentes
pasando una única vez por ellos, demostrando el teorema que hoy llamamos
“de grafos eulerianos” y que mencionamos en el problema 13.7.
En este capítulo veremos algunas propiedades básicas y algunos algoritmos
elementales para grafos. Nos contentaremos con dar una simple, y seguramente
demasiado breve, descripción de los términos y propiedades que usaremos,
dejando para los cursos de matemática discreta las definiciones rigurosas y las
demostraciones.
✎ Lamentablemente no hay una nomenclatura ni notación uniforme de los
muchos conceptos asociados a grafos, de modo que las nuestras pueden
diferir de las de otros autores.

Pág. 134 Grafos y árboles
A fin de distinguir los vértices entre sí es conveniente darles nombres, pero
para el uso computacional supondremos que si hay n vértices, éstos se denominan
1, 2,...,n, i.e. V = {1, 2,...,n}. Más aún, casi siempre usaremos el nombre
n para el cardinal de V .Asícomon es el “nombre oficial” de |V |, el“nombre
oficial” para |E| es m.
Sólo consideraremos grafos simples, para los que no hay una arista de un
vértice en sí mismo, ni aristas “paralelas” uniendo los mismos vértices. En este
caso, podemos relacionar n = |V | y m = |E|: sihayn elementos, hay c(n, 2) =
n(n − 1)/2 subconjuntos de 2 elementos, de modo que m ≤ c(n, 2).
Las aristas están formadas por un par de vértices, y como el orden no importa,
indicaremos la arista que une el vértice a con el vértice b por {a, b}. Claro
que decir que {a, b} ∈E es lo mismo que decir que {b, a} ∈E.
Si e = {a, b} ∈E, diremosquea y b son vecinos o adyacentes, quea y b
son los extremos de e, oquee incide sobre a (y b). A veces, un vértice no tiene
vecinos —no hay aristas que inciden sobre él— y entonces decimos que es un
vértice aislado.
En la figura 13.1, mostramos un ejemplo de grafo donde n =6,
E = {{1, 2}, {1, 3}, {2, 3}, {2, 6}, {3, 4}, {3, 6}, {4, 6}}.
yporlotantom =7,yelvértice 5 es aislado.
3
2
1
4 5
Figura 13.1: Un grafo con 6 vértices y 7 aristas, el vértice 5 es aislado.
Siguiendo con la analogía de calles y rutas, es común hablar de camino,
una sucesión de vértices (el orden es importante) de la forma (v1,v2,...,vk),
donde {vi,vi+1} ∈E para i =1,...,k− 1. Un camino en principio puede tener
vértices repetidos, y si se cierra sobre sí mismo de modo que v1 = vk, decimos
que se trata de un camino cerrado, mientras que si no tiene vértices repetidos
decimos que es un camino simple. Por ejemplo, en la figura 13.1, {3, 2, 6, 3, 4}
es un camino, {1, 2, 3} es un camino simple y {4, 3, 2, 1, 3, 6, 4} es un camino
cerrado. Claro que podemos describir un camino tanto por los vértices como por
las aristas intermedias, y en vez de poner (v1,v2,...,vk) podríamos considerar
({v1,v2}, {v2,v3},...,{vk−1,vk}).
Un ciclo es un camino cerrado sin aristas repetidas (pero puede tener varios
vértices repetidos). Por ejemplo, {4, 3, 2, 1, 3, 6, 4} es un ciclo en el grafo de la
figura 13.1.
De fundamental importancia es reconocer si un grafo es conexo, es decir, si
existe un camino desde cualquier vértice a cualquier otro vértice. Por otra parte,
6

si un grafo es conexo pero no tiene ciclos, decimos que es un árbol.
Por ejemplo, el grafo de la figura 13.1 no es conexo, pues tiene un vértice
aislado. En la figura 13.2.a) mostramos otro grafo no conexo, y en b) unárbol.
a) grafo no conexo con 9 vértices y 9 aristas. b) árbol con 7 vértices.
Figura 13.2: Un grafo no conexo y un árbol.
Si además el grafo es conexo (y simple), como se puede unir un vértice con
los n − 1 restantes, debe haber al menos n − 1 aristas. De modo que para un
grafo (simple) conexo, m tiene que estar básicamente entre n y n2 .
A veces se consideran grafos dirigidos o digrafos, en los que las aristas están
orientadas, y por lo tanto se indican como (a, b), y se distingue entre (a, b) y
(b, a). Nosotros no estudiaremos este tipo de grafos, aunque en realidad hemos
trabajado con el grafo de la figura 11.4 como si fuera un digrafo: las calles sólo
iban de sur a norte o de oeste a este.
Dada su estructura, es más sencillo trabajar con árboles que con grafos.
Como hemos dicho, un árbol es un grafo (simple) conexo y sin ciclos, pero hay
muchas formas equivalentes de describirlo, algunas de las cuales enunciamos
como teorema (que por supuesto creeremos):
Teorema 13.1 (Caracterizaciones de árboles). Un grafo simple G =(V,E)
con |V | = n es un árbol si y sólosisecumplealgunadelassiguientescondiciones:
a) Para cualquier a, b ∈ V existe un único camino que los une.
b) G es conexo y |E| = n − 1.
c) G no tiene ciclos y |E| = n − 1.
d) G es conexo, y si se agrega una arista entre dos vértices cualesquiera, se
crea un único ciclo.
e) G es conexo, y si se quita cualquier arista —pero no los vértices en los
que incide— queda no conexo.
A veces en un árbol consideramos un vértice particular como raíz, y miramos
a los otros vértices como “descendientes” de la raíz: los que se conectan mediante
unaaristaalaraíz son los “hijos”, los que se conectan con un camino de 2 aristas
son los “nietos” y así sucesivamente. Dado que hay un único camino de la raíz
a cualquier otro vértice, podemos clasificar a los vértices según niveles: laraíz
tiene nivel 0, los hijos nivel 1, los nietos nivel 2, etc., como hemos visto al estudiar
árboles binarios ordenados en la sección 12.4.
Por supuesto, podemos pensar que los nietos son hijos de los hijos, los hijos
padres de los nietos, etc., de modo que —en un árbol con raíz— hablaremos
de padres, hijos, ascendientes y descendientes de un vértice. Habrá uno o más
vértices sin descendientes, llamados hojas, mientras que la raíz será elúnico
vértice sin ascendientes. También es común referirse al conjunto formado por
un vértice (aunque el vértice no sea la raíz) y sus descendientes como una rama
del árbol.
Pág. 135

Pág. 136 Grafos y árboles
13.1. Representación de grafos en la computadora
Antes de meternos de lleno con los algoritmos, nos falta una “cosita” más:
¿cómo guardar la información de un grafo en la computadora? Ya sabemos que
los vértices son 1, 2,...,n, pero ¿y las aristas?
Hay muchas formas de representar un grafo en general, y nosotros en este
capítulo nos limitaremos a dos: dar la lista de aristas, y dar la matriz de adyacencias,
una matriz cuyas entradas son sólo0o1ydemodoquelaentradaij
es 1 si y sólo si {i, j} ∈E.
La representación mediante matriz de adyacencias es cómoda, y relativamente
fácil de entender. Quizás sería más eficiente —para los algoritmos que
veremos— dar para cada vértice una lista de sus vecinos. Esta tercera forma
puede implementarse mediante arreglos, pero es mucho más natural usar listas
encadenadas que veremos en el problema 14.9.
En lo que resta de este capítulo, supondremos las declaraciones:
const
MAXN = 20; (* maximo numero de vértices *)
MAXM = 100; (* maximo numero de aristas *)
type
arreglodevertices = array[1..MAXN] of integer;
tipoarista = record i, j: integer end;
arreglodearistas = array[1..MAXM] of tipoarista;
matrizNN = array[1..MAXN,1..MAXN] of integer;
var
ngrafo, mgrafo: integer;
aristasgrafo: arreglodearistas;
adyacencias: matrizNN;
usando para las aristas una representación como arreglo de registros.
Usualmente el ingreso de datos es más sencillo mediante la lista de aristas,
pues la matriz de adyacencias tiene n2 elementos y en general m ≪ n2 (y siempre
m ≤ n(n − 1)/2 para grafos simples). De cualquier modo, es conveniente tener
amanoprocedimientosparalalecturaypasardeunaaotrarepresentación:
Problema 13.2. En nuestros programas supondremos que ngrafo, elnúmero
de vértices del grafo, es entrado explícitamente (recordando que los vértices
serán entonces 1, 2,...,ngrafo).
a) Hacer un procedimiento para leer las aristas ingresadas por terminal, donde
cada arista consta de dos números enteros, formando un arreglo de longitud
mgrafo.
✎ Como es usual, supondremos que el usuario ingresa correctamente los
datos: los vértices de las aristas son enteros entre 1 y ngrafo, nohay
aristas repetidas o de la forma {i, i}, y no hay más de MAXM aristas.
b) Considerando el procedimiento dearistasaadyacencias,
procedure dearistasaadyacencias;
var i, j, k: integer;

13.2. Recorriendo un grafo Pág. 137
begin
for i := 1 to ngrafo do
for j := 1 to ngrafo do
adyacencias[i,j] := 0;
for k := 1 to mgrafo do
with aristasgrafo[k] do begin
adyacencias[i,j] := 1;
adyacencias[j,i] := 1
end
end;
hacer un programa que lea el número de vértices, las aristas (como en el inciso
anterior), calcule la matriz de adyacencias, e imprima para cada vértice,
los vértices que son adyacentes. Por ejemplo, si la entrada son las aristas
{1, 5}, {2, 5} y {4, 2}, deberá imprimir
Vertice Vecinos
1 5
2 4 5
3
4 2
5 1 2
c) Hacer un procedimiento que, dada la matriz de adyacencias, construya el
arreglo de aristas (a fin de evitar repeticiones, es conveniente construir sólo
aristas de la forma {i, j} con i

Pág. 138 Grafos y árboles
Claro que si el grafo no es conexo, no será posible hacerlo. Por suerte, con
un pequeño esfuerzo extra, los algoritmos que veremos también nos dirán si el
grafo es conexo o no.
Estos algoritmos se encuadran en la estructura del algoritmo visitar, que
mostramos en “seudo-código” en el cuadro 13.1, donde con “←” denotamos la
asignación y con la indentación implícitamente señalamos un par “begin-end” o
“comienzo-fin” para agrupar instrucciones.
Algoritmo visitar
Entrada: un grafo G =(V,E), y un vértice i0 ∈ V .
Salida: la lista de vértices que se pueden alcanzar desde i0 “visitados”.
comienzo
Q ←{i0};
mientras Q = ∅ hacer
sea i ∈ Q;
sacar i de Q;
“visitar” i;
para todo j adyacente a i hacer
si j no está “visitado”yj/∈ Q entonces agregar j a Q
fin
Cuadro 13.1: Esquema del algoritmo visitar.
En el algoritmo se guardan en la cola Q los vértices que pueden visitarse, esto
es, son adyacentes a algún vértice ya visitado pero aún no han sido visitados. Así,
en todo momento del algoritmo habrá tresclasesdevértices: los ya visitados, los
que están en la cola (y todavía no se han visitado), y los que no fueron visitados
ni están en la cola (porque todavía no visitamos ninguno de sus vecinos).
Como no queremos agregar a la cola un vértice ya agregado, debemos guardar
información que nos diga si un vértice ha estado en la cola o no. Para los
algoritmos que haremos será conveniente usar un arreglo padre, inicialmenteen
0, y al incluir el vértice j en la cola porque es vecino del vértice i que estamos
visitando, pondremos padre j = i (> 0). Así, la condición padre i > 0 indicaráque
i se ha puesto alguna vez en la cola, aunque ya no esté.
A medida que recorremos el grafo, las aristas que usamos y los vértices que
visitamos van formando un árbol (1) que —cuando el grafo es conexo— se llama
generador o de expansión del grafo, pues contiene a todos los vértices del grafo
original y las aristas del árbol son también aristas del grafo original (pero pueden
no ser todas).
Por supuesto que si el grafo que queremos recorrer es ya un árbol, no se formará
uno nuevo. Pero sí que podemos tomar al vértice i0, con el que empezamos
el recorrido, como raíz, y el arreglo padre justamente nos dirá quién es el padre
de cada vértice en el árbol que se forma.
(1) Esto irá quedando más claro con los ejemplos. Es una propiedad que no demostraremos,
¡como tantas otras!

13.3. Recorrido a lo ancho y en profundidad Pág. 139
Pondremos padre i0 = i0 para indicar que i0 es justamente la raíz y no podemos
seguir “más arriba”, de modo que también para i = i0 la condición
padre i > 0 es equivalente a que el vértice i se ha incoporado alguna vez a la
cola.
13.3. Recorrido a lo ancho y en profundidad
En el recorrido “a lo ancho” o “ancho primero”, visitamos primero el vértice
i0, luego sus vecinos, luego los vecinos de los vecinos, etc., sin volver a visitar a
alguien ya visitado. O sea que, pensando en el árbol que se formará, visitaremos
primerolaraíz, después todos sus hijos, después todos sus nietos, etc., en el mismo
orden en que los vamos encontrando. Es entonces conveniente implementar
la cola Q como cola fifo (como en la sección 12.1): el que llegó antes sale antes.
Problema 13.4 (Recorrido a lo ancho). Implementamos el algoritmo en el
programa anchoprimero (pág. 199), y observamos que:
• Además de las variables mencionadas en la sección 13.1, incorporamos
nvisitado y marbol que nos indicarán la cantidad de vértices visitados
y aristas en el árbol que forman. Por supuesto, al finalizar tendremos
nvisitado = ngrafo si y sólo si hemos recorrido todos los vértices, o equivalentemente,
si el grafo original es conexo.
También agregamos el arreglo aristasarbol , donde guardaremos las aristas
del árbol construido, y el arreglo de vértices visitado, donde guardaremos
el orden en que han sido visitados los vértices.
Es posible que sólo querramos saber si el grafo es conexo. En este caso
los arreglos aristasarbol y visitado no son necesarios, y sólo habrá que
mantener nvisitado y compararlo al terminar con el valor de ngrafo.
• El procedimiento ancho es el que realiza el trabajo. Hemos tomado como
vértice inicial i0 = 1, guardando la cola (fifo) con los vértices a visitar en
el arreglo avisitar,entreppo y fin.
Cuando visitamos un vértice i, guardamos el número correlativo de visita
en visitado. Luego recorremos los vecinos, reconocidos por la condición
adyacencias ij > 0. Si un vecino j de i tiene padre j = 0, quiere decir que
no ha sido agregado a la cola, y entonces se lo coloca en la cola y actualiza
el valor de padre j .
• A fin de reconocer las aristas del árbol, usamos el arreglo padre en el
procedimiento hacerarbol.
a) Ejecutar el programa, tomando como entrada el grafo de la figura 13.1,
agregando las aristas {3, 5} y {4, 5}. Losvértices se recorren en el orden
1, 2, 3, 6, 4, 5.
b) Cambiar el programa de modo de que la raíz sea un vértice arbitrario r (en
vez de 1), ingresado por el usuario.
✎ Una fuente de ineficiencia en la implementación es el uso de la matriz de
adyacencias para reconocer a los vecinos. Esto hace que nuestro programa
haga del orden de n 2 pasos para recorrer el grafo. Si m ≪ n 2 ,esmás conveniente
usar directamente una lista de vecinos para cada vértice, puesto
que entonces el algoritmo hará delordendempasos.

Pág. 140 Grafos y árboles
✎ El orden en que se recorren los vértices —tanto en ancho primero como en
profundidad primero que veremos luego— está determinado también por
el orden que se dan a los vecinos. Acá, al usar la matriz de adyacencias
para buscar los vecinos, seguimos el orden de los naturales, pero podría ser
otro. En la mayoría de las aplicaciones, la numeración dada a los vértices
y sus vecinos no es importante: si lo fuera, hay que sospechar del modelo. ✄
En general, aún cuando el grafo sea un árbol binario ordenado (y con raíz
1), el recorrido a lo ancho es distinto de los recorridos “en orden”, “pre orden” o
“post orden” que hemos visto en el problema 12.6, pues ahora visitamos los vecinos
de la raíz, luego los vecinos de los vecinos, etc., en otras palabras, visitamos
el árbol por niveles.
Problema 13.5. Agregar un procedimiento al programa arbolbinario para imprimir
el árbol construido por niveles: primero la información del vértice en el
nivel 0, luego la de los vértices en el nivel 1, etc., hasta la profundidad. ✄
Si en el algoritmo visitar, en vez de implementar la cola como fifo, la implementamos
como lifo (pila), visitaremos primero los vértices que se han incorporando
más recientemente a la pila. Si el grafo fuera ya un árbol, resultará que
primero visitaremos toda una rama hasta el fin antes de recorrer otra (2) ,loque
hace que este tipo de recorrido se llame “en profundidad” o de “profundidad
primero”.
Problema 13.6 (Recorrido en profundidad).
a) Cambiar el procedimiento ancho del programa anchoprimero de modo de
implementar una pila (cola lifo) en vez de una cola fifo, para realizar el
recorrido en profundidad. Si la entrada es la misma que en el problema 13.4
(agregando las aristas {3, 5} y {4, 5}), los vértices se visitan en el orden
1, 3, 6, 5, 4, 2.
b) Algunos autores (por ejemplo [8]) consideran que la búsqueda en profundidad
consiste en quitar el vértice de la cola sólo cuando se han visitado todos
los vecinos que están después en la cola, lo que en el ejemplo anterior daría
por resultado el orden de visita 1, 2, 3, 4, 5, 6.
Hacer un programa con esta nueva variante, reemplazando en los lugares
apropiados las instrucciones por:
(* al principio solo esta 1 *)
padre[1] := 1;
hay := 1; (* la cantidad de vertices en la pila *)
avisitar[1] := 1;
nvisitado := 1; visitado[1] := 1;
while (hay > 0) do (* mientras la pila no es vacia *)
begin
i := avisitar[hay]; (* tomar el ultimo vertice *)
(* y buscar vecino que no tenga padre *)
j := 1; buscar := true;
while (buscar) do begin
if ((adyacencias[i,j] > 0) and (padre[j] = 0))
(2) Bah, que nos vamos por las ramas.

13.4. Camino más corto: Dijkstra Pág. 141
then
(* se encontro *)
begin
buscar := false;
(* agregar arista (i,j) al arbol *)
padre[j] := i;
(* registrar el orden de visita *)
nvisitado := nvisitado + 1;
visitado[nvisitado] := j;
(* y agregar j a la cola *)
hay := hay + 1;
avisitar[hay] := j
end
else (* probar con el siguiente *)
j := j + 1;
if (j = ngrafo + 1) then begin
(* todos los vecinos ya tienen padre *)
buscar := false;
(* sacar i de la pila *)
hay := hay - 1
end
end (* buscar *)
end (* hay *)
donde la variable buscar es booleana.
c) Hacer un gráfico de los árboles obtenidos en cada caso para el ejemplo dado
y compararlos.
✎ Si el grafo a recorrer es ya un árbol, los resultados obtenidos por estas dos
variantes es el mismo. Pero nuestra implementación de la segunda variante
es mucho más ineficiente que la primera, pues recorremos varias veces las
adyacencias de un mismo vértice buscando un vecino para agregar.
Recordar también la nota sobre la numeración de los vecinos al final
del problema 13.4. ✄
Problema 13.7. Un célebre teorema de Euler dice que un grafo tiene un ciclo
que pasa por todas las aristas exactamente una vez, llamado ciclo de Euler,
si y sólo si el grafo es conexo y el grado de cada vértice es par (recordar el
problema 13.3).
Modificar el programa anchoprimero para que a la salida determine también
si el grafo tiene o no un ciclo de Euler usando el teorema.
✎ Un problema muy distinto es encontrar un ciclo de Euler en caso de existir.
Esto es lo que hacemos en el problema 14.10. ✄
13.4. Camino más corto: Dijkstra
Algunas veces la información interesante de un grafo está enlosvértices,
y las aristas nos dicen que, por alguna razón, dos vértices están relacionados
ynadamás. Tal es el caso de los árboles binarios de la sección 12.4, donde la
conexión estaba asociada al orden entre los datos guardados en los vértices.

Pág. 142 Grafos y árboles
Otras veces, las aristas tienen información adicional que queremos considerar.
Por ejemplo si las aristas indican rutas entre ciudades, podría ser la distancia
entre las ciudades. Cuando cada arista e ∈ E de un grafo tiene un costo o peso
asociado, we, decimos que se trata de un grafo con pesos o pesado (nosotros sólo
consideraremos el caso we > 0paratodoe ∈ E).
En la figura 13.3 damos un ejemplo de grafo con pesos, marcados con recuadros
en las aristas correspondientes, pero por comodidad reproducimos los
datos en el cuadro al costado.
1
2
3
2
1
1
2
1
3
2
8
4 5
1
3
6
Arista e peso we
{1,2} 2
{1,4} 3
{1,5} 8
{2,3} 2
{2,4} 1
{3,4} 1
{3,5} 2
{3,6} 1
{4,6} 1
{5,6} 3
Figura 13.3: Un grafo con pesos en las aristas.
Si tuviéramos que ir de una ciudad a otra, teniendo distintas rutas alternativas
para elegir, es razonable preguntarse cuál de ellas será lamás corta (o la
más barata). Éste es el problema del camino más corto: enungrafopesado,y
dados dos vértices s, t ∈ V , encontrar un camino (v0 = s, v1,...,vk = t) con
peso total mínimo, donde el peso total de un camino se define como
w {v0,v1} + w {v1,v2} + ···+ w {vk−1,vk} =
k
w {vi−1,vi}.
Observar que el valor de k no está fijo: no nos interesa si tenemos que usar
una arista o cien, sólo nos interesa que la distancia total para ir de s a t sea
mínima.
Por ejemplo, en el grafo de la figura 13.3 podemos usar varios caminos para
ir del vértice 1 al 5: el camino (1, 5) usa una única arista (k = 1) y tiene peso 8,
el camino (1, 2, 3, 5) usa 3 aristas y tiene costo total 2 + 2 + 1 = 5, y en realidad
no hay otro con menor costo.
Tal vez el algoritmo más conocido para resolver este problema sea el de
Dijkstra, que sigue la estructura del algoritmo visitar: se comienza desde un
vértice, en este caso s, se lo coloca en una cola, y se visitan los vértices de la
cola.
E. W. Dijkstra (1930–2002) nació ymurióenHolanda. Fue uno de los más
grandes intelectos que contribuyeron a la lógica matemática subyacente en los
programas de computación y sistemas operativos. Entre sus muchas y destacadas
contribuciones está el algoritmo para el camino más corto que presentamos,
publicado en 1959.
Nuevamente habrá tresclasesdevértices: los visitados, los que están en la
cola y no han sido aún visitados, y los que nunca estuvieron en la cola. Como
i=1

13.4. Camino más corto: Dijkstra Pág. 143
novedad, para cada i ∈ V consideraremos el valor di de la distancia más corta de
s a i mediante caminos de la forma (s, v1,v2,...,vk,i) donde todos los vértices
excepto i ya han sido visitados. A fin de indicar que no existe tal camino,
pondremos di = ∞ (siendo éste el valor inicial para todo i).
A diferencia del recorrido a lo ancho, donde se visitan los vértices en el orden
de llegada a la cola, en el algoritmo de Dijkstra elegimos para visitar el vértice
de la cola con menor distancia di. El algoritmo termina cuando t es el próximo
vértice a visitar (y entonces dt es la distancia del menor camino de s a t), o
cuando la cola es vacía,encuyocasonoexisteuncaminodesdeshacia t (y
necesariamente el grafo no es conexo).
Al visitar un vértice i yexaminarunvértice vecino j, verificamos si
di + w {i,j} 0paratodoe∈E. Nosotros dejaremos estas
propiedades para cursos de matemática discreta o teoría de grafos.
Podemos esquematizar el algoritmo en seudo-código como en el cuadro 13.2.
Algoritmo de Dijkstra
Entrada: un grafo pesado G =(V,E,W), y dos vértices s, t ∈ V .
Salida: la distancia dt de un camino más corto entre s y t (dt =
∞, sitalcaminonoexiste).
comienzo
para todo i ∈ V hacer di ←∞;
ds ← 0; Q ←{s};
repetir
sea i ∈ Q tal que di =mínj∈Q dj;
si i = t entonces
sacar i de Q;
para todo j adyacente a i hacer
si di + w {i,j}

Pág. 144 Grafos y árboles
∞, ycomolosvértices j que no han ingresado en la cola son los que satisfacen
dj = ∞, elúltimo lazo interno puede simplificarse a
para todo j ∈ V hacer
si di + w {i,j}

13.5. Mínimo árbol generador: Prim Pág. 145
4. Una vez que determinamos el vértice a visitar, i, lo comparamos con t,
el vértice al cual queremos llegar. Si i = t, hemos llegado y se termina
el procedimiento.
5. En cambio, si i = t, recorremos los vecinos de i, indicados con j,
actualizando dist, padre y la cola si fuera necesario, de acuerdo a la
desigualdad (13.1). Antes de cambiar dist j, sin embargo, preguntamos
si j ha estado en la cola comparando dist j con infinito.
• Para construir e imprimir un camino mínimo, usamos el arreglo padre en
el procedimiento hacercamino: formamos un arreglo recorriendo los antecesores
de t hasta llegar a s. El problema es que, como vamos agregando
atrás, nos queda el camino (t, padre t,...,s), en orden inverso.
Ésto puede no ser problema, pero es fácil imprimirlo de atrás para adelante
de modo de mostrarlo “al derecho”, como hemos hecho. Si fuera
necesario, se puede invertir el arreglo usando un procedimiento como el
del problema 8.3.
a) Ejecutar el programa, tomando como entrada el grafo pesado de la figura
13.3, vértice de partida 1 y vértice de llegada 4.
b) Cambiar el programa de modo que calcule las distancias mínimas de s (ingresado
por el usuario) a todos los otros vértices del grafo (sólo las distancias,
no los caminos).
c) Modificarlo de modo que calcule todas las distancias de i a j, para1≤i< j ≤ ngrafo.
✎ Técnicamente el tipo de cola que usamos en los programas dijkstra y prim
—en la próxima sección— se llama cola de prioridad, en vez de “lifo” o
“fifo”: no se elige ni el primero ni el último sino que se usa otro criterio
“de valor” o “prioridad” para sacar un elemento de la cola.
Nuestra implementación de este tipo de colas es un tanto rudimentaria
a fin de mantener la claridad de los programas. El uso de la variante de
selección directa tarda del orden de |V | pasos cada vez que se elige el
próximo vértice a visitar. En cambio, el uso de variantes de algoritmos
de clasificación más avanzados hace que se tarde a lo sumo del orden de
log2 (|V |) pasos para esa elección.
✎ Otra fuente de ineficiencia es el uso de la matriz de adyacencias (o costos)
si m ≪ n 2 , como hemos observado en el problema 13.4.
✎ Hemos tratado de mantener la presentación de los algoritmos y programas
de este capítulo — algoritmo visitar y los programas anchoprimero, dijkstra
y prim— lomásparecidas entre sí a fin de resaltar las semejanzas, lo que
también afecta (un poquito) a la eficiencia. Es muy posible que el lector
los vea con un “disfraz” bastante distinto en otras referencias. ✄
13.5. Mínimo árbol generador: Prim
Si tuviéramos una cierta cantidad de ciudades y las distancias entre ellas,
un problema interesante es ver cómo construir carreteras de modo de que todas
las ciudades puedan unirse entre sí mediante estas nuevas rutas. Dado que no
nos interesan ciclos, pero el grafo formado por las carreteras debe ser conexo,
estamos buscando un árbol generador.

Pág. 146 Grafos y árboles
El teorema 13.1 nos dice que cuando tenemos un grafo conexo que no es
un árbol, tendremos más de un árbol generador: será cuestión de tomar un
ciclo en el grafo original, sacar cualquiera de las aristas del ciclo, y repetir el
procedimiento hasta que no haya más ciclos, manteniendo la conexión. Como
las aristas que sacamos son bastante arbitrarias, en general hay muchos árboles
generadores de un mismo grafo.
Cuando hay pesos (o costos) asociados a las aristas, como en el caso de la
construcción de las carreteras, nos interesa encontrar entre todos los árboles generadores
uno que minimice la suma de los pesos de las aristas que lo componen,
we,
e en el árbol
llamado árbol generador mínimo (es posible que haya más de un árbol con esta
propiedad, por ejemplo si los costos de todas las aristas son 1).
Volviendo al grafo de la figura 13.3, podemos formar un árbol generador con
las aristas {1, 2}, {1, 4}, {2, 3}, {3, 6}, {6, 5} (siempre un árbol generador debe
tener n − 1 aristas), con peso total 2 + 3 + 2 + 1 + 3 = 11, y si reemplazamos la
arista {5, 6} por la arista {3, 5}, reducimos el costo en 1.
Hay varios algoritmos para encontrar un árbol generador mínimo, y nosotros
veremos aquí el debido a Prim, pues sigue la estructura del algoritmo visitar,
siendo por lo tanto muy parecido al recorrido a lo ancho o al algoritmo de
Dijkstra para el camino más corto. Otro algoritmo, más eficiente en la mayoría
de los casos prácticos, es el de Kruskal, que dejamos para la sección de Problemas
Adicionales pues su implementación es más elaborada.
El algoritmo de Kruskal fue publicado en 1956, mientras que el de Prim fue
publicado en 1959. Dijkstra también obtuvo en forma independiente el algoritmo
de Prim y lo publicó en 1959, en el mismo trabajo donde presenta su algoritmo
para el camino más corto, lo que no es sorpresa dada la similitud.
Recordemos que en el algoritmo visitar manteníamos una cola con los vértices
a visitar, y se formaban tres clases de vértices: los visitados, los que estaban
en la cola, y los que nunca habían ingresado en la cola.
En el algoritmo de Prim se sigue la misma idea, sólo que un vértice en
la cola se visita cuando su “distancia” a los vértices ya visitados es la menor
entre los vértices de la cola. De modo que hay que hacer pocas modificaciones al
algoritmo de Dijkstra: cambiar la definición de la distancia y, en vez de construir
el camino, construir el árbol correspondiente. A diferencia del algoritmo de
Dijkstra, tenemos que mantener información sobre los vértices visitados. Como
el arreglo padre se irá modificando en los sucesivos pasos (en el de Dijkstra
también, pero no en el recorrido a lo ancho), introducimos un nuevo vector con
valores lógicos visitado.
✎ Como con el algoritmo de Dijkstra, se necesita que we > 0paratodoe ∈ E.
Asimismo, dejamos la demostración de que el algoritmo da efectivamente
un árbol generador mínimo para los cursos de matemática discreta o teoría
de grafos.
Problema 13.9 (Algoritmo de Prim para el mínimo árbol generador).
A fin de implementar el algoritmo de Prim, observamos las similitudes y diferencias
con el de Dijkstra:
• La matriz de costos y el valor infinito son idénticos.

13.5. Mínimo árbol generador: Prim Pág. 147
• En el algoritmo de Prim “no existen” s y t, ni por supuesto el camino que
los une.
• Mientras que en el programa dijkstra tomamos a s como “raíz”, en el
programa prim el vértice 1 es el primero en ingresar a la cola, como en el
programa anchoprimero.
• Guardamos información sobre si un vértice ha sido visitado o no en el
arreglo booleano visitado.
✎ Observar que es diferente al usado en el programa anchoprimero, en
el cual guardábamos en visitado el orden de visita.
La distancia se actualiza comparando dist j con w {i,j} envezdeconw {i,j}+
dist i. Por lo tanto, el procedimiento mascorto del programa dijkstra se
puede cambiar a
procedure arbolminimo;
var
i, j, k, kmin, hay: integer;
d, dmin: costo;
avisitar: arreglodevertices;
visitado: array[1..MAXN] of boolean;
begin
(* inicializacion *)
dearistasacostos;
for i := 1 to ngrafo do begin
padre[i] := 0;
dist[i] := infinito;
visitado[i] := false
end;
(* 1 es la "raiz" *)
padre[1] := 1; dist[1] := 0;
(* cola inicial *)
hay := 1; avisitar[1] := 1;
repeat (* aca hay > 0 *)
(* nuevo i: el de minima distancia en la cola *)
kmin := hay; i := avisitar[hay]; dmin := dist[i];
for k := 1 to hay - 1 do begin
j := avisitar[k]; d := dist[j];
if (d < dmin) then begin
kmin := k; i := j; dmin := d end
end;
(* poner i al final de la cola y sacarlo *)
if (kmin < hay) then
avisitar[kmin] := avisitar[hay];
hay := hay - 1;

Pág. 148 Grafos y árboles
(* la distancia de i ya no debe modificarse *)
visitado[i] := true;
(* examinar vecinos de i *)
for j := 1 to ngrafo do
if ((not visitado[j]) and
(costos[i,j] < dist[j])) then begin
(* si j no se agrego, agregarlo a la cola *)
if (dist[j] = infinito) then begin
hay := hay + 1; avisitar[hay] := j end;
(* actualizar dist y padre *)
dist[j] := costos[i,j];
padre[j] := i
end
until (hay = 0)
end;
• En dijkstra buscábamos un camino, y ahora debemos construir un árbol,
i.e. encontrar las aristas correspondientes. Esto lo podremos hacer usando
nuevamente padre, agregando los pesos mediante dist. Así, el procedimiento
hacercamino en dijkstra puede reemplazarse por una variante del
procedimiento hacerarbol del programa anchoprimero, observando que el
peso w de la arista {k, padre k } es dist k.
• A la salida, debemos imprimir el árbol encontrado y un cartel en caso que
el grafo original no sea conexo. Esto puede hacerse modificando las partes
correspondientes de los programas anchoprimero o dijkstra.
a) Hacer un programa para implementar el algoritmo de Prim usando las
ideas expuestas. En el grafo de la figura 13.3, se obtiene el árbol de aristas
{1, 2}, {3, 4}, {2, 4}, {3, 5}, {4, 6}.
b) Incluir también instrucciones a fin de imprimir el peso total del árbol resultante.
c) El algoritmo expuesto empieza con el vértice 1. Cambiarlo de modo de poder
comenzar con un vértice arbitrario r ingresado por el usuario. Observar que
se pueden obtener distintos árboles de mínimo costo (aunque siempre con
el mismo costo total).
✎ Dado la similitud entre nuestras implementaciones de los algoritmos de
“ancho primero”, Dijkstra y Prim, no es sorprendente que valgan las mismas
observaciones hechas al final de los problemas 13.4 y 13.8. ✄
13.6. Problemas Adicionales
Problema 13.10. Modificar el programa anchoprimero de modo que al terminar,
además de decidir si el grafo es conexo o no, decida
a) si es un árbol o no,
b) si tiene un ciclo o no,
c) y en ese caso, exhibir un ciclo.
Sugerencia: incorporar las modificaciones una por vez. ✄

13.6. Problemas Adicionales Pág. 149
13.6.1. El algoritmo de Kruskal
El algoritmo de Kruskal para encontrar un árbol generador de mínimo peso
se aparta un poco del esquema del algoritmo visitar, ymás bien se acerca al
denominado algoritmo del codicioso pues busca incorporar la mejor arista de las
que quedan.
Antes de describir el algoritmo es conveniente introducir el concepto de componente
conexa (o simplemente componente cuando quede claro que es la conexa):
dado un grafo G =(V,E), vamos a dividir, o más correctamente, particionar,
elconjuntodevértices V en subconjuntos, digamos A1,A2,...,Ac, que
llamaremos componentes conexas de G, de modo que dos vértices u, v ∈ V están
en la misma componente si (y sólo si) existe un camino de u a v. Deestaforma
resulta que las componentes A1,A2,...,Ac satisfacen:
1. V = ∪1≤i≤cAi.
2. Si c>1, Ai ∩ Aj = ∅ para 1 ≤ i

Pág. 150 Grafos y árboles
Algoritmo de Kruskal
Entrada: un grafo G con vértices V ,aristasE ypesos{we}e∈E.
Salida: las componentes conexas (vértices) de G, C, y un conjunto
F ⊂ E tal que H =(V,F) tiene las mismas componentes
conexas que G, y con el mínimo peso entre todos los
grafos con esta propiedad. En particular si G es conexo,
H es un árbol generador de mínimo peso.
comienzo
para todo i ∈ V hacer Ci ←{i};
C←{Ci}i∈V ;
F ←∅;
Q ← E;
mientras (E = ∅) y(|C| > 1) hacer
sea e = {i, j} una arista de menor peso en Q;
sacar e de Q;
si Ci = Cj entonces
C ← Ci ∪ Cj;
eliminar Ci y Cj de C y agregar C a C;
Ci ← C; Cj ← C;
F ← F ∪{e}
fin
Cuadro 13.3: Esquema del algoritmo de Kruskal.
una estructura eficiente para ello que —conservando el inglés— llamaremos
union-find (por “unión-encontrar”) y que pasamos a describir.
En cada etapa del algoritmo, vamos a considerar para cada componente
C ∈Cun vértice r ∈ C representante de C, y una función f : V → V tal que
f(i) es el representante de la componente en la que está i, Ci. Enparticular,si
r es el representante de C, tendremos f(r) =r.
f irá cambiando en cada etapa, pues se van fusionando las componentes
conexas, pero como inicialmente tenemos Ci = {i} para todo i ∈ V ,inicialmente
tendremos f(i) =i.
Cuando en alguna etapa se unen C y C ′ —con representantes r y r ′ respectivamente—
para formar C ′′ , por simplicidad elegiremos a uno de ellos, digamos
r, como representante de C ′′ . Es decir que al finalizar esa etapa f(r) sigue siendo
r pero f(r ′ )=r, y en realidad f se ha modificado en todos los vértices de C ′ .
Hacer la redefinición de f explícitamente en cada etapa para todos los vértices
es muy costosa, por lo que se considera otra función auxiliar, g, que inicialmente
toma los mismos valores de f, i.e. inicialmente g(i) =i para todo
i ∈ V .
g también se va modificando en cada etapa, pero lo haremos únicamente
sobre el representante que ha dejado de serlo. Con las notaciones anteriores de
C, C ′ , r y r ′ , y habiendo elegido a r como representante de C ∪ C ′ , pondríamos
g(r ′ )=r. Observemos que una vez que un vértice i deja de ser representante
de la clase Ci, el valor g(i) nosemodifica(g sólo se modifica sobre algunos

13.6. Problemas Adicionales Pág. 151
representantes). Es decir, o bien g(i) no se modifica nunca, o bien se modifica
una única vez.
Para encontrar f(i) en cualquier momento, preguntamos si g(i) =i. Encaso
afirmativo, quiere decir que, o bien la componente Ci no se unió con ninguna
otra, o bien cada vez que se unió con otra resultó que elegimos a i como
representante de la nueva componente, y debe ser f(i) =i.
Por otro lado, si g(i) =j = i, quiere decir que en algún momento Ci se
unióconCjy tomamos como representante a j en vez de i,yporlotantoCi = Cj
desde ese momento en adelante. Podría ser que g(j) = j, en cuyo caso repetimos
el argumento, considerando los valores sucesivos g(i),g(g(i)),g(g(g(i))),...
hasta llegar a algún valor k para el cual g(k) =k, que debe ser el representante
de la clase, por lo que f(i) =k.
✎ El uso de g es análogo al del arreglo padre en el procedimiento hacercamino
del programa dijkstra. De hecho, estamos pensando a cada componente
conexa como árbol con raíz, que se reconoce por g(r) =r y las aristas
son de la forma {i, g(i)} con g(i) = i. Sin embargo, las aristas {i, g(i)} no
tienen por qué estar en el conjunto de aristas originales E.
En la implementación, llamaremos find (por “encontrar”) a este proceso
iterativo para calcular la función f, guardaremos los valores de g en el arreglo
repre (por “representante”, claro), que por simplicidad supondremos definido
globalmente, y pondremos
function find(i: integer): integer;
var r: integer;
begin
r := i;
while (r repre[r]) do r := repre[r];
find := r
end;
Ahora tenemos que resolver cómo elegir el representante cuando se unen
las componentes C y C ′ con representantes r y r ′ respectivamente, o en otras
palabras, cómo actualizar g (o el arreglo repre). En principio podríamos elegir
cualquiera de g(r) =r ′ o g(r ′ )=r, pero podemos hacer la elección eficientemente
si tenemos en cuenta que g se usará para buscar, dado i, alrepresentante
de Ci con el procedimiento iterativo de find, y nos interesa mantener el número
de iteraciones lo más bajo posible.
Si una componente C tiene como representante a r, llamemos ℓ(r) alnúmero
máximo de iteraciones (del lazo “ while ” en el procedimiento find) paracualquier
vértice de esa componente C. Inicialmente tendremos ℓ(r) =0paratodo
r, pero este valor se irá modificando a medida que fusionemos componentes.
Cuando se juntan las componentes C y C ′ con representantes r y r ′ , y
elegimos como representante de la nueva clase a (por ejemplo) r, elnúmero de
iteraciones máximas para la nueva componente será:
ℓ(r ′ ) + 1 para los vértices cuyo representante era r ′ ,
ℓ(r) para los vértices cuyo representante era r,
de modo que el nuevo valor de ℓ(r) serámáx{ℓ(r ′ )+1,ℓ(r)}.
Si queremos que los valores de ℓ aumenten lo menos posible, podemos elegir
r o r ′ como nuevo representante comparando máx{ℓ(r ′ )+1,ℓ(r)} ymáx{ℓ(r)+

Pág. 152 Grafos y árboles
1,ℓ(r ′ )}, o equivalentemente, ℓ(r) yℓ(r ′ ):
g(r ′ )=g(r) si ℓ(r ′ )

13.6. Problemas Adicionales Pág. 153
• Para la salida necesitaremos un procedimiento para imprimir las aristas
elegidas, similar al de escribirarbol en el programa anchoprimero.
• Luego habrá que declarar las funciones de “union-find”, como hemos descripto
anteriormente.
• Podemos hacer el trabajo principal en el procedimiento arbolminimo, donde
elegimos la arista de menor peso haciendo parcialmente selección directa
(como hicimos en dijkstra al elegir la menor distancia entre los que estaban
en la cola).
No es necesario mantener una cola explícita para las aristas si se usa el
mismo arreglo de aristas originales (en todo caso, si es necesario mantener
la lista original, se puede hacer una copia, o directamente pasar el arreglo
de aristas como argumento con lo que la copia se hace automáticamente).
En esta implementación, no “se pierden” las aristas originales, sino que
cambian de lugar (quedando parcialmente ordenadas de mayor a menor).
procedure arbolminimo;
var
hay, ri, rj, k, kmin: integer;
wmin : costo;
e: tipoarista;
begin
(* inicializacion *)
inicializaruf; (* inicializar union-find *)
nconexas := ngrafo; (* numero de componentes *)
marbol := 0; (* en el bosque no hay aristas *)
hay := mgrafo; (* cantidad de aristas a examinar *)
while ((nconexas > 1) and (hay > 0)) do begin
(* tomar la arista de menor peso
y sacarla de la pila *)
kmin := hay;
e := aristasgrafo[hay];
wmin := e.w;
for k := 1 to hay - 1 do
with aristasgrafo[k] do
if (w < wmin) then begin
kmin := k; wmin := w end;
if (kmin < hay) then begin
e := aristasgrafo[kmin];
aristasgrafo[kmin] := aristasgrafo[hay]
end;
hay := hay - 1;
(* miramos si los extremos estan
en la misma componente *)
with e do begin ri := find(i); rj := find(j) end;
if (ri rj) then begin

Pág. 154 Grafos y árboles
end;
(* distintas componentes *)
(* agregar arista a arbol *)
marbol := marbol + 1;
aristasarbol[marbol] := e;
(* juntar componentes conexas *)
union(ri, rj); nconexas := nconexas - 1
end (* if ri rj *)
end (* while nconexas y hay *)
• Al finalizar, además de las aristas, podemos imprimir la cantidad de componentes
conexas, nconexas, donde sabemos que |nconexas| =1⇔ el grafo
es conexo y las aristas elegidas forman un árbol.
Problema 13.11 (Algoritmo de Kruskal para el mínimo árbol generador).
Hacer un programa con las indicaciones dadas, y verificarlo con las
mismas entradas que en el problema 13.9 (figura 13.3). Es posible que la solución
sea distinta. ✄
✎ En nuestra implementación de Kruskal, la fuente de mayor ineficiencia
está enlaselección de la arista de menor peso. En nuestra variante se tarda
alrededor de m pasos en ubicarla, mientras que puede hacerse en el orden de
log 2 m pasos. Tal cual está planteado, el algoritmo puede tardar del orden
de m 2 pasos por el ordenamiento, pero en variantes más eficientes puede
tardar del orden de m log 2 m pasos. Aún con nuestra implementación, el
comportamiento para “grafos típicos” es mejor que el de Prim.
13.7. Comentarios Bibliográficos
La presentación unificada de los algoritmos visitar, Dijkstra y Prim está basada
en [12].

Capítulo 14
Punteros y listas
encadenadas
La lista encadenada surge de la necesidad de evitar la rigidez de la estructura
de arreglo. Recordemos que los arreglos tienen una dimensión predefinida (en
el programa fuente) que a veces resultará excesiva o escasa, dependiendo de la
aplicación. También es muy difícil eliminar o agregar un elemento intermedio,
pues debemos hacer un corrimiento de varios valores del arreglo (por ejemplo,
en el método de clasificación por inserción directa).
En contraste, veremos que la lista encadenada es una estructura dinámica,
que se va construyendo y modificando de acuerdo a los datos que se ingresan.
Para construir una lista encadenada, necesitamos la noción de puntero o
apuntador, que introducimos a continuación.
14.1. Punteros
Recordemos que las variables que hemos usado hasta ahora ocupan un lugar
de memoria, que será más grande o más chico dependiendo de su tipo, y que
pensamos como “cajas”. Para reconocer una variable le hemos dado un nombre
—su identificador— que tienen sentido para nosotros. Pero para la máquina, una
vez compilado el programa, los nombres desaparecen y en cambio identifica cada
variable por la dirección de memoria en la que empieza la caja y su contenido
(y por lo tanto su longitud).
Podemos pensar que un puntero es una variable donde nosotros guardaremos
direcciones de memoria donde empiezan cajas. Aunque todas las direcciones
(para una máquina y sistema operativo dados) ocupan el mismo espacio, en
Pascal debemos agregar en la declaración de un puntero el tipo al cual “apunta”
o “referencia” (esto es una propiedad del lenguaje, protegiéndonos de posibles
errores).
Por ejemplo, si queremos alojar en el puntero p una dirección de memoria
en la que se guardará un entero, declaramos
var p: ^integer
✎ El símbolo ‘ ^ ’ es una abreviatura de ‘ ↑ ’, que normalmente no existe en
los teclados.

Pág. 156 Punteros y listas encadenadas
En este caso, al comienzo del programa p no tiene asignado valor alguno
(como sucede con variables de otros tipos). Para indicar que p no tiene una caja
relacionada, es muy conveniente y aconsejable (para evitar problemas) asignarle
una dirección “imposible” que en Pascal se denomina nil:
p := nil
Podemos interpretar a nil como “un cable a tierra”, que indica que no hay
“nada”. Recordemos que justamente hemos usado con el mismo sentido a la
variable nada en el programa arbolbinario (pág. 197).
A pesar de que, habiéndolo declarado, p ocupa un lugar de memoria, ese
lugar es sólo para guardar direcciones, y puede no coincidir con la cantidad de
espacio necesaria para guardar, por ejemplo, un entero. Si además queremos
reservar un lugar para guardar un entero, usamos “ new ”:
new(p)
Esta instrucción hace que se reserve un lugar en memoria —la famosa “caja”—
para alojar un dato de tipo entero (en este caso), y guarda en p la dirección
de ese lugar, dejando a la caja disponible pero sin valor asignado.
✎ Es posible que no haya más memoria para reservar, cosa improbable con
las computadoras actuales y los programas que nosotros usaremos, por lo
que no nos preocuparemos por esta eventualidad. En programación más
“seria” también debemos preocuparnos por dejar libres los lugares obtenidos
mediante “ new ”yqueyanoserán usados, que en Pascal se hace
mediante “ dispose ”(quenoveremos).
La variable (entera) a la que ahora “apunta” p se indica por pˆ. Así, si
queremos poner el número3allí, hacemos
p^ := 3;
Es un error hacer una asignación a pˆ sin haber
hecho antes una reserva de espacio con “ new ”.
En la figura 14.1 esquematizamos la variable p yla“caja”pˆ alaque
apunta. El valor alojado en p será asignado por la máquina al hacer “ new(p) ”
y desconocido por nosotros, mientras que pˆ tiene alojado el valor 3 hecho
por la asignación “ p^:= 3 ”. Los tamaños de las “cajas” p y pˆ notienenpor
qué coincidir.
p
3
pˆ
Figura 14.1: El puntero p y la variable apuntada pˆ.

14.2. Listas encadenadas Pág. 157
En (estándar) Pascal no es posible obtener la dirección de memoria de una
variable. Por ejemplo si n es una variable entera, no podemos asignar a p la
dirección de n. Por supuesto que no podemos hacer
p := n (* incorrecto! *)
pero si p y q son punteros del mismo tipo (declarado mediante “ type ”), es legal
hacer
q := p
aún cuando p o q no hagan referencia a dato alguno, ya que estamos copiando
en q la dirección guardada en p. Por otro lado, supuesto que p y q sean del
mismo tipo y que ambos se hayan “inicializado” con new, podemos copiar los
contenidos de una caja a la otra mediante
q^ := p^
Nuestro interés en este tipo de variables es en la creación de listas encadenadas.
14.2. Listas encadenadas
Una lista encadenada, o simplemente lista (1) , consiste en una serie de elementos,
llamados nodos (2) unidos entre sí. Los nodos son registros (“ record ”’s),
uno de cuyos campos es un puntero que señala al próximo elemento de la lista.
Una declaración típica para los nodos es:
type
ptrnodo = ^nodo;
nodo = record
info: integer; (* puede haber mas de un
campo de este estilo *)
siguiente: ptrnodo
end;
Observar que la definición de los nodos es de alguna forma recursiva, ya que
el tipo “ ptrnodo ”sólo puede definirse si está definido el tipo “ nodo ”, que a
su vez sólo puede definirse si está definido el tipo “ ptrnodo ”. Sin embargo esta
recursión es un tanto aparente pues las direcciones de memoria siempre ocupan
el mismo lugar (que dependerá de la computadora y sistema operativo). Así, la
reserva de espacio para “ ptrnodo ” es siempre la misma, independientemente
del espacio que deba reservarse para una variable de tipo “ nodo ”.
Las listas encadenadas tienen asociados un puntero donde se guarda la dirección
donde comienza la lista. En nuestra implementación consideraremos que
todos los nodos de la lista tienen información (3) , por lo que la lista “vacía” tiene
el puntero asociado en nil (como nada en el programa arbolbinario). Del mismo
modo, si la lista no es vacía, su último nodo apunta a nil como sucesor.
(1) A veces, para confundir, también hablamos de listas cuando nos referimos a arreglos.
(2) Como en los árboles binarios o grafos dirigidos. En realidad, las listas encadenadas se
pueden pensar como grafos dirigidos.
(3) Nuestra presentación difiere de otras donde siempre hay al menos un nodo.

Pág. 158 Punteros y listas encadenadas
En forma similar a la descripción que hicimos de pilas o colas en general en
la sección 12.1 (pág. 119), las operaciones fundamentales con listas son: inicialización,
agregar nodos a la lista, sacar nodos y recorrer la lista.
Suponiendo que lista es la variable declarada como “ ptrnodo ” que guarda
el comienzo de la lista, tenemos:
Inicialización de lista. Al comienzo la lista no tiene nodos, y ponemos
lista := nil
Agregar un nodo a la lista. Si queremos agregar el nodo p de tipo ptrnodo
“adelante” en la lista, ponemos
p^.siguiente := lista; lista := p
pero puede ser que querramos construir la lista de otra forma, por ejemplo
si queremos que esté ordenada.
Si queremos agregar siempre atrás, es conveniente guardar también la dirección
del último nodo de la lista, y debe preverse en la inicialización.
Agregar un nodo antes o después de otro. Supongamos que p y q son del
tipo “ ptrnodo ”, que pˆ esunelementodelalistayqˆ debe agregarse
después de pˆ. El esquema simple es:
q^.siguiente := p^.siguiente; p^.siguiente := q
Si se desea insertar qˆ antes que pˆ, y no conocemos el antecesor de pˆ,
podemos insertar qˆ después de pˆ y luego intercambiar las datos correspondientes:
q^.siguiente := p^.siguiente; p^.siguiente := q;
temp := p^.info; p^.info := q^.info; q^.info := temp
Eliminar un elemento. Para sacar el nodo siguiente a pˆ, podemos hacer:
q := p^.siguiente; p^.siguiente := q^.siguiente
No podemos eliminar el nodo pˆ si no conocemos su antecesor (salvo que
sea el primero de la lista). En este caso habrá que recorrer la lista hasta
encontrar pˆ, guardando información sobre los antecesores.
Recorrer la lista. Es bastante sencillo en nuestro caso (donde no hay nodos
especiales para el principio o fin de lista):
p := lista;
while (p nil) do begin
haceralgo; (* haceralgo con p o p^ *);
p := p^.siguiente
end

14.2. Listas encadenadas Pág. 159
Problema 14.1. En el programa listas (pág. 206) se ven algunas posibilidades
para construir listas, tanto agregando nodos adelante como en el medio para
formar una lista ordenada por id, y el recorrido de una lista, para buscar una
información o imprimir. Al final del listado del programa damos un ejemplo de
salida (pág. 209).
a) Estudiar cuidadosamente los distintos tipos de listas y la salida.
b) Agregar un procedimiento o función para contar los elementos de una lista,
imprimiendo luego el número. ✄
Problema 14.2 (Listas recursivas). La definición de alguna forma recursiva
del tipo “ ptrnodo ” nos hace pensar que podemos usar recursión para varias de
las tareas.
a) Por ejemplo, para imprimir una lista podríamos usar:
procedure enorden (p: ptrnodo);
begin
if (p nil) then begin
with p^.info do writeln(nombre:tamanio, id:10);
enorden(p^.siguiente)
end
end;
haciendo la llamada a “ enorden(lista)” (eventualmente imprimiendo un
cartel antes si la lista es vacía). Agregar este procedimiento para comprobar
su comportamiento.
b) Cambiar el procedimiento enorden por enordeninverso, enelqueprimero
se hace la llamada recursiva y luego se imprime info, y verificar su comportamiento.
✄
Problema 14.3. Hacer un procedimiento para construir una copia de una lista
encadenada, es decir, una lista con tantos nodos como la original, y en la cual
la información se guarda en el mismo orden que la lista original. ✄
Problema 14.4. Hacer un procedimiento para “invertir” una lista de modo de
que el nodo que estaba en primer lugar esté al final en la nueva lista y viceversa,
etc., sin crear nuevos nodos (i.e. sin usar “ new ”).
Sugerencia: ir formando una nueva lista en la que se incorpora el primer nodo
de la vieja, borrándolo de la vieja, y continuar hasta terminar la lista original.
Sugerencia si la anterior no alcanza: usar el esquema
procedure darvuelta(var lista: ptrnodo);
var p, q: ptrnodo;
begin
q := lista; lista := nil;
while (q nil) do begin
p := q; q := q^.siguiente;
p^.siguiente := lista; lista := p
end
end;
✎ El problema 8.3 hacía lo mismo para un vector, pero la técnica es muy
diferente. En cambio, el esquema propuesto usa la idea del procedimiento
“ enordeninverso ”delproblema14.2, agregando el nodo adelante en vez
de imprimir. ✄

Pág. 160 Punteros y listas encadenadas
Problema 14.5 (El problema de Flavio Josefo II). Implementar una solución
a este problema (problema 6.7) usando en vez de arreglos una lista circular,
i.e. el “último” nodo se encadena al “primero”, donde cada nodo representa una
persona, y la eliminación se traduce en eliminar el nodo de la lista. El programa
debe imprimir la permutación de Flavio Josefo.
Sugerencia: crear una lista quedan de los que “quedan”, inicialmente con los valores
1,...,n, donde el último nodo apunta al primero en vez de a nil. A medida
que se eliminan nodos de quedan, ir formando la permutación de Flavio Josefo.
En cada paso de “eliminación”, guardar información sobre el nodo anterior al
eliminado, para eliminar el nodo y poder contar m de los que quedan a partir
de él.
✎ Recordar también el uso de “ mod ”enelproblemaoriginal. ✄
Problema 14.6. Siguiendo las ideas del problema 14.4 y del procedimiento
ordenada en el programa listas (pág. 206), hacer un procedimiento para ordenar
(por alguna llave) una lista ya ingresada sin generar nuevos nodos. ✄
Problema 14.7. Si una lista se modifica sólo agregando adelante o quitando
el primer elemento, tenemos la estructura de “pila” que hemos usado para resolver
el problema de las torres de Hanoi (problema 11.5). Hacer un programa
resolviendo ese problema usando listas encadenadas en vez de arreglos. ✄
14.3. Otras estructuras dinámicas
En la construcción de listas, hemos colocado un puntero en los registros
(“records”) para apuntar al siguiente elemento en la lista terminando con nil
o volviendo a apuntar al principio de la lista para formar una lista “circular”.
También podemos pensar en agregar en cada registro un puntero para señalar
al elemento anterior (formando una lista doblemente encadenada), pero siempre
podemos visualizar estas listas como “lineales” o “unidimensionales”.
Podemos pensar, en cambio, en agregar punteros en los registros de modo
de señalar a otras listas, que pueden tener el mismo tipo de registros o no.
Si por ejemplo en el programa listas en vez de tener los nodos un campo
para punteros, tenemos dos, y llamamos al primero “izquierdo” y al segundo
“derecho”, obtenemos otra implementación de los árboles binarios ordenados
que vimos en la sección 12.6, reemplazando la “pila” del arreglo por listas encadenadas.
Problema 14.8. Declarando
type
ptrnodo = ^nodo;
nodo = record
llave: integer; (* numero leido *)
cuenta: integer; (* veces que aparecio *)
izquierda: ptrnodo; (* hijo a la izquierda *)
derecha: ptrnodo (* hijo a la derecha *)
end;
rehacer el programa arbolbinario (pág. 197) reemplazando los arreglos por listas
encadenadas, y luego realizar los incisos del problema 12.6. ✄

14.3. Otras estructuras dinámicas Pág. 161
Recordemos que en el problema 8.6 estudiamos un arreglo bidimensional
donde el primer índice indicaba el número de renglón, mientras que el segundo
índice indicaba el número de carácter dentro de ese renglón. Al tener la estructura
de arreglo una dimensión fija, estamos desperdiciando mucho espacio si
queremos tener renglones de tamaños muy diferentes, o si no tenemos mucha
idea de cuántos renglones habrá en el texto completo. Es mucho más apropiado
tomar una lista encadenada, representando cada renglón, y donde sus nodos
apuntan no sólo al siguiente renglón sino también a una lista con el texto de ese
renglón. Los editores de textos trabajan con una estructura similar (escribiendo
luego secuencialmente en el disco cuando guardamos el archivo).
Un problema matemático donde se puede usar una idea similar es en grafos,
al tener la descripción por lista de aristas o por vértices adyacentes a otro dado.
Problema 14.9. Como hemos visto en el capítulo anterior, un grafo G consiste
de un conjunto de vértices V = {1, 2,...,n}, y un conjunto de aristas E, donde
cada arista es de la forma {u, v} con u, v ∈ V , u = v (y supondremos que no
hay aristas repetidas).
Es usual representar los vértices mediante puntos y las aristas con segmentos
o curvas que unen los vértices, como se muestra en la figura 13.1 (pág. 134), en
donde n =6yE = {{1, 2}, {1, 3}, {2, 3}, {2, 6}, {3, 4}, {3, 6}, {4, 6}}.
Por otra parte, en vez de describir G mediante E (y V ), podríamos hacerlo
a partir de las listas de adyacencias o vecinos: para cada u ∈ V el conjunto de
vértices {v ∈ V : {u, v} ∈E}. En el ejemplo anterior, podríamos poner:
1 →{2, 3}, 2 →{1, 3, 6}, 3 →{1, 2, 4, 6}, 4 →{3, 6}, 5 →∅, 6 →{2, 3, 4}.
Para representar el grafo en la computadora usando listas encadenadas (4) ,
podemos recurrir a las estructuras:
Para lista de aristas: Una lista de aristas, donde cada arista se representa
mediante
ptrarista = ^arista;
arista = record u, v: integer; s: ptrarista end;
Para lista de adyacencias: Una lista de vértices, donde cada vértice
tiene un puntero a una lista de vecinos:
ptrvecino = ^vecino;
vecino = record id: integer; s: ptrvecino end;
ptrvertice = ^vertice;
vertice = record
id: integer;
s: ptrvertice;
vecinos: ptrvecino
end;
El programa grafos (pág. 209) imprime la listas de adyacencias si el grafo
es ingresado dando n y E. Estudiarlo y modificarlo de modo de realizar la
operación inversa, i.e. imprimir los aristas cuando el grafo se ingresa dando n y
las listas de adyacencias. ✄
(4) En el capítulo 13 hemos considerado algunas representaciones con arreglos y matrices.

Pág. 162 Punteros y listas encadenadas
14.4. Problemas Adicionales
Problema 14.10 (Ciclo de Euler). En el problema 13.7 nos hemos referido
a la existencia de ciclos de Euler, y nos preocuparemos ahora por encontrar
efectivamente uno.
Para demostrar que un grafo conexo con todos los vértices de grado par tiene
unciclodeEuler,secomienzaapartirdeunvértice y se van recorriendo aristas
y borrándolas hasta que volvamos al vértice original, formando un ciclo. Esto
debe suceder porque todos los vértices tienen grado par. Puede ser que el ciclo
no cubra a todas las aristas, pero como el grafo es conexo, debe haber un vértice
en el ciclo construido que tenga una arista (aún no eliminada) incidente en él, a
partir del cual podemos formar un nuevo ciclo, agregarlo al anterior y continuar
con el procedimiento hasta haber eliminado recorrido todas las aristas.
Esta demostración es bien constructiva, y podemos implementar los ciclos
como listas encadenadas. La implementación de aristas, etc. puede hacerse con
arreglos o matrices.
Hacer un programa para decidir si un grafo ingresado como en el programa
anchoprimero (pág. 199) es conexo y todos los vértices tienen grado par, y
en caso afirmativo construir e imprimir un ciclo de Euler. ✄
14.5. Comentarios Bibliográficos
La presentación de punteros y listas encadenadas está basada en [16], tomando
también ideas de [10].

Capítulo 15
Más problemas
En este capítulo agregamos más problemas para los entusiastas o los que simplemente
quieran practicar más (¡por ejemplo para algún examen!), no estando
ordenados ni por tema ni por dificultad.
Problema 15.1 (Polinomios interpoladores de Lagrange). Un polinomio
P (x) =anx n + an−1x n−1 + ···+ a1x + a0, de grado a lo sumo n, está determinado
por los n + 1 coeficientes. Supongamos que no conocemos los coeficientes,
pero podemos conocer los valores de P (x) en algunos puntos, ¿cuántos puntos
necesitaremos para determinar los coeficientes? Como hay n + 1 coeficientes,
es natural pensar que quedarán determinados por n + 1 ecuaciones, i.e. que
bastarán n + 1 puntos.
Este resultado es cierto, y se puede demostrar planteando un sistema de n+1
ecuaciones lineales, y viendo que su determinante —de Van der Monde— que
se estudia en Álgebra Lineal es no nulo.
Dados (xi,yi), i =1,...,n+1, elpolinomio interpolador de Lagrange se
define como
n+1
P (x) =
yi
xi − xj
i=1 j=i
x − xj
. (15.1)
✎ El polinomio en general resulta de grado ≤ n, y no necesariamente n.
Pensar, por ejemplo, en 3 puntos sobre una recta: determinan un polinomio
de grado 1 y no 2.
✎ En cálculo numérico se ven formas más eficientes (esencialmente extensiones
de la regla de Horner) para el cómputo de estos polinomios interpoladores.
1
0.5
π
6
π
4
π
2
Figura 15.1: Aproximación de sen x (en trazo discontinuo) mediante un polinomio
de grado 3.
π

Pág. 164 Más problemas
a) Ver que efectivamente, P (x) definido por la ecuación (15.1)satisfaceP (xi) =
yi para i =1,...,n+1.
b) Desarrollar un procedimiento para evaluar P (x) dado por la ecuación (15.1),
donde los datos son (xi,yi), 1 ≤ i ≤ n +1, y x. Aclaración: sólose pide una
traducción “literal” de la ecuación (15.1).
c) Utilizarlo en un programa que calcule los coeficientes del polinomio de grado
a lo sumo 3 que pasa por los puntos (−1, 0), (0, 1), (1, 0), (2, 2),enelpunto
x = −2.
d) Ampliar el programa para calcular una aproximación de sen π/4, usando los
valores del seno para 0,π/6,π/2yπ.
✎ Es usual poner π =4×arctan 1, aunque en este problema en particular
no se necesita un valor específico de π (considerar la función sen πx en
vez de sen x).
La figura 15.1 muestra cómo se parecen las gráficas de sen x y el polinomio
en el intervalo [0,π].
Aunque considerado como francés, Joseph-Louis Lagrange (1736–1813) nació
enTurín (Italia) como Giuseppe Lodovico Lagrangia.
Lagrange fue uno de los fundadores del “cálculo de variaciones” (área relacionada
con la mecánica) y las probabilidades, e hizo numerosas contribuciones
en otras áreas como astronomía y ecuaciones diferenciales. ✄
Problema 15.2 (Cuenta de Goldbach). En el problema 5.23 hablamos de
la conjetura de Golbach, que todo número par mayor o igual a 6 puede escribirse
como suma de dos primos impares.
La cuenta de Goldbach es la cantidad de formas en las que un número par
puede escribirse como suma de dos primos impares. Por ejemplo, 20 = 13 + 7 =
17 + 3, por lo que la cuenta de Goldbach de 20 es 2.
Hacer un programa para determinar la cuenta de Goldbach de todos los
pares entre 2 y 10000, y encontrar el máximo. ✄
Problema 15.3. Hacer un programa para simular el juego de la generala en el
que se tiran 5 dados (una única vez), y se tiene “full” cuando hay 3 dados con
un mismo número y los otros 2 con otro número, “póker” cuando hay 4 dados
iguales, “escalera” cuando hay 5 números consecutivos, y “generala” cuando los
5 dados son iguales. Sugerencia: una vez “tirados” los dados, clasificarlos para
determinar si se ha obtenido alguno de los juegos. ✄
Problema 15.4 (Visibilidad en el plano). Consideremos el reticulado C
definido por los puntos del plano con ambas coordenadas enteras. Diremos que
el punto P ∈Ces visible (desde el origen O) si el segmento que une P y O no
contiene otros puntos de C distintos de P y O.
a) Si a, b ∈ N, entonces (a, b) es visible ⇔ mcd(a, b) =1.
b) Desarrollar un programa que dado n ∈ N calcule sn, la cantidad de puntos
visibles en el cuadrado 1 ≤ a, b ≤ n.
c) Se puede demostrar que a medida que n crece, pn = sn/n2 se aproxima
a p =6/π2 =0.6079 ....Calcularpnpara distintos valores de n para ver
que este es el caso. Sugerencia: empezar con n pequeño e ir aumentando
paulatinamente su valor. ✄

Problema 15.5 (Aproximando e con dados). Hacer un programa para
simular una máquina que emite números al azar (uniformemente distribuidos)
en el intervalo (0, 1) uno tras otro hasta que su suma excede 1. Comprobar que
al usar la máquina muchas veces, la cantidad promedio de números emitidos es
aproximadamente e =2.71828 ....
✎
Éste es otro ejemplo del método de Monte-Carlo, esta vez para aproximar
e. ✄
Problema 15.6 (Generando “manos” aleatoriamente). Queremos resolver
el problema de encontrar una “mano” de los números enteros entre 1 y n, es
decir, queremos “mezclar” un mazo de n cartas de un mismo palo (matemáticamente,
obtener una permutación aleatoria de los números entre 1 y n).
Presentamos varias posibilidades:
a) Imaginando que empezamos con la cartas numeradas de 1 a n, ordenadas
crecientemente, hacemos el siguiente procedimiento: sacamos una carta al
azar entre 1 y n y la separamos, de las restantes sacamos una al azar (entre
1yn − 1) y la separamos, y así sucesivamente. Sin embargo, computacionalmente
esta tarea no es sencilla, debido al manejo que debemos hacer de
listas.
b) Una variante es: al elegir la primera carta la colocamos adelante y ponemos
la primera carta en el lugar de la elegida. Luego elegimos al azar alguna de
las cartas que están en las posiciones entre 2 y n y la intercambiamos con la
segunda, y así sucesivamente. Implementar esta idea computacionalmente.
c) En el algoritmo anterior, podríamos reemplazar el intercambiar la carta
elegida con la primera, después con la segunda, etc., por intercambiar con
la última, después con la ante-última, etc. Implementar también esta idea
computacionalmente.
d) Usando alguno de los algoritmos anteriores, hacer un programa para simular
una “mano” de m cartas de un total de n. Por ejemplo, para un jugador en
el truco elegiríamos m =3yn = 40.
✎ ¡Noesnecesariogenerartodalapermutación!
Aunque el problema de las “manos” es muy sencillo de plantear, y se usa
con mucha frecuencia, encontrar algoritmos correctos y eficientes no es sencillo.
La corrección de un algoritmo se refiere a que 1) todas las permutaciones
de 1,...,n se pueden generar de esta forma, y 2) con igual probabilidad. Otro
problema es el de decidir su eficiencia: cuánto tiempo e intercambios realiza en
términos de n. Ninguna de estas preguntas es fácil de responder.
✎ Observar la similitud entre la clasificación por selección directa o inserción
directa con la obtención de “manos” aleatorias en los incisos b) ya)
respectivamente.
Estas similitudes son la base para el estudio teórico de los métodos de
clasificación: peor caso, caso promedio, etc.
✎ El algoritmo en b) estápresentadoen[11, Vol.2,pág. 126], donde se hacen
los análisis de corrección y eficiencia. Es atribuído independientemente a
L. E. Moses y R. V. Oakford (1963) y R. Durstenfeld (1964).
✎ Existen muchos otros algoritmos relacionados con este problema. Los interesados
pueden consultar el libro de Knuth ya mencionado. Otro algoritmo
interesante, debido a R. Floyd, está descripto en [2]. ✄
Pág. 165

Pág. 166 Más problemas
Problema 15.7 (Clasificación por fusión). Los métodos elementales usan
del orden de n 2 comparaciones y/o asignaciones para clasificar un arreglo de
longitud n. En contraposición, los métodos más avanzados usan del orden de
n × log 2 n operaciones. Entre los más “populares” de este tipo podemos mencionar
al heapsort o clasificación por montón, quicksort o clasificación rápida, y
clasificación por fusión o mezcla (ya mencionado en la sección 10.3), que veremos
ahora.
No es difícil explicar este último método, cuya idea es dividir el arreglo
de a pares, y luego ir fusionando —como en el problema 10.4— los subarreglos:
primero juntar pares consecutivos, luego cuaternas consecutivas, etc. hasta llegar
obtener el arreglo completo. Por ejemplo, el método realiza los siguientes pasos
al clasificar (3, 6, 7, 5, 4, 1, 2):
1. 3 6 75412 se juntan de a pares (o lo que se pueda),
2. 3 6 57142 se ordena cada par (i.e. se “fusiona” cada grupo),
3. 3 6 57142 se agrupan de a cuatro (o lo que se pueda),
4. 3567124 se “fusiona” cada grupo,
5. 3567124 se agrupan de a ocho (o lo que se pueda),
6. 1234567 y se fusionan.
A fin de implementar este algoritmo, usamos el procedimiento clasificar que
llama, a su vez, al fusionar:
procedure fusionar(
var a, b: arreglo; (* entra a, sale b *)
inic, medio, fin: integer (* partes a fusionar *)
);
var
i, j, k: integer;
begin
i := inic; j := medio + 1; k := inic - 1;
repeat
k := k + 1;
if (a[i] medio) or (j > fin));
(* copiar lo que falta *)
while (j

a2: arreglo;
begin
k := 1; (* tamanio de subarreglos a fusionar *)
veces := 0; (* las veces que paso por el lazo *)
while (k < n) do begin
veces := veces + 1; k2 := 2 * k;
i := 1; m := k; f := k2;
if ((veces mod 2) = 0) then begin
while (f

Pág. 168 Más problemas
ficar que su comportamiento es correcto, y cotejar el número de asignaciones
(entre arreglos) y comparaciones con los otros algoritmos elementales a fin
de obtener un cuadro similar al 10.1 (sin los tiempos, y para arreglos más
chicos). ✄
Problema 15.8. Al estudiar los datos numéricos (a1,a2,...,an) estadísticamente,
se consideran (entre otros) tres tipos de “medidas”:
La media o promedio: 1
n
ai.
n
i=1
La mediana: Intuitivamente es un valor aℓ tal que la mitad de los datos
son menores o iguales que aℓ y la otra mitad son mayores o iguales que
aℓ. Para obtenerla, se ordenan los datos y la mediana es el elemento
del medio si n es impar y es el promedio de los dos datos en el medio
si hay un número par de datos.
✎ En realidad no es necesario ordenar todos los datos para obtener
la mediana. Por otra parte, observar que la mediana puede no
serundatoenelcasoden par.
La moda: Es un valor aℓ con frecuencia máxima, y puede haber más de
una moda.
Por ejemplo, si los datos son 8, 0, 4, 6, 7, 8, 3, 2, 7, 4, la media es 4.9, la mediana
es 5, y las modas son 4, 7 y 8.
Hacer un programa para generar aleatoriamente un arreglo de longitud n
de números entre 0 y 9, y luego encontrar la media, mediana y moda/s (n es
ingresado por el usuario). ✄
Problema 15.9 (Números de Fibonacci: Zeckendof (1972)). Todo número
entero se puede escribir, de forma única, como suma de (uno o más) números
de Fibonacci no consecutivos, es decir para todo n ∈ N existe una única representación
de la forma
n = b2f2 + b3f3 + ···+ bmfm,
donde bm =1,bk ∈{0, 1}, ybk · bk+1 =0parak =2,...,m− 1.
Por ejemplo, 10 = 8 + 2 = f6 + f3,27=21+5+1=f8 + f5 + f1.
Hacer un programa para calcular esa representación (dando por ejemplo una
lista de los índices k para los que bk =1en(15.9)). Comprobar con algunos
ejemplos la veracidad de la salida. ✄
Problema 15.10 (La Cola del Supermercado). Hacer un programa que
simule una “cola”, donde el tiempo entre dos llegadas consecutivas de clientes
puede considerarse como un número entero (aleatorio y uniformemente distribuido)
de entre 1 y 5 minutos. Suponer que la atención de cada cliente dura
un tiempo fijo de 2 minutos. Hacer la simulación por un período de 8 horas,
computando el porcentaje de uso del servicio, el tiempo que no se ha usado,
la longitud promedio de la cola, el tiempo de espera promedio de los clientes
ycuántos clientes no fueron atendidos al final del período (se supone que los
clientes pueden comenzar a ser atendidos hasta el último instante). Variar los
datos de frecuencia de clientes y tiempo de atención para ver cómo varía el
comportamiento de la “cola”, por ejemplo incrementar el tiempo de atención de
2 a 5 minutos. Discutir estos resultados, experimentando: tiempo de atención

para que los clientes no esperen más de 3 minutos (en promedio), o para que la
cola no crezca indefinidamente, etc. ✄
Problema 15.11 (La Producción de la Fábrica). Supongamos que una
pequeña empresa fabrica un cierto tipo de producto. La empresa quiere contratar
obreros, cada uno de los cuales, con las herramientas disponibles, podrá fabricar
28 unidades diarias del producto. Nuestro objetivo es, mediante simulación,
determinar la cantidad de obreros necesarios para que el atraso en la producción
sea razonable, sin tener mano de obra ociosa excesiva. (Suponemos que no se
mantiene stock).
De experiencia anterior se sabe que los pedidos diarios del producto (la
demanda) sigue en promedio una distribución como se indica:
promedio pedido (unidades) 100 200 300 400 500 600
frecuencia 0.15 0.25 0.18 0.22 0.13 0.07
a) Hacer un programa para analizar la producción diaria durante un cierto
período, digamos durante 30 ó60días, para ver qué cantidad de obreros
será necesaria.
b) Comprobar que los pedidos siguen (aproximadamente) la ley dada por las
frecuencias. (O sea que hay pedidos de 100 el 15 % de las veces, de 200 el
40 %, etc.). Tal vez sea conveniente aumentar la longitud del período de
simulación. ✄
Problema 15.12 (Pasos en búsqueda binaria). La función f que estudiamos
en este problema está relacionada con la cantidad de pasos que se realizan
en la búsqueda binaria cuando hay n elementos.
Consideremos f : N → N definida por f(n) =⌊(n +1)/2⌋, yparak ∈ N,
F (k, n) =f k (n) =f(···(f(n))
···).
k veces
a) Hacer un programa para calcular F (k, n) usando un lazo “ for ”, recordando
que para n ∈ N, ⌊(n +1)/2⌋puede escribirse en Pascal como (n + 1) div
2.
b) ¿Cuál es el valor de F (k, 2k )? (probar con el programa para algunos valores
de k, hacer una conjetura y tratar de demostrarla).
c) Para cada n>2, existe j = g(n) talqueF (k, n) > 1sik

Pág. 170 Más problemas
A, toma cualquier número de fósforos de un fila, pudiendo tomar
uno, dos o hasta toda la fila, pero sólo debe modificar una fila. El
jugador B juega de manera similar con los fósforos que quedan, y
los jugadores van alternándose en sus jugadas. Gana el jugador que
saca el último fósforo.
Veremos que, dependiendo de la posición inicial, uno u otro jugador tiene
siempre una estrategia ganadora. Para esto, digamos que una disposición de los
fósforos es una posición ganadora para el jugador X, sidejando X los fósforos
en esa posición, entonces no importa cual sea la jugada del oponente, X puede
jugar de forma tal de ganar el juego. Por ejemplo, la posición en la cual hay dos
filas con dos fósforos cada una, es ganadora: si A deja esta posición a B, B debe
tomarunoodosfósforos de una fila. Si B toma 2, A toma los dos restantes. Si
B toma uno, A toma uno de la otra fila. En cualquier caso, A gana.
a) Ver que la posición en donde hay 3 filas con 1, 2 y 3 fósforos respectivamente,
es ganadora.
Para encontrar una estrategia ganadora, formamos una tabla expresando el
número de fósforos de cada fila en binario, uno bajo el otro, poniendo en una
fila final “ P ” si la suma total de la columna correspondiente es par, e “ I ”en
otro caso. Por ejemplo, en las posiciones anteriores haríamos:
1 0
1 0
P P
y
0 1
1 0
1 1
P P
En el último ejemplo, es conveniente poner 01 en vez de sólo 1 en la primer
fila a fin de tener todas las filas con igual longitud.
Si la suma de cada columna es par decimos que la posición es correcta, y
en cualquier otro caso decimos que la posición es incorrecta. Por ejemplo, la
posición donde hay 1, 3 y 4 fósforos es incorrecta:
| = 0 0 1
| | | = 0 1 1
| | | | = 1 0 0
I I P
b) En este inciso, veremos que una posición en Nim es ganadora si y sólo si es
correcta.
i) Si ninguna fila tiene más de un fósforo, la posición es ganadora ⇔ hay
en total un número par de fósforos ⇔ la posición es correcta.
ii) Si un número a ∈ N, expresado en binario por (an,an−1,...,a1,a0)
(permitiendo an = 0) es reemplado por otro menor b (entero ≥ 0),
expresado en binario como (bn,bn−1,...,b1,b0), entonces para algún
i, 0≤ i ≤ n, las paridades de ai y bi son distintas.
iii) Por lo tanto, si el jugador X recibe una posición correcta, necesariamente
la transforma en incorrecta.
iv) Supongamos que estamos en una posición incorrecta, es decir, al menos
la suma de una columna es impar. Para fijar ideas supongamos que las
paridades de las columnas son

P P I P I P
Entonces hay al menos un 1 en la tercera columna (la primera con
suma impar). Supongamos, otra vez para fijar ideas, que una fila en la
cual esto pasa es (en binario)
- -
0 1 1 1 0 1
donde marcamos con “ - ”quelosnúmeros debajo están en columnas
de suma impar. Cambiando 0’s y 1’s por 1’s y 0’s en las posiciones
marcadas, obtenemos el número (menor que el original, expresado en
binario):
- -
0 1 0 1 1 1
Estáclaroqueestecambiocorrespondeaunmovimientopermitido,
haciendo la suma de cada columna par, y que el argumento es general.
v) Por lo tanto, si el jugador X recibe una posición incorrecta, puede
moverdemododedejarunaposición correcta.
vi) Si A deja una posición correcta, B necesariamente la convierte en
incorrecta y A puede jugar dejando una posición correcta. Este proceso
continuará hasta que cada fila quede vacía o contenga un único fósforo
(el caso i)).
c) En base a los incisos anteriores, y suponiendo que A y B siempre juegan de
modo óptimo, ¿quién ganará?
d) Ver que la “jugada ganadora” del inciso b.iv) nosiempreesúnica.
e) Desarrollar un programa que, ingresada una posición inicial en la forma de
una lista con el número de fósforos en cada fila, decida si la posición es
correcta o incorrecta, y en este caso encuentre una jugada ganadora.
f )¿cuál es la “estrategia” si el que saca el último fósforo es el que pierde? ✄
Comentarios Bibliográficos
El problema 15.4 está tomado de [4]. Para el problema 15.6, ver las citas
allí mencionadas. El problema 15.10 está tomado de [14], y el problema 15.11
de [1]. El juego de Nim (problema 15.13) y su solución está tomado de [6].
Pág. 171

Apéndice A
Programas mencionados
Problema 2.2: holamundo (pág. 10)
program holamundo(input, output);
(* primer programa *)
begin
writeln(’Hola Mundo!’);
writeln;
writeln(’y Chau!’)
end.
Problema 3.2: sumardos (pág. 16)
program sumardos(input, output);
(* sumar dos numeros enteros *)
var a, b: integer;
begin
writeln(’** Programa para sumar dos numeros enteros’);
writeln;
a := 1;
b := 2;
write(’La suma de ’, a);
write(’ y ’, b);
writeln(’ es ’, a + b);
writeln; writeln(’** Fin **’)
end.
Problema 3.3: leerdato (pág. 17)
program leerdato(input, output);
(* Leer un entero entrado por terminal *)
var a: integer;

Pág. 174 Programas mencionados
begin
writeln(’** Programa para leer un dato entero’);
writeln;
write(’Entrar un entero: ’); readln(a);
writeln;
writeln(’El entero leido es ’, a);
writeln; writeln(’** Fin **’)
end.
Problema 3.4: raiz (pág. 18)
program raiz(input, output);
(*
Obtener la raiz cuadrada de un numero real x.
Se supone que x no es negativo.
*)
var x, y: real;
begin
writeln(’** Calcular la raiz cuadrada de x **’);
writeln;
write(’Entrar x (> 0): ’); readln(x);
y := sqrt(x);
writeln;
writeln(’La raiz cuadrada de ’, x, ’ es ’, y);
writeln; writeln(’** Fin **’)
end.
Problema 3.7: enteroareal (pág. 20)
program enteroareal(input, output);
(* Asignar un entero a un real *)
var
a: integer;
x: real;
begin
writeln(’** Asignar un entero a un real’);
writeln;
write(’Entrar el valor del entero: ’); readln(a);
x := a;
writeln;
writeln( a, ’ cambiado a real es: ’, x);
writeln; writeln(’** Fin **’)
end.

segundos (Problema 3.13) Pág. 175
Problema 3.13: segundos (pág. 22)
program segundos(input, output);
(* Pasar de segundos a horas, minutos y segundos *)
var hs, mins, segs: integer;
begin
write(’** Programa para pasar de segundos’);
writeln(’ a horas, minutos y segundos’);
writeln;
write(’Entrar la cantidad de segundos: ’); readln(segs);
writeln;
writeln(segs, ’ segundos son equivalentes a ’);
mins := segs div 60; segs := segs mod 60;
hs := mins div 60; mins := mins mod 60;
writeln(hs, ’ hs, ’, mins, ’ mins, ’, segs, ’ segs.’);
writeln; writeln(’** Fin **’)
end.
Problema 3.16: positivo (pág. 22)
program positivo(input, output);
(* dice si un numero entero es positivo *)
var a: integer;
begin
writeln(’** Ver si un numero entero es positivo’);
writeln;
write(’Entrar un numero: ’); readln(a);
writeln;
writeln(’es positivo?: ’, a > 0);
writeln; writeln(’** Fin **’)
end.
Problema 3.18: caracteres1 (pág. 24)
program caracteres1(input, output);
(* pasar de caracter a numero y viceversa *)
var c: char; i: integer;
begin
writeln(’** Pasar de caracter a numero y viceversa’);
writeln;
write(’ Entrar un caracter: ’); readln(c);
writeln;
i := ord(c);
writeln(’ El numero de orden de ’, c, ’ es ’, i:1);

Pág. 176 Programas mencionados
(* i:1 indica que escribira i en un solo espacio,
o los que sean necesarios *)
write(’ Verificacion:’);
write(’ el caracter correspondiente a ’, i:1);
writeln(’ es ’, chr(i));
writeln; writeln(’** Fin **’)
end.
Problema 4.2: valorabsoluto (pág. 26)
program valorabsoluto(input, output);
(* encuentra el valor absoluto del numero real x *)
var x, y: real;
begin
writeln(’** Encontrar el valor absoluto de un numero real’);
writeln;
write(’Entrar el numero: ’); readln(x);
if (x >= 0) then y := x else y := -x;
writeln;
writeln(’El valor absoluto de ’, x, ’ es ’, y);
writeln; writeln(’** Fin **’)
end.
Problema 4.4: comparar (pág. 27)
program comparar(input, output);
(* decidir cual numero entero es mayor o si son iguales *)
var a, b: integer;
begin
writeln(’** Comparar dos numeros enteros’);
writeln;
write(’Entrar un numero entero: ’); readln(a);
write(’Entrar otro numero entero: ’); readln(b);
writeln;
if (a > b) then
writeln(a, ’ es mayor que ’, b)
else if (a < b) then
writeln(b, ’ es mayor que ’, a)
else
writeln(a, ’ es igual a ’, b);
writeln; writeln(’** Fin **’)
end.
Problema 4.5: caracteres2 (pág. 27)
program caracteres2(input, output);

esto (Problema 4.11) Pág. 177
(* decidir si un caracter es una letra mayuscula o
minuscula, o no es letra, comparando caracteres *)
var c: char;
begin
writeln(’** Decide si un caracter es una letra ’);
writeln(’ mayuscula o minuscula o no es letra’);
writeln;
write(’ Entrar un caracter: ’); readln(c); writeln;
write(c);
if (’a’

Pág. 178 Programas mencionados
(* hacer una tabla del seno donde los angulos
estan dados en grados *)
const pi = 3.14159265;
var
inicial, final, incremento, grados: integer;
radianes: real;
begin
writeln(’** Hacer una tabla del seno dando valores’);
writeln(’ inicial, final, y del incremento (en grados).’);
writeln;
write(’Entrar el valor inicial (en grados): ’);
readln(inicial);
write(’Entrar el valor final (en grados): ’);
readln(final);
write(’Entrar el valor de incremento (en grados): ’);
readln(incremento);
writeln;
writeln(’Angulo Seno’);
grados := inicial;
while (grados

cifras (Problema 4.16) Pág. 179
while (n > 0) do begin suma := suma + n; n := n-1 end;
writeln;
writeln(’ suma con while al reves: ’, suma:10:0);
(* 10:0 indica que el numero se escribe en
al menos 10 espacios, sin decimales *)
writeln; writeln(’** Fin **’)
end.
Problema 4.16: cifras (pág. 34)
program cifras(input, output);
(* determinar la cantidad de cifras significativas
(en base 10, ignorando el signo) de un entero
entrado por terminal.
E.g. 246 -> 3, -908 -> 3, pero 0 -> 1 *)
var a, b, c: integer;
begin
writeln(’** Determinar la cantidad de cifras de un’);
writeln(’ entero (sin tener en cuenta el signo)’);
writeln;
write(’Entrar el numero: ’); readln(a); writeln;
if (a < 0) then b := -a else b := a;
c := 0;
repeat
c := c + 1;
b := b div 10
until b = 0;
writeln(’La cantidad de cifras de ’, a:1, ’ es ’, c:1);
writeln; writeln(’** Fin **’)
end.
Problema 4.17: epsmin (pág. 34)
program epsmin(input, output);
(*
epsmin = menor numero real mayor que 0.
epsmaq = menor numero real que sumado a 1 da mayor que 1.
*)
var eps, x: real;

Pág. 180 Programas mencionados
begin
writeln(’** Determinacion de epsmin y epsmaq’); writeln;
x := 1;
repeat eps := x; x := x / 2 until (x = 0);
writeln(’epsmin es: ’, eps);
eps := 1;
while (1 + eps > 1) do eps := eps/2;
eps := 2 * eps;
writeln(’epsmaq es: ’, eps);
writeln; writeln(’** Fin **’)
end.
Problema 4.18: potencia (pág. 36)
program potencia(input, output);
(* calculo de potencias con exponente natural *)
var
x, pot: real;
n, i: integer;
begin
writeln(’** Calculo de la potencia x a la n’);
writeln;
write(’Entrar x (real): ’); readln(x);
write(’Entrar n (entero positivo): ’); readln(n);
pot := 1;
for i := 1 to n do pot := pot * x;
writeln;
writeln(x, ’ a la ’, n:1, ’ es ’, pot);
writeln; writeln(’** Fin **’)
end.
Problema 4.22: eolnprueba (pág. 38)
program eolnprueba(input, output);
(* prueba del funcionamiento de eoln *)
var a: integer;
begin

sumardatos (Problema 4.23) Pág. 181
writeln(’** Prueba del funcionamiento de eoln’);
writeln;
a := 1; writeln(’El valor de a es ’, a:1);
if (eoln) then a := 2 else a := 3;
writeln(’Ahora el valor de a es ’, a:1);
writeln; writeln(’** Fin **’)
end.
Problema 4.23: sumardatos (pág. 39)
program sumardatos(input, output);
(* Calcular la suma de datos entrados por terminal, donde
el fin de datos se indica con sin datos *)
var
s, x: real;
findatos: boolean;
begin
writeln(’** Calcular la suma de los datos entrados’);
writeln(’ indicando el fin de datos con doble ’);
writeln;
s := 0; findatos := false; (* inicializacion *)
repeat
write(’Entrar un dato (fin = ): ’);
if (eoln) then findatos := true
else begin readln(x); s := s + x end
until (findatos);
readln; (* para leer el ultimo fin de datos,
en este caso innecesario *)
writeln;
writeln(’La suma de los datos es ’, s);
writeln; writeln(’** Fin **’)
end.
Problema 5.10: babilonico (pág. 47)
program babilonico(input, output);
(*
Metodo babilonico o de Newton para aproximar
la raiz cuadrada de un real positivo
*)

Pág. 182 Programas mencionados
const
itmax = 10;
tol = 10e-5;
x0 = 1.0;
var
it: integer;
a, x, y: real;
begin
(* carteles *)
writeln(’** Metodo babilonico o de Newton para’);
writeln(’ aproximar la raiz cuadrada del numero’);
writeln(’ real positivo "a"’); writeln;
(* datos de entrada *)
write(’ Entrar a (> 0): ’); readln(a); writeln;
(* inicializacion *)
it := 1; x := x0; y := (x + a/x)/2;
(* lazo principal *)
while ((it tol)) do
begin x := y; y := (x + a/x)/2; it := it + 1 end;
(* salida *)
writeln(’Iteraciones realizadas: ’, it);
if (it > itmax) then
writeln(’** Iteraciones maximas excedidas **’);
writeln(’Solucion aproximada obtenida: ’, y:20:10);
(* fin *)
writeln; writeln(’** Fin **’)
end.
Problema 5.15: euclides (pág. 51)
program euclides(input, output);
(*
Algoritmo de Euclides, usando restos
en vez de restas sucesivas
*)
var a, b, r: integer;
begin
(* cartel de info *)
writeln(’** Algoritmo de Euclides para encontrar el ’);
write(’ maximo comun divisor entre dos enteros, ’);
writeln(’ mcd(a,b)’); writeln;

factoresprimos (Problema 5.20) Pág. 183
writeln(’Nota: mcd(0,0) definido como 0’); writeln;
(* datos de entrada *)
write(’ Entrar a: ’); readln(a);
write(’ Entrar b: ’); readln(b); writeln;
(* inicializacion: trabajar con no negativos *)
if (a < 0) then a := -a;
if (b < 0) then b := -b;
(* lazo principal *)
while (b 0) do begin r := a mod b; a := b; b := r end;
(* salida *)
writeln(’El maximo comun divisor es: ’, a:2);
(* fin *)
writeln; writeln(’** Fin **’)
end.
Problema 5.20: factoresprimos (pág. 53)
program factoresprimos(input, output);
(* Encontrar factores primos de un entero positivo *)
var
a, b, s, t: integer;
tesprimo: boolean;
begin
(* carteles *)
writeln(’** Encontrar los factores primos de un entero’);
writeln;
(* datos de entrada *)
write(’Entrar el entero (> 1): ’); readln(a); writeln;
(* inicializacion, lazo e impresion *)
t := a; tesprimo := false; b := 2;
repeat
s := trunc(sqrt(t));
while (((t mod b) 0) and (b s) then tesprimo := true
else begin (* b es factor de t (=> de a) *)
write(b:1, ’, ’);
t := t div b
end
until tesprimo;
writeln(t:1);

Pág. 184 Programas mencionados
(* fin *)
writeln; writeln(’** Fin **’)
end.
Problema 6.1: unidades (pág. 56)
program unidades(input, output);
(*
contar cuantos de los numeros ingresados
terminan en 0,1,...,9
*)
var
dato, digito: integer;
terminaen: array[0..9] of integer;
begin
writeln(’** Contar cuantos de los numeros ingresados’);
writeln(’ terminan en 0,1,...,9’);
writeln;
(* inicializar el arreglo *)
for digito := 0 to 9 do terminaen[digito] := 0;
(* entrar datos *)
write(’Entrar un entero (fin = ): ’);
while (not eoln) do begin
readln(dato);
digito := abs(dato) mod 10;
terminaen[digito] := terminaen[digito] + 1;
write(’Entrar un entero (fin = ): ’)
end;
readln;
(* salida *)
writeln;
writeln(’ Digito numero de datos’);
for digito := 0 to 9 do
writeln( digito:4, terminaen[digito]:20);
writeln; writeln(’** Fin **’)
end.
Problema 6.2: busquedalineal (pág. 57)
program busquedalineal(input, output);
(*
Dado un arreglo a1, a2,... y un elemento x, ver
si x = ai para algun i.

usquedalineal (Problema 6.2) Pág. 185
*)
const MAXN = 20;
var
i, ndatos, x: integer;
findatos, seencontro: boolean;
a: array[1..MAXN] of integer;
begin
(* carteles *)
writeln(’** Dado un arreglo a1, a2,...’);
writeln(’ ver si x = ai para algun i’);
writeln;
(* leer el arreglo *)
write(’Entrar enteros, senialando fin’);
writeln(’ con sin datos.’);
ndatos := 1; findatos := false;
repeat
write(’Entrar el dato ’, ndatos:1);
write(’ (fin = ): ’);
if (eoln) then begin (* no hay mas datos *)
findatos := true; readln end
else begin (* nuevo dato *)
readln(a[ndatos]); (* incorporarlo al arreglo *)
ndatos := ndatos + 1 (* para el proximo *)
end
until (findatos);
ndatos := ndatos - 1;
(* imprimir el arreglo *)
writeln(’El arreglo es: ’); writeln;
for i := 1 to ndatos do begin
write(a[i]:10);
if ((i mod 5) = 0) then writeln
end;
if ((ndatos mod 5) 0) then writeln;
writeln;
(* elemento a buscar *)
write(’Entrar el entero x a buscar: ’); readln(x);
writeln;
(* lazo principal: suponemos ndatos > 1 *)
i := 0;
repeat
i := i + 1;
seencontro := (a[i] = x)
until (seencontro or (i = ndatos));

Pág. 186 Programas mencionados
(* resultados y fin *)
if (seencontro)
then writeln(’Se encontro en la posicion ’, i:1)
else
writeln(’No se encontro’);
writeln; writeln(’** Fin **’)
end.
Problema 6.5: eratostenes (pág. 59)
program eratostenes(input, output);
(* Criba de Eratostenes para encontrar primos *)
const MAXP = 10000; (* maximo primo *)
var
p, i, cuenta, k: integer;
esprimo: array[2..MAXP] of boolean;
begin
writeln(’** Criba de Eratostenes para encontrar’);
writeln(’ los primos entre 2 y ’, MAXP:1);
writeln;
(* inicializacion *)
for i := 2 to MAXP do esprimo[i] := true;
cuenta := 0;
(* lazo principal *)
for i := 2 to MAXP do
if (esprimo[i]) then begin (* nuevo primo *)
cuenta := cuenta + 1;
p := i; (* el nuevo primo *)
(* ahora eliminar multiplos de p *)
k := p + p;
while (k

flaviojosefo1 (Problema 6.7) Pág. 187
Problema 6.7: flaviojosefo1 (pág. 61)
program flaviojosefo1(input, output);
(* Problema de Flavio Josefo con arreglos *)
const MAXN = 100;
var
m, n, i, vuelta, cuenta: integer;
vive: array[1..MAXN] of boolean;
flavio: array[1..MAXN] of integer;
begin
(* carteles *)
writeln(’** Problema de Flavio Josefo’);
writeln;
writeln(’En un circulo de n, se van eliminando de a m’);
writeln;
(* datos *)
write(’Entrar n: ’); readln(n);
write(’Entrar m: ’); readln(m);
writeln;
(* inicializacion *)
for i := 1 to n do vive[i] := true; (* aun vive *)
i := 0;
(* parte principal *)
for vuelta := 1 to n-1 do begin
(* en cada vuelta, i es el ultimo eliminado *)
cuenta := 0; (* contamos m sobrevivientes desde i *)
repeat
if (i n) then i := i + 1 else i := 1;
if (vive[i]) then cuenta := cuenta + 1
until (cuenta = m);
vive[i] := false; (* lo eliminamos *)
flavio[vuelta] := i
end;
(* encontrar el sobreviviente *)
i := 0; repeat i := i + 1 until vive[i];
flavio[n] := i;
(* salida y fin *)
writeln(’ La permutacion de Flavio Josefo es’); writeln;
for i := 1 to n do begin
write(flavio[i]:5);
if ((i mod 10) = 0) then writeln
end;

Pág. 188 Programas mencionados
if ((n mod 10) 0) then writeln;
writeln; writeln(’** Fin **’)
end.
Problema 7.1: potencias2 (pág. 67)
program potencias2(input, output);
(* Comparar x a la n con y a la m. *)
var
n, m, k: integer;
x, y, xn, ym: real;
begin
(* carteles iniciales *)
writeln(’** Comparar x a la n con y a la m’);
writeln;
(* entrar datos *)
write(’Entrar x (real): ’); readln(x);
write(’Entrar n (entero): ’); readln(n);
write(’Entrar y (real): ’); readln(y);
write(’Entrar m (entero): ’); readln(m);
(* calcular x a la n, y a la m *)
xn := 1; for k := 1 to n do xn := xn * x;
ym := 1; for k := 1 to m do ym := ym * y;
(* comparar e imprimir *)
write(x:10:5, ’ a la ’, n:1);
if (xn < ym) then write(’ es menor que ’)
else if (xn > ym) then write(’ es mayor que ’)
else write(’ es igual a ’);
writeln(y:10:5, ’ a la ’, m:1);
(* cartel final *)
writeln; writeln(’** Fin **’)
end.
Problema 7.2: potencias3 (pág. 68)
program potencias3(input, output);
(*
Primer ejemplo de uso de funciones,
definiendo potencia(x,n) para comparar
x a la n con y a la m.
*)
var

iseccion (Problema 7.3) Pág. 189
n, m: integer;
x, y, xn, ym: real;
function potencia(a: real; b: integer): real;
var k: integer; z: real;
begin
z := 1;
for k := 1 to b do z := z * a;
potencia := z
end;
begin
(* carteles iniciales *)
writeln(’** Comparar x a la n con y a la m’);
writeln;
(* entrar datos *)
write(’Entrar x (real): ’); readln(x);
write(’Entrar n (entero): ’); readln(n);
write(’Entrar y (real): ’); readln(y);
write(’Entrar m (entero): ’); readln(m);
(* calcular x a la n, y a la m *)
xn := potencia(x,n); ym := potencia(y,m);
(* comparar e imprimir *)
write(x:10:5, ’ a la ’, n:1);
if (xn < ym) then write(’ es menor que ’)
else if (xn > ym) then write(’ es mayor que ’)
else write(’ es igual a ’);
writeln(y:10:5, ’ a la ’, m:1);
(* cartel final *)
writeln; writeln(’** Fin **’)
end.
Problema 7.3: biseccion (pág. 71)
program biseccion(input, output);
(*
Metodo de biseccion para encontrar raices de funciones
reales y continuas.
*)
const
Cambiar la funcion cuando se investigue otra ecuacion.
Version simplificada que se va mejorando
en los trabajos practicos.

Pág. 190 Programas mencionados
dify = 1.0e-6; (* tolerancia en y *)
maxiter = 30; (* maximo numero de iteraciones *)
var
iter: integer;
poco, mucho, x, (* valores en x *)
ypoco, ymucho, y (* correspondientes valores en y *)
: real;
seguir (* indica si seguir iterando *)
: boolean;
(* funcion para la que se quiere encontrar una raiz *)
function f(x: real): real;
begin
f := x * (x + 1) * (x + 2) * (x - 4/3)
end;
begin
(* carteles *)
writeln(’** Metodo de biseccion para encontrar raices’);
writeln;
write(’Implementacion para ’);
writeln(’f(x) = x (x + 1) (x + 2) (x - 4/3)’);
writeln;
(* datos de entrada *)
write(’ Entrar cota inferior para x: ’); readln(poco);
write(’ Entrar cota superior para x: ’); readln(mucho);
writeln;
(* inicializacion *)
ypoco := f(poco); ymucho := f(mucho);
seguir := (ypoco * ymucho < 0);
iter := 0;
(* lazo principal *)
while (seguir) do begin
iter := iter + 1;
x := (poco + mucho) / 2;
y := f(x);
if (abs(y) < dify) then seguir := false
else if (iter = maxiter) then seguir := false
else if (y * ypoco < 0) then mucho := x
else begin poco := x; ypoco := y end
end;
(* salida *)
if (iter > 0) then (* hay una solucion, aceptable o no *)
begin
writeln(’ Solucion obtenida: ’, x);

tablaseno2 (Problema 7.6) Pág. 191
writeln(’ Valor de f: ’, y);
writeln(’ Iteraciones realizadas: ’, iter:1);
if (abs(y) > dify) then begin
writeln;
write(’* La respuesta puede no estar ’);
writeln(’cerca de una raiz *’)
end
end;
(* fin *)
writeln; writeln(’** Fin **’)
end.
Problema 7.6: tablaseno2 (pág. 76)
program tablaseno2(input, output);
(* hacer una tabla del seno donde los angulos
estan dados en grados *)
const pi = 3.14159265;
var inicial, final, incremento: integer;
procedure cartelesiniciales;
begin
writeln(’** Hacer una tabla del seno dando valores’);
writeln(’ inicial, final, y del incremento (en grados).’);
writeln
end;
procedure leerdatos;
begin
write(’Entrar el valor inicial (en grados): ’);
readln(inicial);
write(’Entrar el valor final (en grados): ’);
readln(final);
write(’Entrar el valor de incremento (en grados): ’);
readln(incremento);
writeln
end;
procedure imprimirtabla;
var
grados: integer;
radianes: real;
begin
writeln(’Angulo Seno’);
grados := inicial;
while (grados

Pág. 192 Programas mencionados
end;
writeln(grados:5, sin(radianes):15:5);
grados := grados + incremento
end
procedure cartelfinal;
begin writeln; writeln(’** Fin **’) end;
begin
cartelesiniciales;
leerdatos;
imprimirtabla;
cartelfinal
end.
Problema 7.7: intercambio (pág. 77)
program intercambio(input, output);
(* prueba de intercambio de valores entre variables *)
var x, y: integer;
procedure incorrecto(a, b: integer);
(* a, b pasados por valor *)
var t: integer;
begin t := a; a := b; b := t end;
begin
writeln(’** Prueba de intercambio de variables’);
writeln;
x := 5; y := 2;
writeln(’Antes: x = ’, x:2, ’, y = ’, y:2);
incorrecto(a,b);
writeln(’Despues: x = ’, x:2, ’, y = ’, y:2);
writeln; writeln(’** Fin **’)
end.
Problema 8.2: maximocaracter (pág. 83)
program maximocaracter(input, output);
(*
Encontrar el maximo caracter en
un renglon entrado por terminal
*)
const MAXC = 255; (* maximo tamanio de arreglo *)
type tiporenglon = array[1..MAXC] of char;

maximocaracter (Problema 8.2) Pág. 193
var
p, (* posicion en el renglon *)
n (* numero de caracteres en el renglon *)
: integer;
t (* el caracter de maximo ordinal *)
: char;
renglon (* el renglon a procesar *)
: tiporenglon;
procedure leerrenglon( var s: tiporenglon; var n: integer);
(* aqui suponemos renglon: array[1..MAXC] of char *)
begin
write(’Escribir algo ’);
writeln(’(no mas de ’, MAXC:1, ’ caracteres.):’);
n := 0;
while ((not eoln) and (n < MAXC)) do begin
n := n + 1; read(s[n]) (* aca es read y no readln *)
end;
readln (* para leer el ultimo fin de linea *)
end;
procedure escribirrenglon( s: tiporenglon; n: integer);
var i: integer;
begin
for i := 1 to n do write(s[i]);
writeln
end;
procedure max(
var t: tiporenglon;
long: integer;
var tmax: char;
var indice: integer);
var i: integer;
begin (* suponemos long positivo *)
tmax := t[1]; indice := 1;
for i := 2 to long do
if (t[i] > tmax) then begin
tmax := t[i]; indice := i end
end; (* fin de procedure max *)
begin
(* titulo *)
write(’** Programa para encontrar el maximo en un ’);
write(’ arreglo de caracteres entrado por terminal’);
writeln;
(* entrada *)
leerrenglon(renglon, n);

Pág. 194 Programas mencionados
(* verificacion *)
writeln; writeln(’El renglon entrado es: ’);
writeln;
escribirrenglon(renglon, n);
(* procesamiento *)
max(renglon, n, t, p);
(* salida y fin *)
writeln; write(’El maximo es "’, t, ’",’);
writeln(’ alcanzado en la posicion ’, p:1);
writeln; writeln(’** Fin **’)
end.
Problema 8.8: deconsolaaarchivo (pág. 88)
program deconsolaaarchivo(input, output);
(*
Copiar de consola a archivo
*)
En la entrada no deben haber renglones "vacios"
var
archivo: text;
c: char;
nombre: string;
begin
(* carteles *)
writeln(’** Copiar de consola a archivo’);
writeln;
(* nombre de archivo a escribir *)
writeln(’ Entrar el nombre del archivo a escribir’);
writeln(’ Atencion: si ya existe se borra!’);
write(’ Archivo: ’); readln(nombre);
rewrite(archivo, nombre);
(* copiar de consola a archivo *)
writeln;
write(’Entrar datos en ’, nombre);
writeln(’ (Fin con retorno "vacio")’);
while (not eoln) do begin
repeat
read(c); write(archivo, c)
until eoln;
readln;
writeln(archivo)

dearchivoaconsola (Problema 8.8) Pág. 195
end;
close(archivo);
(* Fin *)
writeln; writeln(’** Fin **’)
end.
Problema 8.8: dearchivoaconsola (pág. 88)
program dearchivoaconsola(input, output);
(* Copiar de archivo a consola *)
var
archivo: text;
c: char;
nombre: string;
begin
(* carteles *)
writeln(’** Copiar de archivo a consola’);
writeln;
(* nombre de archivo a leer *)
write(’ Entrar el nombre del archivo a leer: ’);
readln(nombre);
reset(archivo, nombre);
writeln;
(* copiar datos en pantalla *)
writeln(’Estos son los datos en ’, nombre, ’:’);
writeln;
while not eof(archivo) do
if (eoln(archivo)) then begin
readln(archivo); writeln end
else begin
read(archivo, c); write(c) end;
close(archivo);
(* Fin *)
writeln; writeln(’** Fin **’)
end.
Problema 9.1: dado (pág. 92)
program dado(input, output);
(*
Simular tirar un dado.

Pág. 196 Programas mencionados
*)
Usa la sentencia "random" de Turbo Pascal.
var d: integer;
begin
writeln(’** Simular tirar un dado’);
writeln;
randomize;
d := 1 + random(6);
writeln(’El dado que salio es ’, d:1);
writeln;
writeln(’** para Fin **’); readln
end.
Problema 9.2: dados (pág. 92)
program dados(input, output);
(*
Contar las veces que se tira un dado
hasta que aparece un numero prefijado.
*)
Usa la sentencia "random" de Turbo Pascal.
var numero, tiros: integer;
begin
writeln(’** Contar las veces que se tira un dado’);
writeln(’ hasta que aparece un numero prefijado’);
writeln;
write(’Entrar el valor que debe aparecer ’);
write(’(entre 1 y 6): ’);
readln(numero);
randomize;
tiros := 0;
repeat tiros := tiros + 1
until (1 + random(6) = numero);
writeln;
write(’El numero ’, numero:1);
writeln(’ tardo ’, tiros, ’ tiros hasta aparecer.’);
writeln;
writeln(’** para Fin **’); readln

arbolbinario (Problema 12.6) Pág. 197
end.
Problema 12.6: arbolbinario (pág. 129)
program arbolbinario(input, output);
(*
Arbol binario parcialmente ordenado guardando los
nodos en un arreglo. Variante de las versiones con
punteros de Wirth87, p. 210, y K&R, p. 153.
*)
Aplicacion al problema de hacer un listado
ordenado de caracteres entrados por terminal,
contando las apariciones.
const
MAXN = 100; (* maximo numero de datos a guardar *)
nada = 0; (* para cuando no hay hijos *)
type
indice = integer; (* para senialar los indices *)
tipodato = char; (* el tipo de datos a ingresar *)
nodo = record
llave: tipodato; (* dato *)
cuenta: integer; (* veces que aparecio *)
izquierda: indice; (* hijo a la izquierda *)
derecha: indice (* hijo a la derecha *)
end;
tipoarbol = array[1..MAXN] of nodo;
var
narbol: integer; (* numero de nodos en el arbol *)
arbol: tipoarbol; (* el arbol! *)
raiz: indice; (* donde empieza el arbol *)
dato: tipodato; (* dato leido *)
function entrardatos(var dato: tipodato): boolean;
begin
write(’Entrar el numero (fin = ): ’);
if (eoln) then
begin entrardatos := false; readln end
else
begin entrardatos := true; readln(dato) end
end;
procedure binario(x: tipodato; var p: indice);
var y: tipodato;
begin
if (p = nada) then begin (* nueva entrada *)
narbol := narbol + 1;

Pág. 198 Programas mencionados
p := narbol;
with arbol[p] do begin
llave := x; cuenta := 1;
izquierda := nada; derecha := nada
end
end
else begin
y := arbol[p].llave;
if (x = y) then (* dato existente *)
arbol[p].cuenta := arbol[p].cuenta + 1
else if (x < y) then (* ir a la izquierda *)
binario(x, arbol[p].izquierda)
else (* ir a la derecha *)
binario(x, arbol[p].derecha)
end
end;
procedure enorden(w: indice);
begin
if (w nada) then
with arbol[w] do begin
enorden(izquierda);
writeln(llave:10, cuenta:20);
enorden(derecha)
end
end;
begin
(* carteles *)
writeln(’** Arbol binario’); writeln;
write(’ Entrar caracteres y contar’);
writeln(’ las veces que aparecieron’);
writeln;
(* inicializacion *)
narbol := 0;
raiz := nada;
(* lectura de datos y construccion del arbol *)
while (entrardatos(dato)) do binario(dato, raiz);
(* salida y fin *)
writeln;
writeln(’Impresion en orden:’);
writeln;
writeln(’ Caracter Cantidad de Apariciones’);
enorden(raiz);
writeln; writeln(’** Fin **’)
end.

anchoprimero (Problema 13.4) Pág. 199
Problema 13.4: anchoprimero (pág. 139)
program anchoprimero(input, output);
(*
Recorrer un grafo a lo ancho para
determinar un arbol de expansion.
*)
Entrada: un grafo dado por lista de aristas y el
numero de vertices, n.
Los vertices son todos los enteros positivos
entre 1 y n. Si alguno no aparece en ninguna
arista, es un vertice aislado.
Salida: las aristas del arbol y el orden en que
fueron visitados los vertices.
Si el arbol no es conexo, se imprime un mensaje.
Implementacion con una cola fifo de vertices a visitar.
const
MAXN = 20; (* maximo numero de vertices *)
MAXM = 100; (* maximo numero de aristas *)
type
arreglodevertices = array[1..MAXN] of integer;
tipoarista = record i, j: integer end;
arreglodearistas = array[1..MAXM] of tipoarista;
matrizNN = array[1..MAXN,1..MAXN] of integer;
var
ngrafo, mgrafo, nvisitado, marbol: integer;
padre, visitado: arreglodevertices;
aristasgrafo, aristasarbol: arreglodearistas;
adyacencias: matrizNN;
function nuevaarista: boolean;
begin
writeln;
write(’ Entrar la arista ’, mgrafo:2);
writeln(’ (fin = ):’);
write(’ Entrar el primer vertice: ’);
if (not eoln) then begin
nuevaarista := true;
with aristasgrafo[mgrafo] do begin
read(i);
write(’ Entrar el segundo vertice: ’);
readln(j)
end (* with *)
end (* if not eoln *)

Pág. 200 Programas mencionados
else begin nuevaarista := false; readln end
end;
procedure entrardatos;
begin
(* vertices *)
writeln;
write(’Entrar el numero de vertices: ’);
readln(ngrafo);
(* aristas *)
writeln;
writeln(’Entrar las aristas:’);
mgrafo := 1;
while (nuevaarista) do mgrafo := mgrafo + 1;
mgrafo := mgrafo - 1
end;
procedure escribiraristas( a: arreglodearistas; m: integer);
const maxrenglon = 10; (* maxima cantidad por renglon *)
var k: integer;
begin
for k := 1 to m do begin
write(’ (’, a[k].i:1, ’,’, a[k].j:1, ’)’);
if ((k mod maxrenglon) = 0) then writeln
end;
if ((m mod maxrenglon) > 0) then writeln
end;
procedure dearistasaadyacencias;
var i, j, k: integer;
begin
for i := 1 to ngrafo do
for j := 1 to ngrafo do
adyacencias[i,j] := 0;
for k := 1 to mgrafo do
with aristasgrafo[k] do begin
adyacencias[i,j] := 1; adyacencias[j,i] := 1
end
end;
procedure ancho;
var
i, j, ppo, fin: integer;
avisitar: arreglodevertices;
begin
(* inicializacion *)
dearistasaadyacencias;
for i := 1 to ngrafo do padre[i] := 0;
nvisitado := 0;

anchoprimero (Problema 13.4) Pág. 201
(* al principio solo esta 1 *)
padre[1] := 1;
ppo := 1; fin := 1; (* los extremos de la cola *)
avisitar[1] := 1;
while (ppo 0) and (padre[j] = 0)) then
begin (* agregar j a la cola *)
padre[j] := i;
fin := fin + 1;
avisitar[fin] := j
end (* if adyacencias > 0 *)
end (* while *)
end;
procedure hacerarbol;
(* Encontrar las aristas del arbol generado usando padre *)
var k: integer;
begin
marbol := 0;
for k := 2 to nvisitado do (* 1 es "raiz" *)
if (padre[k] > 0) then begin
marbol := marbol + 1;
with aristasarbol[marbol] do begin
i := k; j := padre[k] end
end
end;
procedure escribirvisitado;
const maxrenglon = 10; (* maxima cantidad por renglon *)
var i: integer;
begin
for i := 1 to nvisitado do begin
write(visitado[i]:5);
if ((i mod maxrenglon) = 0) then writeln
end;
if ((nvisitado mod maxrenglon) 0) then writeln
end;
begin
(* Carteles *)

Pág. 202 Programas mencionados
writeln(’** Recorrer un grafo a lo ancho para determinar’);
writeln(’ un arbol de expansion entrando las aristas,’);
writeln(’ tomando como raiz a 1.’);
writeln;
(* Datos e inicializacion *)
entrardatos;
writeln;
writeln(’ Las aristas originales son:’);
escribiraristas( aristasgrafo, mgrafo);
(* Procesamiento y salida *)
ancho;
hacerarbol;
writeln;
writeln(’ Las aristas del arbol resultante son:’);
escribiraristas(aristasarbol, marbol);
writeln;
writeln(’Los vertices se visitaron en el siguiente orden:’);
escribirvisitado;
if (nvisitado < ngrafo) then begin
writeln; writeln(’** El grafo no es conexo **’) end;
(* Fin *)
writeln; writeln(’** Fin **’)
end.
Problema 13.8: dijkstra (pág. 144)
program dijkstra(input, output);
(*
Implementacion del algoritmo de Dijkstra para
encontrar un camino mas corto entre dos vertices
en un grafo pesado.
*)
Entrada: un grafo pesado dado por lista de aristas,
el numero de vertices, n, y los vertices a unir, s y t.
Los vertices son todos los enteros positivos
entre 1 y n. Si alguno no aparece en ninguna
arista, es un vertice aislado.
Los pesos de cada arista son enteros positivos.
Salida: la longitud de un camino mas corto, y el
camino que lo realiza como lista de vertices. Si
los vertices no se pueden conectar, se imprime un
mensaje.
const
MAXN = 20; (* maximo numero de vertices *)

dijkstra (Problema 13.8) Pág. 203
MAXM = 100; (* maximo numero de aristas *)
type
costo = integer; (* podria ser real *)
arreglodevertices = array[1..MAXN] of integer;
tipoarista = record
i, j: integer; (* los extremos *)
w: costo (* el costo *)
end;
arreglodearistas = array[1..MAXM] of tipoarista;
matrizNN = array[1..MAXN,1..MAXN] of costo;
var
ngrafo, mgrafo, s, t: integer;
infinito: costo;
padre: arreglodevertices;
dist: array[1..MAXN] of costo;
aristasgrafo: arreglodearistas;
costos: matrizNN;
function nuevaarista: boolean;
begin
writeln;
write(’ Entrar la arista ’, mgrafo:2);
writeln(’ (fin = ): ’);
write(’ Entrar el primer vertice: ’);
if (not eoln) then begin
nuevaarista := true;
with aristasgrafo[mgrafo] do begin
read(i);
write(’ Entrar el segundo vertice: ’);
read(j);
write(’ Entrar el costo (entero > 0): ’);
readln(w);
infinito := infinito + w
end (* with *)
end (* if not eoln *)
else begin nuevaarista := false; readln end
end;
procedure entrardatos;
begin
(* vertices *)
writeln;
write(’Entrar el numero de vertices: ’);
readln(ngrafo);
(* aristas *)
writeln;
writeln(’Entrar las aristas:’);
mgrafo := 1; infinito := 1;

Pág. 204 Programas mencionados
while (nuevaarista) do mgrafo := mgrafo + 1;
mgrafo := mgrafo - 1;
(* vertices a unir *)
writeln;
write(’Entrar el vertice de partida: ’); readln(s);
write(’Entrar el vertice de llegada: ’); readln(t)
end;
procedure escribiraristas(a: arreglodearistas; m: integer);
var k: integer;
begin
writeln;
writeln(’ Vertices Costo’);
for k := 1 to m do
with a[k] do writeln(i:5, j:6, w:9)
end;
procedure dearistasacostos;
var i, j, k: integer;
begin
for i := 1 to ngrafo do
for j := 1 to ngrafo do
costos[i,j] := infinito;
for k := 1 to mgrafo do
with aristasgrafo[k] do begin
costos[i,j] := w; costos[j,i] := w
end
end;
procedure mascorto;
var
i, j, k, kmin, hay: integer;
d, dmin: costo;
avisitar: arreglodevertices;
begin
(* inicializacion *)
dearistasacostos;
for i := 1 to ngrafo do begin
padre[i] := 0; dist[i] := infinito end;
(* s es la "raiz" y el unico en la cola al comenzar *)
padre[s] := s; dist[s] := 0; hay := 1; avisitar[1] := s;
repeat (* aca hay > 0 *)
(* nuevo i: el de minima distancia en la cola *)
kmin := hay; i := avisitar[hay]; dmin := dist[i];
for k := 1 to hay - 1 do begin
j := avisitar[k]; d := dist[j];
if (d < dmin) then begin

dijkstra (Problema 13.8) Pág. 205
kmin := k; i := j; dmin := d end
end;
(* ahora tenemos el nuevo i *)
if (i t) then begin
(* poner i al fin de la cola y sacarlo *)
if (kmin < hay) then avisitar[kmin] := avisitar[hay];
hay := hay - 1;
(* examinar vecinos de i *)
for j := 1 to ngrafo do
if (dist[i] + costos[i,j] < dist[j]) then begin
(* si j no se agrego, agregarlo a la cola *)
if (dist[j] = infinito) then begin
hay := hay + 1; avisitar[hay] := j end;
(* actualizar dist y padre *)
dist[j] := dist[i] + costos[i,j];
padre[j] := i
end
end (* if i t *)
until ((i = t) or (hay = 0))
end;
procedure hacercamino;
(* Construir e imprimir el camino mas corto usando padre. *)
const maxrenglon = 10; (* maxima cantidad / renglon *)
var
i, ncamino: integer;
camino: arreglodevertices;
begin
ncamino := 1; camino[1] := t; i := t;
while (i s) do begin
i := padre[i];
ncamino := ncamino + 1;
camino[ncamino] := i
end;
(* imprimir "dando vuelta" el arreglo *);
writeln(’ Los vertices en el camino son:’);
for i := ncamino downto 1 do begin
write(camino[i]:5);
if ((i mod maxrenglon) = 0) then writeln
end;
if ((ncamino mod maxrenglon) 0) then writeln
end;
begin
(* Carteles *)
writeln(’** Busqueda del camino mas corto entre dos’);
writeln(’ vertices con el algoritmo de Dijkstra.’);
writeln(’ El grafo se entra mediante lista de aristas.’);
(* Datos e inicializacion *)

Pág. 206 Programas mencionados
entrardatos;
writeln; writeln(’Las aristas del grafo son:’);
escribiraristas(aristasgrafo, mgrafo);
writeln; writeln(’Los vertices a unir son:’);
writeln(’ partida: ’, s:1);
writeln(’ llegada: ’, t:1);
(* Procesamiento y salida *)
mascorto;
writeln;
if (padre[t] > 0) then begin
writeln(’ La longitud del camino es ’, dist[t]:1);
hacercamino
end
else begin
writeln;
writeln(’** ’, s:1, ’ y ’ , t:1, ’ no se conectan **’)
end;
(* Fin *)
writeln; writeln(’** Fin **’)
end.
Problema 14.1: listas (pág. 159)
program listas(input, output);
(*
Listas encadenadas con punteros: con los datos ingresados
formamos dos listas, una agregando adelante y otra ordenada.
*)
El fin de lista se indica con "nil", pero podria ser otro
nodo, y tambien podria haber un nodo al principio sin datos.
listaadelante: se agrega nueva info adelante.
listaordenada: lista ordenada por "id". Recorremos toda la
lista buscando donde ubicar la nueva info, que se inserta
"despues" del elemento que ya estaba si coinciden las
llaves de comparacion, para insertar "antes" cambiar
"

listas (Problema 14.1) Pág. 207
nodo = record
info: info;
siguiente: ptrnodo
end;
var
nuevainfo: info;
listaadelante, listaordenada: ptrnodo;
function entrardatos(var datos: info): boolean;
begin
write(’Entrar el nombre (fin = ): ’);
if (not eoln) then begin
entrardatos := true;
with datos do begin
readln(nombre);
write(’Entrar numero de id para "’, nombre, ’": ’);
readln(id)
end
end
else begin entrardatos := false; readln end
end;
procedure adelante (var lista: ptrnodo; nuevainfo: info);
(*
agregar nueva info adelante en lista,
lista puede ser "nil"
*)
var p: ptrnodo;
begin
new(p);
p^.info := nuevainfo; p^.siguiente := lista;
lista := p
end;
procedure insertaradelante( p, q: ptrnodo);
(* insertar q delante de p, ninguno debe ser "nil" *)
var temp: info;
begin
q^.siguiente := p^.siguiente; p^.siguiente := q;
temp := p^.info; p^.info := q^.info; q^.info := temp
end;
procedure insertardetras( p, q: ptrnodo);
(* insertar q detras de p, ninguno debe ser "nil" *)
begin
q^.siguiente := p^.siguiente; p^.siguiente := q
end;
procedure ordenada (var lista: ptrnodo; nuevainfo: info);

Pág. 208 Programas mencionados
(* agregar elementos a una lista ordenada por id *)
var p, r: ptrnodo;
begin
(* nuevo nodo con nueva info *)
new(r); r^.info := nuevainfo;
(* buscar donde ubicar r *)
if (lista = nil) then begin
(* r es el primer nodo *)
lista := r; r^.siguiente := nil end
else begin (* recorrer la lista *)
p := lista;
while ((p^.siguiente nil) and
(p^.info.id nuevainfo.id)
(* cambiar a >= para antes *)
then insertaradelante(p, r)
else (* p es el ultimo de la lista *)
insertardetras(p, r)
end
end;
procedure imprimir (lista: ptrnodo);
var p: ptrnodo;
begin
if (lista = nil) then writeln(’ Lista vacia’);
p := lista;
while (p nil) do begin
with p^.info do writeln(nombre:tamanio, id:10);
p := p^.siguiente
end
end;
begin
(* carteles *)
writeln(’** Prueba de listas encadenadas’);
writeln;
(* inicializacion de listas *)
listaadelante := nil;
listaordenada := nil;
(* entrada de datos y construccion de listas *)
while (entrardatos(nuevainfo)) do begin
adelante( listaadelante, nuevainfo);
ordenada( listaordenada, nuevainfo)
end;

grafos (Problema 14.9) Pág. 209
(* imprimir listas *)
writeln; writeln(’Las listas son:’); writeln;
writeln(’ Lista agregando adelante:’);
imprimir(listaadelante); writeln;
writeln(’ Lista ordenada por id:’);
imprimir(listaordenada);
(* Fin *)
writeln; writeln(’** Fin **’)
end.
Ejemplo de Salida
** Prueba de listas encadenadas **
Entrar el nombre (fin = ): Geri
Entrar numero de id para "Geri": 2
Entrar el nombre (fin = ): Pablito
Entrar numero de id para "Pablito": 1
Entrar el nombre (fin = ): Guille
Entrar numero de id para "Guille": 2
Entrar el nombre (fin = ): Robin Hood
Entrar numero de id para "Robin Hood": 3
Entrar el nombre (fin = ):
Las listas son:
Lista agregando adelante:
Lista ordenada por id:
** Fin **
Problema 14.9: grafos (pág. 161)
Robin Hood 3
Guille 2
Pablito 1
Geri 2
Pablito 1
Geri 2
Guille 2
Robin Hood 3
program grafos(input, output);
(*
Representaciones de grafos dirigidos donde
V = (1,...,n) por lista de aristas o por
listas de vecinos.

Pág. 210 Programas mencionados
*)
Siempre n es dato.
Las listas terminan en "nil".
type
ptrarista = ^arista;
arista = record u, v: integer; s: ptrarista end;
ptrvecino = ^vecino;
vecino = record id: integer; s: ptrvecino end;
ptrvertice = ^vertice;
vertice = record
id: integer;
s: ptrvertice;
vecinos: ptrvecino
end;
var
ngrafo: integer;
aristas: ptrarista;
vertices: ptrvertice;
(***************************************
Aristas
***************************************)
function nuevaarista(var x, y: integer): boolean;
begin
writeln;
writeln(’Entrar una arista (fin = ): ’);
write(’ Entrar el primer vertice: ’);
if (not eoln) then begin
nuevaarista := true;
read(x);
write(’ Entrar el segundo vertice: ’);
readln(y)
end (* if not eoln *)
else begin nuevaarista := false; readln end
end;
procedure agregararista(x, y: integer);
(* agregamos arista adelante *)
var parista: ptrarista;
begin
new(parista);
with parista^ do begin u := x; v := y; s := aristas end;
aristas := parista

grafos (Problema 14.9) Pág. 211
end;
procedure entrararistas;
(* inicializar e ingresar aristas *)
var x, y: integer;
begin
aristas := nil;
while nuevaarista(x,y) do agregararista(x,y)
end;
procedure escribiraristas;
const maxrenglon = 10; (* maxima cantidad por renglon *)
var
k: integer;
p: ptrarista;
begin
if (aristas = nil) then writeln(’** lista vacia’)
else begin
p := aristas; k := 0;
repeat
k := k + 1;
with p^ do write(’ (’, u:1, ’,’, v:1, ’)’);
if ((k mod maxrenglon) = 0) then writeln;
p := p^.s
until (p = nil)
end;
if ((k mod maxrenglon) > 0) then writeln
end;
(***************************************
Vertices y sus vecinos
***************************************)
procedure inicializarvecinos;
var
k: integer;
p: ptrvertice;
begin
vertices := nil;
(* la construimos "al reves" para que quede ordenada *)
for k := ngrafo downto 1 do begin
new(p);
with p^ do begin
id := k; s := vertices; vecinos := nil end;
vertices := p
end (* for k *)
end;
procedure agregarvecino(x, y: integer);
(* agregar y a los vecinos de x *)

Pág. 212 Programas mencionados
var
pvertice: ptrvertice;
pvecino: ptrvecino;
begin
(* buscar x entre los vertices *)
pvertice := vertices; (* aca debe ser vertices nil *)
while (pvertice^.id x) do pvertice := pvertice^.s;
(* actualizar vecinos de "x", agregando "y" adelante *)
new(pvecino);
with pvecino^ do begin s := pvertice^.vecinos; id := y end;
pvertice^.vecinos := pvecino
end;
procedure escribirvecinos;
var
pvertice: ptrvertice;
pvecino: ptrvecino;
begin
(* adyacencias *)
pvertice := vertices;
while (pvertice nil) do begin
write(pvertice^.id:5, ’ -> ’);
pvecino := pvertice^.vecinos;
if (pvecino = nil) then write(’ {}’)
else
repeat
write(pvecino^.id:3);
pvecino := pvecino^.s
until (pvecino = nil);
writeln;
pvertice := pvertice^.s
end
end;
(***************************************
De aristas a vertices
***************************************)
procedure dearistasaadyacencias;
(* construir listas de adyacencias
recorriendo la lista de aristas *)
var parista: ptrarista;
begin
parista := aristas;
while parista nil do begin
with parista^ do begin
agregarvecino(u, v);
agregarvecino(v, u)
end;

grafos (Problema 14.9) Pág. 213
end;
(* proxima arista *)
parista := parista^.s
end
(**************************************
Parte principal
**************************************)
begin
(* carteles *)
writeln(’** Pasar de aristas a adyacencias usando’);
writeln(’ listas encadenadas.’); writeln;
(* Inicializacion y entrada de datos *)
(* vertices *)
write(’ Entrar n (la cantidad de vertices): ’);
readln(ngrafo);
inicializarvecinos; writeln;
(* aristas *)
entrararistas;
(* construccion de listas de adyacencias *)
dearistasaadyacencias;
(* imprimir resultados *)
writeln; writeln(’** Resultados **’); writeln;
writeln(’ Lista de aristas:’);
escribiraristas; writeln;
writeln(’ Listas de vecinos:’);
escribirvecinos;
(* fin *)
writeln; writeln(’** Fin **’)
end.

Apéndice B
Sobre los compiladores
Pascal
Suponiendo que se tenga acceso a una computadora, el próximo problema es
usar un compilador Pascal. Si bien los compiladores comerciales tienen menos
problemas y tienen documentación adecuada, afortunadamente hay varias posibilidades
de compiladores disponibles gratis de internet, y pasamos a presentar
algunas (1) :
• Aunque no se adhiere estrictamente al estándar Pascal, el compilador
“Turbo Pascal” de Borland (para DOS) es muy “robusto” (no tiene problemas),
y su popularidad ha hecho que muchos otros compiladores copiaran
su sintaxis.
La versión 5.5 de este compilador se puede conseguir gratis para uso personal
en Borland Museum (2) . Versiones más recientes de Turbo Pascal o
Delphi (como Turbo Pascal pero para Windows), también para uso personal
pero en francés, pueden conseguirse en Borland Francia (3) .
• Free Pascal (4) , es un compilador gratuito para varias plataformas, incluyendo
DOS, Win32 y Linux, entre otras. La página principal de Free Pascal
(5) tiene más datos sobre Free Pascal y Pascal en general.
• Thefreecountry.com (6) presenta varias posibilidades de compiladores gratis,
incluyendo Turbo Pascal y Delphi.
• Para Macintosh, puede consultarse la página de Pascal Central (7) para
distintas posibilidades, incluyendo programas hechos.
Claro que una vez obtenido el compilador, debe instalarse en la computadora
siguiendo las instrucciones para cada caso.
(1) La información está actualizada a febrero de 2004.
(2) http://community.borland.com/museum/
(3) http://www.inprise.fr/download/compilateurs/
(4) http://www.freepascal.org/download.html
(5) http://www.freepascal.org/
(6) http://www.thefreecountry.com/developercity/pascal.shtml
(7) http://www.pascal-central.com/

Apéndice C
Breve referencia de Pascal
C.1. Resumen de operadores
C.1.1. Operadores aritméticos
Operador operación operando resultado
+ (unitario) identidad entero o real mismo que operando
- (unitario) inversión de signo entero o real mismo que operando
+ (binario) suma entero o real entero o real
- (binario) resta entero o real entero o real
* producto entero o real entero o real
div división entera entero entero
/ división entero o real real
mod resto entero entero
C.1.2. Operadores relacionales
Operador operación operando resultado
= igualdad simple, string o puntero lógico
desigualdad simple, string o puntero lógico
< menor simple o string lógico
> mayor simple o string lógico
= mayor o igual simple o string lógico
C.1.3. Operadores lógicos
Operador operación operando resultado
not negación lógico lógico
or disyunción lógico lógico
and conjunción lógico lógico
C.2. Identificadores estándares
Constantes

Pág. 216 Breve referencia de Pascal
Tipos
Variables
false maxint true
boolean char integer real text
input output
Funciones con argumentos numéricos
Función operación argumento resultado
abs valor absoluto entero o real entero o real
arctan arco tangente entero o real real
chr carácter en orden entero carácter
exp exponencial (e x ) entero o real real
ln logaritmo (base e) entero o real real
odd (∗) si impar entero lógico
round (†) redondeo real entero
sin seno real o entero real
sqr cuadrado real o entero real o entero
sqrt raíz cuadrada real o entero (≥ 0) real
trunc (‡) truncar real entero
(∗) odd (x) es verdadero si x es impar.
(†)
round (x) =trunc(x +0.5) para x ≥ 0, y round (x) =trunc(x − 0.5) para
x ≤ 0.
Otras funciones
(‡) trunc(x) = ⌊x⌋ si x ≥ 0,
⌈x⌉ si x

C.3. Nombres Reservados Pág. 217
C.3. Nombres Reservados
and array begin case const div
downto do else end file for
function goto if in label mod
nil not of or packed procedure
program record repeat set then to
type until var while with

Apéndice D
Algunas notaciones y
símbolos usados
Ponemos aquí algunas notaciones, abreviaturas y expresiones usadas (que
pueden diferir de algunas ya conocidas), sólo como referencia: el lector debería
mirarlo rápidamente y volver cuando surja alguna duda.
D.1. Lógica
⇒ implica o entonces. x > 0 ⇒ x = √ x 2 puede leerse como “si x es
positivo, entonces. . . ”.
⇔ si y sólo si. Significa que las condiciones a ambos lados son equivalentes.
Por ejemplo x ≥ 0 ⇔|x| = x se lee “x es positivo si y sólo si. . . ”.
∃ existe. ∃ k ∈ Z tal que. . . se lee “existe k entero tal que...”.
∀ para todo. ∀ x>0, x = √ x 2 se lee “para todo x positivo,...”.
¬ La negación lógica no. Sip es una proposición lógica, ¬p se lee “no p”.
¬p es verdadera ⇔ p es falsa.
∧ La conjunción lógica y. Sip y q son proposiciones lógicas, p ∧ q es
verdadera ⇔ tanto p como q son verdaderas.
∨ La disyunción lógica o. Sip y q son proposiciones lógicas, p ∨ q es
verdadera ⇔ obienp es verdadera o bien q es verdadera.
D.2. Conjuntos
∈ pertenece. x ∈ A significa que x es un elemento de A.
/∈ no pertenece. x ∈ A significa que x no es un elemento de A.
∪ unión de conjuntos, A ∪ B = {x : x ∈ A o x ∈ B}.
∩ intersección de conjuntos, A ∩ B = {x : x ∈ A y x ∈ B}.

D.3. Números: conjuntos, relaciones, funciones Pág. 219
\ diferencia de conjuntos, A \ B = {x : x ∈ A y x/∈ B}.
||,
# cardinal, |A|, o a veces #(A), es la cantidad de elementos en el conjunto
A.
∅ El conjunto vacío, #(∅) =0.
D.3. Números: conjuntos, relaciones, funciones
N El conjunto de números naturales, N = {1, 2, 3,...}. Observar que para
nosotros 0 /∈ N.
Z Los enteros, Z = {0, 1, −1, 2, −2,...}.
Q Los racionales p/q, donde p, q ∈ Z, q = 0.
R Los reales. Son todos los racionales más números como √ 2, π, etc.,que
no tienen una expresión decimal periódica.
R+
Los reales positivos, R+ = {x ∈ R : x>0}.
C Los complejos, de la forma z = a + bi, cona, b ∈ R y donde i es la
unidad imaginaria, “ i = √ −1”.
±x Dado el número x, ±x representa dos números: x y −x.
| Para m, n ∈ Z, m | n se lee m divide a n, on es múltiplo de m,ysignifica
que existe k ∈ Z tal que n = km.
≈ aproximadamente. x ≈ y se lee “x es aproximadamente igual a y”.
≪ mucho menor. x ≪ y se lee “x es mucho menor que y”.
≫ mucho mayor. x ≫ y se lee “x es mucho mayor que y”.
|x| El valor
absoluto o módulo del número x. Siz = a+bi∈ C con a, b ∈ R,
|z| = a2 + b2 .
⌊x⌋ El piso de x, x ∈ R. Es el mayor entero que no supera a x, porloque
⌊x⌋ ≤x0, o logaritmo en base e, lnx =
log e x. Es la inversa de la exponencial, y =lnx ⇔ e y = x.

Pág. 220 Algunas notaciones y símbolos usados
✎ Para no confundir con los logaritmos en base 10, evitaremos la
notación log x: si nos referimos a la base e usaremos ln x, yen
otras bases log b x.
sen x,
sin x Las función trigonométrica seno, definida para x ∈ R. Su inversa es la
función arcsen (arcsin en inglés).
cos x Las función trigonométrica coseno, definida para x ∈ R. Su inversa es
la función arccos.
tan x Las función trigonométrica tangente, definida como tan x =senx/ cos x.
Su inversa es la función arctan.
arcsen x,
arccos x,
arctan x Funciones trigonométricas inversas respectivamente de sen, cos y tan.
sgn(x),
signo(x) Las función signo, definida para x ∈ R por
⎧
⎪⎨ 1 si x>0,
signo(x) = 0 si x =0,
⎪⎩
−1 si x

Bibliografía
[1] E. M. Baras: Lotus 1-2-3 — Guía del Usuario (2. a ed.), Osborne - Mc-
Graw Hill, 1990. (Citado en pág. 171.)
[2] J. L. Bentley: More Programming Pearls, Addison-Wesley, 1988. (Citado
en pág. 165.)
[3] N. L. Biggs: Introduction to Computing with Pascal, Oxford Science Publications,
1989. (Citado en pág. 24.)
[4] A. Engel: Exploring Mathematics with your computer, The Mathematical
Association of America, 1993. (Citado en págs. 2, 5, 65, 90 y 171.)
[5] E. Gentile: Aritmética elemental en la formación matemática, Red
Olímpica, 1991. (Citado en pág. 5.)
[6] G. H. Hardy y E. M. Wright: An Introduction to the Theory of Numbers
(4. a ed.), Oxford University Press, 1975. (Citado en pág. 171.)
[7] K. Jensen y N. Wirth: Pascal—User Manual and Report, Springer Verlag,
1985. (Citado en págs. 2, 5, 90 y 109.)
[8] R. Johnsonbaugh: Matemáticas Discretas (4. a ed.), Prentice Hall, 1999.
(Citado en pág. 140.)
[9] SirT.L.Heath: The thirteen books of Euclid’s Elements, vol.2,Dover
Publications, 1956. (Citado en pág. 54.)
[10] B. W. Kernighan y D. M. Ritchie: El lenguaje de programación C
(2. a ed.), Prentice-Hall Hispanoamericana, 1991. (Citado en págs. 5, 12,
132 y 162.)
[11] D. E. Knuth: The Art of Computer Programming, Addison-Wesley. Vol. 1
(3. a ed.), 1997; vol. 2 (3. a ed.), 1997; vol. 3 (2. a ed.), 1997. (Citado en págs.
92, 96 y 165.)
[12] C. H. Papadimitriou y K. Steiglitz: Combinatorial Optimization, Algorithms
and Complexity, Dover, 1998. (Citado en pág. 154.)
[13] K. H. Rosen: Elementary Number Theory and its Applications (3. a ed.),
Addison Wesley, 1993. (Citado en pág. 39.)
[14] H. A. Taha: Operations Research — An Introduction (4. a ed.), MacMillan
Publishing Co., 1987. (Citado en pág. 171.)

Pág. 222 Bibliografía
[15] N. Wirth: Introducción a la Programación Sistemática, El Ateneo, 1984.
(Citado en págs. 2 y 80.)
[16] N. Wirth: Algoritmos y Estructuras de Datos, Prentice-Hall Hispanoamericana,
1987. (Citado en págs. 2, 5, 80, 96, 102, 109, 131, 132 y 162.)

Índice de figuras
2.1. Esquema de transferencia de datos en la computadora. ...... 8
2.2. Bits y byte. .............................. 8
2.3. Esquema del desarrollo de un programa. . . . . . . . . . . . . . . 9
2.4. Esquema del programa ejecutable en la memoria. . . . . . . . . . 10
3.1. Datos de tipos elementales en la memoria. ............. 14
3.2. Los datos con sus identificadores. .................. 14
3.3. Esquema de la “densidad variable”. . . . . . . . . . . . . . . . . . 20
5.1. Gráficos de y =cosx y y = x. .................... 44
5.2. Aproximándose al punto fijo de cos x. ............... 44
6.1. Esquema del arreglo v guardado en memoria. . . . . . . . . . . . 56
6.2. Esquema del problema de Flavio Josefo con n =5ym =3. . . . 62
7.1. Una función continua con distintos signos en los extremos. .... 71
7.2. Programa, funciones y procedimientos en la memoria. ...... 75
7.3. Intercambio de los valores de u y v. . . . . . . . . . . . . . . . . . 77
10.1. Ordenando por conteo. ........................103
10.2. Esquema del registro de tipo “ complejo” enmemoria.......105
11.1. Contando la cantidad de caminos posibles. .............112
11.2. Las torres de Hanoi. . . . . . . . . . . . . . . . . . . . . . . . . . 114
12.1. Una estructura “lineal”. . . . . . . . . . . . . . . . . . . . . . . . 126
12.2. Un árbol binario ordenado. . . . . . . . . . . . . . . . . . . . . . 127
12.3. Disposición del arreglo de registros luego de ingresar los datos. . 128
12.4. Disposición del árbol binario luego de ingresar los datos. . . . . . 128
12.5. Los registros de la figura 12.4 “proyectados”. . . . . . . . . . . . 128
12.6. Los registros con índices para la estructura de árbol binario. . . . 129
13.1. Un grafo con 6 vértices y 7 aristas. . . . . . . . . . . . . . . . . . 134
13.2. Un grafo no conexo y un árbol. . . . . . . . . . . . . . . . . . . . 135
13.3. Un grafo con pesos en las aristas. ..................142
14.1. El puntero p y la variable apuntada pˆ. . . . . . . . . . . . . . . 156
15.1. Aproximación de sen x mediante un polinomio. . . . . . . . . . . 163

Índice de cuadros
8.1. Estructura de un programa Pascal. . . . . . . . . . . . . . . . . . 82
8.2. Diferencias entre el estándar y Turbo Pascal. ........... 88
10.1. Comparación de algoritmos de clasificación. . . . . . . . . . . . . 103
13.1. Esquema del algoritmo visitar. . . . . . . . . . . . . . . . . . . . 138
13.2. Esquema del algoritmo de Dijkstra. . . . . . . . . . . . . . . . . . 143
13.3. Esquema del algoritmo de Kruskal. . . . . . . . . . . . . . . . . . 150

Índice alfabético
εmaq, 34, 220
εmin, 19, 34, 220
φ (de Euler), 53
adyacencia
lista de, 161
matriz de, 136
adyacente (vértice), 134
aguja
de Buffon, 94
Hanoi, 113, 121
Al-Khwarizmi, 25
algoritmo, 25
de búsqueda, ver búsqueda
de clasificación, ver clasificación
de Eratóstenes, 60
de Euclides, 49
de Prim, 145
Dijkstra, 141
para grafos, ver grafo
para permutaciones, 124
para subconjuntos, 121
visitar, 137
and, 23
aproximación, ver también convergencia,
método de Monte
Carlo
acantidaddeprimos,61
de n!, 111
de sen x, 164
de número armónico Hn, 41
de raíz cuadrada, 45
de raíz de ecuación, 70
árbol
binario ordenado, 126
caracterización, 135
definición, 135
hoja, 135
rama, 135
archivo
caja de herramientas, 84
de texto, 86, ver también editor
de textos
para guardar programa, 10
arista
de grafo, 133
extremo, 134
lista de, 136, 161
Arquímedes, 59
array, ver arreglo
arreglo, 55, ver también lista
como conjunto, 104
dimensión, 55
ASCII (código), 23, 24
año bisiesto, 27
begin-end
en parte principal, 10
para agrupar, 28
para funciones y procedimientos,
67
Bigollo, ver Fibonacci
Binet, 116
bisección (método), 70
bit, 7
Boole, 13
boolean, 13
bucle (lazo), 30
Buffon, 94
búsqueda
aloancho,139
binaria, 98, 169
en grafo, 137
en profundidad, 140
exhaustiva, 132
lineal, 57
lineal con centinela, 96
byte, 8
caja de herramientas, 84
cálculo

Pág. 226 Índice alfabético
de suma o producto, 32
numérico, ver sec. 5.1
calendario (juliano y gregoriano), 27
camino en grafo, 134
carácter
comparación, 27
imprimible, 23
yordinal,24
case, 26
caótico, 47
char, 13, ver también carácter
chr, 24
ciclo
de Euler, 162
en grafo, 134
clasificación
comparación de métodos, 103
de caracteres, 27
de registros, 107, 108
estabilidad, 109
inserción directa, 101
intercambio directo, 101
lista encadenada, 159, 160
métodos, 101
por conteo, 103
por fusión, 102, 166
recursiva, 112
selección directa, 101
yárbol binario, 126
cola, 119
de prioridad, 145
del supermercado, 168
fifo, 119, 140
lifo (pila), 119, 140
consola, 7
const, 32, 57, 66
contador, 31, 32, 34, 93, 122–124,
126
en arreglo, 56
en lazo, 71, 97, 102, 104
en “ for ”, ver variable de control
convergencia, 42, 43, ver también sec.
5.1
cuadrática, 54
de n/ ln n, 61
de polinomios, 63
de punto fijo, 47
global, 54
método de punto fijo, 42
CPU, 7
criba, 59
de Eratóstenes, 59
criterio de parada, 47, 51, 70, 72
de Moivre, A., 116
De Morgan, 63
leyes de, 23
densidad, 19
Dijkstra, 142, 146
algoritmo, 141
Diofanto, 49
Dirichlet, 43, 65
principio de, 94
dispose, 156
div, 17
do
y for, 35
y while, 30
downto, 36, ver también for-do
e (= 2.718 ...), 36, 42, 111, 219
Monte Carlo, 164
ecuación
cuadrática, 41
diofántica, 48
no lineal, 49
editor de textos, 9, 88, 89, 161, ver
también archivo de texto
else, ver if-then
end, ver también begin-end
“ ; ”antesde,29
sin begin, 105
eof, 88
eoln, 37
epsilon
de máquina (εmaq), 34
mínimo (εmin), 34
Eratóstenes, 59
criba, 59
error
absoluto y relativo, 47
numérico, 33, 34, 36, 41, 45, 72
estrategia, ver método
Euclides, 50, 59
algoritmo para mcd, 48–50
Euler, 54, 116, 133
ciclo de, 141, 162
constante de (γ), 41
función φ, 53

Índice alfabético Pág. 227
factorial, 33
recursivo, 111
Fermat, 49, 65
Fibonacci, 116
número de, 115, 123, 168
Flavio Josefo, 61, 160
for-do, 35
fórmula
de Gauss, 33, 48, 110
de Stirling para n!, 111
Euler-Binet, 116
para x y , 36
forward, 74
función continua, 54
function, ver cap. 7
Gauss, 33
suma de, 32, 41, 110
get (en Pascal), 120
get (en cola), 120
Goldbach, 54
cuenta de, 164
grafo, 133, 137
arista, 133
conexo, 134
dirigido (digrafo), 135
representación, 136
simple, 134
vértice, 133
y lista encadenada, 161
Gregorio (Papa), 27
Hanoi (torres de), 113
Horner, 63
regla de, 63
identificador (de variable), 13
if-then, 26
input al comienzo de programa, 10
integer, 13
juego, ver también problema
cartas (clasificar), 101
de Nim, 169
generala, 164
Julio César, 27
Kruskal, 146
algoritmo, 149
Lagrange, 163, 164
lazo, 30
Leonardo de Pisa, ver Fibonacci
lineal
estructura de arreglo, 126
lista, 160
lista, ver también arreglo
de aristas, 136
encadenada, 157
matriz
arreglo multidimensional, 85
de adyacencias, 136
de costos, 144
máximo común divisor, ver mcd
maxint, 19, 220, ver también integer
mcd, 48, 49, 53, 65, 164
recursivo, 116
media (indicador estadístico), 168
mediana (indicador estadístico), 168
memoria (de computadora), 7
método
babilónico, 45, 53
de barrido, 48
de bisección, 70
de clasificación ver clasificación,
101
de Monte Carlo
para e, 164
para π, 93, 94
de Newton-Raphson, 46
de punto fijo, 42
mínimo común múltiplo (mcm), 52
mod, 22
moda (indicador estadístico), 168
new, 156
Newton, 46
nil, 156
nivel (en árbol), 135
normalización, 47
not, 23
número
armónico (Hn), 41
de Fibonacci, ver Fibonacci
entero, ver integer
primo, ver primo
real, ver real
or, 23

Pág. 228 Índice alfabético
ord, 24
ordinal y carácter, 24
output al comienzo de programa, 10
packed, 83
parámetro
formal, 77
real, 77
pasar (por valor o referencia), 77
Pascal (Blaise), 9
período (en expresión decimal), 64,
89
pi (π), 32, 164
en programa, 32, 76
Monte Carlo, 93, 94
punto fijo, 45
pila, 119
Pitágoras, 50
terna pitagórica, 49
polinomio, 62
de Lagrange, 63, 163
pop (en pila), 120
potencia (cálculo de), 36, 65–68
Prim, 146
algoritmo, 145
primo, 52, 54, 55, 65, 113, ver también
criba de Eratóstenes
Euclides, 52
existencia de infinitos, 52
factorización, 50, 52
y recursión, 117
primos entre sí (coprimos),50
principio
de Dirichlet, 94
del casillero, 94
del palomar, 94
problema
cola del supermercado, 168
contando palabras en texto, 89
cuenta de Goldbach, 164
de “manos”, 165
de Flavio Josefo, 61, 160
de las cajas, 100, 108
del cumpleaños, 94
del viajante, 131
interés sobre saldo, 73
numérico, 41
producción de fábrica, 169
show de televisión, 94
torres de Hanoi, 113, 117
visibilidad en el plano, 164
procedure, ver cap. 7
programa, 8
ejecutable, 9
fuente, 9
mencionado
anchoprimero, 139–141, 144,
145, 147, 148, 153, 162, 199
arbolbinario, 129, 140, 156, 157,
160, 197
babilonico, 47, 181
biseccion, 71, 72, 189
busquedalineal, 57, 59, 82, 96,
184
caracteres1, 24, 175
caracteres2, 27, 176
cifras, 34, 179
comparar, 27, 176
dado, 92, 195
dados, 92, 93, 196
dearchivoaconsola, 87, 89, 195
deconsolaaarchivo, 194
deconsolaarchivo, 87–89
dijkstra, 144, 145, 147, 148,
151–153, 202
enteroareal, 20, 174
eolnprueba, 38, 180
epsmin, 34, 37, 179
eratostenes, 60, 186
euclides, 51, 182
factoresprimos, 53, 183
flaviojosefo1, 61, 187
gauss, 33, 36, 37, 178
grafos, 161, 209
holamundo, 10, 173
intercambio, 77, 192
leerdato, 17, 26, 173
listas, 159, 160, 206
maximocaracter, 83, 84, 86, 121,
192
positivo, 22, 23, 175
potencia, 36, 180
potencias2, 67, 68, 188
potencias3, 68, 77, 188
raiz, 18, 174
resto, 30, 37, 62, 177
segundos, 22, 175
sumardatos, 39, 56, 57, 181
sumardos, 16, 17, 21, 173
tablaseno, 32, 37, 75, 76, 177

Índice alfabético Pág. 229
tablaseno2, 76, 77, 191
unidades, 56, 58, 184
valorabsoluto, 26, 176
prueba de escritorio, 30
puntero, 155
push (en pila), 120
put (en Pascal), 120
put (en cola), 120
Raphson, 46
read, 17, 83
readln, 17
real, 13
record, 105
recorrido de grafo, 137
registro, 105
repeat-until, 34
reset, 87
rewrite, 87
signo (función), 43, 220
Stirling, 111
suma de Gauss, ver Gauss
técnica, ver método
teorema
caracterización de árboles, 135,
146
de Dirichlet, 65
de Euler, 133, 141
de los números primos, 61
suma de grados, 137
terna pitagórica, 49
text
como argumento, 87
tipo, 68, 86
texto, ver editor de, archivo de
then, ver if-then
tipo (de variable), 13
to, ver for-do
type, 81
until, ver repeat-until
Van der Monde, 163
var
declaración de variable, 14
pasar por referencia, 78
variable, 13
carácter (char), 13, 23
de control en “ for ”, 36
elemental, 13
entera (integer), 13, 16
global, 69
local, 68
lógica (boolean), 13, 22
real (real), 13, 16
vértice
adyacente, 134, 161
aislado, 134
de grafo, 133
grado, 137
von Neumann, 7
while-do, 30
Wiles, 49, 65
with, 106
write, 16
writeln, 11
Zeckendof, 168