Какие общие советы у вас есть для игры в гольф на C ++? Я ищу идеи, которые могут быть применены к задачам по коду для гольфа в целом, которые, по крайней мере, несколько специфичны для C ++ (например, «удалить комментарии» - это не ответ). Пожалуйста, оставьте один совет за ответ.

Тройной условный оператор ?:может часто использоваться в качестве подставки в для простого if- elseзаявлений на значительной экономии средств.

Это имеет особое значение в том смысле, что его можно использовать для выбора альтернативных значений, как в

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

Иногда вы можете сохранить два символа, используя тот факт, что статические переменные продолжительности хранения (которые особенно включают в себя все глобальные переменные области видимости) автоматически инициализируются нулями в начале (в отличие от автоматических переменных, где у вас нет такой гарантии). Так что вместо

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

ты можешь написать

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

Некоторые компиляторы (например, GCC) поддерживают многосимвольные константы . Это может сохранить несколько символов, когда требуется большое целочисленное значение. Пример:

int n='  ';

Значение зависит от реализации. Обычно значение 'ab'равно 256*'a'+'b'или 'a'+256*'b'. Вы можете указать до 4 символов между кавычками.

Тот, который я нашел удобным:

Воспользовавшись тем фактом, что ненулевые значения оцениваются trueв булевых выражениях, и это имеет x&&yзначение x*yпри работе с булевыми выражениями

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

оценивает

(x*y)

Вы просто должны знать о переполнениях, как указано ниже.

Используйте следующие типы:

u64, s64, u32, s32 (or int)

Для повторяющихся слов / типов используйте #defines:

#define a while

Это того стоит, если вы используете whileмного, чтобы наверстать лишние 10 символов. ( Около 4. )

Если вы хотите использовать C ++ 0x, вы можете использовать новые функции, такие как лямбда-выражения .

По возможности меняйте &&и ||на &и |соответственно.

При использовании простых операторов if:

if(<condition>)<stuff>;

можно изменить на:

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

который сохраняет характер.

Вместо того, чтобы использовать while(1), используйте for(;;), сохраняя один символ :)

Использование оператора запятой вместо открытых и закрытых скобок может сохранить несколько символов, если у вас есть ситуация, когда в ваших предложениях содержится более одного оператора:

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

против

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

Два символа, сохраненные на простой IF, или всего три для IF / ELSE.

Как различие между C и C ++, результат выражения запятой в C ++ в целом может использоваться как lvalue ... FWIW.

Поскольку элементы массива хранятся непосредственно в памяти друг за другом, а не как-то так:

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

Вы можете сделать что-то вроде этого:

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

Очевидно, что ни один из вышеперечисленных не подходит для удобства чтения, но явное использование указателей может сэкономить вам много места.

Совершенно очевидно, но если вы используете много стандартной библиотеки, вы using namespace std;можете сохранить несколько символов.

Полезно помнить, что a[i]это так же, как *(a+i).

Замените a[0]на *aдля двухсимвольной экономии. Кроме того, a[i][0]эквивалентно *a[i]и a[0][i]сокращается до i[*a]. Поэтому, если вы жестко программируете 0индекс в своем массиве, возможно, существует лучший способ.

Вместо написания больших степеней 10, используйте электронные обозначения . Например, a=1000000000длиннее чем a=1e9. Это может быть распространено на другие номера, как a=1e9+24лучше, чем a=1000000024.

Вы можете использовать троичный оператор ?:без каких-либо выражений в блоке true (он сохраняет байт)

#include <iostream>

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

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

Проверьте это здесь

Более короткий заголовок

Это специфично для GCC, оно может быть расширено другими компиляторами.

Предварительно скомпилированный заголовок.

В G ++ bits/stdc++.hэто предварительно скомпилированный заголовок состоит из всех остальных заголовков. Если вам нужно import2 разных, вы можете просто использовать это.

Короче заголовок.

Это все заголовки, перечисленные на 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>

отсортировано в порядке возрастания длины.

Некоторые из них уже длиннее bits/stdc++.h, а некоторые требуют поддержки C ++ 17. Некоторые другие не поддерживаются TIO G ++ (по причинам, о которых я не знаю). Отфильтровать их мы имеем:

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

Может случиться, что некоторые из них могут быть заменены на более короткие. Просто бинарный поиск, можно ли заменить тот, который вам нужен. В частности:

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

#importвместо того, чтобы #includeдать вам еще один байт.

Кроме того, пробел между #importи заголовком не обязательно:

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

И если вам нужно что-то из stdlibзаголовка, вы можете импортировать любой заголовок с контейнером STL (предпочтительно setили map) вместо cstdlib.

Арифметические операции над логическими значениями:

Несмотря на то что

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

Это лучше чем

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

это не так хорошо, как

a*=(b>0)-.5

Кроме того, использование #define для всего, что используется часто. Это часто короче, чем использование функций, так как имена типов не нужны.

Объедините вещи как можно больше:

a+=a--;

такой же как

a=2*a-1;

Используйте общие лямбды в качестве дешевых шаблонов

Для других типов intиспользование их в качестве аргументов функции может быть дорогостоящим. Тем не менее, были введены общие лямбда-выражения (в C ++ 14?), Позволяющие любой лямбда-выражению быть шаблоном - использование autoтипов аргументов позволяет сохранять байты. Для сравнения:

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

Общие лямбды также очень удобны для принятия итераторов - вероятно, лучший способ принять входные данные массива в C ++ [](auto a, auto z), где aи zпередаются как begin()и end()из массива / вектора / списка / и т.д.

В моей первой попытке кода гольф для задачи «Вычесть следующие числа» я начал с функции (58 байт)

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

затем безопасно 5 байтов с переходом на лямбду и перемещением инициализации из for(53)

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

и наконец после переключения с forна whileя получил 51 байт:

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

Тестовый код ungolfed выглядит примерно так:

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

ОБНОВИТЬ:

На самом деле forможет достигать той же длины, что и while:

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

Вроде поздно на вечеринку, наверное ...

Если вы хотите превратить выражение в -1 и 1 вместо 0 и 1 вместо этого:

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

сделай это:

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

Это может сэкономить несколько байтов в зависимости от использования.

Если вы хотите поменять местами две целочисленные переменные a и b,

a^=b^=a^=b;

можно использовать, сохранив 5 символов, чем стандартным способом

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

Используйте встроенные функции GCC вместо импорта

Если вы используете компилятор GCC, это иногда помогает использовать их встроенные функции, такие как __builtin_putsили __builtin_clz. Например,

44 байта:

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

50 байтов:

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

Если вы используете C ++ 11 или новее (что всегда должно быть в настоящее время), используйте autoдля сложных типов, если это возможно.

Пример: 54 байта вместо 66

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

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

Кроме того, поскольку производительность не имеет значения, для некоторых задач std::listможет просто выполнить работу на несколько байтов меньше:

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

Функции <algorithm>часто требуют передачи, a.begin(),a.end()которая очень длинная, вместо этого вы можете использовать &a[0],&*end(a)для сохранения 3 байта, если aесть vectorили string.

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

Не используйте string(""), используйте "". Это экономит 8 байтов.