- Ausführende
-
Lernen
Python lernen Ausführbare Beispiele, NumPy, pandas und mehr KI lernenNeuronale Netze, ML und LLMs von Grund auf C/C++ lernen Zeiger, Speicher, STL und modernes C++ C# lernenC#-Grundlagen, OOP, LINQ, Async und .NET-Übungen Matplotlib lernenLinien-, Balken-, Streu- und Kreisdiagramme mit interaktiven Visualisierungen Python-Algorithmen Suche, Sortierung, Rekursion und Visualisierungen O(n) C/C++-Algorithmen Implementierungen in C und C++ vergleichen Programmieren für Kinder Spielend programmieren lernen!
- AufgabenNeu
- Für LehrkräfteNeu
- Aktualisierungen
- Spendier mir einen Kaffee
Q-Learning lernt allein aus Erfahrung, wie gut jede Aktion in jedem Zustand ist, Q(s, a). Nachdem in Zustand s die Aktion a ausgeführt, reward erhalten und Zustand s' erreicht wurde:
- target = reward, wenn die Episode endete (
done= 1) - target = reward + gamma × Maximum über a' von Q(s', a'), sonst
- Q(s, a) ← Q(s, a) + alpha × (target - Q(s, a))
Beginne mit allen Q-Werten bei 0 und wende die Übergänge der Reihe nach an.
Implementiere q_learning(num_states, num_actions, transitions, alpha, gamma).
Eingabe
num_states, num_actions: Die Größe der Tabelle.
transitions: Eine Zeile [state, action, reward, next_state, done] pro Schritt.
alpha: Die Lernrate.
gamma: Der Diskontfaktor.
Ausgabe
Gib die Q-Tabelle als Matrix mit einer Zeile pro Zustand und einer Spalte pro Aktion zurück.
Einschränkungen
1 ≤ num_states, num_actions ≤ 100, 0 ≤ Anzahl der Übergänge ≤ 10.000
-100 ≤ reward ≤ 100, done ist 0 oder 1
0 < alpha ≤ 1, 0 ≤ gamma ≤ 1
Beispiele
Beispiel 1
Eingabe:
num_states = 2
num_actions = 2
transitions = [
[0, 1, 0, 1, 0],
[1, 0, 10, 0, 1]
]
alpha = 0.5
gamma = 0.9
Erwartete Ausgabe:
[
[0.0, 0.0],
[5.0, 0.0]
]Erläuterung
Der erste Schritt findet noch keine Belohnung: target = 0 + 0.9 × max(Q[1]) = 0, also bleibt Q[0][1] bei 0. Der zweite Schritt beendet die Episode mit Belohnung 10: Q[1][0] = 0 + 0.5 × (10 - 0) = 5.
Beispiel 2
Eingabe:
num_states = 2
num_actions = 2
transitions = [
[1, 0, 10, 0, 1],
[0, 1, 0, 1, 0]
]
alpha = 0.5
gamma = 0.9
Erwartete Ausgabe:
[
[0.0, 2.25],
[5.0, 0.0]
]Erläuterung
Dieselben Schritte in umgekehrter Reihenfolge. Q[1][0] wird zuerst 5, also sieht der Schritt aus Zustand 0 diesen Wert: target = 0 + 0.9 × 5 = 4.5 und Q[0][1] = 0.5 × 4.5 = 2.25. Die Belohnung ist einen Zustand zurückgeflossen.
Referenzen
-
Beispiel 1 Nicht ausgeführtEingabe:
num_states = 2 num_actions = 2 transitions = [ [0, 1, 0, 1, 0], [1, 0, 10, 0, 1] ] alpha = 0.5 gamma = 0.9Erwartete Ausgabe:[ [0.0, 0.0], [5.0, 0.0] ]Deine Ausgabe -
Beispiel 2 Nicht ausgeführtEingabe:
num_states = 2 num_actions = 2 transitions = [ [1, 0, 10, 0, 1], [0, 1, 0, 1, 0] ] alpha = 0.5 gamma = 0.9Erwartete Ausgabe:[ [0.0, 2.25], [5.0, 0.0] ]Deine Ausgabe
4 versteckte Tests werden beim Einreichen ebenfalls ausgeführt. Scheitert dein Code an einem, siehst du diesen Test. Löse die Aufgabe, um alle zu sehen.
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.
🚀 252,702 Gesamt-Ausführungen (135 diesen Monat)
Ü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.
🦀 Ü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.
- Wählen Sie eine Version aus und bearbeiten Sie die aktuelle Datei oder öffnen Sie eine andere Datei aus dem Arbeitsbereich.
- Führen Sie den Code aus, geben Sie bei Aufforderung Daten im Terminal ein und prüfen Sie den gespeicherten Ausführungsverlauf.
- 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);