Jakie masz ogólne wskazówki na temat gry w golfa w C ++? Szukam pomysłów, które można by zastosować do problemów z golfem w kodzie, które są przynajmniej nieco specyficzne dla C ++ (np. „Usuń komentarze” nie jest odpowiedzią). Proszę zamieścić jedną wskazówkę na odpowiedź.

Trójskładnikowy operator warunkowy ?:może być często używany jako zastępstwo dla prostych if- elsewyciągów przy znacznych oszczędnościach.

Ma to szczególną wartość, ponieważ może być używane do wybierania alternatywnych wartości lv, jak w

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

Czasami można zapisać dwa znaki, wykorzystując fakt, że statyczne zmienne czasu przechowywania (w szczególności wszystkie globalne zmienne zakresu) są automatycznie inicjalizowane na początku na zero (w przeciwieństwie do zmiennych automatycznych, w których nie ma takiej gwarancji). Więc zamiast

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

Możesz pisać

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

Niektóre kompilatory (np. GCC) obsługują stałe wieloznakowe . Dzięki temu można zapisać kilka znaków, gdy wymagana jest duża liczba całkowita. Przykład:

int n='  ';

Wartość zależy od implementacji. Zwykle wartość 'ab'wynosi 256*'a'+'b'lub 'a'+256*'b'. Między znakami cudzysłowu można podać do 4 znaków.

Jeden, który mi się przydał:

Korzystając z faktu, że wartości niezerowe są truewyrażane w wyrażeniach boolowskich, i to x&&yma znaczenie w x*yprzypadku wartości logicznych

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

ocenia na

(x*y)

Musisz tylko pamiętać o przepełnieniu, jak wskazano poniżej.

Użyj następujących typów:

u64, s64, u32, s32 (or int)

W przypadku powtarzających się słów / typów użyj #defines:

#define a while

Warto, jeśli whiledużo używasz, aby nadrobić dodatkowe 10 znaków. ( Około 4. )

Jeśli chcesz używać C ++ 0x, możesz użyć nowych funkcji, takich jak lambdas .

Gdy jest to możliwe, należy zmienić &&i ||na &i |odpowiednio.

Podczas korzystania z prostych instrukcji if:

if(<condition>)<stuff>;

można zmienić na:

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

co ratuje postać.

Zamiast używać while(1), użyj for(;;), zapisując jedną postać :)

Używanie operatora przecinku zamiast otwierania i zamykania nawiasów klamrowych może uratować kilka znaków, jeśli masz sytuację, w której klauzule zawierają więcej niż jedną instrukcję:

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

Dwa znaki zapisane na zwykłym IF lub trzy łącznie dla IF / ELSE.

Jako punkt rozróżnienia między C i C ++ wynik wyrażenia przecinkowego w C ++ jako całości może być użyty jako wartość ... FWIW.

Ponieważ elementy tablic są przechowywane bezpośrednio w pamięci, zamiast czegoś takiego:

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

Możesz zrobić coś takiego:

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

Oczywiście żadne z powyższych nie jest golfem, dla czytelności, ale wyraźne użycie wskaźników może zaoszczędzić dużo miejsca.

To dość oczywiste, ale jeśli używasz dużo standardowej biblioteki, using namespace std;może zapisać kilka znaków.

Warto pamiętać, że a[i]jest to to samo co *(a+i).

Wymienić a[0]z *adwóch znaków oszczędności. Ponadto a[i][0]jest równoważne *a[i]i a[0][i]zmniejsza się do i[*a]. Jeśli więc kodujesz 0indeks na stałe w swojej tablicy, prawdopodobnie istnieje lepszy sposób.

Zamiast pisać duże potęgi 10, użyj notacji e . Na przykład a=1000000000jest dłuższy niż a=1e9. Można to rozszerzyć na inne liczby, takie jak a=1e9+24lepsze niż a=1000000024.

Możesz użyć operatora trójskładnikowego ?:bez żadnych wyrażeń w bloku true (zapisuje on bajt)

#include <iostream>

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

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

Sprawdź tutaj

Krótszy nagłówek

Jest to specyficzne dla GCC, może być rozszerzalne na inne kompilatory.

Wstępnie skompilowany nagłówek.

W G ++ bits/stdc++.hnagłówek prekompilowany składa się ze wszystkich innych nagłówków. Jeśli potrzebujesz import2 różnych, możesz po prostu tego użyć.

Krótszy nagłówek.

To są wszystkie nagłówki wymienione na stronie 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>

posortowane według rosnącej długości.

Niektóre z nich są już dłuższe bits/stdc++.h, a niektóre wymagają obsługi C ++ 17. Niektóre inne nie są obsługiwane przez TIO G ++ (z powodów, których nie znam). Filtruj je:

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

Może się zdarzyć, że niektóre z nich można zastąpić krótszymi. Wystarczy wyszukać binarnie, czy tego, którego potrzebujesz, można wymienić. W szczególności:

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

#importzamiast #includedaje jeszcze jeden bajt.

Ponadto spacja między #importi nagłówkiem niekoniecznie:

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

A jeśli potrzebujesz czegoś z stdlibnagłówka, możesz zaimportować dowolny nagłówek z kontenerem STL (najlepiej setlub map) zamiast cstdlib.

Operacje arytmetyczne na boolach:

Mimo że

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

jest lepszy niż

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

to nie jest tak dobre jak

a*=(b>0)-.5

Używanie #define do wszystkiego, co jest często używane. Często jest krótszy niż używanie funkcji, ponieważ nazwy typów nie są konieczne.

Łącz rzeczy w jak największym stopniu:

a+=a--;

jest taki sam jak

a=2*a-1;

Używaj ogólnych lambdas jako tanich szablonów

W przypadku typów innych niż intużywanie ich jako argumentów funkcji może być kosztowne. Jednak wprowadzono ogólne lambdy (w C ++ 14?) I pozwalają, aby dowolna lambda była szablonem - użycie autotypów argumentów może zaoszczędzić bajty. Porównać:

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

Ogólne lambdy są również bardzo wygodne do akceptowania iteratorów - prawdopodobnie najlepszym sposobem na akceptację danych wejściowych z tablicy w C ++ jest [](auto a, auto z), gdzie ai zsą przekazywane jako begin()i end()z tablicy / vector / list / etc.

W mojej pierwszej próbie kodu golfa dla zadania „Odejmij kolejne liczby” Zacząłem od funkcji (58 bajtów)

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

następnie bezpieczne 5 bajtów z przejściem na lambda i przeniesieniem inicjalizacji z for(53)

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

i wreszcie po przejściu z forna whilemam 51 bajtów:

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

Nie testowany kod testowy przypomina:

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

AKTUALIZACJA:

W rzeczywistości formoże osiągnąć taką samą długość jak while:

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

Trochę późno na imprezę, jak sądzę ...

Jeśli chcesz zmienić wyrażenie na -1 i 1 zamiast 0 i 1, zamiast tego:

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

Zrób to:

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

Może zaoszczędzić niektóre bajty w zależności od użycia.

Jeśli chcesz zamienić dwie zmienne całkowite aib, to:

a^=b^=a^=b;

można użyć, oszczędzając 5 znaków niż standardowy sposób

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

Używaj wbudowanych GCC zamiast importować

Jeśli używasz kompilatora GCC, czasem pomaga korzystanie z ich wbudowanych funkcji, takich jak __builtin_putslub __builtin_clz. Na przykład,

44 bajty:

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

50 bajtów:

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

Jeśli korzystasz z C ++ 11 lub nowszej wersji (co powinno zawsze mieć miejsce teraz), użyj auto, jeśli to możliwe , do typów złożonych.

Przykład: 54 bajty zamiast 66

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

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

Ponadto, ponieważ wydajność nie ma znaczenia, w przypadku niektórych wyzwań std::listmoże po prostu wykonać zadanie o kilka bajtów mniej:

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

Funkcje <algorithm>często wymagają przekazania, a.begin(),a.end()które jest naprawdę długie, zamiast tego można użyć &a[0],&*end(a)do zapisania 3 bajtów, jeśli ajest vectorlub string.

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

Nie używaj string(""), używaj "". Oszczędza 8 bajtów.