Lição 8: Patrulhamento Contínuo

Narrativa

Piloto, seu mecha agora está em modo patrulha. O sistema de navegação realiza verificações contínuas dos setores ao redor, monitorando cada área em busca de atividades suspeitas. Este é um trabalho repetitivo e metódico — exatamente o tipo de tarefa que os computadores executam com perfeição.

Na Academia Æther, chamamos estruturas de repetição de Ciclos de Patrulha. Eles permitem que seu mecha execute ações repetidamente até que uma condição seja atingida ou o piloto intervenha manualmente. Um bom sistema de patrulhamento nunca para de vigiar.

Conceito

Em Rust, loops são estruturas que permitem executar um bloco de código múltiplas vezes. Existem três tipos principais de loops:

loop — Repete infinitamente até encontrar um break:

let mut contador = 0;
loop {
    println!("Verificando setor {}...", contador);
    contador += 1;
    if contador >= 5 {
        break; // Sai do loop
    }
}

while — Repete enquanto uma condição for verdadeira:

let mut energia = 100;
while energia > 20 {
    println!("Sistemas operacionais: {}%", energia);
    energia -= 10;
}

for — Itera sobre uma coleção (arrays, ranges, etc.):

let setores = ["Norte", "Sul", "Leste", "Oeste"];
for setor in setores {
    println!("Patrulhando: {}", setor);
}

Controle de Fluxo em Loops:

• break — Interrompe o loop imediatamente
• continue — Pula para a próxima iteração
• Labels — Permitem controlar loops aninhados: 'externo: loop { break 'externo; }

Requisitos

• Entrada: Arrays de dados (setores, alvos, leituras)
• Processamento: Iterar sobre coleções, buscar valores, processar condicionalmente
• Saída: Resultados das operações de patrulha (strings, contadores, índices)

Design de Dados

Esta lição trabalha com loops sobre arrays de dados primitivos:

// Funções de patrulhamento
pub fn patrulhar_setores(setores: &[&str], max_iteracoes: u32) -> String;
pub fn buscar_alvo(alvos: &[i32], busca: i32) -> Option<usize>;
pub fn processar_sensor_leituras(leituras: &[f64], limiar: f64) -> u32;
pub fn executar_ciclo_verificacao(passos: u32) -> String;
pub fn encontrar_anomalia(dados: &[i32]) -> Option<i32>;

As funções utilizam loops (for, while, loop) para processar coleções — sem usar iteradores (apenas for item in array).

Diagrama Conceitual

flowchart TD
    A[Dados de Entrada] --> B{Tipo de Loop}
    B -->|loop| C[Repetição Infinita]
    B -->|while| D[Condição Verificada]
    B -->|for| E[Iteração sobre Coleção]
    C --> F[break/continue]
    D --> F
    E --> F
    F --> G{Condição de Saída?}
    G -->|Sim| H[Resultado]
    G -->|Não| B

Funções e Módulos

//! Lição 8: Patrulhamento Contínuo
//!
//! Controle de fluxo com loops na Academia Æther.

/// Patrulha setores sequencialmente até atingir o máximo de iterações
pub fn patrulhar_setores(setores: &[&str], max_iteracoes: u32) -> String;

/// Busca um alvo em uma lista de valores, retornando seu índice
pub fn buscar_alvo(alvos: &[i32], busca: i32) -> Option<usize>;

/// Processa leituras de sensores, contando quantas excedem o limiar
pub fn processar_sensor_leituras(leituras: &[f64], limiar: f64) -> u32;

/// Executa um ciclo de verificação com número específico de passos
pub fn executar_ciclo_verificacao(passos: u32) -> String;

/// Encontra a primeira anomalia (valor negativo) nos dados
pub fn encontrar_anomalia(dados: &[i32]) -> Option<i32>;

Exemplo do Conceito

// Exemplo de patrulhamento com for
let setores = ["Alpha", "Beta", "Gamma"];
let mut relatorio = String::new();

for setor in setores {
    relatorio.push_str(&format!("Setor {} verificado; ", setor));
}

// Exemplo de busca com loop
let alvos = [10, 20, 30, 40];
let busca = 30;
let mut encontrado = None;
let mut i = 0;

loop {
    if i >= alvos.len() {
        break;
    }
    if alvos[i] == busca {
        encontrado = Some(i);
        break;
    }
    i += 1;
}

// Exemplo de processamento com while e continue
let leituras = [15.5, 22.0, 18.5, 30.0, 12.0];
let limiar = 20.0;
let mut contador = 0;
let mut i = 0;

while i < leituras.len() {
    i += 1;
    if leituras[i - 1] <= limiar {
        continue; // Pula leituras normais
    }
    contador += 1; // Conta apenas anomalias
}

// Exemplo com labels para loops aninhados
'externo: for x in 0..5 {
    for y in 0..5 {
        if x * y > 6 {
            break 'externo; // Sai do loop externo
        }
    }
}

Explicação:

• Linha 1-6: Loop for para iterar sobre setores
• Linha 8-19: Loop loop para busca manual em array
• Linha 26-38: Loop while com continue para filtrar dados
• Linha 40-47: Labels permitem controlar loops aninhados

Missão

1. Implementar patrulhar_setores: Use um loop for para iterar sobre os setores, construindo uma string com o relatório de patrulha. Pare quando atingir max_iteracoes.
2. Implementar buscar_alvo: Use loop para encontrar o índice de um valor em um array. Retorne Some(index) se encontrar, None se não encontrar.
3. Implementar processar_sensor_leituras: Use while para percorrer as leituras. Use continue para pular valores abaixo do limiar. Retorne a contagem de leituras acima do limiar.
4. Implementar executar_ciclo_verificacao: Use loop para executar exatamente passos iterações, retornando uma string indicando o progresso. Formato esperado: uma sequência de passos indexados a partir de 0, separados por espaço — por exemplo, para passos = 3, retorne algo como "Passo 0 Passo 1 Passo 2" (o último passo é passos - 1)
5. Implementar encontrar_anomalia: Use for para encontrar o primeiro valor negativo. Use break quando encontrar. Retorne Some(valor) ou None.

Diagrama de Fluxo da Missão

flowchart TD
    A[Tarefa: Patrulhamento] --> B[Implementar patrulhar_setores]
    B --> C[Implementar buscar_alvo]
    C --> D[Implementar processar_sensor_leituras]
    D --> E[Implementar executar_ciclo_verificacao]
    E --> F[Implementar encontrar_anomalia]
    F --> G[Testes verificam]
    G --> H{Clippy limpo?}
    H -->|Sim| I[Concluído]
    H -->|Não| J[Corrigir warnings] --> G

Como Executar

# Executar testes
cargo test

# Verificar lint
cargo clippy -- -D warnings

# Formatar código
cargo fmt --check

Dicas

• Use for setor in setores para iterar sobre arrays — não use .iter() (isso vem na Lição 34)
• Para acessar índice e valor: for (i, valor) in array.iter().enumerate() — mas prefira o loop simples por enquanto
• break pode retornar um valor: let result = loop { break 42; }
• Labels são úteis: 'nome: loop { break 'nome; }
• continue pula para a próxima iteração imediatamente
• Cuidado com loops infinitos — sempre tenha uma condição de saída