¿Qué consejos generales tienes para jugar al golf en C ++? Estoy buscando ideas que puedan aplicarse a los problemas de golf de código en general que sean al menos algo específicos para C ++ (por ejemplo, "eliminar comentarios" no es una respuesta). Por favor, publique un consejo por respuesta.

El operador condicional ternario ?:menudo se puede utilizar como soporte en por sencilla if- elsedeclaraciones en un ahorro considerable.

Tiene un valor especial porque puede usarse para seleccionar valores alternativos como en

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

A veces puede guardar dos caracteres utilizando el hecho de que las variables de duración de almacenamiento estático (que incluye especialmente todas las variables de alcance global) se inicializan automáticamente al cero al principio (a diferencia de las variables automáticas donde no tiene dicha garantía). Entonces en lugar de

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

puedes escribir

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

Algunos compiladores (por ejemplo, GCC) admiten constantes de varios caracteres . Esto puede guardar algunos caracteres cuando se requiere un valor entero grande. Ejemplo:

int n='  ';

El valor es específico de la implementación. Por lo general, el valor de 'ab'es 256*'a'+'b'o 'a'+256*'b'. Puede especificar hasta 4 caracteres entre comillas.

Uno que me pareció útil:

Aprovechando el hecho de que los valores distintos de cero se evalúan trueen expresiones booleanas, y eso se x&&yevalúa x*ycuando se trata de valores booleanos

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

evalúa a

(x*y)

Solo debe tener en cuenta los desbordamientos, como se señala a continuación.

Use los siguientes tipos:

u64, s64, u32, s32 (or int)

Para palabras / tipos repetitivos, use #defines:

#define a while

Solo vale la pena si usa whilemucho para compensar los 10 caracteres adicionales. ( Alrededor de 4. )

Si está dispuesto a usar C ++ 0x, puede usar nuevas funciones como lambdas .

Cuando sea posible, cambie &&y ||a &y |respectivamente.

Cuando se usan declaraciones if simples:

if(<condition>)<stuff>;

se puede cambiar a:

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

que salva a un personaje

En lugar de usar while(1), usar for(;;), guardar un personaje :)

El uso del operador de coma en lugar de llaves abiertas y cerradas puede guardar algunos caracteres, si tiene una situación en la que sus cláusulas tienen más de una declaración:

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

Dos caracteres guardados en un IF simple, o tres en total para un IF / ELSE.

Como un punto de distinción entre C y C ++, el resultado de una expresión de coma en C ++ en su conjunto puede usarse como un valor l ... FWIW.

Dado que los elementos de la matriz se almacenan directamente uno tras otro en la memoria, en lugar de algo como esto:

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

Puedes hacer algo como esto:

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

Obviamente, ninguno de los anteriores es golf, para facilitar la lectura, pero el uso explícito de punteros puede ahorrarle mucho espacio.

Es bastante obvio, pero si está utilizando una gran cantidad de la biblioteca estándar, using namespace std;puede guardar algunos caracteres.

Es útil recordar que a[i]es lo mismo que *(a+i).

Reemplazar a[0]con *ados ahorro de caracteres. Además, a[i][0]es equivalente *a[i]y se a[0][i]reduce a i[*a]. Entonces, si está codificando un 0índice en su matriz, probablemente exista una mejor manera.

En lugar de escribir grandes potencias de 10, usa la notación e . Por ejemplo, a=1000000000es más largo que a=1e9. Esto se puede extender a otros números como a=1e9+24es mejor que a=1000000024.

Puede usar el operador ternario ?:sin ninguna expresión en el bloque verdadero (guarda un byte)

#include <iostream>

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

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

Compruébalo aquí

Encabezado más corto

Esto es específico de GCC, puede ser extensible a otros compiladores.

Encabezado precompilado.

En G ++, bits/stdc++.hel encabezado precompilado consiste en todos los demás encabezados. Si necesita import2 diferentes, simplemente puede usar esto.

Encabezado más corto.

Estos son todos los encabezados enumerados en 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>

ordenados en orden creciente de longitud.

Algunos de ellos ya son más largos bits/stdc++.hy otros requieren compatibilidad con C ++ 17. Algunos otros no son compatibles con TIO G ++ (por razones que no conozco). Filtrarlos tenemos:

$("#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>

Puede suceder que algunos de ellos puedan ser reemplazados por otros más cortos. Solo busque binariamente si puede reemplazar la que necesita. En 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)

#importen lugar de #includedarte un byte más.

Además, el carácter de espacio entre #importy el encabezado no es necesariamente:

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

Y si necesita algo del stdlibencabezado, puede importar cualquier encabezado con el contenedor STL (preferible seto map) en lugar de cstdlib.

Operaciones aritméticas en booleanos:

A pesar de que

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

es mejor que

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

no es tan bueno como

a*=(b>0)-.5

Además, usar #define en cualquier cosa que se use mucho. A menudo es más corto que usar funciones, ya que los nombres de tipo no son necesarios.

Combina las cosas tanto como sea posible:

a+=a--;

es lo mismo que

a=2*a-1;

Usa lambdas genéricas como plantillas baratas

Para otros tipos que no sean int, usarlos como argumentos de función puede ser costoso. Sin embargo, se introdujeron lambdas genéricas (en C ++ 14?) Y permiten que cualquier lambda sea una plantilla; el uso autode los tipos de argumento puede guardar bytes. Comparar:

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

Las lambdas genéricas también son muy convenientes para aceptar iteradores: probablemente la mejor manera de aceptar entradas de matriz en C ++ es [](auto a, auto z), dónde ay zse pasan como begin()y end()de la matriz / vector / lista / etc.

En mi primer intento de codificar golf para la tarea "Restar los siguientes números" , comencé desde la función (58 bytes)

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

luego a salvo 5 bytes con cambiar a lambda y mover la inicialización de for(53)

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

y finalmente después de cambiar de fora whileobtuve 51 bytes:

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

El código de prueba sin golf es algo así 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;
}

ACTUALIZAR:

En realidad forpuede alcanzar la misma longitud que while:

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

Un poco tarde para la fiesta, supongo ...

Si desea convertir una expresión en -1 y 1 en lugar de 0 y 1, en lugar de esto:

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

hacer esto:

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

Puede guardar algunos bytes dependiendo del uso.

Si desea intercambiar dos variables enteras a y b, entonces,

a^=b^=a^=b;

se puede usar, ahorrando 5 caracteres que la forma estándar

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

Utilice los componentes incorporados de GCC en lugar de importar

Si está utilizando un compilador GCC, a veces ayuda usar sus funciones integradas, como __builtin_putso __builtin_clz. Por ejemplo,

44 bytes:

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

50 bytes:

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

Si está haciendo C ++ 11 o más reciente (que siempre debería ser el caso ahora), utilícelo autopara tipos complejos, si es posible.

Ejemplo: 54 bytes en lugar de 66

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

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

Además, como el rendimiento no importa, para algunos desafíos, a std::listsolo puede hacer el trabajo por unos pocos bytes menos:

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

Las funciones a <algorithm>menudo requieren pasar, lo a.begin(),a.end()cual es realmente largo, en su lugar puede usar &a[0],&*end(a)para guardar 3 bytes si aes vectoro string.

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

No uses string(""), usa "". Ahorra 8 bytes.