U2 Algoritmos

Programa desarrollado
Unidad 2. Algoritmos

Educacin Abierta y a Distancia * Ciencias Exactas, Ingenieras y Tecnologas
1

1
Universidad Abierta y a Distancia de Mxico

Licenciatura en Matemticas

Computacin I

6 Cuatrimestre


Clave:
050920621/060920621


2

2
ndice
Presentacin de la unidad ...................................................................................... 3
Propsitos ............................................................................................................... 3
Competencia general .............................................................................................. 3
2.1. Fundamentos .................................................................................................... 3
2.1.1. Conceptos Bsicos ....................................................................................... 4
2.1.2. Caractersticas .............................................................................................. 8
2.1.3 Complejidad ................................................................................................. 9
2.1.4. NP-Completo ............................................................................................. 19
Actividad 1. Representaciones de Algoritmos .................................................... 23
2.2. Representacin de Algoritmos ...................................................................... 24
2.2.1. Pseudocdigo ............................................................................................. 24
2.2.2. Diagrama de Flujo ...................................................................................... 26
Actividad 2. Parmetros para comparacin de algoritmos ............................... 28
2.3. Tipos de Algoritmos ....................................................................................... 29
2.3.1. Algoritmo de Bsqueda .............................................................................. 31
2.3.2. Algoritmo de Ordenamiento ........................................................................ 35
2.3.3. Algoritmos Glotones ................................................................................... 39
2.4. Programacin ................................................................................................. 44
2.4.1. Programacin de Algoritmos en C .............................................................. 44
2.4.2. Programacin de Algoritmos en Java ......................................................... 52
Actividad 3. Desarrollo de Algoritmos Tpicos ................................................... 61
Autoevaluacin ..................................................................................................... 62
Evidencia de Aprendizaje. Programacin de algoritmos tpicos en C y J ava .. 63
Cierre de la Unidad ................................................................................................ 63
Para saber ms ...................................................................................................... 64
Fuentes de consulta .............................................................................................. 64


3

3

Presentacin de la unidad

En esta unidad tendrs la oportunidad de aprender los fundamentos de los algoritmos. Adems de los
conceptos bsicos y sus caractersticas, te introducirs a la comparacin de algoritmos considerando sus
tiempos de ejecucin y otros elementos de complejidad.

Conocers los problemas NP-Completos para los cuales nadie ha sido capaz de encontrar un algoritmo
eficiente que se ejecute en una computadora convencional.

Estudiars los detalles de dos representaciones comunes para los algoritmos: pseudocdigo y diagramas
de flujo.

Finalmente estudiars algoritmos prcticos de bsqueda y ordenamiento, as como unos ms avanzados
llamados glotones. Te mostraremos el cdigo en lenguaje C y en Java de estos algoritmos, para que los
pruebes y experimentes con ellos.

Propsitos

Al finalizar esta unidad sers capaz de:
Identificar las representaciones de algoritmos que utilizan pseudocdigo y diagramas de flujo.
Determinar la complejidad de los algoritmos para seleccionar los ms apropiados para la solucin
que se est desarrollando.
Utilizar algoritmos para resolver problemas matemticos.
Programar algoritmos que resuelven problemas matemticos utilizando los lenguajes de
programacin C y Java.

Competencia general

Utilizar procesos informticos para crear algoritmos y representarlos por medio de pseudocdigo y
diagramas de flujo.

2.1. Fundamentos

Informalmente un algoritmo es un procedimiento computacional bien definido que toma algn valor, o
conjunto de valores, cmo entrada y produce algn valor, o conjunto de valores, cmo salida.

Podemos considerar tambin a un algoritmo como una herramienta para resolver un problema
computacional bien especificado.


4

4
Por ejemplo, podemos querer ordenar de manera creciente una secuencia de nmeros. Este problema se
presenta frecuentemente en la prctica y tambin es til para introducir tcnicas estndares de diseo y
herramientas de anlisis.

Definamos formalmente el problema del ordenamiento de la manera siguiente:

Entrada: Una secuencia de n nmeros

Salida: Una permutacin (reordenamiento)
de la secuencia de entrada tal que
.

Por ejemplo, dada la secuencia de entrada , un algoritmo de ordenamiento devuelve
como salida la secuencia . Una secuencia de entrada como la planteada se denomina
una instancia del problema de ordenamiento. En general, una instancia de un problema consiste de la
entrada necesaria para calcular una solucin del problema.

Muchos programas utilizan el ordenamiento en alguno de sus pasos, as que esta operacin es
fundamental para la Informtica. Como resultado, se ha desarrollado una buena cantidad de algoritmos
de ordenamiento.

El algoritmo que es mejor para una determinada aplicacin depende entre otros factores, del nmero de
elementos que van a ser ordenados, de cunto ordenamiento ya tienen, de las posibles restricciones de los
valores de los elementos, de la arquitectura de la computadora, y de la clase de dispositivos de
almacenamiento que van a ser utilizados: memoria principal, discos, o an cintas magnticas

Existen muchos tipos de algoritmos que resuelven problemas en casi todas las reas de la actividad
humana.

Se dice que un algoritmo es correcto si, para cada instancia de entrada, entrega la salida correcta.
Decimos que un algoritmo correcto resuelve el problema computacional dado. Un algoritmo incorrecto
puede entregar una respuesta incorrecta o puede continuar sin detenerse para algunas instancias de
entrada.

Un algoritmo puede ser especificado en espaol, como un programa de computadora, o inclusive como un
diseo de hardware. El requerimiento es que la especificacin debe proporcionar una descripcin
precisa del procedimiento computacional a ser realizado.

2.1.1. Conceptos Bsicos

La palabra algoritmo proviene del nombre de al-Khwrizm, matemtico, astrnomo y gegrafo persa
nativo de una ciudad que fue parte de lo que actualmente es Uzbekistn.


5

5
Antes de que hubiera computadoras, haba algoritmos. Pero ahora que hay computadoras, hay an ms
algoritmos, pues son parte del ncleo de la computacin.

Qu Clase de Problemas son Resueltos Utilizando Algoritmos?

El problema del ordenamiento que mencionamos anteriormente no es, por supuesto, el nico problema
computacional para el que los algoritmos han sido desarrollados. Las aplicaciones prcticas de los
algoritmos se encuentran actualmente en casi cualquier rea:

El proyecto del genoma humano contina siendo desarrollado. La identificacin de los 100,000
genes en el ADN humano, la determinacin de las secuencias de los 3,000 millones de pares de
base qumica que forman el ADN, el almacenamiento de la informacin y el desarrollo de
herramientas para el anlisis de datos requiere algoritmos sofisticados. Muchos mtodos para
resolver estos problemas biolgicos obtienen ideas de los algoritmos ms simples, permitiendo a los
cientficos realizar sus tareas al mismo tiempo que utilizan eficientemente los recursos disponibles.

Internet permite a las personas de todo el mundo acceder y obtener rpidamente grandes
cantidades de informacin. Con la ayuda de buenos algoritmos, los sitios son capaces de
administrar y manipular un gran volumen de datos. Otro tipo de algoritmos se utilizan para encontrar
las mejores rutas por las que deben viajar los datos.

El comercio electrnico permite la compra-venta e intercambio de bienes y servicios, y depende
de la privacidad de informacin personal tal como nmeros de tarjetas de crdito, contraseas y
estados de cuenta bancarios. Las tecnologas incluyen la criptografa y las firmas digitales, las
cuales se basan en algoritmos numricos y en la teora de nmeros.

Las compaas de manufactura y de otras actividades comerciales necesitan a menudo asignar
recursos escasos de la forma ms conveniente. Una compaa petrolera puede desear saber dnde
instalar sus pozos para maximizar sus utilidades.

Un poltico quiere determinar dnde comprar anuncios de campaa para maximizar sus
oportunidades de ganar una eleccin.

Una lnea area desea asignar tripulaciones a los vuelos de la forma menos costosa posible,
asegurndose de que cada vuelo sea cubierto y de que las regulaciones gubernamentales sean
cumplidas.

A partir de un mapa de caminos, en el que la distancia entre cada par de intersecciones adyacentes
est indicada, puede quererse determinar la ruta ms corta entre dos intersecciones.


6

6
Considerando un diseo mecnico dado en trminos de una biblioteca de partes, donde cada
elemento puede incluir instancias de otras partes. Puede necesitarse listar los componentes de
modo que cada uno aparezca antes de cualquier otro elemento que la utiliza.

La lista puede continuar indefinidamente, pero exhibe dos caractersticas que son comunes a muchos
problemas algortmicos:

1. Tienen muchos candidatos de solucin, la mayora de los cuales no resuelve el problema
especfico. Encontrar la respuesta correcta, o la mejor, puede llegar a ser muy desafiante.

2. Son o pueden ser aplicaciones prcticas.

Puede ser definida rigurosamente la nocin de Algoritmo?

Elegimos contestar la pregunta de la siguiente forma: s y no.

Por qu no?

De acuerdo a fuentes consultadas, la nocin de Algoritmo no puede ser definida rigurosamente de manera
general, al menos por el momento. La razn es que la nocin se est expandiendo.

Muchas clases de algoritmos han sido introducidas. Adicionalmente a los algoritmos secuenciales clsicos
en uso desde la antigedad, tenemos ahora algoritmos paralelos, interactivos, distribuidos, en tiempo real,
analgicos, hbridos, cunticos, etc. Nuevas clases continan crendose, as que una definicin formal
completa no ha podido ser cristalizada.

Por qu la respuesta es s?

Sin embargo, el problema de la definicin rigurosa de los algoritmos no carece de esperanza. Algunos
estratos han madurado lo suficiente para soportar definiciones ortodoxas..

Esto aplica a los algoritmos clsicos (o secuenciales clsicos), esencialmente los nicos algoritmos en uso
desde la antigedad hasta la dcada de 1950. Los algoritmos se ejecutan en pasos de complejidad
limitada, escribi Andrei Kolmogorov en 1953. Esta es una buena definicin informal de los algoritmos
secuenciales.

Una definicin axiomtica de los algoritmos secuenciales puede ser encontrada en Gurevich, Y. Sequential
Abstract State Machines Capture Sequential Algorithms, ACM Transactions on Computational Logic 1:1
(2000) 77-111. Esta definicin fue utilizada para derivar la tesis Church-Turing y hace suponer que
Church y Turing tenan en mente solamente algoritmos secuenciales.

La definicin axiomtica fue extendida ms tarde a los algoritmos paralelos sncronos y a los algoritmos
secuenciales interactivos.


7

7
Qu definicin de Algoritmo podemos utilizar?

Despus de haber comentado informalmente acerca de los algoritmos, explorado los campos de aplicacin
y mostrado el umbral para introducirnos a las definiciones formales, expondremos los detalles de algunos
algoritmos prcticos que pueden ser ejecutados en una computadora.

Este ser un buen punto de partida para que ms adelante puedas desarrollar algoritmos propios que
resuelvan problemas especficos y estar en posibilidad para definir un algoritm, desde un punto de vista
prctico, como:

Un algoritmo es un mtodo para resolver problemas, adecuado para ser implementado en una
computadora.

Por su parte, Schneider and Gersting, lo definen como:

Un algoritmo es una coleccin bien ordenada de operaciones no-ambiguas y computables
efectivamente que cuando son ejecutadas producen un resultado y se detienen en una cantidad
finita de tiempo.

Ambas definiciones describen adecuadamente la esencia de un algoritmo, pero la segunda tambin expone
detalles que nos sern tiles ms adelante para derivar caractersticas de los algoritmos.

Presentaremos algunos algoritmos fundamentales importantes e interesantes p Te recomendamos que
los implementes los pruebes y e experimentes con variantes, para su aplicacin en problemas reales.

Problemas Difciles

Los algoritmos que discutiremos suelen ser eficientes (considerando que son bsicos). Nuestra medida
usual de eficiencia es la velocidad, esto es, el tiempo que necesita un algoritmo para producir su resultado.

Existen algunos problemas para los cuales no se conoce una solucin eficiente. Ms adelante estudiars
un subconjunto interesante de este tipo de problemas: los NP-completos.

Por qu son interesantes los problemas NP-completos?

En primer lugar, aunque no ha sido encontrado un algoritmo eficiente para un problema NP-
completo, no se ha probado que ese algoritmo no pueda existir. En conclusin: no se sabe si
existen o no algoritmos eficientes para problemas NP-completos.

En segundo lugar, el conjunto de problemas NP-completos tiene la notable propiedad de que si un
algoritmo eficiente existe para cualquiera de ellos, entonces hay algoritmos eficientes para todos
ellos (No te parece tentador tratar de encontrar un algoritmo eficiente para este conjunto?)


8

8
En tercer lugar, varios problemas NP-completos son similares, aunque no idnticos, a problemas
para los cuales conocemos algoritmos eficientes. Los cientficos de la informtica estn intrigados
al observar cmo un pequeo cambio en la declaracin del problema puede ocasionar una gran
alteracin en la eficiencia del algoritmo mejor conocido.

Es necesario saber acerca de los problemas NP-completos porque algunos de ellos aparecen a menudo en
las aplicaciones reales. Si en el futuro eres requerido para producir un algoritmo eficiente para un problema
y logras demostrar que el problema es NP-completo, podrs dedicar tu tiempo a desarrollar un algoritmo
que produzca una buena, aunque no la ms eficiente, solucin.

2.1.2. Caractersticas

Para que un algoritmo sea ejecutable en una computadora, debe poseer ciertas caractersticas. La
definicin de algoritmo de Schneider and Gersting que incluimos en la seccin anterior, exhibe cinco
caractersticas importantes de los algoritmos:

1. Estn bien ordenados.
2. Contienen operaciones no-ambiguas.
3. Contienen operaciones computables efectivamente.
4. Producen un resultado.
5. Se detienen en una cantidad finita de tiempo.

Discutimos a continuacin detalles de cada una de estas caractersticas.

1. Los algoritmos estn bien ordenados

Un algoritmo es una coleccin de operaciones o instrucciones y debe conocerse el orden correcto en el que
deben procesarse. Si el orden no es claro, puede ejecutarse la instruccin equivocada o ser incierta qu
instruccin debe ejecutarse a continuacin. Esta caracterstica es especialmente importante para las
computadoras. Una computadora solamente puede ejecutar un algoritmo si conoce el orden exacto de los
pasos a seguir.

2. Los algoritmos contienen operaciones no-ambiguas

La instruccin ordena esta lista de nmeros es adecuada para una persona, pero ambigua para una
computadora, as que debe ser simplificada. Cada operacin en un algoritmo debe ser lo suficientemente
clara de manera que no necesite ser simplificada.

Los algoritmos que van a ser ejecutados en una computadora deben escribirse con operaciones bsicas
conocidas como operaciones primitivas. Cuando un algoritmo es escrito usando operaciones primitivas, el
algoritmo es no-ambiguo y la computadora puede ejecutarlo.

3. Los algoritmos contienen operaciones computables efectivamente


9

9

Cada operacin en un algoritmo debe poder ejecutarse. . Existen operaciones que las computadoras no
pueden hacer, como por ejemplo dividir entre cero o encontrar la raz cuadrada de un nmero negativo.
Este tipo de operaciones no son computables efectivamente, as que no pueden ser usadas para escribir
algoritmos.

4. Los algoritmos producen un resultado

En la definicin simple de algoritmo, establecimos que se trata de un mtodo para resolver problemas. A
menos que un algoritmo produzca un resultado, nunca se podr estar seguro que la solucin es correcta.

Si alguna vez alimentaste con un comando a una computadora y nada ocurri, seguramente pensaste que
la computadora estaba funcionando mal: tu comando no produjo ningn resultado o cambio visible. . Lo
mismo se aplica a los algoritmos, solamente aquellos que producen resultados pueden ser verificados
como correctos o errneos.

5. Los algoritmos se detienen en una cantidad finita de tiempo

Los algoritmos deben estar compuestos de un nmero finito de operaciones y deben completar su
ejecucin en una cantidad determinada de tiempo. Vamos a suponer que se desea escribir un algoritmo
que muestre en pantalla todos los enteros mayores que 1.

Los pasos se escribiran como sigue:

1. Muestra el nmero 2

El algoritmo luce muy claro, pero tiene dos problemas:

En primer lugar, contiene un nmero infinito de pasos porque existe un nmero infinito de enteros
mayores que 1.
En segundo lugar, el algoritmo continuar ejecutndose para siempre tratando de alcanzar un nmero
infinito.

Estos problemas violan la consideracin de que un algoritmo debe detenerse en una cantidad finita de
tiempo y deben alcanzar alguna operacin que los obligue a detenerse.

2.1.3 Complejidad

Despus de obtener un algoritmo que funciona correctamente y de haberlo trasladado a un programa, es
necesario definir criterios para medir su rendimiento, los cules consideran la sencillez del algoritmo y el
uso eficiente que hace de los recursos.


10

10

La sencillez en el diseo de un algoritmo facilita su verificacin, el estudio de su eficiencia y su
mantenimiento. Es recomendable, mantener el algoritmo tan simple como sea posible y cuidar que
el cdigo que se genere sea legible.

El uso eficiente de los recursos, suele medirse en funcin de dos parmetros:
o Espacio (memoria o almacenamiento que se utiliza)
o Tiempo (lo que tarda la ejecucin)

Los parmetros representan el costo de encontrar la solucin al problema planteado utilizando un algoritmo
y son tiles tambin para comparar diferentes algoritmos que solucionan el mismo problema. La eficiencia
temporal se considera ms comnmente y es la que estudiaremos a continuacin.

El tiempo de ejecucin de un algoritmo depende de varios factores.

Los datos de entrada
La calidad del cdigo generado por el compilador
La naturaleza y rapidez de las instrucciones del procesador especfico
La complejidad intrnseca del algoritmo

Existen dos formas de estudiar los tiempos de ejecucin:

1. La que proporciona una medida terica y consiste en obtener una funcin que limite (superior o
inferior) el tiempo de ejecucin del algoritmo para determinados valores de entrada.

2. La que ofrece una medida real y consiste en medir el tiempo de ejecucin del algoritmo para
determinados valores de entrada en una computadora especfica.

La primera medida ofrece una estimacin del comportamiento del algoritmo de forma independiente de la
computadora sin necesidad de ser ejecutado.

La segunda representa las medidas reales del comportamiento del algoritmo y se consideran funciones
temporales de los datos de entrada.

El tamao de la entrada es el nmero de componentes sobre los que va a actuar el algoritmo. Ejemplos
de este tamao seran la dimensin de un vector a ordenar o el tamao de las matrices a multiplicar.

Denotaremos con T(n) el tiempo de ejecucin de un algoritmo para una entrada de tamao n.

Tericamente T(n )indicara el nmero de instrucciones ejecutadas por una computadora ideal. Deben
establecerse, entonces, medidas simples y abstractas independientes de la computadora. Para esto debe
acotarse de alguna manera la diferencia que se puede producir entre distintas implementaciones de un
mismo algoritmo.


11

11

Puede tenerse el mismo cdigo ejecutado por dos mquinas de velocidad diferente o dos cdigos
implementando el mismo mtodo. La diferencia da lugar al siguiente principio:

Principio de Invarianza

Dado un algoritmo y dos de sus implementaciones I1 e I2, que consumen T1(n) y T2(n) segundos
respectivamente, el Principio de Invarianza afirma que existen una constante real c > 0 y un nmero
natural n0 tales que para todo
.

Es decir, el tiempo de ejecucin de dos implementaciones distintas de un mismo algoritmo, no va a diferir
ms que en una constante multiplicativa.

De acuerdo a lo anterior podemos afirmar que un algoritmo tarda un tiempo del orden de T(n) si existen
una constante real c > 0 y una implementacin I del algoritmo que tarda menos que cT(n), para todo
tamao n de la entrada.

Deben tenerse en cuenta tanto la constante multiplicativa como el n0 para los que se verifican las
condiciones porque si, en principio, un algoritmo de orden cuadrtico es mejor que uno de orden cbico, al
tener, por ejemplo, dos algoritmos con tiempos de ejecucin de 10
6
n
2
y 5n
3
respectivamente, el primero
slo ser mejor que el segundo para tamaos de entrada superiores a 200,000.

El comportamiento de un algoritmo puede cambiar notablemente para diferentes entradas. Si se utiliza, por
ejemplo, un algoritmo de ordenamiento, su comportamiento va a cambiar dependiendo de lo ordenado que
se encuentren los datos de entrada. Para muchos programas el tiempo de ejecucin es una funcin de la
entrada especfica y no slo de su tamao.

Casos de Estudio

Para un mismo algoritmo, suelen estudiarse tres casos:

Mejor caso. Corresponde a la secuencia del algoritmo que realiza menos instrucciones.
Peor caso. Corresponde a la secuencia del algoritmo que realiza ms instrucciones.
Caso promedio. Corresponde a la secuencia del algoritmo que realiza un nmero de instrucciones
igual a la esperanza matemtica de la variable aleatoria definida por todas las posibles secuencias
del algoritmo para un tamao de entrada, con las probabilidades de que stas ocurran para esa
entrada.

La medicin del tiempo se hace en funcin del nmero de operaciones elementales que realiza el
algoritmo.

Consideramos operaciones elementales (OPEL) aquellas que realiza la computadora en un tiempo
acotado por una constante.


12

12

Las operaciones elementales incluyen: operaciones aritmticas bsicas, las asignaciones a variables de
tipo predefinido por el compilador, los saltos, las llamadas a funciones y procedimientos (as como sus
retornos), el acceso a estructuras bsicas indexadas (como vectores y matrices), y las comparaciones
lgicas. Cada una de ellas cuenta como 1 OPEL.

Tomando en cuenta lo anterior, el tiempo de ejecucin de un algoritmo es una funcin que mide el
nmero de operaciones elementales que realiza el algoritmo para un determinado tamao de entrada.

Podemos analizar un ejemplo tpico: la bsqueda de un nmero c dentro de un arreglo de tamao n.
Suponemos que el algoritmo ha sido codificado con un lenguaje de programacin y lo expresaremos en
pseudocdigo para facilitar el anlisis.

Empezamos con las declaraciones:

Constante n = un nmero entero (int) // nm mximo de elementos de un vector;
Type vector = Array[1..n] de int

Y ahora, la implementacin del algoritmo:

Programa Busca (VAR a: vector; c: int)
int j

BEGIN
j = 1 // 1
WHILE (a[j] < c) AND (j < n) do // 2
j = j + 1 // 3
END WHILE
IF a[j] = c then // 4
return j // 5
ELSE return 0 // 6
ENDIF
END Busca

Para determinar el tiempo de ejecucin, se calcula primero el nmero de operaciones elementales (OPEL)
que se efectan:

Lnea 1: se ejecuta una asignacin (1 OPEL).

Lnea 2: se prueba la condicin del ciclo y ocurren dos comparaciones, un acceso alvector y un AND (4
OPEL).

Lnea 3: ocurre un incremento y una asignacin (2 OPEL).


13

13
Lnea 4: existe una condicin y ocurre un acceso al vector (2 OPEL).

Lnea 5: contiene un return (1 OPEL) si la condicin se cumple.

Lnea 6: contiene un return (1 OPEL), cuando la condicin del IF es falsa.

No se toma en cuenta la copia del vector al rea de ejecucin del programa porque se est pasando por
referencia y no por valor (es lo que indica la palabra VAR). Si se decidiera pasar el vector por valor
(copiando su contenido al rea de ejecucin) tendra que tomarse en cuenta el costo de hacer esto, o sea
agregar n OPEL.

Los casos seran:

Mejor caso donde el algoritmo encuentra el nmero c inmediatamente en la primera posicin del vector,
con lo que el programa termina. Se ejecuta entonces la lnea 1 y la primera mitad de la condicin lo que
representa 2 OPEL (el comportamiento normal del cdigo implica que las expresiones se evalan de
izquierda a derecha y se detiene la evaluacin de la expresin lgica en el momento en que se conoce su
valor (aunque falten trminos por evaluar). Como la condicin es falsa porque el contenido de la celda del
vector es igual al nmero buscado, no se entra al cuerpo del WHILE. Despus de esto, el programa ejecuta
las lneas 4 (2 OPEL) y 5 (1 OPEL). Por lo tanto,

T(n) = 1+2+2+1 = 6.

Peor caso. Donde el programa recorre todo el vector y no encuentra el nmero buscado. El programa
termina al agotarse las posiciones del vector. Se efecta la lnea 1 (1 OPEL), luego el ciclo WHILE se repite
n-1 veces hasta que se cumple la segunda condicin. Despus se efecta la condicin de la lnea 4 y la
funcin acaba al ejecutarse la lnea 6. Cada iteracin del ciclo incluye las lneas 2 y 3, adems de una
ejecucin adicional de la lnea 2 que provoca la salida del ciclo.

((
) )

Caso promedio. Cualquier otro caso que no sea el mejor ni el peor. El ciclo WHILE se ejecutar un
nmero de veces entre 0 y n-1. Suponemos que cada nmero tiene la misma probabilidad de suceder.

Como existen n posibilidades (puede ser que el nmero buscado no est en el vector) cada una tendr una
probabilidad asociada de 1/n. De acuerdo a esto, el nmero de veces que se efectuar el ciclo es de

Se tiene entonces que


14

14
((
) )

No es necesario conocer el propsito del algoritmo para analizar su tiempo de ejecucin y determinar sus
tres casos. Basta con estudiar su cdigo. No debe caerse en el error de determinar los casos basndose en
el propsito del algoritmo; el cdigo implementado es el que los determina.

Anlisis de Algoritmos

Despus de la revisin de este caso tpico sencillo, pueden discutirse elementos que dan paso al anlisis
de algoritmos ms complejos.

Para la mayora de los problemas suelen estar disponibles diversos algoritmos, y aunque ha sido
estudiado el rendimiento de muchos de ellos, su comparacin contina siendo desafiante. Por esta razn,
se han desarrollado guas que ayudan a hacer las comparaciones.

Como lo mencionamos antes, los problemas que resolvemos normalmente tienen un tamao natural
considerando la cantidad de datos a procesar y llamamos n a esta cantidad. Deseamos describir los
recursos utilizados como una funcin de n y estamos interesados en el caso promedio: la cantidad de
tiempo que un programa necesite para procesar datos "tpicos" de entrada y en el peor caso: la cantidad
de tiempo que requiere un programa para ejecutar la peor configuracin de entrada posible.

Algunos algoritmos han sido bien estudiados, as que existen frmulas matemticas precisas para ambos
casos. Las frmulas se desarrollaron estudiando el programa para encontrar el tiempo de ejecucin en
trminos de cantidades matemticas fundamentales y luego realizando el anlisis de las cantidades
involucradas.

En el otro extremo se encuentran los algoritmos cuyas propiedades de rendimiento no han podido ser
determinadas adecuadamente. Quizs su anlisis arroj preguntas matemticas que no han sido
contestadas, o tal vez las implementaciones son demasiado complejas como para que sea factible un
anlisis detallado, o quizs su tipo de datos de entrada no ha podido ser caracterizado adecuadamente. La
mayora de los algoritmos se encuentra entre ambos extremos.

Aunque existen factores importantes para el anlisis, stos quedan fuera del control de quien analiza:

Los programas se traducen al cdigo de mquina de una determinada computadora y puede ser
difcil establecer el tiempo de ejecucin de las instrucciones, especialmente en entornos de recursos
compartidos.
Muchos programas son muy sensibles a sus datos de entrada y su rendimiento puede variar mucho
dependiendo de los datos.
Otros programas no estn bien entendidos, as que resultados matemticos especficos pueden no
estar disponibles.


15

15
A menudo los programas no pueden ser comparados porque corren bajo circunstancias diferentes.

A pesar de las dificultades, es posible predecir el tiempo de ejecucin de un programa, o si un programa
ser ms eficiente que otro en ciertas situaciones. El analista descubrir la informacin del rendimiento de
los algoritmos y el programador aplicar esa informacin en su seleccin de algoritmos para aplicaciones
particulares.

Con los siguientes pasos es posible realizar una primera estimacin del tiempo de ejecucin de un
algoritmo:

Primer paso

Caracterizar los datos que se usarn como entrada y decidir el tipo de anlisis que es apropiado. Se
pretende determinar la distribucin de los posibles tiempos de ejecucin de un algoritmo , de acuerdo a la
distribucin de la probabilidad de ocurrencia de las posibles entradas.

Como no es posible lograr esto para cualquier algoritmo no trivial, ms bien se intenta probar que el tiempo
de ejecucin es siempre menor que alguna "cota superior" sin depender de la entrada, as como derivar el
tiempo de ejecucin promedio para una entrada "aleatoria".

Segundo paso

Identificar operaciones abstractas en las que se basa el algoritmo con el fin de separar el anlisis de la
implementacin.

Por ejemplo, se separa el estudio del nmero de comparaciones que realiza un algoritmo de ordenamiento,
de la determinacin del tiempo que requiere una computadora para ejecutar una instruccin de
comparacin.

Ambos elementos son necesarios para determinar el tiempo real de ejecucin de un programa.

Tercer paso

Proceder al anlisis matemtico teniendo como meta encontrar valores del caso promedio y del peor
caso para cada una de las cantidades fundamentales. No es difcil encontrar una cota superior para el
tiempo de ejecucin de un programa, el desafo es encontrar la mejor cota superior, una que sera
alcanzada si se diera el peor caso.

El caso promedio requiere normalmente un anlisis matemtico ms sofisticado.Despus de que se siguen
estos pasos, el tiempo asociado con cada cantidad fundamental puede ser determinado y obtener
expresiones para el tiempo total de ejecucin.


16

16
El rendimiento de un algoritmo puede llegar a ser analizado de forma precisa y estar limitado solamente
por la incertidumbre en el rendimiento de la computadora o por la dificultad de determinar las propiedades
matemticas de algunas de las cantidades abstractas.

Rara vez vale la pena efectuar un anlisis detallado completo, as que se suele estimar para suprimir los
detalles.

El anlisis de un algoritmo es un proceso cclico: analizar, estimar y refinar el anlisis hasta que se
obtenga una respuesta del nivel de detalle deseado.

El parmetro n que hemos estado manejando y que representa el nmero de elementos de datos a ser
procesados, afecta significativamente el tiempo de ejecucin.

Este parmetro puede ser el grado de un polinomio, el tamao de un archivo que va a ser ordenado o
explorado, el nmero de nodos de un grafo, etc.

La mayora de los algoritmos fundamentales tiene un tiempo de ejecucin proporcional a una de las
siguientes funciones:

1 La mayora de las instrucciones de gran parte de los programas se ejecuta slo
una vez, o mximo unas cuantas veces. Si todas las instrucciones de un programa
tienen esta propiedad, se dice que su tiempo de ejecucin es constante.
Log n Cuando el tiempo de ejecucin de un programa es logartmico, el programa se
hace un poco ms lento a medida que crece n. Este tiempo de ejecucin ocurre
comnmente en programas que resuelven un problema grande transformndolo en
uno ms pequeo, reduciendo el tamao por una fraccin constante.
n Cuando el tiempo de ejecucin de un programa es lineal, que es generalmente el
caso en el que una pequea cantidad de procesamiento se efecta en cada
elemento de entrada. Esta es la situacin ptima para un algoritmo que debe
procesar n entradas (o producir n salidas).
n log n Este tiempo de ejecucin se presenta para algoritmos que resuelven un problema
dividindolo en sub-problemas, resolvindolos independientemente, y luego
combinando las soluciones.
n
2
Cuando el tiempo de ejecucin de un algoritmo es cuadrtico, es prctico utilizarlo
solamente en problemas relativamente pequeos. Los tiempos de ejecucin
cuadrticos se presentan tpicamente en algoritmos que procesan todos los pares
de elementos de datos (quizs en un ciclo doblemente anidado).
n
3
Un algoritmo que procesa tripletas de elementos de datos (quizs en un ciclo
triplemente anidado) tiene un tiempo de ejecucin cbico y es prctico para ser
utilizado solamente en problemas pequeos.
2
n
Pocos algoritmos con un tiempo de ejecucin exponencial son apropiados para


17

17
usos prcticos, aunque tales algoritmos surgen naturalmente como soluciones de
fuerza bruta para los problemas.

El tiempo de ejecucin de un programa en particular puede considerarse como algn coeficiente constante
multiplicado por uno de los trminos de la tabla anterior (trmino principal) ms algunos trminos ms
pequeos. Los valores de estos elementos dependen de los resultados del anlisis y de los detalles de
implementacin.

De forma aproximada, el coeficiente constante depende del nmero de instrucciones del ciclo interno (es
prudente limitar este nmero). Para n grande domina el efecto del trmino principal; para n pequeo otros
trminos contribuyen y las comparaciones son ms difciles.

Complejidad

Un enfoque para estudiar el rendimiento de los algoritmos es estudiar el rendimiento del peor caso,
ignorando factores constantes, con el fin de determinar la dependencia funcional del tiempo de ejecucin
del nmero de entradas o alguna otra variable.

Primero hay que hacer la nocin de proporcional a matemticamente precisa, separando al mismo tiempo
el anlisis de un algoritmo de cualquier implementacin particular. La idea es ignorar los factores
constantes en el anlisis: en la mayora de casos, si queremos saber si el tiempo de ejecucin de un
algoritmo es proporcional a n o proporcional a log n, no importa en qu computadora va a ocurrir la
ejecucin o la manera en que el ciclo interno ser implementado.

El artefacto matemtico para hacer precisa esta nocin se denomina notacin-O, y se define como sigue:

Notacin: Una funcin se dice que es si existen constantes
tales que es menor

que
para todo
.

Informalmente, esto encapsula la nocin de es proporcional a y libera al analista de considerar los detalles
de caractersticas de mquina particulares. Adems, la declaracin de que el tiempo de ejecucin de un
algoritmo es es independiente de la entrada del algoritmo.

Estamos interesados en estudiar el algoritmo, no la entrada o la implementacin, as que la notacin-O es
til para establecer lmites superiores de ejecucin que son independientes tanto de las entradas como de
los detalles de implementacin.

Esta notacin ha sido muy til para que los analistas clasifiquen los algoritmos por rendimiento y para guiar
a los diseadores de algoritmos en la bsqueda de los mejores algoritmos para problemas importantes.

La meta del estudio de la complejidad de un algoritmo es demostrar que su tiempo de ejecucin es
para alguna funcin f, y que no puede haber un algoritmo con un tiempo de ejecucin de O(g(n)) para
cualquier funcin ms pequea (una funcin con
).


18

18

Intentamos proporcionar tanto un lmite superior como uno inferior para el tiempo de ejecucin del peor
caso. Probar los lmites superiores es a menudo una cuestin de contar y analizar frecuencias de
instrucciones; probar los lmites inferiores implica la construccin cuidadosa de un modelo y la
determinacin de cules operaciones fundamentales deben ser efectuadas para resolver un problema.

Cuando los estudios muestran que el lmite superior de un algoritmo coincide con su lmite inferior,
podemos inferir que es infructuoso tratar de disear un algoritmo que sea fundamentalmente ms rpido,
as que podemos concentrarnos en la implementacin. Este punto de vista ha demostrado ser muy til para
los diseadores de algoritmos en aos recientes.

Sin embargo, hay que ser extremadamente cuidadosos al interpretar los resultados expresados utilizando
la notacin-O, por al menos cuatro razones:

1. Es un lmite superior y la cantidad en cuestin puede ser mucho menor.
2. La entrada que produce el peor caso es improbable que ocurra en la prctica.
3. La constante c
0
es desconocida y no necesita ser pequea.
4. La constante n
0
es desconocida y no necesita ser pequea.

La declaracin de que el tiempo de ejecucin de un algoritmo es O(f(n)) no implica que ste alguna vez
requiera ese tiempo: solamente quiere decir que el analista ha sido capaz de probar que nunca va a
requerir ms tiempo. El tiempo real de ejecucin puede ser menor.

An si la entrada para el peor caso es conocida, puede ser que en la prctica consuma menor tiempo de
ejecucin. Muchos algoritmos tiles tienen un mal peor caso. Por ejemplo, quizs el algoritmo de
ordenamiento ms ampliamente usado, Quicksort, tiene un tiempo de ejecucin de
pero es posible
arreglar las cosas para que el tiempo de entradas encontradas en la prctica sea proporcional a

Las constantes c
0
y n
0
implcitas en la notacin-O esconden a menudo detalles de implementacin que son
importantes en la prctica. Obviamente, decir que un algoritmo tiene un tiempo de ejecucin no
significa nada si n es menor que n
0
, y c
0
, pues puede estar escondiendo una gran cantidad de sobrecarga
(overhead) diseada para evitar un mal peor caso. Preferiramos un algoritmo que utilizara n
2

nanosegundos por sobre uno que utilizara log n siglos, pero no podramos hacer esta seleccin con la base
de la notacin-O.

Anlisis del Caso Promedio

Otro enfoque para estudiar el rendimiento de los algoritmos consiste en examinar el caso promedio. En la
situacin ms simple, podemos caracterizar las entradas del algoritmo, por ejemplo, un algoritmo de
ordenamiento puede operar en un arreglo de n enteros aleatorios, o un algoritmo geomtrico puede
procesar un conjunto de n enteros aleatorios, o un algoritmo geomtrico puede procesar un conjunto de n
puntos aleatorios en el plano con coordenadas entre 0 y 1.


19

19
Calculamos el nmero de veces promedio que cada instruccin es ejecutada y el tiempo de ejecucin
promedio del programa multiplicando cada frecuencia de instruccin por el tiempo requerido por la
instruccin y sumando todo. Hay; sin embargo, al menos tres dificultades con este enfoque.

1. En algunas computadoras puede ser difcil determinar la cantidad de tiempo requerida para cada
instruccin. Esto est sujeto a cambio y mucho del anlisis detallado para una computadora puede
no ser relevante para otra. Este es el tipo de problema que los estudios de complejidad estn
diseados para evitar.

2. El anlisis del caso promedio a menudo es un difcil desafo matemtico que requiere argumentos
intrincados y detallados. Por su naturaleza, las matemticas involucradas en probar lmites
superiores son normalmente menos complejas, porque no necesitan ser tan precisas. El
rendimiento del caso promedio de muchos algoritmos es desconocido.

3. En el anlisis del caso promedio, el modelo de entrada puede que no caracterice las entradas
encontradas en la prctica o que no exista un modelo de entrada natural. Cmo podramos
caracterizar la entrada a un programa que procesa texto en lenguaje espaol? Por otro lado, pocos
argumentaran contra el uso de modelos de entrada tales como un archivo ordenado
aleatoriamente para un algoritmo de ordenamiento, o un conjunto de puntos aleatorios para un
algoritmo geomtrico. Para estos modelos es posible derivar resultados matemticos que pueden
predecir el rendimiento de programas en aplicaciones reales.

2.1.4. NP-Completo

Los algoritmos que estudiaremos ms adelante se utilizan para resolver problemas prcticos, as que
consumen una razonable cantidad de recursos; para varios de estos retos se tienen diferentes algoritmos
eficientes para escoger. Desafortunadamente, otros problemas prcticos no tienen soluciones eficientes,
incluso, hay casos en los que no podemos decir si existe o no una solucin idnea .

Esta situacin causa frustracin tanto a programadores y diseadores de algoritmos, quienes no pueden
encontrar algn algoritmo eficiente para un amplio rango de problemas prcticos y tericos. Estos expertos
han sido incapaces de encontrar la raz de esos problemas.

A veces la lnea entre problemas fciles y difciles es muy fina. Por ejemplo, existe un algoritmo eficiente
para el siguiente problema: Encontrar la trayectoria ms corta del vrtice x al vrtice y en un grafo
ponderado dado.

Pero si se pregunta por la trayectoria ms larga (sin ciclos) de x a y , tenemos un problema para el que
nadie conoce una solucin mejor que la de revisar todas las trayectorias posibles. La lnea fina resalta an
ms cuando consideramos problemas similares que solamente piden respuestas s o no:

Problema fcil: Existe una trayectoria de x a y con ?


20

20
Problema difcil (?): Existe una trayectoria de x a y con ?

Algoritmos existentes entregan una solucin para el primer problema en tiempo lineal, pero todos los
algoritmos conocidos para el segundo problema pueden requerir un tiempo exponencial.

Por lo general, es til pensar que un algoritmo de tiempo exponencial para una entrada de tamao n
requiere un tiempo proporcional a 2
n
(por lo menos).

Algoritmos Determinsticos y No- Determinsticos de Tiempo Polinomial

La gran diferencia de rendimiento entre los algoritmos eficientes y los algoritmos exponenciales de
fuerza bruta que revisan cada posibilidad permite estudiar la interfaz entre ellos con un modelo simple.

En este modelo, la eficiencia de un algoritmo es una funcin del nmero de bits utilizados para codificar la
entrada, con algn esquema de codificacin. Nos interesa identificar algoritmos que garanticen ejecutarse
en un tiempo proporcional para algn polinomio de acuerdo al nmero de bits de entrada (tiempo
polinomial).

Cualquier problema que puede ser resuelto por un algoritmo de este tipo se dice que pertenece a:

P: El conjunto de todos los problemas que pueden ser resueltos por
algoritmos determinsticos en tiempo polinomial.

Por determinstico queremos decir que en cualquier momento, sin importar lo que el algoritmo est
elaborando, existe solamente una cosa que puede hacer a continuacin.

Esta nocin considera la forma en que los programas se ejecutan en computadoras reales. Los algoritmos
de ordenamiento pertenecen a P porque (por ejemplo) el ordenamiento por insercin se ejecuta en un
tiempo proporcional a n
2
.

Asimismo, el tiempo tomado por un algoritmo depende de la computadora utilizada pues usar una
computadora diferente afecta el tiempo de ejecucin por solamente un factor polinomial (suponiendo
lmites razonables).

Puedes notar que estamos usando descripciones de naturaleza informal para exponer las ideas centrales
de la teora, no estamos desarrollando definiciones rigurosas o teoremas.

Una manera no razonable de extender la potencia de una computadora es dotarla con la capacidad del
no-determinismo: asegurar que cuando un algoritmo se enfrenta con una seleccin de varias opciones,
tiene la facultad de adivinar la correcta.

Para los propsitos de esta discusin, podemos pensar en un algoritmo no-determinstico que conjetura la
solucin a un problema y luego verifica que la solucin es correcta.


21

21
Tenemos entonces que:

NP: El conjunto de todos los problemas que pueden ser resueltos por
algoritmos no-determinsticos en tiempo polinomial.

Obviamente, cualquier problema que pertenezca a P tambin pertenece a NP. Parece que debera haber
otros problemas pertenecientes a NP: para demostrar que un problema pertenece a NP, necesitamos
encontrar un algoritmo de tiempo polinomial para probar que una solucin dada (la conjeturada) es vlida.

Por ejemplo, la versin s o no del problema de la trayectoria ms larga pertenece a NP. Otro ejemplo de
un problema que pertenece a NP es el problema de satisfabilidad. Dada una frmula lgica de la forma

Donde las
representan variables booleanas (verdadero o falso), + representa or, * representa and, y

representa not, el problema de satisfabilidad es determinar si existe o no una asignacin de valores a las
variables que hace que la frmula sea verdadera (que la satisfaga).

El no-determinismo es una operacin que no puede ser considerada con seriedad Por qu tomar en
cuenta esta herramienta imaginaria que hace que los problemas difciles parezcan triviales? Porque nadie
ha sido capaz de demostrar que ayuda en algn problema en particular!
No ha sido posible encontrar un problema que pueda demostrarse que pertenece a NP pero que no
pertenece a P (o an probar que alguno existe): no sabemos si P = NP o no.

Esta es una situacin frustrante porque muchos problemas prcticos importantes pertenecen a NP (podran
ser resueltos eficientemente en una mquina no-determinstica) pero puede que pertenezcan o no, a P (no
conocemos algoritmos eficientes para ellos en una mquina determinstica).

Si pudiramos probar que un problema no pertenece a P, se puede abandonar la bsqueda de una
solucin eficiente para l. A falta de tal prueba, existe la posibilidad de que algn algoritmo eficiente no ha
sido descubierto. Incluso podra existir un algoritmo eficiente para cada problema de NP, lo cual implicara
que muchos algoritmos eficientes han permanecido sin ser descubiertos.

Virtualmente nadie cree que P = NP, y un esfuerzo considerable ha sido realizado para probar lo contrario,
pero esto permanece an bajo investigacin en la informtica.

NP-Completos

Veremos una lista de problemas que pertenecen a NP, pero que pueden o no pertenecer a P. Estos
problemas son fciles de resolver en una mquina no-determinstica pero, nadie ha sido capaz de
encontrar un algoritmo eficiente para una mquina convencional (o probar que existe) para cualquiera de
ellos.


22

22
Estos problemas tienen una propiedad adicional que aporta evidencia convincente de que : si
cualquiera de los problemas puede ser resuelto en un tiempo polinomial en una mquina determinstica,
entonces todos los problemas en NP pueden ser resueltos (esto es, P = NP).

La falla del esfuerzo de los investigadores para encontrar algoritmos eficientes puede ser vista como una
falla colectiva para demostrar que P = NP.

Estos problemas son NP-completos. Gran nmero de problemas prcticos tienen esta caracterstica.

La herramienta primaria utilizada para probar que los problemas son NP-completos emplea la idea de
reductibilidad polinomial. Cualquier algoritmo para resolver un nuevo problema en NP puede ser usado
para resolver algn problema NP-completo conocido a travs del proceso siguiente:

1. Transformar cualquier instancia del problema NP-completo conocido a una instancia del nuevo
problema.
2. Resolver el problema utilizando el algoritmo dado.
3. Transformar la solucin de vuelta a una solucin del problema NP-completo.

Por polinomialmente reducible, queremos decir que las transformaciones pueden ser hechas en tiempo
polinomial: as la existencia de un algoritmo de tiempo polinomial para el nuevo problema implicara la
existencia de un algoritmo de tiempo polinomial para el problema NP-completo, y esto implicara (por
definicin) la existencia de algoritmos de tiempo polinomial para todos los problemas de NP.

La reduccin puede aplicarse a problemas como:

El vendedor viajero: Dado un conjunto de ciudades y distancias entre todos los pares, encontrar una ruta
de distancia menor que M, que visite todas las ciudades.

Ciclo de Hamilton: Dado un grafo, encontrar un ciclo simple que incluya todos los vrtices.

Supn que sabemos que el problema del ciclo de Hamilton es NP-completo y deseamos determinar si el
dilema del vendedor viajero es tambin NP-completo. Cualquier algoritmo para resolver ste puede ser
usado para solucionar el del ciclo de Hamilton, a travs de la siguiente reduccin: dada una instancia del
problema del ciclo de Hamilton (un grafo) se construye una instancia del problema del vendedor viajero (un
conjunto de ciudades, con distancias entre todos los pares) como sigue: para las ciudades del vendedor
viajero se usa el conjunto de vrtices del grafo; para las que hay entre cada par de ciudades usamos 1 si
hay una arista entre los vrtices correspondientes del grafo, y 2 si no hay arista.

Luego hay que hacer que el algoritmo para el problema del vendedor viajero encuentre una ruta de
distancia menor que o igual a n, el nmero de vrtices del grafo. Esa ruta debe corresponder precisamente
a un ciclo de Hamilton.


23

23
Un algoritmo eficiente para el problema del vendedor viajero tambin sera idneo para el ciclo de Hamilton
que se reduce al problema del vendedor viajero, as que lo NP-completo del problema del ciclo de
Hamilton implica lo NP-completo del problema del vendedor viajero.

Algunos problemas NP-completos.

Se sabe que miles de problemas son NP-completos. La lista empieza con las dificultades del vendedor
viajero y del ciclo de Hamilton e incluye los siguientes:

Particin: Dado un conjunto de enteros, puede ser dividido en dos conjuntos cuya suma sea igual?

Programacin lineal entera: Dado un programa lineal, existe una solucin con enteros?

Programacin multiprocesador: Dado un tiempo lmite y un conjunto de tareas de longitud variable a ser
ejecutadas en dos procesadores idnticos, Pueden las tareas ser desarrolladas de manera que se
cumpla el tiempo lmite?

Cobertura de vrtices: Dado un grafo y un entero n, Existe un conjunto de menos de n vrtices que
toquen todas las aristas?

Actividad 1. Representaciones de Algoritmos

A travs de esta actividad podrs identificar la utilidad y relevancia de las representaciones para los
algoritmos: una de texto y la otra grfica.

De acuerdo a lo descrito en el tema anterior.

1. Ingresa al Foro de discusin que lleva por nombre Representaciones de Algoritmos.

2. Participa activamente en el Foro de discusin, contestando la pregunta:

Cul representacin es la ms conveniente para los algoritmos: el pseudocdigo o los diagramas
de flujo?

Recuerda que debes redactar tu respuesta con claridad, precisin y respeto.

3. Comenta la respuesta de dos de tus compaeros argumentando tu punto de vista.

4. Consulta la Rbrica de participacin del foro que se encuentra en la seccin Material de apoyo


24

24
2.2. Representacin de Algoritmos

Para representar un algoritmo se debe utilizar algn mtodo que permita independizar su desarrollo del
lenguaje de programacin que se pretenda usar y que permita, al mismo tiempo, describir claramente los
pasos que van a resolver el problema.

Dos mtodos simples para representar algoritmos han sido utilizados durante varias dcadas: uno que usa
texto (pseudocdigo), y otro que utiliza grficas (diagrama de flujo).

2.2.1. Pseudocdigo

El pseudocdigo es un lenguaje de especificacin de algoritmos que utiliza palabras similares al ingls o
al espaol (el ingls se suele usar en informtica por ser ms universal). Esto quiere decir que se pueden
desarrollar los algoritmos de una manera ms cercana a un lenguaje de programacin como C o Java, pero
sin alejarse de las palabras que se utilizan comnmente; esto lo hace simple, conciso y entendible.

No existe una sintaxis estndar para el pseudocdigo, pero para desarrollar un algoritmo utilizando este
mtodo se acostumbra seguir una serie de convenciones:

Nombrar al pseudocdigo.
Agregar nmeros a las lneas del pseudocdigo (a todas o a las ms relevantes).
Usar sangras despus de una estructura como for, while, if, etc. Esto ayuda a referir que las lneas
siguientes son parte de la estructura.
Terminar cada estructura con un end-nombre de estructura.
Utilizar la flecha o el signo = para asignarle un valor a una variable, por ejemplo j2, lo que
significa que se le va a asignar el valor de 2 a j, (j vale 2).
Para definir el lmite de la estructura for se emplea la expresin length[a] (duracin[a] en espaol)
lo cual indica que a es el nmero de veces que se repite la estructura for. Esta expresin puede
usarse para cualquier estructura cclica.
Para representar algn elemento i de un arreglo A se utilizan los corchetes [ ], es decir, el
elemento A[i].
Para hacer un comentario se puede usar la doble diagonal: // Comentario.
Para separar dos o ms condiciones, se puede utilizar and.
Para terminar cada paso se puede finalizar con un punto (.)
Siempre hay que indicar cules son las entradas y salidas del programa.

Se muestra a continuacin el desarrollo del algoritmo para la funcin f(x) = ln x usando el Teorema de
Taylor y pseudocdigo.

Paso 1. Nombre
Nombre del pseudocdigo: Teorema de Taylor.


25

25
Paso 2. Entradas y Salidas
Entradas: Valor de x, valor de tolerancia, valor de iteraciones i.
Salidas: Grado del polinomio n o mensaje de error.

Paso 3. Algoritmo

1. Inicio.
2. Inicializacin de variables
n 1
y x - 1
suma 0
potencia y
trmino y
signo -1. // para ejecutar alternancia de signos en la serie

3. while n I // estructura while, for, etc., necesaria
signo -signo // esto es para alternar signos
suma suma + signo * trmino // acumulador de trminos
potencia potencia * y
trmino potencia / (n + 1). // calcula el trmino siguiente
if |trmino| < tolerancia entonces // verifica la precisin (if, case, etc.)
Salida (n)
Fin // el procedimiento tuvo xito
else-if
n n + 1.
end-while.

4. if n = i entonces
Salida (ERROR) // el procedimiento no tuvo xito
fin
end-if.

5. Fin.

Ventajas del Pseudocdigo

Presenta la solucin del problema de una forma clara.
Ocupa menos espacio que el diagrama de flujo.
Permite representar de forma sencilla operaciones repetitivas complejas.
Es ms fcil pasar del pseudocdigo a un lenguaje de programacin.
Cuando se hace correctamente la indentacin, es fcil determinar los niveles en la estructura del
programa.


26

26

2.2.2. Diagrama de Flujo

Los diagramas de flujo son una herramienta desarrollada en la industria de la computacin, para mostrar
los pasos de un proceso. Consiste en una representacin grfica construida con cajas, diamantes y otras
formas, conectadas por medio de flechas. Cada forma representa un paso en el proceso y las flechas
muestran el orden en el que ocurren. Un diagrama de flujo combina smbolos y lneas para mostrar
grficamente la operacin de un algoritmo.

En informtica, existen diferentes smbolos para los diagramas de flujo, existen, inclusive,estndares
nacionales e internacionales para los diagramas de flujo.

Puedes localizar en internet los documentos de algunos de los primeros estndares que fueron creados
para estos diagramas, por ejemplo:

ECMA-4, 2nd Edition. Standard for Flow Charts. European Computer Manufacturers Association.
September 1966.
GC20-8152-1. Flowcharting Techniques. International Business Machines Corporation. 1969.

Se muestran a continuacin algunos de los smbolos ms comunes:

Estos smbolos suelen utilizarse en los casos siguientes:

Terminador: Inicio, fin, detener, espera, terminar una subrutina del proceso.
Proceso: Se refiere a cualquier funcin de procesamiento, cambio de valor, localizacin, etc., de la
informacin usada.
Decisin: Elemento en el que se selecciona el camino que debe seguir el flujo. Las opciones
pueden ser tan simples como un SI o NO resultante de la evaluacin de una expresin.
Conector: Punto de continuacin del diagrama.
Entrada/Salida: Elemento que representa las variables de entrada y salida.


27

27
Entrada manual: Para que el usuario introduzca los valores de las variables de entrada.
Pantalla: Elemento que ayuda a indicar los datos que van a ser mostrados.
Flecha de flujo: Se utiliza para indicar el sentido en el que ocurre el flujo entre procesos y otros
elementos

Consideraciones para el Uso de los Smbolos

No debe haber flechas cruzadas (usar un arco para pasar una lnea sobre otra cuando sea
necesario con el fin de evitar confusiones).
No se deben dejar los conectores vacos, siempre deben de contener un indicador.
Las flechas tienen que tocar al elemento al que apuntan en ambos lados.
Las estructuras de decisin deben tener indicado el valor del camino que vana tomar, por ejemplo SI
y NO.

Presentamos a continuacin un ejemplo de diagrama de flujo. Este diagrama fue desarrollado para
representar el algoritmo que calcula las races de un polinomio de segundo grado (x
2
+ 2x + 5 = 0) por
medio de la ecuacin general:


28

28
Los diagramas de flujo fueron muy populares en sus inicios para representar algoritmos y aunque an se
utilizan con el mismo fin, su popularidad ha disminuido. Mtodos como el pseudocdigo son ms
adecuados para los nuevos lenguajes de programacin.

Por otro lado, los diagramas de flujo se convirtieron en instrumentos comunes en el mundo empresarial, al
igual que en otros campos. En lo que respecta a la Informtica, los nuevos diagramas UML pueden
considerarse como diagramas de flujo evolucionados.

Ventajas de los Diagramas de Flujo

Favorecen la comprensin del algoritmo al representarlo en una grfica.
Permiten identificar problemas y oportunidades de mejora en los algoritmos.
Son fciles de trazar.

Actividad 2. Parmetros para comparacin de algoritmos

Al finalizar esta actividad compararas las tcnicas de compresin de archivos, mediante el estudio de uno
de los parmetros que intervienen en la evaluacin de los algoritmos al utilizar sus recursos. Adems de
identificar algunos aspectos del otro parmetro: el uso del espacio.

1. Escribe un reporte que llevar por nombre Parmetros para comparacin de algoritmos

2. Investiga sobre los siguientes temas:
a. Tcnicas de compresin de archivos
i. Run-Length Encoding
ii. Variable-Length Encoding
iii. Construccin del Cdigo Huffman

3. El documento deber contener los siguientes elementos: introduccin, desarrollo (informacin
generada por ti), explicacin del funcionamiento de la compresin, descripcin de las tcnicas de
compresin listadas, dos links para conocer ms algunos de los temas, conclusiones, las fuentes
de informacin que consultaste para el desarrollo de la misma.

1. Guarda tu documento con la nomenclatura MCOM1_U2_A2_XXYZ. Y enva tu archivo de
evidencias. Recuerda sustituir las XX por las dos primeras de tu primer nombre, la Y por la inicial
de tu apellido paterno y la por la inicial de tu apellido materno.

4. Espera la retroalimentacin de tu Facilitador(a).


29

29

2.3. Tipos de Algoritmos

No existe una clasificacin correcta para los algoritmos, as que discutiremos una clasificacin con base
en la funcionalidad de los ms conocidos. Algunos algoritmos se utilizan en programas pequeos para
resolver problemas especficos. Otros tienen un lugar en sistemas grandes. Muchos algoritmos
fundamentales encuentran aplicacin en ambos dominios.

Algoritmos de Ordenamiento. Reciben datos que no tienen un orden en particular y entregan
datos arreglados en el orden especificado.
Algoritmos Elementales. Apropiados para archivos pequeos o con una estructura especial. En muchas
aplicaciones de ordenamiento es mejor usar estos mtodos simples que los mtodos de propsito general.
Ordenamiento por Seleccin. Primero encuentra el elemento ms pequeo en el arreglo y lo intercambia
con el elemento en la primera posicin, luego localiza el segundo elemento ms pequeo y lo intercambia
con el elemento en la segunda posicin; contina de esta forma hasta que el arreglo completo est
ordenado.
Ordenamiento por Insercin. considera los elementos uno a la vez, insertando cada
uno en su lugar apropiado entre aquellos ya considerados (mantenindolos
ordenados).
El Mtodo de la Burbuja. Se ensea a menudo en las clases introductorias . Se
mantiene recorriendo el archivo intercambiando elementos adyacentes, si es
necesario.
Shellsort. Extensin simple del ordenamiento por insercin que gana velocidad
permitiendo intercambios de elementos que estn separados.
o Quicksort. Algoritmo recursivo muy utilizado. No es difcil de implementar y consume menos
recursos que cualquier otro mtodo de ordenamiento..
o Ordenamiento Radix. Mtodo que toma ventaja de las propiedades digitales de las llaves al
considerarlas como nmeros de un rango restringido.
o Colas de Prioridad. Mtodo de ordenamiento que utiliza estructuras de datos que soportan
las operaciones de insertar un nuevo elemento y eliminar el ms grande.
o Mergesort. Mtodo que utiliza un proceso complementario de la operacin de seleccin
para combinar dos archivos ordenados y obtener uno ms grande.
o Ordenamiento Externo. Mtodo apropiado para aplicaciones de ordenamiento que implican
el procesamiento de archivos muy extensos para ser guardados en la memoria primaria de
cualquier computadora.

Algoritmos de Bsqueda. Realizan una operacin fundamental intrnseca en muchas tareas
computacionales: la bsqueda. Esta operacin recupera alguna pieza (o piezas) de informacin de
un gran acervo previamente almacenado.
o Algoritmos Elementales. Son muy tiles para tablas pequeas y en otras situaciones
especiales, e incorporan tcnicas fundamentales explotadas por algunos mtodos ms
avanzados.


30

30
Bsqueda Secuencial. El mtodo ms simple de bsqueda es almacenar los
registros en un arreglo. Cuando un nuevo registro es insertado, se pone al final del
arreglo; cuando una bsqueda es efectuada se revisa el arreglo secuencialmente.
Bsqueda Binaria. Si el conjunto de registros es grande, el tiempo total de
bsqueda puede ser reducido significativamente utilizando un procedimiento que
aplica el paradigma de "divide y vencers": dividir el conjunto de registros en dos
partes, determinar a cul de las dos partes pertenece la llave, y concentrarse ah.
Bsqueda de Arbol Binario. Mtodo de bsqueda simple, eficiente y dinmico,
considerado como un algoritmo fundamentalde la Informtica.
o rboles Balanceados. En la bsqueda de rbol binario se puede utilizar una tcnica
llamada balanceo que permite garantizar que el peor caso no ocurrir.
o Hashing. Estos algoritmos utilizan un mtodo para referenciar registros directamente en una
tabla realizando transformaciones aritmticas en las llaves que las convierte en direcciones
de tabla.
o Bsqueda Radix. Estos mtodos examinan las llaves de bsqueda de un bit a la vez, en
lugar de utilizar comparaciones completas entre las llaves a cada paso.
o Bsqueda Externa. Algoritmos de bsqueda apropiados para acceder elementos de
archivos muy grandes.

Procesamiento de Cadenas (strings). Los datos que van a ser procesados a menudo no se
descomponen lgicamente en registros independientes con pequeas piezas identificables.

Este tipo de datos se caracteriza porque pueden ser escritos como una cadena,o secuencia lineal
de caracteres.
o Bsqueda de Cadenas.
Algoritmo de Fuerza Bruta
Algoritmo Knuth-Morris-Pratt
Algoritmo Boyer-Moore
Algoritmo Rabin-Karp
Bsquedas Mltiples
o Localizacin de Patrones. Es deseable a menudo realizar la bsqueda de cadenas cuando
no se tiene una informacin completa acerca del patrn a ser encontrado.
o Parsing (anlisis). Se han desarrollado varios algoritmos fundamentales para descomponer
programas de computadora en formas ms adecuadas para procesamiento adicional. La
operacin de parsing tiene aplicacin ms all de la Informtica, dado que est directamente
relacionado al estudio de la estructura del lenguaje en general.
o Compresin de Archivos. Algoritmos diseados para reducir el consumo de espacio sin
invertir mucho tiempo.
o Criptologa. La codificacin de cadenas de caracteres con el fin de mantenerlas secretas.

Algoritmos Geomtricos. Las computadoras estn siendo utilizadas para resolver problemas a
gran escala que son inherentemente geomtricos como puntos, lneas y polgonos que son la base
de una amplia variedad de importantes aplicaciones y dan origen a un interesante conjunto de
problemas y algoritmos.


31

31
o Algoritmos Geomtricos Elementales
o Determinacin de la ConvexHull
o Bsqueda de Rango
o Interseccin Geomtrica
o Problemas del Punto Ms Cercano

Algoritmos de Grafos. Una gran cantidad de problemas son naturalmente formulados en trminos
de objetos y conexiones entre ellos. Por ejemplo, dado un mapa de rutas para una lnea area
pueden formularse preguntas como Cul es la forma ms rpida de ir de esta ciudad a esta otra?

Un grafo es un objeto matemtico que modela precisamente este tipo de situaciones.
o Algoritmos Elementales de Grafos
o Conectividad
o Grafos Ponderados
o Grafos dirigidos
o Flujo de Red
o Matching.

Algoritmos Matemticos.
o Nmeros Aleatorios
o Aritmtica
o Eliminacin Gaussiana
o Aproximacin de curvas
o Integracin

Tcnicas Avanzadas de Diseo y Anlisis.
o Algoritmos Glotones o Avidos (Greedy)

2.3.1. Algoritmo de Bsqueda

Los algoritmos de bsqueda recuperan elementos de informacin de una gran cantidad de datos
previamente almacenados. Existen diversos algoritmos para efectuar bsquedas. Presentamos a
continuacin dos de ellos: el Mtodo secuencial y el Mtodo Hash.

Bsqueda de Elementos por el Mtodo Secuencial

El mtodo consiste en buscar un nmero dentro de un arreglo de nmeros. Esto se hace comparando el
nmero deseado con cada uno de los elementos dentro del arreglo.


32

32

Encontrars a continuacin la representacin en pseudocdigo y en un diagrama de flujo, del algoritmo de
bsqueda secuencial.

Pseudocdigo.

Paso 1.
Bsqueda de un elemento por el mtodo secuencial.

Paso 2.
Entradas: Tamao de la lista dimensin, lista para buscar a[i], elemento a
buscar busk.
Salidas: Mensaje (Nmero encontrado) o (Nmero no encontrado).

1. Inicio.
i 0
j 0 // Variables usadas en los ciclos.
3. for i <dim // Comienza la bsqueda
if a[i] == buskentonces // Comparacin elemento por elemento
Salida (Nmero encontrado)
j++
end-if
end-for
4. if j == 0 entonces
Salida, valores ordenados a[i].
5. Fin.

Diagrama de flujo. Bsqueda Secuencial.


33

33

Bsqueda de un Nmero por el Mtodo Hash.

Este mtodo tambin busca un nmero dentro de un arreglo de nmeros. La diferencia con el mtodo de
bsqueda secuencial es que se divide el arreglo en partes.

Esto se logra dividiendo un nmero del arreglo entre un nmero dado n, con la operacin obtendremos un
residuo, el cual te ayudar a separar los nmeros del arreglo en partes.

Despus de dividir en partes el arreglo principal, podrs buscar el nmero deseado ms rpidamente en un
arreglo que depende del residuo del nmero que buscas. Divide y conquistars!


34

34
A continuacin se muestra la representacin grfica del mtodo. En este ejemplo n = 3 y el nmero que
buscamos es 7.

bsqueda por el mtodo Hash.

Pseudocdigo.

Paso 1.
Bsqueda de un elemento por el mtodo Hash.

Paso 2.
Entradas: Tamao de la lista dimensin, lista para buscar a[i], elemento a buscar busk.
Salidas: Mensaje (Nmero encontrado) o (Nmero no encontrado).

1. Inicio.
residuo 0
i 0
k 0 //en este caso usamos tres variables j, k y l.
l 0
cont 0 //Variable usada para el despliegue del mensaje de salida
3. for i <dim //Comienza la bsqueda
residuo a[i] % 3 //El nmero tres, as como la cantidad de variables
Acomoda los valores de a[i] en // como j en los ciclos, dependen del nmero
de
alma[j][residuo] // divisiones deseadas de la lista de valores
en la
j++ // que se va a buscar.
end-for.
4. residuo busk % 3.
5. for i < j entonces


35

35
Busca el valor busk en alma[i][residuo]
Salida (Nmero encontrado)
cont++
end-for.
6. ifcont == 0 entonces
Salida(Nmero no encontrado).
7. Fin.

Diagrama de flujo. Mtodo Hash.

2.3.2. Algoritmo de Ordenamiento

Los algoritmos de ordenamiento reciben datos que no tienen un orden en particular y entregan datos
arreglados en el orden especificado. Existen diversos algoritmos para este tipo de procesos; presentamos a
continuacin dos de ellos: el de la Burbuja y el de Seleccin de Elementos.

Ordenamiento por el Mtodo de la Burbuja

Este es uno de los mtodos ms conocidos y simples. Funciona comparando dos elementos a la vez;
recorre todo el arreglo varias veces de manera secuencial comparando e intercambiando (si es el caso) un
primer elemento con su consecutivo inmediato. El ordenamiento puede realizarse de forma ascendente o
descendente.


36

36

La representacin grfica siguiente muestra lo que hace el mtodo:

El proceso contina hasta que el arreglo est ordenado.

ordenamiento por el mtodo de la burbuja.

Pseudocdigo

Paso 1.
Ordenamiento por el mtodo de la burbuja.

Paso 2.
Entradas: Cantidad de nmeros dimensin, valores a ordenar de a[i].
Salidas: Valores ordenados a[i].

1. Inicio.
i 0
aux 0 // Variable utilizada en el intercambio de datos.
3. for i <dim //Inicia el ordenamiento
for j <dim
if a[j] a[j+1] entonces //Ordenamiento elemento por elemento
Intercambia valores de a[j] por a[j+1]
end-if
end-for
end-for.
4. Salida, valores ordenados a[i].
5. Fin.

Diagrama de flujo. Mtodo de la Burbuja.


37

37

Ordenamiento por el Mtodo por Seleccin de Elementos

Este mtodo selecciona dentro de todo arreglo al elemento de menor valor y lo intercambia por el de mayor
valor consecutivo. De forma similar al Mtodo de la Burbuja, recorre el arreglo completo varias veces, y lo
puede hacer de forma ascendente y descendente.

A continuacin se muestra la representacin grfica de lo que hace el mtodo:


38

38

ordenamiento por el mtodo de seleccin de elementos.

Pseudocdigo.

Paso 1.
Ordenamiento por seleccin de elementos.

Paso 2.
Entradas: Cantidad de nmeros dimensin, valores a ordenar de a[i].
Salidas: Valores ordenados a[i].

1. Inicio.
i 0
j i+1 // Variables usadas en los ciclos.
aux1 0
aux2 0 // Variable utilizada en el intercambio
de datos.
3. for i <dim //Comienza el ordenamiento
aux2 i
for j <dim
if a[j] < a[aux2] entonces //Ordenamiento en donde se
selecciona el
aux2 j //elemento de mayor valor y se
end-if //intercambia con el de menor
end-for //valor y as sucesivamente
Intercambia valores de a[i] por a[aux2]
end-for.
4. Salida, valores ordenados a[i].
5. Fin.


39

39
Diagrama de flujo. Mtodo por Seleccin de Elementos.

2.3.3. Algoritmos Glotones

La Aproximacin Glotona

Este tipo de algoritmo funciona tomando decisiones que parecen localmente las mejores, sin embargo
globalmente pueden no serlo. El algoritmo no reconsidera su decisin, simplemente la toma y ah
permanece.

Como ejemplo, abordaremos un caso muy comn de los algoritmos glotones: el cambio de dinero. La
representacin grfica de este mtodo se muestra a continuacin (utilizamos dlares y centavos
americanos):


40

40

Pseudocdigo.

Paso 1.
Algoritmo de cambio de dinero

Paso 2.
Entradas: El dinero en dlares n.
Salidas: El nmero de monedas que se necesitan cambio.

Monedas {100, 25, 10, 5, 1} //Constante
i 0
j 0
sum 0
x 0
sol {} // Arreglo que contiene la cantidad de cada
tipo de moneda
cont 0 // Contador de monedas
2. while sum != n
x = Monedas[i]
for sum + x n // Inicia el conteo de monedas y de dinero.
sum sum + x
end-for
sol [i] cont // Almacena la cantidad de monedas
end-while
3. Salida (La cantidad de monedas de Monedas[i] es cont)
4. Fin


41

41
Diagrama de flujo.

Mtodo Glotn para la Seleccin de Actividades

Este mtodo se refiere al problema de la programacin o calendarizacin de actividades que se encuentran
en intervalos de tiempo definidos. Los intervalos tienen un tiempo s
i
de inicio y un tiempo f
i
de trmino.


42

42
Con este mtodo se pretende encontrar el conjunto de actividades de tamao mximo y que sean
mutuamente compatibles entre ellos; asimismo, para que el resultado sea ptimo, los intervalos no deben
traslaparse unos con otros.

Se muestra a continuacin la representacin grfica del mtodo:

Pseudocdigo.

Paso 1.
Mtodo glotn para la seleccin de actividades.

Paso 2.
Entradas: La cantidad de intervalos n, los intervalos con inicio en s y
trmino f a(s
i
, f
i
).
Salidas: Intervalos con compatibilidad ptima alma(s
i
, f
i
)
ptimos
.

1. Inicio.
2. Inicializacin de variables.
i 0.
j 0.
k 1.
aux1 0.
aux2 0.

3. Ordenamiento de los intervalos, considerando el valor f de cada
intervalo de forma ascendente, es decir:f
1
f
2
. . . f
n


43

43
NOTA: Para este paso puedes utilizar alguno de los mtodos de ordenamiento
que vimos anteriormente.

4. k 1.
5. alma (s
0
,f
0
) a(s
0
,f
0
).
6. for i< n
ifs
i
f
j

alma (s
k
,f
k
) a(s
i
,f
i
)
j i
k++.
end-if
end-for
7. Salida alma(s
i
,f
i
).
8. Fin.

Diagrama de flujo.


44

44
2.4. Programacin

En las secciones anteriores presentamos detalles de varios algoritmos, incluyendo su representacin con
pseudocdigo y un diagrama de flujo. Con el fin de que puedas entender mejor el funcionamiento de esos
algoritmos, te presentamos a continuacin su cdigo en C y en Java. Como lo mencionamos al principio, te
recomendamos que estudies y experimentes con los cdigos. Para hacerlo, puedes utilizar el IDE Eclipse
que instalaste y utilizaste en la asignatura de Herramientas Computacionales.

2.4.1. Programacin de Algoritmos en C

Algoritmo de Bsqueda Secuencial

#include <stdio.h>
main()
{
setvbuf(stdout, NULL, _IONBF, 0);
intdim = 40, aux1 = 0, i = 0,j = 0; //Declaracin de variables
charbusk, a[40],o[20];
puts("Bsqueda de elementos, Mtodo secuencial."); //Inicio del programa

printf("Dame el elemento a buscar:\n"); //Adquisicin de datos
scanf("%c",&busk);

printf("Dame los datos (menos de 40 elementos):\n");
scanf("%s",&a[i]);

printf("\n");
for (i = 0; i <dim; i++){ //Inicia bsqueda del
if (a[i] == busk){ //elemento deseado
printf("Est en la posicin: %d\n",(i+1)); //comparando cada uno
j++; //dentro del arreglo
}
}
if (j == 0)
printf("El nmero %d no est.",num);
}

Bsqueda de elementos, Mtodo secuencial.
Dame el elemento a buscar:
2 <ENTER>
Dame los datos (menos de 40 elementos):
234567898765432 <ENTER>

Est en la posicin: 1
Consola


45

45

Algoritmo de Bsqueda Hash

#include<stdio.h>
#include<math.h>
main()
{
//Declaracin de variables
int residuo, i, arreglo[50], num, dim, alma[50][50], j = 0, k = 0, l = 0,
cont = 0;
//Inicio de programa
printf("Mtodo de bsqueda hash\n");

//Adquisicin de datos
printf("Dame el nmero que quieres buscar:");
scanf("%d",&num);

printf("Dame la cantidad de nmeros (menos de 50 elementos): ");
scanf("%d",&dim);
printf("Dame los datos:\n");
for (i = 0; i< dim; i++){
printf("dato %d:",i+1);
scanf("%d",&arreglo[i]);
}
//Dividimos la lista de nmeros dependiendo de su residuo
for (i = 0; i< dim; i++){
residuo = arreglo[i] % 3;
if (residuo == 0){
alma[j][residuo] = arreglo[i];
j++;
}
if (residuo == 1){
alma[k][residuo] = arreglo[i];
k++;
}
if (residuo == 2){
alma[l][residuo] = arreglo[i];
l++;
}
}
residuo =num % 3;


46

46
//Buscamos el nmero en la lista dividida, basndonos en su residuo
if (residuo == 0){
for (i = 0; i< j; i++){
if (alma[i][0] == num)
++cont;
}
}
elseif (residuo == 1){
for (i = 0; i< k; i++){
++cont;
}
}
elseif (residuo == 2){
for (i = 0; i< l; i++){
++cont;
}
}// Una vez encontrado el nmero que buscamos se despliega el nmero de
//coincidencias en la consola
printf("Hay %d coincidencia(s) del nmero que buscas.\n",cont);
}

Mtodo de bsqueda hash:
Dame el nmero que quieres buscar:
1 <ENTER>
Dame la cantidad de nmeros (menos de 50 elementos): 8 <ENTER>
Dame los datos:
dato 1:25 <ENTER>
dato 2:3 <ENTER>
dato 3:12 <ENTER>
dato 4:19 <ENTER>
dato 5:2 <ENTER>
dato 6:1 <ENTER>
dato 7:9 <ENTER>
dato 8:6 <ENTER>
Hay 1 coincidencia(s) del nmero que buscas.
Consola

Algoritmo de Ordenamiento por el Mtodo de la Burbuja

#include <stdio.h>
main()
{
intdim, aux1 = 0, i = 0,j = 0; //Declaracin de variables


47

47
puts("Mtodo de ordenamiento burbuja"); //Inicio del programa
puts("Dame la cantidad de datos que vas a ordenar:");//Cantidad de nmeros
a ordenar
scanf("%d",&dim);
printf("Dame los nmeros a ordenar:\n");
int a[dim];
for (i = 0; i <dim; i++){ //Valores que se van a ordenar
scanf("%d",&a[i]);
}
for (i = 0; i <dim; i++){ //Impresin en pantalla
printf("%d-",a[i]); //de los valores a ordenar
}
printf("\n");
for (i = 0; i <dim; i++){ //Inicio de ordenamiento
for (j = 0; j <dim; j++) //en el que se recorre todo el
if (a[j] >= a[j + 1]) { //arreglo de valores,
comparando
aux1 = a[j]; //cada uno de ellos con todos
los
a[j] = a[j + 1]; //los dems.
a[j + 1] = aux1;
}
}
for (i = 0; i <dim; i++){ //Impresion en pantalla de los
printf("%d-",a[i]); //valores ya ordenados
}
}

Mtodo de ordenamiento burbuja
Dame la cantidad de datos que vas a ordenar: 8 <ENTER>
Dame los nmeros a ordenar:
25 <ENTER>
3 <ENTER>
12 <ENTER>
19 <ENTER>
2 <ENTER>
1 <ENTER>
9 <ENTER>
6 <ENTER>

25-3-12-19-2-1-9-6-
1-2-3-6-9-12-19-25-
Consola

Algoritmo de Ordenamiento por Seleccin de Elementos


48

48
#include <stdio.h>
main()
{

intdim=8, aux1 = 0, i = 0,j = 0, aux2=0; //Declaracion de variables

puts("Metodo de ordenamiento por seleccion"); //Inicio del programa
puts("Dame la cantidad de datos que vas a acomodar:"); //Cantidad de valores a
//ordenar
scanf("%d",&dim);
printf("Dame los numeros a ordenar:\n");
int a[dim];
for (i = 0; i< dim; i++){ //Valores a ordenar
scanf("%d",&a[i]);
}

for (i = 0; i <dim; i++){ //Impresin en pantalla de
printf("%d-",a[i]); //los valores a ordenar
}
printf("\n");

for (i = 0; i< dim; i++){ //Proceso de ordenamiento
aux2=i;
for (j = i+1; j <dim ; j++) //comparacion y seleccion
if (a[j] < a[aux2]) //de valores
aux2=j;
aux1 = a[i];
a[i] = a[aux2];
a[aux2] = aux1; //ordenamiento
//printf("%d",a[i]);
}
for (i = 0; i <dim; i++){ //Impresion en pantalla de
printf("%d-",a[i]); //los valores ordenados
}
}

Mtodo de ordenamiento por seleccin
Dame la cantidad de datos que vas a acomodar: 8 <ENTER>
Dame los nmeros a ordenar:
25 <ENTER>
3 <ENTER>
12 <ENTER>
19 <ENTER>
2 <ENTER>
1 <ENTER>
9 <ENTER>
6 <ENTER>
Consola


49

49

25-3-12-19-2-1-9-6-
1-2-3-6-9-12-19-25-

Algoritmo de Aproximacin Glotona

#include<stdio.h>
#include<math.h>
main()
{
intMonedas[5],i = 0,j = 0, sol[5],sum = 0,cont=0, x=0;
float n;
Monedas[0]=100;
Monedas[1]=25; //Declaracin de monedas (centavos americanos)
Monedas[2]=10;
Monedas[3]=5;
Monedas[4]=1;
//Adquisicin de dinero
printf("Dame la cantidad de dinero en dlares (con centavos): $");
scanf("%f",&n);
i=0;
if (n < 0.01)
printf("ERROR!!");

n=n*100;
while (sum != n){ //Inicia conteo de dinero
cont=0;
x = Monedas[i];
for (j = 0;sum + x <= n;j++){ //Conteo de monedas
sum = sum + x;
cont++;
}
sol[i]=cont;
i++;
}
for(j=0;j<i;j++){ //Despliegue de resultados
printf("Se necesitan %d moneda(s) de ",sol[j]);
printf("%d centavo(s)\n",Monedas[j]);
}
}

Dame la cantidad de dinero en dlares (con centavos): $6.89 <ENTER>
Se necesitan 6 moneda(s) de 100 centavo(s)
Consola


50

50

Algoritmo Glotn para la Seleccin de Actividades

#include<stdio.h>
main()
{
intdim, aux1 = 0, i = 0,j = 0, aux2=0,k = 0; //Declaracion de variables

puts("Mtodo glotn de seleccin de actividades."); //Inicio del programa
puts("Dame la cantidad de datos: "); //Cantidad de valores a
scanf("%d",&dim); //ordenar
printf("Dame los intervalos de las actividades (s,f):\n");
int a[dim][dim],alma[dim][dim];
for (j = 0;j < 2;j++)
scanf("%d",&a[i][j]);
printf("\n");
}

for (j = 0;j < 2;j++) //los valores a ordenar
printf("%d-",a[i][j]);
printf("\n");
}
printf("\n");

aux2=i;
for (j = i+1; j <dim ; j++) //comparacin y seleccin
if (a[j][1] < a[aux2][1]) //de valores
aux2=j;
aux1 = a[i][1];
a[i][1] = a[aux2][1];
a[aux2][1] = aux1; //ordenamiento de los valores i,0

aux1 = a[i][0];
a[i][0] = a[aux2][0];
a[aux2][0] = aux1;
}

for (j = 0;j < 2;j++) //los valores ordenados
printf("%d-",a[i][j]);
printf("\n");
}


51

51
j=0;
k=1;
alma[0][0] = a[0][0];
alma[0][1] = a[0][1];
for (i = 1; i <dim; i++){ //Generacin de la matriz que
if (a[i][0] >= a[j][1]){ //contiene los intervalos ms
alma[k][0] = a[i][0]; //ptimos
alma[k][1] = a[i][1];
k++;
j=i;
}
}
puts("Los intervalos ms ptimos son: \n.");
for (i = 0; i < k; i++){ //Impresin en pantalla de
for (j = 0;j < 2;j++) //la matriz con los
printf("%d-",alma[i][j]); //intervalos ptimos
printf("\n");
}
}

Mtodo glotn de seleccin de actividades.
Dame la cantidad de datos:
11 <ENTER>
Dame los intervalos de las actividades (s,f):
0 <ENTER>
4 <ENTER>

4 <ENTER>
6 <ENTER>

6 <ENTER>
10 <ENTER>

0 <ENTER>
1 <ENTER>

1 <ENTER>
5 <ENTER>

5 <ENTER>
9 <ENTER>

9 <ENTER>
10 <ENTER>

0 <ENTER>
3 <ENTER>

0 <ENTER>
Consola


52

52
2 <ENTER>

7 <ENTER>
10 <ENTER>

8 <ENTER>
10 <ENTER>

0-4-
4-6-
6-10-
0-1-
1-5-
5-9-
9-10-
0-3-
0-2-
7-10-
8-10-

0-1-
0-2-
0-3-
0-4-
1-5-
4-6-
5-9-
6-10-
9-10-
7-10-
8-10-
Los intervalos ms ptimos son:

0-1-
1-5-
5-9-
9-10-

2.4.2. Programacin de Algoritmos en J ava

Algoritmo de Bsqueda Secuencial

package algoritmos;
importjava.util.Scanner;
publicclassBusqueda {
publicstaticvoid main(String[] args) {


53

53
Scanner entrada = newScanner(System.in);

//Inicio del programa
System.out.println("Bsqueda de elementos, Mtodo secuencial.");

System.out.print("Dime la cantidad de elementos en los que vas a buscar:
");
intdim = entrada.nextInt();
int[] a = newint[dim]; //Se declara el arreglo a

//Adquisicin del arreglo que va a contener los arreglos
System.out.print("Dame los nmeros en los que voy a buscar: ");
for (inti = 0; i< dim; i++)
a[i] = entrada.nextInt();

System.out.print("Dame el nmero a buscar: ");
int busca = entrada.nextInt();

//Impresin de los datos almacenados en el arreglo
for (inti = 0; i< dim; i++)
System.out.print(a[i]);

System.out.println(" ");
int j = 0;

//Inicia bsqueda del elemento deseado comparando cada uno dentro del
arreglo
for (inti = 0; i< dim; i++) {
if (a[i] == busca){
System.out.printf("Esta en la posicin: %d\n",(i+1));
j++;
}
}
if (j == 0)
System.out.printf("ERROR! El nmero no fue encontrado\n");
}
}

Bsqueda de elementos, Mtodo secuencial.
Dime la cantidad de elementos en los que vas a buscar: 10
<ENTER>
Dame los nmeros en los que voy a buscar: 1 2 3 4 5 6 7 6 5 4
<ENTER>
Dame el nmero a buscar: 6 <ENTER>
1234567654

Consola


54

54

Bsqueda de elementos, Mtodo secuencial
Dime la cantidad de elementos en los que vas a buscar: 10
<ENTER>
Dame los nmeros en los que voy a buscar: 1 2 3 4 5 6 7 6 5 4
<ENTER>
1234567654
ERROR! El nmero no fue encontrado
Consola

Algoritmo de Bsqueda Hash

package algoritmos;
publicclassBusquedaHash {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);

int residuo, num, i,j = 0, k = 0, l = 0, cont = 0;
int[][] alma = new int[50][50];
int[] a = new int[50];

System.out.println("Bsqueda de elementos, Mtodo Hash.");

System.out.print("Dame la cantidad de nmeros (menos de 50
elementos): ");
intdim = entrada.nextInt();

System.out.print("Dame los nmeros en los que voy a buscar: ");

for (i = 0; i< dim; i++)

System.out.print("Dame el nmero a buscar: ");
num = entrada.nextInt();

//Inicia la divisin de nuestra lista de nmeros con respecto a su
residuo,
// en este caso utilizamos tres residuos diferentes, esto va a
depender de


55

55
// la cantidad de partes en las que queremos dividir nuestra lista de
datos.
for(i = 0; i< dim; i++){
residuo = a [i] % 3;
if (residuo == 0){
alma[j][0] = a[i];
j++;
}
else if (residuo == 1){
alma[k][1] = a[i];
k++;
}
alma[l][2] = a[i];
l++;
}
}
//Obtenemos el residuo del nmero que estamos buscando
residuo = num % 3;
//Buscamos el nmero en la lista dividida, basndonos en su residuo
if (residuo == 0){
for (i = 0; i< j-1; i++){
cont++;
}
}
for (i = 0; i< k-1; i++){
cont++;
}
}
for (i = 0; i< l-1; i++){
cont++;
}
} // una vez encontrado el nmero que buscamos y este se
despliega en la consola
System.out.println("Hay " + cont + " nmero(s) " + num + " en la
lista.");


56

56
if (cont == 0) //Si el nmero no fue encontrado, arroja un error en
la consola.
System.out.printf("ERROR! El nmero no fue encontrado\n");
}
}

Bsqueda de elementos, Mtodo Hash.
Dame la cantidad de nmeros (menos de 50 elementos): 20
<ENTER>
Dame los nmeros en los que voy a buscar: 1 2 3 4 5 6 7 8 7 6 5 4 3 2 1 4
3 2 5 6 <ENTER>

Hay 3 nmero(s) 2 en la lista.
Consola

Algoritmo de Ordenamiento por el Mtodo de la Burbuja

packagealgoritmos;
publicclass Bubble {

int aux1, i, j;

System.out.println("Ordenamiento de elementos, Mtodo Burbuja.");

System.out.print("Dame la cantidad de nmeros: ");
int dim = entrada.nextInt();
int[] a = newint[dim];

System.out.print("Dame los nmeros a ordenar: ");
for (i = 0; i< dim; i++)

for (i = 0; i <dim; i++) //Impresin en pantalla de los
System.out.printf("%d-", a[i]); //valores ya ordenados


for (i = 0; i< dim-1; i++){ //Inicio de ordenamiento
for (j = 0; j < dim-1; j++) //en el que se recorre todo el
if (a[j] >= a[j + 1]){ //arreglo de valores, comparando
aux1 = a[j]; //cada uno de ellos con todos los
a[j] = a[j + 1]; //los dems.


57

57
a[j + 1] = aux1;
}
}
}
}

Ordenamiento de elementos, Mtodo Burbuja.
Dame la cantidad de nmeros: 10 <ENTER>
Dame los nmeros a ordenar: 1 2 3 4 1 2 3 4 1 2 <ENTER>
1-2-3-4-1-2-3-4-1-2-
1-1-1-2-2-2-3-3-4-4-
Consola

Algoritmo de Ordenamiento por Seleccin de Elementos

packagealgoritmos;
public class SortSelection {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);

int aux1, aux2, i, j;

System.out.println("Ordenamiento de elementos, Mtodo de seleccin.");

System.out.print("Dame la cantidad de nmeros: ");
int dim = entrada.nextInt();
int[] a = new int[dim];
System.out.print("Dame los nmeros a ordenar: ");
for (i = 0; i< dim; i++)



aux2=i;
if (a[j] < a[aux2]) //de valores
aux2=j;
aux1 = a[i];
a[i] = a[aux2];


58

58
a[aux2] = aux1; //ordenamiento
}
for (i = 0; i <dim; i++) //Impresin en pantalla de
System.out.printf("%d-",a[i]); //los valores ordenados
}
}

Ordenamiento de elementos, Mtodo de seleccin.
Dame la cantidad de nmeros: 10 <ENTER>
Dame los nmeros a ordenar: 11 33 2 4 5 33 66 60 23 0
<ENTER>
11-33-2-4-5-33-66-60-23-0-
0-2-4-5-11-23-33-33-60-66-
Consola

Algoritmo de Aproximacin Glotona
packagealgoritmos;
publicclassGreedyApproach {
// TODO Auto-generated method stub
inti = 0,j = 0, sum = 0,cont=0, x=0;
int[] Monedas= newint [5];
int[] sol= newint [5];
//Declaracin de monedas (centavos americanos)
Monedas[0]=100; //Dollar
Monedas[1]=25; //Quarter
Monedas[2]=10; //Dime
Monedas[3]=5; //Nickel
Monedas[4]=1; //Penny
//Adquisicin de dinero
System.out.print("Dame la cantidad de dinero en dlares (con centavos):
$");
float n = entrada.nextFloat();

i=0;
if (n < 0.01)
System.out.println("ERROR!!");

n=n*100;
while (sum != n){ //Inicia conteo de dinero
cont=0;
x = Monedas[i];
for (j = 0;sum + x <= n;j++){ //Conteo de monedas
sum = sum + x;
cont++;
}
sol[i]=cont;


59

59
i++;
}
for(j=0;j<i;j++){ //Despliegue de resultados
System.out.printf("Se necesitan %d moneda(s) de ",sol[j]);
System.out.printf("%d centavo(s)\n",Monedas[j]);
}
}
}

Dame la cantidad de dinero en dlares (con centavos): $10.24
<ENTER>
Consola

Algoritmo Glotn de Seleccin de Actividades

packagealgoritmos;
publicclassGreedySelection {
//Declaracion de variables
intdim, aux1 = 0, i = 0,j = 0, aux2=0,k = 0;

System.out.println("Mtodo glotn de seleccin de actividades.");
System.out.println("Dame la cantidad de datos: "); //Cantidad de valores
a
dim = entrada.nextInt(); //ordenar
System.out.println("Dame los intervalos de las actividades (s,f):");
int[][] a = newint [dim][dim];
int[][] alma = newint [dim][dim];

for (j = 0;j < 2;j++)
a[i][j] = entrada.nextInt();
}

for (j = 0;j < 2;j++) //los valores a ordenar
System.out.printf("%d-",a[i][j]);
}
System.out.println("");


60

60

for (i = 0; i <dim; i++){ //Proceso de ordenamiento
aux2=i;
if (a[j][1] < a[aux2][1]) //de valores
aux2=j;
aux1 = a[i][1];
a[i][1] = a[aux2][1];
a[aux2][1] = aux1; //ordenamiento de los valores i,0

aux1 = a[i][0];
a[i][0] = a[aux2][0];
a[aux2][0] = aux1;
}

for (j = 0;j < 2;j++) //los valores ordenados
System.out.printf("%d-",a[i][j]);
}
j=0;
k=1;
alma[0][0] = a[0][0];
alma[0][1] = a[0][1];
for (i = 1; i <dim; i++){ //Generacin de la matriz que
if (a[i][0] >= a[j][1]){ //contiene los intervalos ms
alma[k][0] = a[i][0]; //ptimos
alma[k][1] = a[i][1];
k++;
j=i;
}
}
System.out.println("Los intervalos ms ptimos son: ");
for (i = 0; i < k; i++){ //Impresin en pantalla de
for (j = 0;j < 2;j++) //la matriz con los
System.out.printf("%d-",alma[i][j]); //intervalosptimos
}
}
}

Mtodo glotn de seleccin de actividades.
Dame la cantidad de datos:
5 <ENTER>
Dame los intervalos de las actividades (s,f):
3 <ENTER>
5 <ENTER>

6 <ENTER>
Consola


61

61
8 <ENTER>

1 <ENTER>
4 <ENTER>

4 <ENTER>
7 <ENTER>

7 <ENTER>
10 <ENTER>

3-5-
6-8-
1-4-
4-7-
7-10-

1-4-
3-5-
4-7-
6-8-
7-10-
Los intervalos ms ptimos son:
1-4-
4-7-
7-10-

Actividad 3. Desarrollo de algoritmos tpicos

A travs de esta actividad podrs analizar otros dos algoritmos tiles: Bsqueda Binaria (binary search) y
QuickSort (uno de los ms populares y estudiados).

Instrucciones: Toma en cuenta los lineamientos que se te presentan en el documento descargable

1. Descarga el documento llamado Act. 3. Desarrollo de algoritmos tpicos.

2. Analiza cada instruccin que se presenta y sguelo de manera ordenada.

2. Guarda tu documento con la nomenclatura MCOM1_U2_A2_XXYZ. Y enva tu archivo de
evidencias. Recuerda sustituir las XX por las dos primeras de tu primer nombre, la Y por la inicial
de tu apellido paterno y la por la inicial de tu apellido materno.

3. Espera la retroalimentacin de tu Facilitador(a).


62

62

Autoevaluacin

Felicidades! Haz llegado al final de la Unidad. Es momento de realizar la autoevaluacin para medir el
grado conocimiento obtenido durante la unidad. Par eso resuelve la actividad de Autoevaluacin que
corresponde a un conjunto de reactivos:

Instrucciones: elige la respuesta correcta que corresponda a la pregunta planteada.

1. Conjunto de instrucciones o reglas que se organizan de manera finita para realizar una actividad
mediante pasos sucesivos para resolver un problema.

a) Algoritmo b) Procesos c) Instrucciones d) Base de datos

2. Se Caracterizan por ser todos iguales en el sentido de que si se descubriera una solucin P para
algunos de ellos

a) P b) NP c) NP completos d) Q

3. El uso eficiente de los recursos de cmputo suele medirse en funcin de los siguientes parmetros

a) Tiempo e
instrucciones
b) Memoria y
cantidad de
almacenamiento
c) Espacio y tiempo d) Tiempo y
longitud del
cdigo

4. Las representaciones ms comunes para los algoritmos son

a) Pseudocdigo y
diagramas de
flujo
b) Diagramas de
flujo y
diagramas de
rutas
c) Lenguajes de
programacin y
diagramas de
flujo
d) Pseudocdigo y
lenguajes de
programacin

5. Para qu tipo de algoritmos se utiliza el mtodo de Hash

a) Geomtricos b) De bsqueda c) De
ordenamiento
d) Glotones

Para comparar tus respuestas, revisa el documento Respuestas_autoevaluacin_U2, ubicada en la
pestaa de material de apoyo.

RETROALIMENTACION


63

63

Evidencia de Aprendizaje. Programacin de algoritmos tpicos en C y J ava

Al finalizar esta actividad sers capaz de analizar los tiempos de ejecucin de los algoritmos, as como
desarrollar, modificar algoritmos, y construir sus representaciones.

1. Descarga el siguiente documento EA. Presentacin de resultados

2. Elabora un archivo en donde presentes los resultados que obtuviste.

3. Guarda tu documento con la nomenclatura MCOM1_U2_EA_XXYZ. Y enva tu archivo al Portafolio
de Evidencias. Recuerda sustituir las XX por las dos primeras de tu primer nombre, la Y por la
inicial de tu apellido paterno y la por la inicial de tu apellido materno.

3. Espera la retroalimentacin de tu Facilitador(a), atiende sus comentarios y reenva la nueva
versin de tu evidencia, en caso de que sea requerido.

4. Consulta la Escala de Evaluacin para conocer los criterios con que ser evaluado tu trabajo.

Cierre de la Unidad

En esta unidad tuviste la oportunidad de aprender los fundamentos de los algoritmos. Adems de los
conceptos bsicos y sus caractersticas, te introdujiste a la comparacin de algoritmos considerando sus
tiempos de ejecucin y otros elementos de complejidad.

Tambin conociste los problemas NP-Completos para los cuales nadie ha sido capaz de encontrar un
algoritmo eficiente que se ejecute en una computadora convencional.

Estudiaste los detalles de dos representaciones comunes para los algoritmos: pseudocdigo y diagramas
de flujo.

Finalmente revisaste algoritmos prcticos de bsqueda y ordenamiento, as como unos ms avanzados
llamados glotones. Analizaste el cdigo en lenguaje C y Java de estos algoritmos y podrs continuar
probndolos y experimentando con ellos para que seas capaz de resolver problemas de la vida real.

1-3 aciertos. Los conocimientos obtenidos no fueron suficientes, debes revisar nuevamente el contenido
de la unidad.
4-5 aciertos. Tienes un conocimiento claro de los conceptos manejados en la Unidad. Sigue adelante!.


64

64

Para saber ms

Consulta los siguientes links:

Acerca de algoritmos de ordenamiento: http://www.sorting-algorithms.com/

Aplicaciones de algoritmos: http://elpais.com/diario/2008/04/10/ciberpais/1207791626_850215.html

Acerca de complejidad: http://community.topcoder.com/tc?module=Static&d1=tutorials&d2=complexity1

Acerca de algoritmos avanzados:http://www.xataka.com/otros/un-nuevo-algoritmo-mejora-el-manejo-de-
miembros-artificiales-con-la-mente

Fuentes de consulta

Cormen, T. H., Leiserson, C. E., Rivest, R. L. , Stein, C. (2009). Introduction to Algorithms (3rd. ed.). USA:
The MIT Press.

Heineman, G. T.,Pollice, G., and Selkow, S. (2009). Algorithms in a NutShell. (1
st
. Ed.). USA: OReilly
Media, Inc.

Dasgupta S., Papadimitriou, C. H., and Vazirani, U. V.(2006). Algorithms(1
st
.ed.). No publisher info

ECMA-4, 2nd Edition.(1966) Standard for Flow Charts. European Computer Manufacturers Association.
September 1966

GC20-8152-1.(1969) Flowcharting Techniques. International Business Machines Corporation.

U2 Algoritmos

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

U2 Algoritmos

Uploaded by

Copyright:

Available Formats

Programa desarrollado

de la secuencia de entrada tal que

tales que es menor

representan variables booleanas (verdadero o falso), + representa or, * representa and, y

You might also like