- Executores
-
Aprender
Aprender Python Exemplos executáveis, NumPy, pandas e mais Aprender IARedes neurais, ML e LLMs do zero Aprender C e C++ Ponteiros, memória, STL e C++ moderno Aprender C#Fundamentos, POO, LINQ, async e exercícios .NET Aprender MatplotlibGráficos de linha, barras, dispersão e pizza com visualizadores Algoritmos em Python Busca, ordenação, recursão e visualizações O(n) Algoritmos em C e C++ Compare implementações em C e C++ Programação para crianças Aprenda a programar brincando!
- DesafiosNovo
- Para professoresNovo
- Atualizações
- Me pague um café
A* é o algoritmo clássico de busca de caminhos em jogos e robótica. Ele explora as células em ordem de f = g + h, onde g é o custo pago até agora e h é uma estimativa heurística do custo que falta.
A grade guarda um custo para cada célula: entrar em uma célula custa o seu valor, e 0 é uma parede onde não se pode entrar. Você começa em start (o custo dela não é pago) e pode se mover para cima, para baixo, para a esquerda ou para a direita.
Use A* com a distância de Manhattan |row - goal_row| + |col - goal_col| como heurística. Toda célula aberta custa pelo menos 1, então essa heurística nunca superestima e o A* retorna uma resposta ótima.
Implemente a_star_cost(grid, start, goal).
Entrada
grid: Uma matriz de custos das células (0 = parede).
start, goal: Posições [row, col].
Saída
Retorne o custo total mínimo para chegar a goal, ou -1 se não for possível chegar (inclusive quando start ou goal é uma parede).
Restrições
1 ≤ linhas, colunas ≤ 100
0 ≤ cada custo ≤ 9
Exemplos
Exemplo 1
Entrada:
grid = [
[1, 1, 1],
[1, 0, 1],
[1, 1, 1]
]
start = [0, 0]
goal = [2, 2]
Saída esperada:
4Explicação
O centro é uma parede. Ir duas vezes para a direita e duas vezes para baixo (ou para baixo e depois para a direita) entra em 4 células de custo 1, total 4.
Exemplo 2
Entrada:
grid = [
[1, 9, 1],
[1, 9, 1],
[1, 1, 1]
]
start = [0, 0]
goal = [0, 2]
Saída esperada:
6Explicação
Atravessar o 9 diretamente custa 9 + 1 = 10. Descer, seguir pela linha de baixo e subir de novo entra em seis células de custo 1, total 6.
Referências
-
Exemplo 1 Não executadoEntrada:
grid = [ [1, 1, 1], [1, 0, 1], [1, 1, 1] ] start = [0, 0] goal = [2, 2]Saída esperada:4Sua saída -
Exemplo 2 Não executadoEntrada:
grid = [ [1, 9, 1], [1, 9, 1], [1, 1, 1] ] start = [0, 0] goal = [0, 2]Saída esperada:6Sua saída
4 testes ocultos também serão executados ao enviar. Se seu código falhar em um, você verá esse teste. Resolva o desafio para ver todos.
Online Rust Compiler
Write, compile, run, and debug Rust code online in a full-featured browser IDE. Work with multiple files, save your workspace, and share or collaborate in real time.
🚀 252,702 execuções totais (135 este mês)
Pratique Rust com desafios de código
Resolva problemas práticos direto neste editor: rode os testes de exemplo, envie sua solução e receba uma revisão de código por IA.
🦀 Sobre este executor online de Rust
O CodeUtility Rust Executor permite escrever e executar código Rust diretamente no seu navegador - sem instalação, configuração de toolchain ou ambiente local. Ele é alimentado por um sandbox seguro que oferece suporte às versões reais do compilador Rust 1.70, 1.72, 1.73 e 1.74.
Esta ferramenta compila e executa seus programas Rust na nuvem usando um compilador rustc autêntico,
garantindo resultados precisos e consistentes. Você pode experimentar com variáveis, ownership, borrowing,
pattern matching, traits, genéricos e outros recursos modernos do Rust com facilidade.
É ideal para aprender os conceitos fundamentais de Rust - especialmente segurança de memória, tratamento de erros e concorrência - sem precisar instalar o Cargo ou qualquer setup local. Tudo roda diretamente no seu navegador em segundos.
Mais do que um executor de código
Use no mesmo executor um editor de vários arquivos, um terminal de execução isolado, bibliotecas específicas do ambiente, espaços de trabalho persistentes, compartilhamento e colaboração em tempo real.
Como usar este executor?
Escolha um ambiente de execução, abra ou crie um arquivo, escreva o código e selecione Executar. A saída aparece no terminal; usuários conectados podem manter arquivos em um espaço de trabalho, instalar bibliotecas e colaborar por meio de compartilhamentos.
- Selecione uma versão e edite o arquivo atual ou abra outro arquivo do espaço de trabalho.
- Execute o código, forneça dados no terminal quando solicitado e consulte o histórico de execuções salvo.
- Use bibliotecas, ferramentas do espaço de trabalho, compartilhamento e chat quando a tarefa exigir mais de um trecho de código.
💡 Noções básicas de Rust e exemplos que você pode testar acima
1. Declarando variáveis e constantes
Use let para declarar variáveis. Use const para constantes e mut para variáveis mutáveis.
let x = 10;
let pi: f64 = 3.14;
let name = "Alice";
let is_active = true;
const MAX_USERS: u32 = 100;2. Condicionais (if / match)
Rust usa if para condições e match para correspondência de padrões.
let x = 2;
if x == 1 {
println!("One");
} else if x == 2 {
println!("Two");
} else {
println!("Other");
}
match x {
1 => println!("One"),
2 => println!("Two"),
_ => println!("Other"),
}3. Loops
Rust oferece suporte a for, while e loop infinito.
for i in 0..3 {
println!("{}", i);
}
let mut n = 3;
while n > 0 {
println!("{}", n);
n -= 1;
}4. Arrays
Arrays de tamanho fixo em Rust usam colchetes. Use slices para visualizações.
let nums = [10, 20, 30];
println!("{}", nums[1]);5. Vetores (arrays dinâmicos)
Vec é usado para arrays dinâmicos.
let mut fruits = vec!["apple", "banana"];
fruits.push("cherry");
fruits.pop();
for fruit in &fruits {
println!("{}", fruit);
}6. Entrada/Saída no console
Use println! para saída e std::io para entrada.
use std::io;
let mut name = String::new();
println!("Enter your name:");
io::stdin().read_line(&mut name).unwrap();
println!("Hello, {}", name.trim());7. Funções
Funções usam fn e podem retornar valores usando ->.
fn greet(name: &str) -> String {
format!("Hello, {}", name)
}
println!("{}", greet("Alice"));8. HashMaps
Use std::collections::HashMap para dados chave-valor.
use std::collections::HashMap;
let mut person = HashMap::new();
person.insert("name", "Bob");
println!("{}", person["name"])9. Tratamento de erros
Rust lida com erros usando Result e match ou unwrap().
fn fail() -> Result<(), String> {
Err("Something went wrong".to_string())
}
match fail() {
Ok(_) => println!("Success"),
Err(e) => println!("{}", e),
}10. I/O de arquivos
Use std::fs para ler e escrever arquivos.
use std::fs;
fs::write("file.txt", "Hello File").unwrap();
let content = fs::read_to_string("file.txt").unwrap();
println!("{}", content);11. Manipulação de strings
Strings em Rust são alocadas no heap e oferecem muitos métodos.
let mut text = String::from(" Hello Rust ");
println!("{}", text.trim());
println!("{}", text.to_uppercase());
text = text.replace("Hello", "Hi");
println!("{}", text);12. Structs e métodos
Rust usa struct para tipos de dados e impl para métodos.
struct Person {
name: String,
}
impl Person {
fn greet(&self) -> String {
format!("Hi, I'm {}", self.name)
}
}
let p = Person { name: "Alice".to_string() };
println!("{}", p.greet());13. Referências e empréstimo
Rust usa & para emprestar valores e &mut para referências mutáveis.
fn update(x: &mut i32) {
*x += 1;
}
let mut value = 10;
update(&mut value);
println!("{}", value);