Loop For Aprimorado

Parte da seção Fundamentos do Journey de Rust da Coddy. Lição 66 de 75.

Há 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 de tamanho específico:
```
for chunk in numbers.chunks(2) { }
// Valores: [1,2], [3,4], [5]
```
cada bloco é uma fatia, então você pode usar métodos de fatia nele. Por exemplo, chunk.len() retorna quantos elementos há nesse bloco. O último bloco pode ser menor se o array não puder ser dividido igualmente.

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

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

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

Itere com mutação:

let mut numbers = [1, 2, 3, 4, 5];
for num in numbers.iter_mut() { 
	*num *= 2;
}
// O array passa a ser: [2, 4, 6, 8, 10]

Desafio

Fácil

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

O programa deve:

Imprimir o número de cada item e seu preço (usando enumerate). Formate como Item N: $Price (por exemplo, Item 1: $2.75).
Imprimir os preços em pares (usando chunks) como "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 finais com desconto, cada um em uma nova linha, formatados com 2 casas decimais (por exemplo, $2.48).

Dica: Você pode encadear iteradores, por exemplo, prices.chunks(2).enumerate() fornece ao mesmo tempo o índice do bloco e a fatia do bloco. Cada chunk é uma fatia, então você pode chamar chunk.len() nela e acessar seus elementos usando índices, como chunk[0], chunk[1] etc.

Formato esperado dos preços:
Use ${:.2} para formatar os preços com 2 casas decimais.

O texto exato é Bundle 4: $7.90.

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}; consulte as instruções para ver o formato exato


    println!("\nBundle Deals:");
    // TODO: Encadeie chunks(2) e enumerate(): prices.chunks(2).enumerate()
    // Isso fornece pares (index, chunk); cada chunk é uma fatia, então chunk.len() informa seu tamanho
    // Se chunk.len() == 2, imprima: "Bundle 1: $2.75 + $1.50 = $4.25"
    // Se chunk.len() == 1, imprima a linha do item único descrita nas instruções
    // Use {:.2} para formatar todos os preços com 2 casas decimais


    // TODO: Use iter_mut() para aplicar um 10% discount 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
    // O formato de saída esperado é mostrado nas instruções

}