Quels conseils généraux avez-vous pour jouer au golf en C ++? Je recherche des idées pouvant être appliquées aux problèmes de code de golf en général, qui sont au moins quelque peu spécifiques au C ++ (par exemple, "supprimer les commentaires" n'est pas une réponse). Merci de poster un pourboire par réponse.

L'opérateur conditionnel ternaire ?:peut souvent être utilisé comme support dans des simples if- elsedéclarations à des économies considérables.

Il a une valeur particulière en ce qu’il peut être utilisé pour sélectionner des valeurs alternatives comme dans

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

Parfois, vous pouvez enregistrer deux caractères en utilisant le fait que les variables de durée de stockage statique (qui incluent notamment toutes les variables de portée globales) sont automatiquement initialisées à zéro au début (contrairement aux variables automatiques pour lesquelles vous n'avez aucune garantie de ce type). Donc au lieu de

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

tu peux écrire

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

Certains compilateurs (par exemple, GCC) prennent en charge les constantes à plusieurs caractères . Cela peut économiser quelques caractères lorsqu'une valeur entière importante est requise. Exemple:

int n='  ';

La valeur est spécifique à l'implémentation. Habituellement, la valeur de 'ab'est 256*'a'+'b'ou 'a'+256*'b'. Vous pouvez spécifier jusqu'à 4 caractères entre les guillemets.

Celui que j'ai trouvé pratique:

Profitant du fait que les valeurs non nulles sont évaluées à truedes expressions booléennes, et qui x&&yévalue à x*yquand traiter booléens

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

évalue à

(x*y)

Vous devez juste être conscient des débordements, comme indiqué ci-dessous.

Utilisez les types suivants:

u64, s64, u32, s32 (or int)

Pour les mots / types répétitifs, utilisez #defines:

#define a while

Cela ne vaut que si vous utilisez whilebeaucoup pour compenser les 10 caractères supplémentaires. ( Environ 4. )

Si vous souhaitez utiliser C ++ 0x, vous pouvez utiliser de nouvelles fonctionnalités telles que lambdas .

Si possible, changez &&et ||à &et |respectivement.

Lorsque vous utilisez des instructions if simples:

if(<condition>)<stuff>;

peut être changé en:

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

ce qui sauve un personnage.

Au lieu d'utiliser while(1), utilisez for(;;), en sauvegardant un caractère :)

L'utilisation de l'opérateur virgule au lieu d'accolades ouvrantes et fermantes peut enregistrer quelques caractères, si vous avez une situation dans laquelle vos clauses contiennent plusieurs instructions:

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

contre.

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

Deux caractères enregistrés sur un IF simple ou trois au total pour un IF / ELSE.

En tant que point de distinction entre C et C ++, le résultat d'une expression de virgule en C ++ dans son ensemble peut être utilisé sous la forme d'une valeur lvalue ... FWIW.

Puisque les éléments de tableau sont stockés directement les uns après les autres en mémoire, au lieu de quelque chose comme ceci:

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

Vous pouvez faire quelque chose comme ça:

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

Évidemment, ni l’un ni l’autre des éléments ci-dessus n’est golfé, par souci de lisibilité, mais l’utilisation explicite de pointeurs peut vous faire économiser beaucoup d’espace.

C’est une évidence, mais si vous utilisez beaucoup de la bibliothèque standard, vous using namespace std;pourriez économiser quelques caractères.

Il est utile de se rappeler que a[i]c'est la même chose que *(a+i).

Remplacez a[0]par *apour deux économies de caractères. En outre, a[i][0]est équivalent à *a[i]et a[0][i]réduit à i[*a]. Donc, si vous codez en dur un 0index dans votre tableau, il existe probablement une meilleure solution.

Au lieu d'écrire de grandes puissances de 10, utilisez la notation e . Par exemple, a=1000000000est plus long que a=1e9. Cela peut être étendu à d'autres numéros, comme a=1e9+24c'est mieux que a=1000000024.

Vous pouvez utiliser l'opérateur ternaire ?:sans aucune expression dans le bloc true (il enregistre un octet)

#include <iostream>

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

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

Vérifiez ici

Tête plus courte

Ceci est spécifique à GCC, il peut être extensible à d’autres compilateurs.

En-tête précompilé.

En G ++, bits/stdc++.hl'en-tête précompilé est constitué de tous les autres en-têtes. Si vous avez besoin de import2 types différents, vous pouvez simplement l'utiliser.

En-tête plus court.

Ce sont tous les en-têtes répertoriés sur http://fr.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>

triés par ordre croissant de longueur.

Certains d'entre eux sont déjà plus longs que bits/stdc++.h, et certains nécessitent le support de C ++ 17. Certains autres ne sont pas pris en charge par TIO G ++ (pour des raisons que je ne connais pas). Filtrez-les nous avons:

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

Il se peut que certaines d’entre elles puissent être remplacées par des plus courtes. Juste recherche binaire si celle dont vous avez besoin peut être remplacée. En particulier:

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

#importau lieu de #includevous donne un octet supplémentaire.

De plus, le caractère espace entre #importet en-tête n'est pas nécessairement:

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

Et si vous avez besoin de quelque chose à partir de stdlibheader, vous pouvez importer n'importe quel en-tête avec un conteneur STL (préférable setou map) au lieu de cstdlib.

Opérations arithmétiques sur les booléens:

Bien que

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

est mieux que

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

ce n'est pas aussi bon que

a*=(b>0)-.5

En outre, en utilisant #define sur tout ce qui est beaucoup utilisé. Il est souvent plus court que d'utiliser des fonctions, car les noms de type ne sont pas nécessaires.

Combinez les choses autant que possible:

a+=a--;

est le même que

a=2*a-1;

Utilisez des lambdas génériques comme modèles bon marché

Pour les types autres que int, les utiliser comme arguments de fonction peut être coûteux. Cependant, des lambdas génériques ont été introduits (en C ++ 14?) Et permettent à tout lambda d'être un modèle - utiliser autodes types d'argument pour économiser des octets. Comparer:

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

Les lambdas génériques sont également très pratiques pour accepter des itérateurs. Le meilleur moyen d’accepter les entrées de tableau en C ++ est probablement le suivant [](auto a, auto z): où aet zsont passés comme begin()et end()du tableau / vecteur / liste / etc.

Dans ma première tentative de code de golf pour la tâche "Soustraire les nombres suivants" je suis parti de la fonction (58 octets)

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

puis sécurisez 5 octets avec passage à lambda et initialisation déplacée hors de for(53)

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

et finalement, après avoir basculé de forà, whilej'ai obtenu 51 octets:

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

Le code de test ungolfed est quelque chose comme:

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

MISE À JOUR:

En fait , forpeut atteindre la même longueur que while:

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

Un peu tard pour la fête je suppose ...

Si vous voulez transformer une expression en -1 et 1 au lieu de 0 et 1, au lieu de ceci:

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

faire ceci:

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

Cela peut économiser des octets en fonction de l'utilisation.

Si vous voulez échanger deux variables entières a et b alors,

a^=b^=a^=b;

peut être utilisé en économisant 5 caractères par rapport à la méthode standard

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

Utiliser les fonctions intégrées de GCC au lieu d'importer

Si vous utilisez un compilateur GCC, il est parfois utile d’utiliser leurs fonctions internes, telles que __builtin_putsou __builtin_clz. Par exemple,

44 octets:

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

50 octets:

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

Si vous utilisez C ++ 11 ou plus récent (ce qui devrait toujours être le cas maintenant), utilisez-le autopour les types complexes, si possible.

Exemple: 54 octets au lieu de 66

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

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

En outre, comme les performances importent peu, il est possible que, pour certains problèmes, std::listil ne vous reste plus qu'à faire le travail pour quelques octets en moins:

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

Les fonctions dans <algorithm>souvent requièrent des passes a.begin(),a.end()vraiment longues, mais vous pouvez utiliser &a[0],&*end(a)pour économiser 3 octets si aest vectorou string.

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

Ne pas utiliser string(""), utilisez "". Il sauve 8 octets.