O arquivo de configuração deve ser colocado em ~/.config/helix/languages.toml.

[[language]]
name = "rust"
auto-format = true

roots = [
  "Cargo.toml",
  "Cargo.lock"
]

[language.auto-pairs]
'(' = ')'
'{' = '}'
'[' = ']'
'"' = '"'
'`' = '`'

[language-server.rust-analyzer]
command = "rust-analyzer"

[language-server.rust-analyzer.config]
inlayHints.bindingModeHints.enable = false
inlayHints.closingBraceHints.minLines = 10
inlayHints.closureReturnTypeHints.enable = "with_block"
inlayHints.discriminantHints.enable = "fieldless"
inlayHints.lifetimeElisionHints.enable = "skip_trivial"
inlayHints.typeHints.hideClosureInitialization = false

Entre os plugins mais recomendados para Rust no Neovim estão o rustaceanvim (integração completa com rust-analyzer) e o crates.nvim (gerenciamento de dependências do Cargo diretamente no editor).

Nota: O guia externo abaixo pode ficar desatualizado com o tempo. Prefira consultar a documentação oficial dos plugins para configurações mais recentes.

  https://rsdlt.github.io/posts/rust-nvim-ide-guide-walkthrough-development-debug/

fn main() {
    // Este é um comentário de linha única    
}

fn main() {
    /*
      Este é um comentário de
      bloco que abrange várias
      linhas.
    */
}

fn main() {
    /*
       Início do comentário externo
       /* Este é um comentário de bloco aninhado */
       Fim do comentário externo
    */    
}

fn main() {
    print!("Imprimir sem adicionar uma nova linha no final!");
}

fn main() {
    println!("Imprimir e adicionar nova linha no final!");
}

fn main() {
    print!("Hello, ");
    print!("World");
}

fn main() {
    println!("Primeira linha\nSegunda linha");
}

fn main() {
    println!("Barra invertida: \\");
    println!("Olá \"mundo\"");
    println!(r"C:\Usuários\Snoopy\Documentos\");
}

fn main() {
    let score = 100;
    println!("Score: {}", score);
}

fn main() {
    let cidade = "Recife";
    println!("Cidade: {}", cidade);
}

fn main() {
    // Isto causaria um erro de tempo de compilação:
    println!("{}", x);
    let x = 5;
} 

fn main() {
    let x: i32; 
    x = 42;     
    println!("x = {}", x);
}

fn main() {
    let mut contador = 0;
    println!("Contador = {}", contador);
    
    contador = 5;
    println!("Contador = {}", contador);
}

fn main() {
    let x = 1;    
    x = 2;
    println!("x = {}", x);
}

const MAX_SPEED: i32 = 9000;

fn main() {
    println!("Max Speed: {}", MAX_SPEED);
}

const MAX_SPEED: i32 = 100;

fn main() {    
    MAX_SPEED = 200; // erro: cannot assign to this expression
}

Não. Constantes são sempre imutáveis — a palavra-chave mut não pode ser usada com const de forma alguma. Qualquer tentativa de reatribuição resulta em erro de compilação.

const CONSTANTE_GLOBAL: i32 = 100;

fn main() {
    let variavel_imutavel = 200;
    println!("Constante: {}, Variável: {}", CONSTANTE_GLOBAL, variavel_imutavel);

    // Constantes:
    // - Sempre imutáveis: 'mut' não é permitido de forma alguma (nem como tentativa);
    // - Tipo explícito obrigatório (ex: : i32);
    // - Avaliadas em tempo de compilação;
    // - Podem ser declaradas em escopo global (fora de funções).
    
    // Variáveis Imutáveis (let):
    // - Podem ser tornadas mutáveis com 'mut';
    // - O tipo pode ser inferido;
    // - Locais ao seu escopo;
    // - Podem ser definidas como o resultado de qualquer expressão.
}

fn main() {
    let numero = 42;
    let numero_formatado = format!("O valor é: {}", numero);
    println!("{}", numero_formatado);
}

fn main() {
    let numero = 7;
    let numero_formatado = format!("{:04}", numero);
    println!("{}", numero_formatado);
}

fn main() {
    let pi = 3.14159265359;
    println!("Pi: {:.2}", pi);

    let pi_formatado = format!("{:.2}", pi);
    println!("Pi: {}", pi_formatado);    
}

fn main() {
    let nome = "Snoopy";
    let idade = 8;
    let cidade = "Califórnia";
    
    // Argumentos posicionais
    println!("{0} tem {1} anos e mora na {2}", nome, idade, cidade);
    
    // Argumentos nomeados
    println!("{nome} tem {idade} anos e mora na {cidade}");
             
    // Misturado
    println!("{} tem {idade} anos e mora na {cidade}", nome);
}

fn main() {
    let x = 5;
    println!("Primeiro x: {}", x);

    let x = x + 1;
    println!("Segundo x: {}", x);

    let x = x * 2;
    println!("Terceiro x: {}", x);

    let x = "Olá";
    println!("Quarto x: {}", x);
}

fn main() {
    let x = 5;
    let x = x + 1; // x = 6
    {
        let x = x * 2; // x = 12 
        println!("O valor interno de x é: {}", x); // Saida: 12
    }
    println!("O valor externo de x é: {}", x); // Saida: 6
}

fn main() {
    let a = 10;
    {
        let b = 20;
        println!("Dentro do bloco: a = {}, b = {}", a, b);
        // Saida: Dentro do bloco: a = 10, b = 20
    }
    // println!("Fora do bloco: b = {}", b);
    // Erro: b não está no escopo
}

fn main() {
    let positivo: u32 = 100;
    println!("{:?}", positivo);
   
    let negativo: i32 = -100;
    println!("{:?}", negativo);

    // Erro:
    // let positivo: u32 = -5;
}

fn main() {
    let max_u8: u8 = u8::MAX;
    println!("{:?}", max_u8);

    // erro: causaria um overflow (estouro)
    // let max_u8: u8 = u8::MAX + 1;
    // println!("{:?}", max_u8);
}

fn main() {
    let populacao: u64 = 7_800_000_000;
    println!("População: {populacao:?}");
}

fn main() {
    let video_views: u64 = 2_500_000_000;
    println!("{:?}", video_views);
}

fn main() {
    let min_val_i8: i8 = i8::MIN;
    println!("{:?}", min_val_i8);
   
    let max_val_i8: i8 = i8::MAX;
    println!("{:?}", max_val_i8);
}

fn main() {
    let valor_a: u8 = 10;
    println!("{:?}", valor_a);

    let valor_b: u8 = -10;
    println!("{:?}", valor_b);
}

fn main() {
    let leitura_do_sensor: f32 = 7.89;
    println!("{:?}", leitura_do_sensor);
}

fn main() {
    let char_ascii: char = 'Z';
    println!("{:?}", char_ascii);

    let char_unicode: char = 'Ω';
    println!("{:?}", char_unicode);

    println!("{:?}", std::mem::size_of_val(&char_ascii));
    println!("{:?}", std::mem::size_of_val(&char_unicode));
}

fn main() {
    // erro: deve ter apenas um caractere
    let letra: char = 'ab';
    println!("{:?}", letra);
}

fn main() {
    let arquivo_carregado: bool = true;
    println!("{:?}", arquivo_carregado);

    let apresenta_erro: bool = false;
    println!("{:?}", apresenta_erro);

    // Tipos incompatíveis, esperava-se `bool`, encontrado inteiro
    // let valor: bool = 1;
    // println!("{:?}", valor);
}

fn main() {
    let registro: (&str, u8, f32) = ("Maria", 22, 7.5);
    println!("{:#?}", registro);
}

fn main() {
    let server_response: (u16, &str) = (404, "Not Found");
    println!("{:?}", server_response);
}

fn main() {    
    let produto_info: (&str, f32, u16) = ("Laptop XPTO", 1.250_000, 15);

    println!(
        "Produto: {} \nQuantidade em Estoque: {}",
        produto_info.0, produto_info.2
    );    
}

fn main() {
    let color_rgb: (u8, u8, u8) = (255, 128, 0);
    let (red, green, blue) = color_rgb;

    println!("Red: {} \nGreen: {} \nBlue: {}", red, green, blue);
}

fn main() {
    let api_result: (bool, u64, String) = (true, 1234567890, String::from("Successful operation"));
    println!("{:#?}", api_result);
}

fn main() {
    // erro: 
    // let config: (&str, u16) = ("localhost", 8080);
    // config.1 = 8081;
    
    let mut config: (&str, u16) = ("localhost", 8080);
    println!("{:?}", config);

    config.1 = 8081;
    println!("{:?}", config);
}

fn main () {
    let mut player_status: (&str, i32, u8) = ("Hero", 0, 3);
    println!("Name: {}\nScore: {}\nVidas: {}\n", player_status.0, player_status.1, player_status.2);
    
    player_status.1 = 1500;
    player_status.2 = 2;
    println!("Name: {}\nScore: {}\nVidas: {}", player_status.0, player_status.1, player_status.2);
}

fn main() {
    let mut point: (f32, f32) = (10., 20.);
    println!("{:#?}", point);

    point.0 = 15.5;
    point.1 = 25.;
    println!("{:#?}", point);
}

fn main () {
    let file_details: (String, u64, bool) = (String::from("test.txt"), 127, true);
    println!("{:#?}", file_details);

    let mut file_details_v2 = file_details;
    file_details_v2.0 = String::from("teste_v2.txt");
    file_details_v2.2 = false;

    println!("{:#?}", file_details_v2);
}

fn main () {
    let meses: [&str; 3] = ["Janeiro", "Fevereiro", "Março"];

    println!("{:#?}\n", meses);
    println!("{:#?}", meses[1])
}

fn main () {
    let numeros: [u32; 6] = [1, 2, 4, 8, 16, 32];
    println!("{numeros:#?}\n");
    
    let numeros: [u32; 6] = [1, 2, 4, 8, 16, 32];
    println!("{:#?}", numeros[5]);
}

fn main () {
    let scores = [100, 90, 80];
    println!("{:?}", scores);

    // scores[1] = 95;
    // println!("{:?}", scores);

    let mut scores = [10, 30, 60];
    println!("{:?}", scores);

    scores[1] = 0;
    println!("{:?}", scores);
}

fn main () {
    let mut contador: [u16; 4] = [10, 25, 5, 30];

    contador[0] = 12;
    contador[2] = 8;

    println!("{:?}", contador);
}

fn main () {
    let mut servicos_ativos:[bool; 3] = [true, false, true];
    println!("{:?}", servicos_ativos);

    servicos_ativos[1] = true;
    servicos_ativos[2] = false;
    println!("{:?}", servicos_ativos);
}

fn main() {
    let a: u8 = 15;
    let b: u8 = 7;

    println!("{:?}", a + b);
}

fn main() {
    let total = 10;
    let sub = total - 3;
    println!("{:?}", sub);

    let mut total = 10;
    total -= 3;
    println!("{:?}", total);
}

fn main() {
    let x: u8 = 6;
    let y: u8 = 8;

    let result: u8 = x * y;
    println!("{:?}", result);
}

fn main() {
    let result = 20 / 5;
    println!("{}", result);
}

fn main() {
    let mut resto: u8 = 23;
    resto %= 4;

    println!("{:?}", resto);
}

fn main() {
    let num1: u8 = 12;
    let num2: u8 = 5;

    println!("{:?}", num1 + num2);
}

fn main() {
    let valor: u8 = 9 + 2;
    println!("{:?}", valor);
}

fn main() {
    let mut contador: u8 = 5;
    contador += 3;

    println!("{:?}", contador);
}

fn main() {
    let mut score: u8 = 20;
    score -= 5;

    println!("{:?}", score);
}

fn main() {
    let mut numero: u8 = 2;
    numero *= 4;

    println!("{:?}", numero);
}

fn main() {
    let mut size: u8 = 30;
    size /= 6;

    println!("{:?}", size);
}

fn main() {
    let mut numero: u8 = 17;
    numero %= 5;

    println!("{:?}", numero);
}

fn main() {
    let part1: &str = "Hello, ";
    let part2: &str = "Rust!";

    println!("{}{}", part1, part2);
}

fn main() {
    let s1: String = String::from("Linguagem ");
    let s2: String = String::from("Rust.");

    println!("{:?}", s1 + &s2);
}

fn main() {
    let numero: &str = "Numero: ";
    let numero_str: String = String::from("42");

    println!("{:?}", numero.to_owned() + &numero_str);
}

fn main() {
    let tup: (i32, i32) = (5, -2);
    println!("{:?}", tup.0 * tup.1);
}

fn main() {
    let tup: ((u8, u8), (u8, u8)) = ((1, 2), (3, 4));
    println!("{:?}", tup.0 .0 + tup.1 .1);
}

fn main() {
    let t1: (u8, u8) = (2, 5);
    let t2: (u8, u8) = (8, 1);

    println!("{:?}", t1.0 + t1.1 + t2.0 + t2.1);
}

fn main() {
    let arr: [i32; 5] = [1, 3, 5, 7, 9];
    println!("{:?} + {:?} = {:?}", arr[0], arr[4], arr[0] + arr[4]);
}

fn main() {
    let arr: [u16; 3];
    arr = [10, 20, 30];

    println!("{:?}", arr[0] * arr[1] * arr[2]);
}

fn main() {
    let arr: [[i8; 2]; 2];
    arr = [[2, 2], [4, 4]];

    println!("{:?}", arr[0][0] * arr[0][1] * arr[1][0] * arr[1][1]);
}

fn main() {
    let x: u8 = 1;
    {
        let y: u8 = 2;
        println!("{:?}", x + y);
    }
    
    println!("{:?}", x);
    // println!("{:?}", y); // Erro: `y` fora do escopo
}

fn main() {
    let level1: u8 = 10;
    {
        let level2: u8 = 20;
        {
            let level3: u8 = 30;
            println!("{:?}", level1 + level2 + level3);
        }
        println!("{:?}", level2);
    }
    println!("{:?}", level1);
}

fn main() {
    let principal: u8 = 100;
    println!("{:?}", principal);
    {
      let principal: f32 = 50.;
      println!("{:?}", principal);
    }
    println!("{:?}", principal);
}

fn main() {
    let var: [u8; 2] = [2, 3];
    println!("{:?}", (var[0] + var[1]) * var[1]);
}

fn main() {
    let var: [u8; 2] = [2, 3];
    println!("{:?}", var[0] * var[1] / var[1] % var[1]);
}

fn main() {
    let var: [u8; 2] = [2, 3];
    println!("{:?}", var[0] + var[1] - var[0] + var[0] * var[0]);
}

fn main() {
    let var: [i8; 2] = [2, 3];
    println!("{:?}", (var[0] + var[1]) - (var[0] + var[0]) * var[0]);
}

fn main() {
    let num1: i8 = 10;
    let num2: i8 = 10;

    println!("Num1 = Num2? {:?} ", num1 == num2);
}

fn main() {
    let f1: f32 = 3.14;
    let f2: f32 = 2.71;

    println!("f1 != f2? {}", f1 != f2);
}

fn main() {
    let idade_a: u8 = 25;
    let idade_b: u8 = 30;

    println!("Idade A > Idade B? {}", idade_a > idade_b);
}

fn main() {
    let point1: u8 = 5;
    let point2: u8 = 8;

    println!("Point1 < Point2? {}", point1 < point2);
}

fn main() {
    let nota_a: u8 = 7;
    let nota_b: u8 = 7;

    println!("Nota A >= Nota B? {}", nota_a >= nota_b);
}

fn main() {
    let altura_a: f32 = 1.70;
    let altura_b: f32 = 1.65;

    println!("Altura A <= Altura B? {}", altura_a <= altura_b);
}

fn main() {
    let temp_a: f32 = 22.5;
    let temp_b: f32 = 20.;

    println!("Temperatura A > Temperatura B? {}", temp_a > temp_b);
}

fn main() {
    let count_a: u8 = 100;
    let count_b: u8 = 99;

    println!("Count A < Count B? {}", count_a < count_b);
}

fn main() {
    let val_a: u8 = 8;
    let val_b: u8 = 3;

    println!("{:?}", (val_a + val_b) - 1);
}

fn main() {
    let mut arr: [i32; 3] = [2, 4, 6];

    arr[0] /= 2;
    arr[1] /= 2;
    arr[2] /= 2;

    println!("{:#?}", arr);
}

fn main() {
    let tup: (f64, f64) = (2.5, 3.5);
    let result: f64 = tup.0 + tup.1;

    println!("{:.2}", result);
}

fn main() {
    //&str
    let mensagem: &str = "Start";
    println!("{}", mensagem.to_owned() + " -> End");
}

fn main() {
    // string
    let mut mensagem: String = String::from("Start");
    mensagem += " -> End";
    println!("{}", mensagem);
}

fn main() {
    let cria_string: String = String::new();
    println!("{}", cria_string);
}

fn main() {
    let literal_string: String = String::from("Pequeno, texto!");
    println!("{}", literal_string);
}

fn main() {
    let texto: &str = "Aprendendo Rust";
    println!("{}", texto);
}

fn main() {
    let entrada_string: String = String::from("Aprendendo Rust!");
    let entrada_str: &str = &entrada_string;
    println!("{}", entrada_str);
}

fn main() {
    let entrada_string: String = String::from("Aprendendo Rust!");
    let entrada_str: &str = entrada_string.as_str();
    println!("{}", entrada_str);
}

use std::io;

fn main() {
    println!("Entre com texto:");
    let mut entrada_string: String = String::new();
    io::stdin()
        .read_line(&mut entrada_string)
        .expect("Erro de entrada de dados!");
    let texto_string: &str = entrada_string.as_str();
    println!("\nTexto convertido para &str: {}", texto_string.trim());
}

fn main() {    
    let text: &str = "123";
    let num: u8 = text.parse().expect("Erro ao converter dados!");
    println!("{}", num);    
}

fn main() {
    let text: &str = "123";
     
    let num = match text.parse::<u8>() {
        Ok(num) => num,
        Err(_) => {
            println!("Erro ao converter dados!");
            return;
        }
    };
    println!("{}", num);
}

use std::io;

fn main() {
    println!("Entre com texto:");
    let mut entrada_texto: String = String::new();
    io::stdin()
        .read_line(&mut entrada_texto)
        .expect("Erro de entrada de dados!");

    let texto_a: &str = &entrada_texto.as_str().trim();
    let texto_b: String = String::from(" + string!");

    println!("{}", texto_a.to_string() + &texto_b);
}

fn main() {
    let mut string_mutavel: String = String::from("Pequeno, ");
    string_mutavel.push_str("texto!");
    println!("{}", string_mutavel);
}

fn main() {    
    let mut unico_char: String = String::from("Pequeno, texto");
    let caractere: char = '!';

    unico_char.push(caractere);
    println!("{}", unico_char);
}

fn main() {
    let var_str: &str = "1";
    let var_string: String = String::from("2");
    let var_u8: u8 = 3;

    // a macro format! cria uma nova string
    let result = format!("{}{}{}", var_str, var_string, var_u8);
    println!("{}", result);
}

use std::io;

fn main() {
    println!("Entre com texto:");
    let mut entrada_texto: String = String::new();
    io::stdin().read_line(&mut entrada_texto).err();

    let remove_espaco = entrada_texto.replace(" ", "");
    println!("\nSem espaços = {}", remove_espaco.trim());
}

use std::io;

fn main() {
    println!("Entre com texto:");
    let mut entrada_texto: String = String::new();
    io::stdin().read_line(&mut entrada_texto).err();

    let novo_texto = entrada_texto.replace("erro", "sucesso");
    println!("{}", novo_texto);
}

use std::io;

fn main() {
    println!("Entre com uma frase:");
    let mut entrada_frase: String = String::new();
    io::stdin().read_line(&mut entrada_frase).err();

    let frase = entrada_frase.replacen("antes", "depois", 1);
    println!("{}", frase);
}

use std::io;

fn main() {
    println!("Entre com uma frase:");
    let mut entrada_texto: String = String::new();
    io::stdin().read_line(&mut entrada_texto).err();

    if entrada_texto.contains("Rust") {
        println!("\n{} - contém 'Rust'", entrada_texto.trim());
    } else {
        println!("\n{} - não contém 'Rust'", entrada_texto.trim());
    }
}

use std::io;

fn main() {
    println!("Entre com o nome do arquivo:");
    let mut entrada_texto: String = String::new();
    io::stdin().read_line(&mut entrada_texto).err();

    if entrada_texto.trim().ends_with(".rs") {
        println!("\n{} - termina com '.rs'", entrada_texto.trim());
    } else {
        println!("\n{} - não termina com '.rs'", entrada_texto.trim());
    }
}

use std::io;

fn main() {
    println!("Entre com link:");
    let mut entrada_link: String = String::new();
    io::stdin().read_line(&mut entrada_link).err();

    if entrada_link.starts_with("https://") {
        println!("\n{} - começa com 'https://'", entrada_link.trim());
    } else {
        println!("\n{} - não começa com 'https://'", entrada_link.trim());
    }
}

use std::io;

fn main() {
    println!("Entre com uma frase:");
    let mut entrada_frase: String = String::new();
    io::stdin().read_line(&mut entrada_frase).err();

    let frase = entrada_frase.split_whitespace().next();
    println!("{}", frase.unwrap());
}

use std::io;

fn main() {
    println!("Entre com a frase:");
    let mut entrada_frase: String = String::new();
    io::stdin().read_line(&mut entrada_frase).err();

    if let Some(indice) = entrada_frase.find("rust") {
        println!("\nÍndice de bytes: {}", indice);
    } else {
        println!("\nNão tem: rust");
    }
}

use std::io;

fn main() {
    println!("Entre com a palavra:");
    let mut entrada_palavra: String = String::new();
    io::stdin().read_line(&mut entrada_palavra).err();

    let primeira_letra: char = entrada_palavra.trim_start().chars().next().unwrap_or(' ');
    println!("Primeira letra = {}", primeira_letra);
}

use std::io;

fn main() {
    println!("Entre com uma palavra:");
    let mut entrada_palavra: String = String::new();
    io::stdin().read_line(&mut entrada_palavra).err();

    let palavra = entrada_palavra.trim().replace(" ", "");
    println!("{}", palavra);
    println!("{:?}", palavra.chars().count());
}

use std::io;

fn main() {
    println!("Entre com uma frase:");
    let mut entrada_frase: String = String::new();
    io::stdin().read_line(&mut entrada_frase).err();

    let frase = entrada_frase.trim().replace("a", "A");
    println!("{}", frase);    
}

use std::io;

fn main() {
    println!("Entre com texto:");
    let mut entrada_palavra: String = String::new();
    io::stdin()
        .read_line(&mut entrada_palavra)
        .expect("Erro de entrada de dados!");

    let mut palavra: String = entrada_palavra.trim_end().to_string();
    palavra.pop();
    println!("{}", palavra);
}

fn main() {
    let mut var_string: String = String::with_capacity(50);
    var_string.push_str("Pequeno, grande texto!");

    println!("String = {}", var_string);
    println!("Capacidade = {}", var_string.capacity());
    println!("Tamanho = {}", var_string.len());
    println!("");

    var_string.clear();
    println!("String = {}", var_string);
    println!("Capacidade = {}", var_string.capacity());
    println!("Tamanho = {}", var_string.len());
}

use std::io;

fn main() {
    println!("Entre com uma frase:");
    let mut entrada_frase: String = String::new();
    io::stdin().read_line(&mut entrada_frase).err();

    let maiuscula = entrada_frase.trim().to_uppercase();
    println!("{}", maiuscula);
}

use std::io;

fn main() {
    println!("Digite um número inteiro:");

    let mut entrada_texto: String = String::new();
    io::stdin()
        .read_line(&mut entrada_texto)
        .expect("Erro na leitura do valor digitado!");

    let numero: i32 = match entrada_texto.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter o dado para número!");
            return;
        }
    };

    if numero % 2 == 0 {
        println!("Número {} é Par!", numero);
    } else {
        println!("Número {} é Ímpar!", numero);
    }
}

use std::io;

fn main() {
    println!("Digite um número: ");

    let mut entrada_num: String = String::new();
    io::stdin()
        .read_line(&mut entrada_num)
        .expect("Erro na leitura do valor digitado!");

    let numero: i8 = match entrada_num.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter o dado para número!");
            return;
        }
    };

    if numero > 0 {
        println!("O número {} é Positivo.", numero);
    } else if numero < 0 {
        println!("O número {} é Negativo.", numero);
    } else {
        println!("O número é Zero.");
    }
}

use std::io;

fn main() {
    println!("Digite o primeiro número (A):");
    let mut entrada_num_a: String = String::new();
    io::stdin()
        .read_line(&mut entrada_num_a)
        .expect("Erro na leitura de A!");

    println!("Digite o segundo número (B):");
    let mut entrada_num_b: String = String::new();
    io::stdin()
        .read_line(&mut entrada_num_b)
        .expect("Erro na leitura de B!");
    
    let num_a: i8 = match entrada_num_a.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter número A!");
            return;
        }
    };

    let num_b: i8 = match entrada_num_b.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter número B!");
            return;
        }
    };

    if num_a > num_b {
        println!("O Número A ({}) é o maior.", num_a);
    } else if num_a < num_b {
        println!("O Número B ({}) é o maior.", num_b);
    } else {
        println!("Os números são iguais ({}).", num_a);
    }
}

use std::io;

fn main() {
    println!("Digite sua nota para o Teste A (0-10):");
    let mut entrada_teste_a: String = String::new();
    io::stdin()
        .read_line(&mut entrada_teste_a)
        .expect("Erro ao digitar a primeira nota!");

    println!("Digite a nota para o Teste B (0-10):");
    let mut entrada_teste_b: String = String::new();
    io::stdin()
        .read_line(&mut entrada_teste_b)
        .expect("Erro ao digitar a segunda nota!");

    println!("Digite a nota para o Teste C (0-10):");
    let mut entrada_teste_c: String = String::new();
    io::stdin()
        .read_line(&mut entrada_teste_c)
        .expect("Erro ao digitar o terceiro teste!");

    let teste_a: f32 = match entrada_teste_a.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter: Teste A!");
            return;
        }
    };

    let teste_b: f32 = match entrada_teste_b.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter: Teste B!");
            return;
        }
    };

    let teste_c: f32 = match entrada_teste_c.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter: Teste C!");
            return;
        }
    };

    let media: f32 = (teste_a + teste_b + teste_c) / 3.0;
    println!("Sua média é: {:.2}", media);

    if media < 5.0 {
        println!("Situação: Reprovado!");
    } else if media >= 5.0 && media < 7.0 {
        println!("Situação: Recuperação!");
    } else {
        println!("Situação: Aprovado!");
    }
}

use std::io;

fn main() {
    println!("Digite sua idade:");

    let mut entrada_idade: String = String::new();
    io::stdin()
        .read_line(&mut entrada_idade)
        .expect("Erro na entrada!");

    let idade: u8 = match entrada_idade.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter idade!");
            return;
        }
    };

    if idade >= 18 && idade <= 59 {
        println!("Idade: {}\nVocê é obrigado(a) a votar!", idade);
    } else if (idade >= 16 && idade < 18) || idade >= 60 {
        println!("Idade: {}\nSeu voto é opcional!", idade);
    } else {
        println!("Idade: {}\nVocê não pode votar!", idade);
    }
}

use std::io;

fn main() {
    //
    println!("Digite o número A: ");
    let mut entrada_a: String = String::new();
    io::stdin()
        .read_line(&mut entrada_a)
        .expect("Erro na entrada!");

    //
    println!("Digite o número B: ");
    let mut entrada_b: String = String::new();
    io::stdin()
        .read_line(&mut entrada_b)
        .expect("Erro na entrada!");

    //
    println!("Digite o número C: ");
    let mut entrada_c: String = String::new();
    io::stdin()
        .read_line(&mut entrada_c)
        .expect("Erro na entrada!");

    //
    let num_a: i8 = match entrada_a.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter número A!");
            return;
        }
    };

    let num_b: i8 = match entrada_b.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter número B!");
            return;
        }
    };

    let num_c: i8 = match entrada_c.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter número C!");
            return;
        }
    };

    //
    if num_a == num_b && num_b == num_c {
        println!("A = B = C = {}", num_a);
    } else if num_a == num_b && num_a > num_c {
        println!("A = B = {} > C = {}", num_a, num_c);
    } else if num_a == num_b && num_a < num_c {
        println!("C = {} > A = B = {}", num_c, num_a);
    } else if num_a == num_c && num_a > num_b {
        println!("A = C = {} > B = {}", num_a, num_b);
    } else if num_a == num_c && num_a < num_b {
        println!("B = {} > A = C = {}", num_b, num_a);
    } else if num_b == num_c && num_b > num_a {
        println!("B = C = {} > A = {}", num_b, num_a);
    } else if num_b == num_c && num_b < num_a {
        println!("A = {} > B = C = {}", num_a, num_b);
    } else if num_a > num_b && num_a > num_c {
        println!("A = {}", num_a);
    } else if num_b > num_a && num_b > num_c {
        println!("B = {}", num_b);
    } else {
        println!("C = {}", num_c);
    }
}    

use std::io;

fn main() {
    println!("Digite a pontuação (0 - 100):");
    let mut entrada_pontuacao: String = String::new();
    io::stdin()
        .read_line(&mut entrada_pontuacao)
        .expect("Erro na entrada!");

    let pontuacao: u8 = match entrada_pontuacao.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter pontuação!");
            return;
        }
    };

    if pontuacao <= 59 {
        println!("Nota: F");
    } else if pontuacao <= 69 {
        println!("Nota: D");
    } else if pontuacao <= 79 {
        println!("Nota: C");
    } else if pontuacao <= 89 {
        println!("Nota: B");
    } else if pontuacao <= 100 {
        println!("Nota: A");
    }
}

use std::io;

fn main() {
    // lado_a
    println!("Digite o tamanho do Lado A:");
    let mut entrada_a: String = String::new();
    io::stdin()
        .read_line(&mut entrada_a)
        .expect("Erro na entrada A!");

    // lado_b
    println!("Digite o tamanho do Lado B:");
    let mut entrada_b: String = String::new();
    io::stdin()
        .read_line(&mut entrada_b)
        .expect("Erro na entrada B!");

    // lado_c
    println!("Digite o tamanho do Lado C:");
    let mut entrada_c: String = String::new();
    io::stdin()
        .read_line(&mut entrada_c)
        .expect("Erro na entrada C!");

    let lado_a: f32 = match entrada_a.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter lado A!");
            return;
        }
    };

    let lado_b: f32 = match entrada_b.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter lado B!");
            return;
        }
    };

    let lado_c: f32 = match entrada_c.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter lado C!");
            return;
        }
    };

    if lado_a == lado_b && lado_b == lado_c {
        println!("O triângulo é Equilátero (todos os lados iguais).");
    } else if lado_a == lado_b || lado_b == lado_c || lado_a == lado_c {
        println!("O triângulo é Isósceles (dois lados iguais).");
    } else {
        println!("O triângulo é Escaleno (todos os lados diferentes).");
    }
}

use std::io;

fn main() {
    println!("Digite um número para o dia da semana:");
    let mut entrada_dia: String = String::new();
    io::stdin()
        .read_line(&mut entrada_dia)
        .expect("Erro na entrada!");

    let dia: u8 = match entrada_dia.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter dia!");
            return;
        }
    };

    if dia == 1 || dia == 7 {
        if dia == 1 {
            println!("Domingo - Fim de semana!");
        } else {
            println!("Sábado - Fim de semana!");
        }
    } else if dia == 2 {
        println!("Segunda-feira - Dia útil!");
    } else if dia == 3 {
        println!("Terça-feira - Dia útil!");
    } else if dia == 4 {
        println!("Quarta-feira - Dia útil!");
    } else if dia == 5 {
        println!("Quinta-feira - Dia útil!");
    } else if dia == 6 {
        println!("Sexta-feira - Dia útil!");
    } else {
        println!("Erro!");
    }
}

use std::io;

fn main() {
    println!("Digite sua idade:");
    let mut entrada_idade: String = String::new();
    io::stdin()
        .read_line(&mut entrada_idade)
        .expect("Erro na entrada!");

    let idade: u8 = match entrada_idade.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter idade!");
            return;
        }
    };

    if idade >= 1 && idade <= 12 {
        println!("Classificação: Criança!");
    } else if idade >= 13 && idade <= 17 {
        println!("Classificação: Adolescente!");
    } else if idade >= 18 && idade <= 59 {
        println!("Classificação: Adulto!");
    } else if idade >= 60 {
        println!("Classificação: Idoso!");
    } else {
        println!("Idade inválida!");
    }
}

use std::io;

fn main() {
    println!("Digite o primeiro número:");
    let mut entrada_primeiro_num: String = String::new();
    io::stdin()
        .read_line(&mut entrada_primeiro_num)
        .expect("Erro ao receber o primeiro número!");

    println!("Digite o segundo número:");
    let mut entrada_segundo_num: String = String::new();
    io::stdin()
        .read_line(&mut entrada_segundo_num)
        .expect("Erro ao receber o segundo número!");

    println!("Insira o operador (+, -, *, /):");
    let mut entrada_operador: String = String::new();
    io::stdin()
        .read_line(&mut entrada_operador)
        .expect("Erro ao receber o operador matemático!");

    let primeiro_numero: f32 = match entrada_primeiro_num.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter o primeiro número!");
            return;
        }
    };

    let segundo_numero: f32 = match entrada_segundo_num.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter o segundo número!");
            return;
        }
    };

    let operador: char = match entrada_operador.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter o operador!");
            return;
        }
    };

    if operador == '+' {
        println!("Resultado: {} {} {} = {}", primeiro_numero, operador, segundo_numero, primeiro_numero + segundo_numero);
    } else if operador == '-' {
        println!("Resultado: {} {} {} = {}", primeiro_numero, operador, segundo_numero, primeiro_numero - segundo_numero);
    } else if operador == '*' {
        println!("Resultado: {} {} {} = {}", primeiro_numero, operador, segundo_numero, primeiro_numero * segundo_numero);
    } else if operador == '/' {
        if segundo_numero == 0.0 {
            println!("[Erro] Divisão por zero não é permitida.");
        } else {
            println!("Resultado: {} {} {} = {}", primeiro_numero, operador, segundo_numero, primeiro_numero / segundo_numero);
        }
    } else {
        println!("[Erro] Operador matemático não reconhecido!");
    }
}

use std::io;

fn main() {
    println!("Digite o valor total da compra:");
    let mut entrada_valor: String = String::new();
    io::stdin()
        .read_line(&mut entrada_valor)
        .expect("Erro ao receber o valor!");

    let valor_compra: f32 = match entrada_valor.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("Erro ao converter valor!");
            return;
        }
    };

    if valor_compra < 100.0 {
        println!("Valor: R$ {:.2} - Sem desconto!", valor_compra);
    } else if valor_compra >= 100.0 && valor_compra <= 500.0 {
        let valor_desconto: f32 = valor_compra * 0.10; // 10%
        let novo_valor: f32 = valor_compra - valor_desconto;
        println!("Valor: R$ {:.2} - Desconto de 10% (R$ {:.2})\nNovo valor: R$ {:.2}", valor_compra, valor_desconto, novo_valor);
    } else if valor_compra > 500.0 {
        let valor_desconto: f32 = valor_compra * 0.20; // 20%
        let novo_valor: f32 = valor_compra - valor_desconto;
        println!("Valor: R$ {:.2} - Desconto de 20% (R$ {:.2})\nNovo valor: R$ {:.2}", valor_compra, valor_desconto, novo_valor);
    } else {
        println!("Valor inválido!");
    }
}

use std::io;

const MSG_ERRO_ENTRADA: &str = "Erro na leitura de dados!";
const MSG_ERRO_CONVERSAO: &str = "Erro ao converter valor para número!";

fn main() {
    println!("Digite o Peso (em kg):");
    let mut entrada_peso: String = String::new();
    io::stdin().read_line(&mut entrada_peso).expect(MSG_ERRO_ENTRADA);

    let peso: f32 = match entrada_peso.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("{}", MSG_ERRO_CONVERSAO);
            return;
        }
    };

    println!("Digite a Altura (em metros):");
    let mut entrada_altura: String = String::new();
    io::stdin().read_line(&mut entrada_altura).expect(MSG_ERRO_ENTRADA);

    let altura: f32 = match entrada_altura.trim().parse() {
        Ok(val) => val,
        Err(_) => {
            println!("{}", MSG_ERRO_CONVERSAO);
            return;
        }
    };

    let imc: f32 = peso / (altura * altura);
    println!("Seu IMC é: {:.2}", imc);

    if imc <= 18.5 {
        println!("Classificação: Abaixo do Peso!");
    } else if imc <= 24.9 {
        println!("Classificação: Peso Normal!");
    } else if imc <= 29.9 {
        println!("Classificação: Sobrepeso!");
    } else if imc >= 30.0 {
        println!("Classificação: Obesidade!");
    } else {
        println!("Erro ao calcular IMC ou faixa inválida!");
    }
}

use std::io;

const USERNAME_CORRETO: &str = "admin";
const PASSWORD_CORRETA: &str = "1234";

fn main() {
    println!("Digite o Nome de Usuário:");
    let mut entrada_usuario: String = String::new();
    io::stdin()
        .read_line(&mut entrada_usuario)
        .expect("Erro na leitura!");
    let nome_usuario: &str = entrada_usuario.trim();

    println!("Digite a Senha:");
    let mut entrada_senha: String = String::new();
    io::stdin()
        .read_line(&mut entrada_senha)
        .expect("Erro na leitura!");
    let senha: &str = entrada_senha.trim();

    if nome_usuario == USERNAME_CORRETO && senha == PASSWORD_CORRETA {
        println!("Acesso Concedido! Bem-vindo(a), {}!", nome_usuario);
    } else {
        println!("Acesso Negado! Verifique seu usuário e senha.");
    }
}

use std::io;
use std::time::{SystemTime, UNIX_EPOCH};

fn main() {
    //
    println!("--- Início ---");
    println!("Jogador 1");
    println!("Computador");
    println!("");

    println!("-- Selecionar --");
    println!("  Jogador 1  ");
    println!("");
    println!("[1] Pedra");
    println!("[2] Papel");
    println!("[3] Tesoura");
    println!("");
    println!("1 | 2 | 3");

    //
    let mut entrada_jogador: String = String::new();
    io::stdin()
        .read_line(&mut entrada_jogador)
        .expect("Erro na entrada de dados!");
    let mut jogador: &str = entrada_jogador.trim();

    //
    if jogador == "1" {
        jogador = "Pedra";
    } else if jogador == "2" {
        jogador = "Papel";
    } else {
        jogador = "Tesoura";
    }

    //
    println!("");
    println!("-- Selecionar --");
    println!("  Jogador 2  ");
    println!("");
    println!("-- Sorteando --");
    println!("[1] Pedra");
    println!("[2] Papel");
    println!("[3] Tesoura");
    println!("");

    //
    let nanos = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .expect("Erro")
        .as_nanos();

    let nano_computador = (nanos % 3 + 1) as u8;
    let computador: &str;

    if nano_computador == 1 {
        computador = "Pedra";
    } else if nano_computador == 2 {
        computador = "Papel";
    } else {
        computador = "Tesoura";
    }

    //
    if jogador == computador {
        println!("Jogador 1: {} e Computador: {}", jogador, computador);
        println!("O jogo é um empate!");
    } else if jogador == "Pedra" {
        if computador == "Papel" {
            println!("Jogador 1: {} e Computador: {}", jogador, computador);
            println!("Jogador 1: Você Perdeu!");
        }
        if computador == "Tesoura" {
            println!("Jogador 1: {} e Computador: {}", jogador, computador);
            println!("Jogador 1: Você Venceu!");
        }
    } else if jogador == "Papel" {
        if computador == "Pedra" {
            println!("Jogador 1: {} e Computador: {}", jogador, computador);
            println!("Jogador 1: Você Venceu!");
        }
        if computador == "Tesoura" {
            println!("Jogador 1: {} e Computador: {}", jogador, computador);
            println!("Jogador 1: Você Perdeu!");
        }
    } else { 
        if computador == "Pedra" {
            println!("Jogador 1: {} e Computador: {}", jogador, computador);
            println!("Jogador 1: Você Perdeu!");
        }
        if computador == "Papel" {
            println!("Jogador 1: {} e Computador: {}", jogador, computador);
            println!("Jogador 1: Você Venceu!");
        }
    }
}

fn main() {
    let mut contador: u8 = 0;

    loop {
        contador += 1;
        println!("Contagem = {}", contador);
        if contador >= 5 {
            break;
        }
    }
}

const LIMITE: u8 = 100; 

fn main() {
    let mut soma_atual: u8 = 1; 

    loop {
        println!("{}", soma_atual);

        if soma_atual >= LIMITE {
            break;
        }

        soma_atual += soma_atual; 
    }
}

fn main() {
    let mut contador: u8 = 0;

    loop {
        contador += 1; 

        if contador >= 4 { 
            break;
        }

        println!("Estou preso em um loop!"); 
    }
}

fn main() {
    let mut contador: u8 = 0; 

    loop {
        contador += 1;

        if contador % 2 == 0 { 
            println!("O número {} é par.", contador);
        } else {
            println!("O número {} é ímpar.", contador);
        }

        if contador >= 10 { 
            break;
        }
    }
}

fn main() {
    let mut contador: f32 = 0.0; 

    loop {
        contador += 0.5; 
        println!("{}", contador);

        if contador >= 5.0 { 
            break;
        }
    }
}

use std::io;
use std::time::{SystemTime, UNIX_EPOCH};

const DANO: i8 = 10;

fn main() {
    
    let mut vida_jogador: i8 = 100; 
    let mut vida_monstro: i8 = 100; 

    let mut rodada = 0; 

    println!("--- Início do Jogo ---");
    println!("Jogador vs Monstro");
    println!("");
    
    loop {
        rodada += 1;

        println!("---- Estatísticas ----");
        println!(
            "Jogador:\n HP: {}\n Dano: 10\n Defesa: 10\n",
            vida_jogador 
        );
        println!(
            "Monstro:\n HP: {}\n Dano: 10\n Defesa: 10\n",
            vida_monstro 
        );

        println!("--- Jogador ---");
        println!("[1] Atacar!\n[2] Defender\n");

        let mut entrada_selecao_jogador: String = String::new(); 
        io::stdin()
            .read_line(&mut entrada_selecao_jogador)
            .expect("Erro ao inserir dados!"); 
        let selecao_jogador: i8 = entrada_selecao_jogador 
            .trim()
            .parse()
            .expect("Erro ao converter dados!"); 
        
        let entrada_selecao_monstro = SystemTime::now() 
            .duration_since(UNIX_EPOCH)
            .expect("Erro de tempo!") 
            .as_nanos();
        
        let selecao_monstro = (entrada_selecao_monstro % 2 + 1) as i8; 

        if selecao_jogador == 1 && selecao_monstro == 1 {
            vida_jogador = vida_jogador - (DANO * 2);
            vida_monstro = vida_monstro - (DANO * 2);
            println!("---- Rodada {} ----", rodada);
            println!("Jogador: Atacar\nMonstro: Atacar\n");
            println!("*** DANO DUPLO! ***\n"); 
        } else if selecao_jogador == 1 && selecao_monstro == 2 {
            vida_jogador = vida_jogador - (DANO / 2);
            println!("---- Rodada {} ----", rodada);
            println!("Jogador: Atacar\nMonstro: Defender\n");
            println!("*** JOGADOR BLOQUEADO! ***\n"); 
        } else if selecao_jogador == 2 && selecao_monstro == 1 {
            vida_monstro = vida_monstro - (DANO / 2);
            println!("---- Rodada {} ----", rodada);
            println!("Jogador: Defender\nMonstro: Atacar\n");
            println!("*** MONSTRO BLOQUEADO! ***\n"); 
        } else if selecao_jogador == 2 && selecao_monstro == 2 {
            vida_jogador = vida_jogador - (DANO * 2);
            vida_monstro = vida_monstro - (DANO * 2);
            println!("---- Rodada {} ----", rodada);
            println!("Jogador: Defender\nMonstro: Defender\n");
            println!("*** BLOQUEIO DUPLO! ***\n");
        }

        if vida_jogador <= 0 {
            println!("---- Estatísticas Finais ----");
            println!(
                "Jogador:\n HP: {}\n Dano: 10\n Defesa: 10\n",
                vida_jogador
            );
            println!(
                "Monstro:\n HP: {}\n Dano: 10\n Defesa: 10\n",
                vida_monstro
            );
            println!("--- Jogador ---\n*** VOCÊ PERDEU! ***");
            break;
        }
        if vida_monstro <= 0 {
            println!("---- Estatísticas Finais ----");
            println!(
                "Jogador:\n HP: {}\n Dano: 10\n Defesa: 10\n",
                vida_jogador
            );
            println!(
                "Monstro:\n HP: {}\n Dano: 10\n Defesa: 10\n",
                vida_monstro
            );
            println!("--- Jogador ---\n*** VOCÊ VENCEU! ***"); 
            break;
        }
    }
}

fn main() {
    println!("Contando de 1 .. 100!");
    let mut contador: u8 = 0;

    loop {
        contador += 1;

        if contador % 3 == 0 && contador % 5 == 0 {
            println!("FizzBuzz");

        } else if contador % 3 == 0 {
            println!("Fizz");

        } else if contador % 5 == 0 {
            println!("Buzz");

        } else {
            println!("{}", contador);
        }

        if contador >= 100 {
            break;
        }
    }
}

fn main() {  
    let mut capital: f32 = 1000.0; 
    let mut ano: u8 = 0; 

    loop {
        capital *= 1.07; 
        ano += 1;
        println!("Capital = {} e Ano = {}", capital, ano); 

        if capital >= 2000.0 {
            println!("Capital final = {}", capital);
            println!("Anos necessários = {}", ano);
            break;
        }
    }
}

fn main() {
    let mut caractere_atual: char = 'a'; 
    println!("-- Início --"); 

    loop {
        println!("Caractere: {}", caractere_atual); 
        let valor_inicial_char = caractere_atual as u8; 
        let proximo_valor_char = valor_inicial_char + 1;      
        caractere_atual = proximo_valor_char as char; 

        if caractere_atual > 'f' {
            break;
        }
    }
}

fn main() {
    let mut estado: (u8, bool) = (0, false); 

    loop {
        println!("{:?}", estado);
        estado.0 += 1; 

        if estado.0 > 5 {
            estado.1 = true; 
            println!("{:?}", estado);
            break;
        }
    }
}

use std::io;

fn main() {
    let mut pessoa: (String, u8, f32) = ("Pessoa".to_string(), 0, 0.0);
    println!("{:#?}", pessoa);

    let mut quantidade: u8 = 0; 

    loop {
        println!("Qual é o seu nome?"); 
        let mut entrada_nome: String = String::new(); 
        io::stdin()
            .read_line(&mut entrada_nome)
            .expect("Erro ao inserir dados!"); 
        let nome: String = entrada_nome.trim().to_string(); 

        println!("Qual é a sua idade?"); 
        let mut entrada_idade: String = String::new(); 
        io::stdin()
            .read_line(&mut entrada_idade)
            .expect("Erro ao inserir dados!");
        let idade: u8 = entrada_idade.trim().parse().expect("Erro ao converter dados!"); 

        println!("Qual é a sua altura?"); 
        let mut entrada_altura: String = String::new(); 
        io::stdin()
            .read_line(&mut entrada_altura)
            .expect("Erro ao inserir dados!");
        let altura: f32 = entrada_altura.trim().parse().expect("Erro ao converter dados!"); 

        quantidade += 1;

        pessoa = (nome, idade, altura);
        println!("{:#?}", pessoa);

        if quantidade >= 3 { 
            break;
        }
    }
}

fn main() {

    let array_inicial: [u8; 5] = [10, 20, 30, 40, 50];   
    let mut indice = 0; 

    loop {
        if indice >= array_inicial.len() {
            break;
        }

        println!("{}", array_inicial[indice]);
        indice += 1;
    }
}

fn main() {

    let array_inicial: [u8; 5] = [1, 2, 3, 4, 5];
    
    let mut indice = array_inicial.len() - 1; 

    loop {
        if indice <= 0 {
            println!("{}", array_inicial[indice]);
            break;
        }

        println!("{}", array_inicial[indice]); 
        indice -= 1;
    }
}

fn main() {
    let array_int_inicial: [u8; 2] = [1, 2];
    let array_float_inicial: [f32; 3] = [2.5, 7.3, 9.2];
    let array_char_inicial: [char; 4] = ['A', 'B', 'C', 'D'];
    let array_str_inicial: [&str; 5] = ["Ana", "Bruno", "Carla", "Daniel", "Elza"];

    let mut indice = 0;

    loop {
        if indice >= array_int_inicial.len() {
            break;
        }

        println!("{}", array_int_inicial[indice]);
        indice += 1;
    }
    println!("");

    indice = 0;
   
    loop {
        if indice >= array_float_inicial.len() {
            break;
        }

        println!("{}", array_float_inicial[indice]);
        indice += 1;
    }
    println!("");

    indice = 0;
   
    loop {
        if indice >= array_char_inicial.len() {
            break;
        }

        println!("{}", array_char_inicial[indice]);
        indice += 1;
    }
    println!("");

    indice = 0;
  
    loop {
        if indice >= array_str_inicial.len() {
            break;
        }

        println!("{}", array_str_inicial[indice]);
        indice += 1;
    }
}

fn main() {
    let array_inicial: [u8; 4] = [1, 2, 4, 5]; 
    let mut indice = 0;
    let mut soma = 0;

    loop { 
        if indice >= array_inicial.len() {
            break;
        }

        println!("Valor = {:?}", array_inicial[indice]);
        soma = soma + array_inicial[indice];
        indice += 1;
    }      
    println!("Soma = {}", soma);
}

fn main() {
    let mut array_preencher: [i32; 5] = [0; 5];
    let mut indice = 0;

    loop {
        if indice >= array_preencher.len() {
            break;
        }
        array_preencher[indice] = (indice as i32 + 1) * 10;
        indice += 1;
    }
    println!("Array = {:?}", array_preencher);
}

fn main() {
    let mut contador: u8 = 1; 
    let mut fatorial: u8 = 1; 

    loop {
        println!("Fatorial Parcial = {}", fatorial); 

        fatorial *= contador;
        contador += 1;

        if contador > 5 { 
            break;
        }
    }
    println!("Resultado do Fatorial = {}", fatorial);
}

fn main() {
    let mut numero: f32 = 123.0; 

    loop {
        let divisao = numero / 2.0; 
        let resto = numero % 2.0;

        numero = divisao; 
        println!("123 / 2 = {:.2}\n123 % 2 = {:.2}\n", divisao, resto);

        if numero < 1.0 { 
            break;
        }
    }
}

fn main() {
    let mut contador: u8 = 0; 

    loop {
        println!(
            "Contador = {} | 5 + contador * 2 = {}", 
            contador, 
            5 + contador * 2
        );
        
        println!(
            "Contador = {} | (5 + contador) * 2 = {}", 
            contador, 
            (5 + contador) * 2
        );

        contador += 1;        
        if contador > 5 {
            break;
        }
    }
}

use std::io;

const NUMERO_SECRETO: u8 = 42;

fn main() {
    println!("------- Início -------");
    println!("Jogador 1 VS Computador");
    println!("");
    println!("---------------------");
    println!("Você tem 3 tentativas!");

    let mut tentativas: u8 = 0;

    loop {
        println!("\nInsira um número:");
        
        let mut entrada_numero: String = String::new();
        io::stdin()
            .read_line(&mut entrada_numero)
            .expect("Erro ao inserir dados!");
            
        let numero_jogador: u8 = entrada_numero 
            .trim()
            .parse()
            .expect("Erro ao converter dados!");

        if numero_jogador > NUMERO_SECRETO {
            println!("Muito Alto!"); 
        } else if numero_jogador < NUMERO_SECRETO {
            println!("Muito Baixo!"); 
        } else {
            println!("\nVocê Venceu!"); 
            break;
        }

        tentativas += 1;
        if tentativas == 1 {
            println!("Você tem 2 tentativas restantes!"); 
        } else if tentativas == 2 {
            println!("Você tem 1 tentativa restante!");
        } else if tentativas == 3 {
            println!("VOCÊ PERDEU!");
            break;
        }
    }
}

fn main() {
    println!("-- Início --");
    let mut contador: i8 = 10; 

    loop {
        println!("Contagem Regressiva: {}", contador);
        contador -= 1; 
        if contador < 1 { 
            println!("Lançamento!");
            break;
        }
    }
}

fn main() {
    let mut array_preencher: [i8; 10] = [0; 10];   
    let mut indice = 0; 

    loop {
        if indice >= array_preencher.len() {
            break;
        }

        if indice % 2 == 0 {
            array_preencher[indice] = indice as i8;
        } else {
            array_preencher[indice] = indice as i8 * 2;
        }

        println!("Array = {:?}", array_preencher);
        indice += 1;
    }
}

fn main() {
    let mut contador: u8 = 1;

    while contador <= 5 { 
        println!("Contador = {}", contador);
        contador += 1;
    }
}

fn main() {
    let mut contador: u8 = 10; 

    while contador >= 1 { 
        println!("{}", contador);
        contador -= 1;

        if contador < 1 { 
            println!("Lançamento!");
        }
    }
}

fn main() {
    let mut soma: u16 = 0;    
    let mut contador: u8 = 1;
    
    while contador <= 100 { 
        soma += contador as u16; 
        contador += 1; 
    }
    
    println!("Soma = {}", soma);
}

fn main() {
    let mut contador: u8 = 0;

    loop { 
        contador += 1; 
        println!("Contador = {}", contador);

        if contador >= 7 {
            break; 
        }
    }
}

use std::io;

fn main() {
    println!("Insira um número:");
    
    let mut entrada_numero: String = String::new(); 
    io::stdin()
        .read_line(&mut entrada_numero)
        .expect("Erro de entrada de dados!"); 

    let mut numero: u16 = entrada_numero.trim().parse().expect("Erro na conversão de dados!"); 

    if numero == 1 {
        println!("{}", true); 
    } else {
        while numero % 2 == 0 {
            numero /= 2;
        }

        if numero == 1 {
            println!("{}", true);
        } else {
            println!("{}", false);
        }
    }
}

fn main() {
    let mut contador: u8 = 0; 
    while contador <= 10 { 
        
        if contador % 2 != 0 {
            contador += 1; 
            continue;
        }

        println!("Número par: {}", contador); 
        contador += 1; 
    }
}

use std::io;

fn main() {
    let mut condicao: u8 = 0;  
    while condicao <= 10 { 
        println!("Insira um número:");        
        let mut entrada_numero: String = String::new();         
        io::stdin()
            .read_line(&mut entrada_numero)
            .expect("Erro de entrada de dados!"); 
            
        let numero: u8 = entrada_numero.trim().parse().expect("Erro na conversão de dados!");
        println!("");

        condicao = numero; 

        if condicao <= 10 {
            println!("Número <= 10.");
            println!("Tente novamente!\n");
        } else {
            println!("Número > 10!");
        }
    }
}

use std::io;

fn main() {
    println!("Insira um número:");
    let mut entrada_numero: String = String::new(); 
    io::stdin()
        .read_line(&mut entrada_numero)
        .expect("Erro de entrada de dados!!");

    let numero: u16 = entrada_numero.trim().parse().expect("Erro na conversão de dados!"); 

    if numero == 0 {
        println!("Fatorial: 0 = 1");
    } else {

        let mut fatorial: u16 = 1;
        let mut i: u16 = 1;

        while i <= numero {
            fatorial *= i;
            i += 1;
        }

        println!("Fatorial: {} = {}", numero, fatorial);
    }
}

use std::io;

fn main() {
    println!("Insira um número:");

    let mut entrada_numero: String = String::new();
    io::stdin()
        .read_line(&mut entrada_numero)
        .expect("Erro na entrada de dados!");

    let mut numero: u16 = entrada_numero.trim().parse().expect("Erro na conversão de dados!");
    let numero_salvo = numero;
    let mut numero_invertido: u16 = 0; 

    if numero == 0 {
        numero_invertido = numero;
    } else {
        while numero > 0 {
            let digito = numero % 10; 
             numero_invertido = (numero_invertido * 10) + digito; 
             numero /= 10;
        }
    }
    println!("Número original: {}", numero_salvo);
    println!("Número invertido: {}", numero_invertido);
}

use std::io;

fn main() {
    println!("Insira um número:");     
    let mut entrada_numero: String = String::new();
    io::stdin()
        .read_line(&mut entrada_numero)
        .expect("Erro na entrada de dados!");

    let mut numero: u16 = entrada_numero.trim().parse().expect("Erro na conversão de dados!");
    let numero_salvo: u16 = numero;
    let mut contagem: u8 = 0;

    if numero == 0 {
        contagem = 1; 
    } else {
        while numero > 0 {
            numero /= 10;
            contagem += 1;
        }
    }
    println!("Contagem de dígitos de {} = {}", numero_salvo, contagem);
}

fn main() {
    let mut contador: u16 = 1;
    while contador <= 7 { 
        let quadrado: u16 = contador * contador;
        println!("Quadrado: {} = {}", contador, quadrado);
        contador += 1; 
    }
}

fn main() {
    let mut numero: u8 = 64; 
    while numero > 1 { 
        numero /= 2; 
        println!("Resultado = {}", numero); 
    }
}

fn main() {
    let mut numero: u8 = 51; 
    while numero % 2 > 0 { 
        numero += 1;
    }
    println!("Resultado = {}", numero); 
}

use std::io;

fn main() {
    let mut numero: u8 = 0;
    let numero_secreto: u8 = 42; 

    while numero != numero_secreto { 
        println!("Insira um número:");
        
        let mut entrada_numero: String = String::new(); 
        io::stdin()
            .read_line(&mut entrada_numero)
            .expect("Erro na entrada de dados!");

        numero = entrada_numero
            .trim()
            .parse()
            .expect("Erro na conversão do número!");

        if numero > numero_secreto {
            println!("Muito Alto!!!");
        } else if numero < numero_secreto {
            println!("Muito Baixo!!!");
        } else {
            println!("VOCÊ VENCEU!");
            break;
        }
    }
}

use std::io;

fn main() {
    println!("Insira um número:");
    let mut entrada_numero: String = String::new();
    io::stdin()
        .read_line(&mut entrada_numero)
        .expect("Erro na entrada de dados!");

    let numero_base: u8 = entrada_numero.trim().parse().expect("Erro na conversão de dados!");
    let mut contador: u8 = 0;
    let mut resultado: u8;
    println!();

    while contador < 5 { 
        contador += 1;
        resultado = contador * numero_base;

        println!("{}", resultado);
    }
}

use std::io;

fn main() {
    println!("Insira o número de linhas:");    
    let mut entrada_linha: String = String::new(); 
    io::stdin()
        .read_line(&mut entrada_linha)
        .expect("Erro na entrada de dados!");

    println!("Insira o número de colunas:"); 
    let mut entrada_coluna: String = String::new(); 
    io::stdin()
        .read_line(&mut entrada_coluna)
        .expect("Erro na entrada de dados!");

    let num_linhas: u8 = entrada_linha.trim().parse().expect("Erro na conversão de dados!"); 
    let num_colunas: u8 = entrada_coluna.trim().parse().expect("Erro na conversão de dados!"); 
    let simbolo: String = String::from("*");
    let mut contador_linha: u8 = 0;
    
    while contador_linha < num_linhas {      
        let mut contador_coluna: u8 = 0; 
        while contador_coluna < num_colunas {
            print!("{}", simbolo); 
            contador_coluna += 1;
        }
        println!(); 
        contador_linha += 1;
    }
}

use std::io;

fn main() {
    println!("Insira um número:");
    let mut entrada_numero: String = String::new();
    io::stdin()
        .read_line(&mut entrada_numero)
        .expect("Erro na entrada de dados!");

    let numero_base: u8 = entrada_numero.trim().parse().expect("Erro na conversão de dados!");
    let mut candidato_divisor: u8 = 0;
    let mut divisores_encontrados: u8 = 0;

    while divisores_encontrados < 5 {
        candidato_divisor += 1;

        if candidato_divisor == 0 {
            continue;
        }

        if numero_base % candidato_divisor == 0 {
            divisores_encontrados += 1;
            println!("{} % {} = 0", numero_base, candidato_divisor);
        }
 
        if candidato_divisor > numero_base && divisores_encontrados < 5 {
            println!("Os primeiros 5 múltiplos não foram encontrados!");
            break;
        }
    }
}

fn main() {
    for i in 1..=10 {
        println!("{}", i);
    }
}

fn main() {
    let mut soma: u16 = 0;

    for i in 1..=100 {
        soma += i;
        println!("{}", i);
        println!("{}", soma);
        println!();
    }

    println!("{}", soma);
}

fn main() {
    for i in 0..=20 {
        if i % 2 == 0 {
            println!("{}", i);
        }
    }
}

use std::io;

fn main() {
    println!("Insira um número:");
    let mut entrada_numero: String = String::new();
    io::stdin().read_line(&mut entrada_numero).err();
    let numero_limite: i16 = entrada_numero.trim().parse().expect("");

    println!("");
    for i in 0..=numero_limite {
        println!("Número: {:02} = {:b}", i, i);
    }
}

fn main() {
    for i in 0..=100 {
        println!("{:02}", i);
    }
}

fn main() {
    for i in 0..=100 {
        if i < 10 {
            println!("0{}", i)
        } else {
            println!("{}", i);
        }
    }
}

use std::io;

fn main() {
    println!("Insira um número:");
    let mut entrada_numero: String = String::new();
    io::stdin()
        .read_line(&mut entrada_numero)
        .expect("Erro na entrada de dados!");

    let numero_base: i16 = entrada_numero.trim().parse().expect("Erro na conversão de dados!");
    println!();

    for i in 1..=10 {
        let resultado: i16 = numero_base * i;
        println!("{} x {} = {}", numero_base, i, resultado);
    }
}

use std::io;

fn main() {
    println!("Insira um texto:");

    let mut entrada_texto: String = String::new();
    io::stdin()
        .read_line(&mut entrada_texto)
        .expect("Erro na entrada de dados!");

    let texto_original: String = entrada_texto.trim().to_string();
    let mut texto_invertido = String::new();

    for i in texto_original.chars().rev() {
        texto_invertido.push(i);
        println!("{}", texto_invertido);
    }

    println!("\n{}", texto_invertido);
}

use std::io;

fn main() {
    println!("Insira um número:");
    let mut entrada_numero: String = String::new();
    io::stdin().read_line(&mut entrada_numero).err();

    let mut soma_resultado: i16 = 0;

    for i in entrada_numero.trim().chars() {
        let digito_convertido: i16 = i.to_string().parse().expect("Erro na conversão de dados!");
        soma_resultado += digito_convertido;
    }

    println!("{}", soma_resultado);
}

use std::io;

fn main() {
    println!("Insira um texto:");

    let mut entrada_texto: String = String::new();
    io::stdin()
        .read_line(&mut entrada_texto)
        .expect("Erro na entrada de dados!");

    let texto_minusculo: String = entrada_texto.trim().to_lowercase().to_string();
    let mut qtd_vogais: u8 = 0;

    for i in texto_minusculo.chars() {
        if i == 'a' || i == 'e' || i == 'i' || i == 'o' || i == 'u' {
            qtd_vogais += 1;
        }
    }
    println!("Qtd. = {}", qtd_vogais);
}

fn main() {
    let array: [u8; 5] = [17, 43, 5, 54, 93];
    let mut maior_numero: u8 = 0;

    for (_i, j) in array.iter().enumerate() {
        if *j > maior_numero {
            maior_numero = *j;
        }
    }
    println!("{}", maior_numero);
}

fn main() {
    let array: [u8; 5] = [63, 36, 57, 7, 82];
    let mut menor_numero: u8 = array[1];

    for (_i, j) in array.iter().enumerate() {
        if *j < menor_numero {
            menor_numero = *j;
        }
    }
    println!("{}", menor_numero);
}

use std::io;

fn main() {
    println!("Insira um número:");
    let mut entrada_numero: String = String::new();
    io::stdin()
        .read_line(&mut entrada_numero)
        .expect("Erro na entrada de dados!");

    let numero_limite: u8 = entrada_numero.trim().parse().expect("Erro na conversão de dados!");
    let mut fatorial: u8 = 1;

    for i in 1..=numero_limite {
        fatorial *= i;
        println!("Fatorial Parcial = {}", fatorial);
    }
}

fn main() {
    let arr: [u8; 5] = [1, 2, 3, 4, 5];

    for i in arr.iter().rev() {
        println!("{:#?}", i);
    }
}

use std::io;

fn main() {
    println!("Insira uma palavra:");

    let mut entrada_palavra: String = String::new();
    io::stdin()
        .read_line(&mut entrada_palavra)
        .expect("Erro na entrada de dados!");

    let palavra_original: String = entrada_palavra.trim().to_lowercase().to_string();
    let mut palavra_invertida: String = String::new();

    for i in palavra_original.chars().rev() {
        palavra_invertida.push(i);
    }

    if palavra_original == palavra_invertida {
        println!("A palavra {} é um palíndromo!", palavra_original)
    } else {
        println!("A palavra {} não é um palíndromo!", palavra_original);
    }
}

use std::io;

fn main() {
    println!("Insira uma palavra:");

    let mut entrada_palavra: String = String::new();
    io::stdin()
        .read_line(&mut entrada_palavra)
        .expect("Erro na entrada de dados!");

    let palavra_base: String = entrada_palavra.trim().to_lowercase().to_string();

    println!("\nInsira o caractere de busca: ");

    let mut entrada_caractere: String = String::new();
    io::stdin()
        .read_line(&mut entrada_caractere)
        .expect("Erro na entrada de dados!");

    let caractere_busca: char = entrada_caractere.trim().parse().expect("Erro na entrada de dados!");

    let mut contagem: u8 = 0;

    for i in palavra_base.chars() {
        if i == caractere_busca {
            contagem += 1;
        }
    }

    if contagem >= 1 {
        println!("\nA letra '{}' se repete '{}' vezes!", caractere_busca, contagem);
    } else {
        println!("\nA letra '{}' não se repete.", caractere_busca);
    }
}

fn main() {
    let arr: [u8; 5] = [1, 2, 3, 4, 5];
    let mut mult: u8 = 1;

    for i in arr.iter() {
        mult *= i;
        println!("Stage {:?} = {:?}", i, mult);
    }
}

use std::io;

fn main() {
    let mut array_entrada: [i8; 5] = [0; 5];

    for i in 0..array_entrada.len() {
        println!("\nInsira o número para a posição {}:", i);
        let mut entrada_numero: String = String::new();
        io::stdin().read_line(&mut entrada_numero).expect("Erro ao ler dados!");
        array_entrada[i] = entrada_numero.trim().parse().expect("Erro na conversão de dados!");
    }

    println!("\nArray preenchido: {:?}", array_entrada);
}

use std::io;

fn main() {
    let mut array_numeros: [i8; 10] = [0; 10];
    let mut soma: u8 = 0;

    for i in 0..array_numeros.len() {

        println!("Insira o número:");
        let mut entrada_numero: String = String::new();
        io::stdin()
            .read_line(&mut entrada_numero)
            .expect("Erro na entrada de dados!");
        array_numeros[i] = entrada_numero.trim().parse().expect("Erro na conversão de dados!");

        soma += array_numeros[i] as u8;
    }

    soma /= 10;
    println!("Média = {}", soma);
}

use std::io;

fn main() {
    println!("Insira 5 números:");
    let mut array_entrada: [i8; 5] = [0; 5];
    let mut contagem: u8 = 0;

    for i in 0..array_entrada.len() {

        let mut entrada_numero: String = String::new();
        io::stdin()
            .read_line(&mut entrada_numero)
            .expect("Erro na entrada de dados!");
        array_entrada[i] = entrada_numero.trim().parse().expect("Erro na conversão de dados!");

        if array_entrada[i] < 0 {
            contagem += 1;
        }
    }

    println!("Contagem de números negativos = {}", contagem);
}

use std::io;

fn main() {
    println!("Insira 5 números:");
    let mut array_entrada: [i8; 5] = [0; 5];
    let mut array_pares: [i8; 5] = [0; 5];

    for i in 0..array_entrada.len() {

        let mut entrada_numero: String = String::new();
        io::stdin()
            .read_line(&mut entrada_numero)
            .expect("Erro na entrada de dados!");
        array_entrada[i] = entrada_numero.trim().parse().expect("Erro na conversão de dados!");

        if array_entrada[i] % 2 == 0 {
            array_pares[i] = array_entrada[i];
        }
    }

    println!("\nArray de pares (ímpares são 0): {:?}", array_pares);
}

use std::io;

fn main() {
    println!("Insira o número de usuários que deseja adicionar:");
    let mut entrada_contagem: String = String::new();
    io::stdin().read_line(&mut entrada_contagem).expect("Erro ao ler a contagem!");
    let quantidade: u8 = entrada_contagem.trim().parse().expect("Erro na conversão de dados!");

    let mut dados_usuario: (String, u8);

    for _i in 0..quantidade {
        println!("\nInsira o nome:");
        let mut entrada_nome: String = String::new();
        io::stdin().read_line(&mut entrada_nome).expect("Erro ao ler o nome!");
        let nome = entrada_nome;

        println!("\nInsira a idade:");
        let mut entrada_idade: String = String::new();
        io::stdin().read_line(&mut entrada_idade).expect("Erro ao ler a idade!");
        let idade: u8 = entrada_idade.trim().parse().expect("Erro na conversão de dados!");

        dados_usuario = (nome, idade);
        println!("\nNome:{} Idade:{}", dados_usuario.0, dados_usuario.1);
    }
}

use std::io;

fn main() {
    println!("Insira um caractere (a-z):");

    let mut entrada: String = String::new();
    io::stdin()
        .read_line(&mut entrada)
        .expect("Erro na leitura da entrada!");

    let caractere = entrada.trim();

    match caractere {
        "a" | "e" | "i" | "o" | "u" => println!("O caractere '{}' é uma vogal!", caractere),
        "" => println!("Nenhum caractere foi inserido!"),
        _ => println!("O caractere '{}' é uma consoante!", caractere),
    };
}

use std::io;

fn main() {
    println!("Insira sua nota (0 a 10):");

    let mut entrada: String = String::new();
    io::stdin()
        .read_line(&mut entrada)
        .expect("Erro na leitura da entrada!");

    let nota: u8 = match entrada.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro: O dado inserido não é um número válido!");
            return;
        }
    };

    match nota {
        9 | 10 => println!("Sua nota é: '{}' = 'A'", nota),
        7 | 8 => println!("Sua nota é: '{}' = 'B'", nota),
        5 | 6 => println!("Sua nota é: '{}' = 'C'", nota),
        3 | 4 => println!("Sua nota é: '{}' = 'D'", nota),
        1 | 2 => println!("Sua nota é: '{}' = 'E'", nota),
        0 => println!("Sua nota é: '{}' = 'F'", nota),
        _ => println!("A nota '{}' fornecida não é válida (fora do intervalo 0-10)!", nota),
    };
}

use std::io;

fn main() {
    println!("Insira sua idade:");

    let mut entrada: String = String::new();
    io::stdin()
        .read_line(&mut entrada)
        .expect("Erro na leitura da entrada!");

    let idade: u8 = match entrada.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro: O dado inserido não é um número válido!");
            return;
        }
    };

    match idade {
        0..=12 => println!("Criança!"),
        13..=17 => println!("Adolescente!"),
        18..=59 => println!("Adulto!"),
        60..=120 => println!("Idoso!"),
        _ => println!("Idade fora do limite de análise!"),
    };
}

use std::io;

fn main() {
    println!("Insira usuário:");
    let mut login = String::new();
    io::stdin()
        .read_line(&mut login)
        .expect("Erro na inserção de dados!");

    println!("Insira senha:");
    let mut password = String::new();
    io::stdin()
        .read_line(&mut password)
        .expect("Erro na inserção de dados!");

    let data: (&str, &str) = (login.trim(), password.trim());

    match data {
        ("admin", "1234") => println!("\nAdmin logado!"),
        ("user", "pass") => println!("\nUsuário logado!"),
        _ => println!("\nCredenciais inválidas!"),
    };
}

use std::io;

fn main() {
    println!("Insira a temperatura:");

    let mut entrada: String = String::new();
    io::stdin()
        .read_line(&mut entrada)
        .expect("Erro na inserção de dados!");

    let temperatura: f32 = match entrada.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro na conversão de dados!");
            return;
        }
    };

    match temperatura {
        f32::MIN..=-1.0 => println!("Congelante"),
        0.0..=15.0 => println!("Frio"),
        16.0..=25.0 => println!("Agradável"),
        26.0..=35.0 => println!("Quente"),
        _ => println!("Muito Quente"),
    };
}

use std::io;

fn main() {
    println!("Insira o número");

    let mut entrada: String = String::new();
    io::stdin()
        .read_line(&mut entrada)
        .expect("Erro na inserção de dados!");

    let numero: u8 = match entrada.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro na conversão de dados!");
            return;
        }
    };

    match numero {
        1 => println!("Domingo"),
        2 => println!("Segunda-feira"),
        3 => println!("Terça-feira"),
        4 => println!("Quarta-feira"),
        5 => println!("Quinta-feira"),
        6 => println!("Sexta-feira"),
        7 => println!("Sábado"),
        _ => println!("Insira um valor válido!"),
    }
}

use std::io;

fn main() {
    println!("Insira o número");

    let mut entrada: String = String::new();
    io::stdin()
        .read_line(&mut entrada)
        .expect("Erro na inserção de dados!");

    let numero:u8 = match entrada.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro na conversão de dados!");
            return;
        }
    };

    match numero {
        1 => println!("Janeiro - 31 Dias"),
        2 => println!("Fevereiro - 28 Dias"),
        3 => println!("Março - 31 Dias"),
        4 => println!("Abril - 30 Dias"),
        5 => println!("Maio - 31 Dias"),
        6 => println!("Junho - 30 Dias"),
        7 => println!("Julho - 31 Dias"),
        8 => println!("Agosto - 31 Dias"),
        9 => println!("Setembro - 30 Dias"),
        10 => println!("Outubro - 31 Dias"),
        11 => println!("Novembro - 30 Dias"),
        12 => println!("Dezembro - 31 Dias"),
        _ => println!("Insira um valor válido!"),
    }
}

use std::io;

fn main() {
    println!("Insira um caractere:");
    let mut input = String::new();
    io::stdin()
        .read_line(&mut input)
        .expect("Erro na inserção de dados!");

    let ch: char = input.chars().next().unwrap();

    match ch {
        '0'..='9' => println!("Número: 0-9!"),
        'a'..='z' | 'A'..='Z' => println!("Letra: aA - zZ!"),
        ' ' => println!("Espaço!"),
        _ => println!("Símbolo especial!"),
    }
}

use std::io;

fn main() {
    println!("Insira a coordenada (x):");

    let mut entrada_x = String::new();
    io::stdin()
        .read_line(&mut entrada_x)
        .expect("Erro na inserção de dados!");

    let coordenada_x: i16 = match entrada_x.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro na conversão de dados!");
            return;
        }
    };

    println!("Insira a coordenada (y):");

    let mut entrada_y = String::new();
    io::stdin()
        .read_line(&mut entrada_y)
        .expect("Erro na inserção de dados!");

    let coordenada_y: i16 = match entrada_y.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro na conversão de dados!");
            return;
        }
    };

    match (coordenada_x, coordenada_y) {
        (0, 0) => println!("Origem"),
        (x, y) if x > 0 && y > 0 => println!("Quadrante I"),
        (x, y) if x < 0 && y > 0 => println!("Quadrante II"),
        (x, y) if x < 0 && y < 0 => println!("Quadrante III"),
        (x, y) if x > 0 && y < 0 => println!("Quadrante IV"),
        _ => println!("Sobre o eixo!"),
    };
}

use std::{io, u8};

fn main() {
    println!("Insira o tipo (V ou N):");

    let mut entrada_tipo: String = String::new();
    io::stdin()
        .read_line(&mut entrada_tipo)
        .expect("Erro na inserção de dados!");

    let tipo: char = entrada_tipo.chars().next().unwrap();

    println!("Insira a quantidade:");

    let mut entrada_quantidade: String = String::new();
    io::stdin()
        .read_line(&mut entrada_quantidade)
        .expect("Erro na inserção de dados!");

    let quantidade: u8 = match entrada_quantidade.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro na conversão de dados!");
            return;
        }
    };

    match (tipo, quantidade) {
        ('V' | 'v', u8::MIN..=u8::MAX) => println!("20% de desconto sempre!"),
        ('N' | 'n', 10..=u8::MAX) => println!("10% de desconto!"),
        ('N' | 'n', 5..=9) => println!("5% de desconto!"),
        _ => println!("Sem desconto!"),
    };
}

use std::io;

fn main() {
    println!("Insira o número (A):");

    let mut entrada_a: String = String::new();
    io::stdin()
        .read_line(&mut entrada_a)
        .expect("Erro na inserção de dados!");

    let numero_a: f32 = match entrada_a.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro na conversão de dados!");
            return;
        }
    };

    println!("Insira o número (B):");

    let mut entrada_b: String = String::new();
    io::stdin()
        .read_line(&mut entrada_b)
        .expect("Erro na inserção de dados!");

    let numero_b: f32 = match entrada_b.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro na conversão de dados!");
            return;
        }
    };

    println!("Insira o operador: +, -, *, /");

    let mut entrada_operador: String = String::new();
    io::stdin()
        .read_line(&mut entrada_operador)
        .expect("Erro na inserção de dados!");

    let operador: char = entrada_operador.trim().chars().next().unwrap();

    let _resultado = match operador {
        '+' => println!("\n{} + {} = {}", numero_a, numero_b, numero_a + numero_b),
        '-' => println!("\n{} - {} = {}", numero_a, numero_b, numero_a - numero_b),
        '*' => println!("\n{} * {} = {}", numero_a, numero_b, numero_a * numero_b),
        '/' => println!("\n{} / {} = {}", numero_a, numero_b, numero_a / numero_b),
        _ => println!("\nErro de cálculo!"),
    };
}

use std::io;

fn main() {
    println!("-- Início do Jogo --");
    println!("");
    println!("Selecione:");
    println!("[1] Pedra");
    println!("[2] Papel");
    println!("[3] Tesoura");
    println!("");

    println!("Jogador 1:");
    let mut entrada_jogador1: String = String::new();
    io::stdin()
        .read_line(&mut entrada_jogador1)
        .expect("Erro na inserção de dados!");

    let escolha_jogador1: u8 = match entrada_jogador1.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro na conversão de dados!");
            return;
        }
    };

    println!("\nJogador 2:");
    let mut entrada_jogador2: String = String::new();
    io::stdin()
        .read_line(&mut entrada_jogador2)
        .expect("Erro na inserção de dados!");

    let escolha_jogador2: u8 = match entrada_jogador2.trim().parse() {
        Ok(valor) => valor,
        Err(_) => {
            println!("Erro na conversão de dados!");
            return;
        }
    };

    let _resultado = match (escolha_jogador1, escolha_jogador2) {
        (1, 1) => println!("Jogo empatado!"),
        (1, 2) => println!("Jogador 2 - Vence!"),
        (1, 3) => println!("Jogador 1 - Vence!"),
        (2, 1) => println!("Jogador 1 - Vence!"),
        (2, 2) => println!("Jogo empatado!"),
        (2, 3) => println!("Jogador 2 - Vence!"),
        (3, 1) => println!("Jogador 2 - Vence!"),
        (3, 2) => println!("Jogador 1 - Vence!"),
        (3, 3) => println!("Jogo empatado!"),
        _ => println!("Erro ao processar jogo!"),
    };
}