Foro de elhacker.net

Programación => Ejercicios => Mensaje iniciado por: Saberuneko en 17 Octubre 2010, 15:00 pm


Título: Ejercicios de pseudocódigo
Publicado por: Saberuneko en 17 Octubre 2010, 15:00 pm
Bueno, pues me he animado a postear unos ejercicios sencillos de pseudocódigo. 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: Ejercicios de pseudocódigo (Parte2)
Publicado por: Saberuneko en 27 Octubre 2010, 09:31 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. ^^

Actualizaré este post según tenga más material a mano. Nyaa! =3

Título: Re: Ejercicios de pseudocódigo
Publicado por: Saberuneko en 30 Octubre 2010, 12:49 pm
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


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines