Які загальні поради щодо гольфу в 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(<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;}

vs.

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

Два символи, збережені на звичайному IF або три загалом для IF / ELSE.

Як відмінність C і C ++, результат вираження комами в C ++ в цілому може бути використаний як значення ... 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, використовуйте нотацію e . Наприклад, 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;}

Код тестування, який не має волі, має щось на зразок:

#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 байт.