Walaupun Rust sangat, sangat jarang bersaing dalam kompetisi kode golf (Jawa seringkali lebih pendek), Rust masih bisa menyenangkan untuk bermain golf. Apa saja trik untuk membuat kode Rust lebih pendek?

Silakan posting hanya satu tip di setiap jawaban.

Gunakan penutupan bukan fungsi

Penutupan:

|n|n+1

lebih pendek dari suatu fungsi:

fn f(n:i32)->i32{n+1}

Penutupan yang lebih panjang dari satu pernyataan membutuhkan kawat gigi tetapi masih jauh lebih pendek dari fungsi.

Hindari .iter (). Enumerate ()

Katakanlah Anda memiliki beberapa x yang mengimplementasikan IntoIterator Trait dan Anda perlu memanggil fungsi f yang mengambil indeks elemen dan referensi untuknya. Cara standar untuk melakukan ini adalah

x.iter().enumerate().map(f)

Anda bisa melakukannya

(0..).zip(x).map(f)

dan selamatkan diri Anda tidak hanya karena pencacahan yang luar biasa panjang, tetapi juga panggilan untuk melakukannya!

Jika Anda memerlukan banyak variabel yang dapat diubah, ini dapat membuang banyak ruang untuk mendeklarasikannya dan menginisialisasi mereka, karena masing-masing membutuhkan kata kunci mut dan Anda tidak dapat melakukan apa pun seperti a = b = c = 0. Solusi kemudian adalah mendeklarasikan array yang bisa berubah

let mut a=[0;5];

Anda menghabiskan 3 byte tambahan setiap kali Anda menggunakannya vs variabel normal:

a[0]+=1;

tetapi seringkali masih bisa sia-sia.

Menggunakan tuple untuk trik yang sama seringkali merupakan pilihan yang lebih baik:

let mut t=(1,4,"this", 0.5, 'c');

Ini memiliki keuntungan menyimpan byte pada setiap penggunaan vs. array:

t.0=2

Ini juga memungkinkan mereka dari berbagai jenis. Pada sisi negatifnya, ini membutuhkan lebih banyak karakter untuk diinisialisasi.

Konversi &strkeString

Tidak pernah melakukan ini:

s.to_string()  // 13 bytes
s.to_owned()   // 12 bytes

Ini selalu lebih pendek:

s.repeat(1)    // 11 bytes

Jika sstring literal:

format!(s)     // 10 bytes

Misalnya: gunakan format!("")alih-alih String::new()menyimpan 2 byte.

Jika inferensi tipe berfungsi:

s.into()       // 8 bytes

Ketika menggunakan pemformatan string misalnya dengan print!(), seseorang dapat menggunakan pemformat bernomor dan tidak bernomor untuk menyimpan satu byte per item ke format:

Terbaik ditunjukkan dengan contoh:

fn main(){
    print!("{}{}{}. Yes, {0}{}{2}. All you other{1}{2}s are just imitating.",
           "I'm",
           " Slim",
           " Shady",
           " the real");
}

Output yang mana:

I'm Slim Shady. Yes, I'm the real Shady. All you other Slim Shadys are just imitating.

Jadi pemformat yang tidak bernomor akan ditugaskan ke item secara berurutan, ini memungkinkan Anda untuk melompati indeks. Perhatikan bahwa Anda hanya dapat menggunakan satu formatter yang tidak bernomor per item untuk diformat, setelah itu akan digunakan.

Membaca garis

Setelah mempertimbangkan berbagai hal, saya pikir itu umumnya cara terpendek untuk mengambil garis. Baris memiliki baris baru, dapat dihapus dengan pemangkasan ( .trim()) atau jika itu tidak dapat dilakukan dengan memotong.

let y=&mut"".into();std::io::stdin().read_line(y);

Untuk beberapa baris, linesiterator dapat digunakan, garis iterated tidak berakhir di baris baru. Impor bola diperlukan untuk mengimpor BufRead, diperlukan linesagar tersedia untuk StdinLock<'_>jenis.

use std::io::*;let y=stdin();y.lock().lines()

Melewati titik koma

Dalam fungsi-fungsi yang mengembalikan (), di mana ekspresi terakhir juga bertipe (), Anda tidak perlu mengikuti ;:

fn main(){print!("Hello, world!")}

Ketika bekerja dengan string dengan baris baru di dalamnya, Anda menyimpan satu byte jika Anda menggunakan pemecah baris literal dalam kode sumber vs memiliki \ndalam string.

println!("Hello
World!");

kurang dari 1 byte:

println!("Hello\nWorld!);

Saat menggunakan seluruh angka angka floating point, Anda bisa menghilangkan trailing .0untuk menyimpan satu byte.

let a=1.

kurang dari 1 byte:

let a=1.0