El blog de Wewewew

• $B1$ := Sumatoria de todos los $b = a_x - a_y$ tal que $x > y$ y $b > 0$
• $B2$ := Sumatoria de todos los $b = a_x - a_y$ tal que $x > y$ y $b < 0$

• Para el paso 4 tenemos: $B1 = (3 -0) + (3 - 1) + (3 - 2) = 6$ y $B2 = 0$ lo cual nos da el valor de $6$
• Para el paso 8 tenemos: $B1 = (3 - 0) + (3 - 1)+  (3 - 2) + (3 - 1) + (3 - 2) = 9$ y $B2 = (3 - 5) = - 2$, por lo tanto tenemos $B1 - B2 = 11$

void precalc(){
 int t = 0;
 for(int step = 0; step < n; step++){
  int ans = 0;
  for(int i = step-1; i >= 0; i--){
   t = (s[step] - '0') - (s[i] - '0');
   if(t == 0){
    ans += A[i];
    A[step] = ans;
    break;
   }
   ans += abs(t);
   A[step] = ans;
  }
 }
}

int main(){
 scanf("%d%d",&n,&m);
 scanf("%s",s);
 precalc();
 while(m--){
  scanf("%d",&q);
  printf("%d\n",A[q-1]);
 }
 return 0;
}

La función scanf

10 3161565164181
aab baa aba

int a;
long long int b;
char cadena[15];
scanf("%d %lld", &a, &b); 
scanf("%s", cadena); // 'cadena' es ya una referencia a memoria

La función fgets

// ...
LLLLLLLLL
3 2
// ...

int i, j;
char entrada[10];
fgets(entrada,10,stdin);
// Procesamos 'entrada', que contiene la siguiente secuencia de caracteres: 
// 'L','W','W','W', 'L', 'L', 'L', 'L', 'W' y '\n' <= ¡Sí! el salto de línea
// Recuperamos los enteros:
fgets(entrada,10,stdin);
sscanf(entrada,"%d %d",&i,&j);

• 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

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;
            }
        }

    }
}

• 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>

1.- Sección de declaraciones

Lugar para incluir cabeceras, macros, variables globales... también es posible definir patrones a usar en la sección de reglas

%%

2.- Sección de reglas

Aquí es donde se asocian los patrones(expresiones regulares) a buscar con sentencias(código) de C. Cada vez que el analizador encuentra un a cadena que coincide con el patrón, se ejecuta el código en C

%%

3.- Sección de código en C

Contiene sentencias en C y funciones que serán copiadas íntegramente en el archivo que Felx genere, comúnmente se colocan aquí las funciones que se llamarán en la sección de reglas.