- 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 Go Compiler
Write, compile, run, and debug Go code online in a full-featured browser IDE. Work with multiple files, save your workspace, and collaborate in real time - no setup required.
🚀 206,970 execuções totais (799 este mês)
Pratique Go 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 Go online
O CodeUtility Go Executor permite escrever e executar código Go diretamente no seu navegador - sem instalação, configuração ou ambiente local. É alimentado por um sandbox seguro que suporta versões reais do compilador Go 1.19, 1.20 e 1.21.
Esta ferramenta compila e executa programas Go reais na nuvem, oferecendo um ambiente autêntico de Go. Você pode testar trechos curtos, experimentar com pacotes e explorar os poderosos recursos de concorrência do Go usando gorrotinas e canais.
É perfeita para aprender e praticar os conceitos fundamentais de Go, como variáveis, funções, structs, slices, maps, interfaces e tratamento de erros - tudo isso sem instalar nada localmente.
Seja explorando Go pela primeira vez, testando lógica de backend ou aprendendo como a concorrência funciona, o CodeUtility Go Executor oferece uma forma limpa, rápida e baseada no navegador de executar código Go instantaneamente.
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 Go e exemplos que você pode testar acima
1. Declarando variáveis e constantes
Use var ou := para declarar variáveis. Use const para constantes.
package main
var x int = 10
const Pi = 3.14
func main() {
name := "Alice"
isActive := true
println(x, Pi, name, isActive)
}2. Condicionais (if / switch)
Go suporta instruções if-else e switch com uma sintaxe limpa.
x := 2
if x == 1 {
println("Um")
} else if x == 2 {
println("Dois")
} else {
println("Outro")
}
switch x {
case 1:
println("Um")
case 2:
println("Dois")
default:
println("Outro")
}3. Loops
Go usa apenas o loop for, mas ele pode agir como um loop while.
for i := 0; i < 3; i++ {
println(i)
}
n := 3
for n > 0 {
println(n)
n--
}4. Arrays
Arrays têm tamanho fixo. Use slices para listas dinâmicas.
var nums = [3]int{10, 20, 30}
println(nums[1])5. Manipulação de slices
Use slices e as funções internas append, len, copy e a sintaxe de fatiamento.
fruits := []string{"apple", "banana"}
fruits = append(fruits, "cherry")
fruits = fruits[1:] // slice
println(len(fruits))
for _, fruit := range fruits {
println(fruit)
}6. Entrada/Saída no console
Use fmt.Print, fmt.Scan e fmt.Println.
import "fmt"
var name string
fmt.Print("Digite seu nome: ")
fmt.Scan(&name)
fmt.Println("Olá", name)7. Funções
Funções são declaradas com func e podem retornar múltiplos valores.
func greet(name string) string {
return "Olá, " + name
}
message := greet("Alice")
println(message)8. Maps
Maps são armazenamentos chave-valor. Declare com make().
ages := map[string]int{"Alice": 30}
ages["Bob"] = 25
println(ages["Alice"])9. Tratamento de erros
Go usa múltiplos valores de retorno para erros em vez de exceções.
import "errors"
func fail() error {
return errors.New("algo deu errado")
}
err := fail()
if err != nil {
println(err.Error())
}10. E/S de arquivos
Use os pacotes os e io/ioutil para ler/gravar arquivos.
import (
"fmt"
"os"
"io/ioutil"
)
ioutil.WriteFile("file.txt", []byte("Olá Arquivo"), 0644)
data, _ := ioutil.ReadFile("file.txt")
fmt.Println(string(data))11. Manipulação de strings
Use o pacote strings para operações com strings.
import "strings"
text := " Olá Mundo "
println(strings.TrimSpace(text))
println(strings.ToUpper(text))
println(strings.ReplaceAll(text, "Olá", "Oi"))
words := strings.Split(text, " ")
fmt.Println(words)12. Structs e objetos
Use structs para definir tipos personalizados com métodos.
type Person struct {
Name string
}
func (p Person) Greet() string {
return "Oi, eu sou " + p.Name
}
p := Person{Name: "Alice"}
println(p.Greet())13. Referências (ponteiros)
Go suporta ponteiros usando * e &.
x := 10
ptr := &x
*ptr = 20
println(x) // 20