Quali consigli generali hai per giocare a golf in C ++? Sto cercando idee che possano essere applicate ai problemi del codice golf in generale che siano almeno in qualche modo specifiche per il C ++ (ad esempio "rimuovere i commenti" non è una risposta). Si prega di inviare un suggerimento per risposta.

L'operatore condizionale ternario ?:spesso può essere utilizzato come uno stand in per semplice if- elsele dichiarazioni a notevoli risparmi.

Ha un valore speciale in quanto può essere utilizzato per selezionare valori alternativi come in

#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 volte è possibile salvare due caratteri utilizzando il fatto che le variabili di durata dell'archiviazione statica (che include in particolare tutte le variabili dell'ambito globale) vengono automaticamente inizializzate a zero all'inizio (diversamente dalle variabili automatiche in cui non si dispone di tale garanzia). Quindi invece di

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

tu puoi scrivere

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

Alcuni compilatori (ad es. GCC) supportano costanti multi-carattere . Questo può salvare alcuni caratteri quando è richiesto un valore intero grande. Esempio:

int n='  ';

Il valore è specifico dell'implementazione. Di solito il valore di 'ab'è 256*'a'+'b'o 'a'+256*'b'. È possibile specificare fino a 4 caratteri tra virgolette.

Uno che ho trovato utile:

Sfruttare il fatto che valori diversi da zero vengono valutati truein espressioni booleane e che x&&yvaluta x*yquando si tratta di valori booleani

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

valuta

(x*y)

Devi solo essere consapevole degli overflow, come indicato di seguito.

Usa i seguenti tipi:

u64, s64, u32, s32 (or int)

Per parole / tipi ripetitivi, utilizzare #defines:

#define a while

Ne vale la pena solo se usi whilemolto per compensare i 10 personaggi extra. ( Circa 4. )

Se vuoi usare C ++ 0x, puoi usare nuove funzionalità come lambdas .

Quando possibile, cambiare &&e ||per &e |rispettivamente.

Quando si usano istruzioni if ​​semplici:

if(<condition>)<stuff>;

può essere modificato in:

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

che salva un personaggio.

Invece di usare while(1), usare for(;;), salvare un carattere :)

L'uso dell'operatore virgola al posto delle parentesi graffe aperte e chiuse può salvare alcuni caratteri, se hai una situazione in cui le tue clausole contengono più di un'istruzione:

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

Due personaggi salvati su un semplice IF, o tre in totale per un IF / ELSE.

Come punto di distinzione tra C e C ++, il risultato di un'espressione virgola in C ++ nel suo insieme può essere usato come un valore in valore ... FWIW.

Poiché gli elementi dell'array vengono memorizzati uno dopo l'altro in memoria, anziché qualcosa del genere:

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

Puoi fare qualcosa del genere:

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

Ovviamente nessuna delle precedenti è giocata a golf, per leggibilità, ma l'uso esplicito di puntatori può farti risparmiare molto spazio.

Abbastanza ovvio, ma se stai usando molto della libreria standard, using namespace std;potresti salvare alcuni caratteri.

È utile ricordare che a[i]è lo stesso di *(a+i).

Sostituisci a[0]con *aper un risparmio di due caratteri. Inoltre, a[i][0]equivale a *a[i]e a[0][i]si riduce ai[*a] . Quindi, se stai codificando un 0indice nel tuo array, probabilmente esiste un modo migliore.

Invece di scrivere grandi poteri di 10, usa la notazione . Ad esempio, a=1000000000è più lungo di a=1e9. Questo può essere esteso ad altri numeri come a=1e9+24è meglio di a=1000000024.

È possibile utilizzare l'operatore ternario ?:senza alcuna espressione nel blocco reale (salva un byte)

#include <iostream>

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

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

Controlla qui

Intestazione più corta

Questo è specifico di GCC, potrebbe essere estendibile ad altri compilatori.

Intestazione precompilata.

In G ++ bits/stdc++.hè l'intestazione precompilata composta da tutte le altre intestazioni. Se hai bisogno di import2 diversi puoi semplicemente usare questo.

Intestazione più corta.

Queste sono tutte le intestazioni elencate su 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>

ordinati in ordine crescente di lunghezza.

Alcuni di essi sono già più lunghi di bits/stdc++.he alcuni richiedono il supporto C ++ 17. Alcuni altri non sono supportati da TIO G ++ (per motivi che non conosco). Filtrali li abbiamo:

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

Può succedere che alcuni di essi possano essere sostituiti da altri più corti. Basta cercare binariamente se quello che ti serve può essere sostituito. In particolare:

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

#importinvece di #includedarti un altro byte.

Inoltre, il carattere spazio tra #importe intestazione non è necessariamente:

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

E se hai bisogno di qualcosa dall'intestazione stdlib, puoi importare qualsiasi intestazione con contenitore STL (preferibile seto map) invece di cstdlib.

Operazioni aritmetiche sui booleani:

Sebbene

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

è meglio di

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

non è buono come

a*=(b>0)-.5

Inoltre, usando #define su tutto ciò che viene usato molto. Spesso è più breve dell'uso delle funzioni, poiché i nomi dei tipi non sono necessari.

Combina le cose il più possibile:

a+=a--;

equivale a

a=2*a-1;

Usa lambda generici come modelli economici

Per tipi diversi da int, usarli come argomenti di funzione può essere costoso. Tuttavia, sono stati introdotti lambda generici (in C ++ 14?) E consentono a qualsiasi lambda di essere un modello - l'utilizzo autoper i tipi di argomento può salvare byte. Confrontare:

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

I lambda generici sono anche molto comodi per accettare gli iteratori - probabilmente il modo migliore per accettare input di array in C ++ è [](auto a, auto z), dove ae zsono passati come begin()e end()dell'array / vector / list / etc.

Nel mio primo tentativo di code golf per l' attività "Sottrai i numeri successivi" ho iniziato dalla funzione (58 byte)

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

quindi salva 5 byte con lo spostamento su lambda e spostando l'inizializzazione su for(53)

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

e finalmente dopo il passaggio da fora whileho ottenuto 51 byte:

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

Il codice di prova non salvato è simile a:

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

AGGIORNARE:

In realtà forpuò raggiungere la stessa lunghezza di while:

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

Un po 'tardi alla festa, immagino ...

Se vuoi trasformare un'espressione in -1 e 1 invece di 0 e 1, invece di questo:

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

Fai questo:

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

Può salvare alcuni byte a seconda dell'utilizzo.

Se si desidera scambiare due variabili intere aeb, quindi

a^=b^=a^=b;

può essere utilizzato, salvando 5 caratteri rispetto al modo standard

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

Usa i builtin di GCC invece di importarli

Se stai usando un compilatore GCC, a volte aiuta a usare le loro funzioni integrate, come __builtin_putso __builtin_clz. Per esempio,

44 byte:

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

50 byte:

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

Se stai eseguendo C ++ 11 o versioni successive (che dovrebbe essere sempre il caso ora), utilizza autoper tipi complessi, se possibile.

Esempio: 54 byte anziché 66

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

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

Inoltre, poiché le prestazioni non contano, per alcune sfide si std::listpuò fare il lavoro per pochi byte in meno:

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

Le funzioni <algorithm>spesso richiedono il passaggio, a.begin(),a.end()che è molto lungo, invece è possibile utilizzare &a[0],&*end(a)per salvare 3 byte se aè vectoro string.

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

Non usare string(""), usa "". Salva 8 byte.