CodeUtility
Mach dir das Coderleben leicht!

Online Rust Compiler

Write, compile, run, and debug Rust code online in a full-featured browser IDE. Work with multiple files, save your workspace, and share or collaborate in real time.

Vorinstallierte Bibliotheken
🚀 252,702 Gesamt-Ausführungen (135 diesen Monat)
Einbetten
Ausgabe

Übe Rust mit Coding Challenges

Löse praktische Aufgaben direkt im Editor: Führe die Beispieltests aus, reiche ein und erhalte ein KI-Code-Review.

Alle Rust-Challenges
Einfach

Rechteck-Umfang

Berechne den Umfang eines Rechtecks anhand seiner Seiten.

Du lernst ArithmetikRückgabewerte
BeginnerLearning-pathVariables
Python C++ C# Java JavaScript Go Rust Kotlin Swift
12 gelöst
Lösungen anzeigen (12)
Einfach

Distance Between Points

Compute the straight-line distance between two points.

Du lernst Satz des PythagorasQuadratwurzeln
BeginnerFunctionsLearning-pathmath
Python C++ C# Swift Java JavaScript Go Rust Kotlin
7 gelöst
Lösungen anzeigen (7)
Einfach

Days in a Month

Return how many days a month has, including leap years.

Du lernst KalenderregelnHilfsfunktionen
BeginnerConditionsFunctionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
6 gelöst
Lösungen anzeigen (6)
Einfach

Average of Three

Average three whole numbers.

Du lernst ArithmetikDivision
BeginnerLearning-pathVariables
Python C++ C# Java JavaScript Go Rust Kotlin Swift
6 gelöst
Lösungen anzeigen (6)
Einfach

Skalarprodukt zweier Vektoren

Multipliziere zwei Vektoren elementweise und addiere die Ergebnisse, die Kernoperation jedes Neurons.

Du lernst VektorenSkalarprodukt
Neuronale Netzeaimaschinelles Lernen
Python C++ C# Java JavaScript Go Rust Kotlin Swift
4 gelöst
Lösungen anzeigen (4)
Einfach

Das Größte von Drei

Finde die größte von drei Zahlen ohne eingebaute Maximalfunktion.

Du lernst VergleicheBedingungen kombinieren
BeginnerConditionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
4 gelöst
Lösungen anzeigen (4)
Einfach

Primzahl-Prüfung

Entscheide, ob eine Zahl eine Primzahl ist.

Du lernst TeilbarkeitSchleifen optimieren
BeginnerLoopsNumbersStudent-beginner
Kotlin Swift Python C++ C# Java JavaScript Go Rust
3 gelöst
Lösungen anzeigen (3)
Einfach

Number Triangle

Build a triangle of increasing numbers.

Du lernst Wachsende ZeilenZähler über Zeilen
BeginnerLearning-pathNested-loopsPatterns
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 gelöst
Lösungen anzeigen (3)
Einfach

Armstrong-Zahl

Prüfe, ob eine Zahl gleich der Summe ihrer Ziffern ist, wobei jede Ziffer auf die Anzahl der Ziffern potenziert wird.

Du lernst Ziffern extrahierenPotenzen
BeginnerNumbersStudent-beginner
JavaScript Python C++ C# Java Go Rust Kotlin Swift
3 gelöst
Lösungen anzeigen (3)
Einfach

Row Sums

Add up every row of a grid.

Du lernst 2D-ListenVerschachtelte Schleifen
BeginnerGridsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 gelöst
Lösungen anzeigen (3)
Einfach

Min and Max Together

Find the smallest and largest value in one pass.

Du lernst Ein DurchlaufMehrere Rückgabewerte
ArraysBeginnerFunctionsLearning-path
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 gelöst
Lösungen anzeigen (3)
Einfach

Count Pairs With a Sum

Count pairs of positions whose values add up to a target.

Du lernst IndexpaareDoppelzählung vermeiden
ArraysBeginnerLearning-pathNested-loops
Python C++ C# Java JavaScript Go Rust Kotlin Swift
3 gelöst
Lösungen anzeigen (3)

🦀 Über diesen Rust-Online-Executor

Der CodeUtility Rust Executor ermöglicht es dir, Rust-Code direkt in deinem Browser zu schreiben und auszuführen - keine Installation, kein Toolchain-Setup und keine lokale Umgebung nötig. Er wird von einer sicheren Sandbox betrieben, die echte Rust-Compiler-Versionen 1.70, 1.72, 1.73 und 1.74 unterstützt.

Dieses Tool kompiliert und führt deine Rust-Programme in der Cloud mit einem echten rustc-Compiler aus, was genaue und konsistente Ergebnisse sicherstellt. Du kannst ganz einfach mit Variablen, Ownership, Borrowing, Pattern Matching, Traits, Generics und anderen modernen Rust-Features experimentieren.

Es eignet sich ideal, um die Kernkonzepte von Rust zu lernen - insbesondere Speichersicherheit, Fehlerbehandlung und Nebenläufigkeit - ganz ohne Cargo-Installation oder lokale Einrichtung. Alles läuft in Sekunden direkt in deinem Browser.

Mehr als nur ein Code-Runner

Nutzen Sie im selben Executor einen Editor für mehrere Dateien, ein isoliertes Ausführungsterminal, laufzeitspezifische Bibliotheken, persistente Arbeitsbereiche, Freigaben und Zusammenarbeit in Echtzeit.

Wie verwende ich diesen Executor?

Wählen Sie eine Laufzeit aus, öffnen oder erstellen Sie eine Datei, schreiben Sie Ihren Code und wählen Sie Ausführen. Die Ausgabe erscheint im Terminal. Angemeldete Benutzer können Dateien in einem Arbeitsbereich speichern, Bibliotheken installieren und über Freigaben zusammenarbeiten.

  1. Wählen Sie eine Version aus und bearbeiten Sie die aktuelle Datei oder öffnen Sie eine andere Datei aus dem Arbeitsbereich.
  2. Führen Sie den Code aus, geben Sie bei Aufforderung Daten im Terminal ein und prüfen Sie den gespeicherten Ausführungsverlauf.
  3. Nutzen Sie Bibliotheken, Arbeitsbereichswerkzeuge, Freigaben und den Chat, wenn Ihre Aufgabe mehr als ein einzelnes Codefragment erfordert.

💡 Rust-Grundlagen & Beispiele, die du oben ausprobieren kannst

1. Variablen und Konstanten deklarieren

Verwende let, um Variablen zu deklarieren. Verwende const für Konstanten und mut für veränderliche Variablen.

let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;

const MAX_USERS: u32 = 100;

2. Bedingungen (if / match)

Rust verwendet if für Bedingungen und match für Pattern Matching.

let x = 2;
if x == 1 {
    println!("Eins");
} else if x == 2 {
    println!("Zwei");
} else {
    println!("Sonstiges");
}

match x {
    1 => println!("Eins"),
    2 => println!("Zwei"),
    _ => println!("Sonstiges"),
}

3. Schleifen

Rust unterstützt for, while und die unendliche Schleife loop.

for i in 0..3 {
    println!("{}", i);
}

let mut n = 3;
while n > 0 {
    println!("{}", n);
    n -= 1;
}

4. Arrays

Arrays fester Größe in Rust verwenden eckige Klammern. Verwende Slices für Ansichten.

let nums = [10, 20, 30];
println!("{}", nums[1]);

5. Vektoren (dynamische Arrays)

Vec wird für dynamische Arrays verwendet.

let mut fruits = vec!["apple", "banana"];
fruits.push("cherry");
fruits.pop();

for fruit in &fruits {
    println!("{}", fruit);
}

6. Konsolen-Ein-/Ausgabe

Verwende println! für Ausgaben und std::io für Eingaben.

use std::io;

let mut name = String::new();
println!("Gib deinen Namen ein:");
io::stdin().read_line(&mut name).unwrap();
println!("Hallo, {}", name.trim());

7. Funktionen

Funktionen verwenden fn und können mit -> Werte zurückgeben.

fn greet(name: &str) -> String {
    format!("Hallo, {}", name)
}

println!("{}", greet("Alice"));

8. HashMaps

Verwende std::collections::HashMap für Schlüssel-Wert-Daten.

use std::collections::HashMap;

let mut person = HashMap::new();
person.insert("name", "Bob");
println!("{}", person["name"])

9. Fehlerbehandlung

Rust behandelt Fehler mit Result und match oder unwrap().

fn fail() -> Result<(), String> {
    Err("Etwas ist schiefgelaufen".to_string())
}

match fail() {
    Ok(_) => println!("Erfolg"),
    Err(e) => println!("{}", e),
}

10. Datei-Ein-/Ausgabe

Verwende std::fs zum Lesen und Schreiben von Dateien.

use std::fs;

fs::write("file.txt", "Hello File").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);

11. String-Verarbeitung

Strings in Rust liegen auf dem Heap und unterstützen viele Methoden.

let mut text = String::from(" Hello Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Hello", "Hi");
println!("{}", text);

12. Structs & Methoden

Rust verwendet struct für Datentypen und impl für Methoden.

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) -> String {
        format!("Hi, ich bin {}", self.name)
    }
}

let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());

13. Referenzen & Borrowing

Rust verwendet & zum Borrowing von Werten und &mut für veränderliche Referenzen.

fn update(x: &mut i32) {
    *x += 1;
}

let mut value = 10;
update(&mut value);
println!("{}", value);