Während Rust bei Code-Golf-Wettbewerben sehr, sehr selten wettbewerbsfähig ist (Java ist oft kürzer), kann es dennoch Spaß machen, darin zu golfen. Was sind einige Tricks, um Rust-Code kürzer zu machen?

Bitte posten Sie nur einen Tipp in jeder Antwort.

Verwenden Sie Verschlüsse anstelle von Funktionen

Ein Abschluss:

|n|n+1

ist kürzer als eine Funktion:

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

Schließungen, die länger als eine Anweisung sind, benötigen geschweifte Klammern, sind aber immer noch viel kürzer als eine Funktion.

Vermeiden Sie .iter (). Enumerate ()

Angenommen, Sie haben ein x, das die IntoIterator-Eigenschaft implementiert, und Sie müssen eine Funktion f aufrufen, die den Index eines Elements und einen Verweis darauf verwendet. Die Standardmethode hierfür ist

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

stattdessen kannst du tun

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

und ersparen sie sich nicht nur die ungewöhnlich lange aufzählung, sondern auch den aufruf zum iter!

Wenn Sie viele veränderbare Variablen benötigen, kann dies viel Platz verschwenden, indem Sie sie deklarieren und initialisieren, da für jede Variable das Schlüsselwort mut erforderlich ist und Sie nichts wie a = b = c = 0 tun können. Eine Lösung besteht dann darin, ein veränderliches Array zu deklarieren

let mut a=[0;5];

Sie geben jedes Mal 3 zusätzliche Bytes aus, wenn Sie diese gegen eine normale Variable verwenden:

a[0]+=1;

aber es kann sich oft noch lohnen.

Tupel für den gleichen Trick zu verwenden, ist oft eine noch bessere Option:

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

Dies hat den Vorteil, dass bei jeder Verwendung im Vergleich zum Array ein Byte eingespart wird:

t.0=2

Es können auch verschiedene Typen verwendet werden. Andererseits sind mehr Zeichen für die Initialisierung erforderlich.

Konvertieren &strnachString

Mach niemals diese:

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

Das ist immer kürzer:

s.repeat(1)    // 11 bytes

Wenn sist ein String-Literal:

format!(s)     // 10 bytes

Beispiel: Verwenden Sie format!("")anstelle von String::new(), um 2 Bytes zu speichern.

Wenn die Typinferenz funktioniert:

s.into()       // 8 bytes

Wenn Sie beispielsweise die Formatierung von Zeichenfolgen mit verwenden print!(), können Sie sowohl nummerierte als auch nicht nummerierte Formatierer verwenden, um ein Byte pro Element für die Formatierung zu speichern:

Am besten anhand eines Beispiels:

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

Welche Ausgänge:

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

Die nicht nummerierten Formatierer werden den Elementen in der angegebenen Reihenfolge zugewiesen. Auf diese Weise können Sie den Index für diese Elemente überspringen. Beachten Sie, dass Sie nur ein nicht nummeriertes Formatierungsprogramm pro Element zum Formatieren verwenden können. Danach wird es aufgebraucht.

Zeilen lesen

Nachdem ich verschiedene Dinge bedacht habe, denke ich, dass dies im Allgemeinen der kürzeste Weg ist, um eine Zeile abzurufen. Die Linie hat eine neue Linie. Sie kann durch Trimmen ( .trim()) oder durch Schneiden entfernt werden.

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

Für mehrere Zeilen kann ein linesIterator verwendet werden, die iterierte Zeile endet dann nicht in einer neuen Zeile. Ein glob Import wird Import benötigt BufRead, benötigt für linesfür verfügbar sein StdinLock<'_>Typ.

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

Überspringen von nachgestellten Semikolons

In zurückgegebenen Funktionen (), bei denen der letzte Ausdruck ebenfalls vom Typ ist (), brauchen Sie das Nachstellen nicht ;:

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

Wenn Sie mit Zeichenfolgen mit Zeilenumbrüchen arbeiten, sparen Sie ein Byte, wenn Sie im Quellcode einen wörtlichen Zeilenumbruch verwenden, im Gegensatz zu einem \nin der Zeichenfolge.

println!("Hello
World!");

ist 1 Byte kleiner als:

println!("Hello\nWorld!);

Wenn Sie Gleitkommazahlen mit ganzen Zahlen verwenden, können Sie das Trailing weglassen .0, um ein Byte zu sparen.

let a=1.

ist 1 Byte kleiner als:

let a=1.0