Funções, if/else e loops: quando um ponto e vírgula muda o programa

Expressão e instrução: o ponto e vírgula muda o valorVídeo · 0:32 · legendas em português

ENTENDA A IDEIA

A ideia central

Exemplo Rust

fn double(value: i32) -> i32 {
    value * 2 // expressão: este é o valor devolvido
}
// value * 2; seria uma instrução: o corpo valeria ()

EXPERIMENTE

Edite e execute

A função triple devolve o dobro. Troque value * 2 por value * 3. Não acrescente return nem ponto e vírgula: a última expressão continua sendo o retorno. Execute.

Objetivo

Faça a última expressão da função valer o triplo do argumento.

Saída esperada

triplo de 7: 21

Rust 2021 · Edite e execute

fn triple(value: i32) -> i32 {
    value * 2
}

fn main() {
    println!("triplo de 7: {}", triple(7));
}

ENTENDA A IDEIA

A ideia central

error[E0308]: mismatched types
 --> src/main.rs:1:26
  |
1 | fn triple(value: i32) -> i32 {
  |    ------                ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
2 |     value * 3;
  |              - help: remove this semicolon to return this value

Esta é a resposta do rustc 1.98 para value * 3; no fim de triple. A função promete i32, mas o corpo não tem expressão final: o retorno implícito vira (). O help aponta o caractere exato que você deve remover.

O return explícito continua existindo, para saídas antecipadas: quando uma condição já define o resultado no meio da função. Na última linha, o clippy marca um return desnecessário com o lint needless_return.

EXPERIMENTE

Edite e execute

Pedidos abaixo de 100 não têm desconto. No início de discount, acrescente if total < 100 { return 0; }. A última linha continua sendo a expressão do caso normal. Execute para ver os dois pedidos.

Objetivo

Devolva zero de desconto, antes do cálculo, para pedidos abaixo de 100.

Saída esperada

desconto de 80: 0
desconto de 250: 25

Rust 2021 · Edite e execute

fn discount(total: u32) -> u32 {
    total / 10
}

fn main() {
    println!("desconto de 80: {}", discount(80));
    println!("desconto de 250: {}", discount(250));
}

if como expressão: a decisão vira um valorVídeo · 0:30 · legendas em português

ENTENDA A IDEIA

A ideia central

Exemplo Rust

let grade = 8.5;
let label = if grade >= 7.0 { "aprovado" } else { "recuperação" };
// if grade >= 7.0 { "aprovado" } else { 0 }  → E0308
// if count { ... } com count: i32            → E0308

EXPERIMENTE

Edite e execute

A condição considera esgotado qualquer estoque até 5. Troque stock > 5 por stock > 0. Os dois ramos continuam sendo textos, e o if continua sendo o valor de status. Execute.

Objetivo

Corrija a condição para que só um estoque zero seja esgotado.

Saída esperada

estoque 3: disponível
estoque 0: esgotado

Rust 2021 · Edite e execute

fn main() {
    for stock in [3, 0] {
        let status = if stock > 5 { "disponível" } else { "esgotado" };
        println!("estoque {stock}: {status}");
    }
}

ENTENDA A IDEIA

A ideia central

Uma pergunta separa as linguagens em duas famílias: “quanto vale um if?”. Em C, Java e Go, a pergunta nem faz sentido; para guardar uma decisão, você declara a variável antes e atribui dentro de cada ramo. Em Rust, a decisão já é o valor: o let profile da aula 02 declara e decide em uma linha.

O mesmo vale para o corpo inteiro de uma função. Quando o corpo é uma expressão, a função se lê como uma definição (“o dobro de value é value * 2”), não como uma sequência de comandos. E como cada expressão tem um tipo conhecido na compilação, o compilador recusa um ramo de outro tipo, um else ausente ou uma condição numérica antes de o programa existir.

Exemplo Rust

let release = true;
let profile = if release { "release" } else { "debug" };
// uma linha: declara e decide, sem let mut à espera

EXPERIMENTE

Edite e execute

O programa declara label com mut e atribui dentro do if. Reescreva as duas linhas como uma expressão: let label = if speed > 60 { "rápido" } else { "normal" };. Note que o limite também muda, de 80 para 60. Execute: o mut desaparece.

Objetivo

Troque a variável mutável por um if que vale o rótulo, com o limite 60.

Saída esperada

72 km/h: rápido

Rust 2021 · Edite e execute

fn main() {
    let speed = 72;
    let mut label = "normal";
    if speed > 80 {
        label = "rápido";
    }
    println!("{speed} km/h: {label}");
}

CÓDIGO ANOTADO

Código anotado

Este é o início do programa da aula: uma tabela de temperaturas que usa cada construção no lugar certo. Os blocos anotados formam um programa completo; os desafios de edição já trazem programas independentes.

A cadeia if/else if/else é a única expressão do corpo, e o ramo escolhido é o retorno. Os três ramos têm o mesmo tipo, &'static str. A ordem dos testes define as faixas: quem chega ao segundo teste já tem 15.0 ou mais.

Os limites usam <, então cada fronteira pertence à faixa de cima: 15.0 é “agradável”, e 30.0 é “quente”. O primeiro exercício cobra exatamente essas bordas. O else final não é opcional: sem ele, existiria um caminho sem valor, e a função não teria o que devolver.

Exemplo Rust

// classify devolve a faixa da temperatura; o corpo inteiro é UMA expressão.
fn classify(celsius: f64) -> &'static str {
    if celsius < 15.0 {
        "frio"
    } else if celsius < 30.0 {
        "agradável"
    } else {
        "quente"
    }
}

DESAFIO

Classifique a temperatura com if/else como expressão

Escreva a função classify, a mesma do programa da aula, agora sem olhar. O harness confere as bordas:

pub fn classify(celsius: f64) -> &'static str

Entrada: uma temperatura em graus Celsius.
Saída: "frio" abaixo de 15.0; "agradável" de 15.0 (inclusive) até 30.0 (exclusive); "quente" de 30.0 em diante.
Exemplo: classify(14.9) devolve "frio"; classify(15.0) devolve "agradável"; classify(30.0) devolve "quente".
Restrições: sem return: o corpo deve ser uma única cadeia if/else if/else cujo valor é o retorno. As três strings devem ser iguais, byte a byte.

As fronteiras são o teste real: 15.0 e 30.0 pertencem cada uma à faixa de cima. Escreva primeiro os dois casos de borda no papel e só então a cadeia. O stub sempre devolve "frio", então quatro dos seis casos falham até a cadeia estar completa.

Edite stub.rs. Os controles mostram a execução disponível para este exercício.

Rust 2021 · stub.rs

// classify devolve a faixa da temperatura: "frio" abaixo de 15.0,
// "agradável" de 15.0 até 29.99..., "quente" de 30.0 em diante.
// Sem return: o corpo é uma única cadeia if/else if/else.
pub fn classify(celsius: f64) -> &'static str {
    // implemente:
    let _ = celsius;
    "frio"
}

Arquivos, contrato, dicas e solução

Exercício 1

Classifique a temperatura com if/else como expressão

stub.rs

// classify devolve a faixa da temperatura: "frio" abaixo de 15.0,
// "agradável" de 15.0 até 29.99..., "quente" de 30.0 em diante.
// Sem return: o corpo é uma única cadeia if/else if/else.
pub fn classify(celsius: f64) -> &'static str {
    // implemente:
    let _ = celsius;
    "frio"
}

harness.rs

fn json_escape(value: &str) -> String {
    value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
}

fn print_result(case: usize, pass: bool, input: &str, want: &str, got: &str) {
    println!(
        "RESULT {{\"case\":{case},\"pass\":{pass},\"input\":\"{}\",\"want\":\"{}\",\"got\":\"{}\"}}",
        json_escape(input),
        json_escape(want),
        json_escape(got)
    );
}

fn main() {
    let cases: [(f64, &str); 6] = [
        (14.9, "frio"),
        (15.0, "agradável"),
        (29.9, "agradável"),
        (30.0, "quente"),
        (-5.0, "frio"),
        (40.0, "quente"),
    ];
    for (index, (celsius, want)) in cases.iter().enumerate() {
        let got = classify(*celsius);
        let pass = got == *want;
        print_result(index + 1, pass, &format!("{celsius:.1}"), want, got);
    }
}

cases.json

[
  {
    "case": 1,
    "input": "14.9",
    "want": "frio"
  },
  {
    "case": 2,
    "input": "15.0",
    "want": "agradável"
  },
  {
    "case": 3,
    "input": "29.9",
    "want": "agradável"
  },
  {
    "case": 4,
    "input": "30.0",
    "want": "quente"
  },
  {
    "case": 5,
    "input": "-5.0",
    "want": "frio"
  },
  {
    "case": 6,
    "input": "40.0",
    "want": "quente"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`14.9`	`frio`
2	`15.0`	`agradável`
3	`29.9`	`agradável`
4	`30.0`	`quente`
5	`-5.0`	`frio`
6	`40.0`	`quente`

Execute com o Cargo local

Execute os comandos de preparação.
Copie os arquivos acima para os arquivos vazios com os mesmos nomes.
Execute a verificação de base. O stub deve mostrar o comportamento atual.

Comandos de preparação

cargo new --bin --edition 2024 imersao-04-funcoes-e-fluxo-exercicio-1
cd imersao-04-funcoes-e-fluxo-exercicio-1
touch stub.rs harness.rs cases.json
printf 'include!("../stub.rs");\ninclude!("../harness.rs");\n' > src/main.rs

Verificação de base — confirme o comportamento atual antes da mudança

cargo fmt --check
cargo run --bin imersao-04-funcoes-e-fluxo-exercicio-1
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

São três faixas em ordem: abaixo de 15.0 é "frio", abaixo de 30.0 é "agradável", o resto é "quente" — um if/else if/else resolve, sem return.
Faça a cadeia inteira ser a última expressão da função: cada ramo termina em um literal &'static str sem ponto e vírgula, e o valor do if é o retorno.

Revelar solução

solution.rs

// classify devolve a faixa da temperatura: "frio" abaixo de 15.0,
// "agradável" de 15.0 até 29.99..., "quente" de 30.0 em diante.
// Sem return: o corpo é uma única cadeia if/else if/else.
pub fn classify(celsius: f64) -> &'static str {
    if celsius < 15.0 {
        "frio"
    } else if celsius < 30.0 {
        "agradável"
    } else {
        "quente"
    }
}

A cadeia if/else if/else como expressão final devolve o ramo escolhido; os limites usam < para que 15.0 caia em "agradável" e 30.0 em "quente". A armadilha é pôr ponto e vírgula nos ramos e transformar a expressão em instrução — o E0308 da aula.

A cadeia da aula, com os limites em <:

pub fn classify(celsius: f64) -> &'static str {
    if celsius < 15.0 {
        "frio"
    } else if celsius < 30.0 {
        "agradável"
    } else {
        "quente"
    }
}

A ordem dos testes faz o trabalho das faixas: quem chega ao segundo if já falhou no primeiro, então celsius < 30.0 ali significa, na prática, “de 15.0 até antes de 30.0”. As fronteiras saem certas: 15.0 < 15.0 é falso, então 15.0 cai no segundo ramo; 30.0 < 30.0 é falso, então 30.0 cai no else. O custo é O(1), com no máximo duas comparações.

A armadilha sintática é a da aula: um ponto e vírgula nos ramos ("frio";) ou depois da cadeia transforma a expressão em instrução e causa o E0308. A armadilha lógica é usar <= nos limites: celsius <= 15.0 moveria 15.0 para “frio”, e o caso de borda falharia.

A alternativa com return em cada ramo compila e passa, mas perde a leitura declarativa (“a classificação é esta cadeia”), e o clippy marca o return final com needless_return.

for, while e loop: três laços, três usosVídeo · 0:34 · legendas em português

ENTENDA A IDEIA

A ideia central

Exemplo Rust

for n in 1..=3 { /* 1, 2, 3 */ }      // percorre um range
while fuel > 0 { fuel -= 1; }         // repete enquanto vale
let found = loop { break 42; };       // break entrega um valor

EXPERIMENTE

Edite e execute

O range 1..5 para no 4, e a soma dá 10. Troque 1..5 por 1..=5. Mantenha o acumulador e a mensagem. Execute: a soma deve incluir o 5.

Objetivo

Inclua o 5 no range para somar de 1 a 5.

Saída esperada

soma de 1 a 5: 15

Rust 2021 · Edite e execute

fn main() {
    let mut total = 0;
    for value in 1..5 {
        total += value;
    }
    println!("soma de 1 a 5: {total}");
}

CÓDIGO ANOTADO

Código anotado

O main começa pela tabela. O range 0..=35 gera os inteiros de 0 a 35, e step_by(5) seleciona um a cada cinco: o for visita 0, 5, 10 e assim por diante, até 35.

classify exige f64, e o range produz inteiros. A conversão é explícita: f64::from(celsius). Esse construtor existe quando a conversão nunca perde informação, o que é mais seguro do que as.

O formato {celsius:>2} alinha o número à direita em duas colunas, para a tabela sair alinhada.

Exemplo Rust

fn main() {
    // for + range: 0..=35 inclui as duas pontas; step_by pula de 5 em 5.
    for celsius in (0..=35).step_by(5) {
        let label = classify(f64::from(celsius));
        println!("{celsius:>2}°C → {label}");
    }

EXPERIMENTE

Edite e execute

O laço pula de dez em dez. Troque step_by(10) por step_by(5). O range 0..=20 continua incluindo o 20. Execute e conte as linhas: devem ser cinco.

Objetivo

Mostre os minutos de 0 a 20 de cinco em cinco.

Saída esperada

minuto 0
minuto 5
minuto 10
minuto 15
minuto 20

Rust 2021 · Edite e execute

fn main() {
    for minute in (0..=20).step_by(10) {
        println!("minuto {minute}");
    }
}

DESAFIO

Some os múltiplos de um divisor com for e range

Escreva a função sum_multiples, que soma todos os múltiplos de um divisor dentro de um intervalo:

pub fn sum_multiples(limit: u32, divisor: u32) -> u64

Entrada: o limite superior (inclusive) e o divisor; o divisor é sempre ≥ 1.
Saída: a soma de todos os valores em 1..=limit divisíveis por divisor.
Exemplo: sum_multiples(10, 3) devolve 18 (3 + 6 + 9); sum_multiples(10, 5) devolve 15 (5 + 10); sum_multiples(4, 7) devolve 0, porque não há múltiplo na faixa.
Restrições: use for com um range e um acumulador u64. O retorno comporta a soma de qualquer faixa de entradas u32.

O caso sum_multiples(10, 5) detecta um range errado: o 10 está na faixa e é múltiplo de 5. Se a sua soma der 5, o range exclusivo removeu a ponta. Para testar a divisibilidade, use o método is_multiple_of dos inteiros sem sinal: value.is_multiple_of(divisor).

Edite stub.rs. Os controles mostram a execução disponível para este exercício.

Rust 2021 · stub.rs

// sum_multiples soma todos os valores em 1..=limit divisíveis por divisor.
// O retorno u64 comporta a soma de qualquer faixa u32 completa.
pub fn sum_multiples(limit: u32, divisor: u32) -> u64 {
    // implemente:
    let _ = (limit, divisor);
    0
}

Arquivos, contrato, dicas e solução

Exercício 2

Some os múltiplos de um divisor com for e range

stub.rs

// sum_multiples soma todos os valores em 1..=limit divisíveis por divisor.
// O retorno u64 comporta a soma de qualquer faixa u32 completa.
pub fn sum_multiples(limit: u32, divisor: u32) -> u64 {
    // implemente:
    let _ = (limit, divisor);
    0
}

harness.rs

fn json_escape(value: &str) -> String {
    value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
}

fn print_result(case: usize, pass: bool, input: &str, want: &str, got: &str) {
    println!(
        "RESULT {{\"case\":{case},\"pass\":{pass},\"input\":\"{}\",\"want\":\"{}\",\"got\":\"{}\"}}",
        json_escape(input),
        json_escape(want),
        json_escape(got)
    );
}

fn main() {
    let cases: [(u32, u32, u64); 6] = [
        (10, 3, 18),
        (10, 5, 15),
        (4, 7, 0),
        (1, 1, 1),
        (100, 10, 550),
        (100_000, 1, 5_000_050_000),
    ];
    for (index, (limit, divisor, want)) in cases.iter().enumerate() {
        let got = sum_multiples(*limit, *divisor);
        let pass = got == *want;
        print_result(
            index + 1,
            pass,
            &format!("({limit}, {divisor})"),
            &want.to_string(),
            &got.to_string(),
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "(10, 3)",
    "want": "18"
  },
  {
    "case": 2,
    "input": "(10, 5)",
    "want": "15"
  },
  {
    "case": 3,
    "input": "(4, 7)",
    "want": "0"
  },
  {
    "case": 4,
    "input": "(1, 1)",
    "want": "1"
  },
  {
    "case": 5,
    "input": "(100, 10)",
    "want": "550"
  },
  {
    "case": 6,
    "input": "(100000, 1)",
    "want": "5000050000"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`(10, 3)`	`18`
2	`(10, 5)`	`15`
3	`(4, 7)`	`0`
4	`(1, 1)`	`1`
5	`(100, 10)`	`550`
6	`(100000, 1)`	`5000050000`

Execute com o Cargo local

Execute os comandos de preparação.
Copie os arquivos acima para os arquivos vazios com os mesmos nomes.
Execute a verificação de base. O stub deve mostrar o comportamento atual.

Comandos de preparação

cargo new --bin --edition 2024 imersao-04-funcoes-e-fluxo-exercicio-2
cd imersao-04-funcoes-e-fluxo-exercicio-2
touch stub.rs harness.rs cases.json
printf 'include!("../stub.rs");\ninclude!("../harness.rs");\n' > src/main.rs

Verificação de base — confirme o comportamento atual antes da mudança

cargo fmt --check
cargo run --bin imersao-04-funcoes-e-fluxo-exercicio-2
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

Percorra 1..=limit com for e acumule em uma variável mut iniciada em 0; o teste de múltiplo decide quem entra na soma.
if value.is_multiple_of(divisor) { total += u64::from(value); } dentro do laço — o acumulador largo evita overflow.

Revelar solução

solution.rs

// sum_multiples soma todos os valores em 1..=limit divisíveis por divisor.
// O retorno u64 comporta a soma de qualquer faixa u32 completa.
pub fn sum_multiples(limit: u32, divisor: u32) -> u64 {
    let mut total = 0u64;
    for value in 1..=limit {
        if value.is_multiple_of(divisor) {
            total += u64::from(value);
        }
    }
    total
}

O range inclusivo visita cada candidato uma vez. O acumulador u64 comporta a soma de toda a faixa u32, inclusive limites grandes.

Range inclusivo, teste de múltiplo, acumulador:

pub fn sum_multiples(limit: u32, divisor: u32) -> u64 {
    let mut total = 0u64;
    for value in 1..=limit {
        if value.is_multiple_of(divisor) {
            total += u64::from(value);
        }
    }
    total
}

O 1..=limit visita cada candidato exatamente uma vez — O(n) no limite — e is_multiple_of decide quem entra. O acumulador é u64, e cada candidato passa por u64::from. Assim, a soma de toda a faixa u32 cabe sem overflow. A última linha, total sem ponto e vírgula, é o retorno.

A armadilha número um é o range: 1..limit exclui o próprio limite, e sum_multiples(10, 5) devolveria 5 em vez de 15 — o caso do harness existe para isso. A segunda armadilha é sutil: inverter o teste para divisor.is_multiple_of(value) compila e até acerta alguns casos pequenos, mas pergunta “value divide o divisor?”, o contrário do contrato. E se você escreveu value % divisor == 0: o resultado é o mesmo, mas rode cargo clippy e veja o lint manual_is_multiple_of sugerir o método — é o tipo de melhoria de legibilidade que o linter automatiza. Existe uma alternativa aritmética O(1) — somar a progressão divisor + 2·divisor + ... = divisor · k·(k+1)/2 com k = limit / divisor — que vale conhecer para entrevistas; aqui o laço é o objetivo pedagógico, e para os tamanhos do exercício a diferença é invisível.

CÓDIGO ANOTADO

Código anotado

O while serve para “não sei quantas voltas”: a cada passo a temperatura cai 10 %, e o laço para quando cruza o limiar. São nove passos até ficar abaixo de 40 °F.

A condição fahrenheit > 40.0 é um bool. Escrever while fahrenheit causa E0308 (“expected bool”): Rust não converte números em condições, e o bug clássico do “zero é falso” não chega a compilar.

As duas variáveis mut são o idioma natural aqui: o while precisa de estado que muda a cada volta, e o escopo curto mantém essa mutação sob controle.

Exemplo Rust

    // while: repete enquanto a condição vale; a condição é bool de verdade.
    let mut fahrenheit = 100.0;
    let mut steps = 0;
    while fahrenheit > 40.0 {
        fahrenheit *= 0.9;
        steps += 1;
    }
    println!("resfriou abaixo de 40°F em {steps} passos");

EXPERIMENTE

Edite e execute

O laço não executa nenhuma volta, porque o saldo inicial já é 1000. Troque a condição balance < 1000 por balance < 1500. Cada volta soma 10 % com divisão inteira. Execute para ver quantos meses foram necessários.

Objetivo

Conte os meses até o saldo passar de 1500, com 10 % ao mês.

Saída esperada

5 meses: saldo 1610

Rust 2021 · Edite e execute

fn main() {
    let mut balance = 1000;
    let mut months = 0;
    while balance < 1000 {
        balance += balance / 10;
        months += 1;
    }
    println!("{months} meses: saldo {balance}");
}

CÓDIGO ANOTADO

Código anotado

O main termina com uma busca: o primeiro fator de 91. A saída completa do programa é:

 0°C → frio
 5°C → frio
10°C → frio
15°C → agradável
20°C → agradável
25°C → agradável
30°C → quente
35°C → quente
resfriou abaixo de 40°F em 9 passos
primeiro fator de 91: 7

Confira as pontas da tabela: 15 °C caiu em “agradável”, e 30 °C em “quente”. 91 não é primo (7 × 13), e a função encontra o 7 na sexta volta, depois de testar de 2 a 6. Ela está no último bloco, depois do main: em Rust, a ordem das funções no arquivo não importa.

Exemplo Rust

    // loop como expressão: o break entrega o valor direto para o let.
    let factor = first_factor(91);
    println!("primeiro fator de 91: {factor}");
}

CÓDIGO ANOTADO

Código anotado

break candidate encerra o laço e entrega o candidato. Como o loop é a última expressão do corpo, esse valor é o retorno da função. Não há variável extra para levar o resultado para fora.

O laço termina para todo value >= 2: no pior caso, o candidato chega ao próprio value, que divide a si mesmo. É o que acontece com os primos.

O teste usa is_multiple_of, um método dos inteiros sem sinal. A forma value % candidate == 0 também funciona, mas o clippy sugere o método com o lint manual_is_multiple_of, porque o nome diz a intenção.

Exemplo Rust

// first_factor sobe a partir de 2 até achar o primeiro divisor de value.
fn first_factor(value: u32) -> u32 {
    let mut candidate = 2;
    loop {
        if value.is_multiple_of(candidate) {
            break candidate;
        }
        candidate += 1;
    }
}

EXPERIMENTE

Edite e execute

O loop procura o primeiro número cujo quadrado passa de 20. Troque o 20 da condição e o 20 da mensagem por 50. O break continua entregando o número ao let. Execute.

Objetivo

Encontre o menor número cujo quadrado passa de 50, com break carregando o valor.

Saída esperada

menor número com quadrado acima de 50: 8

Rust 2021 · Edite e execute

fn main() {
    let mut number = 1;
    let found = loop {
        if number * number > 20 {
            break number;
        }
        number += 1;
    };
    println!("menor número com quadrado acima de 20: {found}");
}

DESAFIO

Encontre o primeiro fator com loop e break com valor

Escreva a função first_factor, a busca do programa da aula, com o loop entregando o resultado:

pub fn first_factor(value: u32) -> u32

Entrada: um inteiro value >= 2.
Saída: o menor fator de value que seja ≥ 2. Para números primos, é o próprio número.
Exemplo: first_factor(91) devolve 7; first_factor(12) devolve 2; first_factor(13) devolve 13.
Restrições: use loop com break carregando o valor, sem while, sem for e sem return dentro do laço. O loop deve ser a última expressão da função.

O objetivo é fixar o break com valor: o laço é a expressão de busca, e o resultado sai por ele. O stub devolve o próprio value, que só acerta para números primos.

Edite stub.rs. Os controles mostram a execução disponível para este exercício.

Rust 2021 · stub.rs

// first_factor devolve o menor fator ≥ 2 de value (value >= 2).
// Para primos, é o próprio número. Use loop com break carregando o valor.
pub fn first_factor(value: u32) -> u32 {
    // implemente:
    value
}

Arquivos, contrato, dicas e solução

Exercício 3

Encontre o primeiro fator com loop e break com valor

stub.rs

// first_factor devolve o menor fator ≥ 2 de value (value >= 2).
// Para primos, é o próprio número. Use loop com break carregando o valor.
pub fn first_factor(value: u32) -> u32 {
    // implemente:
    value
}

harness.rs

fn json_escape(value: &str) -> String {
    value
        .replace('\\', "\\\\")
        .replace('"', "\\\"")
        .replace('\n', "\\n")
}

fn print_result(case: usize, pass: bool, input: &str, want: &str, got: &str) {
    println!(
        "RESULT {{\"case\":{case},\"pass\":{pass},\"input\":\"{}\",\"want\":\"{}\",\"got\":\"{}\"}}",
        json_escape(input),
        json_escape(want),
        json_escape(got)
    );
}

fn main() {
    let cases: [(u32, u32); 5] = [(91, 7), (12, 2), (13, 13), (2, 2), (49, 7)];
    for (index, (value, want)) in cases.iter().enumerate() {
        let got = first_factor(*value);
        let pass = got == *want;
        print_result(
            index + 1,
            pass,
            &value.to_string(),
            &want.to_string(),
            &got.to_string(),
        );
    }
}

cases.json

[
  {
    "case": 1,
    "input": "91",
    "want": "7"
  },
  {
    "case": 2,
    "input": "12",
    "want": "2"
  },
  {
    "case": 3,
    "input": "13",
    "want": "13"
  },
  {
    "case": 4,
    "input": "2",
    "want": "2"
  },
  {
    "case": 5,
    "input": "49",
    "want": "7"
  }
]

Casos e valores esperados

Caso	Entrada	Valor esperado
1	`91`	`7`
2	`12`	`2`
3	`13`	`13`
4	`2`	`2`
5	`49`	`7`

Execute com o Cargo local

Execute os comandos de preparação.
Copie os arquivos acima para os arquivos vazios com os mesmos nomes.
Execute a verificação de base. O stub deve mostrar o comportamento atual.

Comandos de preparação

cargo new --bin --edition 2024 imersao-04-funcoes-e-fluxo-exercicio-3
cd imersao-04-funcoes-e-fluxo-exercicio-3
touch stub.rs harness.rs cases.json
printf 'include!("../stub.rs");\ninclude!("../harness.rs");\n' > src/main.rs

Verificação de base — confirme o comportamento atual antes da mudança

cargo fmt --check
cargo run --bin imersao-04-funcoes-e-fluxo-exercicio-3
cargo clippy -- -D warnings

Abrir o Rust Playground (opcional)

Mostrar dicas

Comece um candidato em 2 e suba de um em um; o primeiro que dividir value sem resto é a resposta — e ele sempre existe, porque o próprio value se divide.
Use loop { ... } com break candidate; quando value.is_multiple_of(candidate) — o valor do break vira o valor do loop inteiro, que é a última expressão da função.

Revelar solução

solution.rs

// first_factor devolve o menor fator ≥ 2 de value (value >= 2).
// Para primos, é o próprio número. Use loop com break carregando o valor.
pub fn first_factor(value: u32) -> u32 {
    let mut candidate = 2;
    loop {
        if value.is_multiple_of(candidate) {
            break candidate;
        }
        candidate += 1;
    }
}

loop com break-com-valor devolve o primeiro fator ≥ 2; para primos, o laço sobe até o próprio número, garantindo término. A armadilha é esquecer o incremento (laço infinito) ou começar o candidato em 1, que divide tudo e responde errado sempre.

O chunk 2 do programa da aula, agora justificado linha a linha:

pub fn first_factor(value: u32) -> u32 {
    let mut candidate = 2;
    loop {
        if value.is_multiple_of(candidate) {
            break candidate;
        }
        candidate += 1;
    }
}

O break candidate faz três coisas de uma vez: para o laço, define o valor do loop inteiro e — como o loop é a última expressão do corpo — define o retorno da função. O término é garantido pela matemática: todo value >= 2 é divisível por si mesmo, então o candidato encontra um fator no mais tardar ao alcançar value. Custo O(n) no pior caso (primos); a otimização clássica de parar em √n e devolver value é bem-vinda em código real, mas não muda o mecanismo que o exercício treina.

Duas armadilhas encerram a aula. Começar candidate em 1: um divide tudo, a primeira volta responde 1 e todos os casos falham — o menor fator interessante começa em 2. E esquecer o candidate += 1: aí sim o loop faz jus ao nome, para sempre; se acontecer no seu teste local, Ctrl+C encerra o processo; no navegador, o limite de tempo encerra a execução. Vale o contraste com a alternativa while: possível, mas exige declarar o resultado fora do laço e atribuir dentro — duas variáveis mut e um fluxo de dados que o break com valor expressa em uma linha.

ENTENDA A IDEIA

A ideia central

Um bloco { ... } também é uma expressão: ele vale a sua última expressão. É o mesmo mecanismo do corpo das funções, disponível dentro de qualquer let.

O bloco tem outra vantagem: as variáveis de dentro, price e quantity, deixam de existir no fim dele. O cálculo intermediário não vaza para o resto da função; sobra apenas o resultado, em total.

Na próxima tela, acrescente uma etapa ao cálculo sem mudar o formato do bloco.

Exemplo Rust

let total = {
    let price = 40;
    let quantity = 3;
    price * quantity // o bloco vale esta expressão
};

EXPERIMENTE

Edite e execute

O bloco vale price * quantity, ou seja, 120. Troque a última expressão por price * quantity + 15, sem ponto e vírgula. Execute: o total deve incluir o frete.

Objetivo

Acrescente um frete de 15 à última expressão do bloco.

Saída esperada

total: 135

Rust 2021 · Edite e execute

fn main() {
    let total = {
        let price = 40;
        let quantity = 3;
        price * quantity
    };
    println!("total: {total}");
}

ENTENDA A IDEIA

A ideia central

Python tem a expressão condicional "par" if n % 2 == 0 else "ímpar", mas é uma sintaxe à parte, limitada a uma linha. Em Rust, o mesmo if/else de sempre é expressão em qualquer posição, com blocos de qualquer tamanho.

O range(1, 11) do Python exclui o 11, como 1..11 em Rust; o ..= inclusivo não tem equivalente direto. E onde Python aceita if lista:, Rust exige um bool: if !list.is_empty(). Não existe “truthiness”: o compilador recusa a ambiguidade.

Exemplo Rust

let parity = if n % 2 == 0 { "par" } else { "ímpar" };
for i in 1..=10 { /* inclui o 10 */ }
if !list.is_empty() { /* bool explícito */ }

ENTENDA A IDEIA

A ideia central

Devolva valores pela última expressão e reserve return para saídas antecipadas. O capítulo 3.3 do The Rust Book define a regra: o corpo de uma função é um bloco, e um bloco vale a sua última expressão. O lint clippy::needless_return marca o return desnecessário na última linha.

A mesma disciplina vale para o fluxo: prefira if/else como expressão a uma variável mutável com atribuições, for com range a um contador manual, e loop com break valor a while true com uma variável auxiliar. Cada escolha remove um estado mutável do código, e um estado que não existe não pode quebrar.

Exemplo Rust

fn half(value: u32) -> u32 {
    value / 2 // e não: return value / 2;
}
let label = if value > 0 { "positivo" } else { "zero" };

RESUMO DA AULA

O que você leva desta aula

Expressões valem algo; instruções valem (). O ponto e vírgula transforma a primeira na segunda.
A última expressão de uma função é o retorno; return serve para saídas antecipadas.
E0308 com “found ()” quase sempre aponta um ; sobrando na última linha.
if/else é expressão: ramos do mesmo tipo, else obrigatório quando o valor é usado (E0317), condição bool.
for percorre ranges (1..3 exclui, 1..=3 inclui); while repete enquanto vale; loop devolve valor com break.
Blocos { ... } valem a sua última expressão.
Na próxima aula: o jogo de adivinhação, com entrada do teclado, parse, match e o primeiro contato com Result.

+280 XPpossíveis nesta aula

A ideia central

Edite e execute

Objetivo

Saída esperada

A ideia central

Edite e execute

Objetivo

Saída esperada

A ideia central

Edite e execute

Objetivo

Saída esperada

A ideia central

Edite e execute

Objetivo

Saída esperada

Código anotado

Classifique a temperatura com if/else como expressão

Casos e valores esperados

Execute com o Cargo local

A ideia central

Edite e execute

Objetivo

Saída esperada

Código anotado

Edite e execute

Objetivo

Saída esperada

Some os múltiplos de um divisor com for e range

Casos e valores esperados

Execute com o Cargo local

Código anotado

Edite e execute

Objetivo

Saída esperada

Código anotado

Código anotado

Edite e execute

Objetivo

Saída esperada

Encontre o primeiro fator com loop e break com valor

Casos e valores esperados

Execute com o Cargo local

A ideia central

Edite e execute

Objetivo

Saída esperada

A ideia central

A ideia central

O que você leva desta aula

Você transformou esta ideia em prática.