Fácil Rust

Declarando e imprimindo tipos escalares

Enunciado

Declare uma variável cidade do tipo &str com valor "Recife", uma variável populacao do tipo u32 com valor 1500000, uma variável area do tipo f64 com valor 218.4 e uma variável litoral do tipo bool com valor true. Imprima todas em uma única linha no formato: Cidade: Recife, População: 1500000, Área: 218.4 km², Litoral: true.

Requisitos

  • Declarar as quatro variáveis com os tipos explícitos indicados.
  • Imprimir exatamente no formato pedido, com Área mostrando uma casa decimal.
  • Usar println! com formatação adequada.

Código inicial

fn main() {
    // TODO: declare as variáveis e imprima
}

Saída esperada

Cidade: Recife, População: 1500000, Área: 218.4 km², Litoral: true
Ver dica

Use {:.1} para formatar o float com uma casa decimal e {} para os outros tipos.

Mostrar solução 
fn main() {
    // Declaração explícita dos tipos escalares
    let cidade: &str = "Recife";
    let populacao: u32 = 1500000;
    let area: f64 = 218.4;
    let litoral: bool = true;

    // Impressão formatada: {:.1} mostra uma casa decimal
    println!(
        "Cidade: {}, População: {}, Área: {:.1} km², Litoral: {}",
        cidade, populacao, area, litoral
    );
}

Passo a passo

  1. Declaramos cidade como &str (uma string slice) porque é um texto que não será modificado.
  2. populacao é u32 (inteiro sem sinal de 32 bits) — suficiente para números positivos grandes.
  3. area é f64 (float de 64 bits) para representar o valor com casas decimais.
  4. litoral é bool (true/false) para indicar presença de litoral.
  5. No println!, usamos {} para strings, inteiros e booleanos, e {:.1} para o float, que arredonda e mostra uma casa decimal.
  6. A saída sai exatamente no formato solicitado, com o ² como caractere Unicode dentro da string.

Por que funciona

Rust exige que os tipos sejam conhecidos em tempo de compilação. Ao anotar explicitamente cada variável, deixamos claro para o compilador (e para quem lê) qual é o tipo. O macro println! usa o trait Display para formatar valores; {:.1} é uma especificação de precisão que funciona para floats. A string "km²" é válida porque Rust usa UTF-8 e char/&str suportam Unicode.

Erros comuns

  • Esquecer o tipo em populacao e deixar o compilador inferir como i32: funciona, mas não segue o requisito de tipo explícito. Corrija com let populacao: u32 = 1500000;.
  • Usar {} para o float: Área: 218.4 sem casas decimais fixas. Use {:.1}.
  • Escrever "km2" em vez de "km²": a saída fica diferente do esperado. O caractere ² é Unicode e deve ser copiado corretamente.

Outra forma de resolver

Você pode usar format! para montar a string e depois imprimir:

let linha = format!("Cidade: {}, População: {}, Área: {:.1} km², Litoral: {}", cidade, populacao, area, litoral);
println!("{}", linha);

Útil quando a string precisa ser reutilizada ou armazenada.

Saída esperada

Cidade: Recife, População: 1500000, Área: 218.4 km², Litoral: true