Que dicas gerais você tem para jogar golfe em C ++? Estou procurando idéias que possam ser aplicadas para codificar problemas de golfe em geral que sejam pelo menos um pouco específicos para C ++ (por exemplo, "remover comentários" não é uma resposta). Poste uma dica por resposta.

O operador condicional ternário ?:muitas vezes pode ser usado como um carrinho na de simples if- elsedeclarações em uma economia considerável.

É de valor especial, pois pode ser usado para selecionar valores alternativos como em

#include <iostream>
#include <cstdlib>
int main(int c, char**v){
  int o=0,e=0,u;
  while(--c) ((u=atoi(v[c]))%2?o:e)+=u;
  std::cout << "Sum of odds " << o <<std::endl
            << "Sum of evens " << e <<std::endl;
}

Às vezes, você pode salvar dois caracteres usando o fato de que as variáveis ​​estáticas de duração do armazenamento (que incluem especialmente todas as variáveis ​​de escopo global) são automaticamente inicializadas com zero no início (ao contrário das variáveis ​​automáticas nas quais você não tem essa garantia). Então, ao invés de

int main()
{
  int a=0;
  // ...
}

você pode escrever

int a;
int main()
{
  // ...
}

Alguns compiladores (por exemplo, GCC) suportam constantes de vários caracteres . Isso pode salvar alguns caracteres quando um valor inteiro grande é necessário. Exemplo:

int n='  ';

O valor é específico da implementação. Normalmente, o valor de 'ab'é 256*'a'+'b'ou 'a'+256*'b'. Você pode especificar até 4 caracteres entre as aspas.

Um que eu achei útil:

Aproveitando o fato de que valores diferentes de zero são avaliados trueem expressões booleanas e que são x&&yavaliados x*yquando se lida com booleanos

(x!=0 && y!=0)

avalia como

(x*y)

Você só precisa estar ciente dos estouros, como indicado abaixo.

Use os seguintes tipos:

u64, s64, u32, s32 (or int)

Para palavras / tipos repetitivos, use #defines:

#define a while

Só vale a pena se você usar whilemuito para compensar os 10 caracteres extras. ( Cerca de 4. )

Se você estiver disposto a usar o C ++ 0x, poderá usar novos recursos, como lambdas .

Quando possível, altere &&e ||para &e |respectivamente.

Ao usar instruções if simples:

if(<condition>)<stuff>;

pode ser alterado para:

<condition>?<stuff>:<any single letter variable>;

que salva um personagem.

Em vez de usar while(1), use for(;;), salvando um caractere :)

O uso do operador de vírgula no lugar de chaves de abertura e fechamento pode salvar alguns caracteres, se você tiver uma situação em que suas cláusulas contenham mais de uma instrução:

if(c){x=1;cout<<"Hi";y=2;}else{x=2;cout<<"Bye";y=3;}

vs.

if(c)x=1,cout<<"Hi",y=2;else x=2,cout<<"Bye",y=3;###

Dois caracteres salvos em um IF simples ou três no total para um IF / ELSE.

Como ponto de distinção entre C e C ++, o resultado de uma expressão de vírgula no C ++ como um todo pode ser usado como um valor l ... FWIW.

Como os elementos da matriz são armazenados diretamente um após o outro na memória, em vez de algo como isto:

for(int x = 0; x < 25; x++) {
    for(int y = 0; y < 25; y++)
        array[x][y] = whatever;
}

Você pode fazer algo assim:

int* pointer = array;
for(int i = 0; i < 25*25; i++, pointer++)
    *pointer = whatever;

Obviamente, nenhuma das opções acima é jogada no golfe, para facilitar a leitura, mas o uso explícito de ponteiros pode economizar muito espaço.

Bastante óbvio, mas se você estiver usando grande parte da biblioteca padrão, using namespace std;poderá salvar alguns caracteres.

É útil lembrar que a[i]é o mesmo que *(a+i).

Substitua a[0]por *apara economizar dois caracteres. Além disso, a[i][0]é equivalente a *a[i]e a[0][i]diminui para i[*a]. Portanto, se você estiver codificando um 0índice em sua matriz, provavelmente existe uma maneira melhor.

Em vez de escrever grandes potências de 10, use a notação . Por exemplo, a=1000000000é maior que a=1e9. Isso pode ser estendido para outros números, como a=1e9+24é melhor que a=1000000024.

Você pode usar o operador ternário ?:sem nenhuma expressão no bloco verdadeiro (ele salva um byte)

#include <iostream>

int foo()
{
    std::cout << "Foo\n";
}

int main()
{
    1?foo():0;  // if (true) foo()
    0?:foo();   // if (!false) foo()
}

Veja aqui

Cabeçalho mais curto

Isso é específico do GCC, pode ser extensível a outros compiladores.

Cabeçalho pré-compilado.

No G ++, bits/stdc++.ho cabeçalho pré-compilado consiste em todos os outros cabeçalhos. Se você precisar de import2 diferentes, basta usar isso.

Cabeçalho mais curto.

Todos os cabeçalhos listados em http://en.cppreference.com/w/cpp/header :

$("#a").text(pako.inflate(atob('eJx9VkuW1DAM3HON2cOGx4o3V8lzK0q3wZ9gy90TTo+dDKCyM710yT9VqWS/2ECuzPzdhO3108vfUeCHGmUWNfJmVSMbsxo5m/VUEutZjaWsTo9NSkYfO/OvouNZDP1U4xqFOHkjNzVORmzU8YXDXcf5ym86lSIwvljBXOmWYtA7evYxbXCEi0aAAl930TM4JdiDSLYV0njQzSQNlA7Ikmy4KuDOJDFB6mGOHoVZHrPeNMsM7LhIBuWQ6C1pvW6Jjd5jKVKSXtII/qwlaIoA0EoAgHYPZy+A2GswDhCWH37tVpmkKShinZWtmzPzomkyyZoAika/GkiBRsUaU7jK5MxJULNexUGkdpaDAgvFcwKKq2Eqx1q4OCDLgOQBsdGbYIGxQV+KM9NdnmvRsgK99vIFZC95QPbSAmSvYEAeA0Jy7QxMNsdvX789RdoFbVh0Jce1+r6roHoYRXC/Fa4NAlxzN67vQXbk/xAfrn7UDEI73UjLXsUI7aXek1cru4dqIQ8Uh4H1Kl4HtRrseB8kpbEyDylg1sH84N1LjG6QY4bNqN604dpU/Ea8y4QJHLAm211jsnLzsJapDGvTaIsduBTdAt5TxTTOsCaDq+rg/Vq2WPwl0FBteQs02tY6zlsWBp++MzNUQDsaG2edNkky2JsOgae7xRe6brA3b9x2P3yqBoaiX2J6mDRP3WOdq2N4nvo3sYSYZm4RfBr/4/ghOF7IKXGOJRFD6lZszfM3p+FsimvdybhmIrQov621ZXoOYtwX/KVACG8BIbw4hPoPSwyzbepO+8txgfYJC/uvCgT7fwgGu08IBPsfEgSH3whEh7cZ6ek/LshQ/3RBdPhsQHR80yA8PtMQPmndqPhpO9Bpn7msI+bEsSfp96ZCYU7diOec+wpPOrckMvaBsz6Y9KS6//Xcp3f62LHdZu9NeFqjs7S9/gHXxXg4'), {to: 'string'}));

<script src="https://cdn.rawgit.com/nodeca/pako/master/dist/pako.min.js"></script>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<pre id="a">
  
</pre>

classificados em ordem crescente de comprimento.

Alguns deles já são mais longos bits/stdc++.he outros requerem suporte ao C ++ 17. Alguns outros não são suportados pelo TIO G ++ (por razões que não conheço). Filtre-os, temos:

$("#a").text(pako.inflate(atob('eJx9VcuS3CAMvOc39p5Tak+p/MoUI2SbhIcDYrz++4BdW6WG1B7VYI36IebNRfLV8s/Ix69vb59VYVFVMLuqXCqq8q7oqyQusKql7l7XJmdzqtry36rPixj6o+p2CucUjGyqzkZc0ucLx5c+55U/NJUqUD+dIFfacoq6Y+CQ8gk/4ZMRkCC0LvoG5ww9iOTcgcZBm8kaqANQJLu4KuDFJCkD9WhTQGOWw+qmRSyo4xMZtENScKT92jIb3WOpUrP+pAv8XVvQHQGgRwCAPod3T0DcGo0HhOV32IevTNYSVHHeyTncsbxoZHajqxDBY1MKZ0E/RocmAyiFlmUdnlgDZ5CvLUPTT5uSJmSZkDIhLgUTHagxeUfJMr3ka507K/DiiiYgV5wBuWIDyJVOQI4JIVmH5SRX0vuP9y+RPqCLi06pE25rDVl/GT++HG5W9rYVhrrTgNAlJBK+sofQFdBRlpbHEWrxm8SLk57NlgHq6RoUncyiOXO3yHDr1nTauGdKfhLaQjNqk3Zcrwt/EO/tUY1I4Ia12H5N2ckWkNUc7gt4VljSmxaO/D+sS+6bEzhLZ4YRrpH6yPCifHKbPOwN8cFq1x6SDb4b5SzC4dEWBqK4pHyYbB/DH19p68D2cf+//APa+54V'), {to: 'string'}));

<script src="https://cdn.rawgit.com/nodeca/pako/master/dist/pako.min.js"></script>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<pre id="a">
  
</pre>

Pode acontecer que alguns deles possam ser substituídos por outros mais curtos. Basta procurar binário se o que você precisa pode ser substituído. Em particular:

cstdio -> ios        (-3 bytes)
algorithm -> regex   (-4 bytes)
vector -> queue      (-1 byte)
string -> map        (-3 bytes)
bitset -> regex      (-1 byte)
numeric -> random    (-1 byte)

#importem vez de #includefornecer mais um byte.

Além disso, o caractere de espaço entre #importe cabeçalho não é necessariamente:

#include <map>
// vs
#import<map>

E se você precisar de algo do stdlibcabeçalho, poderá importar qualquer cabeçalho com o contêiner STL (preferível setou map) em vez de cstdlib.

Operações aritméticas em booleanos:

Apesar

a*=b>0?.5:-.5

é melhor que

if(b>0)a*=.5;else a*=-.5;

não é tão bom quanto

a*=(b>0)-.5

Além disso, usar #define em qualquer coisa usada muito. Geralmente é mais curto que o uso de funções, pois os nomes dos tipos não são necessários.

Combine as coisas o máximo possível:

a+=a--;

é o mesmo que

a=2*a-1;

Use lambdas genéricas como modelos baratos

Para tipos diferentes de int, usá-los como argumentos de função pode ser caro. No entanto, lambdas genéricas foram introduzidas (em C ++ 14?) E permitem que qualquer lambda seja um modelo - o uso autopara os tipos de argumento pode salvar bytes. Comparar:

double f(double x, double y)
[](auto x, auto y)

Lambdas genéricos também são muito convenientes para aceitar iteradores - provavelmente a melhor maneira de aceitar entradas de array em C ++ é [](auto a, auto z), onde ae zsão passados ​​como begin()e end()da matriz / vetor / lista / etc.

Na minha primeira tentativa de codificar golf para a tarefa "Subtrair os próximos números" , iniciei da função (58 bytes)

int f(int N, int P){int F;for(F=N;P;F-=++N,P--);return F;}

5 bytes seguros, mudando para lambda e movendo a inicialização para fora de for(53)

[](int N,int P){int F=N;for(;P;F-=++N,P--);return F;}

e, finalmente, depois de mudar forpara while, obtive 51 bytes:

[](int N,int P){int F=N;while(P--)F-=++N;return F;}

O código de teste ungolfed é algo como:

#include <iostream>
int main(void)
{
    int N, P;
    std::cin >> N >> P;
    auto f = [](int N,int P)
    {
        int F = N;
        while (P--)
            F -= ++N;
        return F;
    };
    std::cout << f(N, P) << std::endl;
    return 0;
}

ATUALIZAR:

Na verdade, forpode atingir o mesmo comprimento que while:

[](int N,int P){int F=N;for(;P--;F-=++N);return F;}

Meio atrasado para a festa, eu acho ...

Se você deseja transformar uma expressão em -1 e 1 em vez de 0 e 1, em vez disso:

int x;
if (a * 10 > 5)
    x = 1;
else
    x = -1;

fazem isto:

int x = (a * 10 > 5) * 2 - 1;

Pode salvar alguns bytes, dependendo do uso.

Se você deseja trocar duas variáveis ​​inteiras aeb, então,

a^=b^=a^=b;

pode ser usado, economizando 5 caracteres do que o modo padrão

a+=b;
b=a-b;
a-=b;

Use os recursos internos do GCC em vez de importar

Se você estiver usando um compilador GCC, às vezes é útil usar as funções internas, como __builtin_putsou __builtin_clz. Por exemplo,

44 bytes:

int main(){__builtin_puts("Hello, world!");}`

50 bytes:

#import<cstdio>
int main(){puts("Hello, world!");}

Se você estiver usando o C ++ 11 ou mais recente (o que deve ser sempre o caso agora), use autopara tipos complexos, se possível.

Exemplo: 54 bytes em vez de 66

#include<vector>
std::vector<int> f(std::vector<int> l){return l;}

#include<vector>
auto f(std::vector<int> l){return l;}

Além disso, como o desempenho não importa, para alguns desafios, um std::listpode apenas fazer o trabalho por alguns bytes a menos:

#include<list>
auto f(std::list<int> l){return l;}

As funções <algorithm>geralmente requerem uma passagem a.begin(),a.end()realmente longa; em vez disso, você pode &a[0],&*end(a)salvar 3 bytes se afor vectorou string.

sort(a.begin(),a.end());
sort(begin(a),end(a));
sort(&a[0],&*end(a));

Não use string(""), use "". Ele economiza 8 bytes.