FUENTE

El lenguaje C es uno de los lenguajes de más bajo nivel (relativo) que existe. En este lenguaje la memoria se estructura de manera plana, que es en definitiva lo que es la memoria, un espacio plano de almacenamiento temporal.

Así entonces un nodo de estructura dinámica como el siguiente:

struct empleado{
int idEmpleado;
char* nombre;
char codigoPostal[6];
int idDepto;
struct empleado* sgte;
}

No es una estructura dimensional, sino un manojo de bytes ordenados:

(
Suponiendo arquitectura intel x86 32bits
int = >4 bytes
Dirección de memoria => 4bytes
char x 6 => 6 bytes
)

id nombre Codigo depto siguiente
[][][][] [][][][] [][][][][][] [][][][] [][][][]

Los cuales son interpretados cada uno como entero, puntero a caracter, entero, entero, entero.
En otras palabras, puede ser claramente un vector de bytes, donde a cada subconjunto de bytes se los interpreta como un tipo de datos nativo según la información de la definición de la estructura.

Bien, ahora supongamos que tenemos esta otra estructura bastante distinta:

struct empresa{
char* idEmpresa;
char* razonSocial;
long int cuit;
char* direccion;
char codigoPostal[6];
struct empresa* sgte;
};

Cuando hacemos funciones de acceso a cola (por ejemplo) siempre tenemos la maldita sensación de estar haciendo las mismas cosas miles de veces, puesto que si bien no es lo mismo un empleado y una empresa,
¡¡Las colas son todas iguales!!
¡¡El mecanismo si es el mismo, agrego al final, saco del principio!!

¿Cómo hacer para separar el “¿Qué?” del “¿Cómo?”?

Con el conocimiento que tenemos ahora de la memoria y la estructuración en memoria de las estructuras, existe al menos una forma de hacerlo.

¿Qué tienen en común todos los nodos de una estructura de datos dinámica / recursiva?
Rta.: El puntero al siguiente nodo.

¿Qué tienen en común todos los punteros en una misma arquitectura hardware / sistema operativo?
Rta.: El puntero es un tipo de datos, no importa lo que apunte, siempre pesa lo mismo.

Si planteamos la siguiente estructura:

Struct Nodo {
Struct Nodo* sgte;
};

Tenemos una estructura que el primer valor es un puntero un siguiente nodo, no tenemos variable “contenedor”, y no la necesitamos, puesto que ahora no nos importa el contenido de información, sino el puntero siguiente.

Un programa hecho en C, interpreta los datos según el tipo del mismo en el instante de ejecución dado.

Si yo modificase las estructuras anteriores y pusiese el elemento siguiente primero en la lista, quedaría esto:

struct empleado{
struct empleado* sgte;
int idEmpleado;
char* nombre;
char codigoPostal[6];
int idDepto;
}

struct empresa{
struct empresa* sgte;
char* idEmpresa;
char* razonSocial;
long int cuit;
char* direccion;
char codigoPostal[6];
};

Ahora, la última pregunta a hacernos es:
¿Qué tienen en común nuestras tres estructuras?
Rta.: Las tres empiezan con un puntero conceptualmente igual, el puntero al siguiente elemento.

Como se dan todas estas relaciones, entonces, gracias a la existencia del “casteo”, que hace que el programa interprete un dato como otro, sin afectarlo en el proceso, entonces, podemos definir todas las funciones para manejo de Colas para la estructura mas chica.

#define null NULL
#include
#include

typedef struct Nodo {
struct Nodo* sgte;
}Nodo;

typedef struct Cola {
Nodo* head;
Nodo* tail;
}Cola;

typedef struct Empleado{
struct Empleado* sgte;
int idEmpleado;
char* nombre;
char codigoPostal[6];
int idDepto;
} Empleado;

void inicializarCola (Cola* unaCola) {
unaCola->head = null;
unaCola->tail = null;
}

void agregarNodo (Cola* unaCola, Nodo* unNodo){
unNodo->sgte = null;

if ( unaCola->tail != null) {
unaCola->tail->sgte = unNodo;
}
unaCola->tail = unNodo;

if (unaCola->head == null) {
unaCola->head = unNodo;
}

}

Nodo* obtenerNodo (Cola* unaCola) {
Nodo* retorno;
retorno = unaCola->head;
if ( unaCola->head != null ) {
unaCola->head = unaCola->head->sgte;
}
return retorno;
}

int main (void) {

Cola unaCola;
Empleado* unEmpleado;
int i;
inicializarCola(&unaCola);

for (i = 0; i codigoPostal), '', 6);
unEmpleado->idDepto = i;
unEmpleado->idEmpleado = i * 2;
unEmpleado->nombre = null;
agregarNodo(&unaCola, (Nodo*)unEmpleado);

}

while ((unEmpleado = (Empleado*) obtenerNodo(&unaCola)) != null) {
printf (" Id Empleado: %d \tId Depto: %d \n", unEmpleado->idEmpleado, unEmpleado->idDepto);
}

return 0;
}

/*
Nota: Ejemplo probado con GCC y MinGW. No incluye el manejo de cadenas y la creación de empleados por una función dedicada por cuestiones de tiempo.
*/

Y con esto, tenemos el algoritmo de inserción y obtención de colas para cualquier nodo que tenga como primer dato de estructura el puntero al siguiente valor.

Como se puede ver a simple vista, esto de poder usar la misma función para distintos tipos de datos en los parámetros tiene cierto potencial.
Esta posibilidad de, por medio de casteo a estructuras menores de igual forma es una forma de emular el llamado Polimorfismo paramétrico (que no es el polimorfismo de objetos, sino, el de funcional)

Dadas dos etiquetas t1 y t2 cualesquiera la similitud semántica entre ambas será:

S ( t1,t2 ) = | t1 ∩ t2 | / | t1 ∪ t2 |

Para este ejercicio, se han calculado el número de apariciones de t1 y t2 en Google. El resultado se puede probar en la siguiente URL:

http://156.35.98.82:8080/tagCloud/

En la aplicación, se pueden escribir una serie de tags (pueden contener espacios, por ejemplo "Fernando Alonso") separados por comas. El algoritmo realiza una serie de iteraciones sobre los términos. En cada una de ellas aplica la fórmula anteriormente descrita y saca la pareja de términos con una similitud semántica más cercana a la unidad. De esta forma, cuanto más parecido sea el número de documentos en los que aparezca la pareja de palabras y el número donde aparezca cada una por separado, más relacionadas semánticamente estarán. Cabe destacar que para calcular la unión (denominador), se ha restado el valor de la intersección, para no sumar así valores repetidos y dar un resultado más fiable.

Las conclusiones que se pueden extraer de su aplicación es que el algoritmo funciona en la mayor parte de los casos, pero se podría refinar mucho más. Por ejemplo, es muy importante el orden en el que se agrupan las parejas de palabras ya que la precisión de los resultados varía si agrupamos por la derecha o por la izquierda. Un refinamiento posible sería comprobar la similitud S entre el término que vamos a agrupar con los términos que forman los extremos del grupo, para situarlo en el extremo que más se asemeje a él.

Siempre deben diseñarse buenas sistemas de la criptografía para que ellas sean muy difícil de romper. Es posible construir sistemas que no pueden romperse en práctica (aunque esto normalmente no puede demostrarse). Esto no aumenta esfuerzo de aplicación de sistema significativamente; sin embargo, algún cuidado y la especialización se requiere. No hay ninguna excusa para un diseñador del sistema dejar el sistema rompible. Debe hacerse cualquier mecanismo que puede usarse para engañar seguridad explícita, debe documentarse, y debe traerse en la atención de los usuarios final.

En teoría, cualquier método de la criptografía con una llave puede ser roto probando todas las posibles llaves en sucesión. Si la única opción es de probar todas las llaves, el tiempo de computación requerido aumenta exponencialmente con la longitud de la llave. Una llave de 32 bits toma 2³² (aproximadamente 10⁹) pasos. Esto es algo que cualquiera puede hacer usando su computadora de casa. Un sistema con las llaves de 40 bits toma 2⁴⁰ pasos - este tipo de cómputo requiere algo como una semana (dependiendo de la eficacia del algoritmo) en una moderna computadora de la casa. Un sistema con las llaves de 56 bits (como DES) toma un esfuerzo sustancial (con un número grande de computadoras de la casa que usan esfuerzo distribuido, se ha mostrado para tomar simplemente unos meses), pero es fácilmente rompible con hardware especial. El costo del hardware especial es sustancial pero fácilmente al alcance de los delincuentes organizados, compañías mayores, y gobiernos. Las llaves con 64 bits son ahora probablemente rompibles por gobiernos mayores, y al alcance de los delincuentes organizados, compañías mayores, y menores gobiernos en pocos años. Las llaves con 80 bits parecen buenas durante unos años, y llaves con 128 bits permanecerán irrompibles probablemente por el futuro previsible. A veces se usan llaves aun más grandes.

Sin embargo, la longitud importante no es el único problema pertinente. Pueden romperse muchos cifres sin probar todas las posibles llaves. En general, es muy difícil de diseñar cifres que no podrían romperse usando otros métodos más eficazmente. Diseñando sus propios cifres puede ser divertido, pero no se recomienda para las aplicaciones reales a menos que usted es un verdadero experto y sabe lo que usted está haciendo exactamente.

Uno generalmente debe ser muy cauto de algoritmos inéditos o confidenciales. A menudo el diseñador no está entonces seguro de la seguridad del algoritmo, o su seguridad depende del secreto del algoritmo. Generalmente, ningún algoritmo que depende del secreto del algoritmo está seguro. Particularmente en software, cualquiera puede contratar a alguien para desmontar el algoritmo. La experiencia ha mostrado que la inmensa mayoría de los algoritmos confidenciales que se han vuelto después al conocimiento público ha sido lastimosamente débil en realidad. Vea los esquemas del encriptación incorporados usados por WordPerfect, Lotus 1-2-3, MS Excel, Symphony, Quattro Pro, Paradox, MS Word, y PKZIP.

Las longitudes de llaves usadas en criptografía de llave-público normalmente son más grandes que en cifres simétricos. Esto es causado por la extra estructura que está disponible. Allí el problema no está de suponer la llave correcta, pero derivando la llave confidencial emparejanda de la llave pública. En el caso de RSA, esto podría ser hecho factorizando un entero grande que tiene dos primeros factores grandes. En el caso de algún otro criptosistemaas es equivalente a computar el modulo del logaritmo discreto un entero grande (qué se cree que es aproximadamente comparable a la factorización cuando el moduli es un grande número primero). Hay las importantes criptosistemaas públicos basados en todavía otros problemas.

Para dar alguna idea de la complejidad para el criptosistemaa de RSA, un módulo de 256 bits se factoriza fácilmente en la casa, y las llaves de 512 bits pueden ser rotas por grupos de investigación de universidad dentro de unos meses. Las llaves con 768 bits son probablemente no afiance en el término largo. Las llaves con 1024 bits y más deben estar ahora seguras para a menos que se hacen mayores adelantos de la criptoanálisis contra RSA; las llaves de 2048 bits son consideradas por muchos para estar seguros durante décadas.

Debe darse énfasis a que la fuerza de un sistema de la criptografía es normalmente igual a su eslabón más débil. Ningún aspecto del plan del sistema debe pasarse por alto, de los algoritmos selectos a la distribución importante y políticas del uso.

Criptoanálisis y ataques de criptosistemas

Criptoanálisis es el arte de descifrar comunicaciones del sin saber las llaves apropiadas. Hay muchas técnicas del criptoanálisis. Algunas de las más importantes para un creador del sistema se describen debajo.

• Sólo-ciphertext ataque: Ésta es la situación donde el asaltador no sabe nada sobre los volúmenes del mensaje, y sólo debe trabajar del ciphertext. En práctica es bastante a menudo posible hacer suposiciones sobre el plaintext, tantos tipos de mensajes han arreglado formato de los títulos. Incluso las cartas ordinarias y documentos empiezan de una manera muy predecible. Por ejemplo, muchos ataques clásicos usan análisis de frecuencia del ciphertext, sin embargo, esto no trabaja bien contra los cifres modernos. Los criptosistemaas modernos no son débiles contra sólo-ciphertext ataques, aunque a veces ellos son considerados con la asunción agregada que el mensaje contiene algún prejuicio estadístico.
• Conocido-plaintext ataque: el asaltador sabe o puede suponer el plaintext para algunas partes del ciphertext. La tarea es de decriptar el resto del ciphertext usando esta información. Esto puede ser cumplido determinando la llave usada al encriptar los datos, o vía algún atajo. Uno bien conocido ataque moderno de conocido-plaintext esta el criptoanálisis lineal contra los cifres del bloque.
• Escogido-plaintext ataque: el asaltador puede tener cualquier texto que le gusta el encriptado con la llave desconocida. La tarea es determinar la llave usada para el encription. Un bueno ejemplo de este ataque es el criptoanálisis del diferencial que puede aplicarse contra los cifres del bloque (y en algunos casos también contra las funciones de hash).Algunos criptosistemaas, particularmente RSA, son vulnerables a los ataques escogido-plaintext. Cuando se usan tales algoritmos, el cuidado debe tenerse para diseñar la aplicación (o protocolo) para que un asaltador nunca pueda haber encriptar el escogido-plaintext.

Fuente

Se usan firmas digitales para verificar que un mensaje realmente viene del remitente exigido (asumiendo a sólo el remitente sabe la llave confidencial que corresponde al su llave pública). Ellos también pueden ser usados por tiempo-estampar los documentos: persona de confianza firma el documento y tiempo-estampar con su llave confidencial, así testificando que el documento existió en el momento declarado.

También pueden usarse firmas digitales para testificar (o certifica) que una llave pública pertenece a una persona particular. Esto es hecho firmando la combinación de la llave y la información sobre su dueño por una llave confidencial. La firma digital por una tercera persona (dueño de la llave confidencial), se llaman a menudo la llave pública y información sobre el dueño de la llave pública los certificados.

La razón por confiar en la llave de tercera persona puede ser que de nuevo fue firmada por una llave confidencial. Eventualmente alguna llave debe ser una raíz de la jerarquía de confianza (es decir, en él no se confía porque fue firmada por alguien, pero porque usted cree a prior que en esta llave puede confiarse). En una infraestructura de llave centralizada hay menos raíces en la red de confianza (ej. en agencias gubernamentales se llaman tales raíces las autoridades de la certificación). En una infraestructura distribuida allí no se necesita universalmente aceptados raíces, y cada persona puede tener diferentes raíces de confianza (tal la propia llave de la persona y cualquier llave firmada por él). Éste es el tejido de concepto de confianza usado en PGP.

Una firma digital de un documento arbitrario es creada típicamente computando un compendio del mensaje del documento, y encadenándolo con información sobre el firmante, una tiempo-estampa, etc. El hilo resultante es entonces encriptado usando la llave privada del firmante que usa un algoritmo conveniente. El resultante encriptado bloque de bits es la firma. Es a menudo distribuido junto con la información sobre la llave pública que fue usada para firmarlo. Para verificar una firma, el destinatario determina primero si confía que la llave pertenece a la persona que él se supone que pertenece a (usando la red de confianza o el previo conocimiento), y entonces el decripta la firma usando la llave pública de la persona. Si la firma decripta propiamente y la información empareja el mensaje (compendio del mensaje apropiado etc.), la firma se acepta como válido.

Varios métodos por hacer y verificar firmas digitales están libremente disponible. El algoritmo ampliamente conocido es RSA.

Solo hagan click en el link:

• solucionario-asesoria [word]
• solucionario - asesoria [rar en usaupload]

/***************************************************************************/

Se suponia que la clave era SOLO para los que se quedaron en la asesoria, pero entiendo que algunos no pudieron quedarse por otras razones (DIFERENTES a juegos o fiestas).

Hasta hoy, los que se quedaron a la sesoria ya habran rebizado el solucionario [y corregido algun pequeño error encontrado (supongo)]; asi que dejare la clave para los que "NO SE PUDIERON QUEDAR" :

Clave: fiis

PD: pense que cualquiera que descargara el archivo por lo menos intentaria una vez poniendo como clave a la facultad no?

/***************************************************************************/

Saludos!!

descargar aqui [rapidshare]

descargar aqui [usaupload]

De esta manera se han creado lenguajes que puedan representar nuestros algoritmos y que de esa manera se construya una solucion correcta sin omitir algunos pasos. Imaginense que si se desea crear un algoritmo para que un robot solde una pieza en una ensambladora de automóviles y la persona encargada de implementar el algoritmo olvida, por muy obvio que sea, comprobar si las piezas están en su lugar, obviamente podria terminar en tragedia.

Asi que la gente que se encarga de los estándares en cuanto a lo que se refiere a las tecnologías de la informacion vio la necesidad de representar algoritmos sin tener que referirse a un lenguaje de programación en específico.

Graficos

Este tipo de lenguaje tiende a representar a los algoritmos de una forma grafica. De esta manera se hace mas facil la representación de cada uno de los procesos que debe llevar a cabo una computadora para resolver problema.

Diagramas de Flujo

Sin lugar a duda el lenguaje algorítmico gráfico más común son los Diagramas de Flujo. Éstos pueden definirse como esquemas usados para representar gráficamente un proceso. Pero no sólo se utilizan para representar procesos informaticos, tambien en otras áreas como la economia, la administracion, procesos industriales, etc.

A continuacion explicaremos los símbolos más comunes que se utilizan en la informática para representar diagramas de flujo.

Existen otros simbolos más especificos para otro tipo de procesos, pero en su mayoria ya no se usan porque representaban procesos en dispositivos que hoy en día son obsoletos, como grabar en cinta magnética o leer una tarjeta perforada.

No graficos

Los lenguajes algoritmicos no graficos generalmente son utilizados para representar procesos informaticos ya mas especificos. Dicho de otra forma, para representar la codificacion de un programa sin la necesidad de conocer un lenguaje de programacion especifico.

Pseudocodigo

Sin lugar a duda, el pseudocodigo es el lenguaje algoritmico no grafico mas utilizado hasta la fecha. Cualquier persona que se diga que tiene experiencia como programador, alguna vez se ha visto en la necesidad de representar sus programas en pseudocodigo.

El pseudocodigo significa que vas a convertir tu algoritmo en un lenguaje escrito que se entienda sin utilizar la sintaxis y la gramatica de un lenguaje de programacion en especifico. Existen diferencias entre las normas de como debe realizarse correctamente un pseudocodigo debido a que, como no es necesariamente un lenguaje de programacion, debe adaprtarse a las necesidades del algoritmo en si; por eso varios autores definen su propia sintaxis y gramatica de forma diferente.

Datos

En un pseudocodigo los datos se dan por creados desde el momento en el que son utilizados, asi que no es necesario avisar que variables vamos a ocupar a lo largo de nuestro algoritmo, ni que tipo de datos es el que se va a almacenar dentro de él; pero, una ves que se a utilizado una variable para almacenar cierto tipo de dato debe seguir siendo usada para este tipo. Por ejemplo, si al inicio de nuestro pseudocodigo declaramos que vamos a usar una variable que llamaremos "A" y le asignamos un valor numérico entero como 8, la variable "A" en el resto del algoritmo deberá solamente poder alamacenar datos numéricos enteros.

horario: 6:00p.m-8:00p.m

Asesores:

• Narcizo Susanibar, Miguel
• Pecho Caycho,Ronald
• Sinche Castillo, Boris
• Villanueva Quinteros, Lenin
• Ynocente Castro, Mario

Identificacion de problemas

Generalmente se debe identificar cual es el problema que se pretende resolver atraves de medios informaticos y con que se pretende darle solucion. Los informaticos llaman a este paso analizis.

• Datos numericos. Es todo tipo de informacion que se puede expresar por medio de numeros(enteros ejemplos: 8,-3,23, etc), y (Numeros Reales o de puntos flotantes 1.5, -3.83,etc.)
• Datos alfanumericos. Son un conjunto de caracteres que representan algun tipo de dato. Estan compuestos por todo el conjunto de caracteres alfabeticos, numericos, y algunos caracteres especiales.
• Datos Logicos. Son los que podemos representar mediante dos estados falso y verdadero. Tambien se les conoce como datos boleanos.
• Constantes. Son datos que dentro del problema en si nunca cambiaran por ejemplo, si el problema es calcular el area de un circulo,? = 3.141592 sera una constante para cualquier caso.
• Variables. Son datos que cambian dependiendo de las condiciones del problema que se decea resolver. Tomando el mismo ejemplo del calculo del area de un circulo, la variable podria ser el radio ya que, dependiendo del tamaño del circulo cambiara ese valor.
• Expresiones Logicas. Son un conjunto de condiciones que solo pueden tomar dos estados logicos: falso y verdadero. Estan compuestas por variables constantes operadores logicos y operadores relacionales. Los operadores logiocos son: NOT(no), AND(y) y OR (o). Los relacionales pueden ser: <,>, <=, =<, <>. Dependiendo del elnguaje de programacion que se desee utilizar para resolver el problema puede o no cambiar la forma en que se presentan estos operadores. Por ejemplo, el lenguaje de programacion basados en ANSI como C,C++ y JAVA la negacion se representa por el simobolo de admiracion (!).
• Expresiones Aritmeticas. Son expresiones que se usan para el calculo de valores aritmeticos. Son muy utilez y faciles de entender ya que se representan de forma muy parecida a las expresiones matematicas. Los operadores aritmeticos son los siguientes: +,-,*,/,^,(,) , etc. Al igual que las expresiones logicas, dependiendo del lenguaje de programacion es la forma en como se representa alguno de los operadores aritmeticos y, en ocasiones, hasta la jerarquia que tienen unos sobre otros.

Diseño de una Solucion

Una ves definido el problema y con que se quieres o se puede resolver, se planea la forma de hacerlo, creando un algoritmo de solucion. Usualmente a este proceso se le llama diseño.

Aplicando la Solucion

Cuando ya se definio como se va a resolver el problema, todo lo que implica su solucion atraves de diferentes mecanismos, es hora de aplicarlo. Los informaticos le llaman a este proceso implementacion.

Supervisar la Solucion

Seria excelente que al aplicar una solucion a un problema, este resulte correcta al primer intento. Desafortunadamente no es asi, muchas veces el hecho de aplicar una solucion nos lleva a mas problemas que no estaban preevistos. En la informatica ay que ser muy precisos en los casos que se presentan como problemas y tratar de prever cualquier tipo de inconveniente o caso especial que se pueda presentar, para ello se lleva acabo un proceso llamado prueba o mantenimiento. Es aqui donde el ciclo se puede llegar a repetir tratando de solucionar los nuevos problemas que intervienen en la solucion nos puede llevar de nuevo al analisis y volver a comenzar el ciclo. Este se rompera caundo el problema sea resuelto satisfactoriamente y todo los casos particulares esten cubiertos.

Dicho de esta forma, podemos ver el proceso de solucion como un ciclo de vida, por eso muchos autores manejan este proceso como el ciclo de vida del software.

Eu assino muitos blogs via RSS. O Google tem uma ferramente, Google Reader, que permite que você assine os blogs/sites de que você gosta, para ficar atualizado sempre que atualizarem o blog/site. Funciona da seuinte maneira: você clica em incrição, digita o endereço, e pronto: sempre que o Blog for atualizado, você recebe a atualização na página do google reader. Assim, não precisa ir de blog em blog ver se tem algo útil.

Além disso, o google reader tem uma ferramente típica da web 2.0. Ele compara pessoas com gostos parecidos com o seu (que assinam os mesmos blogs) e procura padrões. Assim, se muita gente que assina um Blog do corinthians também assina um blog de futebol paulista, ele recomenda para você o blogdo futebol paulista. Obviamente tem um algoritmo para isso.

Porém, esse tipo de ferramente, enquanto útil, sempre tem um problema porque o computador (algoritmo) é meio burro. Então, seria melhor se pudéssemos colocar tags nos blogs que assinamos, de forma que aumentasse a eficiência dessa ferramenta.

Enquanto isso não acontece, decidi retornar ao modo antigo e inquirir as pessoas sobre que tipo de blogs elas assinam. Ok, não é exatamente o modo antigo, pré- web, já que quem vem ao meu blog deve compartilhar algum interesse comigo. De todo modo, peço que deixem no comentário, com base no que viram no meu blog, quais RSS vocês assinam e que gostariam de compartilhar comigo.

Abaixo todo os blogs que assino:

http://www.againstmonopoly.org/

http://www.badscience.net/

http://ba.stat.cmu.edu/forthcoming.php

http://ba.stat.cmu.edu/forthcoming.php

http://cienciaemdia.folha.blog.uol.com.br/

http://anand.typepad.com/datawocky/

http://flowingdata.com/

http://marcelocoelho.folha.blog.uol.com.br/

http://www.monbiot.com/

http://outrapolitica.wordpress.com/

http://sequenciasparisienses.blogspot.com/

http://www.iq.harvard.edu/blog/sss/

http://socialscienceplusplus.blogspot.com/

var
n1,n2:real
inicio
// Seção de Comandos

leia(n1,n2)
escreval("a soma é ", n1+n2)

se (n2<>0) entao
escreval("a divisao é ", n1/n2)
fimse

escreval("o quadrado de n1 é ", n1*n1)
escreval("o quadrado de n2 é ", n2*n2)

fimalgoritmo

---------------------------------------------------

algoritmo "q2provarecuperacao"

var
n:inteiro
inicio

leia(n)

se (n % 3 = ) entao
escreval ("divisivel por 3")
fimse

se (n % 17 = ) entao
escreval ("divisivel por 17")
fimse

fimalgoritmo

---------------------------

algoritmo "q3provaRecuperacao"

var
i, maior, menor , n :inteiro
inicio

leia(n)
maior<-n
menor<-n

para i de 2 ate 100 faca
leia(n)
se (n > maior) entao
maior<-n
fimse
se (n < menor) entao
menor<-n
fimse
fimpara
escreval("o menor é ", menor)
escreval("o maior é ", maior)

fimalgoritmo

----------------------

algoritmo "q4provaRecuperacao"

var
nomes: vetor [1..15] de literal
i: inteiro
busca:literal
inicio
//cadastro no vetor
para i de 1 ate 15 faca
leia(nomes[i])
fimpara

leia(busca)

para i de 1 ate 15 faca
se (busca=nomes[i]) entao
escreval("nome encontrado")

fimse

fimpara

fimalgoritmo

Marcos Vinicius - :Luciene - Glaide

Carina - Josivane - Bruna

Alessa - Roseane - Luciana Souza

Monira - Patrícia - Arisvaldo

Jorge - Diego - Josué

Aline - Jilcimar - Oliviane

Carla - Juliana - Silvana

Alana - Diego Miranda - Micilene

Wilma - Rodolfo - Cláudia

Robson - Luis Antonio - Ana Cristina

Thais - Camila - Cristiane

Parte 1 - Estruturas de Decisão: 19/06 (25 exercícios)

Parte 2 - Estruturas de repetição: 08/07 (29 exercícios)

Parte 3 - Vetores : 17/07 (15 exercícios)
-----------------------------> Não haverá adiamento nos prazos

Dia 17/07 será realizada um avaliação final baseada nesses exercícios

Os trios serão definidos na próxima aula.

Arquivo da lista: listao-pascal

Elaborei uma cartilha de transição do Visualg para o Pascal. Pode conferir no link ao lado cartilhapascal.

O compilador a ser usado será o PascalZim, que pode ser baixado no link abaixo:

http://www.ziggi.com.br/downloads/PASCAL-ZIM!.asp

En estos días mi trabajo en el doctorado involucra contar cuántos puntos con coordenadas enteras tienen ciertos "poliedros" en 12 dimensiones. Tales poliedros están determinados por las formas diferentes en que se puede descomponer un número como sumas ordenadas, es decir particiones. Así, dado que 6=3+1+1+1, entonces [3,1,1,1] es una partición de 6.

Las distintas particiones de n=6 son

[6] [5, 1] [4, 2] [4, 1, 1] [3, 2, 1] [3, 1, 1, 1]
[2, 2, 2] [2, 2, 1, 1] [2, 1, 1, 1, 1] [1, 1, 1, 1, 1, 1, 1]

En la aplicación particular que estoy trabajando, únicamente nos importan particiones de longitud 3. Entonces de las anteriores sólo se considerarían

[4, 1, 1]
[3, 2, 1]
[2, 2, 2]

Como siempre es mejor usar la computadora para las tareas mecánicas, me propuse elaborar un programa en Python que genere particiones de un número entero.

El esquema básico es el siguiente:

1. Recorrer todos los números n, n-1, n-2, .., 3, 2, 1  para ocupar la primera posición
2. Una vez fija la primera posición k,  el resto se genera "uniendo" esa primera posición con todas las particiones de n-k.

Por ejemplo, si n=6,  y k=4 entonces todas las particiones que inician con 4 se obtienen de las particiones de 2: [2] y [1,1], dando como resultado [4,2] y [4,1,1], ambas mencionadas arriba.

En particular, una partición es una lista, y el resultado del programa debe ser una lista de listas. Finalmente, aunque en mi aplicación sólo es necesario calcular particiones de longitud 3, me conviene poder calcular particiones de cualquier otra longitud fija.

Bosquejo inicial

# coding=latin1
def particiones(n):
    if n==1:                   # Esto detiene la recursión, si n=1, la única partición es [1],
                               # por lo que la lista de las particiones es [ [1] ]
        return [ [1] ]
    elif n<1:
        return []          # Por si acaso atrapar casos "raros". Si n=0, no hay particiones, regresar []
                           # de modo similar para n<0.
    listaparticiones=[]        # incialmente no tenemos ninguna partición calculada
    for k in range(n,0,-1):      # Aquí recorremos todos los valores k para el primer elemento
        cola= particiones(n-k)     # generamos la lista de particiones de n-l
        for x in cola:             # y para cada una de ellas...
            particion= [k] + x      # la unimos con el primer elemento
            listaparticiones.append(particion)   # y la agregamos a la lista
     return listaparticiones       # al final devolvemos todas las que hayamos construido

lista=particiones(5)        # calcularemos las particiones de n=5...
for p in particiones(5):    # y luego las mostraremos
print p

Todo listo, corremos y...

[4, 1]
[3, 1, 1]
[2, 2, 1]
[2, 1, 1, 1]
[1, 3, 1]
[1, 2, 1, 1]
[1, 1, 2, 1]
[1, 1, 1, 1, 1]

Se ha omitido [5] porque la recursión termina cuando n<0 la lista sobre la que se itera es vacía. Esto se soluciona cambiando

        elif n<1:
                return [] 

por

        elif n<1:
                return [ [] ]          

Sin embargo, algo ha salido mal, porque [1,3,1] no es partición. El problema es que el esquema original no contempla que las "colas" que generan las particiones de n-k no pueden iniciar con un entero mayor que la "cabeza" k.

Otro problema menos evidente y mucho más interesante, es que se están efectuando muchísimas recursiones, en cada paso manteniendo en memoria listas muy grandes de particiones de forma innecesaria (por ejemplo, hay 200 000 particiones de n=50, y al efectuar la recursión fácilmente se usarán varios megabytes de memoria para algo tan sencillo). Además, se hace necesario almacenar la lista de particiones en una variable para poder recorrerla, como en:

lista=particiones(5)
for p in particiones(5):
      print p

La solución a ésto es descartar el enfoque rudimentario de hacer recursiones sobre listas y usar generadores.

Generadores en python

Un generador es una forma conveniente de crear funciones que regresan valores pertenecientes a una lista sin tener que calcular toda la lista de antemano. En el ejemplo anterior, es necesario calcular TODA la lista de particiones

lista=particiones(5)

antes de poder mostrar siquiera la primera. Sería mucho más conveniente que particiones() diera cada una de ellas al necesitarlas, sin necesidad de calcularlas todas de antemano, lo cual se obtiene mediante el uso de generadores.

Otro uso de los generadores es devolver los elementos de una lista infinita, y como matemáticos esto es muy útil, sobre todo si se quiere modelar series y sucesiones.

Por ejemplo, queremos generar una lista de las primeras t aproximaciones a la suma 1 + (1/2) + (1/3) + ... + (1/n).  La función sería:

def armonica():
     suma=0.0        # inicializamos valores
     n=0.0
     while True:   # ciclo infinito!!
         n=n+1         # aumentamos la variable
         suma = suma + 1/n    # calculamos la nueva suma
         yield suma           # regresamos el nuevo valor

El uso de yield en vez de return convierte a la función en un generador, que regresa sus valores de uno en uno en vez de todos al mismo tiempo.

Y el siguiente es un ejemplo de su uso:

t=6
z=armonica()
for j in range(t):
     print z.next()

resultando en

1.0                # 1
1.5                # 1 + 1/2
1.83333333333      # 1 + 1/2 + 1/3
2.08333333333      # 1 + 1/2 + 1/3 + 1/4
2.28333333333      # 1 + 1/2 + 1/3 + 1/4 + 1/5
2.45               # 1 + 1/2 + 1/3 + 1/4 + 1/5 + 1/6

Siendo clave la línea

print z.next()

en la que calcula el siguiente término, sin necesidad de recalcular los anteriores y sin necesidad de calcular los siguientes (al no saber cuántos se le pedirán).

Por ejemplo, si queremos generar todas las aproximaciones hasta que excedamos 3 podemos usar:

for x in armonica():
     print x
     if x >3: break

Este ejemplo es más ilustrativo, porque no sabemos ni siquiera cuántos elementos se calcularán, simplemente se calcula de uno en uno hasta obtener alguno que exceda 3. La línea for x in armonica(): está haciendo uso de que armonica() es un iterador, por lo que se puede recorrer de uno en uno como cuando se recorre range().

De vuelta al problema

Necesitamos entonces 2 cambios: usar generadores y establecer un tope (opcional) al elemento inicial, tope que es necesario para evitar obtener resultados del tipo [1, 3, 1, 1].

def particiones(n, tope=None):     # tope es un parámetro opcional
    if tope==None: tope=n          # si no está presente, la cabeza de la partición puede ser
                                   # tan grande como n mismo
    if n==1:
        yield  [1]          # dado que ya no regresamos una "lista de listas"
    elif n<1:               # sino sólo un elemento, ya no necesitamos los corchetes extra
        yield []
    else:                    # necesario pues a diferencia de return, la función no termina al
                             # al llegar a yield, sino que sólo se pausa
        for k in range(min(n,tope),0,-1):   # min(n,tope) impide que las cabezas sean mayores topes
            for cola in particiones(n-k,tope=k):  # y cada cabeza es tope de las subllamadas
                particion= [k] + cola
                yield particion

Notemos que ya no fue necesario usar variables auxiliares como listaparticiones y colas para almacenar las listas temporales, sino que el uso de generadores (yield) permite acceder a las funciones mismas como si fueran listas.

Usamos la función anterior como:

for x in particiones(5):
        print x

Obteniendo:

[5]
[4, 1]
[3, 2]
[3, 1, 1]
[2, 2, 1]
[2, 1, 1, 1]
[1, 1, 1, 1, 1]

O como en

for x in particiones(6,tope=4):
    print x

que resulta en

[4, 2]
[4, 1, 1]
[3, 3]
[3, 2, 1]
[3, 1, 1, 1]
[2, 2, 2]
[2, 2, 1, 1]
[2, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1]

Las cuales son las particiones de 6 sin elementos mayores a 4.

Toques finales

Casi estamos listos, sólo falta ahora filtrar de forma opcional aquellas particiones que tengan una longitud dada. Añadiremos un nuevo parámetro auxiliar "partes" que dirá el número de partes en que se divide n:

def particiones(n, tope=None, partes=-1):
    # sólo usaremos "partes" cuando sea positiva, por eso el valor inicial de -1
    if tope==None: tope=n
    if n==1:
        yield  [1]
    elif n<1:
        yield []
    else:
        for cabeza in range(min(n,tope),0,-1):
            for cola in particiones(n-cabeza,tope=cabeza,partes=partes-1):  # cada subllamada disminuye las partes en 1
                particion= [cabeza] + cola
                if (partes<0) or ((partes>0) and (len(particion)==partes) ):   # cuando el número de partes no importa
                                                                                # o coincide con el número de partes requerido
                    yield particion                                # devolver la partición

Dado que en cada etapa se filtran las particiones para devolver las que tienen el número de partes necesario, en las etapas más profundas de la recursión se regresan menos particiones y por tanto al construir las particiones totales al salir de las recursiones se hacen muchas menos concatenaciones, de modo que el programa corre mucho más rápido que si directamente se generaran todas y a la salida final se filtraran las que tienen el tamaño deseado.

El resultado de invocar a la función con

for x in particiones(6, partes=3):
    print x

es:

[4, 1, 1]
[3, 2, 1]
[2, 2, 2]

Podemos incluso combinar los parámetros. Así, pedimos las particiones de 10 cuya primera entrada no exceda de 6 y que tengan 4 partes:

for x in particiones(10, partes=4, tope=6):
    print x

obteniendo:

[6, 2, 1, 1]
[5, 3, 1, 1]
[5, 2, 2, 1]
[4, 4, 1, 1]
[4, 3, 2, 1]
[4, 2, 2, 2]
[3, 3, 3, 1]
[3, 3, 2, 2]

Y con eso damos por terminado el trabajo que queríamos.

Uno de estas personas autorizadas es Udi Manber, uno de los pioneros de los métodos de búsquedas en la WWW y responsable de calidad del buscador web de Google, que con este post oficial inicia una serie de artículos oficiales en los que pretende ofrecer un poco más de transparencia sobre su funcionamiento. El objetivo: seguir contando con el respeto de los webmasters que crean sitios web para posicionarse en Google y, sobre todo, de los millones de usuarios que diariamente lo utilizan para buscar información.

Algunas de las cosas más interesantes del citado post son:

Hay más de 1.000 programadores y científicos destinados exclusivamente a tareas relacionadas con el buscador web de Google.

Uno de los problemas más importantes a la hora de rastrar la información de la WWW es que no las páginas web están en cientos de idiomas diferentes, y que además los webmasters no suelen seguir los estándares a la hora de crear documentos web.

Otro problema es entender las consultas de los usuarios, los cuales suelen utilizar menos de tres palabras por cada búsqueda, lo que complica la tarea. Hace unos meses se publicaron estos datos al respecto: solamente el 26% de los usuarios utilizan cuatro o más términos por búsqueda. Además, hay que recordar que el propio Manber reconocía hace tiempo que una de cuatro búsquedas en Google es inédita, lo que complica aún más la labor de devolver resultados con información útil.

El algoritmo de PageRank se sigue utilizando a día de hoy, pero se ha diluido dentro de un sistema mucho más grande de evaluación de la relevancia de los documentos web. Ahora, además de este parámetro, se tienen en cuenta otros como los modelos del lenguaje (Google procesa ahora las frases que se rastrean, los sinónimos o las palabras mal escritas), o la antigüedad o la frescura del documento web (algunas búsquedas tienen su mejor información en las páginas que se han creado en las últimas horas).

Continuamente se están realizando modificaciones en los algoritmos del buscador, y en concreto en 2007 se lanzaron 450 nuevas mejoras (9 por semana de media).

Se ha implementado recientemente la herramienta de revisión ortográfica (el famoso "Quizás quiso decir") en diferentes idiomas, como el catalán, el serbio o el ucraniano.

Google ha creado una red de personas en varios países del mundo, que se encargan de "ofrecer feedback a Google", en referencia al laboratorio 'Rater Hub', en el que se contrata a usuarios de Internet (también de España) para que entrenen a los algoritmos de búsqueda (ver post sobre documento de uso del laboratorio).

Google cuenta también con un importante grupo de voluntarios dentro de la compañía que les ayuda a mejorar las búsquedas en diferentes idiomas.

Muy pocos usuarios se leen las páginas de ayuda del buscador web, y son mayoría los que desconocen todas las posibilidades que ofrece. Por ello, nos encontramos cada vez más con información proveniente de otras herramientas de Google dentro de los resultados del buscador web. Es lo que se conoce como 'Google Universal Search', presentado por el propio Manber hace justo un año.

Hay diferentes grupos de trabajo dentro del Departamento de Calidad del buscador web, y dos de ellos están relacionados con los webmasters. Uno de ellos, para detectar cualquier intento de engaño por parte de algunos de ellos (el de 'Web Spam'), y otro para abrir un canal de comunicación con Google (el de 'Google Webmasters Tools').

Publicado en Google.dirson.com  el 24 de mayo de 2008