Integración de Monte Carlo

Apelando al hecho de que una integral es la sumatoria de la infinidad de resultados de evaluar una función en un intervalo dado, se toman puntos de evaluación aleatorios dentro de ese intervalo dado, se evalúan y se van acumulando para luego realizarles un ajuste matemático, les diría que lo buscaran en Wikipedia, pero este documento me resultó especialmente revelador.

Para el caso de la implementación de POO lo que se consideró fue la creación de dos clases Random y Funcion, la primera para generar números aleatorios y la segunda para evaluar la función.

Aproximación a π

Para este caso se toma un cuarto de círculo de radio = 1, y se lanzan n dardos hacia él de esos n dardos supongamos que m aciertan en él entonces mediante matemágia, podemos encontrar que  π ≈ 4 * m / n

Para (mal) aplicar la POO, existe una clase que hace uso de Random, la clase definida en el ejericio anterior y de otra, llamada Aproximación en la cual se realiza la simulación de los dardos

Comprobación de primalidad (Algoritmo Monte Carlo)

Existe un test de primalidad, inventado por Fermat que nos dice que si tomamos la siguiente frómula a^(n-1) % n para cualquier número a ∈ [1,n-1] y si el resultado de eso es distinto de 1 entonces sabemos que n no es primo. Tomando una gran cantidad de números con valores aleatorios para a ∈ [1,n-1] podríamos asegurar con cierta probabilidad si un número n es primo. Si el test falla, es decir el resultado para cualquiera a es distinto de 1 podemos asegurar que n no es primo.

Resolución del problema de las N reinas (Algoritmo Las Vegas)

El ya conocidísimo problema delas N reinas también se puede resolver mediante probabilidad, es decir, tomamos la columna 1 y colocamos la primera reina, después para la segunda columna tratamos de colocar la siguiente reina en una posición elegida aleatoriamente, si se logró, continuamos con la siguiente columna, y así hasta colocar las N reinas o no poder colocar una, en ese caso falla.

Bastante simple.

• Se usa una lista para para ir almacenando las frecuencias de cada caracter
• Se usa un arreglo de árboles para generar el árbol único de códificación
• Se usa una cola para obtener el código asignado a cada símbolo

FUNC Fibonacci (↓n: NATURAL): NATURAL
   VARIABLES
       tabla: ARRAY [0..n] DE NATURALES
       i: NATURAL
   INICIO
       SI n = 0 ENTONCES
           DEVOLVER 0
       SINOSI n = 1 ENTONCES
           DEVOLVER 1
       SINO
           tabla[0] := 0
           tabla[1] := 1
           PARA i = 2 HASTA n HACER
               tabla[i] := tabla[i-1] + tabla[i-2]
           FINPARA
           DEVOLVER tabla[n]
       FINSI
   FIN

long long fibonacciArreglo(int n) {
    long long * lista;
    if(n == 0) return 0;
    if(n == 1) return 1;
    lista = (long long *) malloc(sizeof(long long) * n);
    lista[0] = 0;
    lista[1] = 1;
    int i;
    for (i = 2; i <= n; i++) {
        lista[i] = lista[i-1] + lista[i-2];
    }
    return lista[n];
}

long long fibonacciCola(int n) {
    Cola cola;
    if (n == 0) return 0;
    if (n == 1) return 1;
    creaLista(&cola);
    formar(&cola, 0);
    formar(&cola, 1);
    int i;
    for (i = 2; i <= n; i++) {
        // Quitamos el elemento menos reciente
        long long fi1 = atender(&cola);
        // Obtenemos el valor del siguiente más reciente
        long long fi2 = valorPrincipio(&cola);
        // Almacenamos el resultado en la cola
        formar(&cola, fi1 + fi2);
    }
    return valorFinal(&cola);
}

Práctica 1: "Pruebas a posteriori (Algoritmos de ordenamiento)"

• Burbuja (Bubble Sort)
• Burbuja Simple
• Burbuja Mejorada
• Inserción (Insertion Sort)
• Selección (Selection Sort )
• Shell (Shell Sort)
• Ordenamiento con árbol binario de busqueda (Binary Search Tree)

Práctica 2: "Análisis temporal y notación de orden (Algoritmos de busqúeda)"

• Búsqueda lineal o secuencial (No recursiva)
• Búsqueda binaria o dicotómica (No recursiva)
• Búsqueda en un árbol binario de búsqueda (No recursiva)
• Modificar los tres algoritmos para trabajar con procesos ligeros (Hilos).

Práctica 3: "Divide y vencerás (Rotación de una imagen)"

char* reverse(const char* str)

using System;
using System.Linq;
using System.Text;

namespace ReverseStringsMsft
{
    class Program
    {
        static void Main(string[] args)
        {
            string s = "this  is  a string";
            string res = Reverse(s);
            string resWord = ReverseWords(s);
            Console.WriteLine(s);
            Console.WriteLine(res);
            Console.WriteLine(resWord);
            Console.Read();
        }

        /// <summary>
        /// Invierte una cadena
        /// </summary>
        /// <param name="str">La cadena que será invertida</param>
        /// <returns>Una nueva instancia de String</returns>
        public static string Reverse(string str)
        {
            if (str == null)
                return null;
   // Convertir a un arreglo
            char[] cr = str.ToArray();
   // Llamamos a la funcion para toda la cadena
            Reverse(cr, 0, cr.Length - 1);
            return new string(cr);
        }

        /// <summary>
        /// Invierte las subcadenas (separadas por espacios) contenidas dentro de una cadena
        /// </summary>
        /// <param name="str">La cadena que será invertida</param>
        /// <returns>Una nueva instancia de String</returns>
        public static string ReverseWords(string str)
        {
            if (str == null)
                return null;
   // Convertir a un arreglo
            char[] cr = str.ToArray();
            int wordStart = 0;
            int end;
   // Recorremos la cadena para encontrar espacios
            for (int i = 0; i < cr.Length; i++)
            {
                char c = cr[i];
    // Por cada espacio o cada vez que lleguemos al final de la cadena
    // llamaremos a la funcion especialmente para la ubicacion de 
    // la palabra encontrada
                if (c == ' ' || i == cr.Length - 1)
                {
                    end = i - 1;
                    Reverse(cr, wordStart, end);
                    wordStart = i + 1;
                }
            }
            return new string(cr);
        }

        /// <summary>
        /// Cambia de posición los caracteres desde <paramref name="start"/> a
  /// <paramref name="end"/> hasta que todos estén invertidos
        /// </summary>
        /// <param name="str">El arreglo a ser invertido</param>
        /// <param name="start">Inicio</param>
        /// <param name="end">Final</param>
        private static void Reverse(char[] str, int start, int end)
        {
            for (; start < end; start++, end--)
            {
    // Cambiamos uno a uno los caracteres desde la posicion
    // inicial hasta la final, y aumentamos las variables para irlos 
    // intercambiando como deseamos
                char aux = str[start];
                str[start] = str[end];
                str[end] = aux;
            }
        }

    }
}

Idea

El dispositivo a medir

Para finalizar

Reporte

SELECT DISTINCT O1.Or1
 ,O2.Or2
FROM (
 SELECT OD1.OrderID Or1
  ,OD2.OrderId Or2
  ,OD1.ProductID
  ,OD2.ProductID P1
 FROM [Order Details] OD1
 INNER JOIN [Order Details] OD2
  ON OD1.ProductID = OD2.ProductID
   AND OD1.OrderID <> OD2.OrderID
 WHERE OD1.OrderID IN (
   SELECT OD.OrderID
   FROM [Order Details] OD
   GROUP BY OD.OrderID
   HAVING COUNT(OD.ProductID) >= 2
   )
  AND OD2.OrderID IN (
   SELECT OD.OrderID
   FROM [Order Details] OD
   GROUP BY OD.OrderID
   HAVING COUNT(OD.ProductID) >= 2
   )
 ) O1
INNER JOIN (
 SELECT OD1.OrderID Or1
  ,OD2.OrderId Or2
  ,OD1.ProductID
  ,OD2.ProductID P2
 FROM [Order Details] OD1
 INNER JOIN [Order Details] OD2
  ON OD1.ProductID = OD2.ProductID
   AND OD1.OrderID <> OD2.OrderID
 WHERE OD1.OrderID IN (
   SELECT OD.OrderID
   FROM [Order Details] OD
   GROUP BY OD.OrderID
   HAVING COUNT(OD.ProductID) >= 2
   )
  AND OD2.OrderID IN (
   SELECT OD.OrderID
   FROM [Order Details] OD
   GROUP BY OD.OrderID
   HAVING COUNT(OD.ProductID) >= 2
   )
 ) O2
 ON O1.Or1 = O2.Or1
  AND O1.Or2 = O2.Or2
  AND O1.P1 <> O2.P2

• DESTINATARIOS: Una columna que contiene los correos a los cuales será enviado el mensaje. Los correos deberán ir separados por un ;.
• ASUNTO: Contiene el asunto con el que será enviado el correo.
• MENSAJE: El mensaje que contendrá el correo, puede ser HTML (recomiendo sea básico).

<configuration>
  <appSettings>

    <add key="mailHost" value="smtp.gmail.com"/>
    <add key="mailUser" value="ejemplo@gmail.com"/>
    <add key="port" value="587"/>
    <add key="ssl" value="true"/>
    <add key="user" value="ejemplo@gmail.com"/>
    <add key="password" value="random*Pass"/>

  </appSettings>
  <connectionStrings>
    <add name="CON" connectionString="Data Source=localhost\SQL;Initial Catalog=DB;User ID=US;Password=PSWD" 
        providerName="System.Data.SqlClient"/>
  </connectionStrings>
</configuration>