Título: Conceptos Básicos y Tutorial de Pseudocódigo desde cero. (+Ejercicios) Publicado por: Saberuneko en 25 Octubre 2010, 09:35 am 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 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 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: 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 (Top-Down) “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> Esta instrucción para el proceso de ejecución hasta que se introduzcan tantos datos como variables aparezcan en la lista de variables.Leer <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) Instrucciones Compuestas:imprimir <expresión> (Impresora) 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> o Doble: Permite decidir por un grupo de instrucciones u otro en función de si se cumple la condición o no.<instrucción1> <instrucción2> <instrucciónn> Fin Si Código: Si <condición> o Múltiple: Ejecuta distintos grupos de instrucciones en función del resultado de la evaluación de una expresión.<instrucción11> <instrucción12> <instrucción1n> Sino <instrucción21> <instrucción22> <instrucción2n> FinSi 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_pseudocodigo-t308049.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: Saberuneko en 29 Octubre 2010, 08:54 am 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 re-utilizar 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. Título: Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero. Publicado por: Saberuneko en 23 Noviembre 2010, 10:39 am 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 n-1 f=FACTORIAL(n-1) {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(n-1) {ya que un termino más sería FACTORIAL(n) que es exactamente lo mismo que n*FACTORIAL(n-1) 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) Arranca el módulo FACTORIAL(2): n=2, como n!=0 llama a f=n*factorial(1) Arranca el módulo FACTORIAL(1): n=1, como n!=0 llama a f=n*factorial(0) Arranca el módulo FACTORIAL(0): n=0 Termina el modulo FACTORIAL(0) devolviendo un 1 Termina el módulo FACTORIAL(1) devolviendo un 1*1 = 1 Termina el módulo FACTORIAL(2) devolviendo un 2*1 = 2 Termina el módulo FACTORIAL(3) devolviendo un 3*2 = 6 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) Título: Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero. Publicado por: Saberuneko en 18 Diciembre 2010, 10:48 am 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 tgt=tgt+(inventario(x,y)*coste(x)) 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 tgt=tgt+(inventario(x,y)*coste(x)) 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 Título: Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero. Publicado por: Saberuneko en 18 Diciembre 2010, 10:49 am 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 x: variable 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 x: variable 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, i-1] 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: MIENTRAS NOT encontrado AND pos >= 1 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 MIENTRAS NOT encontrado AND pos >= 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 ... i-1) 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 ... i-1) 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. ^^ Título: Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero. Publicado por: Saberuneko en 18 Diciembre 2010, 10:49 am 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} PARA conce = 1 HASTA 15 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 conce = 1 HASTA 15 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 |