Esse é o primeiro post no qual começarei a falar a respeito dos principais algoritmos de ordenação conhecidos. Hoje especificamente, falarei a respeito do bubble sort.

O bubble sort é um dos mais simples algoritmos de ordenação e trabalha de uma maneira super simples: Percorre repetidas vezes o vetor que se deseja ordenar, comparando duas posições desse vetor e realizando um "swap" entre elas caso o valor da primeira posição seja maior que o valor da segunda posição. Enquanto houver algum swap o algoritmo é executado.

Dos algoritmos de ordenação é o pior, pois tem complexidade O(n²)

Exemplo:

Imaginemos que você possui um vetor com os seguintes números inteiros [5, 1, 4, 2, 8], e deseja ordená-lo de modo crescente utilizando o algoritmo bubble sort. A cada vez que o vetor é percorrido pelo algoritmo, os elementos em negrito são comparados:

Primeira Vez:

// O algoritmo compara os dois primeiros elementos e realiza o swap entre eles.
( 5 1 4 2 8 ) \para ( 1 5 4 2 8 )
( 1 5 4 2 8 ) \para ( 1 4 5 2 8 )
( 1 4 5 2 8 ) \para ( 1 4 2 5 8 )
( 1 4 2 5 8 ) \para ( 1 4 2 5 8 )

Segunda vez:
( 1 4 2 5 8 ) \para ( 1 4 2 5 8 )
( 1 4 2 5 8 ) \para ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \para ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \para ( 1 2 4 5 8 )
// Nesse momento o vetor está completamente ordenado, entretando o algoritmo não sabe disso. Ele necessita percorrer mais uma vez o vetor sem realizar um swap para compreender isso.

Terceira vez:
( 1 2 4 5 8 ) \para ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \para ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \para ( 1 2 4 5 8 )
( 1 2 4 5 8 ) \para ( 1 2 4 5 8 )
// Finalmente o vetor está ordenado e o algoritmo pode encerrar sua execução.

Um exemplo da implementação desse algoritmo em C# pode ser verificado a seguir:

using System;
namespace ConsoleApp
{
    class Program
    {
        static void Main()
        {
            int[] vetor = { 65, 45, 12, 77, 50, 60, 21, 65, 11, 87 };

            foreach (int item in bubble_sort(vetor))
                Console.WriteLine("{0},", item);

            Console.ReadKey(true);
        }
        public static int[] bubble_sort(int[] vetor)
        {
            bool swap;
            do
            {
                swap = false;
                for (int i = 0; i  vetor[i + 1])
                {
                    if (vetor[i] > vetor[i + 1])
                    {
                        int temp = vetor[i + 1];
                        vetor[i + 1] = vetor[i];
                        vetor[i] = temp;
                        swap = true;
                    }
                }
            }
            while (swap);
            return vetor;
        }
    }
}

Bom pessoal, é isso! Espero que tenham gostado!

Quaisquer dúvidas entrem em contato comigo!

At
Glauco Vinicius

Para resolver esse problema, os algoritmos foram divididos em grupos denominados "Classes de Problemas", de acordo com o parâmetro que afeta mais significativamente o algoritmo.

Classes de Algoritmos

• Complexidade Constante
• Complexidade Linear
• Complexidade Logarítmica
• N log N
• Complexidade Quadrática
• Complexidade Cúbica
• Complexidade Exponencial

Complexidade Constante

• Algoritmos de complexidade O(1)
• Independe do volume de entradas N
• Suas instruções são executadas em um número fixo de vezes

Exemplo:

using System.Collections.Generic;
namespace ConsoleApp
{
    class Classe
    {
        public bool verifica_lista_vazia<T>(List<T> lista)
        {
            bool lista_vazia = lista.Count == 0; // Complexidade O(1)
            return lista_vazia;
        }
    }
}

Complexidade Constante

• Algoritmos de complexidade O(N)
• Uma operação é realizada para cada elemento de uma entrada N

Exemplo:

using System.Collections.Generic;
using System.Collections;
namespace ConsoleApp
{
    class Classe
    {
        public void percorre_lista<T>(List<T> lista)
        {
            IEnumerator enumerator = lista.GetEnumerator(); // Complexidade O(1)
            int count = 0; // Complexidade O(1);
            while (enumerator.MoveNext()) // Complexidade O(N)
            {
                count++;
            }
        }
    }
}

Complexidade Logaritmica

• Algoritmos de complexidade O(logN)
• Ocorre tipicamente em algoritmos que dividem o problema em partes menores

Exemplos: Busca binária

N log N

• Algoritmos de complexidade O(NLogN)
• Ocorre tipicamente em algoritmos que dividem o problema em partes menores, porém juntando posteriormente a solução dos problemas menores

Exemplos: Algoritmos de ordenação externa

Complexidade Quadrática

• Algoritmos de complexidade O(N²)
• Os itens são processados aos pares, em geral com um laço de iteração dentro de outro laço

Exemplo:

using System.Collections.Generic;
using System.Collections;
using System;
namespace ConsoleApp
{
    class Classe
    {
        public void do_nothing(string[] collection_01, string[] collection_02)
        {
            foreach (string item_01 in collection_01) // Complexidade O(N²)
            {
                foreach (string item_02 in collection_02)
                {
                    Console.WriteLine("{0}-{1}", item_01, item_02);
                }
            }
        }
    }
}

Complexidade Cúbica

• Algoritmos de complexidade O(N³)
• Itens são processados três a três, em geral um laço de iteração dentro de outros dois

Exemplo:

using System.Collections.Generic;
using System.Collections;
using System;
namespace ConsoleApp
{
    class Classe
    {
        public void do_nothing(string[] collection_01, string[] collection_02, string[] collection_03)
        {
            foreach (string item_01 in collection_01) // Complexidade O(N³)
            {
                foreach (string item_02 in collection_02)
                {
                    foreach (var item_03 in collection_03)
                    {
                        Console.WriteLine("{0}-{1}-{2}", item_01, item_02, item_03);
                    }
                }
            }
        }
    }
}

• Algoritmos de complexidade O(2^N)
• Utilização de Brute Force para resolvê-los
• Geralmente não são úteis do ponto de vista prática

At
Glauco Vinicius

Existem três escalas de complexidade:

• Pior Caso
• Caso Médio
• Melhor Caso

Pior Caso

• Abordagem que utilizaremos nos próximos posts
• Representado pela letra grega O (ômicron maiúscula)
• Método simples de se obter a complexidade. Baseia-se no maior tempo de execução

Exemplo:
Vamos imaginar que você possui uma lista de telefones com N entradas e deseja encontrar um número específico nessa lista. Assume-se então que a complexidade no pior caso será de O(N), pois leva-se em consideração que o número estará no último lugar da lista.

Caso Médio

• Representado pela letra grega θ (theta)
• É o mais difícil de se determinar
• Deve-se obter a média dos tempos de execução de todas as entradas de tamanho N, ou baseado em probabilidade de determinada condição ocorrer

Melhor Caso

• Representado pela letra grega Ω(ômega)
• Baseia-se no menor tempo de execução de uma entrada N
• É pouco utilizado

Exemplo:
Vamos imaginar que você possui uma lista de telefones com N entradas e deseja encontrar um número específico nessa lista. Assume-se então que a complexidade no melhor caso será de Ω(1), pois leva-se em consideração que o número estará no primeiro lugar da lista.

No próximo post veremos como determinar a complexidade de um algoritmo já implementado utilizando a abordagem do pior caso.

At
Glauco Vinicius

Grande parte das pessoas que já fizeram AEDS viram que:

• Um algoritmo resolve um determinado problema e tem uma entrada de dados N
• O tamanho da entrada N influencia diretamente no tempo de execução do algoritmo

A complexidade de um algoritmo pode ser dividida em duas partes:

• Complexidade espacial: quantidade de recursos necessários para resolver determinado problema
• Complexidade temporal: quantidade de tempo ou número de instruções necessarias para resolver determinado problema

O objetivo nesse primeiro momento é estudar a complexidade temporal. Vale lembrar mais uma vez que em ambos os casos a complexidade é medida levando em consideração o volume da entrada de dados (N)

Nos próximos post falarei mais a respeito da complexidade temporal.

At
Glauco Vinicius

A partir de hoje começarei a postar alguns algoritmos que tenho aprendido sob a orientação de Júlio Melo, um amigo que trabalha comigo na Squadra Tecnologia.

A idéia é criar um repositório pessoal de fácil consulta e promover um maior conhecimento por parte dos leitores de alguns algoritmos não tão difundidos mas que podem ajudar em muito no dia-a-dia.

Iniciei a semana aprendendo o algoritmo de pesquisa binária. Esse é um algoritmo para realizar busca em vetores. É um pré-requisito para a utilização desse algoritmo que o vetor esteja ordenado.

Basicamente o algoritmo realiza sucessivas divisões do espaço de busca (uma técnica conhecida como divisão e conquista), nas quais compara o elemento buscado, também conhecido como chave, com o elemento do meio do vetor. Se o elemento do meio do vetor for o valor buscado, a busca termina com sucesso, caso contrário, se o elemento do meio vier antes da chave, então a busca continua na metade superior do vetor, se o elemento do meio vier depois da chave, a busca continua na metade inferior do vetor.

Esse é um algoritmo de complexidade O(logN), onde n é o tamanho do vetor de busca.

Abaixo a implementação desse algoritmo utilizando C#. Realizei duas implementações rápidas, uma utilizando recursão e outra sem recursão. Vale lembrar que falta ainda adicionar um tratamento para o caso do valor pesquisado não existir no vetor.

using System;
namespace ConsoleApp
{
    class Program
    {
        static void Main()
        {
            int[] vetor = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
            int chave = 80;
            Console.WriteLine(busca_binaria_sem_recursao(vetor, 0, vetor.Length, chave));
            Console.ReadKey(true);
        }
        public static int busca_binaria_com_recursao (int[] vetor, int inicio, int termino, int chave)
        {
            int meio = (inicio + termino) / 2;
            if (chave == vetor[meio])
                return meio;
            else
            {
                if (chave < vetor[meio])
                    return busca_binaria_com_recursao(vetor, inicio, meio - 1, chave);
                else
                    return busca_binaria_com_recursao(vetor, meio + 1, termino, chave);
            }
        }
        public static int busca_binaria_sem_recursao(int[] vetor, int inicio, int termino, int chave)
        {
            int meio = (inicio + termino) / 2;
            while (vetor[meio] != chave)
            {
                if (chave < vetor[meio])
                {
                    termino = meio - 1;
                    meio = (inicio + termino) / 2;
                }
                else
                {
                    inicio = meio + 1;
                    meio = (inicio + termino) / 2;
                }
            }
            return meio;
        }
    }
}

[]'s
Glauco Vinicius

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