Welche allgemeinen Tipps haben Sie zum Golfen in C ++? Ich bin auf der Suche nach Ideen, die sich auf Code-Golf-Probleme im Allgemeinen anwenden lassen, die zumindest etwas spezifisch für C ++ sind (z. B. "Kommentare entfernen" ist keine Antwort). Bitte posten Sie einen Tipp pro Antwort.

Der ternäre Bedingungsoperator ?:kann oft als in für einfachen Stand verwendet werden if- elseAussagen zu erheblichen Einsparungen.

Dies ist insofern von besonderem Wert, als damit alternative Werte wie in ausgewählt werden können

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

Manchmal können Sie zwei Zeichen speichern, indem Sie die Tatsache verwenden, dass statische Speicherdauervariablen (die insbesondere alle globalen Bereichsvariablen umfassen) zu Beginn automatisch auf Null gesetzt werden (im Gegensatz zu automatischen Variablen, für die Sie keine solche Garantie haben). Also statt

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

Du kannst schreiben

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

Einige Compiler (zB GCC) unterstützen Konstanten mit mehreren Zeichen . Dies kann einige Zeichen sparen, wenn ein großer ganzzahliger Wert erforderlich ist. Beispiel:

int n='  ';

Der Wert ist implementierungsspezifisch. In der Regel der Wert 'ab'ist 256*'a'+'b'oder 'a'+256*'b'. Sie können bis zu 4 Zeichen in Anführungszeichen setzen.

Eines, das ich als nützlich empfand:

Unter Ausnutzung der Tatsache , dass Nicht-Null - Werte zu bewerten truein Booleschen Ausdrücken, und dass x&&yauswertet , um , x*ywenn sie mit booleans Umgang

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

bewertet zu

(x*y)

Sie müssen sich nur der Überläufe bewusst sein, wie unten ausgeführt.

Verwenden Sie die folgenden Typen:

u64, s64, u32, s32 (or int)

Verwenden Sie für sich wiederholende Wörter / Typen #defines:

#define a while

Es lohnt sich nur, wenn Sie whileviel verwenden, um die zusätzlichen 10 Zeichen auszugleichen. ( Ungefähr 4. )

Wenn Sie bereit sind, C ++ 0x zu verwenden, können Sie neue Funktionen wie Lambdas verwenden .

Wenn möglich, ändern &&und ||zu &und |ist.

Bei Verwendung von einfachen if-Anweisungen:

if(<condition>)<stuff>;

kann geändert werden in:

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

was einen Charakter speichert.

Anstatt zu benutzen while(1), benutze for(;;), speichere ein Zeichen :)

Die Verwendung des Komma-Operators anstelle von öffnenden und schließenden Klammern kann einige Zeichen sparen, wenn Ihre Klauseln mehr als eine Anweisung enthalten:

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

gegen

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

Zwei Zeichen auf einer einfachen IF oder drei insgesamt für eine IF / ELSE gespeichert.

Zur Unterscheidung zwischen C und C ++ kann das Ergebnis eines Kommaausdrucks in C ++ als Ganzes als Wert ... FWIW verwendet werden.

Da Array-Elemente direkt hintereinander im Speicher abgelegt werden, anstatt wie folgt:

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

Sie können so etwas tun:

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

Aus Gründen der Lesbarkeit ist keines der oben genannten Elemente Golf. Die explizite Verwendung von Zeigern kann jedoch viel Platz einsparen.

Es liegt auf der Hand, aber wenn Sie einen Großteil der Standardbibliothek verwenden, using namespace std;können einige Zeichen gespeichert werden.

Es ist nützlich, sich daran zu erinnern, dass dies a[i]dasselbe ist wie *(a+i).

Ersetzen Sie a[0]durch, *aum zwei Zeichen zu sparen. Auch a[i][0]ist gleichbedeutend mit *a[i]und a[0][i]schrumpft auf i[*a]. Wenn Sie also einen 0Index in Ihrem Array fest codieren , gibt es wahrscheinlich einen besseren Weg.

Anstatt große Zehnerpotenzen zu schreiben, verwenden Sie die e-Notation . Zum Beispiel a=1000000000ist länger als a=1e9. Dies kann auf andere Zahlen erweitert werden, wie a=1e9+24es besser ist als a=1000000024.

Sie können den ternären Operator ?:ohne Ausdrücke im True-Block verwenden (es wird ein Byte gespeichert).

#include <iostream>

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

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

Überprüfen Sie es hier

Kürzere Kopfzeile

Dies ist GCC-spezifisch und möglicherweise auf andere Compiler erweiterbar.

Vorkompilierter Header.

In G ++ bits/stdc++.hbesteht der vorkompilierte Header aus allen anderen Headern. Wenn Sie importzwei verschiedene benötigen, können Sie diese einfach verwenden.

Kürzere Kopfzeile.

Dies sind alle unter http://en.cppreference.com/w/cpp/header aufgelisteten Überschriften :

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

in aufsteigender Reihenfolge der Länge sortiert.

Einige von ihnen sind bereits länger als bits/stdc++.h, und einige von ihnen erfordern C ++ 17-Unterstützung. Einige andere werden von TIO G ++ nicht unterstützt (aus mir unbekannten Gründen). Filtern Sie sie heraus, die wir haben:

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

Es kann vorkommen, dass einige von ihnen durch kürzere ersetzt werden können. Nur binäre Suche, ob das, was Sie brauchen, ersetzt werden kann. Speziell:

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

#importanstatt #includedir ein weiteres Byte zu geben.

Außerdem muss das Leerzeichen zwischen #importund header nicht unbedingt sein:

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

Und wenn Sie etwas aus dem stdlibHeader benötigen , können Sie jeden Header mit STL-Container (vorzuziehen setoder map) anstelle von importieren cstdlib.

Arithmetische Operationen mit Booleschen Werten:

Obwohl

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

ist besser als

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

es ist nicht so gut wie

a*=(b>0)-.5

Verwenden Sie #define auch für alles, was häufig verwendet wird. Sie ist oft kürzer als die Verwendung von Funktionen, da Typnamen nicht erforderlich sind.

Kombiniere die Dinge so oft wie möglich:

a+=a--;

ist das gleiche wie

a=2*a-1;

Verwenden Sie generische Lambdas als billige Vorlagen

Bei anderen Typen intkann die Verwendung als Funktionsargumente teuer sein. Es wurden jedoch generische Lambdas eingeführt (in C ++ 14?), Die es jedem Lambda erlauben, eine Vorlage zu sein - mit autoden Argumenttypen können Bytes gespart werden. Vergleichen Sie:

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

Generische Lambdas sind auch sehr praktisch, um Iteratoren zu akzeptieren - wahrscheinlich ist die beste Methode, um Array-Eingaben in C ++ zu akzeptieren [](auto a, auto z), wo aund zwie begin()und end()vom Array / vector / list / etc übergeben werden.

Bei meinem ersten Versuch, Golf für die Aufgabe "Subtrahiere die nächsten Zahlen" zu codieren, bin ich von der Funktion ausgegangen (58 Bytes)

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

dann sichere 5 Bytes mit Verschiebung nach Lambda und Verschieben der Initialisierung aus for(53)

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

und schließlich nach dem Wechsel von forzu whilebekam ich 51 Bytes:

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

Der ungolfed Testcode ist so etwas wie:

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

AKTUALISIEREN:

forKann tatsächlich die gleiche Länge erreichen wie while:

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

Irgendwann zu spät zur Party, denke ich ...

Wenn Sie einen Ausdruck in -1 und 1 anstelle von 0 und 1 umwandeln möchten, gehen Sie stattdessen wie folgt vor:

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

mach das:

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

Je nach Verwendung können einige Bytes eingespart werden.

Wenn Sie zwei ganzzahlige Variablen a und b vertauschen möchten,

a^=b^=a^=b;

kann verwendet werden und 5 Zeichen als die Standardmethode speichern

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

Verwenden Sie GCC-Builtins, anstatt sie zu importieren

Wenn Sie einen GCC-Compiler verwenden, ist es manchmal hilfreich, die darin enthaltenen Funktionen wie __builtin_putsoder zu verwenden __builtin_clz. Zum Beispiel,

44 Bytes:

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

50 Bytes:

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

Wenn Sie C ++ 11 oder neuer verwenden (was jetzt immer der Fall sein sollte), verwenden Sie auto Option nach Möglichkeit für komplexe Typen.

Beispiel: 54 Bytes statt 66

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

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

Da die Leistung keine Rolle spielt, kann es bei einigen Herausforderungen auch std::listsein, dass der Job nur um ein paar Bytes weniger erledigt wird :

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

Funktionen <algorithm>erfordert oft beiläufig a.begin(),a.end()die wirklich lang ist, stattdessen können Sie mit &a[0],&*end(a)3 Bytes speichern , wenn aist vectoroder string.

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

Nicht benutzen string(""), benutzen "". Das spart 8 Bytes.