Alors que Rust est très, très rarement compétitif dans les compétitions de golf à code (Java est souvent plus court), il peut toujours être amusant de jouer au golf. Quelles sont quelques astuces pour raccourcir le code à Rust?

Veuillez ne poster qu'un seul conseil dans chaque réponse.

Utilisez des fermetures plutôt que des fonctions

Une fermeture:

|n|n+1

est plus courte qu'une fonction:

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

Les fermetures plus longues qu'une instruction nécessitent des accolades mais sont encore beaucoup plus courtes qu'une fonction.

Évitez .iter (). Enumerate ()

Disons que vous avez un x qui implémente le caractère IntoIterator et que vous devez appeler une fonction f qui prend l'index d'un élément et une référence à celui-ci. La façon standard de le faire est

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

à la place, vous pouvez faire

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

et sauvez-vous non seulement l'énumération inhabituellement longue, mais aussi l'appel à iter!

Si vous avez besoin de nombreuses variables mutables, cela peut gaspiller beaucoup d'espace pour les déclarer et les initialiser, car chacune nécessite le mot-clé mut et vous ne pouvez rien faire comme a = b = c = 0. Une solution consiste alors à déclarer un tableau mutable

let mut a=[0;5];

Vous dépensez 3 octets supplémentaires chaque fois que vous les utilisez par rapport à une variable normale:

a[0]+=1;

mais cela peut souvent en valoir la peine.

L'utilisation de tuples pour la même astuce est souvent une meilleure option:

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

Cela a l'avantage d'économiser un octet à chaque utilisation par rapport au tableau:

t.0=2

Il leur permet également d'être de différents types. En revanche, il nécessite plus de caractères pour s'initialiser.

Conversion &strenString

Ne faites jamais ça:

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

C'est toujours plus court:

s.repeat(1)    // 11 bytes

Si sest un littéral de chaîne:

format!(s)     // 10 bytes

Par exemple: utilisez format!("")au lieu de String::new()pour enregistrer 2 octets.

Si l'inférence de type fonctionne:

s.into()       // 8 bytes

Lors de l'utilisation du formatage de chaîne, par exemple avec print!(), on peut utiliser à la fois des formateurs numérotés et non numérotés pour enregistrer un octet par élément à formater:

Mieux illustré avec un exemple:

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

Quelles sorties:

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

Ainsi, les formateurs non numérotés seront attribués aux éléments dans l'ordre, cela vous permet de sauter l'index sur eux. Notez que vous ne pouvez utiliser qu'un seul formateur non numéroté par élément à formater, après quoi il sera utilisé.

Lignes de lecture

Après avoir considéré diverses choses, je pense que c'est généralement le moyen le plus court pour récupérer une ligne. La ligne a une nouvelle ligne, elle peut être supprimée par rognage ( .trim()) ou si cela ne peut pas être fait par découpage.

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

Pour plusieurs lignes, l' linesitérateur peut être utilisé, la ligne itérée ne se termine pas alors par une nouvelle ligne. Une importation globale est nécessaire pour importer BufRead, nécessaire pour linesêtre disponible pour le StdinLock<'_>type.

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

Sauter les points-virgules de fin

Dans les fonctions renvoyant (), où la dernière expression est également de type (), vous n'avez pas besoin de la fin ;:

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

Lorsque vous travaillez avec des chaînes contenant des sauts de ligne, vous enregistrez un octet si vous utilisez un saut de ligne littéral dans le code source par rapport à un \ndans la chaîne.

println!("Hello
World!");

est inférieur de 1 octet à:

println!("Hello\nWorld!);

Lorsque vous utilisez des nombres à virgule flottante entiers, vous pouvez omettre la fin .0pour enregistrer un octet.

let a=1.

est inférieur de 1 octet à:

let a=1.0