Escribir código C/C++ de manera eficiente en programación competitiva

En primer lugar, debe saber acerca de la plantilla , las macros y los vectores antes de pasar a la siguiente fase. 

• Las plantillas son la base de la programación genérica, que implica escribir código de forma independiente de cualquier tipo en particular.
• Una macro es un fragmento de código al que se le ha dado un nombre. Cada vez que se usa el nombre, se reemplaza por el contenido de la macro.
• Los vectores son lo mismo que las arrays dinámicas con la capacidad de cambiar su tamaño automáticamente cuando se inserta o elimina un elemento, y el contenedor maneja automáticamente su almacenamiento.

Entonces podemos usar estas poderosas herramientas para escribir nuestro código de manera efectiva.
Algunos de los trucos geniales que pueden usarse en la programación Competitiva son los siguientes: 

• Uso de bucle basado en rango : esta es una característica muy interesante en C++ 11 y se consideraría mejor si desea iterar de principio a fin. Este código muestra cómo usar los bucles for a distancia para iterar a través de una array y un vector: 

// C++ program to demonstrate range based for
// loops for accessing vector and array elements
#include<iostream>
#include <vector>
using namespace std;
  
int main()
{
    // Create a vector object that
    // contains 5 elements
    vector<int> vec = {0, 1, 2, 3, 4};
  
    // Type inference by reference using auto.
    // Range based loops are preferred when no
    // modification is needed in value
    for (const auto &value : vec)
        cout << value << ' ';
  
    cout << '\n';
  
    // Basic 5 element integer array
    int array[]= {1, 2, 3, 4, 5};
    for (const auto &value: array)
        cout << value << " ";
  
    return 0;
}

Producción:

0 1 2 3 4
1 2 3 4 5

• Lista de inicializadores: este tipo se utiliza para acceder a los valores en una lista de inicialización de C++. Aquí, el compilador construye automáticamente los objetos de este tipo a partir de las declaraciones de la lista de inicialización, que es una lista de elementos separados por comas encerrados entre llaves. 

#include<iostream>
  
template<typename T>
void printList(std::initializer_list<T> text)
{
    for (const auto & value: text)
        std::cout << value << " ";
}
  
// Driver program
int main()
{
    // Initialization list
    printList( {"One", "Two", "Three"} );
    return 0;
}

Producción: 

One Two Three

• Asignación de valor máximo o mínimo: este es útil para evitar un esfuerzo adicional al escribir la función max() o min(). 

#include<iostream>
  
// Call by reference is used in x
template<typename T, typename U>
static inline void amin(T &x, U y)
{
    if (y < x)
        x = y;
}
  
// call by reference is used in x
template<typename T, typename U>
static inline void amax(T &x, U y)
{
    if (x < y)
        x = y;
}
  
// Driver program to find the Maximum and Minimum value
int main()
{
    int max_val = 0, min_val = 1e5;
    int array[]= {4, -5, 6, -9, 2, 11};
  
    for (auto const &val: array)
  
        // Same as max_val = max (max_val, val)
        // Same as min_val = min (min_val,val)
        amax(max_val, val), amin (min_val, val);
  
  
    std::cout << "Max value = " << max_val << "\n"
              << "Min value = " << min_val;
    return 0;
}

Producción:

Max value = 11
Min value = -9

• Entrada/salida rápida en C/C++: en la programación competitiva, debe leer la entrada/salida lo más rápido posible para ahorrar un tiempo valioso. 

#include <bits/stdc++.h>
  
template<typename T> void scan(T &x)
{
    x = 0;
    bool neg = 0;
    register T c = getchar();
  
    if (c == '-')
        neg = 1, c = getchar();
  
    while ((c < 48) || (c > 57))
        c = getchar();
  
    for ( ; c < 48||c > 57 ; c = getchar());
  
    for ( ; c > 47 && c < 58; c = getchar() )
        x= (x << 3) + ( x << 1 ) + ( c & 15 );
  
    if (neg) x *= -1;
}
  
template<typename T> void print(T n)
{
    bool neg = 0;
  
    if (n < 0)
        n *= -1, neg = 1;
  
    char snum[65];
    int i = 0;
    do
    {
        snum[i++] = n % 10 + '0';
        n /= 10;
    }
  
    while (n);
    --i;
  
    if (neg)
        putchar('-');
  
    while (i >= 0)
        putchar(snum[i--]);
  
    putchar('\n');
}
  
// Driver Program
int main()
{
    int value;
  
    // Taking input
    scan(value);
  
    // Printing output
    print(value);
    return 0;
}

Input:  756
Output: 756

Para obtener más información sobre la entrada y salida rápidas, lea este artículo . 

• Uso de macros como bucle for : tal vez, no sería bueno usar este tipo de macros, ya que reduciría la legibilidad del código, pero para escribir código rápido, ¡puede correr ese riesgo! 

#include <bits/stdc++.h>
using namespace std;
  
#define rep(i,n) for (i = 0; i < n; ++i)
#define REP(i,k,n) for (i = k; i <= n; ++i)
#define REPR(i,k,n) for (i = k; i >= n; --i)
  
  
// Driver program to test above Macros
int main()
{
    int i;
    int array[] = {4, 5, 6, 9, 22, 11};
    int size= sizeof(array)/sizeof(array[0]);
      
    // Default 0 index based loop
    rep(i, size)     
        cout << array[i] << " ";
    cout<<"\n";
      
    // Starting index based loop
    REP(i, 1, size-1)     
        cout << array[i] << " ";
    cout<<"\n";
      
    // Reverse for loop
    REPR(i, size-1,0)     
        cout << array[i] << " ";
    return 0;
}

Producción 

4 5 6 9 22 11
5 6 9 22 11
11 22 9 6 5 4

• Usando «bits/stdc++.h»: en lugar de agregar toneladas de líneas #include, solo use #include<bits/stdc++.h> Los archivos incluyen todos los archivos de encabezado que necesitará en la programación competitiva, ahorrando mucho tiempo .
• Contenedores: el uso de varios contenedores como vector, lista, mapa, etc. permite usar las funciones predefinidas y reduce considerablemente el tamaño del código (la mayoría de las veces)
• Fast cin y cout: si usa cin y cout para E/S, simplemente agregue la siguiente línea justo después de main(). 

std::ios_base::sync_with_stdio(false);

• auto: Usar auto para declarar tipos de datos puede ahorrar mucho tiempo durante los concursos de programación. Cuando una variable se define como automática, el compilador determina su tipo durante el tiempo de compilación.
• Bibliotecas y funciones predefinidas: Uso de funciones integradas como __gcd(A,B), swap, _builtin_popcount(R), _builtin_clz(R), etc. donde sea que se pueda aplicar. Trate de aprender las diferentes funciones disponibles en la biblioteca de algoritmos de C++. Son útiles la mayoría de las veces en los programas

En última instancia, al usar estos trucos inteligentes, puede escribir código fácilmente en una cantidad mínima de tiempo y palabras.
Este artículo es una contribución de Shubham Bansal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.