Yo siempre tengo mi camara y mi micro desenchufados al menos que los esté usando, así me aseguro al 100% de ser invisible.
- Bienvenido a Test Foro de elhacker.net SMF 2.1.
Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.
#1562
Ejercicios / Re: Ejercicios de pseudocódigo
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
MODULO perímetro(num:real,lon:real)
DATOS: per:real
MODULO área(num:real,lon:real,apo:real) : ar:real
DATOS: res:real
-----------------------------------------------------------------------------------------
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
MODULO CARGARVECTOR (v:vector, fin:entero)
DATOS: cont:entero
MODULO REORDENAR (v:vector)
DATOS: mem, pos
MODULO DISJUNTOS (va:vector, vb:vector)
DATOS: res:lógico
cont1, cont2: entero
-----------------------------------------------------------------------------------------
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}
MODULO BUSCA_MODELO(pos,modelos,mod)
DATOS: cont{contador}
MODULO TOTAL(ventas,total_ventas)
Datos: conce, mod {contadores para los bucles PARA}
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)
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]
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 MODULOMODULO perímetro(num:real,lon:real)
DATOS: per:real
Código [Seleccionar]
INICIO
per = num * lon
VISUALIZAR per
FIN MODULOMODULO área(num:real,lon:real,apo:real) : ar:real
DATOS: res:real
Código [Seleccionar]
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]
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
FINMODULO CARGARVECTOR (v:vector, fin:entero)
DATOS: cont:entero
Código [Seleccionar]
INICIO
PARA cont = 1 HASTA fin
VISUALIZAR "Introducir Término ", cont, " de ", fin
LEER v(cont)
FIN PARA
FINMODULO REORDENAR (v:vector)
DATOS: mem, pos
Código [Seleccionar]
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
FINMODULO DISJUNTOS (va:vector, vb:vector)
DATOS: res:lógico
cont1, cont2: entero
Código [Seleccionar]
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]
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"
FINMODULO BUSCA_MODELO(pos,modelos,mod)
DATOS: cont{contador}
Código [Seleccionar]
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
FINMODULO TOTAL(ventas,total_ventas)
Datos: conce, mod {contadores para los bucles PARA}
Código [Seleccionar]
INICIO
PARA conce = 1 HASTA 15
PARA mod = 1 HASTA 10
total_ventas(conce)=total_ventas(conce)+ventas(conce,mod)
FIN PARA
FIN PARA
FINMODULO 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]
INICIO
SI v >= 20
pos = 1
SINO
pos = 0
FIN SI
RETORNAR pos
FIN
#1563
Programación General / Re: Conceptos Básicos y Tutorial de Pseudocódigo desde cero.
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:
Como podéis ver, el procedimiento, no retorna el resultado, sino que éste lo visualiza en vez del módulo principal.
FUNCION:
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.
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:
CitarMODULO Calculo()
datos: a,b : enteroCódigo [Seleccionar]INICIO
a = 20
b = 50
suma(a,b)
...
...
FIN MODULO
MODULO Suma(x:entero, y:entero)
datos: s : enteroCódigo [Seleccionar]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:
CitarMODULO Calculo()
datos: a,b,sum : enteroCódigo [Seleccionar]INICIO
a = 20
b = 50
suma = suma(a,b)
VISUALIZAR suma
FIN MODULO
MODULO Suma(x:entero, y:entero)
datos: s : enteroCódigo [Seleccionar]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.
#1564
Noticias / Re: Corregida una brecha de día cero en Firefox
29 Octubre 2010, 08:47 AMCita de: Artikbot en 28 Octubre 2010, 13:53 PM+1!
Viva NoScript!
#1565
Seguridad / Re: Ordenador indetectable?
29 Octubre 2010, 08:45 AM
Ahora que lo pienso, hay tiendas en las que tienes que dar tu nombre y apellidos y mas cosas para comprar un PC, tal vez puede que saquen la información de ahi?
#1566
Dudas Generales / Re: Aviso de interrupción momentanea
29 Octubre 2010, 08:44 AM
Entonces prueba a usar un proxy, a ver que pasa. Tal vez te funcione.
#1567
Seguridad / Re: Ordenador indetectable?
28 Octubre 2010, 09:46 AM
Que cosa más rara... De todos modos, la única manera de hacer un ordenador 100% indetectable es montártelo tu mismo, no conectarlo nunca a internet y tenerlo en un búnker...
#1568
Dudas Generales / Re: Aviso de interrupción momentanea
28 Octubre 2010, 09:43 AM
Si no has hecho un backup del sistema antes de instalar esto, tal vez tengas que desinstalar la aplicación a mano.
Primero, de todos modos prueba a desactivar el servicio de la aplicación. Para ello tienes que ejecutar services.msc y deshabilitar el correspondiente (si tiene).
Si esto no funciona, procede a desinstalación manual. Primero de todo finaliza todos los procesos relacionados con la aplicación. Tras esto eliminala a mano. Luego, ejecuta algún limpiador de registro que te quite (a menos parte de) la basurilla que el programa haya dejado en el registro de windows.
Suerte!
Primero, de todos modos prueba a desactivar el servicio de la aplicación. Para ello tienes que ejecutar services.msc y deshabilitar el correspondiente (si tiene).
Si esto no funciona, procede a desinstalación manual. Primero de todo finaliza todos los procesos relacionados con la aplicación. Tras esto eliminala a mano. Luego, ejecuta algún limpiador de registro que te quite (a menos parte de) la basurilla que el programa haya dejado en el registro de windows.
Suerte!
#1569
Ejercicios / Ejercicios de pseudocódigo (Parte2)
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.
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
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
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:
** Extender la ordenación de la sección a**
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.)
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.
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.
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.
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:
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)
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
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]
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
FINBú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]
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
FINBú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]
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
FINORDENACIÓ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]
PARA i = 2 HASTA n** Extender la ordenación de la sección a**
Código [Seleccionar]
FIN PARAUna 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]
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]
pos = i - 1
encontrado = falso
MIENTRAS NOT encontrado AND pos >= 1
SI a(pos) <= x
encontrado = cierto
SINO
pos = pos - 1
FIN SI
FIN MIENTRASSi 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]
MIENTRAS NOT encontrado AND pos >= 1
SI a(pos) <= x
encontrado = true
SINO
a(pos+1) = a(pos)
pos = pos - 1
FIN SI
FIN MIENTRASQuedá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]
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
FINOrdenació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]
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
FINOrdenació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]
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
FINA 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
#1570
Foro Libre / Re: ¿Que le dirías a una persona que se quiere suicidar?
26 Octubre 2010, 14:24 PM
Yo fuí una de esas personas, hasta que un día el primer amigo que conocía en 5 años me pegó un bofetón y me explicó lo mal que se sentiría si me suicidaba.
La primera persona suficientemente sensible que conocí... si...
La primera persona suficientemente sensible que conocí... si...