Mensajes

Yo tengo dispositivos (como mi DS) que se niegan a conectarse cuando le pongo WPA a mi router... Qué puedo hacer en mi caso? Cambiar la WEP?

[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 visualizaEl área se calculará llamando a una función que la retorna para que el módulo principal la visualiceEl proceso se terminará al introducir 0 como nº de lados.]

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

INICIO
per = num * lon
VISUALIZAR per
FIN MODULO

MODULO área(num:real,lon:real,apo:real) : ar:real
DATOS: res:real

Código [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

INICIO
SI v >= 20
pos = 1
SINO
pos = 0
FIN SI
RETORNAR pos
FIN

[BUSQUEDA DE DATOS:]

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

PARA i = 2 HASTA n
** Extender la ordenación de la sección a**

Código [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

INICIO
PARA i=1 HASTA n-1
PARA j=n HASTA i+1 Inc=-1 {incremento -1: decrementa j en 1 en cada ciclo}
SI a(j) < a(j-1)
x = a(j-1)
a(j-1) = a(j)
a(j) = x
FIN SI
FIN PARA
FIN PARA
FIN

A que éste ha parecido sencillito? Pues es lo que parece. (Cuando lo saqué por primera vez pensé que tenía que haber algo mal porque era demasiado sencillo. Pero no, es correcto. ^^

[Algoritmo 1: Programa que visualice los n primeros números de la sucesión de Fibonacci.]

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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 [Seleccionar] Expandir

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

Nooo! Qué será de la comedia que genaba esa teclita??

Prueba a ponerlo en TCP/UDP... A mí me pasaba que no funcionaba en ocasiones teniéndolo sólo en TCP (lo suele poner por defecto)

Muchas gracias Nov!

Pues eso, si tengo una hoja de cálculo, en la que estoy anotando en dos celdas diferentes las victorias (D2) y las derrotas (D3).

Qué fórmula tendría que poner en una casilla para que me calcule el ratio de victorias/derrotas en porcentaje? (Gana x% de las veces)

Sé que es, probablemente, una duda estúpida. Pero ahora mismo estoy bloqueado y no se me ocurre como calcularlo.

Puff... He echado un vistazo y me pierdo...
Definitivamente, el hardware no es lo mío.

Voy a mirar si consigo descubrir que modelo de monitor gasto primero y ya os comento.