Antologia - Algoritmos Computacionales 1 ITI

Instituto de Estudios Superiores
Metropolitano
[ALGORITMOS
COMPUTACIONALES]
Ingeniería en Tecnologías de la Información
Primer Cuatrimestre
M.TL. Juan Carlos González Pinto

Catedrático
M.TL. Juan Carlos González Pinto ALGORITMOS COMPUTACIONALES
Contenido
I. CONCEPTOS BÁSICOS E HISTORIA .................................................................................................... 3
1.1 Introducción .............................................................................................................................. 3
1.2 Definición de Lenguaje de Programación ................................................................................. 4
1.2.2 Objetivos de la programación ............................................................................................ 4
1.2.3 Historia de los Lenguajes de Programación ....................................................................... 4
1.2.4 Clasificación de los Lenguajes de Programación ................................................................ 7
1.3 Definición de algoritmo ............................................................................................................. 8
1.4 Algoritmos Cotidianos ............................................................................................................... 9
1.5 Definición de Lenguajes Algorítmicos ..................................................................................... 10
II. METODOLOGÍA PARA LA RESOLUCIÓN DE PROBLEMAS............................................................... 11
2.1 Definición del problema .......................................................................................................... 11
2.2 Análisis de los datos ................................................................................................................ 11
2.3 Diseño de la solución............................................................................................................... 12
2.4 Codificación ............................................................................................................................. 13
2.5 Prueba y depuración .............................................................................................................. 13
2.6 Documentación ....................................................................................................................... 13
2.7 Mantenimiento...................................................................................................................... 14
III. ENTIDADES PRIMITIVAS PARA EL DISEÑO DE INSTRUCCIONES ................................................... 14
3.1 Tipos de Datos ......................................................................................................................... 14
3.1.1 El tipo Int .......................................................................................................................... 14
3.1.2 El tipo Char ....................................................................................................................... 16
3.2 Operadores y Operandos ........................................................................................................ 18
3.2.1 Operadores aritméticos ................................................................................................... 18
3.2.2 Operadores de asignación ................................................................................................ 19
3.2.3 Jerarquía de los operadores ................................................................................................. 20
IV. TÉCNICAS DE DISEÑO ................................................................................................................... 20
4..1 Top Down ............................................................................................................................... 20
4.2 Bottom Up ............................................................................................................................... 21
1
Instituto de Estudios Superiores Metropolitano
4.3 Warnier Orr ............................................................................................................................. 21

4.3.1 Elementos Básicos ............................................................................................................ 22
4.3.2 Uso de diagramas de Warnier / Orr ................................................................................. 22
V. TÉCNICAS PARA LA FORMULACIÓN DE ALGORITMOS .................................................................. 24
4.2 Diagramas de Flujo .................................................................................................................. 24
4.4 Pseudocódigo ......................................................................................................................... 30
4.5 Diagramas Estructurados (Nassi - Schneiderman) ................................................................. 34
VI. ESTRUCTURAS ALGORITMICAS .................................................................................................... 36
6.1 Estructura Secuencial .............................................................................................................. 36
6.2 Estructura Condicionales......................................................................................................... 38
6.2.1 Alternativa Simple (si-entonces/if-then) .......................................................................... 39
6.3 Estructuras Repetitivas .......................................................................................................... 40
6.3.1 Estructura Mientras (while)............................................................................................. 40
6.3.2 Estructura Repetir (repeat) ............................................................................................. 42
6.3.3 Estructura Desde/Para (for) ............................................................................................ 43
VII. ARREGLOS ................................................................................................................................... 45
7.1. Vectores ................................................................................................................................. 45
7.2 Matrices................................................................................................................................... 47
2
I. CONCEPTOS BÁSICOS E HISTORIA

1.1 Introducción
Los sistemas modernos de computación consisten en una gran

conjunción de elementos de circuitos (hardware) y de programación
(software) que han sido diseñados para proporcionar a la computación un
ambiente productivo y hasta cierta medida agradable. El término Sistema
de Cómputo se utiliza para señalar lo que el usuario emplea, en lugar del
término Computadora. En los primeros años de la computación, los usuarios
del sistema debían interactuar más estrechamente con el hardware real que
lo que es hoy necesario, muchas funciones que debían realizar los
usuarios mismos se manejan ahora por software mediante Sistemas
Operativos. El sistema operativo crea un ambiente en el cual los usuarios
pueden preparar programas y ejecutarlos sin tener que entrar en los
detalles del hardware del sistema.
Para satisfacer el crecimiento de la demanda de medios de

computación, es que se ha desarrollado la multiprogramación, en la cual
varios usuarios emplean el sistema de forma simultánea, como Windows por
ejemplo. Un término fundamental de esta materia es el Programa, el cual
es simplemente una secuencia de instrucciones que orienta a la Unidad de
Control de Procesamiento (CPU) en el desarrollo de los cálculos, el cual
debe expresarse de forma que sea entendido por el CPU. Un CPU sólo puede
entender instrucciones que estén expresadas en términos de su lenguaje
máquina, pero esto se explicará más adelante.
3
1.2 Definición de Lenguaje de Programación
Un Lenguaje de Programación es un conjunto de reglas, notaciones,

símbolos y/o caracteres ( como letras del código ASCII ) que permiten al
programador poder expresar el procesamiento de datos y sus estructuras en
la computadora. Cada lenguaje posee sus propias sintaxis. Un programa es
un conjunto ordenado de instrucciones que indican a la computadora las
acciones específicas que debe realizar para cumplir una tarea. Con un
programa le decimos a la computadora qué tiene que hacer, el orden en el
que lo tiene que hacer y qué datos usar para ello.
1.2.2 Objetivos de la programación
En la preparación de un programa, el programador puede tener que

escoger entre soluciones alternativas en muchos puntos. Cada elección
debe hacerse para satisfacer los objetivos y restricciones de la tarea de
programación particular. Aquí asumiremos como apropiados para toda tarea
de programación los siguientes objetivos:
 Exactitud
 Claridad
 Eficiencia
1.2.3 Historia de los Lenguajes de Programación
Veamos un poco de la historia de la evolución de los diferentes

lenguajes de programación, ya que estos hasta nuestros días han ido
evolucionando permitiéndole al programador interactuar con la computadora
de una forma más sencilla y más rápida, aunque en algunas ocasiones un
poco mas tardado por la evolución del software. Los primeros lenguajes
4
trataban en primera instancia poder resolver problemas del tipo numérico,

ya que en los años 30's y 40's se trataba de resolver este tipo de
problemas debido a su complejidad en muchos casos. Para los años 50's se
empezaban a dar los lenguajes con notaciones ya definidas tal como el
lenguaje A-0 creado por Grace Hopper junto con grupo en la Univac y el
lenguaje Speedcoding creado para la IBM 701 por John Backus. Unos años
después en 1955 a 1957 Backus junto con su equipo empezó a crear FORTRAN
(FORmula TRANslator) que era para problemas numéricos, el cual fueron
perfeccionado con el tiempo, ya que después le introdujeron las primeras
instrucciones tal como READ INPUT TAPE (lectura de cinta ). Esto le
permitió la rápida aceptación de los programadores e incluso en 1966 era
implementado en la mayoría de las computadoras IBM. E incluso muchos
lenguajes subsecuentes nacieron del FORTRAN. En los 50's es también
cuando se usa el bulbo para las computadoras empezando así con la 1era
Generación ( 1950-1959).
Pero el temor a la expansión de un monopolio de la IBM, hizo que el

lenguaje se hiciera universal, creándose el ALGOL 58 (ALGOrithmic
Language). El cual permitía una notación mas próxima a la real en las
matemáticas, utilidad en la descripción de algoritmos, compilación a
lenguaje maquina y poder usado en cualquier ordenador. Todo esto permitió
la realización de nuevos lenguajes y nuevo hardware según los fines, tal
como el creado por Jules Schwarz, el JOVIAL , usado para la Fuerza Aérea
de EUA.
En 1955 surge la necesidad de crear lenguajes para negocios y con

ello que se crea FLOWMATIC que era el primer lenguaje para este tipo. En
1959 el Departamento de Defensa de EUA , desarrolla el CBL ( Common
Business Language ). Pero el lenguaje ya totalmente dedicado a los
negocios surge en 1960 con el COBOL ( Common Business Oriented ).
Pero Backus seguía creando nuevos conceptos, junto con Naur

empezaron a crear la gramática formal de los lenguajes de programación a
lo que hoy llamamos Notación de Backus-Naur ( BNF ). Es en los 50's
también que surgen los lenguajes de inteligencia artificial como el IPL (
Information Processing Language ), el LISP ( LISt Processing ) creado por
John McCarthy para la IBM 704 y fue el que mas evoluciono y mas aceptado
por los científicos, ya que manejaba la estructura de árboles. Con el
tiempo las ideas iban surgiendo y fue Burroughs en base a la idea de un
5
polaco llamado Lukasiewiez creo el hardware B550 que permitía usar pilas
lo que hacia que ALGOL corriera más rápido. También se empiezan a usar
los transistores para los aparatos electrónicos y con ello da inicio la
2nda Generación ( 1960-1965 ).
Fue en 1967 cuando surge el SIMULA 67 creado por Nygaard y Dahl de

Noruega que era un lenguaje de clases de ALGOL , que permitía usar los
nuevos conceptos que iban surgiendo y que el FORTRAN y ALGOL original no
tenían. En base a esto Stroustrup crea C y después en los 80`s haría las
clases de C : C++. Para los años de 1966 a 1973 se empiezan a crear
sistemas más avanzados, como los chips ( circuitos integrados ) que
consistían en dispositivos que podian tener varios transistores en
espacio reducido. Con esto inicia la 3era Generación.
En 1963 IBM con los avances de su hardware introduce el NPL ( New

Programming Language ) y que después se llamaría MPPL ( Milti-Purpose
Programming Language ) y más tarde sería el PL/1 que maneja
características numéricas de FORTRAN y de negocios como de COBOL. Mas
adelante sale la versión para estudiantes, el PL/C. BASIC otro lenguaje
surgido en los 60's surge por la necesidad de cálculos numéricos no
científicos.
Otro campo en la creación de los lenguajes de programación fue el

de sistemas, al principio de los lenguajes el de maquina y se había
mantenido este como el de sistemas. Pero el avance del tiempo y del
hardware permitieron la creación de CPL y BCPL. Después C quien compitió
con UNIX en los 70's. Es aquí de 1974 a 1984 cuando se empiezan a
desarrollar circuitos integrados más complejos que permitían reducir
muchas cosas en espacios más pequeños. Esto permitió la 4ta generación.
En los 80's el hardware iba avanzando permitiendo crear lenguajes

de mas alto nivel. En los 90's es cuando empiezan a surgir los visuales
que eran adaptaciones y mejoras de los lenguajes de DOS a formato
gráfico. Otros lenguajes como FORTRAN, COBOL y LISP solo han tenido que
irse adaptando a las nuevas tecnologías de hardware que permitieron de
1985 hasta nuestros días el inicio de la 5ta Generación.
Los lenguajes visuales y actuales tales como VISUAL BASIC, C, FOX

PRO y otros han tomado en cuenta las capacidades de las computadoras,
aplicaciones que muchas veces son en modo gráfico (lo cual puede ser un
6
inconveniente por el uso de mucha memoria y espacio en disco ), hacer la

simplificación de algoritmos y procesos así como su implementación y la
estandarización o portabilidad hacia otros lenguajes.
1.2.4 Clasificación de los Lenguajes de Programación
Los programadores escriben instrucciones en diversos lenguajes de

programación. La computadora puede entender directamente algunos de
ellos, pero otros requieren pasos de traducción intermedios. Hoy día se
utilizan cientos de lenguajes de computadora. Los Lenguajes de
Programación pueden clasificarse de muchas formas, sin embargo, las
clasificaciones más aceptadas son las siguientes:
Según su base de desarrollo y su uso en :
 Lenguajes basados en calculo numérico. Tales como Fortran,

Matemática y Matlab.
 Lenguajes para sistemas. Como C y ensamblador.
 Lenguajes para Sistemas de Inteligencia Artificial. Tales como
Prolog, y Lisp.
Según el tipo de instrucciones de que constan:
 Lenguajes de bajo nivel (ensamblador)
Para facilitar y agilizar su labor a los programadores, se buscaron

nuevos lenguajes. El lenguaje ensamblador consiste en pequeñas
abreviaturas de palabras en ingles. Se crearon los programar traductores
para convertir los programas escritos en lenguaje ensamblador a lenguaje
máquina a velocidades de computadora. Estos lenguajes aun requerían
muchas instrucciones para realizar simples operaciones. Requiere además
de que el programador tenga amplios conocimientos de la arquitectura del
ordenador. Además de que el código es sumamente complejo y difícil de
entender por parte de un programador principiante.
Lenguajes de alto nivel
7
Para acelerar, aún más, el proceso de programación se desarrollan los

lenguajes de alto nivel en los que se podía escribir un enunciado para
realizar tareas sustanciales. Los lenguajes de alto nivel permiten a los
programadores escribir instrucciones que asemejan el ingles cotidiano y
contiene notaciones matemáticas de uso común. Su uso requiere que el
programador aprenda un conjunto básico de instrucciones, así como su
sintaxis. Por lo que se convierte en un lenguaje que puede ser fácilmente
comprendido por un programador con conocimientos básicos.
Principales lenguajes de alto nivel
Basic Logo ALGOL

Pascal
C C# C++ Clipper
Perl ADA Cobol Java
Modula2 Fortran
Antes de pasar a definir los siguientes conceptos, se debe hacer un alto

para definir lo que es un código fuente, ya que este término se
utilizará constantemente a lo largo de este material.
Código Fuente: Le daremos el nombre de código fuente a los programas que

escribamos en un determinado lenguaje de programación, que simplemente
estará compuesto por instrucciones escritas por un programador. El código
fuente no constituye software propiamente dicho pero es una instancia
mediante la cual se logra el Software.
1.3 Definición de algoritmo
El término algoritmo proviene de Mohammed Al-Khowizmi matemático

persa del siglo IX que alcanzó gran reputación por el enunciado de las
reglas paso a paso para sumar, restar, multiplicar y dividir números
decimales; la traducción al latín del apellido en la palabra algorismus
derivó posteriormente en algoritmo.
"Un algoritmo se define como un método que se realiza paso a paso para
solucionar un problema que termina en un número finito de pasos".
8
La idea básica de un algoritmo es describir un proceso de manera

tan precisa y carente de ambigüedad que resulte mecánico en el sentido de
que no se requiera mucha inteligencia y pueda ser realizado de memoria o
por una máquina.
Las características fundamentales que debe cumplir todo algoritmo son:
 Debe ser preciso. e indicar el orden de realización de cada paso.

 Debe ser definido. Si se sigue un algoritmo dos veces, se debe
obtener el mismo resultado cada vez.
 Debe ser finito. Si se sigue un algoritmo, se debe terminar en
algún momento; o sea debe tener un número finito de pasos.
La definición de un algoritmo debe describir tres partes: Entrada,
Proceso y Salida.
1.4 Algoritmos Cotidianos

Se refiere a todos aquéllos algoritmos que nos ayudan a resolver
problemas diarios, y que los hacemos casi sin darnos cuenta de que
estamos siguiendo una metodología para resolverlos.
Algunos ejemplos son :
1.- Diseñar un algoritmo para cambiar una llanta a un coche.
Inicio.
Traer gato.
Levantar el coche con el gato.
Aflojar tornillos de las llantas.
Sacar los tornillos de las llantas.
Quitar la llanta.
Poner la llanta de repuesto.
Poner los tornillos.
Apretar los tornillos.
9
Bajar el gato.
Fin
2.- Un cliente ejecuta un pedido a una fábrica. La fábrica examina en su

banco de datos la ficha del cliente, si el cliente es solvente entonces
la empresa acepta el pedido, en caso contrario rechazar el pedido.
Pasos del algoritmo :
Inicio
Leer el pedido
Examinar ficha del cliente
Si el cliente es solvente aceptar pedido, en caso contrario

rechazar pedido
Fin
1.5 Definición de Lenguajes Algorítmicos
Los algoritmos pueden describirse utilizando diversos lenguajes. Cada uno

de estos lenguajes permiten describir los pasos con mayor o menor
detalle. La clasificación de los lenguajes para algoritmos puede
enunciarse de la siguiente manera:
 Lenguaje Natural.
 Lenguaje de Diagrama de Flujo.
 Lenguaje Natural de Programación.
 Lenguaje de Programación de Algoritmos
Lenguaje Natural: Es aquél que describe en español, para nuestro caso,

los pasos a seguir utilizando un vocabulario cotidiano. Se le conoce
como lenguaje jerga cuando se utilizan términos especializados de una
determinada ciencia, profesión o grupo.
10
Lenguaje de Diagrama de Flujo: Es aquél que se vale de diversos símbolos

para representar las ideas o acciones a desarrollar. Es útil para
organizar las acciones o pasos de un algoritmo pero requiere de etapas
posteriores para implementarse en un sistema de cómputo.
Lenguaje Natural de Programación: Son aquéllos que están orientados a la

solución de problemas que se definen de una manera precisa. Generalmente
son aplicados para la elaboración de fórmulas o métodos científicos.
Lenguaje de Programación de Algoritmos: Es un conjunto de palabras,

símbolos y reglas sintácticas mediante los cuales puede indicarse a la
computadora los pasos a seguir para resolver un problema. Los lenguajes
de programación pueden clasificarse por diversos criterios, siendo el más
común su nivel de semejanza con el lenguaje natural, y su capacidad de
manejo de niveles internos de la máquina. En párrafos anteriores se ha
especificado los lenguajes de programación, así como sus tipos.
II. METODOLOGÍA PARA LA RESOLUCIÓN DE PROBLEMAS
2.1 Definición del problema
Está dada en sí por el enunciado del problema, el cual debe ser

claro y complejo. Es importante que conozcamos exactamente "que se desea
obtener al final del proceso"; mientras esto no se comprenda no puede
pasarse a la siguiente etapa.
2.2 Análisis de los datos
Para poder definir con precisión el problema se requiere que las

especificaciones de entrada y salida sean descritas con detalle ya que
esto es un requisito para lograr una solución eficaz. Una vez que el
11
problema ha sido definido y comprendido, deben analizarse los siguientes

aspectos :
 Los resultados esperados.

 Los datos de entrada disponibles.
 Herramientas a nuestro alcance para manipular los datos y alcanzar
un resultado (fórmulas, tablas, accesorios diversos).
Una medida aconsejable para facilitar esta etapa consiste en colocarnos

en lugar de la computadora deduciendo los elementos que necesitaremos
para alcanzar el resultado.
Ejemplo: Leer el radio de un círculo y calcular e imprimir su superficie

y circunferencia.
Análisis: Las entradas de datos en este problema se concentran en el

radio del círculo. Dado que el radio puede tomar cualquier valor dentro
del rango de los números reales, el tipo de datos radio debe ser real.
Las salidas serán dos variables : superficie y circunferencia que también

serán de tipo real.
Entradas : Radio del círculo (variable RADIO).
Salidas : Superficie del círculo (variable AREA), Circunferencia del

círculo (variable CIRCUNFERENCIA).
Variables : RADIO, AREA, CIRCUNFERENCIA tipo real.
2.3 Diseño de la solución
Una computadora no tiene capacidad para solucionar problemas más

que cuando se le proporcionan los sucesivos pasos a realizar, esto se
refiere a la obtención de un algoritmo que resuelva adecuadamente el
problema. En caso de obtenerse varios algoritmos, seleccionar uno de
ellos utilizando criterios ya conocidos. Esta etapa incluye la
descripción del algoritmo resultante en un lenguaje natural, de diagrama
de flujo o natural de programación.
12
Como puede verse, solo se establece la metodología para alcanzar la

solución en forma conceptual, es decir; sin alcanzar la implementación en
el sistema de cómputo. De acuerdo al ejemplo anterior tenemos que la
información proporcionada constituye su entrada y la información
producida por el algoritmo constituye su salida. Los problemas complejos
se pueden resolver más eficazmente por la computadora cuando se dividen
en subproblemas que sean más fácil de solucionar.
2.4 Codificación
Se refiere a la obtención de un programa definitivo que pueda ser

comprensible para la máquina. Incluye una etapa que se reconoce como
compilación. Si la codificación original se realizó en papel, previo a la
compilación deberá existir un paso conocido como trascripción.
2.5 Prueba y depuración
Una vez que se ha obtenido el programa ejecutable, este es sometido

a prueba a fin de determinar si resuelve o no el problema planteado en
forma satisfactoria. Las pruebas que se le aplican son de diversa índole
y generalmente dependen del tipo de problema que se está resolviendo.
Comúnmente se inicia la prueba de un programa introduciendo datos
válidos, inválidos e incongruentes y observando como reacciona en cada
ocasión. El proceso de depuración consiste en localizar los errores y
corregirlos en caso de que estos existan. Si no existen errores, puede
entenderse la depuración como una etapa de refinamiento en la que se
ajustan detalles para optimizar el desempeño del programa.
2.6 Documentación
Debido a que el programa resultante en esta etapa se encuentra totalmente

depurado (sin errores), se procede a la utilización para resolver
problemas del tipo que dio origen a su diseño.
13
En vista de que esta utilización no podrá ser supervisada en todas las

ocasiones por el programador, debe crearse un manual o guía de operación
que indique los pasos a seguir para utilizar el programa.
2.7 Mantenimiento
Se refiere a las actualizaciones que deban aplicarse al programa

cuando las circunstancias así lo requieran. Este programa deberá ser
susceptible de ser modificado para adecuarlo a nuevas condiciones de
operación.
Cualquier actualización o cambio en el programa deberá reflejarse en su

documentación
III. ENTIDADES PRIMITIVAS PARA EL DISEÑO DE

INSTRUCCIONES
3.1 Tipos de Datos
En 'C' existen básicamente cuatro tipos de datos, aunque como

se verá después, podremos definir nuestros propios tipos de datos
a partir de estos cuatro. A continuación se detalla su nombre, el
tamaño que ocupa en memoria y el rango de sus posibles valores.
TIPO TAMAÑO RANGO DE VALORES

char 1 byte -128 a 127
int 2 bytes -32768 a 32767
float 4 bytes -3.4e-38 a 3.4e38
double 8 bytes 1.7e-308 a 1.7e308
3.1.1 El tipo Int
En una variable de este tipo se almacenan números enteros

(sin decimales). El rango de valores que admite es -32767 a 32767.
Cuando definimos una variable lo que estamos haciendo es decirle
al compilador que nos reserve una zona de la memoria para
14
almacenar datos de tipo int. Para guardarla necesitaremos 16 bits

de la memoria del ordenador (216=32767). Para poder usar una
variable primero hay que declararla (definirla). Hay que decirle
al compilador que queremos crear una variable y hay que indicarle
de qué tipo.
Por ejemplo:
int numero;
Podemos declarar más de una variable en una sola línea:
int x, y;
Esto hace que declaremos una variable llamada "numero" que va

a contener un número entero.
Asignar valores a variables de tipo int
La asignación de valores es tan sencilla como:

x = 10;
También se puede dar un valor inicial a la variable cuando se

define:
int x = 15;
También se pueden inicializar varias variables en una sola línea:

int x = 15, y = 20;
Hay que tener cuidado con lo siguiente:

int x, y = 20;
Podríamos pensar que "x" y "y" son igual a 20, pero no es así. La
variable x está sin valor inicial y la variable y tiene el valor
20.
Ejemplo:
#include <stdio.h>
void main()
{
int x = 10;
prinft( "El valor inicial de x es %dn", x );
x = 50;
printf( "Ahora el valor es %d\n", x );
}
Cuya salida será:

El valor inicial de x es 10
Ahora el valor es 50
¡ Importante !
15
Si imprimimos una variable a la que no hemos dado ningún

valor no obtendremos ningún error al compilar pero la variable
tendrá un valor cualquiera. Prueba el ejemplo anterior quitando
int x = 10;
Puede que te imprima el valor 10 o puede que no.
3.1.2 El tipo Char
Las variables de tipo char sirven para almacenar caracteres.

Los caracteres se almacenan en realidad como números del 0 al 255.
Los 128 primeros (0 a 127) son el ASCII estándar. El resto es el
ASCII extendido y depende del idioma y del ordenador. Consulta la
tabla ASCII en el anexo.
Para declarar una variable de tipo char hacemos:

char letra;
En una variable char sólo podemos almacenar solo una letra,

no podemos almacenar ni frases ni palabras. Eso lo veremos más
adelante (strings, cadenas).
Asignar valores a variables de tipo char
Para almacenar un dato en una variable char tenemos dos

posibilidades:
letra = 'A';
o
letra = 65;
En ambos casos se almacena la letra 'A' en la variable. Esto

es así porque el código ASCII de la letra 'A' es el 65.
Para imprimir un char usamos el símbolo %c (c de

character=caracter en inglés):
letra = 'A';
printf( "La letra es: %c.", letra );
resultado:
La letra es A.
También podemos imprimir el valor ASCII de la variable usando %i

en vez de %c:
letra = 'A';
printf( "El número ASCII de la letra %c es: %i.", letra,
letra );
resultado:
El código ASCII de la letra A es 65.
16
Como vemos la única diferencia para obtener uno u otro es el

modificador (%c ó %i) que usemos.
Las variables tipo char se pueden usar (y de hecho se usan

mucho) para almacenar enteros. Si necesitamos un número pequeño
(entre -127 y 127) podemos usar una variable char (8 bits) en vez
de una int (16 bits), con el consiguiente ahorro de memoria.
Todo lo demás dicho para los datos de tipo int se aplica también a
los de tipo char.
Una curiosidad:
letra = 'A';
printf( "La letra es: %c y su valor ASCII es: %i\n", letra,
letra );
letra = letra + 1;
printf( "Ahora es: %c y su valor ASCII es: %i\n", letra,
letra );
En este ejemplo letra comienza con el valor 'A', que es el

código ASCII 65. Al sumarle 1 pasa a tener el valor 66, que
equivale a la letra 'B' (código ASCII 66). La salida de este
ejemplo sería:
La letra es A y su valor ASCII es 65

Ahora es B y su valor ASCII es 66
3.1.2 El tipo Float
En este tipo de variable podemos almacenar números decimales,

no sólo enteros como en los anteriores. El rango de posibles
valores es del 3.4e-38 al 3.4e38.
Declaración de una variable de tipo float:

float numero;
Para imprimir valores tipo float Usamos %f.

float num=4060.80;
printf( "El valor de num es : %f", num );
Resultado:
El valor de num es: 4060.80
Si queremos escribirlo en notación exponencial usamos %e:

float num = 4060.80;
printf( "El valor de num es: %e", num );
Que da como resultado:

El valor de num es: 4.06080e003
17
3.1.2 El tipo Double
En las variables tipo double se almacenan números reales del

1.7e-307 al 1.7e308. Se declaran como double:
double numero;
Para imprimir se usan los mismos modificadores que en float.
3.2 Operadores y Operandos
Un Operando es cada una de las constantes, variables o

expresiones que intervienen en una expresión, mientras que un
Operador es cada uno de los símbolos que indican las operaciones a
realizar sobre los operandos, así como los operandos a los que
afecta.
A continuación se explican los tipos de operadores
(aritméticos y de asignación) que permiten realizar operaciones
matemáticas en lenguaje C.
3.2.1 Operadores aritméticos
Existen dos tipos de operadores aritméticos:
Los binarios:
+ Suma
- Resta
* Multiplicación
/ División
% Módulo (resto)
Los unarios:
++ Incremento (suma 1)
- - Decremento (resta 1)
- Cambio de signo
Su sintaxis es:
binarios:
<variable1><operador><variable2>
unarios:
<variable><operador> y al revés, <operador><variable>.
/* Uso de los operadores aritméticos */
18
#include <stdio.h>
main() /* Realiza varias operaciones */

{
int a=1,b=2,c=3,r;
r=a+b;
printf("%d + %d = %d\n",a,b,r);
r=c-a;
printf("%d - %d = %d\n",c,a,r);
b++;
printf("b + 1 = %d",b);
}
A continuación se explican los tipos de operadores

(aritméticos y de asignación) que permiten realizar operaciones
matemáticas en lenguaje C.
3.2.2 Operadores de asignación
La mayoría de los operadores aritméticos binarios explicados

en el capítulo anterior tienen su correspondiente operador de
asignación:
= Asignación simple
+= Suma
-= Resta
*= Multiplicación
/= División
%= Módulo (resto)
Con estos operadores se pueden escribir, de forma más breve,

expresiones del tipo:
n=n+3 se puede escribir n+=3
/* Uso de los operadores de asignación */
#include <stdio.h>
main() /* Realiza varias operaciones */

{
int a=1,b=2,c=3,r;
a+=5;
printf("a + 5 = %d\n",a);
c-=1;
printf("c - 1 = %d\n",c);
b*=3;
printf("b * 3 = %d",b);
}
19
3.2.3 Jerarquía de los operadores
Será importante tener en cuenta la precedencia de los

operadores a la hora de trabajar con ellos:
( ) Mayor precedencia
++, - -
*, /, %
+, - Menor precendencia
Las operaciones con mayor precedencia se realizan antes que

las de menor precedencia.
Si en una operación encontramos signos del mismo nivel de

precedencia, dicha operación se realiza de izquierda a derecha. A
continuación se muestra un ejemplo sobre ello:
a*b+c/d-e
1. a*b resultado = x
2. c/d resultado = y
3. x+y resultado = z
4. z-e
Fijarse que la multiplicación se resuelve antes que la

división ya que está situada más a la izquierda en la operación.
Lo mismo ocurre con la suma y la resta.
IV. TÉCNICAS DE DISEÑO

4..1 Top Down
También conocida como de arriba-abajo y consiste en
establecer una serie de niveles de mayor a menor complejidad
(arriba-abajo) que den solución al problema. Consiste en efectuar
una relación entre las etapas de la estructuración de forma que
una etapa jerárquica y su inmediato inferior se relacionen
mediante entradas y salidas de información. Este diseño consiste
en una serie de descomposiciones sucesivas del problema inicial,
que recibe el refinamiento progresivo del repertorio de
instrucciones que van a formar parte del programa.
La utilización de la técnica de diseño Top-Down tiene los

siguientes objetivos básicos:
20
 Simplificación del problema y de los subprogramas de cada

descomposición.
 Las diferentes partes del problema pueden ser programadas de
modo independiente e incluso por diferentes personas.
 El programa final queda estructurado en forma de bloque o
módulos lo que hace mas sencilla su lectura y mantenimiento.
4.2 Bottom Up
El diseño ascendente se refiere a la identificación de

aquellos procesos que necesitan computarizarse con forme vayan
apareciendo, su análisis como sistema y su codificación, o bien,
la adquisición de paquetes de software para satisfacer el problema
inmediato.
Cuando la programación se realiza internamente y haciendo un

enfoque ascendente, es difícil llegar a integrar los subsistemas
al grado tal de que el desempeño global, sea fluido. Los problemas
de integración entre los subsistemas son sumamente costosos y
muchos de ellos no se solucionan hasta que la programación alcanza
la fecha limite para la integración total del sistema. En esta
fecha, ya se cuenta con muy poco tiempo, presupuesto o paciencia
de los usuarios, como para corregir aquellas delicadas interfaces,
que en un principio, se ignoran. Aunque cada subsistema parece
ofrecer lo que se requiere, cuando se contempla al sistema como
una entidad global, adolece de ciertas limitaciones por haber
tomado un enfoque ascendente.
Uno de ellos es la duplicación de esfuerzos para acceder el
software y mas aún al introducir los datos.
4.3 Warnier Orr
Los diagramas de Warnier/Orr (también conocidos como

construcción lógica de programas/construcción lógica de sistemas)
fueron desarrollados inicialmente en Francia por Jean Dominique
Warnier y en los Estados Unidos por Kenneth Orr. Este método ayuda
al diseño de estructuras de programas identificando la salida y
resultado del procedimiento, y entonces trabaja hacia atrás para
determinar los pasos y combinaciones de entrada necesarios para
producirlos. Los sencillos métodos gráficos usados en los
diagramas de Warnier/Orr hacen evidentes los niveles en un sistema
y más claros los movimientos de los datos en dichos niveles.
21
4.3.1 Elementos Básicos
Los diagramas de Warnier/Orr muestran los procesos y la secuencia

en que se realizan. Cada proceso se define de una manera
jerárquica ; es decir, consta de conjuntos de subprocesos que lo
definen, en cada nivel, el proceso se muestra en una llave que
agrupa a sus componentes. Puesto que un proceso puede tener muchos
subprocesos distintos, un diagrama de Warnier/Orr usa un conjunto
de llaves para mostrar cada nivel del sistema.
4.3.2 Uso de diagramas de Warnier / Orr
La capacidad de mostrar la relación entre procesos y pasos de

un proceso no es exclusiva de los diagramas de Warnier/Orr, así
como tampoco lo es el uso de la iteración, selección de
alternativas o el tratamiento de casos individuales. Tanto los
diagramas de flujo estructurado y los métodos del español
estructurado logran eso también. Sin embargo, el enfoque que se
usa para desarrollar las definiciones de un sistema por medio de
estos diagramas es distinto y se adapta y se adaptan bien a los
que se usan en el diseño de sistemas lógicos.
Para desarrollar un diagrama de Warnier/Orr , el analista
trabaja hacia atrás, empezando con la salida del sistema y usando
un análisis orientado hacia la salida. En el papel el desarrollo
se mueve de izquierda a derecha. En primer lugar, se definen la
salida o resultados esperados del procedimiento. En el nivel
siguiente, mostrado mediante la inclusión por medio de una llave,
se definen los pasos necesarios para producir la salida. A su vez,
cada paso se define un poco mas. Las llaves adicionales agrupan
los procesos requeridos para producir el resultado en el siguiente
nivel.
Los diagramas de Warnier/Orr ofrecen a los expertos en

sistemas algunas ventajas distintivas. Son simples en apariencia y
fáciles de entender. Aun así, son poderosas herramientas de
diseño. Tienen la ventaja de mostrar agrupaciones de procesos y
los datos que deben transferirse de nivel a nivel. Además, la
secuencia del trabajo hacia atrás garantiza que el sistema estará
orientado hacia el resultado.
La diferencia entre estas dos técnicas de programación se

fundamenta en el resultado que presentan frente a un problema
dado.
22
Imagine una empresa, la cual se compone de varios

departamentos (contabilidad, mercadeo), en cada uno de ellos se
fueron presentando problemas a los cuales se le dieron una
solución basados en un enfoque ascendente (Bottom Up): creando
programas que satisfacían sólo el problema que se presentaba.
Cuando la empresa decidió integrar un sistema global para suplir
todas las necesidades de todos los departamentos se dio cuenta que
cada una de las soluciones presentadas no era compatible la una
con la otra, no representaba una globalidad, característica
principal de los sistemas.
Como no hubo un previo análisis, diseño de una solución a

nivel global en todos sus departamentos, centralización de
información, que son características propias de un diseño
Descendente (Top Down) y características fundamentales de los
sistemas; la empresa no pudo satisfacer su necesidad a nivel
global. La creación de algoritmos es basado sobre la técnica
descendente, la cual brinda el diseño ideal para la solución de un
problema.
23
V. TÉCNICAS PARA LA FORMULACIÓN DE ALGORITMOS
Las técnicas analizadas en la unidad anterior permiten un diseño

global del algoritmo, pero ocasionalmente pueden desatender detalles
específicos de este. Las tres técnicas de formulación de algoritmos más
populares son :
 Diagrama de flujo
 Pseudo código
 Diagramas estructurados
4.2 Diagramas de Flujo
Los diagramas de flujo representan la forma más tradicional para

especificar los detalles algorítmicos de un proceso. Se utilizan
principalmente en programación, economía y procesos industriales; estos
diagramas utilizan una serie de símbolos con significados especiales. Son
la representación gráfica de los pasos de un proceso, que se realiza para
entender mejor al mismo. Son modelos tecnológicos utilizados para
comprender los rudimentos de la programación lineal.
Otra definición del diagrama de flujo es la siguiente:
"Es un esquema para representar gráficamente un algoritmo. Se basan en la

utilización de diversos símbolos para representar operaciones
específicas. Se les llama diagramas de flujo porque los símbolos
utilizados se conectan por medio de flechas para indicar la secuencia de
operación. Para hacer comprensibles los diagramas a todas las personas,
los símbolos se someten a una normalización; es decir, se hicieron
símbolos casi universales, ya que, en un principio cada usuario podría
tener sus propios símbolos para representar sus procesos en forma de
Diagrama de Flujo. Esto trajo como consecuencia que sólo aquel que
conocía sus símbolos, los podía interpretar. La simbología utilizada para
24
la elaboración de diagramas de flujo es variable y debe ajustarse a un

patrón definido previamente."
A continuación se muestran lo símbolos más utilizados, así como su

significado
25
4.3 Simbología de los diagramas de flujo
26
Ejemplo:
27
Calcular el salario neto de un trabajador en función del número

de horas trabajadas, precio de la hora de trabajo y considerando unos
descuentos fijos al salario bruto en concepto de impuestos (20 por 100).
A continuación se muestra el diagrama de flujo que permite resolver el

problema planteado.
28
Ejemplo:
Realizar un diagrama de flujo que permita mostrar en pantalla un mensaje

de mayoría o minoría de edad según sea el caso para un nombre específico.
29
4.4 Pseudocódigo
Es un lenguaje de especificación de algoritmos. El uso de tal

lenguaje hace el paso de codificación final (esto es, la traducción a un
lenguaje de programación) relativamente fácil.
El pseudocódigo nació como un lenguaje similar al inglés y era un

medio representar básicamente las estructuras de control de programación
estructurada. Se considera un primer borrador, dado que el pseudocódigo
tiene que traducirse posteriormente a un lenguaje de programación. Cabe
señalar que el pseudocódigo no puede ser ejecutado por una computadora.
La ventaja del pseudocódigo es que en su uso en la planificación

de un programa, el programador se puede concentrar en la lógica y en las
estructuras de control y no preocuparse de las reglas de un lenguaje
específico. Es también fácil modificar el pseudocódigo si se descubren
errores o anomalías en la lógica del programa, además de todo esto es
fácil su traducción a lenguajes como pascal, COBOL, C, FORTRAN o BASIC.
El pseudocódigo utiliza para representar las acciones sucesivas

palabras reservadas en inglés (similares a sus homónimos en los lenguajes
de programación), tales como star,begin, end, stop, if-then-else, while,
repeat-until….etc
Secuencia
Inicio
acción1
acción2
acción n
Fin
Decisión
Simple
si condición entonces
30
acción 1
acción 2
acción n
Doble
si condición entonces
acción1
acción2
en caso contrario
acción1
acción2
Iteración
Fija
para var. Entera inicial hasta

final hacer
acciòn 1
acciòn 2
acciòn n
Condicional al inicio
mientras condición hacer
acción 1
acción 2
acción n
31
Condicional al final
Repetir
acción1
acción2
acción n
Hasta que condición
Selección
casos selector de
valor1 : acción1
acción2
valor2 : acción1
acción2
valor n : acción1
acción2
Ejercicio :
Se requiere preguntar dos valores, y a continuación ofrecer un menú con

las operaciones básicas (+, -, *, /). Después de presentar el resultado
se ofrecerá la posibilidad de una nueva operación.
Declaración de variables :
Real : X, Y, RESPUESTA
Entero : OPCION
32
Carácter : OP
Inicio
Repetir
escribir(‘Primer valor : ’ )
leer(X)
escribir(‘Segundo valor : ‘)
leer(Y)
escribir(‘1) Suma ‘)
escribir(‘2) Resta ‘)
escribir(‘3) Multiplicación ‘)
escribir(‘4) División ‘)
escribir(‘Qué operación deseas realizar ? : ‘)
l eer(OPCION)
casos OPCION de
1 : RESULTADO X+Y
2 : RESULTADO X-Y
3 : RESULTADO X*Y
4 : si Y=0 entonces escribir(‘ Error ‘)
RESULTADO 0
en caso contrario
RESULTADO X/Y
escribir (‘Resultado : ‘,RESULTADO)
escribir(‘Deseas otro cálculo : [S/N] ‘)
leer(OP)
33
Hasta que RES = ‘N’
Fin
Ejercicio :
Preguntar un nombre y repetirse en pantalla tantas veces como se desee.

(preguntar cantidad de repeticiones), indicando el número de repetición.
Declaración de variables
Cadena : nom
entero : x, n
Inicio
escribir(‘Nombre : ‘)
leer(nom)
escribir(‘Cuántas veces quieres repetirlo ? : ‘)
leer(n)
para x 1 hasta n hacer
escribir(x’.- ‘, nom)
Fin
4.5 Diagramas Estructurados (Nassi - Schneiderman)
El diagrama N-S de Nassi-Schneiderman, también conocido como

diagrama de Chapin, es como un diagrama de flujo en el que se omiten las
flechas de unión y las cajas son contiguas. Las acciones sucesivas se
escriben en cajas sucesivas, y, como en los diagramas de flujo, se pueden
escribir diferentes acciones en una caja.
34
Los Diagramas Estructurados, son una técnica que permite formular

algoritmos mediante una representación geométrica y de asignación de
espacios de un bloque específico.
Un algoritmo se representa de la manera siguiente:
Nombre del Algoritmo
Acciòn 1
Acciòn 2
Acciòn N
Fin
Una estructura condicional en N-S se representa de la siguiente manera :
Ejemplo:
Se desea calcular el salario neto semanal de un trabajador en función del

número de horas trabajadas y la tasa de impuestos.
35
VI. ESTRUCTURAS ALGORITMICAS
Una vez que se conocen los símbolos utilizados en los

algoritmos, se puede empezar a construir estructuras que se
utilizaràn en la resolución de un problema determinado. Entre
estas se pueden mencionar:
 Secuenciales
 Condicionales
6.1 Estructura Secuencial
Es aquélla en la que una acción (instrucción) sigue a otra en

secuencia. Las tareas se suceden de tal modo que la salida de una
es la entrada de la siguiente y así sucesivamente hasta el fin del
proceso. La estructura secuencial tiene una entrada y una salida.
Su representación gráfica es la siguiente:
DIAGRAMA N-S DE UNA ESTRUCTURA SECUENCIAL:

Acciòn 1
Acciòn 2
Acciòn 3
36
PSEUDOCODIGO DE UNA ESTRUCTURA SECUENCIAL:

Inicio
acciones
:
:
fin
Ejemplo:
Calcular el salario neto de un trabajador en función del número de
horas trabajadas, precio de la hora de trabajo y considerando unos
descuentos fijos al sueldo bruto en concepto de impuestos (20 por
100).
Pseudocódigo
Inicio
{cálculo salario neto}
leer nombre, horas, precio_hora
salario_bruto <- horas * precio
impuestos <- 0.20 * salario_bruto
salario_neto <- salario_bruto_impuestos
escribir nombre, salario_bruto, salario_neto_bruto, salario_neto
Fin
El diagrama de flujo quedaría de la siguiente manera
37
Diagrama N-S
6.2 Estructura Condicionales
La especificación formal de algoritmos tiene realmente

utilidad cuando el algoritmo requiere una descripción más
complicada que una lista sencilla de instrucciones. Este es el
caso cuando existen un número de posibles alternativas resultantes
de la evaluación de una determinada condición. Las estructuras
selectivas se utilizan para tomar decisiones lógicas; de ahí que
se suelan denominar también estructuras de decisión o
alternativas.
En las estructuras selectivas se evalúa una condición y en

función del resultado la misma se realiza una opción u otra. Las
condiciones se especifícan usando expresiones lógicas. La
representación de una estructura selectiva se hace con palabras en
pseudocódigo (if, then, else o bien en español si, entonces,
sino), con una figura geométrica en forma de romba o bien con un
triángulo en el interior de una caja rectangular. Las estructuras
selectivas o alternativas pueden ser:
 Simples
 Múltiples

38
6.2.1 Alternativa Simple (si-entonces/if-then)
La estructura alternativa simple si-entonces (en inglés if-

then o bien IF-THEN ) ejecuta una determinada acción cuando se
cumple una determinada condición. La selección si-entonces evalúa
la condición y . . .
 Si la condición es verdadera, entonces ejecuta la acción S1

(o acciones caso de ser S1 una acción compuesta y constar de
varias acciones).
 Si la condición es falsa, entonces no hacer nada.
A continuación se muestra la gráfica de la estructura condicional
simple.
Pseudocódigo en español
Si <condición> Entonces
<acción S1>
Fin_si
Pseudocódigo en inglés
If <condición> then
<acción S1>
end_if
39
Diagrama N-S
6.3 Estructuras Repetitivas
Las estructuras que repiten una secuencia de instrucciones un

número determinado de veces se denominan Bucles y se denomina
Iteración al hecho de repetir la ejecución de una secuencia de
acciones. Entre las estructuras repetitivas se encuentran:
 Mientras (while)
 Repetir (repeat)
 Desde (for)

6.3.1 Estructura Mientras (while)
La estructura repetitiva while, es aquélla en que el cuerpo

del bucle se repite mientras se cumple una determinada condición,
su representación gráfica es:
40
Pseudocódigo en español Pseudocódigo

en inglés
Mientras condición hacer while

condición do
<Acciones>
<Acciones>
Fin_mientras
End_while
Diagrama N-S
Ejemplo:
Contar los números enteros positivos introducidos por teclado. Se
consideran dos variables enteras NUMERO y CONTADOR (contará el
número de enteros positivos). Se supone que se leen números
positivos y se detiene el bucle cuando se lee un número negativo o
cero.
Pseudocódigo
Inicio
Contador <- 0
Leer (numero)
Mientras numero > 0 hacer
Contador <- contador+1
Leer (numero)
Fin_Mientras
Escribir('El número de enteros positivos es :
', contador)
Fin
41
Diagrama de Flujo
Representación en N-S
6.3.2 Estructura Repetir (repeat)
Esta estructura se ejecuta hasta que se cumpla una condición

determinada que se comprueba hasta el final del bucle. Se ejecuta
al menos una vez. El bucle repetir-Hasta_que se repite mientras el
valor de la expresión booleana de la condición sea falsa, justo la
opuesta de la sentencia mientras.
42
Pseudocódigo en Español
Pseudocódigo en Inglés
Repetir
Repeat
<acciones>
<acciones>
:
:
Hasta que <condición>
Until <condición>
Diagrama de Flujo de Repetir
Diagrama N-S de Repetir
6.3.3 Estructura Desde/Para (for)
En muchas ocasiones se conoce de antemano el número de veces

que se desean ejecutar las acciones de un bucle. En estos casos
en el que el número de iteraciones es fija, se debe usar la
estructura desde o para. La estructura Desde ejecuta las acciones
del cuerpo del bucle un número específico de veces y de modo
automático controla el número de iteraciones o pasos a través del
cuerpo del bucle.
43
Pseudocódigo en Español
Pseudocódigo en Inglés
Desde variable(v)= vi Hasta vf hacer For

variable (v)= vi To vf Do
<acciones>
<acciones>
Fin_desde
Donde:
v: Variable índice
vi, vf: Valores inicial y final de la variable
Diagrama de Flujo de la estructura Desde/Para
Diagrama N-S de la estructura Desde/Para
44
VII. ARREGLOS
 Vectores
 Matrices
 Manejo de cadenas de caracteres
Arreglo: Un Arreglo es una estructura de datos que almacena bajo el mismo

nombre (variable) a una colección de datos del mismo tipo.
Los arreglos se caracterizan por:
· Almacenan los elementos en posiciones contiguas de memoria
· Tienen un mismo nombre de variable que representa a todos

los elementos. Para hacer referencia a esos elementos es necesario
utilizar un índice que especifica el lugar que ocupa cada elemento
dentro del archivo.
Unidimensionales (Vectores)
Tipo de
Arreglos
Bidimensionales (Matrices)
7.1. Vectores
Es un arreglo de “N” elementos organizados en una dimensión donde “N”

recibe el nombre de longitud o tamaño del vector. Para hacer referencia a
un elemento del vector se usa el nombre del mismo, seguido del índice
(entre corchetes), el cual indica una posición en particular del vector.
Por ejemplo:
Vec[x]
Donde:
45
Vec………… Nombre del arreglo
x…………… Numero de datos que constituyen el arreglo
Representación gráfica de un vector
Vec[1]
7
8
9
Vec[2] 10
Vec[3] Llenado de un Vector
· Hacer para I = 1 a 10
Vec[4] Leer vec[I]
Fin-para
· Hacer mientras I <= 10
Leer vec[I]
Fin-mientras
· I=1
Repetir
Leer vec[I]
I = I + 1
Hasta-que I>10
46
7.2 Matrices
Es un arreglo de M * N elementos organizados en dos dimensiones donde “M”

es el numero de filas o reglones y “N” el numero de columnas.
Para representar una matriz se necesita un nombre de matriz se necesita un

nombre de matriz acompañado de dos índices.
Mat [R,C]
Donde R indica el renglón y C indica la columna, donde se encuentra

almacenado el dato.
Representación gráfica de una matriz
Mat [R,C]
Donde R -> Renglones y C->Columnas
1,1 1,2 1,3 1,4

2,1 2,2 2,3 2.4
3,1 3,2 3,3 3,4
4,1 4,2 4,3 4,4
Llenado de una matriz
· Por renglones
Hacer para R = 1 hasta R< 5
Hacer para C = 1 hasta C< 5
Leer Mat [R,C]
Fin-para
Fin-para
· Por columnas
Hacer para R = 1 hasta R< 5
Hacer para C = 1 hasta C< 5
47
Leer Mat [R,C]
Fin-para
Fin-para
Nota: Para hacer el llenado de una matriz se deben de usar dos variables
para los índices y se utilizan 2 ciclos uno para los renglones y otro para
las columnas; a estos ciclos se les llama ciclos anidados (un ciclo dentro
de otro ciclo).
48

Antologia - Algoritmos Computacionales 1 ITI

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Antologia - Algoritmos Computacionales 1 ITI

Uploaded by

Copyright:

Available Formats

Instituto de Estudios Superiores

M.TL. Juan Carlos González Pinto

4.3 Warnier Orr ............................................................................................................................. 21

I. CONCEPTOS BÁSICOS E HISTORIA

Los sistemas modernos de computación consisten en una gran

Para satisfacer el crecimiento de la demanda de medios de

1.2 Definición de Lenguaje de Programación

Un Lenguaje de Programación es un conjunto de reglas, notaciones,

1.2.2 Objetivos de la programación

En la preparación de un programa, el programador puede tener que

1.2.3 Historia de los Lenguajes de Programación

Veamos un poco de la historia de la evolución de los diferentes

trataban en primera instancia poder resolver problemas del tipo numérico,

Pero el temor a la expansión de un monopolio de la IBM, hizo que el

En 1955 surge la necesidad de crear lenguajes para negocios y con

Pero Backus seguía creando nuevos conceptos, junto con Naur

Fue en 1967 cuando surge el SIMULA 67 creado por Nygaard y Dahl de

En 1963 IBM con los avances de su hardware introduce el NPL ( New

Otro campo en la creación de los lenguajes de programación fue el

En los 80's el hardware iba avanzando permitiendo crear lenguajes

Los lenguajes visuales y actuales tales como VISUAL BASIC, C, FOX

inconveniente por el uso de mucha memoria y espacio en disco ), hacer la

1.2.4 Clasificación de los Lenguajes de Programación

Los programadores escriben instrucciones en diversos lenguajes de

Según su base de desarrollo y su uso en :

 Lenguajes basados en calculo numérico. Tales como Fortran,

Según el tipo de instrucciones de que constan:

 Lenguajes de bajo nivel (ensamblador)

Para facilitar y agilizar su labor a los programadores, se buscaron

Lenguajes de alto nivel

Para acelerar, aún más, el proceso de programación se desarrollan los

Principales lenguajes de alto nivel

Basic Logo ALGOL

Perl ADA Cobol Java

Antes de pasar a definir los siguientes conceptos, se debe hacer un alto

Código Fuente: Le daremos el nombre de código fuente a los programas que

1.3 Definición de algoritmo

El término algoritmo proviene de Mohammed Al-Khowizmi matemático

La idea básica de un algoritmo es describir un proceso de manera

Las características fundamentales que debe cumplir todo algoritmo son:

 Debe ser preciso. e indicar el orden de realización de cada paso.

1.4 Algoritmos Cotidianos

Algunos ejemplos son :

1.- Diseñar un algoritmo para cambiar una llanta a un coche.

Levantar el coche con el gato.

Aflojar tornillos de las llantas.

Sacar los tornillos de las llantas.

Poner la llanta de repuesto.

Poner los tornillos.

Apretar los tornillos.

2.- Un cliente ejecuta un pedido a una fábrica. La fábrica examina en su

Pasos del algoritmo :

Examinar ficha del cliente

Si el cliente es solvente aceptar pedido, en caso contrario

1.5 Definición de Lenguajes Algorítmicos

Los algoritmos pueden describirse utilizando diversos lenguajes. Cada uno

Lenguaje Natural: Es aquél que describe en español, para nuestro caso,

Lenguaje de Diagrama de Flujo: Es aquél que se vale de diversos símbolos

Lenguaje Natural de Programación: Son aquéllos que están orientados a la

Lenguaje de Programación de Algoritmos: Es un conjunto de palabras,

II. METODOLOGÍA PARA LA RESOLUCIÓN DE PROBLEMAS

2.1 Definición del problema

Está dada en sí por el enunciado del problema, el cual debe ser