Apa tips umum yang Anda miliki untuk bermain golf di C ++? Saya mencari ide yang dapat diterapkan pada masalah kode golf secara umum yang setidaknya agak spesifik untuk C ++ (mis. "Hapus komentar" bukan jawaban). Silakan kirim satu tip per jawaban.

Operator kondisional terner ?:sering dapat digunakan sebagai berdiri di untuk sederhana if- elsepernyataan di tabungan yang cukup.

Ini bernilai khusus karena dapat digunakan untuk memilih nilai alternatif seperti pada

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

Kadang-kadang Anda dapat menyimpan dua karakter dengan menggunakan fakta bahwa variabel durasi penyimpanan statis (yang terutama mencakup semua variabel lingkup global) secara otomatis nol diinisialisasi pada awal (tidak seperti variabel otomatis di mana Anda tidak memiliki jaminan seperti itu). Jadi, bukannya

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

kamu bisa menulis

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

Beberapa kompiler (misalnya GCC) mendukung konstanta multi-karakter . Ini dapat menyimpan beberapa karakter ketika nilai integer besar diperlukan. Contoh:

int n='  ';

Nilainya spesifik implementasi. Biasanya nilai 'ab'is 256*'a'+'b'atau 'a'+256*'b'. Anda dapat menentukan hingga 4 karakter di antara tanda kutip.

Salah satu yang saya temukan berguna:

Mengambil keuntungan dari kenyataan bahwa nilai-nilai non-nol dievaluasi truedalam ekspresi boolean, dan yang x&&ymengevaluasi x*yketika berhadapan dengan boolean

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

mengevaluasi ke

(x*y)

Anda hanya harus mewaspadai luapan, seperti yang ditunjukkan di bawah ini.

Gunakan tipe berikut:

u64, s64, u32, s32 (or int)

Untuk kata / jenis yang berulang, gunakan #defines:

#define a while

Ini hanya layak jika Anda menggunakan whilebanyak untuk mengganti 10 karakter tambahan. ( Tentang 4. )

Jika Anda ingin menggunakan C ++ 0x, Anda dapat menggunakan fitur-fitur baru seperti lambdas .

Jika memungkinkan, ubah &&dan ||ke &dan |masing - masing.

Saat menggunakan pernyataan if sederhana:

if(<condition>)<stuff>;

dapat diubah menjadi:

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

yang menyimpan karakter.

Alih-alih menggunakan while(1), menggunakan for(;;), menyimpan satu karakter :)

Menggunakan operator koma sebagai pengganti kurung buka dan tutup dapat menyimpan beberapa karakter, jika Anda memiliki situasi di mana klausa Anda memiliki lebih dari satu pernyataan di dalamnya:

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

Dua karakter disimpan pada IF biasa, atau tiga total untuk IF / ELSE.

Sebagai titik perbedaan antara C dan C ++, hasil dari ekspresi koma dalam C ++ secara keseluruhan dapat digunakan sebagai nilai lv ... FWIW.

Karena elemen array disimpan secara langsung setelah satu sama lain dalam memori, bukannya sesuatu seperti ini:

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

Anda dapat melakukan sesuatu seperti ini:

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

Jelas tidak satu pun di atas golf, untuk keterbacaan, tetapi secara eksplisit menggunakan pointer dapat menghemat banyak ruang.

Cukup jelas, tetapi Anda menggunakan banyak perpustakaan standar, using namespace std;mungkin menyimpan beberapa karakter.

Yang perlu diingat adalah a[i]sama dengan *(a+i).

Ganti a[0]dengan *auntuk penghematan dua karakter. Juga, a[i][0]sama dengan *a[i]dan a[0][i]menyusut ke i[*a]. Jadi jika Anda meng-coding 0indeks dalam array Anda, cara yang lebih baik mungkin ada.

Alih-alih menulis kekuatan besar 10, gunakan notasi . Misalnya, a=1000000000lebih panjang dari a=1e9. Ini dapat diperluas ke nomor lain seperti a=1e9+24lebih baik daripada a=1000000024.

Anda dapat menggunakan operator ternary ?:tanpa ekspresi di blok-benar (ini menghemat satu byte)

#include <iostream>

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

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

Lihat di sini

Header lebih pendek

Ini khusus GCC, mungkin dapat diperluas ke kompiler lain.

Header yang dikompilasi.

Dalam G ++ bits/stdc++.hadalah header yang dikompilasi terdiri dari semua header lainnya. Jika Anda perlu import2 yang berbeda, Anda bisa menggunakan ini.

Header lebih pendek.

Ini semua tajuk yang terdaftar di 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>

diurutkan dalam peningkatan urutan panjang.

Beberapa dari mereka sudah lebih lama dari bits/stdc++.h, dan beberapa dari mereka memerlukan dukungan C ++ 17. Beberapa lainnya tidak didukung oleh TIO G ++ (untuk alasan yang saya tidak tahu). Saring mereka yang kita miliki:

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

Mungkin saja beberapa dari mereka dapat diganti dengan yang lebih pendek. Hanya pencarian biner apakah yang Anda butuhkan dapat diganti. Khususnya:

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

#importbukannya #includememberi Anda satu byte lagi.

Selain itu, karakter spasi antara #importdan tajuk belum tentu:

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

Dan jika Anda membutuhkan sesuatu dari stdlibtajuk, Anda dapat mengimpor tajuk apa pun dengan wadah STL (lebih disukai setatau map) sebagai gantinya cstdlib.

Operasi aritmatika di Boolean:

Meskipun

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

lebih baik dari

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

itu tidak sebagus

a*=(b>0)-.5

Juga, menggunakan #define pada apa pun yang sering digunakan. Seringkali lebih pendek daripada menggunakan fungsi, karena nama jenis tidak diperlukan.

Gabungkan hal-hal sebanyak mungkin:

a+=a--;

sama dengan

a=2*a-1;

Gunakan lambda generik sebagai templat murah

Untuk tipe selain int, menggunakannya sebagai argumen fungsi bisa jadi mahal. Namun, lambda generik diperkenalkan (dalam C ++ 14?) Dan memungkinkan lambda menjadi templat - menggunakan autountuk tipe argumen dapat menghemat byte. Membandingkan:

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

Lambda Generik juga sangat nyaman untuk menerima iterator - mungkin cara terbaik untuk menerima input array di C ++ adalah [](auto a, auto z), di mana adan zdilewatkan sebagai begin()dan end()dari array / vektor / daftar / dll.

Dalam upaya pertama saya di kode golf untuk tugas "Kurangi angka berikutnya" Saya sudah mulai dari fungsi (58 byte)

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

kemudian amankan 5 byte dengan menggeser ke lambda dan memindahkan inisialisasi dari for(53)

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

dan akhirnya setelah beralih dari forke whilesaya mendapat 51 byte:

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

Kode tes yang tidak disatukan adalah seperti:

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

MEMPERBARUI:

Sebenarnya forbisa mencapai panjang yang sama dengan while:

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

Agak terlambat ke pesta, kurasa ...

Jika Anda ingin mengubah ekspresi menjadi -1 dan 1 alih-alih 0 dan 1, alih-alih ini:

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

melakukan hal ini:

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

Ini dapat menghemat beberapa byte tergantung pada penggunaan.

Jika Anda ingin menukar dua variabel integer a dan b,

a^=b^=a^=b;

dapat digunakan, menyimpan 5 karakter dari cara standar

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

Gunakan GCC bawaan daripada mengimpor

Jika Anda menggunakan kompiler GCC, terkadang membantu menggunakan fungsi bawaannya, seperti __builtin_putsatau __builtin_clz. Sebagai contoh,

44 byte:

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

50 byte:

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

Jika Anda menggunakan C ++ 11 atau lebih baru (yang seharusnya selalu menjadi masalah sekarang), gunakan autountuk tipe yang kompleks, jika memungkinkan.

Contoh: 54 Bytes, bukan 66

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

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

Juga, karena kinerja tidak masalah, untuk beberapa tantangan, std::listmungkin hanya melakukan pekerjaan untuk beberapa byte lebih sedikit:

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

Fungsi dalam <algorithm>sering membutuhkan passing a.begin(),a.end()yang benar-benar panjang, bukannya Anda dapat menggunakan &a[0],&*end(a)untuk menyimpan 3 byte jika aini vectoratau string.

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

Jangan gunakan string(""), gunakan "". Menghemat 8 byte.