Fácil Rust

Soma e média de um Vec

Enunciado

Crie um Vec<i32> com os valores [4, 7, 10, 3, 8]. Calcule e imprima a soma e a média (como f64).

Requisitos

  • Usar a macro vec! para criar o vetor.
  • Calcular a soma com iter().sum().
  • Imprimir a soma e a média com duas casas decimais.

Código inicial

fn main() {
    // TODO: crie o vetor e calcule soma e média
}

Saída esperada

Soma: 32
Média: 6.40
Ver dica

Para converter i32 em f64, use as f64. A média é soma as f64 / vetor.len() as f64.

Mostrar solução 
fn main() {
    // Vetor imutável com os valores pedidos
    let valores = vec![4, 7, 10, 3, 8];

    // Soma todos os elementos (iter() empresta, sum() consome o iterador)
    let soma: i32 = valores.iter().sum();

    // Calcula a média convertendo para f64
    let media = soma as f64 / valores.len() as f64;

    println!("Soma: {}", soma);
    println!("Média: {:.2}", media);
}

Passo a passo

  1. let valores = vec![4, 7, 10, 3, 8]; cria um Vec<i32> com os cinco números. A macro vec! é o jeito idiomático de inicializar vetores com valores conhecidos.
  2. valores.iter() cria um iterador que empresta cada elemento, sem consumir o vetor — assim ainda podemos usar valores.len() depois.
  3. .sum() consome esse iterador e soma todos os i32. O tipo i32 em let soma: i32 ajuda o compilador a inferir o tipo da soma.
  4. soma as f64 converte o inteiro para ponto flutuante, necessário para obter média com casas decimais.
  5. valores.len() as f64 converte o tamanho (um usize) para f64, permitindo a divisão.
  6. println!("Soma: {}", soma); imprime a soma como inteiro.
  7. println!("Média: {:.2}", media); usa {:.2} para formatar com exatamente duas casas decimais.

Por que funciona

O Vec guarda os elementos de forma contígua e expõe métodos como iter(), sum() e len(). Como iter() empresta (&T), o vetor continua válido após a soma. A conversão explícita com as f64 é necessária porque Rust não faz coerção implícita entre inteiros e floats.

Erros comuns

  • Esquecer o as f64: let media = soma / valores.len() as f64; gera erro de compilação porque i32 e f64 não podem ser divididos diretamente.
  • Usar valores.into_iter() em vez de iter(): isso consome o vetor e valores.len() depois falha com "use of moved value".
  • Formatar com {:.2} em um i32 não compila; a formatação com casas decimais exige um tipo float.

Outra forma de resolver

Se quiser evitar o as f64 na divisão, converta os elementos para f64 antes de somar:

let soma_f: f64 = valores.iter().map(|&x| x as f64).sum();
let media = soma_f / valores.len() as f64;

Essa abordagem é útil quando os valores já são floats ou quando se quer precisão maior.

Saída esperada

Soma: 32
Média: 6.40