C ++ 'da golf oynamak için hangi genel ipuçlarınız var? Genel olarak golf problemlerini kodlamak için uygulanabilecek fikirleri arıyorum, en azından C ++ 'a özgüdür (örneğin, "yorumları kaldır" bir cevap değildir). Lütfen cevap başına bir ipucu gönderin.

Üçlü koşullu operatör ?:genellikle basit bir dayanak noktası olarak kullanılabilir if- elsehatırı sayılır tasarruflarla açıklamalar.

Olduğu gibi alternatif değerleri seçmek için kullanılabileceği için özel bir değere sahiptir.

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

Bazen statik depolama süresi değişkenlerinin (özellikle tüm genel kapsam değişkenlerini içeren) başlangıçta otomatik olarak sıfır başlatılması (böyle bir garantinizin olmadığı otomatik değişkenlerin aksine) gerçeğini kullanarak iki karakter kaydedebilirsiniz. Yani yerine

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

Yazabilirsin

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

Bazı derleyiciler (örneğin, GCC) çok karakterli sabitleri destekler . Bu büyük bir tamsayı değeri gerektiğinde birkaç karakter kaydedebilir. Örnek:

int n='  ';

Değer uygulamaya özeldir. Genellikle değeri 'ab'olduğu 256*'a'+'b'veya 'a'+256*'b'. Tırnak işaretleri arasında en fazla 4 karakter belirleyebilirsiniz.

Kullanışlı bulduğum bir tane:

Sıfır olmayan değerlerin trueboolean ifadelerinde x&&ydeğerlendirilmesinden x*yve booleanlarla uğraşırken değerlendirilmesinden faydalanmak

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

için değerlendirir

(x*y)

Sadece aşağıda belirtildiği gibi taşmaların farkında olmalısınız.

Aşağıdaki türleri kullanın:

u64, s64, u32, s32 (or int)

Tekrarlayan kelimeler / türler için #definesşunları kullanın :

#define a while

whileFazladan 10 karakter için telafi etmek için çok kullanıyorsanız buna değer . ( Yaklaşık 4 )

C ++ 0x kullanmaya istekliyseniz, lambdas gibi yeni özellikleri kullanabilirsiniz .

Mümkün olduğunda, değiştirmek &&ve ||için &ve |sırasıyla.

Basit if ifadeleri kullanılırken:

if(<condition>)<stuff>;

değiştirilebilir:

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

hangi bir karakter kaydeder.

Kullanmak yerine while(1)kullanmak for(;;), bir karakter kaydetmek :)

Virgül operatörünü açık ve kapalı ayraçlar yerine kullanmak, maddelerinizde birden fazla ifadenin bulunduğu bir durum varsa, birkaç karakter kaydedebilir:

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

Düz bir IF'ye kaydedilen iki karakter veya bir IF / ELSE için toplam üç karakter.

C ve C ++ arasındaki bir ayrım noktası olarak, bir bütün olarak C ++ 'daki virgül ifadesinin sonucu bir değer olarak kullanılabilir ... FWIW.

Dizi öğeleri, böyle bir şey yerine doğrudan bellekte birbiri ardına depolandığından:

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

Böyle bir şey yapabilirsiniz:

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

Açıkçası, yukarıdakilerin hiçbiri okunabilirlik için golf oynamıyor, ancak açıkça işaretçileri kullanmak size çok fazla alan kazandırabilir.

Oldukça belirgin bir tane, ancak standart kütüphanenin çoğunu kullanıyorsanız, using namespace std;birkaç karakter kaydedebilirsiniz.

Hatırlamakta fayda var a[i]aynıdır *(a+i).

Değiştir a[0]ile *aiki karakter tasarrufu için. Ayrıca, a[i][0]eşdeğerdir *a[i]ve a[0][i]küçülür i[*a]. Eğer 0dizinizdeki bir dizini zor kodluyorsanız, muhtemelen daha iyi bir yol vardır.

10 büyük güçler yazmak yerine, gösterimi kullanın . Örneğin a=1000000000, daha uzun a=1e9. Bu a=1e9+24daha iyi gibi diğer numaralara uzatılabilir a=1000000024.

Üçlü işlecini ?:true bloğunda hiçbir ifade olmadan kullanabilirsiniz (bayt kazandırır)

#include <iostream>

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

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

Buradan kontrol edin

Daha kısa başlık

Bu GCC'ye özgüdür, diğer derleyicilere genişletilebilir.

Önceden derlenmiş başlık.

G ++ bits/stdc++.h'da önceden derlenmiş başlık diğer tüm başlıklardan oluşur. import2 farklı olana ihtiyacınız varsa, sadece bunu kullanabilirsiniz.

Daha kısa başlık.

Bu, http://en.cppreference.com/w/cpp/header adresinde listelenen başlıkların tamamıdır :

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

uzunluk sırasına göre sıralanır.

Bazıları zaten daha uzun bits/stdc++.h, bazıları ise C ++ 17 desteği gerektiriyor. Bazıları TIO G ++ tarafından desteklenmiyor (bilmediğim sebeplerden dolayı). Bunları filtrelendik:

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

Bazılarının daha kısa olanlarla yer değiştirmesi olabilir. İhtiyacınız olanın değiştirilebilir olup olmadığını sadece ikili arama yapın. Özellikle:

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

#importyerine #includebir bayt daha verir.

Ayrıca, #importbaşlık ile başlık arasındaki boşluk karakteri mutlaka değildir:

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

stdlibÜstbilgiden bir şeye ihtiyacınız olursa , herhangi bir üstbilgiyi yerine STL kabı (tercihen setveya map) ile alabilirsiniz cstdlib.

Booleanlarda aritmetik işlemler:

olmasına rağmen

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

daha iyi

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

o kadar iyi değil

a*=(b>0)-.5

Ayrıca, çok kullanılan bir şey üzerinde #define komutunu kullanmak. Tip isimleri gerekli olmadığından, genellikle işlevleri kullanmaktan daha kısadır.

Şeyleri mümkün olduğunca birleştirin:

a+=a--;

aynıdır

a=2*a-1;

Genel lambdas'ı ucuz şablon olarak kullanın

Bunun dışındaki türler için int, onları işlev argümanları olarak kullanmak pahalı olabilir. Bununla birlikte, jenerik lambdalar tanıtıldı (C ++ 14? De) ve herhangi bir lambranın bir şablon olmasına izin verin - autoargüman türlerini kullanarak baytları kurtarabilir. Karşılaştırmak:

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

Genel lambdalar, yineleyicileri kabul etmek için de çok uygundur - muhtemelen C ++ 'da dizi girişlerini kabul etmenin en iyi yolu [](auto a, auto z), / ve / / dizinin / etc dizininin olduğu ave zgeçtiği yerdir .begin()end()

Golf kodundaki ilk denememde "Sonraki numaraları çıkar" görevinden başladım (58 byte)

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

daha sonra güvenli 5 bayt lambda kayması ve başlangıç ​​ayarlarının for(53) dışına çıkarılmasıyla güvenli

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

ve son olarak geçtikten sonra forhiç whileI 51 bayt var:

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

Ungolfed test kodu gibi bir şey:

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

GÜNCELLEME:

Aslında foraynı uzunlukta olabilir while:

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

Partiye geç kaldım sanırım ...

Bir ifadeyi, 0 ve 1 yerine -1 ve 1'e dönüştürmek istiyorsanız, bunun yerine:

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

Bunu yap:

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

Kullanıma bağlı olarak bazı baytları kaydedebilir.

A ve b iki tamsayılı değişkeni değiştirmek isterseniz,

a^=b^=a^=b;

standart yoldan 5 karakter kaydederek kullanılabilir

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

İçe aktarmak yerine GCC yerleşiklerini kullanın

Bir GCC derleyicisi kullanıyorsanız, bazen __builtin_putsveya gibi yerleşik işlevlerini kullanmanıza yardımcı olur __builtin_clz. Örneğin,

44 bayt:

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

50 bayt:

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

Eğer C ++ 11 veya daha yenisini yapıyorsanız (ki şimdi her zaman olduğu gibi), automümkünse karmaşık türler için kullanın .

Örnek: 66 yerine 54 Bayt

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

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

Ayrıca, performans önemli olmadığı için, bazı zorluklar std::listiçin bir iş sadece birkaç bayt için daha az iş yapabilir:

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

Fonksiyonlar <algorithm>çoğunlukla geçmesini gerektirir a.begin(),a.end()yerine kullanabileceğiniz, gerçekten uzun &a[0],&*end(a)olursa 3 bayt kaydetmek için aise vectorya string.

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

Kullanmayın string(""), kullanmayın "". 8 bayt kaydeder.