Kadang-kadang, saat bermain golf, seseorang harus mewakili sejumlah besar kode mereka. Menulisnya apa adanya dapat secara signifikan meningkatkan byte-count.

Apa ¹ tips umum yang Anda miliki untuk mewakili angka panjang secara ringkas dalam kode?

Silakan kirim satu tip per jawaban.

¹ Dengan umum , maksud saya tip yang dapat diterapkan ke lebih dari satu bahasa. Untuk kiat khusus bahasa, poskan di utas masing-masing.

Carilah nomor khusus

Beberapa bahasa memiliki fungsi bawaan untuk kuadrat, eksponensial dengan basis 2, perdana ke- n , faktorial, atau prosedur lain yang dapat menghasilkan angka besar. Periksa apakah nomor Anda termasuk dalam kategori mana pun.

Dan jika tidak, mungkin saja angka yang lebih besar cocok untuk keperluan Anda dan dapat digunakan sebagai gantinya.

Gunakan operator boolean bitwise

Beberapa bahasa memiliki bitwise AND, OR, XOR, dan kadang-kadang TIDAK.

Mengekspresikan angka besar tertentu sebagai kombinasi bitwise dari hasil eksponensial atau shift kiri dan nomor lain dapat membuat Anda tepat angka yang Anda butuhkan. Ini biasanya hanya sepadan jika jumlahnya menjadi cukup besar.

Sebagai contoh, 2147483722adalah 10 byte, tetapi 2<<30^74(2 ^ 31 bitwise-XORed dengan 74) hanya 8.

Gunakan String untuk angka berulang

Untuk bilangan yang sangat berulang, Anda bisa menggunakan string dan melemparkannya ke Integer. Misalnya, dalam JavaScript

+"1".repeat(100) // returns 100 1s (saves 84 bytes!)

Gunakan Notasi Ilmiah

Notasi ilmiah dapat menghemat byte jika nomor panjang. Sebagai contoh:

3564e-8 // returns 0.00003564 (saves 3 bytes!)

Cari nomor lain untuk digunakan

Ini mungkin terdengar seperti bukan jawaban, tetapi tidak selalu jelas bahwa angka yang lebih besar dapat dihitung dengan kode yang lebih pendek. Contoh yang saya ingat adalah Keluaran salinan googol dari string , di mana jawaban yang jelas membutuhkan komputasi 10 ¹⁰⁰ . Ternyata, menghitung kelipatan 10 ¹⁰⁰ mengarah ke jawaban yang sama benarnya, tetapi dalam beberapa bahasa, jawaban yang lebih pendek. Jawaban Dennis di sana menggunakan 100 ¹⁰⁰ , saya sendiri menggunakan 250 ²⁵⁵ .

Kompresi Dasar

Kode dekompresi basis bisa sangat kompleks, tetapi jika Anda memiliki jumlah yang sangat besar kadang-kadang dapat membantu untuk mengompresnya di beberapa basis yang lebih tinggi dari 10.

Ini juga membantu bahwa dalam beberapa bahasa, kode kompresi dasar sangat sederhana. Sebagai contoh, PHP memiliki base64_decode(_), Python memiliki int(_,36), JavaScript parseInt(_,36), dan banyak bahasa golf memiliki built-in dekompresi dasar. Misalnya, dalam CJam:

"+ÜTbô±"256b

Ini mengandung yang tidak patut dicetak. Cobalah online!

Ini menghasilkan:

12345678987654321

Gunakan pecahan eksponensial untuk angka berulang yang besar

Katakanlah Anda ingin menghasilkan angka yang terbuat dari 100 1. Anda dapat menggunakan int("1"*100),, +"1".repeat(100)dll. Tetapi Anda juga dapat memanfaatkan fakta bahwa itu sangat dekat

1e100/9

Ini bekerja paling baik untuk angka yang sangat berulang, seperti yang terbuat dari satu digit. Beberapa digit berulang juga bekerja dengan cukup baik:

12e100/99  // Generates 121212121212... (100 digits)

Kadang-kadang Anda akan menemukan beberapa pola aneh lainnya yang juga dapat direpresentasikan dengan cukup singkat dalam metode ini. Jika kebetulan Anda membutuhkan int("123456790"*11), misalnya:

1e100/81

Namun berhati-hatilah: angka-angka seperti int("1234567890"*10)tidak memiliki representasi yang mudah.

Gunakan Bitwise Left Shift untuk eksponensial 2

Meskipun, ada banyak bahasa yang mendukung operator untuk eksponensial, beberapa tidak. Dan yang tidak, biasanya memerlukan fungsi panggilan (atau metode Kelas / Objek), yang dapat menelan biaya beberapa byte.

Tetapi Anda dapat menghemat beberapa byte saat Anda perlu menaikkan 2 ke daya n dengan menggunakan operator Bitwise Left Shift <<sebagai 1<<n. Perhatikan bahwa ini hanya akan menghemat byte jika n lebih besar atau sama dengan 17. Namun, ini akan selalu menghemat byte jika n dinamis. Beberapa contoh:

1<<2 // returns 4 (3 bytes more :( )
1<<3 // returns 8 (3 bytes more :( )
1<<6 // returns 64 (2 bytes more :( )
1<<14 // returns 16384 (no bytes saved)
1<<17 // returns 131072 (saves 1 byte!)
1<<18 // returns 262114 (saves 1 byte!)

Teorema Sisa Tiongkok

Jika bilangan bulat besar yang sewenang-wenang sering muncul, atau representasi bilangan bulat besar dalam bahasa pemrograman target menghabiskan terlalu banyak byte, Anda dapat mempertimbangkan menggunakan Teorema Sisa Bahasa Cina.

Pilih beberapa bilangan bulat relatif prima m _i > = 2, dan Anda dapat mengekspresikan angka besar dari 0 hingga lcm (m ₁ , m ₂ , ..., m _i ) -1

Misalnya, saya memilih 2, 3, 5, 11, 79, 83, 89, 97, maka saya dapat mengungkapkan angka kurang dari 18680171730 secara unik. 10000000000 (1e10) dapat dinyatakan sebagai 0,1,0,1,38,59,50,49 (1e10 mod 2, 3 ..., 97) yang tidak perlu dinyatakan sebagai kelas / struct Big Integer khusus yang mungkin menghemat beberapa byte dalam beberapa bahasa pemrograman.

Penambahan dan substraksi dapat dilakukan secara langsung menggunakan representasi ini. Contoh:

(0,1,0,1,38,59,50,49)+(0,2,0,6,23,20,16,53) = 1e10 + 5000 
                                            = (0+0 mod 2, 1+2 mod 3, 0+0 mod 5, 1+6 mod 11, 38+23 mod 79, 59+20 mod 83, 50+16 mod 89, 49+53 mod 97)

Gunakan String Padding (jika memungkinkan)

Jika sejumlah besar menyertakan digit berulang di awal atau akhir, Anda mungkin dapat menyimpan byte dengan menggunakan salah satu metode padding bahasa Anda untuk membangun string nomor yang Anda cari, yang kemudian dapat Anda konversi menjadi bilangan bulat.

Contoh

Untuk menghasilkan angka 1111111111111111111111112(25 byte) dalam JavaScript (ES8):

+"2".padStart(25,1) // 19 bytes

Gunakan Eksponen

Jika bahasa Anda memiliki operator eksponen, Anda mungkin dapat menggunakannya untuk menghasilkan, jika bukan angka yang Anda inginkan, setidaknya angka yang dapat Anda lakukan dengan perhitungan sederhana atau 2 angka untuk sampai pada nomor Anda. Bahkan tanpa operator, Anda mungkin masih bisa menyimpan byte dengan fungsi atau metode bawaan.

Contoh

The bilangan bulat aman maksimum dalam JavaScript adalah 9007199254740991, yang merupakan 16 digit. Dalam ES7, ini dapat dihitung dengan 7 byte berikut:

2**53-1

Persamaan dalam ES6 dan sebelumnya, sementara panjang yang sama dengan bilangan bulat itu sendiri dalam contoh ini, menunjukkan bahwa menggunakan metode yang lebih verbose mungkin tidak perlu biaya byte.

Math.pow(2,53)-1

Meskipun demikian, hal di atas dapat bekerja lebih pendek jika, misalnya, Anda telah memiliki Mathalias karakter tunggal di tempat lain dalam kode Anda.

Gunakan pecahan sebagai pengganti float

Contoh: 1./3sebagai pengganti0.333333333