Loop For Aprimorado

Parte da seção Fundamentals do Journey de Rust da Coddy — lição 66 de 75.

Existem diferentes maneiras de iterar sobre um array, aqui estão algumas delas:
Considere o seguinte array:

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

Iterador Direto:

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

Índice & Valor:

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

Fatias (slices) de tamanho específico:
```
for chunk in numbers.chunks(2) { }
// Valores: [1,2], [3,4], [5]
```
Cada chunk é uma fatia (slice), então você pode usar métodos de slice nele — por exemplo, chunk.len() retorna quantos elementos estão naquele chunk. O último chunk pode ser menor se o array não for dividido igualmente.

Você também pode encadear .enumerate() em .chunks() para obter tanto um índice quanto o chunk ao mesmo tempo:

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

Aqui, .chunks(2) produz as fatias primeiro, e depois .enumerate() envolve cada uma com um contador — então i é o índice do chunk e chunk é a fatia.

Iterate com mutação:

for num in numbers.iter_mut() { 
	*num *= 2;
}
// O array se torna: [2, 4, 6, 8, 10]

Desafio

Fácil

Crie um programa que processe uma lista de compras com itens e seus preços, e forneça diferentes visualizações dos dados.

O programa deve:

Imprimir o número de cada item e o preço (usando enumerate). Formatado como Item N: $Price (ex.: Item 1: $2.75).
Imprimir os preços em pares (usando chunks) como "ofertas de pacote" ("bundle deals"). Se um pacote tiver 2 itens, imprima a soma: Bundle N: $Price1 + $Price2 = $Sum. Se tiver apenas 1 item, imprima: Bundle N: $Price.
Aplicar um desconto de 10% a todos os preços (usando iter_mut).
Imprimir os preços com desconto finais, cada um em uma nova linha, formatados com 2 casas decimais (ex.: $2.48).

Dica: Você pode encadear iteradores juntos — por exemplo, prices.chunks(2).enumerate() fornece tanto o índice do bloco quanto a fatia (slice) do bloco de uma só vez. Cada chunk é uma fatia, então você pode chamar chunk.len() nele e acessar os índices com chunk[0], chunk[1], etc.

Formato de saída esperado para os preços:
Use ${:.2} para formatar os preços com 2 casas decimais.

Experimente você mesmo

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

    println!("Original Prices:");
    // TODO: Use enumerate() para imprimir o número e o preço de cada item
    // Dica: prices.iter().enumerate() fornece pares (index, &price)
    // Formate os preços com 2 casas decimais usando {:.2} — ex.: "Item 1: $2.75"


    println!("\nBundle Deals:");
    // TODO: Encadeie chunks(2) e enumerate() juntos: prices.chunks(2).enumerate()
    // Isso fornece pares (index, chunk) — cada chunk é um slice, então chunk.len() indica o seu tamanho
    // If chunk.len() == 2, print: "Bundle 1: $2.75 + $1.50 = $4.25"
    // Se chunk.len() == 1, imprima: "Bundle 4: $7.90"
    // Use {:.2} para formatar todos os preços com 2 casas decimais


    // TODO: Use iter_mut() para aplicar um desconto de 10% a todos os preços
    // Dica: multiplique cada *price por 0.9


    println!("\nPrices after 10% discount:");
    // TODO: Imprima cada preço com desconto formatado com 2 casas decimais
    // Esperado: "$2.48" etc.

}