Rust kod golf yarışmalarında çok nadiren rekabetçi olmasına rağmen (Java genellikle daha kısadır), golf oynamak yine de eğlenceli olabilir. Rust kodunu kısaltmak için bazı püf noktaları nelerdir?

Lütfen her cevapta yalnızca bir ipucu gönderin.

İşlevler yerine kapakları kullanın

Bir kapatma:

|n|n+1

bir işlevden daha kısa:

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

Bir ifadeden daha uzun olan kapaklar için braketler gerekir, ancak yine de bir fonksiyondan çok daha kısadır.

.İter (). Numaralandırmaktan kaçının ().

Diyelim ki IntoIterator Özelliği'ni uygulayan bir x'iniz var ve bir öğenin indeksini alan bir f işlevini çağırmanız gerekiyor ve buna bir başvuru. Bunu yapmanın standart yolu

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

onun yerine yapabilirsin

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

ve sadece alışılmadık uzun sayımları değil, aynı zamanda iter çağrısını da kurtarın!

Değişken değişkenlere ihtiyacınız varsa, her biri mut anahtar sözcüğünü gerektirdiği ve a = b = c = 0 gibi bir şey yapamayacağınız için bunları bildirmek ve bunları başlatmak için çok fazla alan harcar. Öyleyse çözüm, değişken bir dizi bildirmektir.

let mut a=[0;5];

Normal bir değişkene karşı her kullanışınızda 3 ekstra bayt harcarsınız:

a[0]+=1;

ama yine de buna değer olabilir.

Aynı numara için tüfek kullanmak genellikle daha iyi bir seçenektir:

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

Bu, diziye karşı her kullanımda bir bayt kaydetme avantajına sahiptir:

t.0=2

Aynı zamanda farklı türlerde olmalarına izin verir. Olumsuz tarafı, başlatmak için daha fazla karakter gerektirir.

dönüştürme &str içinString

Asla bunları yapmayın:

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

Bu daima daha kısadır:

s.repeat(1)    // 11 bytes

Eğer sbir dize değişmezi geçerli:

format!(s)     // 10 bytes

Örneğin: kullan format!("")String::new() 2 bayt kaydetmek yerine .

Yazı çıkarımı çalışıyorsa:

s.into()       // 8 bytes

Örneğin, dize biçimlendirmesi kullanılırken print!() , biçimlendirilecek öğe başına bir bayttan tasarruf etmek için numaralandırılmış ve numaralandırılmamış biçimlendiriciler kullanılabilir:

En iyi örnekle gösterilmiştir:

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

Hangi çıktılar:

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

Böylece numaralandırılmamış biçimlendiriciler sırayla öğelere atanır, bu, dizini üstlerine atlamanızı sağlar. Biçimlendirmek için her öğe için yalnızca bir numaralandırılmamış biçimlendirici kullanabileceğinizi unutmayın, bundan sonra bitecektir.

Satırları okumak

Çeşitli şeyleri düşündükten sonra, bunun bir hat almanın en kısa yolu olduğunu düşünüyorum. Çizginin yeni bir çizgisi vardır, kırparak ( .trim()) çıkarılabilir veya dilimleme ile yapılamazsa.

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

Birden çok satır için, linesyineleyici kullanılabilir, yinelenen satır daha sonra newline ile bitmez. Alınması için bir glob içe aktarması gerekiyor BufRead, tür linesiçin kullanılabilir olması gerekiyordu StdinLock<'_>.

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

Sondaki noktalı virgülleri atlama

Dönen (), son ifadenin de tür olduğu işlevlerde (), izlemeye gerek kalmaz ;:

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

İçinde yeni satır bulunan dizelerle çalışırken, kaynak kodda değişmez satır sonu varsa \ndizgede bir tane varsa, bir bayttan tasarruf edin .

println!("Hello
World!");

şundan 1 bayt daha az:

println!("Hello\nWorld!);

Tam sayı kayan nokta sayılarını kullanırken, .0bir bayttan tasarruf etmek için sonunu atlayabilirsiniz .

let a=1.

şundan 1 bayt daha az:

let a=1.0