ESCREVENDO CÓDIGO C/C++ COM EFICIÊNCIA EM PROGRAMAÇÃO COMPETITIVA

Primeiro de tudo você precisa saber sobre Modelo Macros e Vetores antes de passar para a próxima fase!

Os modelos são a base da programação genérica que envolve escrever código de uma forma independente de qualquer tipo específico.
Uma macro é um fragmento de código ao qual foi dado um nome. Sempre que o nome é usado ele é substituído pelo conteúdo da macro.
Os vetores são iguais aos arrays dinâmicos, com a capacidade de se redimensionar automaticamente quando um elemento é inserido ou excluído, com seu armazenamento sendo tratado automaticamente pelo contêiner.

Portanto, podemos usar essas ferramentas poderosas para escrever nosso código de maneira eficaz.
Alguns dos truques interessantes que podem ser usados na programação competitiva são apresentados a seguir:

Usando intervalo baseado em loop : Este é um recurso muito interessante em C++ 11 e seria considerado o melhor se você quiser iterar do início ao fim. Este código mostra como usar loops for variados para iterar por meio de um array e um vetor: CPP

    // C++ program to demonstrate range based for   // loops for accessing vector and array elements   #include       #include         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  ;   }

Saída:

0 1 2 3 4 1 2 3 4 5

Lista de inicializadores: Este tipo é usado para acessar os valores em uma lista de inicialização C++. Aqui, os objetos deste tipo são construídos automaticamente pelo compilador a partir de declarações de lista de inicialização, que é uma lista de elementos separados por vírgula entre colchetes. CPP

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

Saída:

One Two Three

Atribuindo valor máximo ou mínimo: Este é útil para evitar esforço extra ao escrever a função max() ou min(). CPP

    #include       // 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_valval)      amax  (  max_val       val  )     amin     (  min_val       val  );      std  ::  cout      < <     'Max value = '      < <     max_val      < <     '  n  '       < <     'Min value = '      < <     min_val  ;      return     0  ;   }

Saída:

Max value = 11 Min value = -9

Entrada/saída rápida em C/C++: Na programação competitiva você deve ler a entrada/saída o mais rápido possível para economizar um tempo valioso. C

    #include          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 saber mais sobre entrada e saída rápida Leia este artigo .

Usando macros como loop for : Talvez não fosse bom usar tais macros, pois reduziriam a legibilidade do código, mas para escrever código rápido você pode correr esse risco! CPP

    #include          using     namespace     std  ;   #define rep(in) for (i = 0; i  < n; ++i)   #define REP(ikn) for (i = k; i  <= n; ++i)   #define REPR(ikn) 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  ;   }

Saída

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

Os arquivos incluem todos os arquivos de cabeçalho necessários na programação competitiva, economizando muito do seu tempo. Recipientes: O uso de vários contêineres, como mapa de lista de vetores, etc., permite usar funções predefinidas e reduz consideravelmente o tamanho do código (na maioria das vezes) Cin e cout rápidos: Se você usar cin e cout para E/S, basta adicionar a seguinte linha logo após main().

std::ios_base::sync_with_stdio(false);

auto: Usar auto para declarar tipos de dados pode economizar muito tempo durante concursos de programação. Quando uma variável é definida como compilador automático determina seu tipo durante o tempo de compilação. Bibliotecas e funções predefinidas: Usando funções integradas, como __gcd(AB) swap _builtin_popcount(R) _builtin_clz(R) etc, onde quer que isso possa ser aplicado. Tente aprender as diferentes funções disponíveis em algoritmo biblioteca de C++. Eles são úteis na maioria das vezes em programas

Em última análise, usando esses truques inteligentes, você pode escrever código facilmente em um mínimo de tempo e palavras.

Criar questionário