Tujuan dari posting ini adalah untuk mengumpulkan semua tips golf yang dapat dengan mudah diterapkan <all languages>daripada yang khusus.

Hanya posting jawaban yang logikanya dapat diterapkan ke sebagian besar bahasa

Tolong, satu tip per jawaban

Gabungkan Loop

Anda biasanya dapat menggabungkan dua loop konsekuen, atau dua loop bersarang, menjadi satu.

Sebelum:

for (i=0; i<a; i++) foo();
for (i=0; i<b; i++) bar();

Setelah:

for (i=0; i<a+b; i++) i<a?foo():bar();

Hanya untuk menyebutkan yang sudah jelas:

Pertanyakan pilihan algoritma Anda dan coba sesuatu yang sama sekali baru.

Ketika bermain golf (terutama masalah yang lebih sulit yang mengakibatkan program lebih lama) terlalu sering Anda mungkin tetap pada jalur yang Anda pilih pertama kali tanpa mencoba opsi mendasar lainnya. Tentu saja, Anda dapat bermain golf mikro satu atau beberapa baris sekaligus atau sebagian dari keseluruhan gagasan, tetapi seringkali tidak mencoba solusi yang sama sekali berbeda.

Ini terutama terlihat di Hitting 495 (Kaprekar) di mana menyimpang dari algoritma yang sebenarnya dan mencari pola yang dapat Anda terapkan untuk mendapatkan hasil yang sama lebih pendek dalam banyak bahasa (hanya bukan J).

Kelemahannya adalah Anda mungkin memecahkan hal yang sama setengah lusin kali. Tapi itu benar-benar bekerja di semua bahasa kecuali HQ9 + (di mana menemukan cara lain untuk menghasilkan Hello World akan sedikit sia-sia).

Gunakan Pengembangan Test-Driven

Jika kode harus menangani berbagai input, maka tulis tes komprehensif dan membuatnya mudah untuk menjalankan semuanya dengan sangat cepat. Ini memungkinkan Anda untuk mencoba mengubah langkah bayi berisiko satu per satu. Golf kemudian menjadi seperti refactoring dengan niat jahat.

Cobalah untuk mengurangi pernyataan logis

Misalnya, jika Adan Bboolean dan bahasa Anda memperlakukan boolean seperti angka sampai batas tertentu, A and (not B)dan A>Bsetara. Misalnya dengan Python

if A and not B:
    foo()

sama dengan:

if A>B:
    foo()

Inisialisasi variabel menggunakan nilai yang sudah Anda miliki.

Alih-alih x=1, coba cari sesuatu yang sudah sama dengan 1.
Misalnya, nilai pengembalian fungsi: printf("..");x=0;-> x=!printf("..");. Ini paling mudah dengan 0, karena Anda selalu dapat meniadakan, atau ketika semua yang Anda butuhkan adalah nilai kebenaran yang benar (dan tidak peduli apakah itu 1 atau 19).

Gunakan unary ~untuk x+1danx-1

Trik ini berlaku untuk bahasa yang memiliki operator negasi bitwise unary ~dan operator negasi reguler unary -.

Jika program Anda, secara kebetulan, berisi ekspresi -x-1, Anda dapat menggantinya dengan ~xuntuk menyimpan byte. Ini tidak terlalu sering terjadi, tetapi perhatikan apa yang terjadi jika kita meniadakan ( -) kedua ekspresi: x+1sama dengan -~x! Demikian pula, x-1sama ~-x. (Pikirkan ke arah mana tilde menunjuk: kanan adalah +, kiri adalah -.)

Ini berguna, karena dalam semua bahasa saya bisa memikirkan yang memiliki operator ini, mereka memiliki prioritas lebih tinggi daripada kebanyakan operator. Ini memungkinkan Anda menghemat tanda kurung. Tonton bagaimana kami menyimpan empat byte di sini:

(x+1)*(y-1)     ==>    -~x*~-y

Peras ruang putih

Ketahui aturan untuk spasi putih dalam bahasa Anda. Beberapa tanda baca, atau karakter lain, mungkin tidak memerlukan spasi putih di sekitarnya. Pertimbangkan fungsi shell Bourne ini :

f () { echo a; echo b; }

Dalam Bourne shell, ();adalah metacharacters, dan tidak perlu mengelilingi spasi putih. Namun, {}adalah kata-kata dan perlu spasi putih kecuali mereka di sebelah karakter metak. Kita dapat bermain golf sejauh 4 ruang di sebelah ();, tetapi harus menjaga jarak antara {dan echo.

f(){ echo a;echo b;}

Dalam Common Lisp dan PicoLisp , ()adalah karakter metachar . Pertimbangkan kode ini untuk menemukan rata-rata dua angka:

(/ (+ a b) 2)

Kami dapat bermain golf 2 ruang.

(/(+ a b)2)

Beberapa bahasa memiliki aturan aneh dan halus untuk spasi putih. Pertimbangkan program Ruby ini, yang mencetak jumlah dan produk dari linier bilangan bulat.

#!ruby -an
i=$F.map &:to_i
puts"#{i.reduce &:+} #{i.reduce &:*}"

Masing-masing &membutuhkan ruang sebelum dirinya sendiri. Di Ruby, i=$F.map &:to_iberarti di i=$F.map(&:to_i)mana &melewati parameter blok. Tapi, i=$F.map&:to_iberarti di i=$F.map.&(:to_i)mana &operator biner.

Keanehan ini terjadi dalam bahasa, seperti Perl atau Ruby, yang menggunakan tanda baca yang ambigu. Jika ragu, gunakan REPL atau tulis program pendek untuk menguji aturan spasi putih.

menugaskan fungsi nama baru jika digunakan beberapa kali

x = SomeLongFunctionName
x(somedata)
x(somemoredata)
etc

Nama Variabel Huruf Tunggal

Anda memiliki 52 dari mereka; gunakan semuanya! Jangan takut untuk mencoba pendekatan yang berbeda dan membandingkan panjangnya. Ketahui bahasa dan fungsi pintas / pustaka tertentu yang tersedia.

Gunakan operator kondisional.

Operator bersyarat

bool ? condition_true : condition_false

lebih bermanfaat, lebih bijak daripada pernyataan IF .

if(a>b){r=a;}else{r=b;}

dapat ditulis sebagai

r=a>b?a:b;

Tuliskan penjelasan tentang kode Anda

Menulis penjelasan memaksa Anda untuk secara menyeluruh melihat setiap bagian dari kode Anda lagi dan membuat pemikiran dan pilihan Anda dalam menulis suatu bagian tertentu secara eksplisit. Dengan melakukan itu, Anda mungkin menemukan bahwa pendekatan yang berbeda dimungkinkan yang dapat menghemat beberapa byte, atau bahwa Anda secara tidak sadar membuat asumsi yang tidak selalu berlaku.

Tip ini mirip dengan Pertanyaan algoritma pilihan Anda dan coba sesuatu yang sama sekali baru ; Namun, saya telah menemukan bahwa langkah untuk benar-benar menuliskan bagaimana setiap bagian seharusnya bekerja kadang-kadang penting untuk menjadi sadar akan alternatif.

Sebagai bonus, jawaban termasuk penjelasan lebih menarik bagi pengguna lain dan karenanya lebih cenderung untuk di-upgrade.

Periksa jumlah karakter Anda

Kedengarannya seperti no-brainer, tetapi dengan berhati-hati Anda mungkin dapat "menyelamatkan" beberapa karakter dengan tidak benar-benar melakukan apa pun!

Jika Anda menggunakan Windows, Anda mungkin memasukkan \r\nbukan hanya \ratau \nketika Anda menekan Return - menambahkan byte tambahan per baris! Putar karakter kontrol hanya untuk mengecek Anda tidak melakukan ini.

Di Notepad ++ Anda dapat mengonversi semua \r\nujung baris menjadi hanya \rdengan masuk ke Edit > EOL Conversion > UNIX/OSX Format.

Pastikan juga Anda tidak memasukkan spasi spasi tambahan dalam jumlah karakter Anda! Umpan baris pada baris terbawah dalam kode Anda juga tidak penting, sehingga tidak perlu dihitung juga.

Baca pertanyaan dengan seksama

Code golfing adalah tentang memahami pertanyaan (apa yang ditanyakan dan apa yang tidak ditanyakan, meskipun itu akan tersirat dalam pengaturan lain) seperti memproduksi kode yang (mungkin) hanya memuaskan apa yang ditanyakan.

Masukan apa pun selain apa yang diminta secara eksplisit tidak perlu ditangani. Jika ada beberapa kasus uji dan tidak ada persyaratan umum, kode Anda hanya dapat berfungsi dalam kasus tersebut. Dll

Gunakan operasi bitwise untuk memeriksa angka antara 0 dan 2 ⁿ -1

Mungkin ada sedikit kasus tepi, tetapi kadang-kadang bisa berguna. Itu bergantung pada fakta bahwa semua angka yang m = 2 ⁿ -1 berlaku memiliki n bit paling kanan diatur ke 1.

Jadi, 7 ₁₀ == 00000111 ₂ , 15 ₁₀ == 00001111 ₂ , 31 ₁₀ == 00011111 ₂ dan seterusnya.

Caranya adalah x&~m. Ini akan kembali benar setiap kali xadalah tidak antara 0 dan m(inklusif), dan false jika tidak. Menghemat 6 byte dari persamaan ekuivalen terpendek berikutnya:, x>=0&&x<=mtetapi jelas hanya berfungsi ketika mmemenuhi 2 ⁿ -1.

Gunakan kembali parameter fungsi, bukan variabel baru

Lebih besar / kurang dari untuk menyimpan digit:

//use:
if(n>9){A}else{B}
//instead of:
if(n<10){B}else{A}

Hanya ingat untuk menukar kode dari ifke elsedan mereka akan melakukan hal yang persis sama (atau mengganti sisi ketidaksetaraan)!

Catatan: ini dapat diterapkan dengan kekuatan 10 dan negatifnya:...-100, -10, 10, 100...

(tautan sumber)

Gunakan> dan <sebagai ganti> = dan <=

Saat memeriksa nilai integer yang dikodekan dengan keras, gunakan >dan <alih-alih >=dan <=jika memungkinkan. Misalnya, menggunakan

if(x>24&&x<51)

Lebih pendek 2 byte daripada menggunakan

if(x>=25&&x<=50)

Hindari jeda lingkaran prematur

Jika menjalankan melalui loop untuk memeriksa 1 atau lebih contoh dari boolean check, itu mungkin membuat program yang lebih efisien untuk keluar dari loop pada nilai true pertama. Namun, menghapus break dan looping melalui semua iterasi memungkinkan kode yang lebih pendek

int main() {
bool m = false;
int n = 1000;
for (int i = 0; i < n; i++) {
if (i >= 100) {
m = true;
break; // remove this line
}
} 
return 0;
}

gunakan -sebagai ganti!=

untuk perbandingan numerik:

Jika a sama dengan b, a-bmenghasilkan 0, yang salah. Apa pun selain 0kebenaran; jadi
jika digunakan dalam konteks boolean, a-b<=>a!=b

Jika Anda menggunakannya dengan if/elseatau dengan operator ternary, ini juga dapat menghemat satu byte untuk kesetaraan:
a==b?c:d<=>a-b?d:c

Pisahkan string untuk array panjang

Sebagian besar bahasa memiliki cara untuk membagi string menjadi array string di sekitar token. Ini pasti akan lebih pendek dari array literal begitu panjangnya mencapai ambang tergantung pada bahasa, karena overhead tambahan per string akan menjadi satu salinan token satu char daripada satu (setidaknya) dua pembatas string.

Misalnya dalam GolfScript

["Foo""Bar""Baz""Quux"]  # 23 chars

menjadi

"Foo
Bar
Baz
Quux"n/  # 20 chars

Untuk beberapa bahasa, ambangnya serendah satu string. Misal di Jawa,

new String[]{"Foo"}  // 19 chars

menjadi

"Foo".split("~")  // 16 chars

Pahami apa yang dilakukan orang lain

Selain menyenangkan, jika Anda memeriksa kode orang lain, Anda kadang-kadang dapat menemukan algoritma yang baik yang tidak Anda pikirkan, atau trik (kadang-kadang yang jelas) yang Anda abaikan.

Terkadang ada jawaban yang sudah ada yang bisa Anda terjemahkan ke bahasa lain, dan manfaatkan dari kebaikan bahasa lainnya.

tahu prioritas operator Anda

Setiap kali Anda menggabungkan beberapa ekspresi, periksa tabel diutamakan operator untuk bahasa Anda untuk melihat apakah Anda dapat memesan ulang barang untuk menghemat tanda kurung.

Contoh:

• Dalam semua bahasa yang saya tahu, operator bitwise memiliki prioritas lebih tinggi daripada operator boolean: (a&b)&&ctidak perlu tanda kurung: a&b&&csama seperti (a*b)+ctidak.
• a+(b<<c)dapat ditulis ulang sebagai a+b*2**c.
  Itu tidak menyimpan apa pun untuk contoh ini, tetapi itu akan jika cadalah integer literal kecil (<14).
• Operasi bitwise memiliki prioritas lebih rendah daripada kebanyakan operasi aritmatika, jadi jika bahasa Anda secara implisit melemparkan boolean ke int, Anda dapat menyimpan byte a<b&&c<ddengan a<b&c<d(kecuali jika Anda memerlukan evaluasi hubung singkat)

Lebih pendek untuk-loop

Jika Anda memiliki Xpernyataan {di dalam }for-loop Anda, Anda bisa memindahkan X-1pernyataan (di )dalam for-loop setelah tanda koma kedua for(blah;blah;HERE)untuk menghemat 3 byte. (pisahkan pernyataan dengan menggunakan koma ,)

Dari pada

for(int i=0;i<9;){s+=s.length();println(i++);}

Anda dapat memindahkan salah satu pernyataan ke (kawat gigi for-loop )sambil meninggalkan yang lainnya

for(int i=0;i<9;println(i++))s+=s.length();

dan simpan 3 byte (disimpan 1 byte lagi berkat @ETHProductions)

Sederhananya,

dari pada

for(blah;blah;){blah 1;blah 2;...;blah X}

pindahkan pernyataan di sekitar sehingga Anda berakhir dengan ini

for(blah;blah;blah 2,...,blah X)blah 1;

dan simpan 3 byte

Gunakan unary ~untuk a-b-1dana+b+1

Selain saran @ Lynn tentang x+1→ -~x; dan x-1→~-x , Anda juga dapat bermain golf a-b-1dan a+b+1.

a-b-1    // 5 bytes
a+~b     // 4 bytes

a+b+1    // 5 bytes
a-~b     // 4 bytes

Ini mungkin terlihat seperti tip yang tidak akan sering Anda gunakan, agak seperti menggunakan ~xbukannya -x-1tidak sering terjadi, tetapi saya sudah cukup sering menggunakannya untuk melihatnya sebagai tip yang bermanfaat di sini. Terutama dengan pengindeksan array Anda dapat menggunakan ini di atas dalam beberapa kasus.

Kompres atau garis-garis

Trik sederhana yang saya buat ketika mencoba untuk memeras kondisi panjang dirantai oleh ands (atau ors, dalam hal ini hanya mengganti 'semua' dengan 'apa saja').

Misalnya:

if a>0 and a<10 and a+b==4 and a+3<1:

Menjadi

if all([a>0,a<10,a+b==4,a+3<1]):

Mengandalkan kompiler untuk memberikan kinerja yang diperlukan.

Pastikan untuk mengetahui optimisasi mana yang dijamin oleh kompiler dan pada level optimasi mana, dan gunakan secara bebas. Dan bahkan jika kinerja bukan persyaratan perhatian , Anda masih dapat menguji dengan optimisasi, dan kemudian hanya mendiskon satu karakter karena kode Anda secara teknis masih valid tanpa flag compiler.

Pertimbangkan fungsi Haskell berikut untuk menghitung 2 ^ n (mengabaikan fakta bahwa Haskell sudah memiliki satu atau tiga operator eksponensial bawaan) (23 karakter):

p 0=1;p x=p(x-1)+p(x-1)

Masalahnya - sangat lambat, berjalan dalam waktu yang eksponensial. Ini mungkin membuat kode Anda tidak dapat diuji atau untuk gagal kendala kinerja yang diberikan oleh pertanyaan. Anda mungkin tergoda untuk menggunakan variabel sementara atau fungsi literal yang segera dipanggil untuk menghindari panggilan fungsi berulang (25 karakter):

p 0=1;p x=(\y->y+y)$p$x-1

Tetapi kompiler sudah dapat melakukan itu untuk Anda, Anda hanya perlu menetapkan -Osebagai flag kompiler! Alih-alih menghabiskan beberapa karakter tambahan per situs untuk menghilangkan sub-ekspresi umum secara manual, katakan saja kepada kompiler untuk melakukan optimasi dasar bagi Anda untuk total satu atau dua karakter di seluruh program.

Mungkin agak jelas tapi ...

Manfaatkan nilai pengembalian operator

Perlu diingat bahwa operator penugasan mengembalikan nilai!

Misalnya, jika Anda ingin menambahkan y ke x dan kemudian memeriksa apakah x lebih besar dari sesuatu, Anda bisa melakukannya

if(25<x+=y)

dari pada

x+=y;if(x>25)

Atau mungkin Anda ingin menemukan panjang string setelah memangkasnya:

strlen(s=trim(s))

Daripada

s=trim(s);strlen(s)

Memanfaatkan versi bahasa / kompiler / kebiasaan lingkungan / fitur baru

Ini sangat berguna untuk polyglot , tetapi dapat diterapkan untuk tantangan lain. Kadang-kadang, bug penyusun dapat memangkas byte, bug implementasi dapat memungkinkan Anda untuk menyimpan beberapa karakter, atau fitur yang benar-benar canggih dapat meningkatkan skor Anda.

Gabungkan banyak / bersarang jika memeriksa menggunakan Dan / Atau bila memungkinkan.

yaitu:

if (a && (b || c)) {

}

dari pada:

if (a) {
    if (b) {
        //Do Stuff
    } elseif (c) {
        //Do same stuff
    }
}

Temukan cara yang lebih baik untuk menginisialisasi variabel Anda

Beberapa jawaban lain hampir menyebutkan hal ini, tetapi dalam banyak bahasa (diketik dengan ketat?), Lebih pendek untuk diinisialisasi xsebagai string kosong seperti:

x:=""

atau xsebagai rune kosong (char) seperti:

x:=''

dari

var x string

dan

var x rune

Menggunakan nilai yang sudah ada sebelumnya jelas lebih disukai, tetapi tidak begitu mudah.