Exercícios em Go

Gopher Programming

Essa página contém exercícios práticos de programação em Go, feitos dentro ou fora do ambiente de sala de aula.

Tutorial - Como compilar e executar

Opção 1: Compilar e executar diretamente

go run file.go

Opção 2: Criar executável e depois executar

# Compilar e criar executável
go build file.go

# Executar o arquivo gerado
./file.exe

Exercícios

Encontrados no GitHub

  1. Soma de dois números inteiros
  2. Divisão de dois números inteiros
  3. Antecessor e sucessor de um número
  4. Verificar se um número é par, positivo ou negativo
  5. Verificar se um número é primo
  6. Ordenação de sequência numérica
  7. Ordenação de caracteres em ordem ascendente
  8. Árvore de decisão binária
  9. Valor e endereço de uma variável
  10. Torre de Hanói com 3 discos
  11. Dia da semana da data de nascimento
  12. Igualdade entre dois números
  13. Moda de uma sequência numérica
  14. Verificar palíndromo
  15. Área de um retângulo
  16. Conversão entre unidades de temperatura
  17. Jogo da adivinhação
  18. Gerar arquivo JPG a partir de matrizes RGB
  19. Contar vogais e consoantes
  20. Encontrar ocorrências de palavras
  21. Fatorial de um número
  22. Hello World
  23. Cálculo de IMC
  24. Cálculo de MMC
  25. Média de números
  26. Leitura de arquivo PPM

Resolução:

Exercício 1 - Soma de dois números inteiros

package main

import "fmt"

func soma(a, b int) int {
	return a + b
}

func main() {
	var num1, num2 int

	fmt.Print("Digite o primeiro número: ")
	fmt.Scan(&num1)

	fmt.Print("Digite o segundo número: ")
	fmt.Scan(&num2)

	resultado := soma(num1, num2)

	fmt.Printf("%d + %d = %d\n", num1, num2, resultado)
}

Exemplo de saída:

Digite o primeiro número: 5
Digite o segundo número: 3
5 + 3 = 8

Exercício 2 - Divisão de dois números inteiros

package main

import "fmt"

func divisao(a, b int) int {
	return a / b
}

func main() {
	var num1, num2 int

	fmt.Print("Digite o primeiro número: ")
	fmt.Scan(&num1)

	fmt.Print("Digite o segundo número: ")
	fmt.Scan(&num2)

	resultado := divisao(num1, num2)

	fmt.Printf("%d / %d = %d\n", num1, num2, resultado)
}

Exemplo de saída:

Digite o primeiro número: 10
Digite o segundo número: 2
10 / 2 = 5

Exercício 3 - Antecessor e sucessor de um número

package main

import "fmt"

func antecessor(a int) int {
	return a - 1
}

func sucessor(a int) int {
	return a + 1
}

func main() {
	var num int

	fmt.Print("Digite um número: ")
	fmt.Scan(&num)
	fmt.Printf("O antecessor de %d é %d\n", num, antecessor(num))
	fmt.Printf("O sucessor de %d é %d\n", num, sucessor(num))
}

Exemplo de saída:

Digite um número: 7
O antecessor de 7 é 6
O sucessor de 7 é 8

Exercício 4 - Verificar se um número é par, positivo ou negativo

package main

import "fmt"

func ehPar(num int) bool {
	return num%2 == 0
}

func classificarNumero(num int) string {
	if num > 0 {
		return "positivo"
	} else if num < 0 {
		return "negativo"
	} else {
		return "zero"
	}
}

func main() {
	var numero int

	fmt.Print("Digite um número: ")
	fmt.Scan(&numero)

	if ehPar(numero) {
		fmt.Printf("O número %d é PAR\n", numero)
	} else {
		fmt.Printf("O número %d é ÍMPAR\n", numero)
	}

	classificacao := classificarNumero(numero)
	fmt.Printf("O número %d é %s\n", numero, classificacao)
}

Exemplo de saída:

Digite um número: -4
O número -4 é PAR
O número -4 é negativo

Exercício 5 - Verificar se um número é primo

package main

import "fmt"

func ehPrimo(num int) bool {
	if num <= 1 {
		return false
	}
	if num == 2 {
		return true
	}
	if num%2 == 0 {
		return false
	}
	for i := 3; i*i <= num; i += 2 {
		if num%i == 0 {
			return false
		}
	}
	return true
}

func main() {
	var numero int

	fmt.Print("Digite um número: ")
	fmt.Scan(&numero)

	if ehPrimo(numero) {
		fmt.Printf("%d é primo\n", numero)
	} else {
		fmt.Printf("%d não é primo\n", numero)
	}
}

Exemplo de saída:

Digite um número: 17
17 é primo

Exercício 22 - Hello World

package main

import "fmt"

func main() {
	fmt.Println("Hello, World!")
}

Saída:

Hello, World!

Exercício 6 - Ordenação de sequência numérica

package main

import (
	"fmt"
	"sort"
)

func main() {
	var x int
	nums := make([]int, 0)

	fmt.Println("Digite números inteiros para ordenar. Digite 0 para terminar (0 não será incluído).")
	for i := 1; ; i++ {
		fmt.Printf("Digite o %dº número: ", i)
		if _, err := fmt.Scan(&x); err != nil {
			fmt.Println("Entrada inválida. Encerrando.")
			return
		}
		if x == 0 {
			break
		}
		nums = append(nums, x)
	}

	if len(nums) == 0 {
		fmt.Println("Nenhum número para ordenar.")
		return
	}

	sort.Ints(nums)

	fmt.Println("Sequência ordenada:")
	for _, v := range nums {
		fmt.Printf("%d ", v)
	}
	fmt.Println()
}

Exemplo de saída:

Digite números inteiros para ordenar. Digite 0 para terminar (0 não será incluído).
Digite o 1º número: 5
Digite o 2º número: 2
Digite o 3º número: 8
Digite o 4º número: 1
Digite o 5º número: 0
Sequência ordenada:
1 2 5 8

Exercício 7 - Ordenação de caracteres em ordem ascendente

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strings"
)

func main() {
	fmt.Println("Digite uma linha de caracteres:")

	reader := bufio.NewReader(os.Stdin)
	input, err := reader.ReadString('\n')
	if err != nil && len(input) == 0 {
		return
	}

	input = strings.TrimRight(input, "\r\n")

	runes := []rune(input)

	sort.Slice(runes, func(i, j int) bool { return runes[i] < runes[j] })

	parts := make([]string, len(runes))
	for i, r := range runes {
		parts[i] = string(r)
	}

	fmt.Println("Caracteres ordenados:", strings.Join(parts, " "))
}

Exemplo de saída:

Digite uma linha de caracteres:
golang
Caracteres ordenados:   a g l n o

Exercício 8 - Árvore de decisão binária

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

// Node representa um nó da árvore de decisão
type Node struct {
	Question string
	Yes      *Node
	No       *Node
	Result   string
}

// Decide interativamente perguntando ao usuário
func (n *Node) DecideInteractive(reader *bufio.Reader) string {
	// Se for folha, retorna resultado
	if n.Result != "" {
		return n.Result
	}

	// Faz a pergunta
	fmt.Printf("%s (sim/nao): ", n.Question)
	resposta, _ := reader.ReadString('\n')
	resposta = strings.TrimSpace(strings.ToLower(resposta))

	// Trata resposta
	if resposta == "sim" || resposta == "s" || resposta == "y" || resposta == "yes" {
		return n.Yes.DecideInteractive(reader)
	} else if resposta == "nao" || resposta == "n" || resposta == "no" {
		return n.No.DecideInteractive(reader)
	} else {
		fmt.Println("❗ Resposta inválida, digite 'sim' ou 'nao'.")
		return n.DecideInteractive(reader) // repete a pergunta
	}
}

func main() {
	reader := bufio.NewReader(os.Stdin)

	// Folhas
	stayHome := &Node{Result: "Ficar em casa"}
	goOut := &Node{Result: "Sair"}

	// Nó intermediário
	isHot := &Node{
		Question: "Está quente?",
		Yes:      stayHome,
		No:       goOut,
	}

	// Raiz
	isRaining := &Node{
		Question: "Está chovendo?",
		Yes:      stayHome,
		No:       isHot,
	}

	fmt.Println("Sistema de decisão:")
	decisao := isRaining.DecideInteractive(reader)
	fmt.Println("\nDecisão final:", decisao)
}

Exemplo de saída:

Sistema de decisão:
Está chovendo? (sim/nao): nao
Está quente? (sim/nao): sim

Decisão final: Ficar em casa

Exercício 9 - Valor e endereço de uma variável

package main

import "fmt"

func main() {
	var x int
	fmt.Print("Digite um número inteiro: ")
	if _, err := fmt.Scan(&x); err != nil {
		fmt.Println("Erro na leitura:", err)
		return
	}

	fmt.Println("Valor de x:", x)
	fmt.Printf("Endereço de x: %p\n", &x)
}

Exemplo de saída:

Digite um número inteiro: 42
Valor de x: 42
Endereço de x: 0xc00001c0a8

Exercício 10 - Torre de Hanói com 3 discos

package main

import (
	"fmt"
	"strings"
)

func hanoi(n int, origem, destino, auxiliar rune, pegs map[rune][]int) {
	if n <= 0 {
		return
	}
	if n == 1 {
		disk := pegs[origem][len(pegs[origem])-1]
		pegs[origem] = pegs[origem][:len(pegs[origem])-1]
		pegs[destino] = append(pegs[destino], disk)
		fmt.Printf("Mover disco %d de %c para %c\n", disk, origem, destino)
		return
	}
	hanoi(n-1, origem, auxiliar, destino, pegs)
	hanoi(1, origem, destino, auxiliar, pegs)
	hanoi(n-1, auxiliar, destino, origem, pegs)
}

func formatPeg(p []int) string {
	if len(p) == 0 {
		return "[]"
	}
	// queremos mostrar do maior para o menor (base -> topo)
	parts := make([]string, len(p))
	for i := len(p) - 1; i >= 0; i-- {
		parts[len(p)-1-i] = fmt.Sprintf("%d", p[i])
	}
	return "[" + strings.Join(parts, " ") + "]"
}

func main() {
	n := 3
	pegs := map[rune][]int{
		'A': make([]int, 0, n),
		'B': make([]int, 0, n),
		'C': make([]int, 0, n),
	}
	for d := n; d >= 1; d-- {
		pegs['A'] = append(pegs['A'], d)
	}

	fmt.Printf("Ordem inicial: A:%s B:%s C:%s\n", formatPeg(pegs['A']), formatPeg(pegs['B']), formatPeg(pegs['C']))

	hanoi(n, 'A', 'C', 'B', pegs)
}

Saída:

Ordem inicial: A:[1 2 3] B:[] C:[]
Mover disco 1 de A para C
Mover disco 2 de A para B
Mover disco 1 de C para B
Mover disco 3 de A para C
Mover disco 1 de B para A
Mover disco 2 de B para C
Mover disco 1 de A para C

Exercício 11 - Dia da semana da data de nascimento

package main

import (
	"fmt"
	"time"
)

func diaSemana(data string) (string, error) {
	layouts := []string{"02/01/2006", "2006-01-02", "2/1/2006", time.RFC3339}
	var t time.Time
	var err error
	for _, l := range layouts {
		t, err = time.Parse(l, data)
		if err == nil {
			return t.Weekday().String(), nil
		}
	}
	return "", fmt.Errorf("formato de data inválido")
}

func main() {
	var s string
	fmt.Print("Digite a data de nascimento (DD/MM/AAAA): ")
	fmt.Scan(&s)
	dia, err := diaSemana(s)
	if err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(dia)
}

Exemplo de saída:

Digite a data de nascimento (DD/MM/AAAA): 15/08/1990
Wednesday

Exercício 12 - Igualdade entre dois números

package main

import "fmt"

func igual(a, b int) bool { return a == b }

func main() {
	var a, b int
	fmt.Print("Digite dois números: ")
	fmt.Scan(&a, &b)
	fmt.Println(igual(a, b))
}

Exemplo de saída:

Digite dois números: 5 5
true

Exercício 13 - Moda de uma sequência numérica

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func moda(nums []int) int {
	freq := make(map[int]int)
	best, bestCount := nums[0], 0
	for _, n := range nums {
		freq[n]++
		if freq[n] > bestCount {
			best = n
			bestCount = freq[n]
		}
	}
	return best
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Digite números separados por espaço: ")
	line, _ := reader.ReadString('\n')
	parts := strings.Fields(line)
	nums := make([]int, 0, len(parts))
	for _, p := range parts {
		if v, err := strconv.Atoi(p); err == nil {
			nums = append(nums, v)
		}
	}
	if len(nums) == 0 {
		fmt.Println(0)
		return
	}
	fmt.Println(moda(nums))
}

Exemplo de saída:

Digite números separados por espaço: 1 2 3 2 4 2 5
2

Exercício 14 - Verificar palíndromo

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"unicode"
)

func palindromo(s string) bool {
	rs := make([]rune, 0, len(s))
	for _, r := range strings.ToLower(s) {
		if unicode.IsLetter(r) || unicode.IsNumber(r) {
			rs = append(rs, r)
		}
	}
	i, j := 0, len(rs)-1
	for i < j {
		if rs[i] != rs[j] {
			return false
		}
		i++
		j--
	}
	return true
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Digite uma sequência: ")
	s, _ := reader.ReadString('\n')
	s = strings.TrimSpace(s)
	fmt.Println(palindromo(s))
}

Exemplo de saída:

Digite uma sequência: arara
true

Exercício 15 - Área de um retângulo

package main

import "fmt"

func area(base, altura float64) float64 { return base * altura }

func main() {
	var b, h float64
	fmt.Print("Base: ")
	fmt.Scan(&b)
	fmt.Print("Altura: ")
	fmt.Scan(&h)
	fmt.Println(area(b, h))
}

Exemplo de saída:

Base: 5
Altura: 3
15

Exercício 16 - Conversão entre unidades de temperatura

package main

import "fmt"

func cToF(c float64) float64 { return c*9/5 + 32 }
func fToC(f float64) float64 { return (f - 32) * 5 / 9 }

func main() {
	var t float64
	var u string
	fmt.Print("Digite valor e unidade (C/F): ")
	fmt.Scan(&t, &u)
	if u == "C" || u == "c" {
		fmt.Println(cToF(t))
		return
	}
	if u == "F" || u == "f" {
		fmt.Println(fToC(t))
		return
	}
	fmt.Println("Unidade inválida")
}

Exemplo de saída:

Digite valor e unidade (C/F): 25 C
77

Exercício 17 - Jogo da adivinhação

package main

import (
	"fmt"
	"math/rand"
	"time"
)

func main() {
	rand.Seed(time.Now().UnixNano())
	target := rand.Intn(100) + 1
	var guess int
	for {
		fmt.Print("Adivinhe (1-100): ")
		fmt.Scan(&guess)
		if guess < target {
			fmt.Println("Maior")
		} else if guess > target {
			fmt.Println("Menor")
		} else {
			fmt.Println("Acertou")
			break
		}
	}
}

Exemplo de saída:

Adivinhe (1-100): 50
Maior
Adivinhe (1-100): 75
Menor
Adivinhe (1-100): 62
Acertou

Exercício 18 - Gerar arquivo JPG a partir de matrizes RGB

package main

import (
	"encoding/binary"
	"fmt"
	"image"
	"image/color"
	"image/jpeg"
	"os"
)

func main() {
	var w, h int
	fmt.Print("Largura altura: ")
	fmt.Scan(&w, &h)
	total := w * h
	r := make([]uint8, total)
	g := make([]uint8, total)
	b := make([]uint8, total)
	fmt.Printf("Digite %d bytes para R, G e B (decimal, separados por espaço ou newline):\n", total)
	for i := 0; i < total; i++ {
		var v int
		fmt.Scan(&v)
		r[i] = uint8(v)
	}
	for i := 0; i < total; i++ {
		var v int
		fmt.Scan(&v)
		g[i] = uint8(v)
	}
	for i := 0; i < total; i++ {
		var v int
		fmt.Scan(&v)
		b[i] = uint8(v)
	}
	img := image.NewRGBA(image.Rect(0, 0, w, h))
	idx := 0
	for y := 0; y < h; y++ {
		for x := 0; x < w; x++ {
			img.Set(x, y, color.RGBA{r[idx], g[idx], b[idx], 255})
			idx++
		}
	}
	f, err := os.Create("out.jpg")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer f.Close()
	var opt jpeg.Options
	opt.Quality = 80
	_ = binary.Write(f, binary.LittleEndian, []byte{})
	jpeg.Encode(f, img, &opt)
	fmt.Println("out.jpg gerado")
}

Exemplo de saída:

Largura altura: 2 2
Digite 4 bytes para R, G e B (decimal, separados por espaço ou newline):
255 0 0 255
0 255 0 0
0 0 255 255
out.jpg gerado

Exercício 19 - Contar vogais e consoantes

package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
	"unicode"
)

func conta(s string) (int, int) {
	vogais := "aeiou"
	v, c := 0, 0
	for _, r := range strings.ToLower(s) {
		if !unicode.IsLetter(r) {
			continue
		}
		if strings.ContainsRune(vogais, r) {
			v++
		} else {
			c++
		}
	}
	return v, c
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Digite texto: ")
	s, _ := reader.ReadString('\n')
	v, c := conta(s)
	fmt.Println(v, "vogais e", c, "consoantes")
}

Exemplo de saída:

Digite texto: Programação em Go
7 vogais e 7 consoantes

Exercício 20 - Encontrar ocorrências de palavras

package main

import (
	"bufio"
	"fmt"
	"os"
	"regexp"
	"strings"
)

func ocorrencias(text, pattern string) int {
	re := regexp.MustCompile("(?i)" + regexp.QuoteMeta(pattern))
	return len(re.FindAllStringIndex(text, -1))
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Digite o texto: ")
	txt, _ := reader.ReadString('\n')
	fmt.Print("Digite a palavra/padrão: ")
	pat, _ := reader.ReadString('\n')
	txt = strings.TrimSpace(txt)
	pat = strings.TrimSpace(pat)
	fmt.Println(ocorrencias(txt, pat))
}

Exemplo de saída:

Digite o texto: Go é uma linguagem Go muito poderosa Go
Digite a palavra/padrão: Go
3

Exercício 21 - Fatorial de um número

package main

import "fmt"

func fatorial(n int) int {
	if n <= 1 {
		return 1
	}
	r := 1
	for i := 2; i <= n; i++ {
		r *= i
	}
	return r
}

func main() {
	var n int
	fmt.Print("Digite n: ")
	fmt.Scan(&n)
	fmt.Println(fatorial(n))
}

Exemplo de saída:

Digite n: 5
120

Exercício 23 - Cálculo de IMC

package main

import "fmt"

func imc(peso, altura float64) float64 { return peso / (altura * altura) }

func classificaIMC(imc float64) string {
	switch {
	case imc < 18.5:
		return "Abaixo do peso"
	case imc < 25.0:
		return "Peso normal"
	case imc < 30.0:
		return "Sobrepeso"
	case imc < 35.0:
		return "Obesidade grau I"
	case imc < 40.0:
		return "Obesidade grau II"
	default:
		return "Obesidade grau III"
	}
}

func main() {
	var peso, altura float64
	fmt.Print("Peso (kg): ")
	fmt.Scan(&peso)
	fmt.Print("Altura (m): ")
	fmt.Scan(&altura)
	if peso <= 0 || altura <= 0 {
		fmt.Println("Peso e altura devem ser maiores que zero")
		return
	}
	// se altura provavelmente foi informada em centímetros (ex: 181), converte para metros
	if altura > 10 {
		altura = altura / 100.0
	}
	val := imc(peso, altura)
	fmt.Printf("IMC: %.2f - %s\n", val, classificaIMC(val))
}

Exemplo de saída:

Peso (kg): 70
Altura (m): 1.75
IMC: 22.86 - Peso normal

Exercício 24 - Cálculo de MMC

package main

import "fmt"

func gcd(a, b int) int {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}

func lcm(a, b int) int { return a / gcd(a, b) * b }

func main() {
	var a, b int
	fmt.Print("Digite dois números: ")
	fmt.Scan(&a, &b)
	fmt.Println(lcm(a, b))
}

Exemplo de saída:

Digite dois números: 12 18
36

Exercício 25 - Média de números

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func media(nums []float64) float64 {
	s := 0.0
	for _, v := range nums {
		s += v
	}
	return s / float64(len(nums))
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	fmt.Print("Digite números separados por espaço: ")
	line, _ := reader.ReadString('\n')
	parts := strings.Fields(line)
	nums := make([]float64, 0, len(parts))
	for _, p := range parts {
		if v, err := strconv.ParseFloat(p, 64); err == nil {
			nums = append(nums, v)
		}
	}
	if len(nums) == 0 {
		fmt.Println(0)
		return
	}
	fmt.Println(media(nums))
}

Exemplo de saída:

Digite números separados por espaço: 7 8 9 10
8.5

Leitura de arquivo PPM

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	img, _ := os.Open("image.ppm")

	reader := bufio.NewReader(img)

	var formato string
	var linhas, colunas, maxVal int

	fmt.Fscan(reader, &formato)
	fmt.Fscan(reader, &linhas, &colunas)
	fmt.Fscan(reader, &maxVal)

	fmt.Printf("Formato: %s\n", formato)
	fmt.Printf("Dimensões: %dx%d\n", linhas, colunas)
	fmt.Printf("Valor máximo: %d\n", maxVal)
	fmt.Printf("Pixels:\n")

	var r, g, b int

	for i := 0; i < linhas; i++ {
		for j := 0; j < colunas; j++ {
			fmt.Fscan(reader, &r, &g, &b)
			_ = r
			_ = g
			_ = b
			fmt.Printf("%d %d %d\n", r, g, b)
		}
	}
}

Exemplo de saída (com um arquivo image.ppm de exemplo):

Formato: P3
Dimensões: 2x2
Valor máximo: 255
Pixels:
255 0 0
0 255 0
0 0 255
255 255 255
up