Fundamentos de Programación - Algoritmos

Jfferson Beltrn
Fundamentos de
Programacin - Algoritmos
Fundamentos de Programacin Algoritmos 2

Fundamentos de
Programacin -
Algoritmos

Jfferson Beltrn M.

3 Jfferson Beltrn M.

Fundamentos de Programacin - Algoritmos
Todos los derechos reservados. No est permitida la reproduccin total o
parcial de este libro, ni su tratamiento informtico, ni la transmisin de ninguna
forma o por cualquier medio, ya sea electrnico, mecnico, por fotocopia u
otros mtodos, sin el permiso previo y por escrito de los titulares del Copyright.
Copyright 2012. Jfferson Beltrn Morales.
ISBN: 978-9942-11-536-2
Mayo 2012
Quito Ecuador


CONTENIDO
OBJETIVO. .............................................................................................................. 7
INTRODUCCIN. ................................................................................................... 7
1. EL ORDENADOR. ............................................................................................ 9
2. EL SOFTWARE. ............................................................................................. 11
3. SISTEMA BINARIO Y REPRESENTACIN BINARIA DE DATOS. ............... 12
3.1. SISTEMAS DE NUMERACIN. ............................................................... 12
3.2. EL SISTEMA BINARIO. ........................................................................... 12
3.2.1 TRANSFORMACIN DE BINARIO A DECIMAL (ENTEROS). ............ 13
3.2.2 TRANSFORMACIN DE DECIMAL (ENTEROS) A BINARIO ............. 13
3.2.3 OPERACIONES BSICAS Y LGICAS. .............................................. 14
4 ALGORITMOS Y ELEMENTOS QUE LO CONFORMAN. .............................. 17
4.1 CARACTERSTICAS DE LOS ALGORITMOS. ........................................ 17
4.2 PARTES DE UN ALGORITMO. ............................................................... 17
4.2.1 TIPOS DE DATOS. ............................................................................... 18
4.2.2 CONSTANTES Y VARIABLES. ............................................................ 18
4.2.3 SENTENCIAS O INSTRUCCIONES. .................................................... 18
4.2.4 OPERADORES Y EXPRESIONES. ...................................................... 19
4.2.5 ESTRUCTURAS DE CONTROL. .......................................................... 20
4.3 PASOS PARA CREAR UN ALGORITMO. ............................................... 20
5 CONCEPTOS BSICOS DE PROGRAMACIN. .......................................... 21
5.1 PROGRAMA. ........................................................................................... 21
5.1.1 CARACTERSTICAS DEL PROGRAMA............................................... 21
5.2 APLICACIN INFORMTICA. ................................................................. 22
5.3 SISTEMA INFORMTICO. ...................................................................... 22
5.4 DATOS. .................................................................................................... 22
5.5 INFORMACIN. ....................................................................................... 22
5.6 PROCESAMIENTO DE DATOS. ............................................................. 22
5.6.1 ACTIVIDADES DEL PROCESAMIENTO DE DATOS. ......................... 22
6 RESOLUCIN DE PROBLEMAS CON COMPUTADORA - DESARROLLO
DE SOFTWARE. ................................................................................................... 22
6.1 PASOS DEL DESARROLLO DE SOFTWARE. ....................................... 23

6.1.1 ANLISIS DEL PROBLEMA. ................................................................ 23
6.1.2 DISEO DEL ALGORITMO SOLUCIN. ............................................. 24
6.1.3 CODIFICACIN DEL PROGRAMA. ..................................................... 24
6.1.4 COMPILACIN Y EJECUCIN. ........................................................... 25
6.1.5 PRUEBAS - VERIFICACIN. ............................................................... 25
6.1.6 DEPURACIN. ..................................................................................... 25
6.1.7 DOCUMENTACIN DE PROGRAMA. ................................................. 26
6.1.8 MANTENIMIENTO DEL PROGRAMA. ................................................. 27
7 TIPOS Y PARADIGMAS DE PROGRAMACIN. ........................................... 27
7.1 PROGRAMACIN ESTRUCTURADA. .................................................... 27
7.2 PROGRAMACIN MODULAR. ............................................................... 28
7.3 PROGRAMACIN FUNCIONAL. ............................................................. 28
7.4 PROGRAMACIN ORIENTADA A OBJETOS (POO). ............................ 28
7.5 PROGRAMACIN DIRIGIDA POR EVENTOS. ....................................... 29
7.6 PROGRAMACIN DE SCRIPTS. ............................................................ 30
7.7 PROGRAMACIN CONCURRENTE Y PARALELA. ............................... 30
7.8 PROGRAMACIN LGICA. .................................................................... 30
7.9 PROGRAMACIN DISTRIBUIDA. ........................................................... 30
7.10 PROGRAMACIN WEB. ...................................................................... 31
8 LENGUAJES DE PROGRAMACIN. ............................................................. 32
8.1 LENGUAJES DE MAQUINA. ................................................................... 32
8.2 LENGUAJES DE BAJO NIVEL. ............................................................... 32
8.3 LENGUAJES DE ALTO NIVEL. ............................................................... 32
8.4 COMPILACIN, COMPILADORES E INTRPRETES. ........................... 33
8.4.1 COMPILADOR E INTRPRETE. .......................................................... 34
9 LA LGICA COMO ASPECTO FUNDAMENTAL DE LA PROGRAMACIN. 35
9.1 QU ES LGICA? ................................................................................. 35
10 REPRESENTACIN GRFICA DE LOS ALGORITMOS. .......................... 37
10.1 DESCRIPCIN NARRADA. .................................................................. 37
10.2 PSEUDOCDIGO. ............................................................................... 38
10.3 DIAGRAMAS DE FLUJO O FLUJOGRAMAS. ...................................... 38
10.4 INTRODUCCIN A UML (Unified Modeling Language). ...................... 40

10.4.1 DIAGRAMAS UML. ............................................................................ 40
11 ENTORNO DE PROGRAMACIN INTEGRADO (IDE). ............................. 41
12 PROGRAMACIN ESTRUCTURADA. ....................................................... 42
12.1 ESTRUCTURA SECUENCIAL. ............................................................. 48
12.2 ESTRUCTURAS SELECTIVAS O CONDICIONALES. ......................... 53
12.2.1 ESTRUCTURA SELECTIVA SI-ENTONCES (IF-THEN). ............. 53
12.2.2 EXPRESIONES LGICAS. ............................................................... 59
12.2.3 ESTRUCTURAS ANIDADAS............................................................. 64
12.2.4 ESTRUCTURA DE SELECCIN MLTIPLE SEGN (CASE). .... 71
12.3 ESTRUCTURAS REPETITIVAS O ITERATIVAS. ................................ 76
12.3.1 ESTRUCTURA REPETITIVA PARA (FOR). ................................. 77
12.3.1.1 CONTADOR. .................................................................................. 78
12.3.1.2 ACUMULADOR O TOTALIZADOR. ............................................... 78
12.3.2 ESTRUCTURA ITERATIVA MIENTRAS (WHILE). ....................... 82
12.3.2.1 CENTINELAS. ................................................................................ 85
12.3.2.2 BANDERAS. ................................................................................... 88
12.3.3 ESTRUCTURA ITERATIVA REPETIR (REPEAT). ....................... 90
13 ESTRUCTURA DE DATOS Y ARREGLOS................................................. 95
13.1 INTRODUCCIN. ................................................................................. 96
13.2 ESTRUCTURA DE DATOS. ................................................................. 96
13.3 ARREGLOS. ......................................................................................... 96
13.3.1 ARREGLO UNIDIMENSIONAL. ...................................................... 100
13.3.1.1 PARTES DE UN ARREGLO. ....................................................... 101
13.3.1.2 OPERACIONES CON ARREGLOS. ............................................ 102
13.3.2 ARREGLO BIDIMENSIONAL. ......................................................... 111
14 MODULARIDAD. ....................................................................................... 114
14.1 PROCEDIMIENTOS Y FUNCIONES. ................................................. 116
14.1.1 IMPLEMENTACIN DE PROCEDIMIENTOS Y FUNCIONES........ 117
14.2 BIBLIOTECAS. ................................................................................... 124
15 RECURSIVIDAD. ...................................................................................... 124
16 ESTILO DE PROGRAMACIN. ................................................................ 128
17 BIBLIOGRAFA. ......................................................................................... 129

FUNDAMENTOS DE PROGRAMACIN ALGORITMOS

OBJETIVO.
Mostrar los fundamentos de la programacin, de modo que al final del curso, el
estudiante ser capaz de disear algoritmos mediante ejercicios prcticos
utilizados cotidianamente en el desarrollo de aplicaciones de software, con
ayuda de las diferentes tcnicas algortmicas, con la finalidad de formarse una
mentalidad de programador.

INTRODUCCIN.
Todos tenemos conciencia de que el xito de una empresa depende de la
rapidez, calidad, control de los recursos, exactitud y otros muchos factores.
Hace tiempo, las empresas ya sean grandes o pequeas, tenan que hacer sus
procesos manualmente o con ayuda de mquinas. Pero a raz de la aparicin
de las primeras computadoras, las grandes empresas obtuvieron unas de estas
y comenzaron a tener mayor ventaja sobre las dems organizaciones. Con el
paso del tiempo, se crearon computadoras ms pequeas, de menos costo,
ms rpidas, lo cual ha provocado que cualquier persona o empresa pueda
adquirir una o ms de estas computadoras.
En la actualidad, muchas empresas realizan sus operaciones por medio de
computadoras, por ejemplo en las fbricas ensambladoras de autos se utilizan
robots programados, los cuales se encargan de montar y soldar las partes que
forman el carro; en los supermercados, se utilizan las computadoras junto con
un programa para registrar rpidamente las compras de los clientes, adems
de que les ayuda para llevar el control de su inventario y de sus ingresos entre
otras cosas; en los hospitales, se estn utilizando pequeos robots
programados, los cuales se introducen en el cuerpo del paciente para realizar
incisiones, cauterizar, saturar, etc.; este manual, fue elaborado en un editor de
textos llamado Microsoft Word, el cual es un programa de aplicacin diseado
especficamente para poder crear y dar formato a documentos de texto. En fin,
podramos continuar enumerando en donde se utilizan las computadoras y
nunca terminaramos, lo cual da un amplio campo de trabajo para los
programadores.
Este manual, tiene la finalidad de mostrarte los fundamentos de la
programacin y formarte una mentalidad de programador, mediante la
elaboracin de algoritmos utilizando diferentes tcnicas algortmicas y
herramientas de software para escribir y entender de manera ms sencilla el
fascinante mundo de la programacin. Ya que un programador es decir, la
persona que disea sistemas computacionales o aplicaciones de software,

antes de comenzar a interactuar con la computadora tiene que tener una
manera de pensar diferente a las dems personas para poder analizar y
resolver problemas mediante aplicaciones de software, los cuales primero debe
plasmarlos en papel o en alguna herramienta de software especfica para ello y
luego en un lenguaje de programacin.


1. EL ORDENADOR.
Un ordenador es una mquina programable. Las dos caractersticas principales
de un ordenador son:
Responde a un sistema especfico de instrucciones de una manera
bien definida.
Puede ejecutar una lista de instrucciones pregrabadas (un
programa).
Los ordenadores modernos son electrnicos y digitales. La maquinaria real,
cables, transistores, y circuitos, se llaman hardware; las instrucciones y los
datos se llaman software.
Todos los ordenadores de uso general requieren los siguientes componentes
de hardware:
Dispositivos de Entrada: Como su nombre lo indica, sirven para
introducir datos (informacin) en el ordenador para su proceso. Ejemplo:
teclado, ratn, scanner, etc.
Dispositivos de Salida: Regresan los datos procesados que sirven de
informacin al usuario. Los ms comunes son el monitor y la impresora.
La Unidad Central de Procesamiento (CPU). Aunque generalmente al
gabinete se le denomina CPU, el CPU es el microprocesador del
ordenador y es el encargado de hacer todos los clculos y operaciones
(es cerebro del ordenador). El CPU a su vez se divide en las siguientes
partes:
Unidad de Control: Coordina las actividades del ordenador y determina
que operaciones se deben realizar y en qu orden; as mismo controla
todo el proceso del ordenador.
Unidad Aritmtica - Lgica: Realiza operaciones aritmticas y lgicas,
tales como suma, resta, multiplicacin, divisin y comparaciones.
La Memoria. Es una parte del ordenador en donde se almacenan los
datos a procesar y la informacin resultante. Esta puede ser de dos
tipos:
Memoria Primaria: Es el espacio en que se almacenan los datos a
procesar o calcular en este momento.
Memoria Secundaria: Es el espacio en el que se almacena la
informacin resultante para su futura consulta o manejo. Por ejemplo:
discos duros, unidades de almacenamiento magntico (CD-DVD), etc.

Adems de estos componentes, muchos otros hacen posible que los
componentes bsicos trabajen juntos eficientemente. Por ejemplo, cada
ordenador requiere un bus que transmita datos de una parte del ordenador a
otra.
Generalmente, los ordenadores se pueden clasificar por tamao y potencia de
la siguiente forma, aunque hoy un solapamiento considerable:
Ordenador personal (personal computer): Un ordenador pequeo,
para un slo usuario basado en un microprocesador. Adems del
microprocesador, un ordenador personal tiene un teclado para introducir
datos, un monitor para mostrar la informacin, y un dispositivo de
almacenamiento para guardar datos.
Estacin de trabajo (workstation): Una computadora de gran potencia
para un slo usuario. Una estacin de trabajo es como un ordenador
personal, pero tiene un microprocesador ms potente y un monitor de
mejor calidad.
Miniordenador (minicomputer): Un ordenador para varios usuarios
capaz de soportar centenares de usuarios simultneamente.
Chasis (mainframe): Una computadora multiusuario de gran potencia
capaz de soportar miles de usuarios simultneamente.
Superordenador (supercomputer): Un ordenador extremadamente
rpido que puede realizar cientos de millones de instrucciones por
segundo.

DISPOSITIVOS
DE ENTRADA
DISPOSITIVOS
DE SALIDA
UNIDAD DE
CONTROL
UNIDAD DE
ARITMTICA
Y LGICA
C.P.U.
MEMORIA

Nota: No se dar ms detalle sobre los ordenadores pues nos tomara todo el
semestre y no es el objetivo del curso.

2. EL SOFTWARE.
Las operaciones que debe realizar el hardware son especificadas con una lista
de instrucciones, llamadas programas, o software. El software se divide en dos
grandes grupos:
Software del sistema, y Software de aplicaciones.
El software del sistema es el conjunto de programas indispensables
para que la mquina funcione. Estos programas son, bsicamente, el
Sistema Operativo, los editores de texto (Word, Writer, etc), los
compiladores de lenguajes de programacin y los utilitarios (Microsoft
Office, OpenOffice, antivirus, navegadores, correo electrnico, etc).
o El Sistema Operativo es el software bsico de una computadora,
que provee una interfaz entre el resto de programas del
ordenador, los dispositivos de hardware y el usuario. Dirige las
operaciones globales de la computadora, instruye a la
computadora para ejecutar otros programas, administra los
recursos de la mquina, coordina el hardware y organiza archivos
y directorios en dispositivos de almacenamiento de una forma
sencilla y transparente para el usuario. Los principales sistemas
operativos son: MS-DOS, Microsoft Windows, Unix, Mac OS,
Solaris, Linux, Android, iOS, etc.

Los programas que realizan tareas concretas (por ejemplo facturacin,
contabilidad, anlisis estadstico, gestin de negocios, sistemas
bancarios, etc.) se denominan programas de aplicacin o software de
aplicaciones.

3. SISTEMA BINARIO Y REPRESENTACIN BINARIA DE
DATOS.
3.1. SISTEMAS DE NUMERACIN.
Sistema de Numeracin es el conjunto de elementos o smbolos, operaciones y
relaciones que, a travs de reglas propias, permite establecer el papel de tales
relaciones y operaciones.

El ms conocido y usado es el sistema de numeracin decimal, no es el nico y
por el contrario los ms utilizados en los circuitos digitales son el octal, el
hexadecimal y sobre todo el binario.

Las computadoras suelen efectuar las operaciones aritmticas utilizando una
representacin para los datos numricos basada en el sistema de
numeracin de base dos conocido como binario natural o simplemente
binario.

Se utilizan los sistemas octal y hexadecimal (bases 8 y 16) respectivamente
para obtener cdigos intermedios. A nivel electrnico, utilizar cdigos
intermedios resulta ms favorable que transformar directamente decimales en
binarios y al revs.

3.2. EL SISTEMA BINARIO.
El sistema de numeracin binario es el conjunto de elementos {0, 1} con las
operaciones aritmticas (suma, resta, multiplicacin) y lgicas (OR, AND y
NOT).

Los elementos del conjunto o alfabeto binario se denominan cifras binarias o
bits.


El bit del extremo de la derecha es el bit menos significativo o de menor peso.
El bit del extremo de la izquierda es el bit ms significativo o de mayor peso.

3.2.1 TRANSFORMACIN DE BINARIO A DECIMAL (ENTEROS).
Consiste en multiplicar cada uno de los trminos por potencias crecientes de 2
a partir de la coma decimal y hacia la izquierda, y realizar la suma de las
operaciones.
Ejemplo: convertir a decimal 101011102

3.2.2 TRANSFORMACIN DE DECIMAL (ENTEROS) A BINARIO
Se va dividiendo la cantidad decimal por 2, apuntando los restos, hasta obtener
cociente cero. El ltimo resto obtenido es el bit ms significativo (MSB) y el
primero es el bit menos significativo (LSB).


3.2.3 OPERACIONES BSICAS Y LGICAS.
Las operaciones ms bsicas con el sistema binario son la suma, la resta, la
multiplicacin y la divisin. Estas operaciones son similares a las del sistema
decimal, ya que el sistema binario tambin es un sistema posicional

Las operaciones binarias lgicas bsicas son OR, XOR, AND y NOT, de aqu
surgen otras como la NOR, la NAND, la XOR y la XNOR.

La OR responde a la unin entre conjuntos, La AND a la interseccin y la
NOT al complemento. A continuacin se muestra la tabla de verdad de las
principales operaciones lgicas binarias.


3.3 REPRESENTACIN BINARIA DE DATOS.
El bit es la unidad mnima de almacenamiento empleado en informtica, en
cualquier dispositivo digital o en la teora de la informacin; con l podemos
represe4ntar dos valores (0 y 1), los ordenadores trabajan internamente con
dos niveles de voltaje: apagado (0) y encendido (1), por los que su sistema
de numeracin natural es el sistema binario.
Cuando se almacena la informacin no se trabaja a nivel de bit, sino que se
trabaja a nivel de carcter (letras, caracteres especiales, nmeros, etc), que
ocupa un byte, que se compone de 8 bits. El ordenador trabaja con
agrupaciones de bits fciles de manipular y suelen ser mltiplos de 2, la base
del sistema binario. Los tamaos ms comunes son:
Octeto, carcter o byte. Es la agrupacin de 8 bits, es el tamao ms
comn de informacin; con l se puede codificar un alfabeto completo
(ASCII estndar).
Palabra. Es el tamao de informacin manejada en paralelo por los
componentes del sistema, como la memoria y los buses. Son comunes
palabras de 8, 32, 64, 128, 256 y 512 bits, es decir, 1 byte, 4, 8, 16, 32 y
64 bytes. A mayor tamao de palabra, mayor es la precisin y la
potencia de clculo del ordenador.
Lo normal es utilizar los mltiplos del byte: kilobyte (kb), megabyte (Mb),
gigabyte (Gb), etc.


Cualquier informacin escrita, cualquier texto se puede representar por medio
de caracteres. Los caracteres utilizados en informtica se suelen clasificar en
cinco categoras:
Caracteres alfabticos: letras maysculas y minsculas del alfabeto
Caracteres numricos: constituidos por las diez cifras decimales.
Caracteres especiales: smbolos ortogrficos y matemticos no
incluidos en los grupos anteriores.
Caracteres geomtricos y grficos: smbolos con los que se
representan formas geomtricas o iconos elementales:
Caracteres de control: representan rdenes de control, como salto de
lnea (NL), comienzo de lnea (CR), sincronizacin de una transmisin
(SYN), pitido (BEL), etc.

Cuando se introducen textos en un ordenador a travs del perifrico que
corresponda, los caracteres se codifican con un cdigo de entrada/salida,
asociando a cada carcter una determinada combinacin de n bits.

Los elementos del conjunto de caracteres, as como su nmero m, dependern
del cdigo de E/S utilizado por el programa que interprete el texto introducido
as como del perifrico que lo codifique.

Si utilizamos n bits para codificar m smbolos, el nmero mnimo de bits
necesarios para codificar un conjunto de smbolos depende del cardinal de este
conjunto:
Con 2 bits (n=2) podemos hacer 2^2=4 combinaciones, es decir, se
podran codificar 4 smbolos distintos (m=4).
Con 3 bits (n=3) seran 2^3=8 combinaciones, 8 smbolos (m=8), y as
sucesivamente.
Con n bits se podran codificar m=2^n smbolos distintos.
Dicho de otra forma, para codificar m smbolos distintos se necesitan n
bits, siendo n el menor nmero natural que verifica:

Los principales cdigos de E/S son:
El cdigo ASCII (American Standard Code for Information Interchange)
bsico utiliza 7 bits y es uno de los ms utilizados actualmente. El cdigo
ASCII extendido usa 8 bits por carcter por lo que se tienen 256
caracteres diferentes. El problema es que los smbolos codificados son
insuficientes para representar caracteres especiales de idiomas de
diversas culturas como china, japonesa, coreana, etc.

Unicode es un cdigo de E/S propuesto por un consorcio de empresas y
entidades que trata de crear aplicaciones capaces de procesar texto de
muy diferentes sistemas de escritura. Las caractersticas principales son:
o Est reconocido como estndar ISO/IEC 10646.
o Cubre la mayora de los lenguajes actuales.
o A cada carcter se le asigna un nico cdigo. Todos los smbolos
se representan con un nmero fijo de bits, 16 concretamente.
o Cada carcter est formado por una cadena de 16 bits, pudiendo
codificarse en total 216 = 65356 smbolos diferentes.
o No contempla la codificacin de caracteres de control.
o Incluye caracteres combinados, smbolos como , , etc.
o No determina la forma o imagen concreta de cada carcter
(fuente).
Se puede tambin representar tambin sonidos, imgenes, videos, etc.,
y cualquier informacin que se almacene en un computador.

4 ALGORITMOS Y ELEMENTOS QUE LO CONFORMAN.
Un algoritmo es un mtodo para resolver un problema mediante una serie de
pasos precisos, definidos y finitos. Es un conjunto de reglas para resolver
determinado problema describiendo de forma lgica su solucin. Cada una de
las acciones de que consta un algoritmo es denominada sentencia (o
instrucciones) y stas deben ser escritas en trminos de cierto lenguaje
comprensible para el computador, que es el lenguaje de programacin.
4.1 CARACTERSTICAS DE LOS ALGORITMOS.
Los criterios que debe satisfacer un algoritmo (caractersticas) son:
Entrada. Son cero o ms parmetros (datos) los cuales son
externamente sustituidas.
Salida. Al menos un dato es producido.
Exactitud/precisin. Cada instruccin debe ser clara y sin ambigedad
(hacen lo que deben hacer).
Finito. Terminar despus de un nmero finito de pasos.
Eficiente. Cada instruccin puede ser verificada por una persona con
una prueba manual que satisfaga los requerimientos planteados por el
problema.
Repetible. Dada una misma entrada, siempre debe dar la misma salida.

4.2 PARTES DE UN ALGORITMO.

Los algoritmos se construyen utilizando elementos simples para que el lenguaje
se parezca ms a los lenguajes de programacin de alto nivel. Entre ellos se
tienen:
4.2.1 TIPOS DE DATOS.
Las diferencias piezas de informacin con las que un programa trabaja se
conocen colectivamente como datos. Todos los datos tienen un tipo
asociado con ellos, que determina la naturaleza del conjunto de valores que
aquel puede tomar. Por ejemplo, un dato puede ser un simple caracter, tal
como B, un valor entero como 36, un nmero real como 5.75, una cadena de
caracteres como Hola Mundo, un valor de verdad como Verdadero o Falso,
entre otros.
4.2.2 CONSTANTES Y VARIABLES.
Todos los programas necesitan almacenar datos temporalmente para poder
procesarlos y generar as la salida esperada. Estos datos, a grandes rasgos,
pueden clasificarse en dos grupos:
A un dato cuyo valor no puede cambiar (se mantiene constante) durante
la ejecucin de un programa se lo denomina Constante. Las constantes
deben ser declaradas y asignadas un valor antes de su utilizacin.
Por su parte, los datos de un programa cuyo valor puede cambiar
durante la ejecucin del mismo se conocen como Variables. Una
variable es, en realidad, una posicin de memoria con nombre (Nombre
de la Variable), y que contiene un valor (Valor de la Variable). Las
variables se asemejan a cajas o buzones, donde cada una de las cuales
tiene un nmero y contiene un valor. Existen tantos tipos de variables
como tipos de datos diferentes.
4.2.3 SENTENCIAS O INSTRUCCIONES.
Las sentencias describen acciones algortmicas que pueden ser ejecutadas. En
general, las sentencias se clasifican en ejecutables (especifican, por ejemplo,
operaciones de clculos aritmticos y entradas/salidas de datos) y no
ejecutables (no realizan acciones concretas ni afectan a la ejecucin del
programa, sino que ayudan a su legibilidad) como la declaracin de variables.
Las sentencias se clasifican, segn su tipo y nmero, en:
Sentencias Simples: Son sentencias que no contiene ninguna otra
sentencia. El ejemplo ms tpico de sentencia simple es la sentencia de

asignacin, la cual se utiliza para almacenar un valor en una variable.
La operacin de asignacin se suele representar en pseudocdigo con
el smbolo , para denotar que el valor situado a su derecha se
almacena en la variable situada a la izquierda:
o variable Valor
o Ejemplo: suma0 (la asignacin slo ser vlida si el valor es
vlido para el tipo de dato definido para la variable).
Otros ejemplos de sentencias simples son las de entrada/salida.
Sentencias estructuradas: Son sentencias compuestas de otras
sentencias que se ejecutan en secuencia, condicionalmente o
repetidamente.
4.2.4 OPERADORES Y EXPRESIONES.
Las variables y constantes se pueden procesar utilizando operaciones y
funciones adecuadas para sus tipos.
Se denomina expresin a un conjunto de variables y / o constantes unidas por
operadores.
Un operador es un smbolo o palabra que significa que se ha de realizar cierta
accin entre uno o dos valores que son llamados operandos.
Si en una expresin existe ms de una operacin debe tenerse en cuenta que
existen una serie de reglas para definir la prioridad en la que stas se
realizarn. Por este motivo es que se suelen utilizar los parntesis para
establecer la prioridad de aplicacin de los operandos.
Existen diversos tipos de operadores, por ejemplo:
Aritmticos: Son apropiados nicamente para tipos numricos.
Ejemplos de operadores aritmticos son + , - , * y / , etc., los
cuales permiten obtener el resultado de la suma, la resta, la
multiplicacin y la divisin de dos datos respectivamente. Su resultado
es un nmero.
De relacin: Los operadores de relacin (o relacionales) se utilizan para
expresar condiciones y describen una relacin entre dos valores.
Ejemplos de operadores relacionales son < (Menor que), > (Mayor
que), = (Igual a) y <> (Distinto a), etc. Su resultado es un valor de
verdad.

Los operadores aritmticos y los relacionales se utilizan de la siguiente
forma: variable o constante operador variable o constante. Por ejemplo:
a + b, c/d, a<b, c<>d, etc.
Lgicos: Estos operadores se utilizan con constantes lgicas de forma
similar al modo en que los operadores aritmticos se utilizan con las
constantes numricas. Estos operadores trabajan con operandos que
son expresiones lgicas. La operacin and (y) combina dos condiciones
simples y produce un resultado verdadero slo si los dos operandos son
verdaderos. La operacin or (o) es verdadera si uno de los dos
operandos es verdadero. La operacin not (no) acta sobre una sola
condicin simple u operando y simplemente niega (o invierte) su valor.
Su resultado en es valor de verdad. Existen otros operadores lgicos
adems de los mencionados.
Ejemplo de expresin: Cos (2*pi * X) + 7.69 * X

4.2.5 ESTRUCTURAS DE CONTROL.
El concepto de flujo de control a travs de un algoritmo y luego del programa se
refiere al orden en que se ejecutan las acciones individuales del mismo.
Aunque un flujo normal de un programa estructurado es lineal, existen mtodos
que permiten salir del flujo lineal a travs del uso de las llamadas estructuras
de control.
Las estructuras de control de un lenguaje de programacin son mtodos para
especificar el orden en que las instrucciones de un algoritmo se ejecutarn.
Estas estructuras son, por consiguiente, fundamentales en los lenguajes de
programacin y en los diseos de los algoritmos.
Las estructuras de control son:
Secuencia: Sucesin simple de dos o ms operaciones (una tras otra).
De Seleccin/Condicionales: Bifurcacin condicional de una o ms
operaciones.
De Repeticin o Iteracin: Repeticin de una operacin mientras se
cumple una condicin.
4.3 PASOS PARA CREAR UN ALGORITMO.

Para disear un algoritmo se debe comenzar por identificar las tareas ms
importantes para resolver el problema y disponerlas en el orden en que han de
ser ejecutadas. Los pasos para crear un algoritmo son:
Anlisis del problema. Para resolver cualquier problema, se debe
comprenderlo completamente.
Diseo del algoritmo. Se describen los pasos para resolver el problema.
Es mejor solucionar problemas pequeos.
Prueba del algoritmo. Se realiza las pruebas manuales necesarias para
comprobar que el algoritmo arroje los resultados deseados.
En general, los algoritmos reciben datos de entrada, los procesa y genera la
salida.

El proceso se refiere a los clculos que se deben hacer para obtener la salida
deseada. A partir de los datos de entrada se consigue la salida.
Los algoritmos generalmente se escriben en diagramas de flujo y
pseudocdigo. El primero trabaja con representaciones grficas, el segundo
con un lenguaje especial (ms adelante se describir a detalle stos
conceptos).

5 CONCEPTOS BSICOS DE PROGRAMACIN.
Es un proceso para convertir especificaciones generales de un sistema en
instrucciones utilizables por la mquina, que produzcan los resultados
deseados. Se le conoce tambin como desarrollo de software.
5.1 PROGRAMA.
Es una lista de instrucciones que la computadora debe seguir para procesar
datos y convertirlos en informacin. Las instrucciones se componen de
enunciados usados en lenguajes de programacin como Pascal, Java, C, C#,
etc.
5.1.1 CARACTERSTICAS DEL PROGRAMA.
Debe ser confiable y funcional.

Advertir errores de entrada obvios y comunes.
Documentado adecuadamente.
Ser comprensible.
Codificado en el lenguaje apropiado.

5.2 APLICACIN INFORMTICA.
Es el conjunto de uno a varios programas. Por ejemplo, el sistema de un
Banco, pues se conforma de varios programas como Clientes, Contabilidad,
Ahorros, Crdito, Cartera, etc.

5.3 SISTEMA INFORMTICO.
En el conjunto de elementos necesarios (computadora, terminales, impresoras,
etc.) para la realizacin y explotacin de aplicaciones informticas.

5.4 DATOS.
Son las caractersticas propias de cualquier entidad. Por ejemplo: los datos de
una persona como su edad, fecha de nacimiento, domicilio, nmero de
telfono, etc.
5.5 INFORMACIN.
Es el conocimiento relevante producido como resultado del procesamiento de
datos y adquirido por la gente para realzar el entendimiento y cumplir ciertos
propsitos.
5.6 PROCESAMIENTO DE DATOS.
Consiste en la recoleccin de datos de entrada que son evaluados y ordenados
para ser colocados de manera que produzcan informacin til.
5.6.1 ACTIVIDADES DEL PROCESAMIENTO DE DATOS.
Captura de datos de entrada
Manejo de los datos (incluye clasificacin, ordenacin, transformacin,
clculos, etc).
Administracin de la salida resultante.

6 RESOLUCIN DE PROBLEMAS CON COMPUTADORA -
DESARROLLO DE SOFTWARE.

El proceso de resolucin de un problema con una computadora conduce a la
escritura de un programa, y a su ejecucin en la misma. Aunque el proceso de
disear programas es, esencialmente, un proceso creativo, se pueden
considerar una serie de fases o pasos comunes que generalmente deben
seguir todos los programadores. Las fases de resolucin de un problema con
computadoras son:
- Anlisis del problema
- Diseo del algoritmo solucin
- Codificacin
- Compilacin y Ejecucin
- Verificacin
- Depuracin
- Documentacin
- Mantenimiento
El proceso de crear y mantener programas de computacin se denomina
Desarrollo de Software o Ciclo de Vida de Desarrollo de Software.
Las dos primeras fases conducen a un diseo detallado escrito en forma de
algoritmo. Como habamos mencionado, un algoritmo es un mtodo para
resolver un problema mediante una serie de pasos (instrucciones) precisos,
definidos y finitos. Durante la tercer etapa (codificacin) se implementa (poner
en funcionamiento) el algoritmo en un cdigo escrito en un lenguaje de
programacin, reflejando las ideas desarrolladas en la fase de anlisis y
diseo.
La fase de compilacin y ejecucin traduce y ejecuta el programa. En las fases
de verificacin y depuracin el programador busca errores de las etapas
anteriores y los elimina. Cuanto ms tiempo se invierta en la fase de anlisis y
diseo, menor ser el tiempo necesario para depurar el programa. Por ltimo,
debe realizarse la documentacin del mismo.
Los programas son mantenidos en el tiempo, pues se realizan mejoras o se
aumenta funcionalidad a los mismos.
6.1 PASOS DEL DESARROLLO DE SOFTWARE.
6.1.1 ANLISIS DEL PROBLEMA.
Se conoce tambin como especificacin, definicin o anlisis del problema. En
este paso se determinan la informacin inicial para la elaboracin del
programa. Es donde se determina qu es lo que debe resolverse con el

computador, de qu presupuestos se debe partir... en definitiva, el
planteamiento del problema.
Se requieren de cinco tareas:
1. Determinacin de objetivos del programa. Debe definirse claramente los
problemas particulares que debern ser resueltos o las tareas que hay que
realizar, esto nos permitir saber qu es lo que se pretende solucionar y nos
proporcionar informacin til para el planeamiento de la solucin.
2. Determinacin de la salida deseada. Los datos seleccionados deben ser
arreglados en una forma ordenada para producir informacin. Esta salida
podra ser una salida de impresin, de presentacin en el monitor, etc.
3. Determinacin de los datos de entrada. Una vez identificada la salida que
se desea, se pueden determinar los datos de entrada y la fuente de estos
datos. Los datos deben ser recolectados y analizados.
4. Determinacin de los requerimientos de procesamiento. Aqu se
definen las tareas de procesamiento que deben desempearse para que los
datos de entrada se conviertan en una salida.
5. Documentacin de las especificaciones del programa. Es importante
disponer de documentacin permanente. Deben registrarse todos los datos
necesarios para el procesamiento requerido. Esto conduce al siguiente paso
del diseo del programa.

6.1.2 DISEO DEL ALGORITMO SOLUCIN.

Es disear cualquier sistema nuevo o las aplicaciones que se requieren para
satisfacer las necesidades. Esta actividad se debe dividir en:
Operaciones de entrada/salida.
Clculos.
Lgica/ comparacin.
Almacenamiento/ consulta.
En este paso se genera una solucin con tcnicas de programacin como
diseo descendente de programas, pseudocdigos, diagramas de flujo y
estructuras lgicas.
6.1.3 CODIFICACIN DEL PROGRAMA.

Es la generacin real del programa con un lenguaje de programacin. En esta
etapa se hace uso de la lgica que desarroll en el paso del diseo del
programa para efectivamente generar un programa. Se debe seleccionar el
lenguaje apropiado para resolver el problema.

6.1.4 COMPILACIN Y EJECUCIN.
En la fase de compilacin y ejecucin, el compilador comprueba la sintaxis y
semntica del programa, lo traduce y se ejecuta el programa.
6.1.5 PRUEBAS - VERIFICACIN.
Consiste en verificar la funcionalidad del programa a travs de varios mtodos
para detectar errores posibles.
Chequeo de Escritorio. El programador se sienta frente a un escritorio y
corrige una impresin del programa. Revisa el listado lnea por lnea en
busca de errores de sintaxis y lgica.
Prueba manual de datos de muestra. Se corre el programa en forma
manual aplicando datos tanto correctos como incorrectos para comprobar
que funciona correctamente.
Intento de Traduccin. El programa corre en una computadora usando un
programa traductor para convertirlo a lenguaje de mquina. Para ello debe
estar ya libre de errores de sintaxis, de lo contrario sern identificados por el
programa de traduccin.
Prueba de datos de muestra en la computadora. Despus del intento de
traduccin y corregidos los errores de sintaxis, se procede a buscar errores
de lgica utilizando diferentes datos de muestra.
Prueba por un grupo selecto de usuarios potenciales. Esto se conoce
como prueba beta. Se trata por lo general del paso final en la prueba de un
programa. Usuarios potenciales ponen a prueba el programa y ofrecen
retroalimentacin.
6.1.6 DEPURACIN.
Depurar es correr el programa en una computadora y corregir las partes que no
funcionan. En esta fase se comprueba el funcionamiento de cada programa y
esto se hace con datos reales o ficticios. Cuando los programas estn
depurados, se prueban. Cuando los programas se depuran, se pueden
encontrar los siguientes errores:
Errores de sintaxis o de compilacin. Es una violacin de las reglas del
lenguaje de programacin. Son ms fciles de corregir, ya que son
detectados por el compilador (posible error de escritura), el cual dar
informacin sobre el lugar donde est y la naturaleza de cada uno de ellos
mediante un mensaje de error.

Errores de Ejecucin. Se deben generalmente a operaciones no
permitidas como dividir por cero, leer un dato no numrico en una variable
numrica, exceder un rango de valores permitidos, etc. Se detectan porque
se produce una parada anormal del programa durante su ejecucin.
Errores de Lgica. Corresponden a la obtencin de resultados que no son
correctos y la nica manera de detectarlos es realizando suficientes
pruebas del programa. Son los ms difciles de corregir, no slo por la
dificultad de detectarlos, sino porque se deben a la propia concepcin y
diseo del programa.
Errores de Especificacin. Es el peor tipo de error y el ms difcil de
corregir. Se deben a mal diseo del programa posiblemente por mala
comunicacin usuario-programador y se detectan cuando ya se ha
concluido el diseo e incluso cuando el programa est en produccin
(funcionando), lo cual puede implicar repetir gran parte del trabajo realizado.
6.1.7 DOCUMENTACIN DE PROGRAMA.
Consiste en describir por escrito a nivel tcnico los procedimientos
relacionados con el programa y su modo de uso. Tambin se debe documentar
el programa para que sea ms entendible.
Para quines es la documentacin?
Los documentos que deben elaborarse son: Manual de Usuario y Manual
Tcnico.
A los usuarios se les elabora un manual de referencia o de usuario para que
aprendan a utilizar el programa. Esto se hace a travs de capacitaciones y
revisin de la documentacin del manual de usuario. El manual del usuario no
est escrito a nivel tcnico sino al de los distintos usuarios previstos y explica
en detalle cmo usar el programa: descripcin de las tareas que realiza el
programa, instrucciones necesarias para su instalacin puesta en marcha y
funcionamiento, recomendaciones de uso, mens de opciones, mtodo de
entrada y salida de datos, mensajes de error, recuperacin de errores, etc.
A los operadores por si se presentan mensajes de error, sepan cmo
responder a ellos. Adems que se encargan de darle soporte tcnico al
programa.
A los programadores a travs del manual tcnico para que recuerden
aspectos de la elaboracin del programa o en caso que otras personas puedan
actualizarlo o modificarlo (darle mantenimiento) y no son necesariamente las
personas que lo disearon. Es por ello, que la documentacin debe contener

algoritmos y diagramas de flujo de los diferentes mdulos que lo constituyen y
las relaciones que se establecen entre ellos; listados del programa, corridas,
descripcin de variables que se emplean en cada mdulo, cules son comunes
a diferentes mdulos y cules locales; descripcin de los ficheros de cada
mdulo y todo lo que sea de importancia para un programador. Tambin se
documenta tcnicamente mediante diagramas UML (Unified Modeling
Language).
A los analistas de sistemas que son las personas que debern proporcionar
toda la informacin al programador. Estos se encargan de hacer una
investigacin previa de cmo realizar el programa y documentar con las
herramientas necesarias para que el programador pueda desarrollar el sistema
en algn lenguaje de programacin adecuado.
6.1.8 MANTENIMIENTO DEL PROGRAMA.
Es el paso final del desarrollo del software. Alrededor del 75% del costo total
del ciclo de vida de un programa se destina al mantenimiento. El propsito del
mantenimiento es garantizar que los programas en uso estn libres de errores
de operacin y sean eficientes y efectivos, adems que los sistemas
evolucionan en el tiempo y su funcionalidad es aumentada o mejorada de
acuerdo a las necesidades de los usuarios.

7 TIPOS Y PARADIGMAS DE PROGRAMACIN.
Existen varios tipos o tcnicas de programacin, en la mayora de casos, las
tcnicas se centran en programacin estructurada, modular y orientada a
objetos. A continuacin, se presenta brevemente las principales tcnicas de
programacin:

7.1 PROGRAMACIN ESTRUCTURADA.
Programacin Estructurada es una tcnica en la cual la estructura de un
programa, esto es, la interpelacin de sus partes se realiza tan claramente
como sea posible mediante el uso de tres estructuras de control:
Secuencia: Sucesin simple de dos o ms operaciones (una tras otra).
Seleccin/Condicional: Bifurcacin condicional de una o ms
operaciones.
Repeticin: Repeticin de una operacin mientras se cumple una
condicin.

Estos tres tipos de estructuras lgicas de control pueden ser combinados para
producir programas que manejen cualquier tarea de procesamiento de
informacin.
Una caracterstica importante en un programa estructurado es que puede ser
ledo en secuencia, desde el comienzo hasta el final sin perder la continuidad
de la tarea que cumple el programa, de esta manera la comprensin y lectura
de un programa es muy sencilla y se torna fcil el encontrar errores.

7.2 PROGRAMACIN MODULAR.
La programacin modular consta de varias secciones dividas de forma que
interactan a travs de llamadas a funciones o procedimientos, que integran el
programa en su totalidad.

En la programacin modular, el programa principal coordina las llamadas a los
mdulos secundarios (subprogramas) y pasa los datos necesarios en forma de
parmetros.

A su vez, cada mdulo puede contener sus propios datos y llamar a otros
mdulos o funciones.

7.3 PROGRAMACIN FUNCIONAL.
Se caracteriza principalmente por permitir declarar y llamar a funciones dentro
de otras funciones.

7.4 PROGRAMACIN ORIENTADA A OBJETOS (POO).
La programacin orientada a objetos o POO (OOP segn sus siglas en
ingls) es un paradigma de programacin que usa objetos y sus interacciones,
para disear aplicaciones y programas informticos. Est basado en varias
tcnicas, incluyendo herencia, abstraccin, polimorfismo y encapsulamiento
Los objetos son entidades que tienen un determinado estado (atributos),
comportamiento (mtodo) e identidad:
El estado est compuesto de datos, ser uno o varios atributos a los que
se habrn asignado unos valores concretos (datos).
El comportamiento est definido por los mtodos o mensajes a los que
sabe responder dicho objeto, es decir, qu operaciones se pueden
realizar con l.
La identidad es una propiedad de un objeto que lo diferencia del resto,
dicho con otras palabras, es su identificador (concepto anlogo al de
identificador de una variable o una constante).

Un objeto contiene toda la informacin que permite definirlo e identificarlo frente
a otros objetos pertenecientes a otras clases e incluso frente a objetos de una
misma clase, al poder tener valores bien diferenciados en sus atributos. A su
vez, los objetos disponen de mecanismos de interaccin llamados mtodos,
que favorecen la comunicacin entre ellos. Esta comunicacin favorece a su
vez el cambio de estado en los propios objetos. Esta caracterstica lleva a
tratarlos como unidades indivisibles, en las que no se separa el estado y el
comportamiento.
Los mtodos (comportamiento) y atributos (estado) estn estrechamente
relacionados por la propiedad de conjunto. Esta propiedad destaca que una
clase requiere de mtodos para poder tratar los atributos con los que cuenta.
De esta manera se estara realizando una programacin estructurada
camuflada en un lenguaje de programacin orientado a objetos.
La POO difiere de la programacin estructurada tradicional, en la que los datos
y los procedimientos estn separados y sin relacin, ya que lo nico que se
busca es el procesamiento de unos datos de entrada para obtener otros de
salida. La programacin estructurada anima al programador a pensar sobre
todo en trminos de procedimientos o funciones, y en segundo lugar en las
estructuras de datos que esos procedimientos manejan. En la programacin
estructurada solo se escriben funciones que procesan datos. Los
programadores que emplean POO, en cambio, primero definen objetos para
luego enviarles mensajes solicitndoles que realicen sus mtodos por s
mismos.
7.5 PROGRAMACIN DIRIGIDA POR EVENTOS.
La programacin dirigida por eventos es un paradigma de programacin en el
que tanto la estructura como la ejecucin de los programas van determinados
por los sucesos que ocurran en el sistema, definidos por el usuario o que ellos
mismos provoquen.
Mientras en la programacin estructurada (o secuencial) es el programador el
que define cul va a ser el flujo del programa, en la programacin dirigida por
eventos ser el propio usuario o lo que sea que est accionando el
programa el que dirija el flujo del programa. Aunque en la programacin
secuencial puede haber intervencin de un agente externo al programa, estas
intervenciones ocurrirn cuando el programador lo haya determinado, y no en
cualquier momento como puede ser en el caso de la programacin dirigida por
eventos.
El creador de un programa dirigido por eventos debe definir los eventos que
manejarn su programa y las acciones que se realizarn al producirse cada
uno de ellos, lo que se conoce como el administrador de evento.
En la programacin dirigida por eventos, al ejecutarse el programa esperar
hasta que se produzca algn evento. Cuando alguno de los eventos esperados

por el programa tenga lugar, el programa pasar a ejecutar el cdigo del
correspondiente administrador de evento. Por ejemplo, si el evento consiste en
que el usuario ha hecho click en el botn de play de un reproductor de
pelculas, se ejecutar el cdigo del administrador de evento, que ser el que
haga que la pelcula se muestre por pantalla.
7.6 PROGRAMACIN DE SCRIPTS.
Un script es un programa que se escribe con una sintaxis particular
generalmente en un archivo de texto plano que permanece en su forma
original, para que sea interpretado comando por comando cada vez que se
ejecuta por un intrprete o un shell.
Un script es bsicamente un programa que llama a otros programas, con la
posibilidad de hacer algn tipo de procesamiento propio (como control de flujo,
operaciones matemticas simples, etc).
7.7 PROGRAMACIN CONCURRENTE Y PARALELA.
La programacin paralela es una tcnica de programacin en la que muchas
instrucciones se ejecutan simultneamente. Se basa en el principio de que los
problemas grandes se pueden dividir en partes ms pequeas que pueden
resolverse de forma concurrente ("en paralelo").

Se suele utilizar para controlar los accesos de usuarios y programas a un
recurso de forma simultnea. Se trata de una programacin ms lenta y
laboriosa.

La computacin paralela emplea elementos de procesamiento mltiple
simultneamente para resolver un problema. Esto se logra dividiendo el
problema en partes independientes de tal manera que cada elemento de
procesamiento pueda ejecutar su parte del algoritmo a la misma vez que los
dems. Los elementos de procesamiento pueden ser diversos e incluir recursos
tales como un nico ordenador con muchos procesadores, varios ordenadores
en red, hardware especializado o una combinacin de los anteriores.

7.8 PROGRAMACIN LGICA.
Se suele utilizar en la inteligencia artificial, principalmente en juegos y en
sistemas expertos. Se trata de una programacin basada en el clculo de
predicados (una teora matemtica que permite lograr que un ordenador
basndose en hecho y reglas lgicas, pueda dar soluciones inteligentes).

7.9 PROGRAMACIN DISTRIBUIDA.

La programacin distribuida es un paradigma de programacin enfocado en
desarrollar sistemas distribuidos, abiertos, escalables, transparentes y
tolerantes a fallos. Este paradigma es el resultado natural del uso de las
computadoras y las redes.
Casi cualquier lenguaje de programacin que tenga acceso al mximo al
hardware del sistema puede manejar la programacin distribuida, considerando
una buena cantidad de tiempo y cdigo.
La programacin distribuida tpicamente cae en alguna de las varias
arquitecturas bsicas o arquitecturas: cliente-servidor, 3-tier, n-tier, objetos
distribuidos, entre otras adems.
7.10 PROGRAMACIN WEB.
La programacin web permite la creacin de sitios dinmicos en Internet. Esto
se consigue generando los contenidos del sitio a travs de una base de datos
mediante lenguajes de script. Con la programacin web podemos desarrollar
sitios dinmicos como peridicos digitales o tiendas virtuales.
La programacin web, parte de las siglas WWW, que significan World Wide
Web o telaraa mundial.
Para realizar una pgina con la programacin web, se deben tener claros, tres
conceptos fundamentales:
El URL (Uniform Resource Locators), es un sistema con el cual se
localiza un recurso dentro de la red, este recurso puede ser una pgina
web, un servicio o cualquier otra cosa. En resumen, el URL no es ms
que un nombre, que identifica una computadora, dentro de esa
computadora un archivo que indica el camino al recurso que se solicita.
HTTP (Hypertext Transfer Protocol), que es el protocolo encargado de
llevar la informacin que contiene una pgina Web por toda la red de
internet.
HTML (Hypertext Markup Language), es el lenguaje necesario cuya
funcionalidad es la de representar cualquier clase de informacin que se
encuentre almacenada en una pgina Web.
En la programacin web, el HTML es el lenguaje que permite codificar o
preparar documentos de hipertexto, que viene a ser el lenguaje comn para la
construccin de una pgina Web.
Las aplicaciones web residen en un servidor web como Apache, Internet
Information Server (IIS), etc., en cambio el cliente es un navegador web como
Internet Explorer, Google Chrome, Apple Safari, Mozilla Firefox, etc.


8 LENGUAJES DE PROGRAMACIN.
Es un conjunto de smbolos junto a un conjunto de reglas para combinar dichos
smbolos que se usan para escribir programas de computadoras que pueden
ser entendidos por ellas. Constan de un lxico, una sintaxis y una semntica.
Lxico: Conjunto de smbolos permitidos o vocabulario.
Sintaxis: Reglas que indican cmo realizar las construcciones del
lenguaje.
Semntica: Reglas que permiten determinar el significado de cualquier
construccin del lenguaje.
stos se clasifican en tres grandes categoras: mquina, bajo nivel
(ensamblador, o assembler) y alto nivel.
8.1 LENGUAJES DE MAQUINA.
Los lenguajes de mquina son aquellos cuyas instrucciones son directamente
entendibles por la computadora, y no necesitan traduccin posterior para que el
CPU pueda comprender y ejecutar el programa. La programacin en lenguaje
de mquina es difcil, ya que implica escribir directamente en un sistema binario
(ceros y unos), por eso se necesitan lenguajes que permitan simplificar ese
proceso.
8.2 LENGUAJES DE BAJO NIVEL.
Los lenguajes de bajo nivel fueron diseados con ese fin. stos son
dependientes de la arquitectura fsica de la computadora y de un conjunto
especfico de instrucciones para el CPU, y los programas escritos en ellos
deben ser traducidos a lenguaje mquina para poder ser ejecutados. Un
lenguaje tpico de bajo nivel es el lenguaje ensamblador (Assembler).
8.3 LENGUAJES DE ALTO NIVEL.
Los lenguajes de programacin de alto nivel son aquellos en los que las
instrucciones o sentencias a la computadora son escritas con palabras
similares a los lenguajes humanos en general lenguaje ingls lo que facilita
la escritura y comprensin por parte del programador. Una propiedad de los
lenguajes de alto nivel es que son independientes de la mquina, esto es, las
sentencias del programa no dependen del diseo de hardware de una
computadora especfica. Los programas escritos en lenguajes de alto nivel, al
igual que los escritos en lenguajes de bajo nivel, no son entendibles
directamente por la mquina, sino que necesitan ser traducidos a instrucciones

en lenguaje mquina que entiendan las computadoras. Los programas escritos
en un lenguaje de alto nivel se llaman Programas Fuente.
Existen diversos tipos de lenguajes de programacin de alto nivel, segn su
evolucin temporal y el uso que se les quiera dar. Algunos ejemplos de tipos de
lenguajes de alto nivel son:
Estructurados - procedimentales: Basic, C, Pascal, Cobol, Fortran,
etc.
Orientados a Objetos: SmallTalk, C#, Visual Basic.NET, C++, Java,
Objetive-C, etc.
Declarativos: Lisp, Prolog, etc.
Funcionales: AML, CAML, etc.
Dirigidos por eventos: Visual Basic, etc
De scripting:
o Lenguaje de control de tareas y shells: cmd.exe, csh, AppleScript,
sh, etc.
o GUI Scripting: AutoHotkey, AutoIt, Expect, Automator, etc.
o Lenguaje scripting de aplicaciones especficas: ActionScript en
Flash, MATLAB, mIRC, etc.
De programacin web: Del lado del servidor se tiene ASP
(Active Server Pages), JSP (JavaServer Pages), etc., y del
lado del cliente lenguajes como JavaScript, JScript,
VBScript, etc.
o Lenguajes de procesamiento de textos: AWK, Perl, sed, XSLT.
o Lenguajes dinmicos de propsito general: Groovy, Lisp, Perl,
PHP, Python, Ruby, etc.
Multiparadigma: Java, C#, Visual Basic.NET, C++, Delphi, PHP, Visual
Basic, etc.

8.4 COMPILACIN, COMPILADORES E INTRPRETES.

Los compiladores son programas se encargan de traducir lo que haya escrito
en lenguaje de alto nivel (cdigo o programa fuente) y lo convierten en un
programa llamado cdigo o programa objeto (casi ejecutable). El proceso de
traduccin de un programa fuente a un programa objeto se denomina
Compilacin.

8.4.1 COMPILADOR E INTRPRETE.
Compilador un programa que traduce un programa escrito en un lenguaje de
alto nivel, por ejemplo C++, en un programa en lenguaje de mquina que la
computadora es capaz de entender y ejecutar directamente. Un compilador es
un tipo especial de programa, en cuanto a que sus entradas o datos son algn
programa y su salida es otro programa. Para evitar confusiones, solemos
llamar programa fuente o cdigo fuente al programa de entrada, y programa
objeto o cdigo objeto a la versin traducida que el compilador produce. Cdigo
se usa frecuentemente para referirse a un programa o a una parte de l, sobre
todo cuando se habla de programas objeto.
El compilador, informa al usuario de la presencia de errores en el programa
fuente, pasndose a crear el programa objeto cuando est libre de errores. El
cdigo objeto puede ser ejecutado posteriormente. Una vez traducido un
programa, su ejecucin es independiente de su compilacin. Involucra dos
pasos en su operacin:
Convertir cdigo fuente a objeto.
Ejecutar el cdigo objeto.
Al tener el cdigo objeto, el programa se ejecuta ms rpido.
En cambio, un intrprete permite que un programa fuente escrito en un
lenguaje vaya traducindose y ejecutndose directamente sentencia a
sentencia por la computadora. Convierte uno por uno los enunciados del cdigo

fuente a cdigo objeto antes de ser ejecutados. Convierte y ejecuta el
programa en lnea al mismo tiempo. Ejemplo: Basic estndar y JavaScript.
Las ventajas de los intrpretes son:
Resulta ms fcil localizar y corregir errores (depuracin de programas)
Son ms pedaggicos para aprender a programar.
El programa es ms fcil de desarrollar.
Para cada una de las lneas se ejecuta el siguiente proceso:
Anlisis de la instruccin de esa lnea.
Traduccin de esa lnea (si ya est correcta) a cdigo objeto.
Ejecucin de esa lnea.
Con el intrprete, cada vez que necesitamos ejecutar el programa tenemos que
volver a analizarlo porque no hay cdigo objeto.

Con el compilador, aunque ms lenta la traduccin, slo se realiza una vez.

9 LA LGICA COMO ASPECTO FUNDAMENTAL DE LA
PROGRAMACIN.
Es la capacidad de pensar racionalmente acerca de soluciones alternativas y
los resultados de aplicarlas, y por lo tanto, de hacer elecciones inteligentes.
Es el estudio crtico del razonamiento y tiene un valor terico y prctico.
Es el estudio de los mtodos y principios usados al distinguir entre los
argumentos correctos (buenos) y los argumentos incorrectos (malos).
En un sentido amplio, es el estudio del correcto razonamiento.
La lgica se remonta a la poca de Aristteles en el siglo IV antes de Cristo. En
lgica, Aristteles desarroll reglas para establecer un razonamiento
encadenado que, si se respetaban, no produciran nunca falsas conclusiones si
la reflexin parta de premisas verdaderas (reglas de validez). En el ejemplo
ms famoso, "Todos los humanos son mortales" y "Todos los griegos son
humanos", se llega a la conclusin vlida de que "Todos los griegos son
mortales"
9.1 QU ES LGICA?
Lgica Deductiva. Es la que se encarga de determinar la validez o
invalidez de los argumentos. Permite proporcionar la simbologa que nos

servir para facilitar el desarrollo de la capacidad de anlisis de problemas,
para obtener una solucin posible.
Argumentos. Cuando el razonamiento se expresa con palabras, recibe el
nombre de "argumento". Un argumento es un grupo cualquiera de
proposiciones o enunciados que forman premisas y conclusiones. Este
puede constar de varias premisas pero de una sola conclusin.
Premisas y Conclusin. Las premisas de un argumento son proposiciones
afirmadas como fundamento o razones para aceptar una conclusin. La
conclusin es la proposicin afirmada que se basa en las otras
proposiciones o premisas. Una proposicin puede ser premisa en un
argumento y conclusin en otro.
Por ejemplo: "Todos los hombres son mortales". Aparece como premisa en
el siguiente argumento:
"Todos los hombres son mortales"
"Scrates es un hombre"
"Por lo tanto, Scrates es mortal".
Y como conclusin en el siguiente argumento:
" Todos los animales son mortales"
"Todos los hombres son animales"
"Luego, todos los hombres son mortales"
Expresiones como "por tanto", "por lo cual", "de ello se deduce", sirven para
introducir la conclusin de un argumento, en tanto que "pues" y "porque" se
emplean para introducir las premisas.
Otro Ejemplo:
"Todos se aburren en la conferencia".
"Ninguno de los que se aburren presta atencin".
"Por consiguiente, ninguno de los asistentes est prestando atencin".

Hay dos condiciones que debe satisfacer un argumento para establecer la
verdad de su conclusin: Debe ser vlido y todas sus premisas deben ser
verdaderas.
Enunciado Simple: Es el que no contiene otro enunciado como parte
componente. Ej. "Las rosas son rojas"

Enunciado compuesto. Es el que se compone de varios enunciados.
Ej. "Las rosas son rojas y las violetas son azules". Cuando los
enunciados se unen por la conjuncin Y, se denominan
Enunciados conyuntos.
Cuando los enunciados se unen por el conector O, se denominan
Enunciados disyuntos. De aqu surgen las siguientes tablas de verdad:

Ejemplos de aplicacin de estas tablas de verdad:
Si A y B son valores verdaderos y P y Q son falsos, cul es el valor de
verdad de la siguiente expresin: not (A or B) and (P and not Q)
Solucin: Evaluamos primero los parntesis, comenzando con el
primero. En la tabla OR buscamos a qu equivalen Verdadero or
Verdadero (porque A y B son verdaderos segn el enunciado).
Obtenemos que es Verdadero. Como la expresin est negada, su valor
opuesto es Falso. Al evaluar el segundo parntesis, Q es falso y al
negarlo nos queda verdadero. Luego, si P es falso nos queda Falso and
Verdadero, y esto es igual a Falso.

10 REPRESENTACIN GRFICA DE LOS ALGORITMOS.
10.1 DESCRIPCIN NARRADA.

Este algoritmo es caracterizado porque sigue un proceso de ejecucin comn y
lgico, describiendo textualmente paso a paso cada una de las actividades a
realizar dentro de una actividad determinada.
Ejemplo: Algoritmo para asistir a clases:
1. Levantarse
2. Baarse
3. Vestirse
4. Desayunar
5. Cepillarse los dientes
6. Salir de casa
7. Tomar el autobs
8. Llegar a la Universidad
9. Buscar el aula
10. Ubicarse en un asiento

10.2 PSEUDOCDIGO.
Pseudo = falso. El pseudo cdigo no es realmente un cdigo sino una imitacin
y una versin abreviada de instrucciones reales para las computadoras. Es una
tcnica para diseo de programas que permite definir las estructuras de datos,
las operaciones que se aplicarn a los datos y la lgica que tendr el programa
de computadora para solucionar un determinado problema. Utiliza un
pseudolenguaje muy parecido a nuestro idioma, pero que respeta las
directrices y los elementos de los lenguajes de programacin. Se concibi para
superar las dos principales desventajas de los diagramas de flujo: lento de
crear y difcil de modificar sin un nuevo redibujo.
Ejemplo: Escribir un algoritmo que imprima en pantalla Hola Mundo.
Proceso HolaMundo
Escribir "Hola Mundo;
FinProceso

10.3 DIAGRAMAS DE FLUJO O FLUJOGRAMAS.
Son la representacin grfica de la solucin algortmica de un problema. Para
disearlos se utilizan determinados smbolos o figuras que representan una

accin dentro del procedimiento. Utilizan unos smbolos normalizados, con los
pasos del algoritmo escritos en el smbolo adecuado y los smbolos unidos con
flechas, denominadas lneas de flujo, que indican el orden en que los pasos
deben ser ejecutados.
Para su elaboracin se sigue las siguientes reglas:
1. Se escribe de arriba hacia abajo y de izquierda a derecha.
2. Siempre se usan flechas verticales u horizontales, jams curvas.
3. Evitar cruce de flujos.
4. En cada paso expresar una accin concreta.
La secuencia de un flujo normal en una solucin de un problema es:
1. Tiene un inicio.
2. Una lectura o entrada de datos.
3. El proceso de datos.
4. Una salida de informacin.
5. Un final
Ejemplo: Dibujar un diagrama de flujo que imprima en pantalla Hola Mundo.

Entre las ventajas de usar diagrama de flujos se tiene:
o Rpida comprensin de las relaciones.
o Anlisis efectivo de las diferentes secciones del programa.
o Pueden usarse como modelos de trabajo en el diseo de nuevos
programas o sistemas.
o Comunicacin con el usuario.

o Documentacin adecuada de los programas.
o Codificacin eficaz de los programas.
o Depuracin y pruebas ordenadas de programas

Entre las desventajas podemos anotar:
o Diagramas complejos y detallados suelen ser laboriosos en su
planteamiento y diseo.
o Acciones a seguir tras la salida de un smbolo de decisin, pueden ser
difciles de seguir si existen diferentes caminos.
o No existen normas fijas para la elaboracin de los diagramas de flujo
que permitan incluir todos los detalles que el usuario desee introducir.

10.4 INTRODUCCIN A UML (UNIFIED MODELING LANGUAGE).

UML es el lenguaje de modelado de sistemas de software ms conocido y
utilizado en la actualidad; est respaldado por el OMG (Object Management
Group). Es un lenguaje grfico para visualizar, especificar, construir y
documentar un sistema. UML ofrece un estndar para describir un "plano" del
sistema (modelo), incluyendo aspectos conceptuales tales como procesos de
negocio, funciones del sistema, y aspectos concretos como expresiones de
lenguajes de programacin, esquemas de bases de datos y componentes
reutilizables.
Es importante resaltar que UML es un "lenguaje de modelado" para especificar
o para describir mtodos o procesos. Se utiliza para definir un sistema, para
detallar los artefactos en el sistema y para documentar y construir. En otras
palabras, es el lenguaje en el que est descrito el modelo.
Hay que tener en cuenta que el estndar UML no define un proceso de
desarrollo especfico, tan solo se trata de una notacin, es decir, no es una
metodologa de desarrollo de software.
UML cuenta con varios tipos de diagramas, los cuales muestran diferentes
aspectos de las entidades representadas. Estos diagramas son:
10.4.1 DIAGRAMAS UML.
Diagramas de comportamiento. Permiten exhibir comportamientos de un
sistema o de los procesos de las organizaciones.
o Diagrama de caso de uso.

o Diagrama de actividad.
o Diagrama de estado.
o Diagrama de interaccin.
Diagramas de Interaccin. Es un subconjunto de los diagramas de
comportamiento que permiten enfatizar las interacciones entre los objetos.
o Diagrama de comunicaciones
o Diagrama de secuencia
o Diagrama de tiempo.
Diagramas de estructura. Muestran los elementos de una especificacin
que sean independientes del tiempo.
o Diagrama de clases.
o Diagrama de estructura.
o Diagrama de componentes.
o Diagrama despliegue.
o Diagrama de objeto
o Diagrama de paquetes.

11 ENTORNO DE PROGRAMACIN INTEGRADO (IDE).
Un entorno de programacin es un programa que contiene, adems del
compilador, utilitarios y herramientas. Estos elementos estn integrados, de
modo que pueden llamarse fcilmente uno a otros durante el proceso de
programacin.

Por este motivo, a los entornos de programacin frecuentemente se los
identifica con la sigla IDE (en ingls, Integrated Development Environment, o
Entorne de programacin integrado).
Un entorno de programacin tpico contiene:
Un editor, que proporciona el medio para introducir el texto y los
smbolos que constituyen el cdigo fuente
Un intrprete o un compilador, que convierte el cdigo fuente en
instrucciones que la computadora puede comprender y ejecutar.
Un depurador (o debugger), que ayuda a analizar y corregir errores
en tiempo de ejecucin.
Ayuda (manuales, tutoriales, ejemplos, etc.) integrada.
El proceso de diseo, codificacin, depuracin y ejecucin de un programa es
mucho ms fcil y rpido cuando se utiliza un buen entorno de programacin.
Ejemplos de entorno de programacin son: Microsoft Visual Studio, Eclipse,
NetBeans.

Nuestro objetivo ahora es escribir algoritmos en pseudocdigo y en diagramas
de flujo, para ello usaremos las herramientas PSeInt y JTraductor aunque no
son propiamente IDEs. PSeInt es una herramienta en donde se escribe
algoritmos en pseudocdigo, genera un diagrama de flujo y lo convierte en un
programa C++, permite ejecutar el algoritmo paso a paso controlando la
velocidad e inspeccionando expresiones, en cambio, JTraductor genera un
programa Java. PSeInt es un software con varios aos de creacin, en cambio
JTraductor se basa en PSeInt pero es de reciente creacin.

12 PROGRAMACIN ESTRUCTURADA.
Recordemos que Programacin Estructurada es una tcnica en la cual la
estructura de un programa se lo realiza tan claramente como es posible
mediante el uso de tres estructuras de control:
Secuenciales: Sucesin simple de dos o ms operaciones (una tras
otra).
Selectivas o Condicionales: Bifurcacin condicional de una o ms
operaciones.
Repetitivas o Iterativas: Repeticin de una operacin mientras se
cumple una condicin.
Escribiremos los algoritmos bajo el paradigma de la programacin estructurada,
para ello usaremos un pseudolenguaje cuyas caractersticas son:
Sintaxis sencilla (sin la complejidad de los lenguajes de programacin).
Manejo de las estructuras bsicas de control.
Slo 3 tipos de datos bsicos:

o
Numrico: Nmeros, tanto enteros como reales. Para separar
decimales se utiliza el punto. Ejemplos: 12 23 0 -2.3 3.14
o
Lgico: Slo puede tomar dos valores: VERDADERO o FALSO.
o
Caracter: Caracteres o cadenas de caracteres encerrados entre
comillas (pueden ser dobles o simples). Ejemplos 'hola' "hola
mundo" '123' 'FALSO' 'etc'. (generalmente se usa comillas simples
para un carcter y dobles para cadena de caracteres o texto)
Estructuras de datos: Arreglos.

Todo algoritmo en pseudocgido tiene la siguiente estructura general:
Proceso <NombrePrograma>
<accin 1>;
<accin 2>;

.
.
.
<accin n>;
FinProceso

Se inicia con la palabra clave Proceso seguida del nombre del programa, luego
le sigue una secuencia de instrucciones (acciones) y finaliza con la palabra
FinProceso. Una secuencia de instrucciones es una lista de una o ms
instrucciones, cada una terminada en punto y coma. No puede haber
instrucciones fuera del proceso, aunque si comentarios.

Las acciones incluyen operaciones de entrada y salida, asignaciones de
variables, condicionales si-entonces o de seleccin mltiple y/o lazos mientras,
repetir o para.

Se pueden introducir comentarios luego de una instruccin, o en lneas
separadas, mediante el uso de la doble barra ( // ). Todo lo que precede a //,
hasta el fin de la lnea, no ser tomado en cuenta al interpretar el algoritmo. No
puede haber instrucciones fuera del programa, aunque si comentarios.

Las estructuras no secuenciales pueden anidarse. Es decir, pueden contener
otras adentro, pero la estructura contenida debe comenzar y finalizar dentro de
la contenedora.

En diagrama de flujo en cambio se usa la siguiente estructura general para
diagramar algoritmos:

Constantes e identificadores.
o Los identificadores deben constar slo de letras y nmeros,
comenzando siempre con una letra.

o
Las constantes de tipo carcter se escriben entre comillas ( " ).

o En las constantes numricas, el punto ( . ) es el separador decimal.

Inicio
Fin
Acciones

o Las constates lgicas son Verdadero y Falso.

Definicin de variables.
La instruccin Definir permite explicitar el tipo de una o ms variables. Esta
definicin puede ser opcional u obligatoria, aunque la asignacin de tipos a
los datos tiene dos objetivos principales:

1- Detectar errores de operaciones en los programas durante la fase de
codificacin.
2- Determinar cmo se ejecutarn las operaciones entre datos.
Una operacin de suma no tiene sentido con caracteres de texto, slo con
nmeros. Por consiguiente, si el compilador detecta una operacin de suma
de dos caracteres normalmente producir un error. Incluso entre tipos
numricos la operacin de suma se almacena de modo distinto, ya que los
nmeros enteros y los reales se almacenan de formas distintas en memoria.
A menos que el programa conozca los tipos de datos no puede ejecutar
correctamente la operacin de suma.
A los lenguajes que exigen que todos los datos utilizados deban tener sus
tipos declarados explcitamente se los conoce como fuertemente tipados.
El tipo de un dato puede ser convertido bajo ciertas condiciones a otro tipo.
Este mecanismo explcito de conversin de tipos de datos se suele
denominar CAST.
La sintaxis es:

Definir <var1> , <var2> , , <varN> Como [Real/Entero/Logico/Caracter] ;

Una variable debe ser definida antes de ser utilizada por primera vez.

Ejemplo:
Definir var Como Real; // se define la variable var como Real
Definir acumulador Como Entero; // acumulador es una variable Entero

Asignacin.

La instruccin de asignacin permite almacenar un valor en una variable.

<variable> <- <expresin> ;

Al ejecutarse la asignacin, primero se evala la expresin de la derecha y
luego se asigna el resultado a la variable de la izquierda. El tipo de la
variable y el de la expresin deben coincidir.

Ejemplo:
var<-1.0; // asigna 1.0 a var
acumulador<-acumulador +1; // incrementa en 1 el acumulador
Entradas.

La instruccin Leer permite ingresar informacin desde el ambiente.

Leer <variablel> , <variable2> , ... ,<variableN> ;

Esta instruccin lee N valores desde el ambiente (en este caso el teclado) y
los asigna a las N variables mencionadas. Pueden incluirse una o ms
variables, por lo tanto el comando leer uno o ms valores.

Ejemplo:
Leer cantidad;
Leer valor1, valor2, valor3;
Salidas.

La instruccin Escribir permite mostrar valores al ambiente.

Escribir <exprl> , <expr2> , ... , <exprN> ;

Esta instruccin imprime al ambiente (en este caso en la pantalla) los
valores obtenidos de evaluar N expresiones. Dado que puede incluir una o
ms expresiones, mostrar uno o ms valores.

Ejemplo:
Escribir Ingrese el nombre: ;
Escribir El Resultado es: , resp*2 ;

Arreglos.
Los arreglos son estructuras de datos homogneas (todos sus datos son del
mismo tipo) que permiten almacenar un determinado nmero de datos bajo
un mismo identificador, para luego referirse a los mismos utilizando uno o
ms subndices.
Para utilizar un arreglo, primero es obligatorio su dimensionamiento, es
decir, definirlo declarando los rangos de sus subndices, lo cual determina
cuantos elementos se almacenarn y como se acceder a los mismos,
Dimensionamiento.
Pseudocdigo:
La instruccin Dimension permite definir un arreglo, indicando sus
dimensiones.

Dimension <identificador> (<max1>,...,<maxN>);

Esta instruccin define un arreglo con el nombre indicado en
<indentificador> y N dimensiones. Los N parmetros indican la cantidad de
dimensiones y el valor mximo de cada una de ellas. La cantidad de
dimensiones puede ser una o ms, y la mxima cantidad de elementos
debe ser una expresin numrica positiva.

Se pueden definir ms de un arreglo en una misma instruccin,
separndolos con una coma (,).

Dimension <ident1>
(<max11>,..,<max1N>),..,<identM>(<maxM1>,..,<maxMN>);

Es importante notar que es necesario definir un arreglo antes de utilizarlo.

Ejemplo:
Definir vector, matriz Como Entero;
Dimension vector[100], matriz[10,20];

Diagrama de flujo: El grfico que se usa en diagrama de flujo para la
definicin de variables y dimensionamiento de arreglos es el mismo que se
utiliza para la asignacin.
Operadores y Funciones.
Este pseudolenguaje dispone de un conjunto bsico de operadores y
funciones que pueden ser utilizados para la construccin de expresiones
ms o menos complejas.

Las siguientes tablas exhiben la totalidad de los operadores de este
lenguaje reducido:

Operador Significado Ejemplo
Relacionales

> Mayor que 3>2
< Menor que 'ABC'<'abc'
= Igual que 4=3
<> Diferente que 4<>3
<= Menor o igual que 'a'<='b'
>= Mayor o igual que 4>=5
Lgicos

& Conjuncin (y / and). (7>4) & (2=1) //falso
| Disyuncin (o / or). (1=1 | 2=1) //verdadero
~ Negacin (no / not). ~(2<5) //falso
Algebraicos

+ Suma suma <- suma+1
* Multiplicacin area <- base * altura
- Resta stock <- disponible - venta
/ Divisin porc <- 100 * parte / total
^ Potenciacin sup <- 3.41 * radio ^ 2
%
Mdulo (resto de la
divisin entera)
resto <- num % 2

La jerarqua de los operadores matemticos es igual a la del lgebra,
aunque puede alterarse mediante el uso de parntesis.
A continuacin se listan las funciones integradas disponibles:

Funcin Significado
RC(X) o RAIZ(X) Raz Cuadrada de X
ABS(X) Valor Absoluto de X
LN(X) Logaritmo Natural de X
EXP(X) Funcin Exponencial de X
SEN(X) Seno de X
COS(X) Coseno de X
ATAN(X) Arcotangente de X

TRUNC(X) Parte entera de X
REDON(X) Entero ms cercano a X
AZAR(X) Entero aleatorio entre 0 y x-1

Como habamos mencionado anteriormente, un problema se puede dividir en
acciones elementales o instrucciones, usando un nmero limitado de
estructuras de control (bsicas) y sus combinaciones que pueden servir para
resolver dicho problema

12.1 ESTRUCTURA SECUENCIAL.
Se caracteriza porque una accin se ejecuta detrs de otra. El flujo del
programa coincide con el orden fsico en el que se han ido poniendo las
instrucciones.
Dentro de este tipo podemos encontrar operaciones de inicio/fin, inicializacin
de variables, operaciones de asignacin, clculo, sumarizacin, etc. Este tipo
de estructura se basa en las 5 fases de que consta todo algoritmo o programa:
1. Definicin de variables (Declaracin)
2. Inicializacin de variables.
3. Lectura de datos.
4. Clculo.
5. Salida.
Ejemplo 1: Se desea encontrar la longitud y el rea de un crculo de radio
ingresado por teclado.
Solucin. El objetivo del ejercicio es encontrar la longitud y el rea de un
crculo con un radio ingresado por teclado. Las salidas sern entonces la
longitud y el rea. (Fase 5 del algoritmo) Sabemos que la longitud de un crculo
viene dada por la frmula 2 * pi * radio y que el rea viene dada por pi * radio al
cuadrado. (Fase 4 del algoritmo) Si definimos las variables como: (fase 1 del
algoritmo)
long = Longitud, area = rea, radio = radio, pi = 3.1416, hagamos el
algoritmo:
Pseudocdigo:

Proceso Algoritmo1
//este algoritmo calcula el rea y la longitud de un crculo de radio ingresado
por teclado
Definir pi, radio, area, long Como Real; //definicin de variables
pi <- 3.1416; //definicin de un valor constante
Escribir "Ingrese el radio: "; //despliega en pantalla
Leer radio; //Ingresa por teclado el radio
area <- pi * radio ^ 2; //asignacin del valor del rea
long <- 2 * pi * radio ;//asignacin del valor de la longitud
Escribir "Area: ", area, " Longitud: ", long; //salida del algoritmo
FinProceso

Diagrama de Flujo:

Ejemplo 2. Leer el sueldo de tres empleados y aplicarles un aumento del 10,
12 y 15% respectivamente. Desplegar el resultado.
Solucin.
Salidas: Sueldos finales.
Entradas: Salarios de los empleados.
Datos adicionales: aumentos del 10, 12 y 15%
Clculos:
Sueldo final = sueldo inicial * (1+porcentaje/100)
Definicin de variables:
sueldoFinal1, sueldoFinal2, sueldoFinal3 = los sueldos finales
sueldo1, sueldo2, sueldo3 = salarios de los empleados

Pseudocdigo:

Proceso Algoritmo2
//Leer el sueldo de tres empleados y aplica un aumento del 10, 12 y
//15% respectivamente
Definir sueldo1,sueldo2,sueldo3 Como Real; //definicin de variables
Definir sueldoFinal1, sueldoFinal2, sueldoFinal3 Como Real;
sueldo1 <- 0; //inicializamos variables
sueldo2 <- 0;
sueldo3 <- 0;
sueldoFinal1 <- 0;
sueldoFinal2 <- 0;
sueldoFinal3 <- 0;
Escribir "Ingrese el sueldo de los 3 empleados";
Leer sueldo1,sueldo2,sueldo3; //lee los sueldos
sueldoFinal1 <- sueldo1 * 1.10; //incrementa el 10% al sueldo original
//y lo asigna en sueldoFinal1
Escribir "Sueldos incrementados: ",sueldoFinal1," ",sueldoFinal2,"
",sueldoFinal3;
FinProceso

Diagrama de flujo:

Otras Acciones Secuenciales.

En PSeInt, La instruccin "Borrar Pantalla" (o "Limpiar Pantalla") permite,
como su nombre lo indica, borrar la pantalla y colocar el cursor en la esquina
superior izquierda.
Ejemplo:
Borrar Pantalla;
La instruccin "Esperar Tecla" detiene su algoritmo hasta que el usuario
presione una tecla cualquiera de su teclado.
Ejemplo:
Esperar Tecla;
La instruccin "Esperar" tambin puede utilizarse para pausar el algoritmo
durante un intervalo de tiempo predefinido, indicando a continuacin de la
palabra clave la longitud y unidad de dicho intervalo. Las unidades vlidas son
Segundos y Milisegundos.
Ejemplo:
Esperar 3 Segundos;

12.2 ESTRUCTURAS SELECTIVAS O CONDICIONALES.

Con frecuencia nos enfrentamos a situaciones en las que se deben
proporcionar instrucciones alternativas que pueden o no ejecutarse
dependiendo de los datos de entrada, reflejando el cumplimiento o no de una
determinada condicin. La realizacin de acciones alternativas o decisiones se
especifican utilizando condiciones que son verdaderas o falsas. Estas
condiciones se llaman expresiones lgicas, o booleanas. Dado que las
expresiones lgicas toman el valor verdadero o falso, se necesita una
sentencia de control que dirija a la computadora a ejecutar una sentencia si la
expresin es verdadera, y otra sentencia en caso de que sea falsa.

12.2.1 ESTRUCTURA SELECTIVA SI-ENTONCES (IF-THEN).

La siguiente figura muestra el diagrama de flujo de la estructura Si-Entonces:

EL pseudocdigo es:
Si <condicin>
Entonces
<instrucciones>
Sino
<instrucciones>
FinSi

La estructura Si funciona de la siguiente manera:
1. Se evala la expresin lgica.
2. Si la expresin toma el valor verdadero (true), se ejecutar la sentencia
A y el control pasar a la sentencia inmediatamente siguiente.
3. Si la expresin toma el valor falso (false), entonces slo se ejecutar la
sentencia B y el control pasa de nuevo inmediatamente a la siguiente
sentencia del programa. La clusula sino (else) es optativa, en ese caso,
si la condicin es falsa no se ejecuta ninguna instruccin y la ejecucin
del programa contina con la instruccin siguiente.
.
Ejemplo 3. Construir un algoritmo que lea la calificacin de un alumno en un
examen, escriba "Aprobado" en caso que esa calificacin fuese mayor o igual
que 7.

Solucin.
Salidas: Mensaje de aprobado si se cumple la condicin.
Entradas: Calificacin.
Datos adicionales: Un alumno aprueba si la calificacin es mayor o igual
que 7.
Variables:
Cal = calificacin


Pseudocdigo:
Proceso Algoritmo3
//lee la calificacin de un alumno y escribe "Aprobado" si es mayor o
//igual que 7
Definir cal Como Real; //declaro la variable
Escribir "Ingrese la calificacin del alumno: ";
Leer cal;
Si cal>=7 Entonces
Escribir "Aprobado";
FinSi
FinProceso.

Diagrama de flujo:

Ejemplo 4. Dada la calificacin de un alumno en un examen, escriba
"Aprobado" si su calificacin es mayor o igual que 7 y "Reprobado" en caso
contrario.
Pseudocdigo:
Proceso Algoritmo3
//escribe "Aprobado" si es mayor o igual que 7 o "Reprobado" caso
//contrario
Definir cal Como Real; //declaro la variable
Escribir "Ingrese la calificacin del alumno: ";
Leer cal;
Si cal>=7 Entonces

Escribir "Aprobado";
Sino
Escribir "Reprobado";
FinSi
FinProceso

Diagrama de flujo:

Ejemplo 5. Dado como dato el sueldo de un trabajador, aplicar un aumento
del 15% si su sueldo es inferior a $1000 y 12% en caso contrario, luego
imprimir el nuevo sueldo del trabajador.
Pseudocdigo:

Proceso Algoritmo5
//aumento el 15% si su sueldo es inferior a $1000 y 12% en caso
//contrario
Definir sueldo, nuevoSueldo Como Real; //declaro la variable
Escribir "Ingrese el sueldo del trabajador: ";
Leer sueldo;
Si sueldo<1000 Entonces
NuevoSueldo <- sueldo*1.15;
Sino
NuevoSueldo <- sueldo*1.12;
FinSi
Escribir "El nuevo sueldo es: ", nuevoSueldo;
FinProceso

Diagrama de flujo:

12.2.2 EXPRESIONES LGICAS.
Sirven para plantear alternativas o decisiones y dan como resultado un valor
booleano verdadero o falso, es decir, se cumple o no se cumple la condicin.
Se pueden clasificar en simples y complejas. Las simples son las que usan
operadores relacionales y las complejas las que usan operadores lgicos.
Ejemplo 6: Operador lgico Y (&): Una escuela aplica dos exmenes a sus
aspirantes, por lo que cada uno de ellos obtiene dos calificaciones denotadas
como calif1 y calif2. El aspirante que obtenga calificaciones mayores o iguales
que 7 en ambos exmenes es aceptado; en caso contrario es rechazado.
Pseudocdigo:

Proceso Algoritmo6
//escribe aceptado si las 2 calificaciones son >= que 7, caso contrario
//es rechazado
Definir calif1, calif2 Como Real;
Escribir "Ingrese la nota 1: ";
Leer calif1;
Leer calif2;
Si ((calif1>=7) & (calif2>=7)) Entonces
Escribir "Estudiante aceptado";
Sino
Escribir "Estudiante rechazado";
FinSi
FinProceso

Diagrama de flujo:

En este ejemplo, ntese que tambin se usa operadores relacionales. Por lo
general cuando hay operadores lgicos, stos van acompaados de
operadores relacionales.
Ejemplo 7: Operador lgico O (|): Una escuela aplica dos exmenes a sus
aspirantes, por lo que cada uno de ellos obtiene dos calificaciones denotadas
como calif1 y calif2. El aspirante que obtenga una calificacin mayor o igual
que 9 en cualquiera de los exmenes es aceptado; en caso contrario es
rechazado.
Pseudocdigo:
Proceso Algoritmo7
//escribe aceptado si una de las 2 calificaciones es >= que 9, caso
//contrario es rechazado

Definir calif1, calif2 Como Real;
Leer calif1;
Leer calif2;
Si ((calif1>=9) | (calif2>=9)) Entonces
Escribir "Estudiante aceptado";
Sino
Escribir "Estudiante rechazado";
FinSi
FinProceso

Diagrama de flujo:

La instruccin del ejemplo 7 equivale a OR ya que nos dice que puede ser en
cualquiera de los exmenes no necesariamente en los dos. En ejemplo 6 la
palabra ambos equivale a seleccionar la instruccin AND. Si la instruccin nos
dijera que obtenga una nota en cualquiera de los exmenes pero no en ambos,
nos estara indicando una instruccin XOR que es un tipo de OR pero
exclusivo. Es decir, no puede considerarse el caso en que tenga la misma
nota en los dos exmenes, solo en uno de los dos.


12.2.3 ESTRUCTURAS ANIDADAS.
Recordemos que las estructuras no secuenciales se pueden anidar, es decir,
pueden contener otras adentro, pero la estructura contenida debe comenzar y
finalizar dentro de la contenedora.
En la solucin de problemas encontramos numerosos casos en los que luego
de tomar una decisin y marcar el camino correspondiente a seguir, es
necesario tomar otra decisin. Dicho proceso puede repetirse numerosas
veces. En los problemas en donde un bloque condicional incluye otro
bloque condicional se dice que un bloque est anidado dentro del otro.
Ejemplo 8. Determinar la cantidad de dinero que recibir un trabajador por
concepto de las horas extras trabajadas en una empresa, sabiendo que cuando
las horas de trabajo exceden de 40, el resto se consideran horas extras y que
stas se pagan al doble de una hora normal cuando no exceden de 8; si las
horas extras exceden de 8 se pagan las primeras 8 al doble de lo que se paga
por una hora normal y el resto al triple.
Solucin. Lo primero que hay que determinar es si el trabajador trabaj horas
extras o no. Encontrar las horas extras de la siguiente forma:
Horas extras = horas trabajadas - 40
En caso que s trabaj horas extras:
Si horas extras > 8 entonces a horas extras excedentes de 8 = horas extras
-8 y pago por horas extras = pago por hora normal * 2 * 8 + pago por hora
normal * 3 * horas extras excedentes de 8
De otra forma (slo horas al doble) pago por horas extras = pago por hora
normal * 2 * horas extras.
Finalmente, pago total que recibir el trabajador ser:
Pago = pago * hora normal * 40 + pago por horas extras.
Si no trabaj horas extras tendremos:
Pago = pago por hora normal * horas trabajadas.
Datos de salida: Pago.
Datos de entrada: nmero de horas trabajadas y pago por hora normal.
Definicin de variables:
ht = horas trabajadas
het = horas extras que exceden de 8
ph = pago por hora normal
phe = pago por horas extras
he = horas extras

pt = pago que recibe el trabajador
Pseudocdigo:
Proceso Algoritmo8
Definir he, het, ht Como Entero; //variable de horas trabajadas
Definir ph, phe, pt Como Real; //variables para pago
Escribir "Ingrese las horas trabajadas: ";
Leer ht;
Escribir "Ingrese el valor por hora normal: ";
Leer ph;
Si ht > 40 entonces
//determinamos las horas extras
he <- ht - 40;
Si he > 8 entonces
//determinamos las horas a pagar al triple
het <- he - 8;
//las 8 se pagan al doble y el resto al triple
phe <- ph * 2 * 8 + ph * 3 * het;
Sino
//se pagan al doble
phe <- ph * 2 * he;
FinSi
//pago horas normales ms horas extras
pt <- ph * 40 + phe;
Sino

//no hay horas extras
pt <- ph * ht;
FinSi
Escribir "El valor a pagar es: ", pt;
FinProceso

Diagrama de flujo:


Ejemplo 9. Dados los datos A, B y C que representan nmeros enteros
diferentes, construir un algoritmo para escribir estos nmeros en forma
descendente. Este es un ejemplo de los algoritmos conocidos como de Lgica
Pura, ya que poseen muchas decisiones y muchas bifurcaciones.
Observacin: Para ordenar nmeros no es un algoritmo eficiente, pero nos
sirve para ejemplarizar estructuras anidadas.
Solucin:
Salida: A, B y C ordenados descendentemente.
Entradas: A, B y C.
La dinmica del problema es comparar dos nmeros a la vez para
conocer cul es el mayor.
Pseudocdigo:
Proceso Algoritmo9
//ordenar 3 nmeros de mayor a menor
Definir a,b,c Como Entero;
Escribir "Ingrese 3 nmeros: ";
Leer a,b,c;
Escribir "Los nmeros ordenados descendentemente son: ";
Si a>b Entonces
Si a>c Entonces
Si b>c Entonces
Escribir a," ",b," ",c;
Sino
Escribir a," ",c," ",b;
FinSi
Sino
Escribir c," ",a," ",b;

FinSi
Sino
Si b>c Entonces
Si a>c Entonces
Escribir b," ",a," ",c;
Sino
Escribir b," ",c," ",a;
FinSi
Sino
Escribir c," ",b," ",a;
FinSi
FinSi
FinProceso

Diagrama de flujo:


12.2.4 ESTRUCTURA DE SELECCIN MLTIPLE SEGN (CASE).
Con frecuencia es necesario que existan ms de dos elecciones posibles. Este
problema se podra resolver por estructuras selectivas anidadas o en cascada,
pero si el nmero de alternativas es grande puede plantear serios problemas
de escritura y de legibilidad.
Usando la estructura de decisin mltiple se evaluar una expresin que podr
tomar n valores distintos, 1, 2, 3,,n y segn que elija uno de estos valores en
la condicin, se realizar una de las n acciones o lo que es igual, el flujo del
algoritmo seguir slo un determinado camino entre los n posibles.
Esta estructura se representa por un selector el cual si toma el valor 1 ejecutar
la accin A, si toma el valor 2 ejecutar la accin B, si toma el valor N realizar
la accin N.
La estructura de seleccin mltiple se implementa con la sentencia Segn,
cuyo diagrama de flujo y pseudocdigo son:
Diagrama de flujo:

Pseudocdigo:

Segun <variable> Hacer
<nmero1>: <instrucciones>
<nmero2>,<nmero3>: <instrucciones>
<...>
De Otro Modo: <instrucciones>
FinSegun


Reglas:
Esta instruccin permite ejecutar opcionalmente varias acciones posibles
(distintas entre si), dependiendo del valor almacenado en una variable de
tipo numrico.
Al ejecutarse, se evala el contenido de la variable y se ejecuta la
secuencia de instrucciones asociada con dicho valor.
Cada opcin est formada por uno o ms nmeros separados por comas,
dos puntos y una secuencia de instrucciones.
Si una opcin incluye varios nmeros, la secuencia de instrucciones
asociada se debe ejecutar cuando el valor de la variable es uno de esos
nmeros.
Opcionalmente, se puede agregar una opcin final, denominada De Otro
Modo, cuya secuencia de instrucciones asociada se ejecutar slo si el
valor almacenado en la variable no coincide con ninguna de las opciones
anteriores.
Ejemplo 10: Escribir un algoritmo tal que si opc=1 realice la suma, si opc=2, el
producto, si opc=3, la divisin y 0 en cualquier otro caso, despliegue el
resultado:
Pseudocdigo:
//Ejemplo de estructura Segun
Proceso Algoritmo10
Definir num1,num2, opc Como Entero;
Definir resp Como Real;
resp <-0;
Escribir "Ingrese una opcin: 1 (Suma), 2 (Producto), 3 (Divisin) :";
Leer opc;
Escribir "Ingrese los dos nmeros a operar: ";
Leer num1,num2;
Segun opc Hacer

1:
resp <- num1+num2;
2:
resp <- num1*num2;
3:
Si num2=0 Entonces
Escribir "El denominador no puede ser 0";
Sino
resp <- num1/num2;
FinSi
De Otro Modo:
resp <- 0;
FinSegun
Escribir "El resultado es : ",resp;
FinProceso

Diagrama de Flujo:

Ejemplo 11. Dados como datos la categora y el sueldo de un trabajador,
calcule el aumento correspondiente teniendo en cuenta la siguiente tabla.
Imprimir la categora del trabajador y el nuevo sueldo.

Incrementos
Categora Aumento
1 15%
2 10%
3 8%
4 7%

Pseudocdigo:
Proceso Algoritmo11
//ejemplo de estructura Segun
Definir cat Como Entero;
Definir sueldo, inc, nuevoSueldo Como Real;
Escribir "Ingrese la categora : ";
Leer cat;
Escribir "Ingrese el sueldo : ";
Leer sueldo;
Segun cat Hacer
1:
inc <- sueldo*0.15;
2:
inc <- sueldo*0.1;
3:
inc <- sueldo*0.08;
4:
inc <- sueldo*0.07;
De Otro Modo:
inc<- 0;
FinSegun
nuevoSueldo <- sueldo + inc;
Escribir "Categora : ",cat,", nuevo sueldo: ",nuevoSueldo;
FinProceso

Diagrama de Flujo:

12.3 ESTRUCTURAS REPETITIVAS O ITERATIVAS.
Las computadoras estn especialmente preparadas para ejecutar tareas
repetidamente. Los clculos simples o la manipulacin de pequeos conjuntos
de datos se pueden realizar fcilmente a mano, pero las tareas grandes o
repetitivas son realizadas con mayor eficiencia por una computadora. Las
estructuras de control repetitivas son aquellas en las que una sentencia o
grupos de sentencias se repiten muchas veces. Este conjunto de sentencias se

denomina bucle, ciclo, lazo, o loop. Las acciones que se repiten en un bucle
constituyen el cuerpo del bucle, y cada repeticin del cuerpo del bucle se
denomina iteracin.
Las estructuras repetitivas bsicas son:
Estructura Para.
Estructura Mientras.
Estructura Repetir.

12.3.1 ESTRUCTURA REPETITIVA PARA (FOR).
En numerosas ocasiones se puede necesitar un bucle que se ejecute un
nmero determinado de veces, y cuyo nmero se conozca por anticipado. Para
aplicaciones de este tipo se utiliza la sentencia Para (for). Esta sentencia
requiere que conozcamos por anticipado el nmero de veces que se ejecutarn
las sentencias del interior del bucle.
En la siguiente figura se muestra el diagrama de flujo de la estructura Para:

El pseudocdigo es:

Para <variable> <- <inicial> Hasta <final> (Con Paso <paso>) Hacer
<instrucciones>
FinPara

Al ejecutarse la sentencia Para la primera vez, el valor <inicial> se asigna a la
variable <variable>, denominada variable de control, y a continuacin se
ejecuta las sentencias de instrucciones que forman el cuerpo del bucle. Al
llegar al final del bucle (FinPara), se incrementa la variable <variable> en

<paso> unidades y se verifica si el valor almacenado en <variable> es mayor
que el valor <final>; en caso negativo se vuelve a ejecutar todas las sentencias
del interior del bucle hasta que la variable de control <variable> sea mayor que
el valor final <final>. Algunos lenguajes permiten definir lo que se llama paso,
que es la cantidad de unidades en las que se incrementar o decrementar la
variable de control en cada iteracin. Si se omite la clusula Con Paso <paso>,
la variable <variable> se incrementar en uno.
Es comn usar en las estructuras repetitivas los contadores y acumuladores
que los describimos a continuacin:

12.3.1.1 CONTADOR.
Un contador es una variable cuyo valor se incrementa o decrementa en una
cantidad constante cada vez que se produce un determinado suceso o accin.
Los contadores se utilizan con la finalidad de contar sucesos o acciones
internas de un bucle; deben realizar una operacin de inicializacin y
posteriormente las sucesivas de incremento o decremento del mismo. La
inicializacin consiste en asignarle al contador un valor. Se situar antes y
fuera del bucle.

Representacin:
<nombre del contador> <- <nombre del contador> + <valor constante>;
Si en vez de incremento es decremento se coloca un menos en lugar del ms.

Ejemplo:
i <- i + 1;

12.3.1.2 ACUMULADOR O TOTALIZADOR.
Es una variable que suma sobre s misma un conjunto de valores para de esta
manera tener la suma de todos ellos en una sola variable. La diferencia entre
un contador y un acumulador es que mientras el primero va aumentando un
valor constante, el acumulador va aumentando en una cantidad variable.

Representacin:
<Nombre del acumulador> <- <nombre del acumulador> + <valor variable>;
Ejemplo 12. Calcular la suma de los cuadrados de los primeros 100 enteros y
escribir el resultado. Se desea resolver el problema usando estructura Para.

Pseudocdigo:
Proceso Algoritmo12
//Ejemplo estructura Para
Definir i,suma Como Entero;
//inicializo el acumulador
suma <- 0;
Para i<-1 Hasta 100 Con Paso 1 Hacer
suma <- suma + i*i;
FinPara
Escribir "La suma de los 100 primeros enteros es: ",suma;
FinProceso

Diagrama de flujo:

Ejemplo 13. Calcular la promedio de N nmeros enteros y escribir el resultado.
Pseudocdigo:
// Calcula el promedio de una lista de N datos
Proceso Algoritmo13
Definir i, numDatos Como Entero;
Definir acum, promedio, dato Como Real;
acum <- 0;
Escribir "Ingrese la cantidad de datos:";
Leer numDatos;


Para i<-1 Hasta numDatos Hacer
Escribir "Ingrese el dato ",i,": ";
Leer dato;
acum <- acum + dato;
FinPara

promedio <- acum / numDatos;
Escribir "El promedio es: ",promedio;
FinProceso

Diagrama de flujo:

12.3.2 ESTRUCTURA ITERATIVA MIENTRAS (WHILE).
La estructura iterativa Mientras es aquella en la que el nmero de iteraciones
no se conoce por anticipado y el cuerpo del bucle se repite mientras se cumple
una determinada condicin. Por esta razn, se lo conoce como bucle
condicional.
El diagrama de flujo y pseudocdigo de la estructura iterativa mientras son:
Diagrama de flujo:

Pseudocdigo:
Mientras <condicin> Hacer
<instrucciones>
FinMientras

Cuando la sentencia mientras se ejecuta, lo primero que sucede es la
evaluacin de la expresin lgica <condicin>. Si se evala como falsa,
ninguna accin se realiza y el programa sigue en la siguiente sentencia
despus del bucle. Si la expresin lgica se evala como verdadera, entonces
se ejecuta el cuerpo del bucle y se evala de nuevo la expresin lgica
<condicin>, es decir, se puede ejecutar el bucle, cero o ms veces. Este
proceso se repite mientras la expresin lgica sea verdadera. Despus de cada
iteracin la expresin lgica se evala y se verifica de nuevo; si cambia de
verdadera a falsa la sentencia mientras finaliza. Mientras que la condicin sea
verdadera el bucle se ejecutar. Esto significa que el bucle se ejecutar
indefinidamente a menos que algo en el interior del mismo modifique la
condicin haciendo que su valor pase a falso. Si la expresin nunca cambia de
valor, entonces el bucle no termina nunca y se denomina bucle o loop infinito
(en general, esta situacin no es deseable), a fin de evitarlo, las instrucciones
del cuerpo del bucle deben contener alguna instruccin que modifique la o las
variables involucradas en la expresin lgica <condicin>, de modo que sea
falsa en algn momento y as finalice la ejecucin del ciclo.


Ejemplo 14. Calcular la suma de los cuadrados de los primeros 100 nmeros
enteros y escribir el resultado.
Solucin. Como recordars, resolvimos este ejercicio en la leccin anterior
pero utilizando la estructura Para. Ahora lo haremos con la estructura Mientras.
En este caso, se necesita un contador (un ndice), para llevar la cuenta de las
veces que entramos al cuerpo del bucle. Tambin es importante notar que esta
variable se debe inicializar antes de entrar al cuerpo del ciclo y dentro del
cuerpo se incrementar en uno cada vez que ingrese a l.
Esta variable adems nos sirve para compararla con el valor dado en la
condicin, cuando no se cumple la condicin, se sale del ciclo.
Pseudocdigo:
//Ejemplo estructura Mientras
Proceso Algoritmo14
//inicializo el acumulador y el contador
suma <- 0;
i <- 1;

Mientras i<=100 Hacer
//sumo al acumulador
suma <- suma + i*i;
//incremento el contador
i <- i+1;
FinMientras


FinProceso

Diagrama de flujo:

En las estructuras cclicas condicionales es comn controlar los ciclos con
centinelas y banderas.

12.3.2.1 CENTINELAS.

En un bucle mientras controlado por tarea, la condicin mientras especifica que
el cuerpo del bucle debe continuar ejecutndose mientras la tarea no haya sido
completada, esto puede ser controlado por centinelas.
Centinelas son variables que toman valores adecuados para suspender el
ingreso a un bucle.
Por ejemplo, si se tienen las calificaciones de un test (comprendida entre 0 y
100); un valor centinela en esta lista puede ser -1, ya que nunca ser una
calificacin vlida y cuando aparezca este valor se terminar de ejecutar el
bucle. Si la lista de datos son nmeros positivos, un valor centinela puede ser
un nmero negativo.
Ejemplo 15. Suponga que debemos obtener la suma de los gastos que hicimos
en nuestro ltimo viaje, pero no sabemos exactamente cuntos fueron.
Solucin: Si definimos gasto1, gasto2, gasto3, ...., -1 donde gastoi es el gasto
nmero i y sumaGasto es el acumulador de gastos efectuados. -1 es el
centinela de fin de datos.
Pseudocdigo:
//Ejemplo de centinelas
Proceso Algoritmo15
Definir gasto, sumaGasto Como Real;
sumaGasto <- 0;
Escribir "Ingrese -1 para salir";
Escribir "Ingrese el gasto realizado: ";
//leemos gasto fuera del bucle mientras
Leer gasto;
Mientras gasto <> -1 Hacer
sumaGasto <- sumaGasto + gasto;
Escribir "Ingrese el gasto realizado: ";
Leer gasto;

FinMientras
Escribir "El gasto total es: ",sumaGasto;
FinProceso

Diagrama de flujo:


12.3.2.2 BANDERAS.
Conocidas tambin como interruptores, switch, flags o conmutadores, son
variables que pueden tomar solamente dos valores durante la ejecucin del
programa, los cuales pueden ser 0 1, o bien los valores booleanos True o
False. Se les suele llamar interruptores porque cuando toman los valores 0 1
estn simulando un interruptor abierto/cerrado o encendido/apagado.

Ejemplo 16: Leer un nmero entero N y calcular el resultado de la siguiente
serie: 1 - 1/2+ 1/3 - 1/4+.... +/- 1/N.

Pseudocdigo:
//Ejemplo de banderas
Proceso Algoritmo16
Definir bandera Como Logico;
Definir serie Como Real;
Definir i, num Como Entero;
serie <- 0;
i <- 1;
Escribir "Ingrese el valor de N: ";
Leer num;
//inicializamos la bandera
bandera <- Verdadero;
Mientras i <= num Hacer
Si bandera = Verdadero Entonces
serie <- serie + 1/i;
bandera <- Falso;
Sino
serie <- serie - 1/i;

bandera <- Verdadero;
FinSi
i <- i+1;
FinMientras
Escribir "La suma de la serie es: ",serie;
FinProceso

Diagrama de flujo:


12.3.3 ESTRUCTURA ITERATIVA REPETIR (REPEAT).

La estructura iterativa Repetir es una bucle condicional como lo es tambin la
estructura Mientras. Se usa cuando el nmero de iteraciones no se conoce por
anticipado (lo cual si se conoce en la estructura Para).
La diferencia entre ambas es que la condicin se sita al inicio (Mientras) o al
final (Repetir) de la secuencia de instrucciones. Entonces, en el primero, el
bucle contina mientras la condicin es verdadera (la cual se comprueba antes
de ejecutar la accin, es decir se ejecuta cero o ms veces) y en el segundo, el
bucle contina hasta que la condicin se hace verdadera (la condicin se
comprueba despus de ejecutar la accin, es decir, se ejecutar al menos una
vez).
El diagrama de flujo de la estructura Repetir es el siguiente:

El pseudocdigo de la estructura Repetir es:

Repetir
<instrucciones>
Hasta Que <condicin>

Al ejecutarse esta instruccin, la secuencia de instrucciones que forma el
cuerpo del ciclo se ejecuta una vez y luego se evala la condicin <condicin>.
Si la condicin es falsa, el cuerpo del ciclo se ejecuta nuevamente y se vuelve
a evaluar la condicin. Esto se repite hasta que la condicin sea verdadera.

Note que, dado que la condicin se evala al final, las instrucciones del cuerpo
del ciclo sern ejecutadas al menos una vez.

Adems, a fin de evitar ciclos infinitos, el cuerpo del ciclo debe contener alguna
instruccin que modifique la o las variables involucradas en la condicin de
modo que en algn momento la condicin sea verdadera y se finalice la
ejecucin del ciclo.

Un ciclo Repetir controlado por centinela, por ejemplo es cuando el usuario
digita una letra para salir como S o N para indicar si desea continuar o no. El
bucle debe repetirse hasta que la respuesta del usuario sea n o N. (Observe
que los centinelas solamente pueden usarse con las estructuras Mientras y
Repetir, no con estructuras Para).
Ejemplo 17: Calcular la suma de los cuadrados de los primeros 100 nmeros
enteros y escribir el resultado.
Solucin. Nuevamente resolveremos el ejercicio de las dos lecciones
anteriores, ahora utilizando la estructura Repetir.
Como sabemos, en los bucles condicionales podemos usar una variable
contador que debe inicializarse antes del ciclo e incrementarse dentro del bucle
para controlar el nmero de veces que se ingresar al mismo. A diferencia de
la estructura Mientras, la condicin ahora estar colocada al final del bucle para
que primero se ejecute la instruccin y luego se verifique si la condicin se
cumple. Esto quiere decir, que en esta estructura el bucle se realizar por lo
menos una vez. Tambin podrs observar que la condicin est al revs,
porque el bucle se repite hasta que la condicin se cumpla. En el bucle
Mientras, la condicin se evaluaba mientras era verdadera.
Pseudocdigo:
//Ejemplo estructura Repetir
Proceso Algoritmo17
//inicializo el acumulador y el contador
suma <- 0;
i <- 1;

Repetir
suma <- suma + i*i;
//incremento el contador

i <- i+1;
Hasta Que i>100

FinProceso

Diagrama de flujo:


Ejemplo 18. Se desea calcular la suma de N nmeros ingresados por el
usuario, hasta que l decida no ingresar ms nmeros.
Pseudocdigo:
//Ejemplo estructura Repetir con centinelas
Proceso Algoritmo18
Definir suma, num Como Real;;
Definir resp Como Caracter;
//inicializo acumulador
suma <- 0;
//inicializo la centinela

Repetir
Escribir "Ingrese un nmero: ";
Leer num;
suma <- suma + num;
//pregunto se desea continuar
Escribir "Desea ingresar otro nmero (S/N): ";
// leo la respuesta
Leer resp;
Hasta Que (resp='N' | resp='n')

Escribir "La suma es: ",suma;
FinProceso

Diagrama de flujo:

13 ESTRUCTURA DE DATOS Y ARREGLOS.

13.1 INTRODUCCIN.

Todas las variables que se han considerado hasta ahora son de tipo simple.
Una variable de tipo simple consiste de una sola localidad o caja de memoria
y slo puede contener un valor a la vez. Una variable de tipo estructurado
consiste en toda una coleccin de casillas de memoria. Los tipos de datos
estudiados: entero, real, carcter, lgico son considerados como datos de tipo
simple, puesto que una variable que se define con alguno de estos tipos slo
puede almacenar un valor a la vez, es decir, existe una relacin de uno a uno
entre la variable y el nmero de elementos (valores) que es capaz de
almacenar. En cambio un dato de tipo estructurado, puede almacenar ms de
un elemento (valor) a la vez, con la condicin de que todos los elementos
deben ser del mismo tipo, es decir, que se puede tener un conjunto de datos
enteros, reales, etc.

13.2 ESTRUCTURA DE DATOS.
Estructura de Datos es una coleccin de datos que se caracterizan por su
organizacin y las operaciones que se definen en ella. Las estructuras de datos
tienen en comn que un identificador o nombre, puede representar a mltiples
datos individuales.
Los datos de tipo estndar pueden ser organizados en diferentes estructuras
de datos: estticas y dinmicas.
Estructura de Datos Estticas. Son aquellas en las que se asigna una
cantidad fija de memoria cuando se declara la variable y no puede ser
modificada durante la ejecucin del programa. Corresponden a este tipo
los arreglos y registros.
Estructuras de Datos Dinmicas. Son aquellas en las que el espacio
ocupado en memoria puede ser modificado en tiempo de ejecucin.
Corresponden a este tipo las listas, rboles y grafos. Estas estructuras
no son soportadas en todos los lenguajes. La eleccin de la estructura
de datos idnea depender de la naturaleza del problema a resolver y,
en menor medida, del lenguaje.
13.3 ARREGLOS.

Un arreglo (o array) es una estructura de datos en la que se almacena una
coleccin de datos del mismo tipo (por ejemplo, los sueldos de los empleados
de una empresa). Dicho de otra forma, un arreglo y es una lista de un nmero
finito n de elementos del mismo tipo que se caracteriza por:
- Almacenar sus elementos en posiciones de memoria contiguas
- Tener un nico nombre de variable (por ejemplo salarios) que
representa a todos los elementos
- Permitir acceso directo o aleatorio a sus elementos individuales,
para ello se utiliza un ndice que especifique la posicin relativa
en el arreglo.
En resumen, un arreglo es una coleccin finita, homognea y ordenada de
elementos.
Finita. Todo arreglo tiene un lmite, es decir, debe determinarse cul
ser el nmero mximo de elementos que podrn formar parte del
arreglo.
Homognea. Todos los elementos del arreglo deben ser del mismo tipo.
Ordenada: Se puede determinar cul es el primer elemento, el segundo,
el tercero,.... y el n-simo elemento.
Los arreglos se clasifican de acuerdo con el nmero de dimensiones que
tienen. As se tienen los arreglos:
Unidimensionales (vectores).
Bidimensionales (tablas o matrices).
Multidimensionales (tres o ms dimensiones).


Ejemplo.
Suponga que se desea desarrollar un programa para:
1. Leer una lista de calificaciones de un examen.
2. Encontrar su media.
3. Escribir una lista de las calificaciones mayores que la media.
4. Ordenar la lista de las calificaciones en orden ascendente.
Supongamos tambin que hay 100 calificaciones. Con lo estudiado hasta el
momento, deberamos utilizar 100 variables diferentes nota1, nota2, ....,
nota100, de ese modo son 100 direcciones diferentes de memoria para
almacenar las calificaciones del examen. Se imagina declarar las 100 variables,
cuntas instrucciones involucra?
Definir nota1, nota2, nota3,.........nota100 Como Entero;
(En la declaracin real de un algoritmo en pseudocdigo no pueden usarse
puntos suspensivos, por lo tanto sern 100 veces). En la fase de lectura de
datos, sern tambin 100 veces las instrucciones para ir leyendo cada valor.
Leer nota1, nota2, nota3,........., nota100;
Para calcular la media:
media (nota1+nota2+.......+nota100)/100;

Para la lista de calificaciones mayores que la media, deber tambin
compararse una por una:
Si nota1 > media Entonces
Escribir nota1;
FinSi
Escribir nota2;
FinSi

Escribir nota100;
FinSi

Y despus de muchsimas lneas de cdigo..... Todava falta ordenar la lista de
calificaciones en orden ascendente!

Los arreglos nos permiten ahorrar instrucciones, porque es fcil recorrer toda la
lista de notas con unas pocas instrucciones. En el caso anterior, cuando el
acceso a la informacin es secuencial, slo se puede acceder a un elemento
buscando desde el principio de la lista, y esto es algo lento. Lo que se necesita
es una estructura de acceso directo que permita almacenar y recuperar los
datos directamente especificando su posicin en la estructura, de esa manera
se requerir el mismo tiempo para acceder al elemento de la posicin 100 que
el de la posicin 5.
Queremos tambin que esta estructura se almacene en memoria principal para
que su almacenaje y recuperacin sea ms rpida. Es por ello que existen los
arreglos, que estn organizados en una secuencia de elementos, todos del
mismo tipo y se puede acceder a cada elemento directamente especificando su
posicin en esta secuencia.
Para poder utilizar un arreglo, debemos indicar su tipo, un nombre nico y su
dimensionamiento, es decir, declarar los rangos de sus ndices, lo cual
determina cuantos elementos se almacenarn y como se acceder a los
mismos. Al declarar un arreglo, se debe inicializar sus elementos antes de
utilizarlos
Definicin y Dimensionamiento.

La instruccin Dimension permite declarar un arreglo, indicando sus
dimensiones.
Dimesion <identificador> (<max1>,...,<maxN>);
Esta instruccin define un arreglo con el nombre indicado en <indentificador> y
N dimensiones. Los N parmetros indican la cantidad de dimensiones y el valor
mximo de cada una de ellas. La cantidad de dimensiones puede ser una o
ms, y la mxima cantidad de elementos debe ser una expresin numrica
positiva.
Se pueden definir ms de un arreglo en una misma instruccin, separndolos
con una coma (,).

Dimension <ident1>
(<max11>,..,<max1N>),..,<identM>(<maxM1>,..,<maxMN>);

Es importante notar que es necesario definir un arreglo antes de utilizarlo.

Ejemplo:
Definir vector, matriz Como Entero;
Dimension vector[100], matriz[10,20];

13.3.1 ARREGLO UNIDIMENSIONAL.
Un arreglo de una dimensin (tambin conocido como vector) es un tipo de
datos estructurado compuesto de un nmero de elementos finitos, tamao fijo y
elementos homogneos que se almacenan bajo un mismo nombre, y se
diferencian por la posicin que tiene cada elemento dentro del arreglo de datos.
Finitos indica que hay un ltimo elemento, tamao fijo significa que el tamao
del arreglo debe ser conocido en tiempo de compilacin y homogneo significa
que todos sus elementos son del mismo tipo.
Los elementos del arreglo se almacenan en posiciones contiguas de memoria,
a cada una de las cuales se puede acceder directamente mediante un nmero
entero denominado ndice del arreglo, que identifica la posicin del elemento
dentro del conjunto.
Generalmente los ndices de los elementos de los arreglos inician en 0, es
decir, si declaramos un arreglo de 100 elementos, los ndices de elementos
vlidos van de 0 a 99 (aunque existen lenguajes que inician los ndices de los
arreglos en 1).

vector[0]
vector[1]
vector[2]
..
vector[97]
vector[98]
vector[99]

13.3.1.1 PARTES DE UN ARREGLO.
Los componentes. Hacen referencia a los elementos que forman el
arreglo, es decir, a los valores que se almacenan en cada una de las
casillas del mismo.
Los ndices. Permiten hacer referencia a los componentes del arreglo en
forma individual, especifican cuntos elementos tendr el arreglo y adems,
de qu modo podrn accederse esos componentes.

valor
o

valor
1

valor
2

...
valor
97

valor
98

valor
99

Definicin y Dimensionamiento.
Ejemplo. Definir un arreglo llamado vector de 100 elementos de tipo Real.
Definir vector Como Real;
Dimension vector[100];
Componentes
ndice
vector[0]
vector[1]
vector[2]
..
vector[97]
vector[98]
vector[99]


13.3.1.2 OPERACIONES CON ARREGLOS.

Las operaciones que se pueden realizar con vectores durante el proceso de
resolucin de un problema son:
Lectura/ Escritura,
Asignacin.
Actualizacin (insercin, eliminacin, modificacin).
Recorrido (acceso secuencial).
Ordenacin.
Bsqueda.

Lectura. El proceso de lectura de un arreglo consiste en leer y asignar un
valor a cada uno de sus elementos. Normalmente se realizan con
estructuras repetitivas. Usamos los ndices para recorrer los elementos del
arreglo.
Ejemplo:
Para i <- 0 Hasta 99 Con Paso 1 Hacer
Leer vector[i];
FinPara
Escritura. Es similar al caso de lectura, slo que en lugar de leer el
componente del arreglo, lo escribimos.
Ejemplo:
Escribir vector[i];
FinPara
Asignacin. No es posible asignar directamente un valor a todo el arreglo;
sino que se debe asignar el valor deseado en cada componente. Podemos
recorrer el arreglo con una estructura repetitiva y asignar un valor a todos
los elementos del arreglo.
Ejemplo:
vector[1] <- 5; //asigna el valor 5 a la posicin 1 del arreglo vector

vector[10] <- vector[1] / 2; //asigna una operacin al arreglo vector
//Se puede asignar un valor constante a todos los elementos del vector
vector[i] <- 10;
FinPara
Inicializacin. Siempre es importante inicializar las variables y por lo tanto
tambin los arreglos. Por ejemplo, inicializar con 0 cada elemento del
arreglo.
Ejemplo:
vector[i] <- 0;
FinPara
Acceso Secuencial. (Recorrido). El acceso a los elementos de un vector
puede ser para leer en l o para escribir (visualizar su contenido). Recorrido
del vector es la accin de efectuar una accin general sobre todos los
elementos de ese vector.
Actualizacin. Incluye aadir (insertar), borrar o modificar algunos de los
ya existentes. Se debe tener en cuenta si el arreglo est o no ordenado.
Aadir datos a un vector consiste en agregar un nuevo elemento al final del
vector, siempre que haya espacio en memoria (recordemos que el tamao
de un arreglo es fijo).

Observacin. Las partes de un arreglo unidimensional y las operaciones son
las mismas que en los arreglos multidimensionales (pueden extenderse), salvo
que se trata de varias dimensiones y no slo de una.
Ejemplo19. Se desea ingresar una lista de 10 valores numricos y calcular la
suma, el promedio, los nmeros mayor y menor de dicha lista
Pseudocdigo:
//Ejemplo de arreglos
Proceso Algoritmo19

Definir lista, i, mayor, menor, suma, promedio Como Entero;
//defino el arreglo y su tamao
Dimension lista[10];
//inicializo variables
suma <- 0;
//inicializo el arreglo
lista[i] <- 0;
FinPara
//leo los elementos del arreglo
Escribir "Ingrese el valor ",(i+1)," de la lista: ";
Leer lista[i];
FinPara
//inicializo los nmeros mayor y menor con el primer
//elemento del arreglo
mayor <- lista[0];
menor <- mayor;
//calculo la suma recorriendo el arreglo
suma <- suma + lista[i];
FinPara
//calculo el promedio
promedio <- suma / 9;

//calculo los nmeros mayor y menor de la lista
Si lista[i] > mayor Entonces
mayor <- lista[i];
FinSi
Si lista[i] < menor Entonces
menor <- lista[i];
FinSi
FinPara
//presento los resultados
Escribir "Suma: ", suma, ", Promedio: ", promedio;
Escribir "Nmero mayor: ", mayor, ", Nmero menor: ", menor;
FinProceso
Diagrama de flujo:


Ejemplo 20. Ingresar una lista de nombres (la lista termina cuando se ingresa
un nombre en blanco), no se permite ingresar nombres repetidos y luego
ordenar y presentar la lista.
Pseudocdigo:
//Ordenamiento de un arreglo
Proceso Algoritmo20
Definir nombre,lista,aux Como Cadenas;
Definir seRepite Como Logico;
Definir cant,i,j,posMenor Como Enteros;
Dimension lista[200];
Escribir "Ingrese un nombre (enter en blanco para terminar):";
// leer la lista
cant <- 0;
Leer nombre;
Mientras nombre<>"" Hacer
Escribir "Ingrese un nombre: ";
lista[cant] <- nombre;
cant <- cant+1;
Repetir // leer un nombre y ver que no est ya en la lista
Leer nombre;
seRepite <- Falso;
//no es "" el nombre no se necesita buscar un repetido
Si nombre<>"" Entonces
Para i <- 0 Hasta cant-1 Hacer
Si nombre=lista[i] Entonces

seRepite <- Verdadero;
//salgo del bucle pues es ya
//repetido y no necesito seguir buscando
i <- cant;
Escribir "Nombre repetido";
Escribir "Ingrese un nombre: ";
FinSi
FinPara
FinSi
Hasta Que ~ seRepite
FinMientras
// ordenamos la lista
// busca el menor entre i y cant
posMenor <- i;
Para j <- i+1 Hasta cant-1 Hacer
Si lista[j] < lista[posMenor] Entonces
posMenor <- j;
FinSi
FinPara
// intercambia el que estaba en i con el menor que encontr
aux <- lista[i];
lista[i] <- lista[posMenor];
lista[posMenor] <- aux;

FinPara
// mostrar como queda la lista
Escribir "La lista ordenada en forma ascendente es:";
Escribir " ",lista[i];
FinPara
FinProceso

Diagrama de flujo:


13.3.2 ARREGLO BIDIMENSIONAL.
Hasta ahora hemos visto cmo se puede manipular informacin con una sola
columna o lista de entrada con los llamados vectores, o arreglos de una
dimensin. Sin embargo, en numerosas ocasiones es necesario trabajar con
datos que tengan ms de una dimensin (se representan por ejemplo como
tablas de doble entradas, cubos, etc.).
Un arreglo bidimensional (matriz o tabla) es un arreglo con dos ndices. Para
localizar o almacenar un valor en el arreglo se deben especificar dos
posiciones (dos subndices), uno para la fila y otro para la columna.
Internamente en memoria se reservan MxN posiciones consecutivas para
almacenar todos los elementos del arreglo.
Declaracin de una matriz.
Ejemplo: Definir una arreglo bidimensional de 10 filas y 20 columnas de
nmeros enteros llamado matriz.
Definir matriz Como Entero;
Dimension matriz[10,20];
Una matriz se representa como una tabla, donde: 1<=I<=M y 1<=J<=N
(observe que al igual que en los vectores, las filas y columnas de las matrices
inician en 0).
1 2 J N
1 matriz[0,0] matriz[0,1] .. matriz[0,j] matriz[0,n-1]
2 matriz[1,0] matriz[1,1] .. matriz[1,j] matriz[1,n-1]
..
I matriz[i,0] matriz[i,1] .. matriz[i,j] matriz[i,n-1]
M
matriz[m-
1,0] matriz[m-1,1] ..
matriz[m-
1,j]
matriz[m-1,n-
1]

Ejemplo 21. Se desea realizar la suma de dos matrices, ingresar las
dimensiones por teclado.
Pseudocdigo:
//Ejemplo de matrices
Proceso Algoritmo21

Definir i, j, m, n, matriz1, matriz2, matriz3 Como Entero;
Escribir "Ingrese el nmero de filas: ";
Leer m;
Escribir "Ingrese el nmero de columnas: ";
Leer n;
//defino la dimension de las matrices
Dimension matriz1[m,n], matriz2[m,n], matriz3[m,n];
Limpiar Pantalla;
//ingreso la primera matriz
Escribir "Ingrese la matriz A:";
Para i <- 0 Hasta m-1 Con Paso 1 Hacer
Para j <- 0 Hasta n-1 Con Paso 1 Hacer
Escribir "Ingrese el valor A[",i+1,",",j+1,"]";
Leer matriz1[i,j];
FinPara
FinPara
Limpiar Pantalla;
//ingreso la segunda matriz
Escribir "Ingrese la matriz B:";
Escribir "Ingrese el valor B[",i+1,",",j+1,"]";
Leer matriz2[i,j];
FinPara

FinPara
Escribir "Presione enter...";
Esperar Tecla;
Limpiar Pantalla;
//sumo las matrices y las presento en pantalla
Escribir "La suma de A+B es:";
matriz3[i,j] <- matriz1[i,j] + matriz2[i,j];
Escribir "C[",i+1,",",j+1,"]=",matriz3[i,j];
FinPara
FinPara
FinProceso

Diagrama de flujo:

14 MODULARIDAD.

Una estrategia para la resolucin de problemas complejos con computadoras
es la divisin o descomposicin del problema en otros problemas ms
pequeos y fciles de resolver. Estos subproblemas se implementan mediante
mdulos o subprogramas. Los subprogramas son una herramienta
importante para el desarrollo de algoritmos y programas, de modo que
normalmente un proyecto de programacin se compone de un programa
principal y un conjunto de subprogramas, con las llamadas a los mismos dentro
del programa principal. Un subprograma realiza una tarea concreta que se
describe con una serie de instrucciones y que, idealmente, debera ser
independiente de otros subprogramas. El descomponer un programa en
mdulos independientes ms simples se conoce tambin como el mtodo de
"Divide y vencers".
Cundo es til la modularizacin?
Este enfoque de segmentacin o modularizacin es til en dos casos:
1. Cuando existe un grupo de instrucciones o una tarea especfica que
deba ejecutarse en ms de una ocasin.
2. Cuando un problema es complejo o extenso, la solucin se divide o
segmenta en mdulos que ejecutan partes o tareas especficas.
Ventajas de la Programacin Modular.
Las ventajas ms sobresalientes de utilizar subprogramas o mdulos son:
El uso de subprogramas facilita el diseo descendente y modular, que
permite descomponer un problema complejo en subproblemas hasta que
stos sean concretos y fciles de resolver.
Los procedimientos se pueden ejecutar ms de una vez en un programa y
en diferentes programas, ahorrando en consecuencia tiempo de
programacin. Un subprograma, en esencia, se puede ver como una caja
negra (encapsulamiento) que ejecuta una tarea en particular en un
programa, acepta entradas y produce ciertas salidas. Una vez que el
mdulo se ha escrito y comprobado, se puede utilizar en otros programas
eliminando la duplicacin innecesaria de cdigo (reutilizacin de cdigo).
Aumenta la facilidad de depuracin y bsqueda de errores en un programa
ya que stos se pueden aislar fcilmente depurndose sus errores
individualmente antes de su inclusin en bibliotecas independientes y de ser
llamados en el programa principal.
El uso de subprogramas facilita la divisin de tareas de programacin entre
un equipo de programadores.

El uso de mdulos facilita la proyeccin y la comprensin de la lgica
subyacente para el programador y el usuario.

14.1 PROCEDIMIENTOS Y FUNCIONES.
Los subprogramas en programacin estructurada se clasifican en
procedimientos y funciones, que son unidades de programas diseados para
ejecutar una tarea especfica.
Las funciones normalmente devuelven un slo valor a la unidad de programa
(programa principal u otro subprograma) que los referencia (que los llama o
invoca). Los procedimientos pueden devolver cero, uno o varios valores.
Las funciones se dividen en estndares y definidas por el usuario.
Estndar. Son funciones proporcionadas por lenguaje de programacin.
Definidas por el usuario. Son funciones definidas el programador con el
propsito de ejecutar alguna funcin especfica, y que por lo general se
usan cuando se trata de hacer algn clculo que ser requerido en varias
ocasiones en la parte principal del algoritmo.
Las funciones y procedimientos estn compuestos por un grupo de sentencias
a las que se asigna un nombre (identificador) y constituyen una unidad de
programa a la que se puede invocar desde el programa principal u otra funcin
o procedimiento.
Una de las caractersticas importantes y diferenciadoras de los subprogramas
es la posibilidad de comunicacin entre el programa principal y los
subprogramas (o entre dos subprogramas). Esta comunicacin se realiza a
travs de una lista de parmetros. Un parmetro es un medio para pasar
informacin valores a variables del programa principal a un subprograma y
viceversa. No es obligatorio que un subprograma utilice parmetros, ya que
stos no siempre son necesarios.
Un parmetro es, prcticamente, una variable cuyo valor debe ser o bien
proporcionado por el programa principal al subprogramas o ser devuelto desde
el subprogramas al programa principal. Por consiguiente, hay dos tipos de
parmetros: parmetros de entrada y parmetros de salida. Los de entrada
son aquellos cuyos valores deben ser proporcionados por el programa
principal, mientras que los de salida son aquellos cuyos valores se calcularn

en el subprograma y se deben devolver al programa principal para su proceso
posterior.
Visibilidad de las variables.
Las variables que intervienen en un programa con subprogramas pueden ser
de dos tipos: variables locales y variables globales.
Una variable local es una variable que est declarada dentro de un
subprograma, y se dice que es local al subprograma. Una variable local slo
est disponible durante el funcionamiento del mismo, y su valor se pierde una
vez que el subprograma termina. Dos variables locales pueden tener el
mismo nombre siempre que estn declaradas en funciones o
procedimientos diferentes.
Las variables declaradas en el programa principal se denominan variables
globales. A diferencia de las variables locales, cuyos valores se pueden utilizar
slo dentro del subprograma en el que estn declaradas, las variables globales
pueden ser utilizadas en el programa principal y en todos los subprogramas,
permanecen activas durante toda la ejecucin del programa.
Hay que tener especial precaucin al trabajar con variables globales, ya que al
ser recursos compartidos todos los subprogramas pueden tener acceso
simultneo a ellas y se pueden producir errores lgicos debidos a la
concurrencia. Por lo general, es una buena prctica evitar el uso de variables
globales desde subprogramas a menos que sea estrictamente necesario.
Las variables tambin pueden ser declaradas dentro de un bloque o estructura
de control, y se comportarn como variables locales nicamente dentro de
dicho bloque o estructura.
Si dos variables, una global y una local, tienen el mismo nombre, la local
prevalecer sobre la global dentro del mdulo en que ha sido declarada.
14.1.1 IMPLEMENTACIN DE PROCEDIMIENTOS Y FUNCIONES.
La implementacin de procedimientos y funciones lo haremos en la
herramienta JTraductor, pues en PSeInt no es posible realizarlo (al momento
de escribir estas lneas), adems que es muy comn para un programador
aprender varios lenguajes de programacin, si estn muy claros del algoritmo,
bsicamente es cuestin de aprender un nuevo lxico, sintaxis y semntica y
saber las semejanzas y diferencias entre un lenguaje y otro.


La siguiente tabla muestra un comparativo entre PSeInt (v20120418 ) y
JTraductor (v0.8.0).

PSeInt JTraductor
Inicio /Fin del Algoritmo
Proceso <NombrePrograma>
<accin 1>;
<accin 2>;
. .
.
<accin n>;
FinProceso
Proceso Principal
<accin 1>;
<accin 2>;
. .
.
<accin n>;
Fin
Comentarios
//esto es un comentario No existe forma de definir comentarios
Tipos de Variables
Real/Entero/Logico/Caracter Real/Entero/Logico/Cadena
Declaracin de Variables
Definir <var1> , <var2> , , <varN>
Como [Real/Entero/Logico/Caracter] ;
<Tipo variable> <variable> <- <valor>
Operadores
>, <, =, ,<>, >=, <=, &, |, ~, +, -, *, /, ^ >, <, =, !=, >=, <=, &&, ||, +, -, *, /
Asignacin
<variable> <- <expresin> ; <variable> <- <expresin>
Lectura
Leer <var1> , <var2> , ... ,<varN> ; Leer <variable>
Escritura
Escribir <exprl> , <expr2> ,..., <exprN> ; Escribir <exprl> , <expr2> ,..., <exprN>
Estructura Si-Entonces
Si <condicin> Entonces
<instrucciones>
Sino
<instrucciones>
FinSi
Si <condicin> Entonces
<instrucciones>
Sino
<instrucciones>
FinSi
Estructura Segn

Segun <variable> Hacer
<num>: <instrucciones>
<num>,<num>: <instrucciones>
<...>
De Otro Modo: <instrucciones>
FinSegun
No es soportado la estructura Segn
Estructura Para
Para <variable> <- <inicial> Hasta
<final> (Con Paso <paso>) Hacer
<instrucciones>
FinPara
Para <Tipo Var> <variable> <- <inicial>
Hasta <final> Con Paso <paso> Hacer
<instrucciones>
FinPara
Estructura Mientras
<instrucciones>
FinMientras
<instrucciones>
FinMientras
Estructura Repetir
Repetir
<instrucciones>
Hasta Que <condicin>
No es soportado la estructura repetir
Arreglos
Dimension <ident1>
(<max11>,..,<max1N>),..,<identM>(<m
axM1>,..,<maxMN>);
No es soportado los arreglos

Declaracin de Funciones.
El pseudocdigo para declarar funciones es:
Funcion <Tipo Var> <nombreFuncion> (<TipoVar> <Var1>, <TipoVar>
<Var2>,...)
<instrucciones>
Retornar <Variable/Valor>
FinFuncion
Las funciones siempre deben retornar una variable o valor <Variable/Valor> del
mismo tipo del que fue declarada la funcin <Tipo Var> a travs de la palabra
reservada Retornar.

Pueden tener cero o ms parmetros (<TipoVar> <VarN>) que deben ser
pasados al momento de llamar a la funcin, si no se tienen parmetros, debe ir
el parntesis vaco.
El nombre de la funcin <nombreFuncion> debe iniciar con un carcter vlido.
Ejemplo 21. Realizar una funcin que acepte dos nmeros como parmetros y
devuelva la suma de dichos nmeros.
Solucin. Crearemos una funcin llamada sumarNumeros que ser llamada en
el programa principal.
Pseudocdigo:
Funcion Real sumarNumeros (Real parametro1, Real parametro2)
Real suma
suma <- parametro1 + parametro2
Retornar suma
FinFuncion

Proceso principal
Real suma <- 0, num1, num2
Escribir "Ingrese el primer nmero"
Leer num1
Escribir "Ingrese el segundo nmero"
Leer num2
suma <- sumarNumeros(num1,num2)
Escribir "La suma es: ", suma
Fin
En este ejemplo vemos la definicin (declaracin) de una funcin en
pseudocdigo para calcular la suma de dos nmeros reales, los cuales son

pasados al subprograma como parmetros de entrada. La funcin calcula la
suma y la devuelve como un parmetro de salida.
Esta funcin la podemos invocar desde el programa principal u otra funcin o
procedimiento. Ntese que los nombres de los parmetros en la definicin
(parametro1 y parametro2) no necesariamente tienen que ser los mismos que
los utilizados en la invocacin (num1 y num2). Ntese tambin que el
compilador chequear previamente que el tipo de dato del parmetro de salida
de la funcin (en este caso un nmero real) pueda ser asignado a la variable
suma segn su tipo.
Al nombre de la funcin junto con la lista ordenada de sus parmetros de
entrada se lo conoce como firma de la funcin. En general, no puede haber
dentro del mismo programa dos funciones con la misma firma.
A primera vista, los procedimientos parecen dificultar la escritura de un
programa. Sin embargo, no slo no es as, sino que la organizacin de un
programa en funciones y/o procedimientos lo hace ms fcil de escribir y
depurar.

Declaracin de Procedimientos.
El pseudocdigo para declarar procedimientos es:
Procedimiento <nomProcedimiento> (<TipoVar> <Var1>, <TipoVar>
<Var2>,...) <instrucciones>
FinProcedimiento
Los procedimientos, a diferencia de las funciones no devuelven ningn valor.
Pueden tener cero o ms parmetros (<TipoVar> <VarN>) que deben ser
pasados al momento de llamar al procedimientos, si no se tienen parmetros,
debe ir el parntesis vaco.
El nombre del procedimiento <nomProcedimiento> debe iniciar con un carcter
vlido.
Ejemplo 22. Se desea crear un procedimiento que de la bienvenida al usuario
que ingresa al programa.
Procedimiento bienvenida (Cadena nombre)

Escribir "\n\t Bienvenido: ", nombre
FinProcedimiento

Proceso principal
Cadena nombre
Escribir "Ingrese su nombre: "
Leer nombre
bienvenida(nombre)
Fin
Al nombre de la funcin junto con la lista ordenada de sus parmetros de
entrada se lo conoce como firma del procedimiento. En general, no puede
haber dentro del mismo programa dos procedimientos con la misma firma.
A primera vista, los procedimientos parecen dificultar la escritura de un
programa. Sin embargo, no slo no es as, sino que la organizacin de un
programa en funciones y/o procedimientos lo hace ms fcil de escribir y
depurar.
Ejemplo 23. Realizar un algoritmo que calcule las operaciones matemticas
bsicas (suma, resta, multiplicacin y divisin) de dos nmeros. Use funciones
y procedimientos.
Pseudocdigo:
Funcion Real sumar (Real num1, Real num2)
Retornar (num1 + num2)
FinFuncion

Funcion Real multiplicar (Real num1, Real num2)
Retornar (num1 * num2)
FinFuncion

Funcion Real restar (Real num1, Real num2)
Retornar (num1 - num2)
FinFuncion

Funcion Real dividir (Real num1, Real num2)
Retornar (num1 / num2)
FinFuncion

Procedimiento calculadora (Real num1, Real num2)
Escribir "El resultado de la suma es: ", sumar(num1,num2)
Escribir "El resultado de la resta es: ", restar(num1,num2)
Escribir "El resultado del producto es: ", multiplicar(num1,num2)
Si num2!=0 Entonces
Escribir "El resultado de la divisin es: ", dividir(num1,num2)
Sino
Escribir "El resultado de la divisin es: Denominador igual a 0"
FinSi
FinProcedimiento

Proceso principal
Real num1<-0,num2<-0
Escribir " \tCALCULADORA\n"
Escribir "Ingrese el primer nmero: "

Leer num1
Escribir "Ingrese el segundo nmero: "
Leer num2
calculadora(num1,num2)
Fin
Se puede observar que en programa principal se orquesta (invoca) al resto de
funciones o procedimientos, armando de esta manera el programa deseado; el
procedimiento calculadora imprime en pantalla el resultado de las operaciones
matemticas bsicas calculadas con funciones.

14.2 BIBLIOTECAS.
En la mayora de los lenguajes de programacin de alto nivel es posible
guardar un subprograma o un conjunto de subprogramas como un archivo
independiente al cual se denomina genricamente biblioteca (del ingls library).
Las bibliotecas pueden luego ser referenciadas dentro de mltiples programas
para que stos puedan hacer uso de los subprogramas incluidos en aquella.
Recordemos que la salida del proceso de compilacin de un cdigo fuente se
denomina Programa Objeto, que es ni ms ni menos que el cdigo de
mquina generado a partir del cdigo fuente (SIN INCLUIR EL CODIGO DE
LAS BIBLIOTECAS UTILIZADAS). El Programa Objeto es luego utilizado como
entrada para que otro componente de software, llamado linker, lo asocie con
los subprogramas que se encuentran en las bibliotecas referenciadas y
produzca el llamado Programa Ejecutable. Este proceso se conoce
comnmente como Link-Edicin.
Observacin. Tanto PSeInt como en JTraductor no es posible el uso de
bibliotecas.

15 RECURSIVIDAD.
Recursividad, es el proceso de resolver un problema reducindolo a uno o
ms subproblemas que son idnticos en su estructura al problema original y
ms simples de resolver.

Una vez que se ha subdividido el problema original, se utiliza la misma tcnica
de descomposicin para subdividir cada uno de estos subproblemas en otros
que son menos complejos, hasta que los subproblemas llegan a ser tan
simples que se pueden resolver sin realizar ms subdivisiones, y la solucin
general del problema se obtiene juntando todos los componentes resueltos.

Se dice que un proceso es recursivo si forma parte de s mismo, es decir, que
se define en funcin de s mismo. En otras palabras, un mtodo es recursivo si
contiene invocaciones a s mismo.

La recursin aparece en la vida diaria, en problemas matemticos, en
estructuras de datos y en muchos otros problemas. Es un proceso
extremadamente potente, por lo que hay que saber cundo y cmo aplicarla.

Es una poderosa herramienta de programacin como alternativa a algoritmos
iterativos (cuando es casi imposible resolver con estructuras iterativas).
En resumen, la recursividad consiste en:
En el cuerpo de sentencias del subalgoritmo se invoca al propio
subalgoritmo para resolver una versin ms pequea del problema
original.
Habr un caso (o varios) tan simple que pueda resolverse directamente
sin necesidad de hacer otra llamada recursiva.

En general el pseudocdigo de un algoritmo recursivo es el siguiente:
Funcion <Tipo Var> recursivo (<TipoVar> <Var1>, <TipoVar> <Var2>,...)
<Tipo Var> valor
<instrucciones>
valor <- recursivo(<Var1>, <Var2>,...)
<instrucciones>
Retornar valor
FinFuncion

Las condiciones que debe cumplir un algoritmo recursivo son:
Asegurar que existe una condicin de salida, en la que no se producen
llamadas recursivas (caso base).
Asegurar que se cubren todos los posibles casos entre el base y los no
base.

Cada llamada, en el caso no base, conduce a problemas cada vez ms
pequeos que terminarn en el caso base.

Ejemplo 24. Calcular el factorial de un nmero entero usando un algoritmo
recursivo.

Solucin.
Recordemos la definicin recursiva del factorial:

n! = n * (n-1)! , si n > 1
1! = 1

Por lo tanto, tenemos los casos:
Si n = 1 (caso base) Retornar 1
Si n > 1 Retornar n * factorial(n 1)
Sea factorial(n) la funcin que calcula el factorial de un nmero entero n, sea
n=4, entonces:

factorial (4) = 4 * factorial (3) = 4 * 6 = 24
factorial (3) = 3 * factorial (2) = 3 *2 = 6
factorial (2) = 2 * factorial (1) = 2 * 1 = 2
factorial (1) = 1
Pseudocdigo:
Funcion Entero factorial (Entero n)
Entero temp
Si n>1 Entonces
temp <- n*factorial(n-1)
Sino
temp <- 1
FinSi
Retornar temp
FinFuncion
Proceso principal
Entero n<-0
Escribir "Factorial de un nmero entero\t\n"

Escribir "Ingrese en valor de n: "
Leer n
Escribir "El factorial de ",n," es ", factorial(n)
Fin
A veces, podemos encontrar una solucin iterativa simple, que haga que el
algoritmo sea ms eficiente.
Ejemplo 25. Calcular el factorial de un nmero entero usando un algoritmo
iterativo.

Solucin.
Se define el factorial como:

n! = n * (n-1)! , si n > 1
1! = 1
De acuerdo con esta definicin, se tiene que:
n! = n * (n-1)!, si n>1
(n-1)! = (n-1) * (n-2)!
(n-2)! = (n-2) * (n-3)!
.
(2)! = (2) * (1)!

De donde:
n!=n*(n-1)*(n-2)**1, que es la definicin iterativa de factorial.

Sea factorial(n) la funcin que calcula el factorial de un nmero entero n, sea
n=4, entonces:

factorial (4) = 4*3*2*1 = 24

Pseudocdigo:
Funcion Entero factorial (Entero n)
Entero fact<-1
Para Entero i <- 1 Hasta n Con Paso 1 Hacer
fact <- fact*i
FinPara
Retornar fact

FinFuncion

Proceso principal
Entero n<-0
Escribir "Factorial de un nmero entero\t\n"
Escribir "Ingrese en valor de n: "
Leer n
Escribir "El factorial de ",n," es ", factorial(n)
Fin

Ventajas.
La principal ventaja es la simplicidad de comprensin y su gran potencia,
favoreciendo la resolucin de problemas complejos de manera natural, sencilla
y elegante; y facilidad para comprobar y convencerse de que la solucin del
problema es correcta. El valor de la recursividad reside en el hecho de que se
puede usar para resolver problemas sin fcil solucin iterativa.

Desventajas.
El principal inconveniente es la ineficiencia tanto en tiempo como en memoria,
dado que para permitir su uso es necesario transformar el programa recursivo
en otro iterativo, que utiliza bucles y pilas para almacenar las variables. Una
simple llamada puede generar un gran nmero de llamadas recursivas.
(factorial(n) genera n llamadas recursivas).

Observacin. La recursividad se debe usar cuando sea realmente necesaria,
es decir, cuando no exista una solucin iterativa simple.

16 ESTILO DE PROGRAMACIN.
El buen estilo de programacin es, sin lugar a dudas, una de las caractersticas
ms importantes que debe tener un buen programador. Un programa con buen
estilo es ms fcil de leer, de corregir y de mantener. Aunque la experiencia
proporciona el estilo, existen una serie de reglas que se recomiendan seguir
desde el principio del aprendizaje de la programacin.

Comentarios. La legibilidad de los programas aumenta considerablemente
utilizando comentarios. Un comentario es un texto explicativo ms o menos
largo, situado en el programa e ignorado por el compilador. Los comentarios
son considerados parte del cdigo fuente por ms que sean ignorados en
las etapas de compilacin y ejecucin, y tienen importancia primordial en las
fases de anlisis, puesta a punto y mantenimiento. Los comentarios son una
parte fundamental de la documentacin de un programa, ya que ayudan al
programador y a otras personas a la comprensin del mismo. No es raro
encontrar programas en los cuales los comentarios ocupan ms lugar,
incluso, que las propias instrucciones.
Eleccin de nombres significativos para variables, funciones y
procedimientos. Las variables, constantes, nombres de subprogramas y
nombres de programas deben ser significativos para orientar al usuario o a
otros programadores sobre lo que representan: X, Y, JJ no son
identificadores significativos.
Identacin. Aunque no suele ser requerido por los compiladores de los
lenguajes de alto nivel, es una prctica habitual realizar una identacin (o
tabulacin) en cada uno de los bloques y unidades de programas
fundamentales para mejorar la legibilidad del cdigo fuente.
Espacios y Lneas en Blanco. Con el mismo fin de mejorar le legibilidad y
comprensibilidad del programa es recomendado utilizar espacios en blanco
antes y despus de un operador, as como tambin dejar una lnea en
blanco entre partes importantes o que estn lgicamente separadas.
Validacin. Los programas no pueden considerarse correctos hasta que
han sido validados utilizando un rango amplio de datos de prueba para
contemplar todas las posibles direcciones que el flujo de control puede
tomar en tiempo de ejecucin.

17 BIBLIOGRAFA.
Fundamentos de Informtica. Luis A. Urea y otros. Editorial Alfaomega ra-
ma, 1999.
Fundamentos de Programacin. Libro de Problemas. Luis Joyanes Aguilar,
Rodrguez Baena y Fernndez Azuela. 1996.
Pascal y Turbo Pascal enfoque prctico. Luis Joyanes Aguilar. Editorial Mc
Graw Hill, 1996.


Lgica Simblica. Luis Joyanes Aguilar y Angel Hermoso. Editorial Mc Graw
Hill.

Programacin en Pascal. Irving M. Copi. Editorial C.E.C.S.A., 4 Edicin.
Cmo programar en C/C++. Sanford Leestma y Larry Nyhoff. Editorial
Prentice Hall, 1999.
Introduccin a la Ciencia de las Computadoras. Deitel/Deitel. Editorial
Prentice Hall.
Aprenda Visual C++ Ya. Mark Andrews. Editorial Mc Graw Hill.
Visual C++ 6.0 Manual de Referencia. Chris Pappas y William H. Murray.
Editorial Mc Graw Hill.
Computacin. Metodologa, Lgica Computacional y Programacin. Ma. del
Rosario Bores Rangel y Romn Rosales Becerril. 1 Edicin, Editorial Mc Graw
Hill, 1993.
Programacin en C. Byron S. Gottfried. 1 Edicin,
Editorial Mc Graw Hill, 1991.
Metodologa de la Programacin. Algoritmos, Diagramas de Flujo y
programas
Tomos I y II. Osvaldo Cair Battistutti. 1a Edicin
Editorial Alfaomega, 1995.
Enciclopedia del Lenguaje C. Francisco Javier Ceballos .1 Edicin, Editorial
Alfaomega ra-ma, 1999.
http://pseint.sourceforge.net/
http://jtraductor.sourceforge.net/

Fundamentos de Programación - Algoritmos

Enviado por

Dados do documento

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Fundamentos de Programación - Algoritmos

Enviado por

Direitos autorais:

Formatos disponíveis

Jfferson Beltrn

Sintaxis sencilla (sin la complejidad de los lenguajes de programacin).

Manejo de las estructuras bsicas de control.

Slo 3 tipos de datos bsicos:

Estructuras de datos: Arreglos.

Você também pode gostar