Conceptos Básicos y Tutorial de Pseudocódigo Desde Cero

12/3/2016 Imprimir Página Conceptos Básicos y Tutorial de Pseudocódigo desde cero.
(+Ejercicios)
Foro de elhacker.net
Programación => Programación General => Mensaje iniciado por: Bruenor Battlehammer en
25 Octubre 2010, 09:35
Título: Conceptos Básicos y Tutorial de Pseudocódigo desde cero. (+Ejercicios)
Publicado por: Bruenor Battlehammer en 25 Octubre 2010, 09:35
Estructuras Básicas de Datos:
Introducción:
Dato: Cualquier información correspondiente a una entidad susceptible de un
tratamiento informático. Ej.: (Entidad: Empresa / Datos: Nombre, Dirección, Nº
Empleados…)
Para un ordenador la información que maneja es numérica (ceros y unos)
“binario”, aún así, los datos tienen que estar clasificados para poder tratarlos
de forma conveniente.
La clasificación de los datos determina las ESTRUCTURAS DE DATOS de un
lenguaje.
Un dato se caracteriza por llevar asociado los siguientes elementos:
Identificador: nombre que permite referenciar el dato.
Los identificadores de los datos deben cumplir una serie de condiciones:
a Pueden estar constituidos por letras, dígitos y el carácter “_”
b No pueden contener espacios.
c El nº de caracteres y dígitos máximos dependen del compilador utilizado.
d Deben comenzar por una letra
e Deben dar alguna pista para reconocer el dato que van a referenciar.
Tipo: Determina el rango de valores que van a ser posibles para ese dato.
Ej.: EDAD: Nº entero.
Valor inicial: Valor perteneciente al rango determinado por el tipo asociado al
identificador.
Tipos de datos:
Clasificación de los datos:
Datos Básicos
Numéricos: Entero, Real
No Numéricos: Carácter, Lógico
Derivados: Puntero
Datos Estructurados:
Internos:
Estáticos lineales: Tablas
Dinámicos Lineales: Listas, Pilas, Colas
No lineales: Árboles, Grafos
Externos: Ficheros, Bases de Datos
http://foro.elhacker.net/printpage.html;topic=308772.0 1/26
12/3/2016 Imprimir Página Conceptos Básicos y Tutorial de Pseudocódigo desde cero. (+Ejercicios)
Compuestos: Estructura de Datos, Registro
Puntero: Funciona con direcciones de memoria asociadas.
Existe un operador que permite obtenerlas, pero ya lo trataremos más
adelante.
Datos estructurados: Compuestos de datos básicos.
(Internos: Memoria Temporal / Externos: Dispositivos de Almacenamiento)
Datos dinámicos: Reservas de memoria en tiempo de ejecución.
Lista: Se accede y llena en cualquier orden.
Pila: Se insertan los datos en orden, se extraen en orden inverso.
Cola: Obligatorio insertarlos en orden y extraerlos en ese mismo orden.
Datos estáticos: Reservan una cantidad fija de memoria (En tiempo de
compilación)
Datos Básicos:
Datos numéricos: Se utilizan para contener magnitudes y se dividen en
enteros y reales.
a Enteros: Se emplean para representar números enteros, el rango de
representación depende del compilador y del ordenador. Los datos de tipo
entero aparecen representados por los dígitos decimales, que pueden ir
precedidos por los signos + o . Ej.: 35 +3200.
b Reales: Se emplean para representar números con parte fraccionaria o
números Enteros muy grandes o muy pequeños que están fuera del rango
establecido para los enteros.
Para su representación se utilizan dos formatos:
• Decimal: Dígitos del 0 a 9 y el punto decimal que separa la parte entera de la
fraccionaria.
• Formato Científico o Exponencial: <mantisa><E><característica>
Mantisa: Nº real decimal.
E: Base 10
Característica: Exponente.
La representación interna viene determinada por la precisión:
• Para simple precisión (32 bits)
o Signo 1bit (posición 31)
o Exponente 8bits (posiciones 23 a 30)
o Mantisa 23bits (posiciones 0 a 22)
• Para doble precisión (64 bits)
o Signo 1bit (posición 63)
o Exponente 11bits (posiciones 52 a 62)
o Mantisa 52bits (posiciones 0 a 51)
Datos No numéricos:
a Carácter: Se emplea para representar un carácter dentro de un conjunto
definido por el fabricante del ordenador, de tal manera que cada carácter se
corresponda con un nº entero, según un determinado código. Ej.: Código ASCII.
Se representan encerrando el carácter entre comillas simples, existen los
siguientes tipos de caracteres:
o Dígitos: ‘1’,’0’,’9’…
o Alfabéticos: ‘A’,’a’,’b’…
o Alfabéticos: ‘A’,’a’,’b’…
o Especiales: ‘*’,’_’…
La representación interna depende del código utilizado, los códigos más
empleados son los que utilizan 8 bits, como por ejemplo el ASCII (American
Standard Code for Information Interchange) o el EBCDIC (Extended Binary
Coded Decimal Interchange Code)
Ej.: A = 65 = 01000001
En algunos lenguajes como el COBOL se considera tipo de dato básico a las
cadenas alfanuméricas. Estas se representan encerradas entre dobles comillas.
Ej.: “I.E.S Dr. Fleming Nº25”
En C no es un tipo de dato básico (Se usan tablas)
b Lógico: Es un tipo de dato que solo puede tomar dos valores, se pueden
representar como Cierto y Falso, True y False, V y F.
Internamente se representa con un ‘0’ para false y un ‘1’ para true.
En C ‘0’ es false, mientras que cualquier otra cosa se considera como true.
Variables y Constantes:
Memoria Central: Dispositivo de almacenamiento temporal de:
• Datos
• Instrucciones
• Resultados de un programa:
o Intermedios
o Finales
Consideremos la memoria como una caja dividida en compartimentos. Cada
compartimento es del mismo tamaño y está identificado por una dirección de
memoria. Los compartimentos se suelen denominar celdas, las direcciones,
posiciones de memoria.
Cada celda tiene una dirección distinta que permite identificarla. Esto nos
permite almacenar y recuperar datos de la Memoria Central.
Nota: Las cadenas no se pueden meter en una sola dirección de memoria, sino
que usan varias simultáneamente.
Almacenar algo en una posición usada sobrescribe lo anterior por lo tanto:
La escritura en memoria es destructiva, mientras que la lectura no lo es.
Las zonas de memoria no están vacías a menos que se sobrescriban
intencionadamente.
Las direcciones de memoria se pueden identificar con un nombre, el sistema se
encarga de asignar una dirección concreta a ese nombre. (En lenguajes de
programación de alto nivel)[C o superior].
Variable: Zona de memoria referenciada con un nombre de variable que va a
contener un dato.
Nota: Una variable NO es un dato, contiene un dato.
Para que una variable esté perfectamente definida hay que indicarle:
• Un nombre (identificador)
• Un tipo de dato
• Un valor inicial
Para introducir un valor en una variable se realiza lo siguiente:
Para introducir un valor en una variable se realiza lo siguiente:
Código:
<variable> = <valor>
A este hecho se le llama Asignación de Variables.
Para recuperar el valor basta con nombrar la variable:
Código:
<variable>
(haciendo esto la máquina tomará <valor> de la memoria y sustituirá la
variable por dicho valor en la ejecución)
En función del dato asignado a la variable, se pueden clasificar en numéricas,
enteras, reales, alfanuméricas, caracteres y lógicas.
Asignación: Introducción de un valor o del contenido de otra variable en una
zona de memoria referenciada por ese nombre de variable. = se usa tanto
como asignación, como para preguntar al sistema si es igual.
Nota: Se aconseja usar ‘==’ para preguntar si es igual y ‘=’ para asignar, esto
ayudará a diferenciar ambas tareas de forma sencilla a la hora de revisar el
código.
Tanto la variable receptora como la otra tienen que ser del mismo tipo para
realizar la asignación del valor de una variable a otra.
Código:
<variable1> = <variable2>
Constante: Es una zona de memoria referenciada con un nombre de
constante, cuyo valor no puede cambiar a lo largo de la ejecución de un
programa.
Las constantes pueden ser numéricas, enteras o reales, alfanuméricas o de
carácter.
Las constantes lógicas no tienen sentido.
Operadores:
Operadores: Símbolos que permiten conectar datos, variables y constantes con
el fin de realizar una operación determinada.
Operador Símbolo Significado
Paréntesis () Paréntesis
Aritméticos **,^ Potencia
* Producto
/ División Real
DIV,\ División Entera
%,mod Resto de una división entera
+ Suma
Resta
+ Concatenación
Concatenación eliminando espacios en blanco
Relacionales ==,= Igual, Asignación
!=,<> Distinto
< Menor
<= Menor o Igual
> Mayor
>= Mayor o Igual
Lógicos !,NOT,NO Negación
ff,AND,Y Conjunción
||,OR,O Disyunción
AB AND AB OR A NOT
00 0 00 0 0 1
01 0 01 1 1 0
10 0 10 1
11 1 11 1
Existen reglas de prioridad entre los distintos operadores, dependen de los
lenguajes de programación, pero en general son los siguientes:
1. Paréntesis
2. Signo
3. Potencia
4. Producto, División y Módulo (Resto)
5. Suma y Resta
6. Concatenación
7. Relacionales
8. Negación
9. Conjunción
10. Disyunción
Expresiones:
Expresiones: Son un conjunto de valores variables (operandos) y operadores
relacionados o combinados entre si, según unas reglas establecidas. Los
operandos pueden ser también valores retornados por funciones.
En función del resultado obtenido, las expresiones se clasifican en:
• Aritméticas: El resultado de la evaluación de la expresión es numérico.
• Relacionales: Utilizan operadores relacionales y el resultado es un valor
lógico.
• Lógicas: Utilizan operadores lógicos y se aplican expresiones relacionales.
El resultado de la evaluación es un valor lógico.
• Alfanuméricas: Utilizan operandos y operadores alfanuméricos.

ESTRUCTURAS ESTÁTICAS DE DATOS:
Tablas: Está formada por un número fijo de elementos (variables) todos ellos
del mismo tipo de datos y situados en posiciones contiguas de memoria.
Elemento: Es cada uno de los datos que constituyen la tabla.
Nombre de Tabla: Es un nombre de variable que permite referenciar toda la
tabla de forma global y nos permitirá acceder a cada elemento de forma
individual.
Tipo de Tabla: Es el tipo de dato de todos los elementos de la lista.
Índices: Un entero positivo que nos permite identificar cada elemento de una
tabla.
Tamaño de Tabla: Número máximo de elementos que componen la tabla.
ACCESO A LOS ELEMENTOS: Los elementos de una tabla tratados
individualmente son variables que reciben el mismo trato que cualquier otra
variable simple, con un tipo de dato que coincide con el tipo de la tabla y una
denominación propia que la distingue de los diversos elementos. Para acceder
o referenciar un elemento en particular es suficiente con indicar el nombre de
la tabla seguido por el índice correspondiente entre paréntesis.
Dimensión: El número de índices que necesitamos para referenciar una tabla.
CLASIFICACIÓN DE LAS TABLAS:
• Unidimensionales: (Vectores) En este caso, solo es necesario un índice para
acceder a los elementos de la misma.
Código:
<Nombre> (<índice>)
• Bidimensionales: (Matrices) Son aquellas que necesitan dos índices para
acceder a cada uno de sus elementos.
Código:
<Nombre> (<índice1><índice2>)
Programación Estructurada:
Introducción:
Desde el nacimiento de la informática, se han ido desarrollando métodos y
herramientas con el objetivo de facilitar y mejorar el diseño y resolución de
programas. Hay dos clases:
Programación estructurada: Conjunto de técnicas que incorporan:
a Diseño descendente (TopDown) “Diseño por capas”
b Descomposición de tareas en tareas más simples
c Solo se pueden utilizar 3 tipos de estructuras
a. Alternativa
b. Repetitiva
c. Secuencial
Programación modular: Consiste en la división de un programa en módulos,
de tal forma que cada uno de ellos se encargue de la ejecución de una tarea.
Los módulos pueden ser subprogramas, subrutinas, funciones o
procedimientos.
Partes de un programa:
Todo programa está constituido por un conjunto de instrucciones o de órdenes
capaces de manipular los datos. Estas órdenes pueden ser divididas en tres
grandes grupos que determinan las partes de un programa.
Entrada de datos > Proceso > Salida de resultados
• Instrucciones de entrada de datos: Conjunto de instrucciones que
permiten llevar datos desde el exterior (tomar datos a través de un dispositivo
de entrada y almacenarlos en la memoria central).
• Instrucciones de proceso: Conjunto de instrucciones encargadas de
procesar o realizar un tratamiento de datos obteniendo unos resultados que se
almacenan en la memoria central.
• Instrucciones de salida: Permiten extraer datos (resultados) de la
memoria central mostrándolos a través de un dispositivo de salida.
Datos >
Dispositivo Externo <> Memoria Principal <> Proceso o algoritmo
< Resultados
Algoritmo:
Es la descripción abstracta de todas las acciones u operaciones que debe
realizar un ordenador de forma clara y detallada así como el orden en el que
estas deberán ejecutarse junto con la descripción de todos aquellos datos que
deberán ser manipulados por dichas acciones y que nos conducen a la solución
del problema. Un algoritmo deberá reflejar las 3 partes de un programa
(entrada, proceso, salida) es importante tener en cuenta que todo algoritmo
debe ser totalmente independiente del lenguaje de programación utilizado. Las
características que debe cumplir el diseño de todo algoritmo son las siguientes.
a Debe ser conciso y detallado. Debe reflejar con el máximo detalle el orden
de ejecución de cada acción u operación que vaya a realizar el ordenador.
b Debe ser flexible, permitiendo y facilitando así las futuras modificaciones o
actualizaciones del diseño realizado.
c Debe ser finito, tener comienzo y final.
d Ser lo más claro y sencillo posible.
Diagramas de Flujo:
Son representaciones gráficas que mediante símbolos estandarizados permiten
describir las acciones y la lógica que ha de seguir un algoritmo junto con el
flujo de datos para la obtención de los resultados convenidos.
Ordinogramas: Diseño
Organigramas: Análisis
Pseudocódigo: Lenguaje intermedio entre el natural y el lenguaje de
programación (el cual vamos a tratar en este tutorial). Todo algoritmo en
pseudocódigo debe reflejar las distintas partes de un programa.
Tipos de Instrucciones:
Instrucción: Hecho o suceso de duración limitada que permite generar unos
cambios previstos en la ejecución de un programa.
Instrucciones de definición de datos: Permiten reservar la memoria
necesaria para almacenar los datos que se van a manejar en el programa.
Mediante el uso de variables simples o complejas.
Las instrucciones de definición consisten únicamente en dar un nombre y un
tipo de dato a las zonas de memoria que quiero reservar.
Instrucciones primitivas:
• Instrucciones de Entrada: Permiten almacenar un dato en la memoria
central durante el uso de una o más variables procedentes de un dispositivo
externo (generalmente el teclado).
Código:
Leer <variable>
Leer <lista de variables
Esta instrucción para el proceso de ejecución hasta que se introduzcan tantos
datos como variables aparezcan en la lista de variables.
• Instrucciones de Asignación: Consiste en introducir en una variable el
resultado de evaluar una expresión.
Código:
<variable> = <expresión>
• Instrucciones de Salida: Permiten recuperar un dato de la memoria
central para mostrarlo desde un periférico de salida.
Código:
visualizar <expresión> (Pantalla)
imprimir <expresión> (Impresora)
Instrucciones Compuestas:
No pueden ser ejecutadas directamente por el procesador y están constituidas
por un bloque de acciones agrupadas en subrutinas, subprogramas, funciones o
módulos.
Código:
<nombre_modulo>
Instrucciones de control: Se utilizan para controlar la secuencia de ejecución
de un programa y también para determinar si se ejecutan o no bloques de
instrucciones:
• Alternativas:
o Simple: Permite la ejecución de un grupo de instrucciones en función de que
se cumpla o no una condición.
Código:
Si <condición>
<instrucción1>
<instrucción2>
<instrucciónn>
Fin Si
o Doble: Permite decidir por un grupo de instrucciones u otro en función de si
se cumple la condición o no.
Código:
Si <condición>
<instrucción11>
<instrucción12>
<instrucción1n>
Sino
<instrucción21>
<instrucción22>
<instrucción2n>
FinSi
o Múltiple: Ejecuta distintos grupos de instrucciones en función del resultado
de la evaluación de una expresión.
Código:
Según_Valor: <expresión>
<valor1>: <bloque de instrucción 1>
<valor2>: <bloque de instrucción 2>
<valorn>: <bloque de instrucción n>
Por_Defecto: <bloque de instrucción por defecto>
Fin_Según_Valor
Instrucciones repetitivas:
Nos permiten variar o alterar la secuencia normal de ejecución de un programa
haciendo posible que un grupo de acciones se ejecute más de una vez de forma
consecutiva, también se denomina bucles o lazos.
Estructura Mientras: Se caracteriza por la repetición de un conjunto de
instrucciones en función de que se cumpla o no la condición, pueden repetirse
de 0 a n veces.
Código:
Mientras <condición>
<Instrucción1>
<Instrucción2>
<Instrucciónn>
Finmientras
o Se evalúa la condición, si se cumple, se ejecutan las instrucciones
comprendidas entre el mientras y el fin mientras y de nuevo se evalúa. El
proceso termina cuando la condición se cumple.
Estructura Repetir: Permite la repetición de un proceso mientras se cumpla
una condición evaluando la condición al final de cada repetición, el proceso se
repite de 1 a n veces.
Código:
Repetir
<Instrucción1>
<Instrucción2>
<Instrucciónn>
Mientras <condición>
o El conjunto de instrucciones entre repetir y mientras, se ejecuta (al menos
una vez) evaluando la condición y volviendo a repetir en caso de que se
cumpla.
Estructura Para: Repetición de un proceso un número determinado de veces
Código:
Para <variable> = <valor_inicial> hasta <valor_final> Inc = <valor_incremento>
<Instrucción1>
<Instrucción2>
<Instrucciónn>
Finpara
Donde el incremento indica la cantidad a aumentar la variable dentro del
proceso repetitivo.
Contadores y Acumuladores:
Contador: Es una variable que se incrementa o decrementa en una cantidad
constante.
Código:
<variable> = <variable> + 1
Acumulador: Variable que se incrementa en un valor no constante.
Código:
<variable1> = <variable1> + <variable2>
Tenéis disponibles en este otro post varios ejercicios resueltos de pseudocódigo
con los que podéis poner en práctica lo aprendido en este.
Ejercicios de Pseudocódigo
(http://foro.elhacker.net/ejercicios/ejercicios_de_pseudocodigot308049.0.html)
Iré actualizando ambos post según me vaya siendo posible.
Título: Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero.
Publicado por: Bruenor Battlehammer en 29 Octubre 2010, 08:54
DISEÑO MODULAR DE PROGRAMAS:
La descomposición modular consiste en dividir el programa en varias partes
denominadas módulos, cada uno de los cuales tiene una misión que deberá ser
lo más específica posible. Cada módulo puede ser llamado por uno o más
módulos, quedando suspendida la ejecución del módulo que llama y entrando
en ejecución el módulo llamado hasta que este termina, devolviendo a
continuación el control del programa al módulo que lo llamó en el punto que se
dejó.
La idea básica es que tenemos un programa principal, desde el que podemos
llamar a módulos, los cuales pueden llamar a otros módulos si llega a ser
necesario.
Las principales ventajas de la programación modular son las siguientes:
Facilitar la comprensión del problema y su resolución escalonada
Aumentar la claridad y legibilidad de los programas
Permitir la resolución del problema por varios programadores a la vez
Reducir el tiempo de desarrollo aprovechando módulos previamente
desarrollados
Mejorar la depuración. Pues se pueden depurar los módulos aisladamente.
Facilitar un mejor y más rápido mantenimiento de la aplicación.
Clasificación de los módulos:
Se pueden clasificar en función de distintos criterios:
a) En función de su situación con respecto al módulo que llama
Internos: Se encuentran en el mismo fichero que el módulo que llama
Externos: Se encuentran en distinto fichero que el módulo que llama
b) En función del retorno o no retorno de un valor
Funciones: Retorna un valor de forma explícita cuando acaban la ejecución
del mismo. Este valor debe ser recogido o evaluado en una instrucción del
módulo que lo llamó. Luego, la llamada a una función siempre forma parte de
una instrucción.
Procedimientos: No hace un retorno explícito de ningún valor, cuando se
llama al módulo. La llamada es una instrucción completa. Es decir, no forma
parte de ninguna otra instrucción.
Cuando un módulo acaba de ejecutarse se continúa con la siguiente instrucción
a la lammada del mismo.
Tanto funciones como procedimientos pueden modificar parámetros que se les
envían como argumentos.
c) En función de cuando ha sido desarrollado
De programa: Se han desarrollado a la vez que el programa que los llama.
De librería: Son módulos que han sido desarrollados previamente e
incorporados a las librerías que acompañan al compilador.
Ámbito de una variable: Parte de un programa donde esa variable es
reconocida y por tanto, puede ser utilizada, pueden ser de dos tipos: variables
globales y locales.
Locales: Deben estar definidas en un lugar específico del programa que no
pertenezca a ninguno de sus módulos, si se definen al comienzo del programa,
su ámbito de validez es todo el programa (todos sus módulos), si se define en
otro punto del programa, su ámbito de validez es el resto del programa.
Globales: Se definen al principio del programa y pertenecen por tanto a todo el
programa completo.
Parámetros:
También llamados argumentos, son variables de enlace entre módulos para
establecer relaciones entre ellos, de forma que no se produzcan efectos
laterales (la modificación de un módulo debe influir en el funcionamiento de
otros módulos relacionados). Este tipo de enlace está cerca del concepto de
"caja negra", en el sentido de que lo que realmente interesa es la entrada y la
salida del módulo, ignorando inicialmente como trabaja internamente.
Se pueden clasificar en:
Actuales: Son variables locales definidas en el módulo que llama, que serán
enviadas al módulo llamado.
Formales: Son variables locales en el módulo llamado, que se definen para que
recojan los parámetros actuales del módulo que llama.
Los parámetros se expresan dentro de los paréntesis que siguen al
indentificador del módulo. Si el módulo no tiene parámetros, los paréntesis
aparecerán vacíos. Tiene que existir una correspondencia entre los parámetros
actuales y los formales en número, orden y tipo de dato.
Ahora voy a poner un ejemplo simple para diferenciar entre procedimiento y
función:
PROCEDIMIENTO:
Citar
MODULO Calculo()
datos: a,b : entero
Código:
INICIO
a = 20
b = 50
suma(a,b)
...
...
FIN MODULO
MODULO Suma(x:entero, y:entero)
datos: s : entero
Código:
INICIO
s = x+y
VISUALIZAR s
FIN MODULO
Como podéis ver, el procedimiento, no retorna el resultado, sino que éste lo
visualiza en vez del módulo principal.
FUNCION:
Citar
MODULO Calculo()
datos: a,b,sum : entero
Código:
INICIO
a = 20
b = 50
suma = suma(a,b)
VISUALIZAR suma
FIN MODULO
MODULO Suma(x:entero, y:entero)
datos: s : entero
Código:
INICIO
...
...
s = x + y
retorna s
FIN MODULO
La función, en cambio, retorna el resultado para que el módulo principal del
programa lo muestre. (La instrucción suma = suma(a,b) pide que el resultado
del módulo suma(), con los parámetros a y b, sea introducido en la variable
suma.)
Una recomendación: Tratad de llamar a los parámetros actuales de forma
distinta a los formales, ya que esto permite reutilizar los actuales en más
módulos posteriormente sin confundir unos con otros.
Paso de parámetros:
El paso de parámetros puede hacerse de dos formas distintas:
a) Paso por valor: Se envía el valor que tiene cada uno de los parámetros
actuales en el momento de realizar la llamada, estos valores son recogidos por
los parámetros formales del módulo llamado, que deben estar definidos con los
mismos tipos de datos que los parámetros actuales. (Parámetro de entrada)
b) Paso por referencia: Se envían las direcciones de memoria que tienen
asignados cada uno de los parámetros formales del módulo llamado, por tanto,
en el módulo llamado se pueden modificar los valores de las variables de
enlace. El paso de parámetros por referencia o dirección ofrece menos
seguridad que el paso de parámetros por valor, pues si se produce algún error
en las modificaciones de las variables de enlace, estas quedan reflejadas en la
memoria.
Con el paso por referencia se puede:
Pasar la dirección para utilizar y modificar el valor que contiene. (Parámetro
de entrada y de salida)
Pasar la dirección de una variable vacía para que me recoja un resultado y
se pueda utilizar en el módulo que llama. (Parámetro de salida).
Actualizaré dentro de poco el post de ejercicios con varios algoritmos que
utilizan módulos.
Publicado por: Bruenor Battlehammer en 23 Noviembre 2010, 10:39
ALGORITMOS RECURSIVOS:
Para definir algoritmos recursivos, es necesario establecer una relación de
recurrencia en términos del tamaño del problema.
Las relaciones recurrentes más simples se establecen disminuyendo el tamaño
del problema en una unidad o dos (cantidad fija) aunque también puede
reducirse en algunos casos en cantidades no fijas (mitad) dado que la solución
del problema se plantea como una relación recurrente del tamaño del mismo,
para poder obtener la solución, es necesario poder disponer de unas series (o
solo una en muchos casos) de soluciones particulares, lo que se denomina caso
base.
Ejemplo1: Algoritmo recursivo para el calculo factorial de un número n.
Caso Base: n=0 f=1 {ya que el factorial de 0 es 1}
Hipótesis de Recurrencia: Sé resolver el factorial de n1 f=FACTORIAL(n1)
{haremos posteriormente esa función FACTORIAL, que será la que haga la
recurrencia}
¿Cómo lo resuelvo para un término más? n*FACTORIAL(n1) {ya que un
termino más sería FACTORIAL(n) que es exactamente lo mismo que
n*FACTORIAL(n1) la diferencia es que el primero no nos permite la
recurrencia pero el segundo si.}
FUNCION FACTORIAL
Código:
INICIO
SI n==0
f=1
SINO
f=n*factorial(n‐1)
FIN SI
RETORNA f
FIN
Ahora paso a explicar su funcionamiento, aunque a la hora de plantearlo no
hace falta verlo así, basta con saber que va a funcionar, si se intenta ver el
funcionamiento en algoritmos con recursiones muy complejas, solo se
conseguirá liarse y no llegar a nada.
Este algoritmo realizará lo siguiente, por ejemplo para n=3:
Arranca el módulo FACTORIAL(3):
n=3, como n!=0
llama a f=n*factorial(2)
n=2, como n!=0
n=1, como n!=0
n=0
Termina el modulo FACTORIAL(0) devolviendo un 1
Termina el módulo FACTORIAL(1) devolviendo un 1*1 = 1
En conclusión, sacamos que, cuando se ejecuta un programa recursivo, las
llamadas recursivas no se ejecutan inmediatamente, lo que se hace es
colocarlas en una pila hasta que se encuentra la condición de terminación de la
recursividad, entonces se ejecutan las llamadas a la función en orden inverso a
como se generaron como si se fueran sacando de la pila. *si no lo recordáis
ya, ver pila en posts superiores*
Ejemplo ilustrado:
(http://img155.imageshack.us/img155/8369/pila.png)
Publicado por: Bruenor Battlehammer en 18 Diciembre 2010, 10:48
Bueno, por petición de Littlehorse, he unido los ejercicios de pseudocódigo con
el tutorial. Si veis algún error en la resolución de los mismos, decídmelo, que
así aprendo más. ^w^
Espero que os gusten y os sean útiles para practicar. ^w^
Algoritmo 1: Programa que visualice los n primeros números de la
sucesión de Fibonacci.
Datos: a,n,cont,suma ; nºentero
Algoritmo:
Código:
INICIO
a = 0, b = 1
VISUALIZAR "Introduzca n"
LEER n
SI n > 2
suma = a + b
VISUALIZAR a,"",b
PARA cont = 3 HASTA n
a = suma
suma = a + suma
VISUALIZAR suma
FIN PARA
SINO
VISUALIZAR "No se puede aplicar la serie a menos de 3 términos!"
FIN SI
FIN
Algoritmo 2: Algoritmo que visualice los 25 primeros números perfectos.
Datos: n, cont, res, final
Algoritmo:
Código:
INICIO
final = 0
REPETIR
res = 0
PARA cont = 1 HASTA n DIV 2
SI cont % n == 0
res = res + cont
FIN SI
FIN PARA
SI res == n
VISUALIZAR n
final = final + 1
FIN SI
n = n + 1
MIENTRAS final < 25
FIN
Algoritmo 3: Introducir por teclado una secuencia de datos, cada una de
ellas compuestas por un nombre y las calificaciones obtenidas por ese
alumno en 6 asignaturas, la secuencia termina al introducir fin como
nombre de alumno, el algoritmo deberá visualizar el nombre del alumno,
seguido de su nota media, al introducir fin, se mostrará la nota media del
grupo. (No se permite usar tablas en este ejercicio, pero simplificaría
mucho el code)
Datos: alumno ; alfanumerico
nota, media, grupo: nº real
cont, alumnos, nalumnos : nº entero
Algoritmo:
Código:
INICIO
nalumnos = 0, global = 0
REPETIR
VISUALIZAR "Introduzca el nombre del alumno"
LEER alumno
media = 0
SI alumno != fin
PARA cont = 1 HASTA 6
VISUALIZAR "Introduzca la nota número" , cont
LEER nota
media = media + nota
FIN PARA
media = media / 6
global = global + media
nalumnos = nalumnos + 1
VISUALIZAR alumno, media
FIN SI
MIENTRAS alumno != fin
global = global / nalumnos
VISUALIZAR "Media del grupo: ", global
FIN
Algoritmo 4: Visualizar los n primeros números primos (n se introduce por
teclado, usar una variable booleana para comprobar si el numero es
primo)
Datos: cond, cont, n, a, primos
Algoritmo:
Código:
INICIO
primos = 0
VISUALIZAR "Introduzca n"
LEER n
MIENTRAS primos < n
cont = 0, cond = true
MIENTRAS cond = true
cont = cont + 1
SI cont % a = 0
cond = false
FIN SI
FIN MIENTRAS
SI cont == a
VISUALIZAR a
primos = primos + 1
FIN SI
a = a +1
FIN MIENTRAS
FIN
Algoritmo 5: En una hurna hay 80 bolas numeradas del 1 al 80 se extrae
una bola y el numero se introduce por teclado devolviendo de nuevo la
bola a la hurna el proceso se repite hasta que aparezca 3 veces el numero
33. Hacer un programa que utilice cuantas veces ha salido cada una.
(usar tablas)
DATOS: numeros (80)
bola, cont; nºentero.
Algoritmo:
Código:
INICIO
MIENTRAS numeros(33) < 3
VISUALIZAR "Introduzca el número de bola"
LEER bola
numeros(bola) = numeros(bola) + 1
FIN MIENTRAS
PARA cont = 1 HASTA 80
VISUALIZAR "Número de ", bola, "que salieron: ", numeros(bola)
FIN PARA
FIN
Algoritmo 6: Un almacén dispone de 8 departamentos numerados del 1 al
8 destinados a contener una serie de piezas. Las piezas están numeradas
del 0 al 8 éstas llegan de una en una depositándose en el departamento
del mismo número. Hacer un algoritmo que determine cuantas piezas hay
en cada departamento después del suministro, el suministro termina al
llegar la pieza numero 0, puede ocurrir que llegue una pieza no
comprendida en el rango establecido con lo cual se debera visualizar el
mensaje pieza número..... es incorrecta. Inicialmente no hay piezas en
los departamentos.
DATOS: deps (8*9)
pieza, dep; nºentero
Código:
INICIO
VISUALIZAR "Introduzca pieza y departamento"
LEER pieza, dep
MIENTRAS pieza != 0
SI pieza < 0 == 1 OR pieza > 0 == 1
VISUALIZAR "Pieza número ", pieza, "es incorrecta"
SINO
deps(dep,pieza) = deps(dep,pieza) + 1
FIN SI
VISUALIZAR "Introduzca pieza y departamento"
LEER pieza, dep
FIN MIENTRAS
PARA dep = 1 HASTA 8
PARA pieza = 0 HASTA 8
VISUALIZAR "Departamento: ", dep, "Pieza: ", pieza, "Cantidad: ", deps(dep,pieza)
FIN PARA
FIN PARA
FIN
Algoritmo 7: Una distribuidora de piezas de motor dispone de 3
almacenes para almacenar 4 piezas distintas, el número de piezas por
almacén se representan mediante una matriz de 4x3 denominada
inventario, también dispone de un vector con los costes de cada pieza,
diseñar un algoritmo que permita calcular:
a) El valor que tiene cada almacén, teniendo en cuenta cada pieza
b) El valor del que dispone cada almacén, teniendo en cuenta todas las
piezas.
c) El valor total de cada pieza en todos los almacenes
d) El valor total general
Suponer que la matriz inventario y el vector de costes ya están
introducidos anteriormente
Resolución 1 (Larga y menos eficiente, pero mucho más simple de interpretar)
Código:
INICIO
//Resolución del apartado A con dos bucles para.
PARA y=1 HASTA 3
PARA x=1 HASTA 4
VISUALIZAR "El valor de pieza",x,"en almacén",y,"es",(inventario(x,y)*coste(x))
FIN PARA
FIN PARA
//Resolución del apartado B con dos bucles para.
PARA y=1 HASTA 3
tgt=0
PARA x=1 HASTA 4
tgt=tgt+(inventario(x,y)*coste(x))
FIN PARA
VISUALIZAR "El valor de almacén",y,"es",tgt
FIN PARA
//Resolución del apartado C con dos bucles para
PARA x=1 HASTA 4
tgt=0
PARA y=1 HASTA 3
FIN PARA
VISUALIZAR "El valor de piezas",x,"es",tgt
FIN PARA
//Resolución del apartado D con dos bucles para
sup=0
PARA y=1 HASTA 3
tgt=0
PARA x=1 HASTA 4
FIN PARA
sup=sup+tgt
FIN PARA
VISUALIZAR "Valor global es",sup
FIN
Resolución 2 (Búsqueda de la máxima eficiencia y el menor tamaño posible)
Código:
INICIO
//Resolución de los apartados A, B y D en el mismo bucle PARA
PARA y=1 HASTA 3
tgt=0
PARA x=1 HASTA 4
part = inventario(x,y)*costes(x)
VISUALIZAR "Valor de pieza",x,"en almacén",y,"es",part
tgt = tgt + part
FIN PARA
sup = sup + tgt
VISUALIZAR "Valor total de almacén",y,"es",tgt
FIN PARA
VISUALIZAR "Valor total global",sup
//Resolución del apartado C en otros dos bucles PARA, ya que
//en esta es necesario colocarlos de forma inversa.
PARA x=1 HASTA 4
tgt=0
PARA Y=1 HASTA 3
tgt = tgt + (inventario(x,y)*coste(x))
FIN PARA
VISUALIZAR "El valor de piezas",x,"es",tgt
FIN PARA
FIN
Tras unos cuantos algoritmos que cubren el uso de casi todas las funciones
explicadas en la teoría. Paso a la explicación simple de algunos algoritmos
estándar.
BUSQUEDA DE DATOS:
Búsqueda Lineal: Se trata de determinar si un elemento x está en un vector,
para ello buscaremos una posición pos donde se encuentre ese elemento.
(Dado un vector a de n elementos se debe cumplir que a(pos)==x)
La búsqueda lineal consiste en recorrer el vector a hasta que encuentre el
elemento, o bien hasta que acabe el recorrido (si no está).
Programa: Búsqueda_Lineal
Datos:
n: valor constante.
a: vector de tamaño n, tipo T (debe tener el mismo tipo que x, para poder
poner "x" como el dato que queremos buscar dentro del vector)
x: variable de tipo T
pos: número entero
encontrado: variable booleana.
Código:
INICIO
{se supone que el vector a está cargado}
pos = 1
encontrado = false
VISUALIZAR "Elemento a buscar"
LEER x
MIENTRAS NOT encontrado AND pos <=n
SI a(pos)==x
encontrado = true
SINO
pos = pos + 1
FIN SI
FIN MIENTRAS
SI encontrado
VISUALIZAR x, "está en la posición", pos
SINO
VISUALIZAR x, "no está"
FIN SI
FIN
Búsqueda lineal con centinela: Este método es parecido al anterior, y se
basa en dimensionar el vector a una dimensión más que las definidas en el
tamaño del vector. Esta posición se va a utilizar para introducir el elemento a
buscar. De esta forma, nos aseguraremos que siempre va a estar, con el
objeto de simplificar las condiciones del proceso repetitivo.
Programa: Busqueda_centinela
Datos:
n: valor constante
a: vector de tamaño n+1 de tipo T
encontrado: variable booleana
Código:
INICIO
{suponemos el vector ya cargado}
encontrado = false
pos = 1
VISUALIZAR "Introduzca el elemento a buscar"
LEER x
a(n+1) = x {centinela}
MIENTRAS NOT encontrado
SI a(pos)==x
encontrado = cierto
SINO
pos = pos + 1
FIN SI
FIN MIENTRAS
SI pos == n+1
VISUALIZAR "El elemento no está"
SINO
VISUALIZAR x, "está en la posición", pos
FIN SI
FIN
Búsqueda Dicotómica: Si los elementos del vector están ordenados bien de
forma creciente o decreciente, no es necesario examinar todos los elementos,
ya que comparando el valor buscado x con el valor central, se puede eliminar
la búsqueda en una de las dos mitades, con lo cual el algoritmo resulta mucho
más rápido. Supondremos que tenemos el vector ordenado en sentido
creciente.
Si en cada paso del algoritmo comparamos el valor de x como el de la posición
central (k), podemos obtener lo siguiente:
Caso 1: Que a(k) == x > Acaba la búsqueda y el elemento está en k.
Caso 2: Que a(k) > x > Eliminamos la parte del vector superior a k.
Caso 3: Que a(k) < x > Eliminamos la parte del vector inferior a k.
Programa: Busqueda_Dicotomica
Datos:
izq, der: variables que delimitarán la dimensión del vector en la que estamos
buscando. Servirán para ir recortando la búsqueda según el resultado de la
comparación de a(k) con x.
a: vector de n elementos de tipo T
Código:
INICIO
VISUALIZAR "Indique elemento a buscar"
LEER x
izq = 1
der = n
encontrado = false
MIENTRAS NOT encontrado AND der < izq {la segunda condición sirve para finalizar el bucle si no
se encuentra el dato}
k = (izq + der) DIV 2 {aquí definimos el elemento medio en la sección del vector que vamos a
comprobar}
SI a(k) == x
encontrado = cierto
SINO
SI a(k) < x
izq = k + 1 {ajuste del inicio del fragmento ajustado por la derecha de k}
SINO
der = k ‐ 1 {ajuste del final del fragmento ajustado por la izquierda de k}
FIN SI
FIN SI
FIN MIENTRAS
SI encontrado
VISUALIZAR x, "está en posición", k
SINO
VISUALIZAR x, "no está"
FIN SI
FIN
ORDENACIÓN DE DATOS:
Generalmente se considera ordenar con reorganizar un conjunto dado de
objetos. Por ejemplo, los elementos de un vector en una secuencia
especificada. El objetivo es facilitar la búsqueda de los elementos del conjunto
ordenado. En particular vamos a practicar la ordenación a los elementos de un
vector n>0 elementos de un tipo ordenable, así, los elementos del vector son
a(n), deberemos encontrar una permutación de los mismos tal que: a(b1) <=
a(b2) ... <= a(bn)
La primera condición a imponer a los métodos de ordenación de vectores es la
utilización económica de la memoria disponible, esto implica que las
permutaciones de elementos con vista a su ordenación, debe realizarse usando
el espacio ocupado por el vector.
Los métodos que trasladan los elementos de un vector a otro no tienen interés
(ya que implicaría duplicar el espacio necesario para realizar la operación).
Ordenación por inserción directa:
Para realizar este algoritmo partimos de la siguiente situación hipotética.
(NOTA: Nunca se dará esta situación, esto solo sirve para considerar el
programa tanto desde el comienzo, como durante el proceso intermedio)
La sección [1, i1] está ordenada, pero no se asegura que los elementos estén
en la posición final de ordenación, a esto se le llama ordenación no clasificada.
Para extender la ordenación al elemento i deberemos insertar el mismo en la
posición correspondiente de la sección a(1...i)
Concluimos pues que necesitaremos:
Código:
PARA i = 2 HASTA n
** Extender la ordenación de la sección a**
Código:
FIN PARA
Una posibilidad sería esta:
(Nótese que usamos uno de los algoritmos de búsqueda tratados anteriormente
para buscar la posición correcta del elemento a ordenar.)
Código:
INICIO
PARA i = 2 HASTA n
pos = 1
encontrado = false
x = a(i)
MIENTRAS NOT encontrado AND pos <= i
SI a(pos) >= x
encontrado = true
SINO
pos = pos + 1
FIN SI
FIN MIENTRAS
j = i ‐ 1
MIENTRAS j >= pos {mientras el hueco donde queremos colocar el dato no esté libre...}
a(j+1) = a(j) {...desplazamos todos los datos una posición hacia la derecha}
j = j ‐ 1
FIN MIENTRAS
a(pos) = x
FIN PARA
FIN
Esta disposición es correcta (y si no lo es, corregidme, que os lo agradeceré),
pero no es lo más eficiente, aquí he introducido el algoritmo de búsqueda tal
cual, para que pudieseis ver facilmente un ejemplo de su utilidad.
Ahora que ya tenemos el algoritmo planteado, vamos a hacerlo más eficiente.
Para ello, intentaremos meter ambos bucles en uno. Para ello debemos tener
en cuenta que la búsqueda y ordenación de los elementos se pueda hacer de
forma simultánea y no en bucles separados. Para conseguir esto, ambos bucles
deberían realizarse en el mismo sentido.
Teniendo en cuenta que el desplazamiento en sentido inverso es más simple en
el proceso de desplazamiento de datos, mientras que las búsqueda se hace de
forma análoga en un sentido u otro, es preferible modificar el algoritmo de
ésta.
Código:
pos = i ‐ 1
encontrado = falso
MIENTRAS NOT encontrado AND pos >= 1
SI a(pos) <= x
encontrado = cierto
SINO
pos = pos ‐ 1
FIN SI
FIN MIENTRAS
Si se compara este bucle con el desplazamiento de elementos, se puede
observar lo siguiente.
1. La variable de control de ambos comienza y termina con el mismo valor y i
1, el correspondiente al valor de inserción.
2. En ambos casos, la variable se modifica en cada paso de la misma forma,
decrementándola, por tanto, ambos ejecutan el mismo númeor de veces. Con
los mismos valores de la variable de control.
En consecuencia, las dos variables, y los dos algoritmos pueden combinarse en
uno solo.
Código:
SI a(pos) <= x
encontrado = true
SINO
a(pos+1) = a(pos)
pos = pos ‐ 1
FIN SI
FIN MIENTRAS
Quedándonos como resultado el programa final:
Programa: Ordenación_inserción_directa
Datos:
n: constante
a: vector de tamaño n tipo T
x: var de tipo T
encontrado: var lógica (booleana)
pos, i: nº enteros.
Código:
INICIO
{suponemos el vector cargado}
PARA i = 2 HASTA n
x = a(i)
encontrado = false
pos = i ‐ 1
SI a(pos) <= x
encontrado = cierto
SINO
a(pos+1) = a(pos)
pos = pos ‐ 1
FIN SI
FIN MIENTRAS
a(pos+1) = x
FIN PARA
FIN
Ordenación por selección directa: Partimos del supuesto de que tenemos una
sección (1 ... i1) ordenada y clasificada (recordad que esto era para
considerar ambos casos de algoritmo durante inicio y proceso).
El objetivo en ese caso sería extender la ordenación al elemento i del vector.
Para ello buscamos el mínimo de la sección (i ... n)
Programa: Inserción_Directa
Datos:
n: cte
a: vec de n elementos tipo T
x: var tipo T
i,j,pos: nºentero
Algoritmo:
Código:
INICIO
PARA i = 1 HASTA n ‐ 1
pos = i
PARA j = i + 1 HASTA n
SI a(j) <= a(pos)
pos = j
FIN SI
FIN PARA
x = a(i)
a(i) = a(pos)
a(pos) = x
FIN PARA
FIN
Ordenación por intercambio (o método de la burbuja):
Al igual que antes, suponemos que está ordenada y clasificada la sección a(1
... i1) y queremos extender la ordenación al elemento i.
La diferencia con el método anterior es que aquí no se busca el mínimo, sino
que este se lleva hasta la posición i mediante intercambios de pares de
elementos adyacentes del vector.
Si los elementos se consideran burbujas en un depósito de agua, con pesos
acordes a sus valores, en cada pasada sobre el vector, asciende una burbuja
hasta su posición correspondiente. (También hay la posibilidad de que otras se
acerquen a su posición final, por ello hay casos en los que esta ordenación
acelera el proceso)
Código:
INICIO
PARA i=1 HASTA n‐1
PARA j=n HASTA i+1 Inc=‐1 {incremento ‐1: decrementa j en 1 en cada ciclo}
SI a(j) < a(j‐1)
x = a(j‐1)
a(j‐1) = a(j)
a(j) = x
FIN SI
FIN PARA
FIN PARA
FIN
A que éste ha parecido sencillito? Pues es lo que parece. (Cuando lo saqué por
primera vez pensé que tenía que haber algo mal porque era demasiado
sencillo. Pero no, es correcto. ^^
Algoritmo 8: Visualizar una cabecera, realizar sucesivas veces la lectura
de tres números que representan el número de lados, la longitud de un
lado y la apotema de un polígono regular, visualizando el perímetro y el
área correspondiente.
El perímetro se realizará llamando a un procedimiento que lo calcula y
visualiza
El área se calculará llamando a una función que la retorna para que el
módulo principal la visualice
El proceso se terminará al introducir 0 como nº de lados.
Datos adicionales: Área = perímetro * apotema / 2
MODULO PRINCIPAL
DATOS: n,x,ap,ar:nºreal
Código:
INICIO
VISUALIZAR "Cálculo de áreas y perímetros"
VISUALIZAR "Introduzca número de lados, longitud y apotema"
VISUALIZAR "____________________________________________________"
LEER n,x,ap
REPETIR
PERIMETRO(n,x)
ar = AREA(n,x,ap)
VISUALIZAR ar
LEER n,x,ap
MIENTRAS n>0
FIN MODULO
MODULO perímetro(num:real,lon:real)
DATOS: per:real
Código:
INICIO
per = num * lon
VISUALIZAR per
FIN MODULO
MODULO área(num:real,lon:real,apo:real) : ar:real
DATOS: res:real
Código:
INICIO
res = (num*lon*apo)/2
retorna res
FIN MODULO

Algoritmo 9: Introducir los datos en dos vectores (tener en cuenta de que
pueden ser de distinto tamaño) mediante las llamadas a un
procedimiento que permite cargar los datos de un vector. Los datos se
introducirán ordenados, uno en sentido creciente y otro en decreciente, el
algoritmo deberá visualizar si los vectores son disjuntos o no lo son. Para
ello, retornará 1 si son disjuntos y 0 si no lo son (variable lógica). Para
facilitar el diseño de esta función, se llamará a un procedimiento que
reordenará el segundo vector en sentido creciente (desde el módulo
principal)
NOTA: Suponer que el usuario introduce el primer vector en orden creciente, y
el segundo en decreciente.
DATOS GLOBALES: m,n: constantes
MODULO PRINCIPAL
DATOS: va, vb: vector res: lógico
Código:
INICIO
CARGARVECTOR(va,m)
CARGARVECTOR(vb,n)
REORDENAR(vb)
res = DISJUNTOS(va,vb)
SI res
VISUALIZAR "Son disjuntos"
SINO
VISUALIZAR "No son disjuntos"
FIN SI
FIN
MODULO CARGARVECTOR (v:vector, fin:entero)
DATOS: cont:entero
Código:
INICIO
PARA cont = 1 HASTA fin
VISUALIZAR "Introducir Término ", cont, " de ", fin
LEER v(cont)
FIN PARA
FIN
MODULO REORDENAR (v:vector)
DATOS: mem, pos
Código:
INICIO
pos = m
PARA cont = 1 HASTA m DIV 2
mem = v(cont)
v(cont) = v(pos)
v(pos) = mem
pos = pos ‐ 1
FIN PARA
FIN
MODULO DISJUNTOS (va:vector, vb:vector)
DATOS: res:lógico
cont1, cont2: entero
Código:
INICIO
res = 1
cont1 = 1
MIENTRAS res == 1 AND cont1 <= n
cont2 = 1
MIENTRAS res == 1 AND cont2 <= m AND va(cont1) >= vb(cont2)
SI va(cont1) == vb(cont2)
res = 0
SINO
cont2 = cont2 + 1
FIN SI
FIN MIENTRAS
cont1 = cont1 + 1
FIN MIENTRAS
RETORNAR res
FIN

Algoritmo 10 [Ejercicio Práctico]: Una marca de autos, dispone de 15
concesionarios para la venta de los mismos, en la oficina central se desea
contabilizar las ventas realizadas por los concesionarios. Para ello, se
creará una tabla de 15x10 (10 tipos de coche). Para contabilizar las
ventas se introducirán los siguientes datos: nº de concesionario y modelo
de coche. Para determinar la columna se realizará una búsqueda en el
vector modelos que contiene dichos datos, cuya situación es la misma
que en la tabla, la búsqueda se realizará mediante un procedimiento que
retornará la posición, la jornada se finalizará cuando se introduzca un 0
como número de concesionario, una vez terminada la jornada laboral, se
obtendrá un listado del número de ventas realizadas por concesionario,
para ello, se llamará un procedimiento que habrá calculado dichas ventas,
el vector será retornado por el procedimiento al programa principal para
la realización del listado. La empresa va a conceder un plus de venta a
cada concesionario que venda más de 20 vehículos de un modelo
particular. Visualizar cuales, usando una función, si el concesionario
vende más de vente, retornará "true", de lo contrario, retornará "false".
Programa: Coches
Datos Globales: cplus: cte {contiene el modelo del plus}
MODULO PRINCIPAL
DATOS: ventas: tabla (15x10) {contendrá las ventas de modelo por
concesionario}
modelos: vector (10) {contendrá los 10 modelos de coche, en el mismo orden
que la tabla, servirá para localizar la columna adecuada en la tabla ventas}
total_ventas: vector (15) {generado por el módulo "total", contendrá las ventas
totales por concesionario}
conce, mod, pos: variables {múltiples usos}
Código:
INICIO
VISUALIZAR "Buenos días"
VISUALIZAR "Número de concesionario"
LEER conce
MIENTRAS conce > 0 {si se introduce algo menor que 1, se finalizará el programa}
VISUALIZAR "Modelo de coche:"
LEER mod
SI conce <= 15 {si se introduce algo mayor que 15, dará error y lo pedirá de nuevo}
BUSCA_MODELO(&pos,modelos,mod) {módulo, se envía la posición de memoria de la variable pos}
SI pos != 0
ventas(conce,pos) = ventas(conce,pos) + 1 {aumento de 1 venta en la posición adecuada}
SINO
VISUALIZAR "Modelo no válido"
FIN SI
SINO
VISUALIZAR "Concesionario no válido"
FIN SI
VISUALIZAR "Número de concesionario"
LEER conce
FIN MIENTRAS
TOTAL(ventas,total_ventas) {módulo, se envían tanto la tabla ventas, como total_ventas,
modifica la segunda}
PARA conce = 1 HASTA 15
VISUALIZAR "Concesionario:", conce, "ventas:", total_ventas(conce)
FIN PARA
BUSCA_MODELO(&pos, modelos,cplus) {buscamos el modelo del plus, contenido en la constante
cplus}
SI PLUS(ventas(&conce),pos) == 1 {función, retorna "true" si se vendieron más de 20, (ver el
módulo)}
VISUALIZAR "Concesionario", conce, "recibe plus"
FIN SI
FIN PARA
VISUALIZAR "Fin del listado, que tenga un buen día"
FIN
MODULO BUSCA_MODELO(pos,modelos,mod)
DATOS: cont{contador}
Código:
INICIO
cont = 0 ; *pos = 0
MIENTRAS *pos == 0 AND cont <= 10
SI modelos(cont) == mod
*pos = cont {modificando la variable original}
SINO
cont = cont + 1
FIN SI
FIN MIENTRAS
FIN
MODULO TOTAL(ventas,total_ventas)
Datos: conce, mod {contadores para los bucles PARA}
Código:
INICIO
PARA mod = 1 HASTA 10
total_ventas(conce)=total_ventas(conce)+ventas(conce,mod)
FIN PARA
FIN PARA
FIN
MODULO PLUS(v,pos)
Datos cont {contador}
(En el paso final uso pos como si fuera booleana, aunque en realidad sea una
variable de tipo entero) (1=true, 0=false)
Código:
INICIO
SI v >= 20
pos = 1
SINO
pos = 0
FIN SI
RETORNAR pos
FIN
Powered by SMF 1.1.21 | SMF © 20062008, Simple Machines

Conceptos Básicos y Tutorial de Pseudocódigo Desde Cero

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Conceptos Básicos y Tutorial de Pseudocódigo Desde Cero

Загружено:

Авторское право:

Доступные форматы

12/3/2016 Imprimir Página Conceptos Básicos y Tutorial de Pseudocódigo desde cero.

Вам также может понравиться

Conceptos Básicos y Tutorial de Pseudocódigo Desde Cero

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Conceptos Básicos y Tutorial de Pseudocódigo Desde Cero

Загружено:

Авторское право:

Доступные форматы

12/3/2016 Imprimir Página ­ Conceptos Básicos y Tutorial de Pseudocódigo desde cero.

Вам также может понравиться

12/3/2016 Imprimir Página Conceptos Básicos y Tutorial de Pseudocódigo desde cero.