Erweiterte For-Schleife

Teil des Abschnitts Fundamentals der Rust-Journey von Coddy — Lektion 66 von 75.

Es gibt verschiedene Möglichkeiten, über ein Array zu iterieren, hier sind einige davon:
Betrachten wir das folgende Array:

let numbers = [1, 2, 3, 4, 5];

Direkter Iterator:

for num in numbers.iter() {}
// Werte: 1, 2, 3, 4, 5

Index & Value:

for (index, value) in numbers.iter().enumerate() { }
// Werte: (0,1), (1,2), (2,3), (3,4), (4,5)

Slices in bestimmter Größe:
```
for chunk in numbers.chunks(2) { }
// Werte: [1,2], [3,4], [5]
```
Jeder Chunk ist ein slice, sodass Sie Slice-Methoden darauf verwenden können — zum Beispiel gibt chunk.len() zurück, wie viele Elemente sich in diesem Chunk befinden. Der letzte Chunk kann kleiner sein, wenn das Array nicht gleichmäßig teilbar ist.

Sie können .enumerate() auch an .chunks() anhängen, um gleichzeitig einen Index und den Chunk zu erhalten:

for (i, chunk) in numbers.chunks(2).enumerate() { }
// Werte: (0,[1,2]), (1,[3,4]), (2,[5])

Hier erzeugt .chunks(2) zuerst die Slices, und .enumerate() versieht jedes davon mit einem Zähler — sodass i der Chunk-Index und chunk der Slice ist.

Iterieren mit Mutation:

for num in numbers.iter_mut() { 
	*num *= 2;
}
// Array wird zu: [2, 4, 6, 8, 10]

Aufgabe

Einfach

Erstelle ein Programm, das eine Einkaufsliste mit Artikeln und deren Preisen verarbeitet und verschiedene Ansichten der Daten bereitstellt.

Das Programm sollte:

Jede Artikelnummer und den Preis ausgeben (unter Verwendung von enumerate). Formatieren als Item N: $Price (z. B. Item 1: $2.75).
Die Preise paarweise (unter Verwendung von chunks) als "bundle deals" ausgeben. Wenn ein Paket 2 Artikel enthält, gib die Summe aus: Bundle N: $Price1 + $Price2 = $Sum. Wenn es nur 1 Artikel enthält, gib aus: Bundle N: $Price.
Einen Rabatt von 10% auf alle Preise anwenden (unter Verwendung von iter_mut).
Die finalen rabattierten Preise jeweils in einer neuen Zeile ausgeben, formatiert auf 2 Dezimalstellen (z. B. $2.48).

Hint: Du kannst Iteratoren miteinander verketten — zum Beispiel liefert prices.chunks(2).enumerate() sowohl den Chunk-Index als auch den Chunk-Slice auf einmal. Jeder chunk ist ein Slice, sodass du chunk.len() darauf aufrufen und mit chunk[0], chunk[1], etc. darauf zugreifen kannst.

Expected output format for prices:
Verwende ${:.2}, um Preise auf 2 Dezimalstellen zu formatieren.

Probier es selbst

fn main() {
    let mut prices = [2.75, 1.50, 5.00, 3.5, 4.1, 2.25, 7.9];

    println!("Original Prices:");
    // TODO: Verwende enumerate(), um jede Artikelnummer und den Preis auszugeben
    // Hinweis: prices.iter().enumerate() liefert (index, &price)-Paare
    // Formatiere Preise auf 2 Dezimalstellen mit {:.2} — z. B. "Item 1: $2.75"


    println!("\nBundle Deals:");
    // TODO: Verkette chunks(2) und enumerate() miteinander: prices.chunks(2).enumerate()
    // Dies liefert (index, chunk)-Paare — jeder chunk ist ein Slice, also gibt dir chunk.len() seine Größe an
    // If chunk.len() == 2, print: "Bundle 1: $2.75 + $1.50 = $4.25"
    // Wenn chunk.len() == 1, gib aus: "Bundle 4: $7.90"
    // Verwende {:.2}, um alle Preise auf 2 Dezimalstellen zu formatieren


    // TODO: Verwende iter_mut(), um einen 10%-Rabatt auf alle Preise anzuwenden
    // Hinweis: multipliziere jeden *price mit 0.9


    println!("\nPrices after 10% discount:");
    // TODO: Gib jeden rabattierten Preis formatiert auf 2 Dezimalstellen aus
    // Erwartet: "$2.48" usw.

}