elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Security Series.XSS. [Cross Site Scripting]


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Conceptos Básicos y Tutorial de Pseudocódigo desde cero. (+Ejercicios)
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Conceptos Básicos y Tutorial de Pseudocódigo desde cero. (+Ejercicios)  (Leído 17,730 veces)
Saberuneko


Desconectado Desconectado

Mensajes: 2.112



Ver Perfil WWW
Conceptos Básicos y Tutorial de Pseudocódigo desde cero. (+Ejercicios)
« 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>
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

Iré actualizando ambos post según me vaya siendo posible.


« Última modificación: 18 Diciembre 2010, 10:51 am por Saberuneko » En línea

Saberuneko


Desconectado Desconectado

Mensajes: 2.112



Ver Perfil WWW
Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero.
« Respuesta #1 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.


« Última modificación: 30 Octubre 2010, 12:40 pm por Saberuneko » En línea

Saberuneko


Desconectado Desconectado

Mensajes: 2.112



Ver Perfil WWW
Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero.
« Respuesta #2 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:

En línea

Saberuneko


Desconectado Desconectado

Mensajes: 2.112



Ver Perfil WWW
Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero.
« Respuesta #3 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
En línea

Saberuneko


Desconectado Desconectado

Mensajes: 2.112



Ver Perfil WWW
Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero.
« Respuesta #4 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. ^^
En línea

Saberuneko


Desconectado Desconectado

Mensajes: 2.112



Ver Perfil WWW
Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero.
« Respuesta #5 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
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Tutorial Perl desde cero « 1 2 »
Scripting
WHK 11 11,645 Último mensaje 26 Diciembre 2007, 14:40 pm
por Axus
problema con el WDASM EN EL TUTORIAL DE CRACKING DESDE CERO
Ingeniería Inversa
juancarlos230 3 5,675 Último mensaje 30 Noviembre 2010, 23:05 pm
por yako-_-
Algunos conceptos básicos de seguridad informática que deberías conocer
Noticias
wolfbcn 0 2,142 Último mensaje 2 Julio 2011, 13:49 pm
por wolfbcn
Qué es el ROOT y para qué sirve, conceptos básicos
Noticias
wolfbcn 0 1,250 Último mensaje 28 Julio 2012, 01:35 am
por wolfbcn
Cómo instalar Windows 10 desde cero (Tutorial)
Windows
El_Andaluz 0 903 Último mensaje 12 Marzo 2020, 05:08 am
por El_Andaluz
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines